rstreeview.cpp

c语言实现的遥感图像处理的一些基本操作

				else
					pLayer->Status = (pLayer->Status & ~RS_EDITABLE_FLAG) | RS_UNEDITABLE;
			}
		}
		break;
	}
}

//根据工作元指针初始化树视图
void CRSTreeView::InitializeTreeCtrl(CRSWorkUnit* pWorkUnit)
{
	HTREEITEM hRoot = m_pTreeCtrl->GetRootItem();

	CString LayerName;
	LAYERITEM* pLayer;
	POSITION pos = pWorkUnit->m_pLayerMap->GetStartPosition();
	while (pos)
	{
		pWorkUnit->m_pLayerMap->GetNextAssoc(pos, LayerName, pLayer);

		//新建层信息，并加入到树
		TREELAYER* pTreeLayer = new TREELAYER;
		pTreeLayer->Name = LayerName;
		pTreeLayer->Status = RS_VISIBLE | RS_EDITABLE;
		pTreeLayer->DataSource = GEOMETRY;

		TVINSERTSTRUCT tvis;
		tvis.hParent = hRoot;
		tvis.hInsertAfter = TVI_LAST ;
		tvis.item.pszText = (LPTSTR)((LPCTSTR)LayerName);
		tvis.item.iImage = IMAGE_LAYER_EDITABLE;
		tvis.item.iSelectedImage = IMAGE_LAYER_EDITABLE;
		tvis.item.stateMask = TVIS_STATEIMAGEMASK;
		tvis.item.state = INDEXTOSTATEIMAGEMASK( IMAGE_LAYER_VISIBLE);
		tvis.item.mask = TVIF_IMAGE | TVIF_TEXT | TVIF_SELECTEDIMAGE | TVIF_STATE;
		HTREEITEM hLayer = m_pTreeCtrl->InsertItem(&tvis);
		//轮循层的编码类信息，并加入层节点下
		for (int i = 0 ; i < pLayer->pFeatureArray->GetSize() ; i ++)
		{
			TREEFEATURE* pTreeFeature = new TREEFEATURE;
			pTreeFeature->UserID = pLayer->pFeatureArray->GetAt(i)->UserID;
			pTreeFeature->Status = RS_VISIBLE | RS_EDITABLE;
			pTreeLayer->DataSource = GEOMETRY;
			pTreeLayer->Features.Add(pTreeFeature);

			TVINSERTSTRUCT tvis;
			tvis.hParent = hLayer;
			tvis.hInsertAfter = TVI_LAST ;
			tvis.item.pszText = (LPTSTR)((LPCTSTR)pLayer->pFeatureArray->GetAt(i)->UserID);
			tvis.item.iImage = IMAGE_FEATURE_EDITABLE;
			tvis.item.iSelectedImage = IMAGE_FEATURE_EDITABLE;
			tvis.item.stateMask = TVIS_STATEIMAGEMASK;
			tvis.item.state = INDEXTOSTATEIMAGEMASK( IMAGE_FEATURE_VISIBLE);
			tvis.item.mask = TVIF_IMAGE | TVIF_TEXT | TVIF_SELECTEDIMAGE | TVIF_STATE;
			m_pTreeCtrl->InsertItem(&tvis);
		}
		m_Layers.Add(pTreeLayer);
	}
	m_pTreeCtrl->Expand(hRoot, TVE_EXPAND);
}

