void CEditPropExternals::OnHdnItemclickExternalslist(NMHDR *pNMHDR, LRESULT *pResult)
{
    LPNMHEADER phdr = reinterpret_cast<LPNMHEADER>(pNMHDR);

    if (m_nSortedColumn == phdr->iItem)
        m_bAscending = !m_bAscending;
    else
        m_bAscending = TRUE;
    m_nSortedColumn = phdr->iItem;

    std::sort(m_externals.begin(), m_externals.end(), &CEditPropExternals::SortCompare);

    m_ExtList.SetRedraw(FALSE);
    m_ExtList.DeleteAllItems();
    m_ExtList.SetItemCountEx((int)m_externals.size());

    CHeaderCtrl * pHeader = m_ExtList.GetHeaderCtrl();
    HDITEM HeaderItem = { 0 };
    HeaderItem.mask = HDI_FORMAT;
    const int itemCount = pHeader->GetItemCount();
    for (int i = 0; i<itemCount; ++i)
    {
        pHeader->GetItem(i, &HeaderItem);
        HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
        pHeader->SetItem(i, &HeaderItem);
    }
    pHeader->GetItem(m_nSortedColumn, &HeaderItem);
    HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);
    pHeader->SetItem(m_nSortedColumn, &HeaderItem);

    m_ExtList.SetRedraw(TRUE);

    *pResult = 0;
}
Example #2
0
void CSiriusView::OnDestroy() 
{
HDITEM hdi;

	// store columns width
	CHeaderCtrl *pHdr = GetListCtrl().GetHeaderCtrl();
	hdi.mask = HDI_WIDTH;
	pHdr->GetItem(0, &hdi);
	g_Settings.m_iListSrcAddr = hdi.cxy;
	pHdr->GetItem(2, &hdi);
	g_Settings.m_iListDestAddr = hdi.cxy;
	pHdr->GetItem(1, &hdi);
	g_Settings.m_iListSrcPort = hdi.cxy;
	pHdr->GetItem(3, &hdi);
	g_Settings.m_iListDestPort = hdi.cxy;
	pHdr->GetItem(4, &hdi);
	g_Settings.m_iListProto = hdi.cxy;
	pHdr->GetItem(5, &hdi);
	g_Settings.m_iListTraffic = hdi.cxy;
	pHdr->GetItem(6, &hdi);
	g_Settings.m_iListBS = hdi.cxy;
	pHdr->GetItem(7, &hdi);
	g_Settings.m_iListABS = hdi.cxy;

	if (g_bStarted) {
		OnCommandStop();
		g_bStarted = FALSE;
	}
	CListView::OnDestroy();
}
Example #3
0
void CLeftView::RestoreHeaderState(CString szHeader)
{
	CListCtrl& ctlList = (CListCtrl&) GetListCtrl();
	CHeaderCtrl* pHeaderCtrl = ctlList.GetHeaderCtrl();

	HDITEM hdi;
	int nNewPos, nPos = 0;
	int   nCount = pHeaderCtrl->GetItemCount();
	for(int i = 0; i < nCount; i++)
	{
		nNewPos = szHeader.Find(_T(","), nPos);
		if( nNewPos != 0)
		{
			CString szWidth = szHeader.Mid(nPos,nNewPos-nPos);
			int nWidth = _ttoi( szWidth );
			if( nWidth != 0 )
			{
				hdi.mask = HDI_WIDTH;
				pHeaderCtrl->GetItem(i, &hdi);
				hdi.cxy = nWidth;
				pHeaderCtrl->SetItem(i, &hdi);
				nPos = nNewPos + 1;
			}
		}
	}
}
Example #4
0
void LListCtrl::SetHeaderControlText( DWORD dwPos, const CUString& strValue )
{
    myLockListCtrl.Lock();
    if ( m_hWnd )
    {
        CHeaderCtrl* pHeaderCtrl = GetHeaderCtrl();

        ASSERT( (int)dwPos < pHeaderCtrl->GetItemCount() );

        HDITEM hdi;

        memset( &hdi, 0, sizeof( HDITEM ) );

        // Get header item data
        pHeaderCtrl->GetItem( dwPos, &hdi );

        // modify item data
        CUStringConvert strCnv;
        hdi.pszText = strCnv.ToT( strValue );
        hdi.mask = HDI_TEXT;

        // Set item data
        pHeaderCtrl->SetItem( dwPos, &hdi );

    }
    myLockListCtrl.Unlock();
}
void CListCtrlEx::OnLvnColumnclick(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
	// TODO: 在此添加控件通知处理程序代码
	*pResult = 0;
	BeginWaitCursor();
	SortItems(pNMLV->iSubItem);
	CHeaderCtrl* pHdrCtrl = GetHeaderCtrl(); 
	int n = pHdrCtrl->GetItemCount();

	HDITEM hdi;  
	for( int i = 0; i < n; i++ )  
	{  
		hdi.mask = HDI_FORMAT;  // 读取排序箭头图标状态,必需指定  
		pHdrCtrl->GetItem(i, &hdi);  
		//Set sort image to this column
		if(i == pNMLV->iSubItem)
		{
			//Windows xp has a easier way to show the sort order
			//in the header: i just have to set a flag and windows
			//will do the drawing. No windows xp, no easy way.
			hdi.fmt &= ~(HDF_SORTDOWN|HDF_SORTUP);
			hdi.fmt |= CompareObject::m_iLastSort[i] ? HDF_SORTUP : HDF_SORTDOWN;
		}
		//Remove sort image (if exists)
		//from other columns.
		else
		{
			hdi.fmt &= ~(HDF_SORTDOWN|HDF_SORTUP);
		}
		pHdrCtrl->SetItem( i, &hdi );  
	} 
	EndWaitCursor();
	Invalidate();
}
Example #6
0
// CFileOpenDlg::SetColumnIcons
//
//		Correctly sets the columns sort icons
//
void CFileOpenDlg::SetColumnIcons()
{
	CHeaderCtrl*	pHeader = m_listFile.GetHeaderCtrl();

	if(pHeader)
	{
		HDITEM	hdi;
		int		i,
				nItems	= pHeader->GetItemCount();

		for(i = 0; i < nItems; ++i)
		{
			hdi.mask = HDI_IMAGE | HDI_FORMAT;
			pHeader->GetItem(i, &hdi);

			if(i+1 == m_nSort)
			{
				hdi.iImage = 1;
				hdi.fmt |= HDF_IMAGE | HDF_BITMAP_ON_RIGHT;
			}
			else if(i+1 == -m_nSort)
			{
				hdi.iImage = 2;
				hdi.fmt |= HDF_IMAGE | HDF_BITMAP_ON_RIGHT;
			}
			else
			{
				hdi.iImage = 0;
				hdi.fmt &= ~(HDF_IMAGE | HDF_BITMAP_ON_RIGHT);
			}
			pHeader->SetItem(i, &hdi);
		}
	}
}
Example #7
0
LRESULT CVGMFileListView::OnColumnClick ( NMHDR* phdr )
{
CWaitCursor w;
int nCol = ((NMLISTVIEW*) phdr)->iSubItem;

    // If the user clicked the column that is already sorted, reverse the sort
    // direction. Otherwise, go back to ascending order.
    if ( nCol == m_nSortedCol )
        m_bSortAscending = !m_bSortAscending;
    else
        m_bSortAscending = true;

    if ( g_bXPOrLater )
        {
        HDITEM hdi = { HDI_FORMAT };
        CHeaderCtrl wndHdr = GetHeader();

        // Remove the sort arrow indicator from the previously-sorted column.
        if ( -1 != m_nSortedCol )
            {
            wndHdr.GetItem ( m_nSortedCol, &hdi );
            hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
            wndHdr.SetItem ( m_nSortedCol, &hdi );
            }

        // Add the sort arrow to the new sorted column.
        hdi.mask = HDI_FORMAT;
        wndHdr.GetItem ( nCol, &hdi );
        hdi.fmt |= m_bSortAscending ? HDF_SORTUP : HDF_SORTDOWN;
        wndHdr.SetItem ( nCol, &hdi );
        }

    // Store the column being sorted, and do the sort
    m_nSortedCol = nCol;

    SortItems ( SortCallback, (LPARAM)(DWORD_PTR) this );

    // Have the list ctrl indicate the sorted column by changing its color.
    if ( g_bXPOrLater )
        SetSelectedColumn ( nCol );

    return true;   // retval ignored
}
Example #8
0
LPARAM CLogViewDlg::GetHeaderParam(int nIndex)
{
    CHeaderCtrl* pHeader = m_LogList.GetHeaderCtrl();
    if(pHeader != NULL)
    {
        HDITEM hdItem = {0};
        hdItem.mask = HDI_LPARAM;
        pHeader->GetItem(nIndex, &hdItem);
        return hdItem.lParam;
    }
    return 0;
}
Example #9
0
void SetSortArrow(CListCtrl * control, int nColumn, bool bAscending)
{
	if (control == NULL)
		return;
	// set the sort arrow
	CHeaderCtrl * pHeader = control->GetHeaderCtrl();
	HDITEM HeaderItem = {0};
	HeaderItem.mask = HDI_FORMAT;
	for (int i=0; i<pHeader->GetItemCount(); ++i)
	{
		pHeader->GetItem(i, &HeaderItem);
		HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
		pHeader->SetItem(i, &HeaderItem);
	}
	if (nColumn >= 0)
	{
		pHeader->GetItem(nColumn, &HeaderItem);
		HeaderItem.fmt |= (bAscending ? HDF_SORTUP : HDF_SORTDOWN);
		pHeader->SetItem(nColumn, &HeaderItem);
	}
}
Example #10
0
void InsertMenu(CListCtrl& list,
                CMenu* pMenu,
                UINT nIndex,              // Menu id to remplace
                CImageList* pImageList) 
{	
   CHeaderCtrl *pHeader = list.GetHeaderCtrl();
   int nbCol = pHeader->GetItemCount();
   int nAfter = -1, id;
   char buffer[maxTitleLength];
   HDITEM hi;

   if (pImageList == NULL) pImageList = pHeader->GetImageList();

   hi.mask = HDI_FORMAT|HDI_IMAGE|HDI_LPARAM|HDI_TEXT;
   hi.pszText = buffer;
   hi.cchTextMax = maxTitleLength;

   while (--nbCol >= 0) {
      pHeader->GetItem(nbCol, &hi);
      if (hi.lParam == 0) continue;

      // there is a sort possible column
      id = nIndex + nbCol;
      if (nAfter < 0) {
         if (!pMenu->ModifyMenu(nIndex, MF_BYCOMMAND|MF_STRING, id, buffer))
            return;
      } else {
         pMenu->InsertMenu(nAfter, MF_BYCOMMAND|MF_STRING, id, buffer);
      }

      if (hi.iImage && pImageList) {
         static CBitmap bm, *pOldBm;
         IMAGEINFO ii;
         CDC dcMem;

         // fill a bitmap with the sort image
         pImageList->GetImageInfo(hi.iImage, &ii);
         int w = ii.rcImage.right - ii.rcImage.left;
         int h = ii.rcImage.bottom - ii.rcImage.top;
         dcMem.CreateCompatibleDC(NULL);
         if (bm.m_hObject) bm.DeleteObject();
         bm.CreateCompatibleBitmap(&dcMem, w, h);
         pOldBm = dcMem.SelectObject(&bm);
         dcMem.FillSolidRect(0, 0, w, h, 0xFFFFFF);
         pImageList->Draw(&dcMem, hi.iImage, CPoint(0,0), ILD_NORMAL);
         dcMem.SelectObject(pOldBm);

         // display the sort icon
         pMenu->SetMenuItemBitmaps(id, MF_BYCOMMAND, &bm, &bm);
      }
      nAfter = id;
   }
}
Example #11
0
void CManagePSWDPols::OnColumnEntryClick(NMHDR *pNotifyStruct, LRESULT *pLResult)
{
  *pLResult = 1L;

  NMHEADER *pNMHeader = (NMHEADER *)pNotifyStruct;

  int iIndex = pNMHeader->iItem;

  HDITEM hdi;
  hdi.mask = HDI_FORMAT;
  CHeaderCtrl *pHdrCtrl = m_PolicyEntries.GetHeaderCtrl();

  if (iIndex == m_iSortEntriesIndex) {
    m_bSortEntriesAscending = !m_bSortEntriesAscending;
  } else {
    // Turn off all previous sort arrows
    for (int i = 0; i < pHdrCtrl->GetItemCount(); i++) {
      pHdrCtrl->GetItem(i, &hdi);
      if ((hdi.fmt & (HDF_SORTUP | HDF_SORTDOWN)) != 0) {
        hdi.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN);
        pHdrCtrl->SetItem(i, &hdi);
      }
    }
    m_iSortEntriesIndex = iIndex;
    m_bSortEntriesAscending = true;
  }

  pHdrCtrl->GetItem(iIndex, &hdi);

  // Turn off all arrows
  hdi.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN);
  // Turn on the correct arrow
  hdi.fmt |= (m_bSortEntriesAscending ? HDF_SORTUP : HDF_SORTDOWN);
  pHdrCtrl->SetItem(iIndex, &hdi);

  m_PolicyEntries.SortItems(&CManagePSWDPols::SortEntries, (DWORD_PTR)this);
}
Example #12
0
void CFileDiffDlg::OnHdnItemclickFilelist(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMHEADER phdr = reinterpret_cast<LPNMHEADER>(pNMHDR);
	if (m_bThreadRunning)
		return;

	if (m_nSortedColumn == phdr->iItem)
		m_bAscending = !m_bAscending;
	else
		m_bAscending = TRUE;
	m_nSortedColumn = phdr->iItem;
	m_arSelectedFileList.RemoveAll();
	Sort();

	CString temp;
	m_cFileList.SetRedraw(FALSE);
	m_cFileList.DeleteAllItems();
	m_cFilter.GetWindowText(temp);
	Filter(temp);

	CHeaderCtrl * pHeader = m_cFileList.GetHeaderCtrl();
	HDITEM HeaderItem = {0};
	HeaderItem.mask = HDI_FORMAT;
	for (int i=0; i<pHeader->GetItemCount(); ++i)
	{
		pHeader->GetItem(i, &HeaderItem);
		HeaderItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
		pHeader->SetItem(i, &HeaderItem);
	}
	pHeader->GetItem(m_nSortedColumn, &HeaderItem);
	HeaderItem.fmt |= (m_bAscending ? HDF_SORTUP : HDF_SORTDOWN);
	pHeader->SetItem(m_nSortedColumn, &HeaderItem);

	m_cFileList.SetRedraw(TRUE);

	*pResult = 0;
}
Example #13
0
void CTxMsgListView::OnColumnclickLstcMsgDetails(NMHDR* pNMHDR, LRESULT* pResult)
{
    NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
    // If it is first column
    if( pNMListView->iSubItem == 0 )
    {
        // Get the status from Image Index
        BOOL bToBeChecked = FALSE;
        // Change header Control Image Index
        CHeaderCtrl* pHeader = m_omLctrMsgList.GetHeaderCtrl();
        if( pHeader != nullptr )
        {
            // Get Current Image Index
            HDITEM hditem;
            hditem.mask = HDI_IMAGE | HDI_FORMAT;
            if( pHeader->GetItem(0, &hditem ) == TRUE )
            {
                // Image Index To be Set
                int nNewImageIndex = 0;
                // Toggle Image Index
                if( hditem.iImage == 0 )
                {
                    bToBeChecked = TRUE;
                    nNewImageIndex = 1;
                }

                // Update Image Index
                hditem.fmt |=  HDF_IMAGE;
                hditem.iImage = nNewImageIndex;
                pHeader->SetItem(0, &hditem );
                // Update Message Check Value
                vSetMessageCheckValue( bToBeChecked );

                CTxFunctionsView* pView = (CTxFunctionsView*)
                                          pomGetFunctionsViewPointer();

                if( pView != nullptr )
                {
                    if(pView->m_CheckBoxAutoUpdate.GetCheck() == BST_CHECKED)
                    {
                        pView->vAccessButtonApply();
                        this->SetFocus();
                    }
                }
            }
        }
    }
    *pResult = 0;
}
Example #14
0
int SortStatus(CListCtrl &list,
               int status)       // 0..(n-1)*2 => select column code
                                 // -1 => clear the sorted column
{                                // -2 => return only the sorted column code
   CHeaderCtrl *pHeader = list.GetHeaderCtrl();
   int ix = pHeader->GetItemCount(), rq = (status + 2) / 2 - 1;
   HDITEM hi;

   if (rq >= ix) status = -1;

   // search the old sorted column
   hi.mask = HDI_IMAGE|HDI_LPARAM;
   while (--ix >= 0) {
      pHeader->GetItem(ix, &hi);
      if (hi.iImage == 0) continue;

      // the old sorted column is found
      if (status == -2) {
         // Req = -2 : put the status (state and sorted column)
         return ix * 2 + (hi.iImage & 1);
      } else if (rq != ix) {
         // delete old display icon
         hi.iImage = 0;
//         hi.lParam |= STI_REVERSE;        //************************
         pHeader->SetItem(ix, &hi);
      }
      break;
   }
   if (status < 0) return -1;             // there is not sorted column !

   if (rq != ix) pHeader->GetItem(rq, &hi);
   hi.lParam = (hi.lParam & ~1) | (status & 1);
   hi.iImage = hi.lParam;
   pHeader->SetItem(rq, &hi);
   return status;
}
Example #15
0
CString GetColumnTitle(CListCtrl &list, int iSubItem, LPCTSTR pszTitle)
{
   CHeaderCtrl *pHeader = list.GetHeaderCtrl();
   char buffer[maxTitleLength] = {0, };
   HDITEM hi;

   hi.mask = HDI_FORMAT|HDI_TEXT;
   hi.pszText = buffer;
   hi.cchTextMax = maxTitleLength;
   if (pHeader->GetItem(iSubItem, &hi) && pszTitle) {
      hi.pszText = LPTSTR(pszTitle);
      pHeader->SetItem(iSubItem, &hi);
   }
   return CString(buffer);
}
Example #16
0
bool CPWListCtrl::IsNotesColumnPresent()
{
  CHeaderCtrl *pHeader = GetHeaderCtrl();
  if (pHeader == NULL)
    return false;

  HDITEM hdi;
  hdi.mask = HDI_LPARAM;
  
  for (int icol = 0; icol < pHeader->GetItemCount(); icol++) {
    pHeader->GetItem(icol, &hdi);
    if (hdi.lParam == CItemData::NOTES)
      return true;    
  }
  return false;
}
Example #17
0
void  CTxMsgListView::vCheckHeaderCtrl(bool bCheck)
{
    CHeaderCtrl* pHeader = m_omLctrMsgList.GetHeaderCtrl();
    if( pHeader != nullptr )
    {
        // Get Current Image Index
        HDITEM hditem;
        hditem.mask = HDI_IMAGE | HDI_FORMAT;
        if( pHeader->GetItem(0, &hditem ) == TRUE )
        {
            // Update Image Index
            hditem.fmt |=  HDF_IMAGE;
            hditem.iImage = bCheck;
            pHeader->SetItem(0, &hditem );
        }
    }
}
Example #18
0
// Resize columns in a header
void CLeftView::HeaderAutoFit(int nItem, bool change)
{
	CListCtrl& listctrl = GetListCtrl();
	CHeaderCtrl* pCtrl = listctrl.GetHeaderCtrl();
	
	if(pCtrl != NULL)
	{
		ASSERT(pCtrl != NULL);

		HD_ITEM hi;
		CRect rClient;
		GetClientRect(&rClient); // size without vscroll and hscroll bars

		int nItemCount = pCtrl->GetItemCount();
		int nHBoarder = ::GetSystemMetrics(SM_CXBORDER);

		//CScrollBar* pBar;
		//DWORD dwStyle = GetStyle();
		//int nScrollWidth = ::GetSystemMetrics(SM_CXVSCROLL);

		////If no scroll bars, set width to zero
		//pBar = GetScrollBarCtrl(SB_VERT);
		//if ((pBar != NULL && !pBar->IsWindowEnabled()) ||
		//	(pBar == NULL && !(dwStyle & WS_VSCROLL)))
		//		nScrollWidth = 0;

		//int t_width = 0;
		//
		//hi.mask = HDI_WIDTH;
		//pCtrl->GetItem(0, &hi);
		//t_width = hi.cxy;

		//hi.mask = HDI_WIDTH;
		//pCtrl->GetItem(1, &hi);
		//t_width += hi.cxy;

		hi.mask = HDI_WIDTH;
		pCtrl->GetItem(nItem, &hi);
		hi.mask = HDI_WIDTH;
		int width = hi.cxy;
		hi.cxy = rClient.Width() - hi.cxy + nHBoarder - 1;
		//TRACE("change %d, width %d, t_width %d, ITEM %d, WIDTH %d, O_ITEM %d, O_WIDTH %d\n", (change == true?1:0),  rClient.Width(), t_width, nItem, width, (nItem==0?1:0), hi.cxy);
		if (change == true) pCtrl->SetItem((nItem==0?1:0), &hi);
	}
}
void CCompareResultsDlg::OnColumnClick(NMHDR *pNotifyStruct, LRESULT *pLResult)
{
  NMHEADER *pNMHeaderCtrl  = (NMHEADER *)pNotifyStruct;

  // Get column number to CItemData value
  int isortcolumn = pNMHeaderCtrl->iItem;

  if (m_iSortedColumn == isortcolumn) {
    m_bSortAscending = !m_bSortAscending;
  } else {
    m_iSortedColumn = isortcolumn;
    m_bSortAscending = true;
  }

  m_LCResults.SortItems(CRCompareFunc, (LPARAM)this);

  // Reset item listindex
  for (int i = 0; i < m_LCResults.GetItemCount(); i++) {
    DWORD_PTR dwItemData = m_LCResults.GetItemData(i);
    st_CompareData *pst_data = GetCompareData(dwItemData);
    ASSERT(pst_data != NULL);
    pst_data->listindex = i;
  }

#if (WINVER < 0x0501)  // These are already defined for WinXP and later
#define HDF_SORTUP   0x0400
#define HDF_SORTDOWN 0x0200
#endif

  HDITEM hdi;
  hdi.mask = HDI_FORMAT;

  CHeaderCtrl *pHDRCtrl;

  pHDRCtrl = m_LCResults.GetHeaderCtrl();
  pHDRCtrl->GetItem(isortcolumn, &hdi);
  // Turn off all arrows
  hdi.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN);
  // Turn on the correct arrow
  hdi.fmt |= ((m_bSortAscending == TRUE) ? HDF_SORTUP : HDF_SORTDOWN);
  pHDRCtrl->SetItem(isortcolumn, &hdi);

  *pLResult = TRUE; // Say we have done all processing on return
}
Example #20
0
void CGitProgressList::ResizeColumns()
{
	SetRedraw(FALSE);

	TCHAR textbuf[MAX_PATH] = {0};

	CHeaderCtrl * pHeaderCtrl = (CHeaderCtrl*)(GetDlgItem(0));
	if (pHeaderCtrl)
	{
		int maxcol = pHeaderCtrl->GetItemCount()-1;
		for (int col = 0; col <= maxcol; ++col)
		{
			// find the longest width of all items
			int count = min((int)m_arData.size(), GetItemCount());
			HDITEM hdi = {0};
			hdi.mask = HDI_TEXT;
			hdi.pszText = textbuf;
			hdi.cchTextMax = _countof(textbuf);
			pHeaderCtrl->GetItem(col, &hdi);
			int cx = GetStringWidth(hdi.pszText)+20; // 20 pixels for col separator and margin

			for (int index = 0; index<count; ++index)
			{
				// get the width of the string and add 12 pixels for the column separator and margins
				int linewidth = cx;
				switch (col)
				{
				case 0:
					linewidth = GetStringWidth(m_arData[index]->sActionColumnText) + 12;
					break;
				case 1:
					linewidth = GetStringWidth(m_arData[index]->sPathColumnText) + 12;
					break;
				}
				if (cx < linewidth)
					cx = linewidth;
			}
			SetColumnWidth(col, cx);
		}
	}

	SetRedraw(TRUE);
}
Example #21
0
CString CLeftView::GetHeaderState(void)
{
	CString szHeader;
	CListCtrl& ctlList = (CListCtrl&) GetListCtrl();
	CHeaderCtrl* pHeaderCtrl = ctlList.GetHeaderCtrl();

	HDITEM hdi;
	int   nCount = pHeaderCtrl->GetItemCount();
	for(int i = 0; i < nCount; i++)
	{
		hdi.mask = HDI_WIDTH;
		pHeaderCtrl->GetItem(i, &hdi);
		CString szWidth;
		szWidth.Format( _T("%d,"), hdi.cxy);
		szHeader.Append( szWidth ) ;
	}

	return szHeader;
}
Example #22
0
void CListCtrlEx::SortListCtrlNone()
{
	if (this->m_pColumnMap[abs(this->m_nSortColumn) - 1] > 0)
	{
		CHeaderCtrl* pHeaderCtrl = GetHeaderCtrl();
		pHeaderCtrl->SetImageList(&this->m_nArrowList);

		HDITEM hdrItem;
		int nColumns = pHeaderCtrl->GetItemCount();
		for (int index = 0; index < nColumns; index++)
		{
			hdrItem.mask = HDI_FORMAT | HDI_IMAGE | HDI_LPARAM;
			pHeaderCtrl->GetItem(index, &hdrItem);

			hdrItem.fmt = hdrItem.fmt & HDF_JUSTIFYMASK | HDF_STRING;
			pHeaderCtrl->SetItem(index, &hdrItem);
		}
	}
}
Example #23
0
int COXItemTip::GetRealColumn(int nCol)
{
#if (_WIN32_IE >= 0x0300)
	ASSERT(::IsWindow(m_hWndHooked));

	//ASSERT(GetHookedWnd()->IsKindOf(RUNTIME_CLASS(CListCtrl)));
	//changed 12/15/99
	//	ASSERT(GetHookedWnd()->IsKindOf(RUNTIME_CLASS(CListCtrl)) ||
	//		GetHookedWnd()->IsKindOf(RUNTIME_CLASS(CListView)));

	ASSERT(m_hWndHooked==m_pAttachedCtrl->m_hWnd);

    // Get the header control 
	CHeaderCtrl* pHeader = (CHeaderCtrl*)m_pAttachedCtrl->GetDlgItem(0);
    ASSERT(pHeader);

    // get the current number of columns 
    int nCount=pHeader->GetItemCount();
	ASSERT(nCol<nCount);

    // find the real column number. We will request new HDI_ORDER info
    for (int nIndex=0; nIndex<nCount; nIndex++)
    {
        HD_ITEM hdItem;
        hdItem.mask=HDI_ORDER;
        BOOL bReturn = pHeader->GetItem(nIndex,&hdItem);
        ASSERT(bReturn);

        if(hdItem.iOrder==nCol)
        {
            return nIndex;
        }
    }

	// we shouldn't be here
    ASSERT(FALSE);

    return -1;
#else
	return nCol;
#endif
}
Example #24
0
void CCommonAppUtils::ResizeAllListCtrlCols(CListCtrl * pListCtrl)
{
    int maxcol = ((CHeaderCtrl*)(pListCtrl->GetDlgItem(0)))->GetItemCount()-1;
    int nItemCount = pListCtrl->GetItemCount();
    TCHAR textbuf[MAX_PATH] = { 0 };
    CHeaderCtrl * pHdrCtrl = (CHeaderCtrl*)(pListCtrl->GetDlgItem(0));
    if (pHdrCtrl)
    {
        int imgWidth = 0;
        CImageList * pImgList = pListCtrl->GetImageList(LVSIL_SMALL);
        if ((pImgList)&&(pImgList->GetImageCount()))
        {
            IMAGEINFO imginfo;
            pImgList->GetImageInfo(0, &imginfo);
            imgWidth = (imginfo.rcImage.right - imginfo.rcImage.left) + 3;  // 3 pixels between icon and text
        }
        for (int col = 0; col <= maxcol; col++)
        {
            HDITEM hdi = {0};
            hdi.mask = HDI_TEXT;
            hdi.pszText = textbuf;
            hdi.cchTextMax = _countof(textbuf);
            pHdrCtrl->GetItem(col, &hdi);
            int cx = pListCtrl->GetStringWidth(hdi.pszText)+20; // 20 pixels for col separator and margin

            for (int index = 0; index<nItemCount; ++index)
            {
                // get the width of the string and add 14 pixels for the column separator and margins
                int linewidth = pListCtrl->GetStringWidth(pListCtrl->GetItemText(index, col)) + 14;
                // add the image size
                if (col == 0)
                    linewidth += imgWidth;
                if (cx < linewidth)
                    cx = linewidth;
            }
            pListCtrl->SetColumnWidth(col, cx);

        }
    }
}
Example #25
0
void CListCtrlEx::QuickSort(int nSortColumn)
{
	if (this->m_pColumnMap[abs(nSortColumn) - 1] > 0)
	{
		this->m_nSortColumn = nSortColumn;
		this->m_nCompareType = this->m_pColumnArray[abs(nSortColumn) - 1].compare;
	}
	else
		return;

	QuickSort(0, GetItemCount()-1);

	CHeaderCtrl* pHeaderCtrl = GetHeaderCtrl();
	pHeaderCtrl->SetImageList(&this->m_nArrowList);

	HDITEM hdrItem;
	int nColumns = pHeaderCtrl->GetItemCount();
	for (int index = 0; index < nColumns; index++)
	{
		hdrItem.mask = HDI_FORMAT | HDI_IMAGE | HDI_LPARAM;
		pHeaderCtrl->GetItem(index, &hdrItem);
		if (abs(this->m_nSortColumn) - 1 ==  hdrItem.lParam && this->m_nSortColumn > 0)
		{
			hdrItem.iImage = 0;
			hdrItem.fmt = hdrItem.fmt & HDF_JUSTIFYMASK | HDF_IMAGE | HDF_STRING | HDF_BITMAP_ON_RIGHT;
		}
		else if (abs(this->m_nSortColumn) - 1 == hdrItem.lParam && this->m_nSortColumn < 0)
		{
			hdrItem.iImage = 1;
			hdrItem.fmt = hdrItem.fmt & HDF_JUSTIFYMASK | HDF_IMAGE | HDF_STRING | HDF_BITMAP_ON_RIGHT;
		}
		else
			hdrItem.fmt = hdrItem.fmt & HDF_JUSTIFYMASK | HDF_STRING;

		pHeaderCtrl->SetItem(index, &hdrItem);
	}
}
Example #26
0
void COptionsShortcuts::OnColumnClick(NMHDR *pNotifyStruct, LRESULT *pLResult)
{
  NMHEADER *pNMHeaderCtrl  = (NMHEADER *)pNotifyStruct;

  // Get column number to CItemData value
  int iKBSortColumn = pNMHeaderCtrl->iItem;

  if (m_iKBSortedColumn == iKBSortColumn) {
    m_bKBSortAscending = !m_bKBSortAscending;
  } else {
    m_iKBSortedColumn = iKBSortColumn;
    m_bKBSortAscending = true;
  }

  m_EntryShortcutLC.SortItems(CKBSHCompareFunc, (LPARAM)this);

#if (WINVER < 0x0501)  // These are already defined for WinXP and later
#define HDF_SORTUP   0x0400
#define HDF_SORTDOWN 0x0200
#endif

  HDITEM hdi;
  hdi.mask = HDI_FORMAT;

  CHeaderCtrl *pHDRCtrl;

  pHDRCtrl = m_EntryShortcutLC.GetHeaderCtrl();
  pHDRCtrl->GetItem(iKBSortColumn, &hdi);
  // Turn off all arrows
  hdi.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN);
  // Turn on the correct arrow
  hdi.fmt |= ((m_bSortAscending == TRUE) ? HDF_SORTUP : HDF_SORTDOWN);
  pHDRCtrl->SetItem(iKBSortColumn, &hdi);

  *pLResult = TRUE; // Say we have done all processing on return
}
Example #27
0
void CVGMFileListView::Clear()
{
    DeleteAllItems();

    if ( -1 != m_nSortedCol )
    {
    if ( g_bXPOrLater )
        {
        // Remove the sort arrow indicator from the sorted column.
        HDITEM hdi = { HDI_FORMAT };
        CHeaderCtrl wndHdr = GetHeader();

        wndHdr.GetItem ( m_nSortedCol, &hdi );
        hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
        wndHdr.SetItem ( m_nSortedCol, &hdi );

        // Remove the sorted column color from the list.
        SetSelectedColumn(-1);
        }

    m_nSortedCol = -1;
    m_bSortAscending = true;
    }
}
Example #28
0
void CLiveListCtrl::Sort(int nColumn)
{
	const int nOldColumn = (int)GetWindowLongPtr( GetSafeHwnd(), GWLP_USERDATA );

	if ( nColumn == -1 )
	{
		nColumn = nOldColumn;
	}
	else
	{
		nColumn++;

		if ( nColumn == abs( nOldColumn ) )
		{
			if ( nOldColumn > 0 )
				nColumn = 0 - nOldColumn;
			else
				nColumn = 0;
		}

		SetWindowLongPtr( GetSafeHwnd(), GWLP_USERDATA, nColumn );
	}

#ifdef IDB_SORT_ASC
	if ( ! CLiveList::m_bmSortAsc.m_hObject )
	{
		// Palette .bmp - 192,192,192 swapped to system color
		CLiveList::m_bmSortAsc.LoadMappedBitmap( IDB_SORT_ASC );
		CLiveList::m_bmSortDesc.LoadMappedBitmap( IDB_SORT_DESC );
	}

	CHeaderCtrl* pHeader = GetHeaderCtrl();
	for ( int nCol = 0 ; ; nCol++ )
	{
		HDITEM pColumn = {};
		pColumn.mask = HDI_BITMAP|HDI_FORMAT;

		if ( ! pHeader->GetItem( nCol, &pColumn ) ) break;

		HBITMAP hbm;
		int fmt;
		if ( nCol == abs( nColumn ) - 1 )
		{
			fmt = pColumn.fmt | HDF_BITMAP | HDF_BITMAP_ON_RIGHT;
			hbm = (HBITMAP)( nColumn > 0 ? CLiveList::m_bmSortAsc.GetSafeHandle() : CLiveList::m_bmSortDesc.GetSafeHandle() );
		}
		else
		{
			fmt = pColumn.fmt & ~HDF_BITMAP;
			hbm = NULL;
		}
		if ( pColumn.fmt != fmt || pColumn.hbm != hbm )
		{
			pColumn.fmt = fmt;
			pColumn.hbm = hbm;
			VERIFY( pHeader->SetItem( nCol, &pColumn ) );
		}
	}
#endif // IDB_SORT_ASC/DESC

	if ( nColumn )
	{
		std::stable_sort( m_pIndex.begin(), m_pIndex.end(),
			boost::bind( CLiveList::Less, _1, _2, nColumn ) );
	}

	InvalidateRect( NULL );
}
Example #29
0
void CLiveList::Sort(CListCtrl* pCtrl, int nColumn, BOOL bGraphic)
{
	ASSERT_VALID( pCtrl );

	int nOldColumn = (int)GetWindowLongPtr( pCtrl->GetSafeHwnd(), GWLP_USERDATA );

	if ( nColumn == -1 )
	{
		nColumn = nOldColumn;
	}
	else
	{
		if ( nColumn == abs( nOldColumn ) - 1 )
		{
			if ( nOldColumn > 0 )
				nColumn = 0 - nOldColumn;
			else
				nColumn = 0;
		}
		else
		{
			nColumn++;
		}

		SetWindowLongPtr( pCtrl->GetSafeHwnd(), GWLP_USERDATA, nColumn );
	}

#ifdef IDB_SORT_ASC
	if ( bGraphic )
	{
		if ( ! m_bmSortAsc.m_hObject )
		{
			// Palette .bmp - 192,192,192 swapped to system color
			m_bmSortAsc.LoadMappedBitmap( IDB_SORT_ASC );
			m_bmSortDesc.LoadMappedBitmap( IDB_SORT_DESC );
		}

		CHeaderCtrl* pHeader = (CHeaderCtrl*)CWnd::FromHandle( (HWND)pCtrl->SendMessage( LVM_GETHEADER ) );
		ASSERT_VALID( pHeader );
		for ( int nCol = 0 ; ; nCol++ )
		{
			HDITEM pColumn = {};
			pColumn.mask = HDI_BITMAP|HDI_FORMAT;

			if ( ! pHeader->GetItem( nCol, &pColumn ) ) break;

			HBITMAP hbm;
			int fmt;
			if ( nCol == abs( nColumn ) - 1 )
			{
				fmt = pColumn.fmt | HDF_BITMAP | HDF_BITMAP_ON_RIGHT;
				hbm = (HBITMAP)( nColumn > 0 ? m_bmSortAsc.GetSafeHandle() : m_bmSortDesc.GetSafeHandle() );
			}
			else
			{
				fmt = pColumn.fmt & ~HDF_BITMAP;
				hbm = NULL;
			}
			if ( pColumn.fmt != fmt || pColumn.hbm != hbm )
			{
				pColumn.fmt = fmt;
				pColumn.hbm = hbm;
				VERIFY( pHeader->SetItem( nCol, &pColumn ) );
			}
		}
	}
#endif // IDB_SORT_ASC/DESC

	if ( nColumn )
		pCtrl->SendMessage( LVM_SORTITEMS, (WPARAM)pCtrl, (LPARAM)SortCallback );
}
Example #30
0
void CDlgBDSelectRezTL::OnBnClickedButtonExportExcel()
{
	
	CDatabase database;
	CString sDriver = "MICROSOFT EXCEL DRIVER (*.XLS)"; // exactly the same name as in the ODBC-Manager
	CString sExcelFile = "Тележки1067.xls";                // Filename and path for the file to be created
	if( iNewProc ) sExcelFile = "Тележки1067arx.xls";
	CString sSql;
  
	CString strColListInsert = "";
	CString strColListCreate = "";
	int iColCount = 0;
	LVITEM Item;
	HDITEM hItem;
	enum   { sizeOfBuffer = 256 };
	TCHAR  lpBuffer[sizeOfBuffer];
	bool   fFound = false;

	hItem.mask = HDI_TEXT;
	hItem.pszText = lpBuffer;
	hItem.cchTextMax = sizeOfBuffer;
	CHeaderCtrl *hcHeader = m_List.GetHeaderCtrl();
  
	iColCount =  hcHeader->GetItemCount();
	CString strTitle = "";
	for( int i = 0; i < iColCount; i++ )
	{
		if( i ) 
		{	  
			strColListInsert += ", ";
			strColListCreate += ", ";
		}
	  
		if( hcHeader->GetItem(i, &hItem) )
		{
			strTitle = hItem.pszText;
			strTitle.Remove('.');
			strColListInsert = strColListInsert + "[" + strTitle + "]";
			strColListCreate = strColListCreate + "[" + strTitle + "] TEXT";
		}
	}

  
    // Build the creation string for access without DSN
	DeleteFile(".\\" + sExcelFile);
    if( !CopyFile(".\\html\\" + sExcelFile, ".\\" + sExcelFile, 1) )
	{
		// Создам шаблон
		sSql.Format("DRIVER={%s};DSN='';FIRSTROWHASNAMES=1;READONLY=FALSE;CREATE_DB=\".\\html\\%s\";DBQ=.\\html\\%s",
                sDriver, sExcelFile, sExcelFile);
		database.OpenEx(sSql,CDatabase::noOdbcDialog);
		sSql = "CREATE TABLE [Тележки 1067] (" + strColListCreate + ")";
		database.ExecuteSQL(sSql);
		database.Close();
		CopyFile(".\\html\\" + sExcelFile, ".\\" + sExcelFile, 1);
	}

	sSql.Format("DRIVER={%s};DSN='';FIRSTROWHASNAMES=1;READONLY=FALSE;CREATE_DB=\".\\%s\";DBQ=%s",
                sDriver, sExcelFile, sExcelFile);

    // Create the database (i.e. Excel sheet)
    if( database.OpenEx(sSql,CDatabase::noOdbcDialog) )
    {
		/*
		TRY
		{
		sSql = "CREATE TABLE [Тележки 1067] (" + strColListCreate + ")";
		database.ExecuteSQL(sSql);
		}
		CATCH_ALL(e)
		{
		}
		END_CATCH_ALL
		*/
		

		for( int i = 0; i < m_List.GetItemCount(); i++ )
		{
			CString strLine = "";
			for( int j = 0; j < iColCount; j++ )
			{
				if( j ) strLine += ", ";
				strLine += "'" + m_List.GetItemText(i, j) + "'";
			}
			//sSql = "INSERT INTO [Тележки 1067] (" + strColListInsert + ") VALUES ( " + strLine + " )";
			sSql = "INSERT INTO [Тележки 1067] VALUES ( " + strLine + " )";
			database.ExecuteSQL(sSql);
		}
		
      
	}      

    database.Close();
	CString str = "excel.exe .\\" + sExcelFile;
	ShellExecute(NULL, "open", "excel.exe", 
                           sExcelFile, 
                           NULL, SW_SHOWNORMAL);

}