home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / sdk / mapi / win16 / dev / abview / tbllist.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-11  |  16.9 KB  |  677 lines
  1. /*
  2.  -  T B L L I S T . C P P
  3.  -  Copyright (C) 1995 Microsoft Corporation
  4.  -
  5.  *
  6.  */
  7.  
  8. #include <afxwin.h>
  9. #include <mapiwin.h>
  10. #include <mapix.h>
  11. #include "resource.h"
  12. #include "tbllist.h"
  13.  
  14.  
  15. //Global Font object pointers
  16. extern CFont*  pBoldFont;
  17. extern CFont*  pNormFont;
  18. extern CFont*  pLightFont;
  19. extern BOOL    fUNICODE;
  20. extern BOOL    fObjectType;
  21. extern LPSPropTagArray ABH_PropTagArray;
  22.  
  23. /*************************************************************************
  24.  *  CTblList Message Map.
  25.  *************************************************************************/
  26.  
  27. BEGIN_MESSAGE_MAP(CTblList, CListBox)
  28.     ON_WM_VSCROLL()
  29.     ON_WM_KEYDOWN()
  30. END_MESSAGE_MAP()
  31.  
  32. /*************************************************************************
  33.  *  CTblList Methods.
  34.  *************************************************************************/
  35.  
  36. /*
  37.  ** CTblList::CTblList
  38.  *
  39.  *  PARAMETERS:
  40.  *      UINT        - ID of the listbox resource
  41.  *      LPMAPITABLE - Table being viewed
  42.  *      BOOL        - Hierarchy Table flag
  43.  *
  44.  *  DESCRIPTION:
  45.  *      Constructor for the CTblList Class
  46.  *
  47.  *  RETURNS:
  48.  *      void
  49.  */
  50.  
  51. CTblList::CTblList( UINT nIDTemplate, LPMAPITABLE lpMAPITable, ULONG ulCurrentTableType )
  52. {
  53.     BOOL err;
  54.  
  55.     m_nIDTemplate           = nIDTemplate;
  56.     m_lpMAPITable           = lpMAPITable;
  57.     m_ulCurrentTableType    = ulCurrentTableType;
  58.     m_nPageSize             = 0;
  59.     m_ulCount               = 0;
  60.     
  61.     m_lpbBitmap = new CBitmap();
  62.     err = m_lpbBitmap->LoadBitmap( IDB_ABIMAGES );
  63.     if ( !err )
  64.         MessageBox( "No Bitmap loaded!", "NOTE:", MB_OK );
  65. }
  66.  
  67.  
  68. /*
  69.  ** CTblList::~CTblList
  70.  *
  71.  *  PARAMETERS:
  72.  *      none
  73.  *
  74.  *  DESCRIPTION:
  75.  *      Destructor for the CTblList Class
  76.  *
  77.  *  RETURNS:
  78.  *      void
  79.  */
  80.  
  81. CTblList::~CTblList()
  82. {
  83.     delete m_lpbBitmap;    
  84. }
  85.  
  86.  
  87. /*
  88.  ** CTblList::InitListBox
  89.  *
  90.  *  PARAMETERS:
  91.  *      none
  92.  *
  93.  *  DESCRIPTION:
  94.  *      Initializes the ListBox
  95.  *
  96.  *  RETURNS:
  97.  *      void
  98.  *
  99.  */
  100.  
  101. void CTblList::InitListBox()
  102. {
  103.     HRESULT hResult     = NULL;
  104.             m_nPageSize = GetPageSize();
  105.             
  106.     if(!m_lpMAPITable)
  107.         return;            
  108.  
  109.     if( FAILED(hResult = m_lpMAPITable->GetRowCount( TBL_NOWAIT, &m_ulCount )))
  110.         return;
  111.  
  112.     if( m_ulCount > m_nPageSize )
  113.     {
  114.         EnableScrollBarCtrl( SB_VERT, TRUE );
  115.         SetScrollRange( SB_VERT, (int)0, (int)(m_ulCount-m_nPageSize), FALSE );
  116.         ShowScrollBar( SB_VERT, TRUE );
  117.     }
  118.  
  119.     if( FAILED(hResult = m_lpMAPITable->SetColumns( (LPSPropTagArray)ABH_PropTagArray, 0 )))
  120.         return;
  121.  
  122.     VScroll( m_nPageSize );
  123.     SetCurSel( 0 );
  124. }
  125.  
  126.  
  127. /*
  128.  -  CTblList::
  129.  -  OnVScroll
  130.  -
  131.  *  Purpose:
  132.  *      Handles Scrolling Commands
  133.  *
  134.  */
  135.  
  136. void CTblList::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  137. {
  138.     HRESULT hResult     = NULL;
  139.     int     nOffset     = 0;
  140.     float   fOffset     = (float)0;
  141.     short   nScrollInc;
  142.     int     nNewPos;
  143.     int     nVScrollMin, nVScrollMax;
  144.     int     nVScrollPos = 0;
  145.     
  146.     nVScrollPos = GetScrollPos(SB_VERT);
  147.  
  148.     //Get the scroll bar range
  149.     GetScrollRange( SB_VERT, &nVScrollMin, &nVScrollMax );
  150.  
  151.     switch (nSBCode)
  152.     {
  153.         case SB_TOP: //move to the top
  154.             nScrollInc = -nVScrollPos;
  155.  
  156.             if( FAILED(hResult = m_lpMAPITable->SeekRow( BOOKMARK_BEGINNING, 0, NULL )))
  157.                 return;
  158.  
  159.         break;
  160.  
  161.         case SB_BOTTOM: //move to the bottom
  162.             nScrollInc = nVScrollMax - nVScrollPos;
  163.  
  164.             if( FAILED(hResult = m_lpMAPITable->SeekRow( BOOKMARK_END, -m_nPageSize, NULL )))
  165.                 return;
  166.  
  167.         break;
  168.  
  169.         case SB_LINEUP: //move one line up
  170.             nScrollInc = -1;
  171.         break;
  172.  
  173.         case SB_LINEDOWN: //move one line down
  174.             nScrollInc = 1;
  175.         break;
  176.  
  177.         case SB_PAGEUP: //move one page up
  178.             nScrollInc = -(m_nPageSize-1);
  179.         break;
  180.  
  181.         case SB_PAGEDOWN: //move one page down
  182.             nScrollInc = (m_nPageSize-1);
  183.         break;
  184.  
  185.         case SB_THUMBPOSITION: //track the thumb box
  186.             nScrollInc = nPos - nVScrollPos;
  187.  
  188.             if( nPos == 0 )
  189.             {
  190.                 if( FAILED(hResult = m_lpMAPITable->SeekRow( BOOKMARK_BEGINNING, 0, NULL )))
  191.                     return;
  192.             }
  193.             else if( nPos == nVScrollMax )
  194.             {
  195.                 if( FAILED(hResult = m_lpMAPITable->SeekRow( BOOKMARK_END, -m_nPageSize, NULL )))
  196.                     return;
  197.             }
  198.  
  199.             if ( !((nPos == 0) || (nPos == nVScrollMax)) )
  200.             {
  201.  
  202.                 if( FAILED(hResult = m_lpMAPITable->SeekRowApprox( nPos, nVScrollMax )))
  203.                     return;
  204.  
  205.                 // Calculate an offset to adjust for the Scrollbar being at the top or
  206.                 // bottom of the list.  This is important if the paging if the view
  207.                 // is to take into account the location of the current table pointer
  208.                 // and the amount that is cached in view.
  209.  
  210.                 fOffset = (float)nPos / (float)nVScrollMax;
  211.                 nOffset = (int)((float)m_nPageSize * fOffset);
  212.  
  213.                 if( FAILED(hResult = m_lpMAPITable->SeekRow( BOOKMARK_CURRENT, -nOffset, NULL )))
  214.                     return;
  215.             }
  216.  
  217.         break;
  218.  
  219.         default:
  220.             nScrollInc = 0;
  221.     }
  222.  
  223.     // Calculate new vertical thumb box position so that:
  224.     // 0 <= nNewPos <= nVScrollMax
  225.     nNewPos = max(0, min(nVScrollPos + nScrollInc, nVScrollMax));
  226.  
  227.     // adjust scroll increment
  228.     if( (nSBCode  == SB_THUMBPOSITION) || (nSBCode  == SB_TOP) || (nSBCode  == SB_BOTTOM) )
  229.     {
  230.         while(DeleteString( 0 )) {}
  231.         nScrollInc = m_nPageSize;
  232.     }
  233.     else
  234.         nScrollInc = nNewPos - nVScrollPos;
  235.  
  236.     // is nScrollInc not zero?
  237.     if (nScrollInc)
  238.     {
  239.         // move the thumb box
  240.         SetScrollPos( SB_VERT, nNewPos ); 
  241.  
  242.         // scroll the list boxes
  243.         VScroll(nScrollInc);
  244.     }
  245. }
  246.  
  247.  
  248.  
  249. /*
  250.  -  CTblList::
  251.  -  VScroll
  252.  -
  253.  *  Purpose:
  254.  *      Handles ITable interface Commands
  255.  *
  256.  */
  257.  
  258. void CTblList::VScroll(short nScrollInc)
  259. {
  260.     short       nScrollAmt  = 0;
  261.     LPSRowSet   lpRows      = NULL;
  262.     HRESULT     hResult     = NULL;
  263.     ULONG       cRows       = 0;
  264.  
  265.     if( nScrollInc < 1 )
  266.     {
  267.         nScrollAmt = nScrollInc-m_nPageSize;
  268.  
  269.         if( FAILED(hResult = m_lpMAPITable->SeekRow( BOOKMARK_CURRENT, nScrollAmt, NULL )))
  270.             return;
  271.  
  272.         nScrollInc = -nScrollInc;
  273.  
  274.         if( !FAILED(hResult = m_lpMAPITable->QueryRows( nScrollInc, 0, &lpRows )))
  275.         {
  276.             if( lpRows->cRows )
  277.             {
  278.                 for( cRows = 0; cRows < lpRows->cRows; cRows++)
  279.                     DeleteString( (UINT)((m_nPageSize-1)-cRows) );
  280.  
  281.                 for( cRows = 0; cRows < lpRows->cRows; cRows++)
  282.                     InsertString( (int)cRows, (char*) lpRows->aRow[cRows].lpProps );
  283.  
  284.                 MAPIFreeBuffer( lpRows );
  285.             }
  286.             else
  287.                 MAPIFreeBuffer( lpRows );
  288.         }
  289.  
  290.         nScrollAmt = m_nPageSize-nScrollInc;
  291.  
  292.         if( FAILED(hResult = m_lpMAPITable->SeekRow( BOOKMARK_CURRENT, nScrollAmt, NULL )))
  293.             return;
  294.  
  295.     }
  296.     else
  297.     {
  298.         if( !FAILED(hResult = m_lpMAPITable->QueryRows( nScrollInc, 0, &lpRows )))
  299.         {
  300.             if( lpRows->cRows )
  301.             {
  302.                 if( GetCount() )
  303.                 {
  304.                     for( cRows = 0; cRows < lpRows->cRows; cRows++)
  305.                         DeleteString( 0 );
  306.                 }
  307.  
  308.                 for( cRows = 0; cRows < lpRows->cRows; cRows++)
  309.                     AddString( (char*) lpRows->aRow[cRows].lpProps );
  310.  
  311.                 MAPIFreeBuffer( lpRows );
  312.             }
  313.             else
  314.                 MAPIFreeBuffer( lpRows );
  315.         }
  316.     }
  317. }
  318.  
  319.  
  320. /*
  321.  -  CTblList::
  322.  -  DeleteString
  323.  -
  324.  *  Purpose:
  325.  *      Handles Deleting of Row from Table
  326.  *
  327.  */
  328. int CTblList::DeleteString(UINT nIndex)
  329. {
  330.     int cStrings = 0;
  331.     int nCount = (this)->GetCount();
  332.     
  333.     if (nCount > 0)
  334.     {
  335.         LPSPropValue lpProps = NULL;
  336.         lpProps = (LPSPropValue)GetItemData( nIndex );
  337.  
  338.         if( (DWORD)lpProps != LB_ERR )
  339.         {
  340.             cStrings = CListBox::DeleteString( nIndex );
  341.             MAPIFreeBuffer( lpProps );
  342.         }
  343.     }
  344.  
  345.     return GetCount();
  346. }
  347.  
  348.  
  349. /*
  350.  -  CTblList::
  351.  -  GetPageSize
  352.  -
  353.  */
  354.  
  355. int CTblList::GetPageSize()
  356. {
  357.     CRect       rect;
  358.     CDC *       pdcListBox = NULL;
  359.     TEXTMETRIC  tmListBox;
  360.  
  361.     m_nPageSize = 0;
  362.  
  363.     GetWindowRect( &rect );
  364.  
  365.     pdcListBox = GetDC();
  366.     pdcListBox->GetTextMetrics( &tmListBox );
  367.  
  368.     m_nPageSize = (rect.bottom - rect.top) / tmListBox.tmHeight;
  369.  
  370.     return m_nPageSize;
  371. }
  372.  
  373.  
  374. /*
  375.  -  CTblList::
  376.  -  DrawItem
  377.  -
  378.  */
  379.  
  380. void CTblList::DrawItem(LPDRAWITEMSTRUCT lpDIS)
  381. {
  382.     CDC *   pDC = CDC::FromHandle(lpDIS->hDC);
  383.     CFont * lpOldFont;
  384.     int     idx = 1;
  385.     CSize   size;
  386.     int     x = 0;
  387.     int     nIndent = 0;
  388.     
  389.     LPSPropValue lpProps = NULL;
  390.  
  391.     if( ODA_DRAWENTIRE & lpDIS->itemAction )
  392.     {
  393.         pDC->PatBlt( lpDIS->rcItem.left, lpDIS->rcItem.top,
  394.         lpDIS->rcItem.right - lpDIS->rcItem.left,
  395.         lpDIS->rcItem.bottom - lpDIS->rcItem.top,
  396.         PATCOPY );
  397.  
  398.         lpProps = (LPSPropValue)lpDIS->itemData;
  399.  
  400.         if (!lpProps)
  401.             return;
  402.  
  403.         CDC * pDCBitmap = new CDC;
  404.         ULONG   IconBM = 0;
  405.  
  406.         lpOldFont = pDC->SelectObject( pLightFont );
  407.  
  408.         if((PROP_TYPE(lpProps[3].ulPropTag) == PT_NULL) || (fObjectType == TRUE))
  409.         {
  410.             switch( lpProps[2].Value.ul )
  411.             {
  412.                 case MAPI_MAILUSER:
  413.                     IconBM = BMWIDTH * 12;
  414.                     break;
  415.                 case MAPI_DISTLIST:
  416.                     IconBM = BMWIDTH * 13;
  417.                     lpOldFont = pDC->SelectObject( pNormFont );
  418.                     break;
  419.                 case MAPI_ABCONT:
  420.                     IconBM = BMWIDTH * 14;
  421.                     break;
  422.                 default:    
  423.                     IconBM = BMWIDTH * 17;
  424.                     break;
  425.             }
  426.         } 
  427.         else if( m_ulCurrentTableType == fHierarchy )
  428.         {
  429.             switch( lpProps[3].Value.ul )
  430.             {
  431.                 case DT_MODIFIABLE:
  432.                     IconBM = BMWIDTH * 7;
  433.                     break;
  434.                 case DT_GLOBAL:
  435.                     IconBM = BMWIDTH * 8;
  436.                     break;
  437.                 case DT_LOCAL:
  438.                     IconBM = BMWIDTH * 9;
  439.                     break;
  440.                 case DT_WAN:
  441.                     IconBM = BMWIDTH * 10;
  442.                     break;
  443.                 case DT_NOT_SPECIFIC:
  444.                     IconBM = BMWIDTH * 11;
  445.                     break;
  446.                 default:    
  447.                     IconBM = BMWIDTH * 16;
  448.                     break;
  449.             }
  450.         }
  451.         else if( m_ulCurrentTableType != fHierarchy )
  452.         {
  453.             switch( lpProps[3].Value.ul )
  454.             {
  455.                 case DT_MAILUSER:
  456.                     IconBM = 0;
  457.                     break;
  458.                 case DT_DISTLIST:
  459.                     IconBM = BMWIDTH * 1;
  460.                     lpOldFont = pDC->SelectObject( pNormFont );
  461.                     break;
  462.                 case DT_FORUM:
  463.                     IconBM = BMWIDTH * 2;
  464.                     lpOldFont = pDC->SelectObject( pNormFont );
  465.                     break;
  466.                 case DT_AGENT:
  467.                     IconBM = BMWIDTH * 3;
  468.                     lpOldFont = pDC->SelectObject( pNormFont );
  469.                     break;
  470.                 case DT_ORGANIZATION:
  471.                     IconBM = BMWIDTH * 4;
  472.                     lpOldFont = pDC->SelectObject( pNormFont );
  473.                     break;
  474.                 case DT_PRIVATE_DISTLIST:
  475.                     IconBM = BMWIDTH * 5;
  476.                     lpOldFont = pDC->SelectObject( pNormFont );
  477.                     break;
  478.                 case DT_REMOTE_MAILUSER:
  479.                     IconBM = BMWIDTH * 6;
  480.                     break;
  481.                 default:    
  482.                     IconBM = BMWIDTH * 16;
  483.                     break;
  484.             }
  485.         }
  486.  
  487.         pDCBitmap->CreateCompatibleDC( pDC );
  488.         pDCBitmap->SelectObject( m_lpbBitmap );
  489.  
  490.         if( m_ulCurrentTableType == fHierarchy )
  491.         {
  492.             nIndent = (int)(INDENT * lpProps[4].Value.ul);
  493.  
  494.             if (nIndent == 0)
  495.                 lpOldFont = pDC->SelectObject( pBoldFont );
  496.                 
  497.  
  498.             if(PROP_TYPE(lpProps[5].ulPropTag) != PT_NULL)
  499.             {
  500.                 if(lpProps[5].Value.ul & AB_SUBCONTAINERS) 
  501.                 pDC->BitBlt( (int)(lpDIS->rcItem.left + nIndent), 
  502.                              (int)lpDIS->rcItem.top,
  503.                              (int)15, 
  504.                              (int)BMHEIGHT,
  505.                              pDCBitmap,
  506.                              (int)BMWIDTH * 18,
  507.                              (int)0,
  508.                              SRCCOPY );
  509.             }
  510.  
  511.             nIndent += 13;
  512.         }
  513.  
  514.         pDC->BitBlt( (int)(lpDIS->rcItem.left + nIndent), 
  515.                      (int)lpDIS->rcItem.top,
  516.                      (int)BMWIDTH, 
  517.                      (int)BMHEIGHT,
  518.                      pDCBitmap,
  519.                      (int)IconBM,
  520.                      (int)0,
  521.                      SRCCOPY );
  522.  
  523.         delete pDCBitmap;
  524.  
  525.         if(PROP_TYPE(lpProps[0].ulPropTag) == PT_UNICODE)
  526.         {
  527.  
  528. #ifdef _WINNT        
  529.             TextOutW( lpDIS->hDC,
  530.                       lpDIS->rcItem.left+BMWIDTH+nIndent, lpDIS->rcItem.top,
  531.                       (LPWSTR)lpProps[0].Value.lpszW,
  532.                       lstrlenW((LPWSTR)lpProps[0].Value.lpszW ));
  533. #endif                      
  534.  
  535.         }
  536.         else
  537.         {
  538.             pDC->TextOut( lpDIS->rcItem.left+BMWIDTH+nIndent, lpDIS->rcItem.top,
  539.                           (LPCSTR)lpProps[0].Value.lpszA,
  540.                           lstrlen((LPCSTR)lpProps[0].Value.lpszA ));
  541.         }
  542.         
  543.  
  544.         if( ODS_SELECTED & lpDIS->itemState )
  545.             pDC->PatBlt( lpDIS->rcItem.left, lpDIS->rcItem.top,
  546.                          lpDIS->rcItem.right - lpDIS->rcItem.left,
  547.                          lpDIS->rcItem.bottom - lpDIS->rcItem.top,
  548.                          DSTINVERT );
  549.  
  550.         if( ODS_FOCUS & lpDIS->itemState )
  551.             pDC->DrawFocusRect( &lpDIS->rcItem );
  552.     }
  553.     else
  554.     {
  555.         if( ODA_SELECT & lpDIS->itemAction )
  556.             pDC->PatBlt( lpDIS->rcItem.left, lpDIS->rcItem.top,
  557.                          lpDIS->rcItem.right - lpDIS->rcItem.left,
  558.                          lpDIS->rcItem.bottom - lpDIS->rcItem.top,
  559.                          DSTINVERT );
  560.  
  561.         if( ODA_FOCUS & lpDIS->itemAction )
  562.             pDC->DrawFocusRect( &lpDIS->rcItem );
  563.     }
  564. }
  565.  
  566.  
  567. /*
  568.  -  CTblList::
  569.  -  MeasureItem
  570.  -
  571.  */
  572.  
  573. void CTblList::MeasureItem(LPMEASUREITEMSTRUCT)
  574. {
  575. }
  576.  
  577.  
  578. /*
  579.  -  CTblList::
  580.  -  CompareItem
  581.  -
  582.  */
  583.  
  584. int CTblList::CompareItem(LPCOMPAREITEMSTRUCT)
  585. {
  586.     return 0;
  587. }
  588.  
  589. /*
  590.  -  CTblList::
  591.  -  DeleteItem
  592.  -
  593.  */
  594.  
  595. void CTblList::DeleteItem(LPDELETEITEMSTRUCT)
  596. {
  597. }
  598.  
  599. /*
  600.  -  CTblList::
  601.  -  OnKeyDown
  602.  -
  603.  *  Purpose:
  604.  *
  605.  */
  606.  
  607. void CTblList::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags )
  608. {
  609. int nTopIndex = GetTopIndex();
  610. int nCurSel   = GetCurSel();
  611. int nGetCount = GetCount();
  612.  
  613.     switch (nChar)
  614.     {
  615.         case VK_HOME:
  616.             OnVScroll( SB_TOP, 0, NULL );
  617.             SetCurSel( 0 );
  618.             
  619.         break;
  620.  
  621.         case VK_END:
  622.             OnVScroll( SB_BOTTOM, 0, NULL );
  623.             SetCurSel( nGetCount - 1 );
  624.             
  625.         break;
  626.  
  627.         case VK_UP:
  628.             if(nCurSel == 0)
  629.             {
  630.                 OnVScroll( SB_LINEUP, 0, NULL );
  631.                 SetCurSel( 0 );
  632.             }
  633.             else
  634.                 CListBox::OnKeyDown( nChar, nRepCnt, nFlags );
  635.  
  636.         break;
  637.  
  638.         case VK_DOWN:
  639.             if(nCurSel == (nTopIndex + nGetCount - 1))
  640.             {
  641.                 OnVScroll( SB_LINEDOWN, 0, NULL );
  642.                 SetCurSel( nGetCount - 1 );
  643.             }    
  644.             else
  645.                 CListBox::OnKeyDown( nChar, nRepCnt, nFlags );
  646.                 
  647.         break;
  648.  
  649.         case VK_PRIOR:
  650.             if(nCurSel == 0)
  651.             {
  652.                 OnVScroll( SB_PAGEUP, 0, NULL );
  653.                 SetCurSel( 0 );
  654.             } 
  655.             else
  656.                 CListBox::OnKeyDown( nChar, nRepCnt, nFlags );
  657.  
  658.         break;
  659.  
  660.         case VK_NEXT:
  661.             if(nCurSel == (nTopIndex + nGetCount - 1))
  662.             {
  663.                 OnVScroll( SB_PAGEDOWN, 0, NULL );
  664.                 SetCurSel( nGetCount - 1 );
  665.             }
  666.             else
  667.                 CListBox::OnKeyDown( nChar, nRepCnt, nFlags );
  668.  
  669.         break;
  670.  
  671.         default:
  672.             CListBox::OnKeyDown( nChar, nRepCnt, nFlags );
  673.             return;
  674.     }
  675. }
  676.  
  677.