//根据工作元状态文件初始化树视图
//Path－－工作元状态文件所在路径
//WUName－－工作元名
BOOL CRSTreeView::InitializeTreeCtrl(CString Path, CString WUName)
{
	if (Path.IsEmpty() || WUName.IsEmpty())
		return FALSE;

	::ValidateDir(Path);

	fstream ios;

	ios.open(Path + WUName + ".GWS", ios::in | ios::binary, filebuf::sh_none);
	
	if (ios.bad())
		return FALSE;

	char flag[16];
	ios.read(flag, 16);
	if (lstrcmp(flag, "RSSTAR_WUSTATUS"))
	{
		ios.close();
		return FALSE;
	}

	float version ;
	ios.read((char*)&version, sizeof(float));

	ios.seekg(64, ios::cur);

	DWORD res;
	ios.read((char*)&res, sizeof(DWORD));

	DWORD LayerCount;
	ios.read((char*)&LayerCount, sizeof(DWORD));

	HTREEITEM hRoot = m_pTreeCtrl->GetRootItem();

	char LayerName[24];
	BYTE LayerStatus;
	DATASOURCE DataSource;
	DWORD FeatureCount;
	char OrientFile[256];
	//轮循所有层，加入到树
	for (DWORD i = 0 ; i < LayerCount ; i ++)
	{
		ios.read(LayerName, 24);
		ios.read((char*)&LayerStatus, sizeof(BYTE));
		ios.read((char*)&DataSource, sizeof(enum));

		ios.read(OrientFile, 256);
		if (DataSource == IMAGE)
		{
//			CString dir = m_pWorkUnit->GetWUImageDir();
//			GetDocument()->LoadImageFromOrientFile(dir + OrientFile + ".ori");
		}
		ios.read((char*)&FeatureCount, sizeof(DWORD));

		TREELAYER* pTreeLayer = new TREELAYER;
		pTreeLayer->Name = LayerName;
		pTreeLayer->Status = LayerStatus;
		pTreeLayer->DataSource = DataSource;
		pTreeLayer->ImageOrientFile = OrientFile;

		TVINSERTSTRUCT tvis;
		tvis.hParent = hRoot;
		tvis.hInsertAfter = TVI_LAST ;
		tvis.item.pszText = (LPTSTR)((LPCTSTR)LayerName);
		tvis.item.iImage = IMAGE_LAYER_EDITABLE;
		tvis.item.iSelectedImage = IMAGE_LAYER_EDITABLE;
		tvis.item.stateMask = TVIS_STATEIMAGEMASK;
		tvis.item.state = INDEXTOSTATEIMAGEMASK( IMAGE_LAYER_VISIBLE);
		tvis.item.mask = TVIF_IMAGE | TVIF_TEXT | TVIF_SELECTEDIMAGE | TVIF_STATE;
		HTREEITEM hLayer = m_pTreeCtrl->InsertItem(&tvis);

		//如果是几何节点，则需轮循其编码类信息
		if (DataSource == GEOMETRY)
		{
			char UserID[24];
			BYTE FeatureStatus;
			for (DWORD i = 0 ; i < FeatureCount ; i ++)
			{
				ios.read(UserID, 24);
				ios.read((char*)&FeatureStatus, sizeof(BYTE));

				TREEFEATURE* pTreeFeature = new TREEFEATURE;
				pTreeFeature->UserID = UserID;
				pTreeFeature->Status = FeatureStatus;
				pTreeLayer->Features.Add(pTreeFeature);

				TVINSERTSTRUCT tvis;
				tvis.hParent = hLayer;
				tvis.hInsertAfter = TVI_LAST ;
				tvis.item.pszText = (LPTSTR)((LPCTSTR)UserID);
				tvis.item.iImage = IMAGE_FEATURE_EDITABLE;
				tvis.item.iSelectedImage = IMAGE_FEATURE_EDITABLE;
				tvis.item.stateMask = TVIS_STATEIMAGEMASK;
				tvis.item.state = INDEXTOSTATEIMAGEMASK( IMAGE_FEATURE_VISIBLE);
				tvis.item.mask = TVIF_IMAGE | TVIF_TEXT | TVIF_SELECTEDIMAGE | TVIF_STATE;
				m_pTreeCtrl->InsertItem(&tvis);
			}
		}
		m_Layers.Add(pTreeLayer);

	}
	m_pTreeCtrl->Expand(hRoot, TVE_EXPAND);

	ios.close();

	return TRUE;
}

