uictrl.cpp

vc座的资源管理器源代码

	return pEdit;
}

void CUIODListCtrl::DeleteProgressBar(int nRow,int nCol)
{
	CUIListCtrlData *pData = GetListCtrlData(nRow);
	if (pData)
	{
		pData->DestroyCtrl(nCol);
		RedrawItems(nRow,nRow);
	}
}

void CUIODListCtrl::UpdateProgressBar(int nRow,int nCol,int nPos)
{
	CUIListCtrlData *pData = GetListCtrlData(nRow);
	ASSERT(pData);
	if (pData == NULL)
		return;
	CTextProgressCtrl *pCtrl = (CTextProgressCtrl*)pData->GetCtrl(nCol);
	if (pCtrl)
	{
		pCtrl->SetPos(nPos);
		RedrawItems(nRow,nRow);
	}
}

CTextProgressCtrl *CUIODListCtrl::AddProgressBar(int nItem,int nCol,int nMin,int nMax)
{
	// The returned pointer should not be saved
	if (GetViewType() != LVS_REPORT)
		return NULL;
	CUIListCtrlData *pData = GetListCtrlData(nItem);
	if (pData == NULL)
		return NULL;
	CTextProgressCtrl *pCtrl = new CTextProgressCtrl;
	pData->SetCtrl(pCtrl,nCol);
	pCtrl->SetRange(nMin,nMax);
	return pCtrl;
}

//
// Message handlers
//
void CUIODListCtrl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	if (GetFocus() != this) 
		SetFocus();
	CListCtrl::OnHScroll(nSBCode, nPos, pScrollBar);
}

void CUIODListCtrl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	if (GetFocus() != this) 
		SetFocus();
	CListCtrl::OnVScroll(nSBCode, nPos, pScrollBar);
}

void CUIODListCtrl::OnLButtonDown(UINT nFlags, CPoint point)
{
	CListCtrl::OnLButtonDown(nFlags, point);
}

BOOL CUIODListCtrl::OnSelChanged(int nItem, LRESULT* pResult)
{
	*pResult = 0;
	return FALSE;
}

BOOL CUIODListCtrl::OnEndLabelEdit(NMHDR* pNMHDR, LRESULT* pResult)
{
	LV_DISPINFO *plvDispInfo = (LV_DISPINFO *)pNMHDR;
	LV_ITEM	*plvItem = &plvDispInfo->item;

	if (plvItem->pszText != NULL)
	{
		if (plvItem->iItem == -1)
		{
			CHeaderCtrl *pHeader = (CHeaderCtrl*)GetDlgItem(0);
			if (pHeader)
			{
				CString strText;
				GetHeaderText(pHeader,plvItem->iSubItem,strText);
				HD_ITEM hdItem;
				ZeroMemory(&hdItem,sizeof(hdItem));
				hdItem.mask = HDI_TEXT;
				hdItem.pszText = plvItem->pszText;
				hdItem.cchTextMax = lstrlen(plvItem->pszText);
				ReplaceString(m_strHeadings,strText,plvItem->pszText);
				if (EndLabelEdit(plvItem->iItem,plvItem->iSubItem,plvItem->pszText))
					pHeader->SetItem(plvItem->iSubItem,&hdItem);
			}
		}
		else
		{
			if (EndLabelEdit(plvItem->iItem,plvItem->iSubItem,plvItem->pszText))
				AddString(plvItem->iItem, plvItem->iSubItem, plvItem->pszText);
		}
	}
	*pResult = FALSE;
	return TRUE;
}

LRESULT CUIODListCtrl::OnDeleteItem(WPARAM wParam,LPARAM lParam)
{
	if (m_nItems)
		m_nItems--;
	TRACE(_T("Item deleted %d\n"),wParam);
	return Default();
}

LRESULT CUIODListCtrl::OnDeleteColumn(WPARAM wParam,LPARAM lParam)
{
	if (m_nSubItems)
		m_nSubItems--;
	TRACE(_T("Column deleted %d\n"),wParam);
	return Default();
}

LRESULT CUIODListCtrl::OnSetImageList(WPARAM wParam, LPARAM lParam)
{
	if((int)wParam==LVSIL_STATE)
	{
		int cx, cy;

		if(::ImageList_GetIconSize((HIMAGELIST)lParam,&cx,&cy))
			m_cxStateImageOffset=cx;
		else
			m_cxStateImageOffset=0;
	}

	return Default();
}

LRESULT CUIODListCtrl::OnSetTextColor(WPARAM wParam, LPARAM lParam)
{
	m_clrText=(COLORREF)lParam;
	return(Default());
}

