开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Windows Mobile > 查看源码
XListBox.cpp
资源名称：TextViewNG.rar　[点击查看]
上传用户：hmc_gdtv
上传日期：2013-08-04
资源大小：798k
文件大小：25k
源码类别：

Windows Mobile

开发平台：

Visual C++

XListBox.cpp：源码内容
  1. /*
  2.  * Copyright (c) 2001,2002,2003 Mike Matsnev.  All Rights Reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice immediately at the beginning of the file, without modification,
  10.  *    this list of conditions, and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. Absolutely no warranty of function or purpose is made by the author
  15.  *    Mike Matsnev.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  * 
  28.  * $Id: XListBox.cpp,v 1.1.2.33 2004/10/21 14:53:27 mike Exp $
  29.  * 
  30.  */
  32. #include <afxwin.h>
  33. #include <afxcmn.h>
  35. #include "resource.h"
  36. #include "config.h"
  37. #include "XListBox.h"
  39. #define DEFAULT_FONT_SIZE     11
  40. #define UICON_PAD       1
  41. #define COLOR0       RGB(0,0,0)
  42. #define COLOR1       RGB(255,255,255)
  43. #define COLOR2       RGB(251,242,233)
  44. #define COLOR3       RGB(128,128,128)
  45. #define COLOR4       RGB(255,255,255)
  46. #define COLOR5       RGB(16,32,255)
  48. #define INDENT_PER_LEVEL      5
  50. // string compare
  51. #define CmpI(s1,s2) 
  52.     (::CompareString(LOCALE_USER_DEFAULT,NORM_IGNORECASE, 
  53.     (s1),-1,(s2),-1)-2)
  55. struct XLBItem {
  56.   TCHAR   *text1;
  57.   TCHAR   *text2;
  58.   int   icon_index;
  59.   int   level;
  60.   int   flags;
  61.   LONG    user_data;
  62. };
  64. #define XIF_COLLAPSED 1
  66. struct XLB {
  67.   HWND   hWnd;
  69.   int   num_items;
  70.   int   max_items;
  71.   XLBItem   *items;
  73.   int   visible_items;
  74.   XLBItem   **vitems;
  76.   int   selection; // selection is I
  77.   int   top_offset;
  78.   int   scroll_page;
  80.   int   item_height;
  81.   int   line_height;
  83.   HIMAGELIST   icons;
  84.   bool   icons_shared;
  86.   HFONT   font;
  87.   int   dots_width;
  89.   HIMAGELIST   tree_icons;
  91.   int   flags;
  93.   XLB_GetText   gtf;
  94.   void   *gtdata;
  96.   int   uicon_w;
  97.   int   ticon_w;
  98. };
  100. #define XLF_TREE  1
  102. static bool   XLB_GrowList(XLB *x) {
  103.   int incr=x->num_items;
  105.   if (incr<16)
  106.     incr=16;
  107.   if (incr>4096)
  108.     incr=4096;
  110.   int newsize=x->num_items+incr;
  112.   XLBItem   *newitems=(XLBItem*)realloc(x->items,newsize*sizeof(XLBItem));
  113.   if (newitems==NULL)
  114.     return false;
  116.   x->items=newitems;
  118.   XLBItem   **newvitems=(XLBItem**)realloc(x->vitems,newsize*sizeof(XLBItem*));
  119.   if (newvitems==NULL)
  120.     return false;
  122.   x->vitems=newvitems;
  124.   x->max_items=newsize;
  126.   return true;
  127. }
  129. static void  XLB_UpdateVisibleItems(XLB *x) {
  130.   XLBItem *ii=x->items;
  131.   XLBItem *jj=ii+x->num_items;
  132.   XLBItem **kk=x->vitems;
  134.   int   level = 0;
  135.   int   flags = 0;
  137.   while (ii<jj) {
  138.     if (ii->level > level)
  139.       flags=XLF_TREE;
  141.     level = ii->level;
  143.     *kk++=ii;
  145.     if (ii++->flags & XIF_COLLAPSED) {
  146.       // skip all following children
  147.       while (ii<jj && ii->level>level) {
  148. ++ii;
  149. flags=XLF_TREE;
  150.       }
  151.     }
  152.   }
  154.   x->visible_items = kk - x->vitems;
  156.   x->flags |= flags;
  157. }
  159. static int  XLB_GetIFromV(XLB *x,int v) {
  160.   return x->vitems[v] - x->items;
  161. }
  163. static int  XLB_GetVFromI(XLB *x,int i) {
  164.   int     top=x->visible_items-1;
  165.   int     bottom=0;
  166.   XLBItem   *ii=&x->items[i];
  167.   XLBItem   **kk=x->vitems;
  169.   while (bottom<=top) {
  170.     int   middle=(bottom+top)>>1;
  172.     if (kk[middle]==ii)
  173.       return middle;
  175.     if (kk[middle]>ii)
  176.       top=middle-1;
  177.     else
  178.       bottom=middle+1;
  179.   }
  181.   return -1;
  182. }
  184. static int  XLB_GetParent(XLB *x,int i) {
  185.   XLBItem   *jj=x->items;
  186.   XLBItem   *ii=jj+i;
  187.   int     level=ii->level;
  189.   while (ii-->jj)
  190.     if (ii->level < level)
  191.       return ii - jj;
  193.   return -1;
  194. }
  196. static void XLB_UpdateScrollbar(XLB *x);
  198. static void XLB_Restore(XLB *x,int item) {
  199.   bool changed=false;
  201.   for (;;) {
  202.     item=XLB_GetParent(x,item);
  204.     if (item<0)
  205.       break;
  207.     if (x->items[item].flags & XIF_COLLAPSED) {
  208.       x->items[item].flags &= ~XIF_COLLAPSED;
  209.       changed=true;
  210.     }
  211.   }
  213.   if (changed)
  214.     XLB_UpdateVisibleItems(x);
  215. }
  217. static bool XLB_HasChildren(XLB *x,int item) {
  218.    return item < x->num_items-1 && x->items[item+1].level > x->items[item].level;
  219. }
  221. #define SPC(x) ((x)==_T(' ') || (x)==_T('t') || (x)==_T('r') || (x)==_T('n'))
  223. static void XLB_PaintItem(XLB *x,int item,int vitem,HDC hDC,RECT& rc) {
  224.   // cache an item pointer
  225.   XLBItem   *ii=&x->items[item];
  227.   // query text1 and text2 if they are NULL
  228.   const TCHAR   *text1=ii->text1;
  229.   const TCHAR   *text2=ii->text2;
  231.   if (text1==NULL && x->gtf) {
  232.     CString t(x->gtf(x->gtdata,0,item,ii->user_data));
  233.     text1=ii->text1=_tcsdup(t);
  234.   }
  236.   if (text2==NULL && x->gtf) {
  237.     CString t(x->gtf(x->gtdata,1,item,ii->user_data));
  238.     text2=ii->text2=_tcsdup(t);
  239.   }
  241.   // set text and bg colors
  242.   COLORREF  text1_color,text2_color,bk_color;
  243.   if (item==x->selection)
  244.     text1_color=text2_color=COLOR4;
  245.   else {
  246.     text1_color=COLOR0;
  247.     text2_color=COLOR3;
  248.   }
  249.   bk_color=
  250.     item==x->selection ? COLOR5 :
  251.       vitem&1 ? COLOR1 : COLOR2;
  252.   ::SetBkColor(hDC,bk_color);
  254.   // calculate indentation and paint it
  255.   int     indent=ii->level*INDENT_PER_LEVEL;
  256.   if (indent > (rc.right-rc.left)/2)
  257.     indent=(rc.right-rc.left)/2;
  259.   RECT rci=rc;
  260.   rci.right=rci.left;
  262.   if (indent)
  263.     rci.right+=indent;
  265.   if (x->flags & XLF_TREE)
  266.     rci.right+=x->ticon_w;
  268.   if (ii->icon_index>=0)
  269.     rci.right+=x->uicon_w;
  271.   if (rci.right!=rci.left)
  272.     ::ExtTextOut(hDC,rci.left,rci.top,ETO_OPAQUE,&rci,NULL,0,NULL);
  274.   // top and bottom text rectangles
  275.   RECT     rt,rb;
  276.   rt=rc;
  277.   rt.bottom=rt.top+x->line_height;
  278.   rt.left+=indent;
  279.   rb=rt;
  280.   rb.top+=x->line_height;
  281.   rb.bottom+=x->line_height;
  283.   // paint a tree icon
  284.   if (x->flags & XLF_TREE) { // tree mode
  285.     // reduce text width
  286.     rci=rc;
  287.     rci.left=rt.left;
  288.     rci.right=rci.left+x->ticon_w;
  290.     rt.left+=x->ticon_w;
  291.     rb.left+=x->ticon_w;
  293.     // paint the icon itself
  294.     ::ImageList_DrawEx(x->tree_icons,
  295.       XLB_HasChildren(x,item) ? (ii->flags & XIF_COLLAPSED ? 0 : 1) : 2,
  296.       hDC,
  297.       rci.left,rci.top,0,0,
  298.       bk_color,CLR_NONE,
  299.       ILD_NORMAL);
  300.   }
  302.   // paint an icon
  303.   if (ii->icon_index>=0) {
  304.     // calc icon rectangle
  305.     rci=rc;
  306.     rci.left+=rt.left;
  307.     rci.right=rci.left+x->uicon_w;
  309.     // reduce text width by icon size
  310.     rt.left+=x->uicon_w;
  311.     rb.left+=x->uicon_w;
  313.     // paint the icon itself
  314.     ::ImageList_DrawEx(x->icons,
  315.       ii->icon_index,
  316.       hDC,
  317.       rci.left+UICON_PAD,rci.top+UICON_PAD,0,0,
  318.       bk_color,CLR_NONE,
  319.       ILD_NORMAL);
  320.   }
  322.   // paint text2
  323.   if (text2) {
  324.     int   tl=_tcslen(text2);
  326.     // get text2 width
  327.     SIZE    sz;
  328.     ::GetTextExtentPoint(hDC,text2,tl,&sz);
  330.     // calc text box
  331.     rci=rb;
  333.     // adjust bottom rectangle
  334.     if (sz.cx<rb.right-rb.left)
  335.       rb.right-=sz.cx;
  336.     else
  337.       rb.right=rb.left;
  338.     rb.right-=5;
  340.     if (rb.right<rb.left)
  341.       rb.right=rb.left;
  343.     rci.left=rb.right;
  345.     // paint text
  346.     ::SetTextColor(hDC,text2_color);
  347.     ::ExtTextOut(hDC,rci.left+3,rci.top,ETO_OPAQUE|ETO_CLIPPED,&rci,text2,tl,NULL);
  348.   }
  350.   int tl=text1 ? _tcslen(text1) : 0;
  352.   // get size of top part
  353.   SIZE sz;
  354.   int top_len=0;
  355.   ::GetTextExtentExPoint(hDC,text1,tl,rt.right-rt.left,&top_len,NULL,&sz);
  357.   // do some simple word wrapping
  358.   int i;
  359.   for (i=0;i<top_len;++i)
  360.     if (text1[i]==_T('n') || text1[i]==_T('r'))
  361.       break;
  362.   top_len=i;
  363.   if (top_len!=tl && !SPC(text1[top_len])) {
  364.     while (i>0 && !SPC(text1[i-1]))
  365.       --i;
  366.     if (i>0)
  367.       top_len=i;
  368.   }
  370.   // back off until spaces end
  371.   while (top_len>0 && SPC(text1[top_len-1]))
  372.     --top_len;
  374.   // set text1 color
  375.   ::SetTextColor(hDC,text1_color);
  377.   // paint top part
  378.   ::ExtTextOut(hDC,rt.left,rt.top,ETO_OPAQUE|ETO_CLIPPED,&rt,text1,top_len,NULL);
  380.   // skip spaces here
  381.   while (top_len<tl && SPC(text1[top_len]))
  382.     ++top_len;
  384.   // paint bottom part
  385.   if (rb.right>rb.left) {
  386.     // check size
  387.     ::GetTextExtentExPoint(hDC,text1+top_len,tl-top_len,rb.right-rb.left,&i,NULL,&sz);
  388.     if (i!=tl-top_len) { // overflow, will need to append "..."
  389.       ::GetTextExtentExPoint(hDC,text1+top_len,tl-top_len,rb.right-rb.left-x->dots_width,&i,NULL,&sz);
  390.       ::GetTextExtentPoint(hDC,text1+top_len,i,&sz);
  391.     }
  392.     ::ExtTextOut(hDC,rb.left,rb.top,ETO_OPAQUE|ETO_CLIPPED,&rb,text1+top_len,i,NULL);
  393.     if (i!=tl-top_len)
  394.       ::ExtTextOut(hDC,rb.left+sz.cx,rb.top,0,NULL,_T("..."),3,NULL);
  395.   }
  396. }
  398. static void XLB_PaintAll(XLB *x,HDC hDC) {
  399.   // load tree icons if we are in tree mode
  400.   if (x->flags & XLF_TREE && !x->tree_icons) {
  401.     x->tree_icons=::ImageList_LoadBitmap(
  402.       ::AfxGetResourceHandle(),
  403.       MAKEINTRESOURCE(IDB_TREE),
  404.       13, // XXX hardcoded
  405.       0,
  406.       RGB(255,0,255));
  407.     int   dummy;
  408.     ::ImageList_GetIconSize(x->tree_icons,&x->ticon_w,&dummy);
  409.   }
  411.   // select our font
  412.   HGDIOBJ   obj=NULL;
  413.   if (x->font)
  414.     obj=::SelectObject(hDC,x->font);
  416.   // get client rect
  417.   RECT cli;
  418.   ::GetClientRect(x->hWnd,&cli);
  420.   // get update rect
  421.   RECT dirty;
  422.   if (!::GetUpdateRect(x->hWnd,&dirty,FALSE))
  423.     dirty=cli;
  425.   // shift update rect to (0,0)
  426.   dirty.top-=cli.top;
  427.   dirty.bottom-=cli.top;
  428.   dirty.left-=cli.left;
  429.   dirty.right-=cli.left;
  431.   // repaint all items from top to bottom
  432.   int top=(x->top_offset+dirty.top)/x->item_height;
  433.   int bottom=(x->top_offset+dirty.bottom-1)/x->item_height;
  434.   cli.top+=top*x->item_height-x->top_offset;
  435.   for (int i=top;i<=bottom;++i,cli.top+=x->item_height) {
  436.     cli.bottom=cli.top+x->item_height;
  437.     if (i>=0 && i<x->visible_items)
  438.       XLB_PaintItem(x,XLB_GetIFromV(x,i),i,hDC,cli);
  439.     else {
  440.       // draw a blank rectangle
  441.       ::SetBkColor(hDC,COLOR1);
  442.       ::ExtTextOut(hDC,cli.left,cli.top,ETO_OPAQUE,&cli,NULL,0,NULL);
  443.     }
  444.   }
  446.   // restore font
  447.   if (obj)
  448.     ::SelectObject(hDC,obj);
  449. }
  451. static void   XLB_InitFont(XLB *x,HDC hDC) {
  452.   LOGFONT lf;
  454.   memset(&lf,0,sizeof(lf));
  455.   lf.lfHeight=-(DEFAULT_FONT_SIZE*GetDeviceCaps(hDC,LOGPIXELSY))/96;
  456.   lf.lfWeight=FW_BOLD;
  457.   lf.lfCharSet=ANSI_CHARSET;
  458.   lf.lfOutPrecision=OUT_DEFAULT_PRECIS;
  459.   lf.lfClipPrecision=CLIP_DEFAULT_PRECIS;
  460. #ifdef _WIN32_WCE
  461.   lf.lfQuality=CLEARTYPE_QUALITY;
  462. #else
  463.   lf.lfQuality=DEFAULT_QUALITY;
  464. #endif
  465.   _tcscpy(lf.lfFaceName,_T("Tahoma"));
  467.   x->font=::CreateFontIndirect(&lf);
  469.   TEXTMETRIC tm;
  470.   HGDIOBJ obj=::SelectObject(hDC,x->font);
  471.   ::GetTextMetrics(hDC,&tm);
  472.   SIZE sz;
  473.   ::GetTextExtentPoint(hDC,_T("..."),3,&sz);
  474.   ::SelectObject(hDC,obj);
  476.   x->line_height=tm.tmAscent+tm.tmDescent;
  477.   x->item_height=x->line_height*2;
  478.   x->dots_width=sz.cx;
  479. }
  481. static void XLB_ScrollTo(XLB *x,int top) {
  482.   int delta=x->top_offset - top;
  484.   x->top_offset=top;
  486.   ::SetScrollPos(x->hWnd,SB_VERT,top,TRUE);
  488.   ::ScrollWindowEx(x->hWnd,0,delta,NULL,NULL,NULL,NULL,SW_INVALIDATE);
  489. }
  491. static void XLB_EnsureVisible2(XLB *x,int item) {
  492.   int v=XLB_GetVFromI(x,item);
  494.   int   cvis=x->scroll_page/x->item_height; // completely visible items
  495.   if (cvis==0)
  496.     cvis=1;
  498.   int item_offset=v*x->item_height-x->top_offset;
  499.   // if the item is not fully visible, then
  500.   // scroll and repaint completely
  501.   if (item_offset<0) {
  502.     x->top_offset=v*x->item_height;
  503.     ::SetScrollPos(x->hWnd,SB_VERT,x->top_offset,TRUE);
  504.   } else if (item_offset+x->item_height>x->scroll_page) {
  505.     x->top_offset=(v-cvis+1)*x->item_height;
  506.     ::SetScrollPos(x->hWnd,SB_VERT,x->top_offset,TRUE);
  507.   }
  508. }
  510. static LRESULT CALLBACK XLB_WndProc(HWND hWnd,UINT uMsg,
  511.     WPARAM wParam,LPARAM lParam)
  512. {
  513.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  514.   int i,j;
  515.   HDC hDC;
  517.   switch (uMsg) {
  518.   case WM_CREATE:
  519.     x=(XLB*)malloc(sizeof(*x));
  520.     if (x==NULL)
  521.       return -1;
  522.     memset(x,0,sizeof(*x));
  523.     ::SetWindowLong(hWnd,0,(LONG)x);
  525.     x->hWnd=hWnd;
  526.     x->selection=-1;
  528.     hDC=::GetDC(hWnd);
  529.     XLB_InitFont(x,hDC);
  530.     ::ReleaseDC(hWnd,hDC);
  532.     break;
  534.   case WM_DESTROY:
  535.     if (x->icons && !x->icons_shared)
  536.       ::ImageList_Destroy(x->icons);
  537.     if (x->tree_icons)
  538.       ::ImageList_Destroy(x->tree_icons);
  539.     if (x->font)
  540.       ::DeleteObject(x->font);
  541.     for (i=0;i<x->num_items;++i) {
  542.       free(x->items[i].text1);
  543.       free(x->items[i].text2);
  544.     }
  545.     free(x->items);
  546.     free(x->vitems);
  547.     free(x);
  548.     break;
  550.   case WM_PAINT: {
  551.     PAINTSTRUCT ps;
  552.     hDC=::BeginPaint(hWnd,&ps);
  553.     XLB_PaintAll(x,hDC);
  554.     ::EndPaint(hWnd,&ps);
  555.     break; }
  557.   case WM_VSCROLL:
  558.     i=-1;
  559.     j=x->visible_items*x->item_height-x->scroll_page;
  560.     switch (LOWORD(wParam)) {
  561.     case SB_BOTTOM:
  562.       i=j;
  563.       break;
  564.     case SB_LINEDOWN:
  565.       i=min(x->top_offset+x->item_height,j);
  566.       break;
  567.     case SB_LINEUP:
  568.       i=max(x->top_offset-x->item_height,0);
  569.       break;
  570.     case SB_PAGEDOWN:
  571.       i=min(x->top_offset+x->scroll_page,j);
  572.       break;
  573.     case SB_PAGEUP:
  574.       i=max(x->top_offset-x->scroll_page,0);
  575.       break;
  576.     case SB_THUMBPOSITION:
  577.     case SB_THUMBTRACK: {
  578.       SCROLLINFO si;
  579.       si.cbSize=sizeof(si);
  580.       si.fMask=SIF_TRACKPOS;
  581.       ::GetScrollInfo(hWnd,SB_VERT,&si);
  582.       i=min(si.nTrackPos,j);
  583.       break; }
  584.     case SB_TOP:
  585.       i=0;
  586.       break;
  587.     }
  588.     if (i>=0 && i<=j && i!=x->top_offset)
  589.       XLB_ScrollTo(x,i);
  590.     break;
  592.   case WM_KEYDOWN:
  593.     i=-1;
  594.     j=XLB_GetVFromI(x,x->selection);
  595.     switch (wParam) {
  596.     case VK_RIGHT: case VK_ADD:
  597.       // expand item
  598.       if (x->flags & XLF_TREE && x->selection>=0 &&
  599. x->items[x->selection].flags & XIF_COLLAPSED &&
  600. XLB_HasChildren(x,x->selection))
  601.       {
  602. x->items[x->selection].flags &= ~XIF_COLLAPSED;
  603. XLB_UpdateVisibleItems(x);
  604. XLB_UpdateScrollbar(x);
  605. ::InvalidateRect(x->hWnd,NULL,FALSE);
  606.       }
  607.       return 0;
  608.     case VK_LEFT: case VK_SUBTRACT:
  609.       // collapse item
  610.       if (x->flags & XLF_TREE && x->selection>=0 &&
  611. !(x->items[x->selection].flags & XIF_COLLAPSED) &&
  612. XLB_HasChildren(x,x->selection))
  613.       {
  614. x->items[x->selection].flags |= XIF_COLLAPSED;
  615. XLB_UpdateVisibleItems(x);
  616. XLB_UpdateScrollbar(x);
  617. ::InvalidateRect(x->hWnd,NULL,FALSE);
  618.       }
  619.       return 0;
  620.     case VK_UP:
  621.       i=j-1;
  622.       break;
  623.     case VK_DOWN:
  624.       i=j+1;
  625.       break;
  626.     case VK_PRIOR:
  627.       i=max(j-(x->scroll_page+x->item_height-1)/x->item_height,0);
  628.       break;
  629.     case VK_NEXT:
  630.       i=min(j+(x->scroll_page+x->item_height-1)/x->item_height,x->visible_items-1);
  631.       break;
  632.     case VK_HOME:
  633.       i=0;
  634.       break;
  635.     case VK_END:
  636.       i=x->visible_items-1;
  637.       break;
  638.     }
  639.     if (i>=0 && i<x->visible_items && i!=j) {
  640.       j=i*x->item_height-x->top_offset;
  641.       // if the item is not fully visible, then
  642.       // scroll and repaint completely
  643.       if (j<0 || j+x->item_height>x->scroll_page) {
  644. x->selection=XLB_GetIFromV(x,i);
  645. XLB_EnsureVisible2(x,x->selection);
  646. ::InvalidateRect(x->hWnd,NULL,FALSE);
  647.       } else
  648. XLB_SetSelection(hWnd,XLB_GetIFromV(x,i));
  649.     }
  650.     break;
  652.   case WM_LBUTTONDOWN:
  653.     i=(HIWORD(lParam)+x->top_offset)/x->item_height;
  654.     if (i>=0 && i<x->visible_items) {
  655.       j=XLB_GetIFromV(x,i);
  656.       XLB_SetSelection(hWnd,j);
  658.       // if we are in tree mode and hit a control icon,
  659.       // then collapse/uncollapse an item
  660.       if (x->flags & XLF_TREE && x->tree_icons) {
  661. int   iw,ih;
  662. ::ImageList_GetIconSize(x->tree_icons,&iw,&ih);
  664. if (LOWORD(lParam) < x->items[j].level*INDENT_PER_LEVEL + iw &&
  665.     XLB_HasChildren(x,j))
  666. {
  667.   x->items[j].flags ^= XIF_COLLAPSED;
  668.   XLB_UpdateVisibleItems(x);
  669.   XLB_UpdateScrollbar(x);
  670.   ::InvalidateRect(x->hWnd,NULL,FALSE);
  671. }
  672.       }
  673. #if POCKETPC
  674.       SHRGINFO shrg;
  675.       memset(&shrg,0,sizeof(shrg));
  676.       shrg.cbSize=sizeof(shrg);
  677.       shrg.hwndClient=hWnd;
  678.       shrg.ptDown.x=LOWORD(lParam);
  679.       shrg.ptDown.y=HIWORD(lParam);
  680.       shrg.dwFlags=SHRG_RETURNCMD;
  681.       if (SHRecognizeGesture(&shrg)==GN_CONTEXTMENU)
  682. ::SendMessage(::GetParent(hWnd),XLM_CONTEXTMENU,lParam,(LPARAM)hWnd);
  683. #endif
  684.     }
  685.     break;
  687.   case WM_LBUTTONUP:
  688.     i=(HIWORD(lParam)+x->top_offset)/x->item_height;
  689.     if (i>=0 && i<x->visible_items && x->selection>=0)
  690.       ::SendMessage(::GetParent(hWnd),XLM_CLICK,lParam,(LPARAM)hWnd);
  691.     break;
  693.   case WM_RBUTTONDOWN:
  694.     i=(HIWORD(lParam)+x->top_offset)/x->item_height;
  695.     if (i>=0 && i<x->visible_items) {
  696.       XLB_SetSelection(hWnd,XLB_GetIFromV(x,i));
  697.       ::SendMessage(::GetParent(hWnd),XLM_CONTEXTMENU,lParam,(LPARAM)hWnd);
  698.     }
  699.     break;
  701.   case WM_LBUTTONDBLCLK:
  702.     i=(HIWORD(lParam)+x->top_offset)/x->item_height;
  703.     if (i>=0 && i<x->visible_items)
  704.       ::SendMessage(::GetParent(hWnd),XLM_DBLCLK,lParam,(LPARAM)hWnd);
  705.     break;
  707.   case WM_GETDLGCODE:
  708.     return DLGC_WANTARROWS | DLGC_WANTCHARS;
  710. #if defined(WM_MOUSEWHEEL) && defined(SPI_GETWHEELSCROLLLINES) && defined(WHEEL_DELTA)
  711.   case WM_MOUSEWHEEL: {
  712.     UINT    lines=3;
  713.     ::SystemParametersInfo(SPI_GETWHEELSCROLLLINES,0,&lines,0);
  714.     int     scrl=(short)HIWORD(wParam)*(int)lines*x->item_height;
  715.     scrl/=WHEEL_DELTA;
  716.     j=x->visible_items*x->item_height-x->scroll_page;
  717.     i=max(min(x->top_offset-scrl,j),0);
  718.     if (i!=x->top_offset)
  719.       XLB_ScrollTo(x,i);
  720.     break; }
  721. #endif
  723.   default:
  724.     return ::DefWindowProc(hWnd,uMsg,wParam,lParam);
  725.   }
  727.   return 0;
  728. }
  730. void  XLB_SetImageList(HWND hWnd,HIMAGELIST hIml,bool shared) {
  731.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  732.   if (!x)
  733.     return;
  735.   if (x->icons && !x->icons_shared)
  736.     ::ImageList_Destroy(x->icons);
  738.   x->icons=hIml;
  739.   x->icons_shared=shared;
  741.   if (hIml) {
  742.     int     dummy;
  743.     ::ImageList_GetIconSize(hIml,&x->uicon_w,&dummy);
  744.     x->uicon_w+=UICON_PAD*2;
  745.   } else
  746.     x->uicon_w=0;
  747. }
  749. void  XLB_UpdateScrollbar(XLB *x) {
  750.   RECT   rc;
  751.   ::GetClientRect(x->hWnd,&rc);
  753.   x->scroll_page=rc.bottom-rc.top;
  755.   SCROLLINFO  si;
  756.   memset(&si,0,sizeof(si));
  757.   si.cbSize=sizeof(si);
  759.   si.fMask=SIF_PAGE|SIF_RANGE;
  760.   si.nMin=0;
  761.   si.nMax=x->visible_items*x->item_height-1;
  762.   if (si.nMax<x->scroll_page) {
  763.     si.nMax=0;
  764.     si.nPage=0;
  765.   } else
  766.     si.nPage=x->scroll_page;
  767.   ::SetScrollInfo(x->hWnd,SB_VERT,&si,TRUE);
  768. }
  770. struct XLB_Handle *XLB_GetHandle(HWND hWnd) {
  771.   return (XLB_Handle *)::GetWindowLong(hWnd,0);
  772. }
  774. bool  XLB_AppendItem(struct XLB_Handle *handle,
  775.      const TCHAR *text1,const TCHAR *text2,
  776.      int icon,int level,
  777.      LONG user_data)
  778. {
  779.   XLB *x=(XLB*)handle;
  781.   if (!x)
  782.     return false;
  784.   if (x->num_items >= x->max_items && !XLB_GrowList(x))
  785.     return false;
  787.   XLBItem *ii=&x->items[x->num_items];
  789.   ii->text1=ii->text2=NULL;
  791.   if (text1) {
  792.     ii->text1=_tcsdup(text1);
  793.     if (ii->text1==NULL)
  794.       return false;
  795.   }
  797.   if (text2) {
  798.     ii->text2=_tcsdup(text2);
  799.     if (ii->text2==NULL) {
  800.       free(ii->text1);
  801.       return false;
  802.     }
  803.   }
  805.   ii->icon_index=icon;
  806.   ii->level=level;
  807.   ii->user_data=user_data;
  808.   ii->flags=0;
  810.   x->num_items++;
  812.   return true;
  813. }
  815. int XLB_GetSelection(HWND hWnd) {
  816.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  818.   if (!x)
  819.     return -1;
  821.   return x->selection;
  822. }
  824. static void XLB_GetItemRect(XLB *x,int item,RECT& r) {
  825.   memset(&r,0,sizeof(r));
  827.   if (item<0 || item>=x->num_items)
  828.     return;
  830.   item=XLB_GetVFromI(x,item);
  832.   if (item<0)
  833.     return;
  835.   ::GetClientRect(x->hWnd,&r);
  837.   r.top+=x->item_height*item;
  838.   r.top-=x->top_offset;
  839.   r.bottom=r.top+x->item_height;
  840. }
  842. static void XLB_InvalidateItem(XLB *x,int item) {
  843.   RECT   ri;
  845.   XLB_GetItemRect(x,item,ri);
  846.   ::InvalidateRect(x->hWnd,&ri,FALSE);
  847. }
  849. void XLB_SetSelection(HWND hWnd,int sel) {
  850.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  852.   if (!x || sel<0 || sel>=x->num_items || sel==x->selection)
  853.     return;
  855.   if (XLB_GetVFromI(x,sel)<0) {
  856.     XLB_Restore(x,sel);
  857.     XLB_UpdateScrollbar(x);
  858.   }
  860.   if (x->selection!=-1)
  861.     XLB_InvalidateItem(x,x->selection);
  862.   if (sel!=-1)
  863.     XLB_InvalidateItem(x,sel);
  865.   x->selection=sel;
  866. }
  868. int XLB_GetItemCount(HWND hWnd) {
  869.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  871.   if (!x)
  872.     return 0;
  874.   return x->num_items;
  875. }
  877. LONG XLB_GetData(HWND hWnd,int item) {
  878.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  880.   if (!x || item<0 || item>=x->num_items)
  881.     return 0;
  883.   return x->items[item].user_data;
  884. }
  886. void XLB_EnsureVisible(HWND hWnd,int item,bool middle) {
  887.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  889.   if (!x || item<0 || item>=x->num_items)
  890.     return;
  892.   int v=XLB_GetVFromI(x,item);
  894.   if (v<0) { // item is not currently visble
  895.     XLB_Restore(x,item);
  896.     XLB_UpdateScrollbar(x);
  897.     v=XLB_GetVFromI(x,item);
  898.   }
  900.   int   cvis=x->scroll_page/x->item_height; // completely visible items
  901.   if (cvis==0)
  902.     cvis=1;
  904.   if (middle) { // scroll the view so the item is in the middle
  905.     int   new_offset=(v-cvis/2)*x->item_height;
  906.     if (new_offset+x->scroll_page > x->visible_items*x->item_height)
  907.       new_offset=x->visible_items*x->item_height - x->scroll_page;
  908.     if (new_offset<0)
  909.       new_offset=0;
  911.     if (x->top_offset != new_offset)
  912.       XLB_ScrollTo(x,new_offset);
  913.     return;
  914.   }
  916.   int item_offset=v*x->item_height-x->top_offset;
  917.   // if the item is not fully visible, then
  918.   // scroll and repaint completely
  919.   if (item_offset<0)
  920.     XLB_ScrollTo(x,v*x->item_height);
  921.   else if (item_offset+x->item_height>x->scroll_page)
  922.     XLB_ScrollTo(x,(v-cvis+1)*x->item_height);
  923. }
  925. // TODO: avoid unneeded redraws
  926. void XLB_DeleteItem(HWND hWnd,int item) {
  927.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  929.   if (!x || item<0 || item>=x->num_items)
  930.     return;
  932.   free(x->items[item].text1);
  933.   free(x->items[item].text2);
  935.   memmove(&x->items[item],&x->items[item+1],sizeof(XLBItem)*(x->num_items-item-1));
  937.   x->num_items--;
  939.   if (x->selection>=x->num_items)
  940.     x->selection=x->num_items-1;
  942.   XLB_UpdateVisibleItems(x);
  944.   XLB_EnsureVisible(hWnd,x->selection);
  945.   ::InvalidateRect(hWnd,NULL,FALSE);
  946.   XLB_UpdateScrollbar(x);
  947. }
  949. void XLB_SetItemText1(HWND hWnd,int item,const TCHAR *text) {
  950.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  952.   if (!x || item<0 || item>=x->num_items)
  953.     return;
  955.   free(x->items[item].text1);
  956.   x->items[item].text1=_tcsdup(text);
  958.   XLB_InvalidateItem(x,item);
  959. }
  961. void XLB_DeleteAllItems(HWND hWnd) {
  962.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  964.   if (!x)
  965.     return;
  967.   for (int i=0;i<x->num_items;++i) {
  968.     free(x->items[i].text1);
  969.     free(x->items[i].text2);
  970.   }
  972.   x->num_items=0;
  973.   x->visible_items=0;
  974.   x->selection=-1;
  975.   x->top_offset=0;
  976.   ::SetScrollPos(hWnd,SB_VERT,0,TRUE);
  977.   XLB_UpdateScrollbar(x);
  978. }
  980. void  XLB_UpdateState(HWND hWnd) {
  981.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  983.   if (!x)
  984.     return;
  986.   XLB_UpdateVisibleItems(x);
  987.   XLB_UpdateScrollbar(x);
  988. }
  990. void  XLB_CollapseLevel(HWND hWnd,int level) {
  991.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  993.   if (!x)
  994.     return;
  996.   if (level<0)
  997.     level = 0x7fffffff; // XXX should be maxint
  999.   XLBItem *ii=x->items;
  1000.   XLBItem *jj=ii+x->num_items;
  1002.   while (ii<jj) {
  1003.     if (ii->level >= level)
  1004.       ii->flags |= XIF_COLLAPSED;
  1005.     else
  1006.       ii->flags &= ~XIF_COLLAPSED;
  1007.     ++ii;
  1008.   }
  1010.   if (x->top_offset >= x->visible_items)
  1011.     x->top_offset = 0; // XXX can do something better
  1013.   XLB_UpdateState(hWnd);
  1014.   ::InvalidateRect(hWnd,NULL,FALSE); // XXX can be avoided sometimes
  1015. }
  1017. // custom sort function
  1018. static int  compare_items(const void *v1,const void *v2) {
  1019.   const XLBItem *i1=(XLBItem*)v1;
  1020.   const XLBItem *i2=(XLBItem*)v2;
  1022.   int   i=i1->user_data-i2->user_data;
  1023.   if (i!=0)
  1024.     return i;
  1025.   bool e1=!i1->text1 || !*i1->text1;
  1026.   bool e2=!i2->text1 || !*i2->text1;
  1027.   if (e1)
  1028.     return e2 ? 0 : -1;
  1029.   if (e2)
  1030.     return 1;
  1031.   return CmpI(i1->text1,i2->text1);
  1032. }
  1034. void XLB_SortItems(HWND hWnd) {
  1035.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  1037.   if (!x)
  1038.     return;
  1040.   qsort(x->items,x->num_items,sizeof(XLBItem),compare_items);
  1041. }
  1043. const TCHAR *XLB_GetItemText1(HWND hWnd,int item) {
  1044.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  1046.   if (!x || item<0 || item>=x->num_items)
  1047.     return NULL;
  1049.   return x->items[item].text1;
  1050. }
  1052. void XLB_SetGTFunc(HWND hWnd,XLB_GetText fn,void *ugtdata) {
  1053.   XLB *x=(XLB*)::GetWindowLong(hWnd,0);
  1055.   if (!x)
  1056.     return;
  1058.   x->gtf=fn;
  1059.   x->gtdata=ugtdata;
  1060. }
  1063. void   XLB_Init() {
  1064.   WNDCLASS    wc;
  1066.   memset(&wc,0,sizeof(wc));
  1068.   wc.style=CS_DBLCLKS|CS_HREDRAW|CS_VREDRAW;
  1069.   wc.lpfnWndProc=XLB_WndProc;
  1070.   wc.cbWndExtra=sizeof(XLB*);
  1071.   wc.hInstance=::GetModuleHandle(NULL);
  1072.   // assume the SDK always defines this via macro
  1073. #if defined(LoadCursor)
  1074.   wc.hCursor=::LoadCursor(NULL,IDC_ARROW);
  1075. #endif
  1076.   wc.lpszClassName=_T("XListBox");
  1078.   ATOM cls=::RegisterClass(&wc);
  1079. }