//保存工作元状态文件
BOOL CRSTreeView::SaveWULayerStatus()
{
	CString Path, File;

	Path = m_pWorkUnit->m_pWUInfo->Directory;
	if (Path.IsEmpty())
		return FALSE;
	::ValidateDir(Path);
	
	File = m_pWorkUnit->m_pWUInfo->WorkUnitName;
	if (File.IsEmpty())
		return FALSE;

	fstream ios;
	ios.open(Path + File + ".GWS", ios::out | ios::binary, filebuf::sh_none);
	
	if (ios.bad())
		return FALSE;

	char flag[16] = _T("RSSTAR_WUSTATUS");
	ios.write(flag, 16);

	float version = RSSTAR_VERSION_10;
	ios.write((LPCTSTR)&version, sizeof(float));

	ios.seekp(64, ios::cur);

	DWORD res = 100;
	ios.write((LPCTSTR)&res, sizeof(DWORD));

	DWORD LayerCount = m_Layers.GetSize();
	ios.write((LPCTSTR)&LayerCount, sizeof(DWORD));

	for (DWORD i = 0 ; i < LayerCount ; i ++)
	{
		ios.write(m_Layers.GetAt(i)->Name, 24);
		ios.write((LPCTSTR)&m_Layers.GetAt(i)->Status, sizeof(BYTE));
		ios.write((LPCTSTR)&m_Layers.GetAt(i)->DataSource, sizeof(enum));
		ios.write(m_Layers.GetAt(i)->ImageOrientFile, 256);

		DWORD FeatureCount = m_Layers.GetAt(i)->Features.GetSize() ;
		ios.write((LPCTSTR)&FeatureCount, sizeof(DWORD));

		for (DWORD j = 0 ; j < FeatureCount ; j ++)
		{
			ios.write(m_Layers.GetAt(i)->Features.GetAt(j)->UserID, 24);
			ios.write((LPCTSTR)&m_Layers.GetAt(i)->Features.GetAt(j)->Status, sizeof(BYTE));
		}
	}
	ios.close();

	return TRUE;
}

//清除保存的层及编码类信息
void CRSTreeView::ClearLayerTree()
{
	DWORD LayerCount = m_Layers.GetSize();

	for (DWORD i = 0 ; i < LayerCount ; i ++)
	{
		DWORD FeatureCount = m_Layers.GetAt(i)->Features.GetSize() ;
		for (DWORD j = 0 ; j < FeatureCount ; j ++)
			delete m_Layers.GetAt(i)->Features.GetAt(j);

		delete m_Layers.GetAt(i);
	}
}

void CRSTreeView::PreSubclassWindow() 
{
//	ModifyStyle(0, TVS_ENABLEDRAGDROP);

	CTreeView::PreSubclassWindow();
}

void CRSTreeView::OnBegindrag(NMHDR* pNMHDR, LRESULT* pResult) 
{
	NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
	// TODO: Add your control notification handler code here
	*pResult = 0;

	m_hitemDrag = pNMTreeView->itemNew.hItem;
	m_hitemDrop = NULL;

	//如果拖动的不是层节点，则返回
	CString name;
	if (!IsLayerNode(m_hitemDrag, name))
		return;

	m_pDragImage = m_pTreeCtrl->CreateDragImage(m_hitemDrag);  // get the image list for dragging
	// CreateDragImage() returns NULL if no image list
	// associated with the tree view control
	if( !m_pDragImage )
		return;

	m_bLDragging = TRUE;
	m_pDragImage->BeginDrag(0, CPoint(-15,-15));
	POINT pt = pNMTreeView->ptDrag;
	ClientToScreen( &pt );
	m_pDragImage->DragEnter(NULL, pt);
	SetCapture();
}

void CRSTreeView::OnMouseMove(UINT nFlags, CPoint point) 
{
	HTREEITEM	hitem;
	UINT		flags;

	if (m_bLDragging)
	{
		POINT pt = point;
		ClientToScreen( &pt );
		CImageList::DragMove(pt);
		if ((hitem = m_pTreeCtrl->HitTest(point, &flags)) != NULL)
		{
			CImageList::DragShowNolock(FALSE);
			m_pTreeCtrl->SelectDropTarget(hitem);
			m_hitemDrop = hitem;
			CImageList::DragShowNolock(TRUE);
		}
	}
	
	CTreeView::OnMouseMove(nFlags, point);
}