LRESULT CUIODListCtrl::OnSetTextBkColor(WPARAM wParam, LPARAM lParam)
{
	m_clrTextBk=(COLORREF)lParam;
	return(Default());
}

LRESULT CUIODListCtrl::OnSetBkColor(WPARAM wParam, LPARAM lParam)
{
	m_clrBkgnd=(COLORREF)lParam;
	return(Default());
}

void CUIODListCtrl::OnSize(UINT nType, int cx, int cy) 
{
	m_cxClient=cx;
	CListCtrl::OnSize(nType, cx, cy);
}

void CUIODListCtrl::OnPaint() 
{
	if (m_bDelayPaint)
		return;
	Default();
    if (GetItemCount() <= 0)
    {
        COLORREF clrText = ::GetSysColor(COLOR_WINDOWTEXT);
        COLORREF clrTextBk = ::GetSysColor(COLOR_WINDOW);

        CDC* pDC = GetDC();
        // Save dc state
        int nSavedDC = pDC->SaveDC();

        CRect rc;
        GetWindowRect(&rc);
        ScreenToClient(&rc);

        CHeaderCtrl* pHC;
        pHC = GetHeaderCtrl();
        if (pHC != NULL)
        {
            CRect rcH;
            pHC->GetItemRect(0, &rcH);
            rc.top += rcH.bottom;
        }
        rc.top += 10;

        pDC->SetTextColor(clrText);
        pDC->SetBkColor(clrTextBk);
        pDC->FillRect(rc, &CBrush(clrTextBk));
        pDC->SelectStockObject(ANSI_VAR_FONT);
        pDC->DrawText(m_strNoItemsMess, -1, rc, 
                      DT_CENTER | DT_WORDBREAK | DT_NOPREFIX | DT_NOCLIP);

        // Restore dc
        pDC->RestoreDC(nSavedDC);
        ReleaseDC(pDC);
    }
    // Do not call CListCtrl::OnPaint() for painting messages
	// in full row select mode, we need to extend the clipping region
	// so we can paint a selection all the way to the right
	if(m_bClientWidthSel && (GetStyle() & LVS_TYPEMASK)==LVS_REPORT && GetFullRowSel() && (GetStyle() & LVS_OWNERDRAWFIXED))
	{
		CRect rcAllLabels;
		GetItemRect(0,rcAllLabels,LVIR_BOUNDS);

		if(rcAllLabels.right<m_cxClient)
		{
			// need to call BeginPaint (in CPaintDC c-tor)
			// to get correct clipping rect
			CPaintDC dc(this);

			CRect rcClip;
			dc.GetClipBox(rcClip);

			rcClip.left=min(rcAllLabels.right-1,rcClip.left);
//			rcClip.right=m_cxClient;

			InvalidateRect(rcClip,FALSE);
			// EndPaint will be called in CPaintDC d-tor
		}
	}

//	CListCtrl::OnPaint();
}

void CUIODListCtrl::OnSetFocus(CWnd* pOldWnd) 
{
	CListCtrl::OnSetFocus(pOldWnd);

	if(pOldWnd!=NULL && ::IsWindow(pOldWnd->m_hWnd))
	{
		// check if we are getting focus from label edit box
		if(pOldWnd!=NULL && pOldWnd->GetParent()==this)
			return;
	}
}

void CUIODListCtrl::OnKillFocus(CWnd* pNewWnd) 
{
	CListCtrl::OnKillFocus(pNewWnd);

	// check if we are losing focus to label edit box
	if (pNewWnd!=NULL && pNewWnd->GetParent()==this)
		return;
}

void CUIODListCtrl::OnRClickHeader(CPoint point,int nColIndex)
{
	m_nColClicked = nColIndex;
	CMenu menu;
	VERIFY(menu.LoadMenu(IDR_POPUPMENU_HEADERCTRL));
	CMenu* pPopup = menu.GetSubMenu(0);
	ASSERT(pPopup != NULL);		
	pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y,this);
}

void CUIODListCtrl::OnHeaderRemoveColumn()
{
	if (m_nColClicked != -1)
	{
		int nWidth = GetColumnWidth(m_nColClicked);
		if (nWidth)
		{
			m_pColWidths[m_nColClicked] = nWidth;
			SetColumnWidth(m_nColClicked,0);
		}
		m_nColClicked = -1;
	}
}