void CRSTreeView::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if (m_bLDragging)
	{
		m_bLDragging = FALSE;
		CImageList::DragLeave(this);
		CImageList::EndDrag();
		ReleaseCapture();

		delete m_pDragImage;

		// Remove drop target highlighting
		m_pTreeCtrl->SelectDropTarget(NULL);

		if( m_hitemDrag == m_hitemDrop )
			return;

		//如果拖动的释放位置不是层节点，则返回
		CString name;
		if (!IsLayerNode(m_hitemDrop, name))
			return;

		// If Drag item is an ancestor of Drop item then return
		HTREEITEM htiParent = m_hitemDrop;
		while( (htiParent = m_pTreeCtrl->GetParentItem( htiParent )) != NULL )
		{
			if( htiParent == m_hitemDrag ) return;
		}

		m_pTreeCtrl->Expand( m_hitemDrop, TVE_EXPAND ) ;


		//将源层拷贝成目的层下一个兄弟节点
		HTREEITEM htiNew = CopyBranch( m_hitemDrag, m_pTreeCtrl->GetRootItem(), m_hitemDrop);
//		HTREEITEM htiNew = CopyBranch( m_hitemDrag, m_hitemDrop, TVI_LAST );

		//同时修改层信息中相应的位置
		TREELAYER* pSrc, *pTag;
		int srcindex, tagindex;
		pSrc = GetLayerItem(m_hitemDrag);
		for (int i = 0 ; i < m_Layers.GetSize() ; i ++)
		{
			if (m_Layers[i]->Name == pSrc->Name)
			{
				srcindex = i;
				break;
			}
		}
		m_Layers.RemoveAt(srcindex);

		pTag = GetLayerItem(m_hitemDrop);
		for (i = 0 ; i < m_Layers.GetSize() ; i ++)
		{
			if (m_Layers[i]->Name == pTag->Name)
			{
				tagindex = i;
				break;
			}
		}
		m_Layers.InsertAt(tagindex + 1, pSrc);
		((CRSView*)m_pMainView)->Update();
		//emd for layers change

		m_pTreeCtrl->DeleteItem(m_hitemDrag);
		m_pTreeCtrl->SelectItem( htiNew );

	}
	
	CTreeView::OnLButtonUp(nFlags, point);
}

// CopyBranch           - Copies all items in a branch to a new location
// Returns              - The new branch node
// htiBranch            - The node that starts the branch
// htiNewParent - Handle of the parent for new branch
// htiAfter             - Item after which the new branch should be created
HTREEITEM CRSTreeView::CopyBranch( HTREEITEM htiBranch, HTREEITEM htiNewParent, 
                                                HTREEITEM htiAfter /*= TVI_LAST*/ )
{
    HTREEITEM hChild;

    HTREEITEM hNewItem = CopyItem( htiBranch, htiNewParent, htiAfter );
    hChild = m_pTreeCtrl->GetChildItem(htiBranch);
    while( hChild != NULL)
    {
            // recursively transfer all the items
            CopyBranch(hChild, hNewItem);  
            hChild = m_pTreeCtrl->GetNextSiblingItem( hChild );
    }
    return hNewItem;
}

// CopyItem             - Copies an item to a new location
// Returns              - Handle of the new item
// hItem                - Item to be copied
// htiNewParent         - Handle of the parent for new item
// htiAfter             - Item after which the new item should be created
HTREEITEM CRSTreeView::CopyItem( HTREEITEM hItem, HTREEITEM htiNewParent, 
                                        HTREEITEM htiAfter /*= TVI_LAST*/ )
{
    TV_INSERTSTRUCT					tvstruct;
    HTREEITEM                       hNewItem;
    CString                         sText;

    // get information of the source item
    tvstruct.item.hItem = hItem;
    tvstruct.item.mask = TVIF_CHILDREN | TVIF_HANDLE | 
                            TVIF_IMAGE | TVIF_SELECTEDIMAGE;
    m_pTreeCtrl->GetItem(&tvstruct.item);  
    sText = m_pTreeCtrl->GetItemText( hItem );
    
    tvstruct.item.cchTextMax = sText.GetLength();
    tvstruct.item.pszText = sText.LockBuffer();

    // Insert the item at proper location
    tvstruct.hParent = htiNewParent;
    tvstruct.hInsertAfter = htiAfter;
    tvstruct.item.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT;
    hNewItem = m_pTreeCtrl->InsertItem(&tvstruct);
    sText.ReleaseBuffer();

    // Now copy item data and item state.
    m_pTreeCtrl->SetItemData( hNewItem, m_pTreeCtrl->GetItemData( hItem ));
    m_pTreeCtrl->SetItemState( hNewItem, m_pTreeCtrl->GetItemState( hItem, TVIS_STATEIMAGEMASK ), 
                                                    TVIS_STATEIMAGEMASK );

    // Call virtual function to allow further processing in derived class
//    OnItemCopied( hItem, hNewItem );

    return hNewItem;
}