void CUIODListCtrl::OnHeaderEditText()
{
	CHeaderCtrl *pHeader = (CHeaderCtrl*)GetDlgItem(0);
	if (pHeader == NULL)
		return;

	CString strText;
	int cxy = GetHeaderText(pHeader,m_nColClicked,strText);
	int xPos = 0;
	for(int i=0;i < m_nSubItems;i++)
	{
		if (i == m_nColClicked)
			break;
		xPos += m_pColWidths[i];
	}
	CRect rect;
	rect.left = xPos;
	rect.right = rect.left+cxy;
	rect.top = 0;
	rect.bottom = GetSystemMetrics(SM_CXHSCROLL);
	TRACE2("Creating header edit control at left=%d,right=%d\n",rect.left,rect.right);
	DWORD dwStyle = WS_BORDER|WS_CHILD|WS_VISIBLE|ES_AUTOHSCROLL;
	CEdit *pEdit = new CInPlaceEdit(-1, m_nColClicked, strText);
	pEdit->Create( dwStyle, rect, this, -1/*IDC_IPEDIT*/ );
	m_nColClicked = -1;
}

int CUIODListCtrl::GetHeaderText(CHeaderCtrl *pHeader,int nPos,CString &strText)
{
	HD_ITEM hdItem;
	ZeroMemory(&hdItem,sizeof(hdItem));
	int nLen = 128;
	int nRes;
	do
	{
		nLen *= 2;
		hdItem.mask = HDI_TEXT | HDI_WIDTH;
		hdItem.cchTextMax = nLen;
		hdItem.pszText = strText.GetBufferSetLength(nLen);
		pHeader->GetItem(nPos,&hdItem);
		nRes = lstrlen(hdItem.pszText);
	} while (nRes == nLen-1);
	strText.ReleaseBuffer(-1);
	return hdItem.cxy;
}

void CUIODListCtrl::OnHeaderReset()
{
	for(int i=0;i < m_nSubItems;i++)
	{
		SetColumnWidth(i,m_pColWidths[i]);
	}
	m_nColClicked = -1;
}

void CUIODListCtrl::OnContextMenu(CWnd *pWnd,CPoint point)	
{
	CPoint ptClient(point);
	ScreenToClient(&ptClient);	
	int nCol;
	int nRow = HitTestEx(ptClient,&nCol);
	if (nRow == -2)
		return;
	ShowPopupMenu(nRow,nCol,point);
}

void CUIODListCtrl::ShowPopupMenu(int nRow,int nCol,CPoint point)
{
	CMenu menu;
	VERIFY(menu.LoadMenu(IDR_POPUPMENU_LISTCTRL));
	CMenu* pPopup = menu.GetSubMenu(0);
	ASSERT(pPopup != NULL);
	m_PopupPoint.x = 0;
	m_PopupPoint.y = 0;
	if (PopupMenuItem(nRow,nCol,pPopup,point))
		return;
	m_PopupPoint = point;
	pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y,this);
}

void CUIODListCtrl::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
{
	// is it for us?
	if (m_PopupPoint.x == 0 && m_PopupPoint.y == 0)
		return;
	if (pPopupMenu->GetMenuItemID(0) == ID_HEADER_REMOVE_COL)
	{
		if (m_nColClicked == -1)
		{
			pPopupMenu->EnableMenuItem(ID_HEADER_EDIT_TEXT,MF_BYCOMMAND | MF_GRAYED);
			pPopupMenu->EnableMenuItem(ID_HEADER_RESET,MF_BYCOMMAND | MF_GRAYED);
		}
		return;
	}
	// These commands are only available in report mode(detail mode)
	UINT nEnabled = (GetViewType() == LVS_REPORT) ? MF_ENABLED : MF_GRAYED; 
	pPopupMenu->EnableMenuItem(ID_UI_VIEW_FULL_ROW_SELECTION,MF_BYCOMMAND | nEnabled);
	pPopupMenu->EnableMenuItem(ID_UI_VIEW_GRIDLINES,MF_BYCOMMAND | nEnabled);
	pPopupMenu->EnableMenuItem(ID_UI_VIEW_COLUMN_SIZING,MF_BYCOMMAND | nEnabled);
	pPopupMenu->EnableMenuItem(ID_UI_VIEW_COLUMN_ORDERING,MF_BYCOMMAND | nEnabled);
	if (nEnabled == MF_ENABLED)
		pPopupMenu->EnableMenuItem(ID_UI_VIEW_EDIT_COLUMN,MF_BYCOMMAND | (m_bEditSubItems && (GetStyle() & LVS_EDITLABELS)) ? MF_ENABLED : MF_GRAYED);
	else
		pPopupMenu->EnableMenuItem(ID_UI_VIEW_EDIT_COLUMN,MF_BYCOMMAND | MF_GRAYED);
	// won't work with owner draw list control
	if (GetStyle() & LVS_OWNERDRAWFIXED)
	{
		pPopupMenu->EnableMenuItem(ID_UI_VIEW_CHECKBOXES,MF_BYCOMMAND | MF_GRAYED);
	}
	UINT nIDItem=ID_VIEW_DETAILS;
	switch(GetViewType())
	{
	case LVS_ICON:
			nIDItem = ID_UI_VIEW_LARGE_ICONS;
			break;
	case LVS_SMALLICON:
			nIDItem = ID_UI_VIEW_SMALL_ICONS;
			break;
	case LVS_LIST:
			nIDItem = ID_UI_VIEW_LIST;
			break;
	case LVS_REPORT:
			nIDItem = ID_UI_VIEW_DETAILS;
			break;
	}
	pPopupMenu->CheckMenuRadioItem(ID_UI_VIEW_LARGE_ICONS,ID_VIEW_LIST,nIDItem,MF_BYCOMMAND);
	DWORD dwExStyle = GetExStyle();
	if (m_bFullRowSel)
		pPopupMenu->CheckMenuItem(ID_UI_VIEW_FULL_ROW_SELECTION,MF_BYCOMMAND | MF_CHECKED);
	if (m_bColumnSizing)
		pPopupMenu->CheckMenuItem(ID_UI_VIEW_COLUMN_SIZING,MF_BYCOMMAND | MF_CHECKED);
	if ((dwExStyle & LVS_EX_HEADERDRAGDROP))
		pPopupMenu->CheckMenuItem(ID_UI_VIEW_COLUMN_ORDERING,MF_BYCOMMAND | MF_CHECKED);
	if ((dwExStyle & LVS_EX_GRIDLINES))
		pPopupMenu->CheckMenuItem(ID_UI_VIEW_GRIDLINES,MF_BYCOMMAND | MF_CHECKED);
	if ((dwExStyle & LVS_EX_CHECKBOXES))
		pPopupMenu->CheckMenuItem(ID_UI_VIEW_CHECKBOXES,MF_BYCOMMAND | MF_CHECKED);
	if ((dwExStyle & LVS_EX_TRACKSELECT))
		pPopupMenu->CheckMenuItem(ID_UI_VIEW_TRACK_SELECT,MF_BYCOMMAND | MF_CHECKED);
}

void CUIODListCtrl::OnViewLargeIcons()
{
	SetViewType(LVS_ICON);
}

void CUIODListCtrl::OnViewSmallIcons()
{
	SetViewType(LVS_SMALLICON);
}

void CUIODListCtrl::OnViewDetails()
{
	SetViewType(LVS_REPORT);
}

void CUIODListCtrl::OnViewList()
{
	SetViewType(LVS_LIST);
}

void CUIODListCtrl::OnViewFullRowSelection()
{
	ToggleFullRowSel();
}

void CUIODListCtrl::OnViewTrackSelect()
{
	ToggleTrackSelect();
}

void CUIODListCtrl::OnViewGridlines()
{
	ToggleGridLines();
}

void CUIODListCtrl::OnViewCheckboxes()
{
	ToggleCheckBoxes();
}

void CUIODListCtrl::OnViewColumnOrdering()
{
	ToggleHeaderDragDrop();
}

void CUIODListCtrl::OnViewColumnSizing()
{
	ToggleColumnSizing();
}

void CUIODListCtrl::OnViewEditColumn()
{
	int index;
	int colnum;
	CPoint point(m_PopupPoint);
	ScreenToClient(&point);
	if (( index = HitTestEx( point, &colnum )) != -1)
	{
		UINT flag = LVIS_FOCUSED;
		if( (GetItemState( index, flag ) & flag) == flag && colnum > 0)
		{
			// Add check for LVS_EDITLABELS
			EditSubLabel( index, colnum );
		}
	}
}

LRESULT CUIODListCtrl::OnGetItemText(WPARAM wParam, LPARAM lParam)
{
	int iItem = (int)wParam; 
	LV_ITEM *pitem = (LV_ITEM*)lParam;
	int nSubItem = pitem->iSubItem;
	int nLen = pitem->cchTextMax;
	const CUIStrListCtrlData *pData = (CUIStrListCtrlData *)GetListCtrlData(iItem);
//	ASSERT_KINDOF(CUIStrListCtrlData,pData);
	if (!pData->IsKindOf(RUNTIME_CLASS(CUIStrListCtrlData)))
	{
		NMLVDISPINFO di;
		di.hdr.hwndFrom = GetSafeHwnd();
		di.hdr.code = LVN_GETDISPINFO;
		memcpy(&di.item,pitem,sizeof(LVITEM));
		di.item.mask = LVIF_TEXT;
		SendMessage(WM_NOTIFY,0,(LPARAM)&di);
		_tcsncpy(pitem->pszText,di.item.pszText,nLen);