home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ool.zip / OOL / source / xevent.cpp < prev    next >
C/C++ Source or Header  |  1997-04-05  |  27KB  |  998 lines

  1. #include "XCntrevn.h"
  2. #include "XDragEvn.h"
  3. #include "XWindow.h"
  4. #include "XPoint.h"
  5. #include "XBitmap.h"
  6. #include "XDragItm.h"
  7. #include "XMousevn.h"
  8. #include "XCntEvnt.h"
  9. #include "XKeyEvnt.h"
  10. #include "XContObj.h"
  11. #include "XcnDrEvn.h"
  12. #include "XCnEdEvn.h"
  13. #include "xString.h"
  14. #include "XContCol.h"
  15. #include "XItmDEvn.h"
  16. #include "XBackEvn.h "
  17.  
  18.  
  19. #include <stdlib.h>
  20.  
  21. #ifdef OOL_FOR_OS2_X86
  22. #define GBN_BUTTONUP      0x0524
  23. #define GBN_BUTTONDOWN    0x0525
  24. #endif
  25.  
  26.  
  27. /*@ XContainerEvent::GetObject(void)
  28. @remarks Returns the object which posted the event
  29. @returns       XContainerObject * the Object (can be NULL)
  30. */
  31. XContainerObject * XContainerEvent::GetObject(void)
  32. {
  33.     if (core)
  34.     {
  35.         RECORDCORE *pr = (RECORDCORE *) ((PBYTE) core + sizeof(RECORDCORE));
  36.         XContainerObject *obj;
  37.  
  38.         memcpy(&obj, pr, 4);
  39.         return obj;
  40.     }
  41.     else
  42.         return NULL;
  43. }
  44.  
  45.  
  46. XContainerEvent :: XContainerEvent(const XContainerControl * w, const MPARAM mp1, const MPARAM mp2):XControlEvent(SHORT2FROMMP(mp1))
  47. {
  48.     core = NULL;
  49.  
  50.     if (mp1)
  51.     {
  52.         windowID = SHORT1FROMMP(mp1);
  53.         window = (XWindow *) w;
  54.     }
  55.  
  56.     if (!window)
  57.         return;
  58.  
  59.     eventID = SHORT2FROMMP(mp1);
  60.  
  61.     switch (eventID)
  62.     {
  63.     case CN_EMPHASIS:
  64.         core = ((PNOTIFYRECORDEMPHASIS) mp2)->pRecord;
  65.         break;
  66.     case CN_ENTER:
  67.         core = ((NOTIFYRECORDENTER *) mp2)->pRecord;
  68.         break;
  69.     case CN_INITDRAG:
  70.         core = ((CNRDRAGINIT *) mp2)->pRecord;
  71.         break;
  72.     default:
  73.         core = (PRECORDCORE) mp2;
  74.     }
  75. }
  76.  
  77.  
  78. XContainerEditEvent :: XContainerEditEvent(const XWindow * w, const MPARAM mp1, const MPARAM mp2):XContainerEvent((XContainerControl *) w, mp1, mp2)
  79. {
  80.     cnEdit = (CNREDITDATA *) mp2;
  81.     core = cnEdit->pRecord;
  82. }
  83.  
  84.  
  85.  
  86. /*@ XContainerEditEvent::GetObject(void)
  87. @remarks Returns a pointer to the object which is edited;
  88. @returns XContainerObject * theObject
  89. */
  90. XContainerObject * XContainerEditEvent::GetObject(void)
  91. {
  92.     RECORDCORE *pr = (RECORDCORE *) ((PBYTE) cnEdit->pRecord + sizeof(RECORDCORE));
  93.     XContainerObject *obj;
  94.  
  95.     memcpy(&obj, pr, 4);
  96.     return obj;
  97. }
  98.  
  99.  
  100. XContainerDragEvent :: XContainerDragEvent(const XWindow * w, const MPARAM mp1, const MPARAM mp2):XContainerEvent((XContainerControl *) w, mp1, mp2)
  101. {
  102.     printer = NULL;
  103.     if (mp2)
  104.     {
  105.         core = ((CNRDRAGINFO *) mp2)->pRecord;
  106.         dragInfo = ((CNRDRAGINFO *) mp2)->pDragInfo;
  107.     }
  108. }
  109.  
  110.  
  111. BOOL XContainerDragEvent::GetDropPos(XPoint * p)
  112. {
  113.     if ((!(dragInfo)) || eventID != DRG_DROP)
  114.         return FALSE;
  115.     p->Set(dragInfo->xDrop, dragInfo->yDrop);
  116.     return TRUE;
  117. }
  118.  
  119.  
  120. XContainerDragEvent :: ~XContainerDragEvent()
  121. {
  122.     if (dragInfo)
  123.         DrgFreeDraginfo(dragInfo);
  124.     dragInfo = NULL;
  125. }
  126.  
  127.  
  128. BOOL XContainerDragEvent::GetDragItem(XDragItem * itm, const SHORT index)
  129. {
  130.     if (!(dragInfo))
  131.         return FALSE;
  132.     if (index > dragInfo->cditem)
  133.         return FALSE;
  134.  
  135.     DRAGITEM *pItem = DrgQueryDragitemPtr(dragInfo, index);
  136.  
  137.     itm->item = pItem;
  138.     return TRUE;
  139. }
  140.  
  141.  
  142. XControlEvent :: XControlEvent(XWindow * w, const void *mp1, const void *mp2)
  143. {
  144.     windowID = SHORT1FROMMP(mp1);
  145.     window = w->GetWindow(windowID);
  146.     if (!window)
  147.         return;
  148.  
  149.     char str[5];
  150.  
  151.     WinQueryClassName(window->GetHandle(), 5, (PCH) str);
  152.     str[0] = ' ';
  153.     SHORT type = atol(str);
  154.  
  155.     switch (type)
  156.     {
  157.     case 2:                    // Combo
  158.         switch (SHORT2FROMMP(mp1))
  159.         {
  160.         case CBN_LBSELECT:
  161.             eventID = WIN_SELECTED;
  162.             break;
  163.         case CBN_ENTER:
  164.             eventID = WIN_ENTER;
  165.             break;
  166.         case CBN_LBSCROLL:
  167.             eventID = WIN_VSCROLL;
  168.             break;
  169.         case CBN_EFSCROLL:
  170.             eventID = WIN_HSCROLL;
  171.             break;
  172.         case CBN_SHOWLIST:
  173.             eventID = WIN_SHOWLIST;
  174.             break;
  175.         case CBN_EFCHANGE:
  176.             eventID = WIN_CHANGED;
  177.             break;
  178.         }
  179.         break;
  180.     case 3:                    // Button
  181.         if (SHORT2FROMMP(mp1) == BN_CLICKED)
  182.             eventID = WIN_CHANGED;
  183.         break;
  184.     case 6:                    // Entry
  185.         switch (SHORT2FROMMP(mp1))
  186.         {
  187.         case EN_CHANGE:
  188.             eventID = WIN_CHANGED;
  189.             break;
  190.         case EN_SCROLL:
  191.             eventID = WIN_HSCROLL;
  192.             break;
  193.         case EN_SETFOCUS:
  194.             eventID = WIN_SETFOCUS;
  195.             break;
  196.         case EN_KILLFOCUS:
  197.             eventID = WIN_KILLFOCUS;
  198.             break;
  199.         }
  200.         break;
  201.     case 7:                    // Listbox
  202.         switch (SHORT2FROMMP(mp1))
  203.         {
  204.         case LN_SELECT:
  205.             eventID = WIN_SELECTED;
  206.             break;
  207.         case LN_ENTER:
  208.             eventID = WIN_ENTER;
  209.             break;
  210.         case LN_SCROLL:
  211.             eventID = WIN_HSCROLL;
  212.             break;
  213.         case LN_SETFOCUS:
  214.             eventID = WIN_SETFOCUS;
  215.             break;
  216.         case LN_KILLFOCUS:
  217.             eventID = WIN_KILLFOCUS;
  218.             break;
  219.         }
  220.         break;
  221.     case 10:                    // MLE
  222.         switch (SHORT2FROMMP(mp1))
  223.         {
  224.         case MLN_CHANGE:
  225.             eventID = WIN_CHANGED;
  226.             break;
  227.         case MLN_VSCROLL:
  228.             eventID = WIN_VSCROLL;
  229.             break;
  230.         case MLN_HSCROLL:
  231.             eventID = WIN_HSCROLL;
  232.             break;
  233.         case MLN_SETFOCUS:
  234.             eventID = WIN_SETFOCUS;
  235.             break;
  236.         case MLN_KILLFOCUS:
  237.             eventID = WIN_KILLFOCUS;
  238.             break;
  239.         }
  240.         break;
  241.     case 32:                    // SpinButton
  242.         switch (SHORT2FROMMP(mp1))
  243.         {
  244.         case SPBN_CHANGE:
  245.             eventID = WIN_CHANGED;
  246.             break;
  247.         case SPBN_SETFOCUS:
  248.             eventID = WIN_SETFOCUS;
  249.             break;
  250.         case SPBN_KILLFOCUS:
  251.             eventID = WIN_KILLFOCUS;
  252.             break;
  253.         case SPBN_UPARROW:
  254.             eventID = WIN_UPARROW;
  255.             break;
  256.         case SPBN_DOWNARROW:
  257.             eventID = WIN_DOWNARROW;
  258.             break;
  259.         case SPBN_ENDSPIN:
  260.             eventID = WIN_ENDTRACK;
  261.             break;
  262.         }
  263.         break;
  264.     case 37:
  265.         switch (SHORT2FROMMP(mp1))
  266.         {
  267.         case CN_KILLFOCUS:
  268.             eventID = WIN_KILLFOCUS;
  269.             break;
  270.         case CN_SETFOCUS:
  271.             eventID = WIN_SETFOCUS;
  272.             break;
  273.         }
  274.         break;
  275.     case 38:                    // Slider
  276.         switch (SHORT2FROMMP(mp1))
  277.         {
  278.         case SLN_CHANGE:
  279.             eventID = WIN_CHANGED;
  280.             break;
  281.         case SLN_SETFOCUS:
  282.             eventID = WIN_SETFOCUS;
  283.             break;
  284.         case SLN_KILLFOCUS:
  285.             eventID = WIN_KILLFOCUS;
  286.             break;
  287.         case SLN_SLIDERTRACK:
  288.             eventID = WIN_TRACK;
  289.             break;
  290.         }
  291.         break;
  292.     case 39:                    // Valueset
  293.         switch (SHORT2FROMMP(mp1))
  294.         {
  295.         case VN_SELECT:
  296.             eventID = WIN_SELECTED;
  297.             break;
  298.         case VN_ENTER:
  299.             eventID = WIN_ENTER;
  300.             break;
  301.         case VN_SETFOCUS:
  302.             eventID = WIN_SETFOCUS;
  303.             break;
  304.         case VN_KILLFOCUS:
  305.             eventID = WIN_KILLFOCUS;
  306.             break;
  307.         }
  308.         break;
  309.     case 64:                    // GraphicButton
  310.         switch (SHORT2FROMMP(mp1))
  311.         {
  312.         case GBN_BUTTONDOWN:
  313.         case GBN_BUTTONUP:
  314.             eventID = WIN_CHANGED;
  315.             break;
  316.         }
  317.         break;
  318.     case 65:                    // CircularSlider
  319.         switch (SHORT2FROMMP(mp1))
  320.         {
  321.         case CSN_CHANGED:
  322.             eventID = WIN_CHANGED;
  323.             break;
  324.         case CSN_SETFOCUS:
  325.             {
  326.                 BOOL e = (BOOL) mp2;
  327.  
  328.                 if (e)
  329.                     eventID = WIN_SETFOCUS;
  330.                 else
  331.                     eventID = WIN_KILLFOCUS;
  332.             }
  333.             break;
  334.         case CSN_TRACKING:
  335.             eventID = WIN_TRACK;
  336.             break;
  337.         }
  338.     }
  339.     window->DoControl(this);
  340. }
  341.  
  342.  
  343. /*@ 
  344. @class XDragEvent
  345. @parent XEvent
  346. @type overview
  347. @symbol _
  348. @remarks Drag/drop events generate a XDragEvent, you catch them with XDragHandler.
  349. If drag-events should be cought in a container-control use XContainerDragEvent / XContainerHandler.
  350. */
  351.  
  352.  
  353. /*@ XDragEvent::SetAcceptMode()
  354. @remarks Set the operation supported by the application which receives
  355. the drag-event
  356. @parameters    SHORT accept              the opperation, possible values are
  357.                                                         <t '°' c=2>
  358.                                              °DRG_DROP       °accept the items
  359.                                              °DRG_NODROP     °dont accept the items in this case
  360.                                              °DRG_NEVERDROP  °never accept the items
  361.                                                         </t>
  362. */
  363.  
  364.  
  365. /*@ XDragEvent::SetOperation()
  366. @remarks Set the operation supported by the application which generates
  367. the drag-event
  368. @parameters    SHORT operation           the opperation, possible values are
  369.                                                         <t '°' c=2>
  370.                                              °DRG_COPY   °copy the items
  371.                                              °DRG_MOVE   °move the items
  372.                                              °DRG_LINK   °link the items
  373.                                                         </t>
  374. */
  375.  
  376.  
  377. XDragEvent :: ~XDragEvent()
  378. {
  379.     if (dragInfo)
  380.         DrgFreeDraginfo(dragInfo);
  381.     dragInfo = NULL;
  382. }
  383.  
  384.  
  385. XDragEvent :: XDragEvent(const LONG event, const void *v)
  386. {
  387.     printer = NULL;
  388.     switch (event)
  389.     {
  390.     case DM_DROP:
  391.         eventID = DRG_DROPPED;
  392.         break;
  393.     case DM_DRAGOVER:
  394.         eventID = DRG_DRAGOVER;
  395.         break;
  396.     case DM_DISCARDOBJECT:
  397.         eventID = DRG_DISCARDOBJECT;
  398.         break;
  399.     case DM_ENDCONVERSATION:
  400.         eventID = DRG_ENDCONVERSATION;
  401.         break;
  402.     }
  403.  
  404.     dragInfo = NULL;
  405.     DRAGINFO *info = (DRAGINFO *) v;
  406.  
  407.     if (DrgAccessDraginfo(info))
  408.         dragInfo = info;
  409.     accept = DRG_NODROP;
  410.     operation = 0;
  411. }
  412.  
  413.  
  414. /*@ XDragEvent::GetDropPos()
  415. @remarks Query the position where the objects were dropped
  416. @parameters    XPoint * position         buffer which will get the position
  417. */
  418. BOOL XDragEvent::GetDropPos(XPoint * p)
  419. {
  420.     if ((!(dragInfo)) || eventID != DRG_DROP)
  421.         return FALSE;
  422.     p->Set(dragInfo->xDrop, dragInfo->yDrop);
  423.     return TRUE;
  424. }
  425.  
  426.  
  427. /*@ XDragEvent::GetDragItem()
  428. @remarks Query a dragitem.
  429. @parameters    XDragItem * buffer        buffer which will get the item-information<br>
  430.                SHORT index               zero-based index of item to query
  431. */
  432. BOOL XDragEvent::GetDragItem(XDragItem * itm, const SHORT index)
  433. {
  434.     if (!(dragInfo))
  435.         return FALSE;
  436.     if (index > dragInfo->cditem)
  437.         return FALSE;
  438.  
  439.     DRAGITEM *pItem = DrgQueryDragitemPtr(dragInfo, index);
  440.  
  441.     itm->item = pItem;
  442.     return TRUE;
  443. }
  444.  
  445.  
  446. XMouseEvent :: XMouseEvent(const LONG e, const void *v1, const void *v2)
  447. {
  448.     switch (e)
  449.     {
  450.     case WM_BUTTON1DOWN:
  451.         eventID = MOU_BTN1DOWN;
  452.         break;
  453.     case WM_BUTTON1DBLCLK:
  454.         eventID = MOU_BTN1DBLCLICK;
  455.         break;
  456.     case WM_BUTTON1CLICK:
  457.         eventID = MOU_BTN1CLICK;
  458.         break;
  459.     case WM_BUTTON1UP:
  460.         eventID = MOU_BTN1UP;
  461.         break;
  462.     case WM_BUTTON2DOWN:
  463.         eventID = MOU_BTN2DOWN;
  464.         break;
  465.     case WM_BUTTON2DBLCLK:
  466.         eventID = MOU_BTN2DBLCLICK;
  467.         break;
  468.     case WM_BUTTON2CLICK:
  469.         eventID = MOU_BTN2CLICK;
  470.         break;
  471.     case WM_BUTTON2UP:
  472.         eventID = MOU_BTN2UP;
  473.         break;
  474.     case WM_BUTTON3DOWN:
  475.         eventID = MOU_BTN3DOWN;
  476.         break;
  477.     case WM_BUTTON3DBLCLK:
  478.         eventID = MOU_BTN3DBLCLICK;
  479.         break;
  480.     case WM_BUTTON3CLICK:
  481.         eventID = MOU_BTN3CLICK;
  482.         break;
  483.     case WM_BUTTON3UP:
  484.         eventID = MOU_BTN3UP;
  485.         break;
  486.     default:
  487.         eventID = e;
  488.         break;
  489.     }
  490.  
  491.     p.Set(SHORT1FROMMP(v1), SHORT2FROMMP(v1));
  492.  
  493.     keyboardState = SHORT2FROMMP((MPARAM) v2);
  494. }
  495.  
  496.  
  497. XItemDrawEvent :: XItemDrawEvent(const LONG msg, const void *mp1, const void *mp2, const SHORT t)
  498. {
  499.     type = t;
  500.     eventID = msg;
  501.     windowID = SHORT1FROMMP(mp1);
  502.     item = (POWNERITEM) mp2;
  503.     color = 0;
  504.     textStyle = DT_VCENTER | DT_LEFT;
  505. }
  506.  
  507.  
  508. /*@ XItemDrawEvent::GetObject(void)
  509. @group comtainer-related functions
  510. @remarks Returns the object from which an item must be drawn. Only use
  511. this function in container-controls!
  512. @returns    XContainerObject *   the object
  513. */
  514. XContainerObject * XItemDrawEvent::GetObject(void)
  515. {
  516.     CNRDRAWITEMINFO *info = (CNRDRAWITEMINFO *) item->hItem;
  517.  
  518.     if (!(info->pRecord))
  519.         return NULL;
  520.     RECORDCORE *pr = (RECORDCORE *) ((PBYTE) info->pRecord + sizeof(RECORDCORE));
  521.     XContainerObject *obj;
  522.  
  523.     memcpy(&obj, pr, 4);
  524.     return obj;
  525. }
  526.  
  527.  
  528. /*@ XItemDrawEvent::GetColumn(void)
  529. @group comtainer-related functions
  530. @remarks Returns the column from which an item must be drawn. Only use
  531. this function in container-controls!
  532. @returns    XContainerColumn *   the column
  533. */
  534. XContainerColumn * XItemDrawEvent::GetColumn(void) const
  535. {
  536.     CNRDRAWITEMINFO *info = (CNRDRAWITEMINFO *) item->hItem;
  537.  
  538.     if (info->pFieldInfo)
  539.         return (XContainerColumn *) info->pFieldInfo->pUserData;
  540.     else
  541.         return NULL;
  542. }
  543.  
  544.  
  545. /*@ XItemDrawEvent::DrawItem(const XBitmap * bitmap, const char *title, const BOOL drawOver)
  546. @group drawing
  547. @remarks Draws an item using a bitmap and/or text in
  548. XListBox, XContainerControl and XMenuBar
  549. @parameters <t '°' c=2>
  550.                 °XBitmap * bitmap     °A bitmap to display (can be NULL)
  551.             °char * text          °Text to display (can be NULL)
  552.             °BOOL drawOver        °If FALSE (default) first the bitmap is drawn and the text is drawn right from the bitmap.
  553.                                  If TRUE, the text is drawn over the bitmap.
  554.                 </t>                                            
  555. */
  556. void XItemDrawEvent::DrawItem(const XBitmap * bitmap, const char *title, const BOOL drawOver)
  557. {
  558.     POINTL p;
  559.  
  560.     GpiCreateLogColorTable(item->hps, LCOL_RESET, LCOLF_RGB, 0L, 0L, NULL);
  561.  
  562.     if (type == 4)
  563.         WinFillRect(item->hps, &item->rclItem, SYSCLR_MENU);
  564.     else if (type == 37)
  565.     {
  566.         if (item->fsAttribute & CRA_SELECTED)
  567.             WinFillRect(item->hps, &item->rclItem, SYSCLR_HILITEBACKGROUND);
  568.     }
  569.     else
  570.         WinFillRect(item->hps, &item->rclItem, (item->fsState == 1 ? SYSCLR_HILITEBACKGROUND : SYSCLR_ENTRYFIELD));
  571.  
  572.     if (item->fsAttribute & MIA_HILITED && type == 4)
  573.     {
  574.         GpiSetColor(item->hps, SYSCLR_BUTTONDARK);
  575.         p.x = item->rclItem.xLeft + 2;
  576.         p.y = item->rclItem.yBottom;
  577.         GpiMove(item->hps, &p);
  578.         p.y = item->rclItem.yTop - 1;
  579.         GpiLine(item->hps, &p);
  580.         p.x = item->rclItem.xRight - item->rclItem.xLeft - 1;
  581.         GpiLine(item->hps, &p);
  582.         GpiSetColor(item->hps, SYSCLR_BUTTONLIGHT);
  583.         p.y = item->rclItem.yBottom;
  584.         GpiLine(item->hps, &p);
  585.         p.x = item->rclItem.xLeft + 2;
  586.         GpiLine(item->hps, &p);
  587.  
  588.         item->rclItem.xLeft += 3;
  589.     }
  590.  
  591.     if ((item->fsAttributeOld & MIA_CHECKED || item->fsAttribute & MIA_CHECKED) && type == 4)
  592.     {
  593.         p.y = (item->rclItem.yTop - item->rclItem.yBottom - bitmap->cy) / 2 + item->rclItem.yBottom - (item->fsAttribute & MIA_HILITED ? 2 : 0) + 1;
  594.         p.x = item->rclItem.xLeft;
  595.  
  596.         HBITMAP hb = WinGetSysBitmap(HWND_DESKTOP, SBMP_MENUCHECK);
  597.  
  598.         WinDrawBitmap(item->hps, hb, NULL, (PPOINTL) & p, (item->fsAttribute & MIA_DISABLED ? SYSCLR_MENUDISABLEDTEXT : SYSCLR_OUTPUTTEXT), SYSCLR_MENU, DBM_NORMAL);    // /XColor(COL_PALEGRAY).
  599.                                                                                                                                                                         // GetColor()
  600.         item->fsAttributeOld = (item->fsAttribute &= ~MIA_CHECKED);
  601.         GpiDeleteBitmap(hb);
  602.     }
  603.  
  604.     if (type == 4)
  605.         item->rclItem.xLeft += 14;
  606.  
  607.     if (type == 37)
  608.     {
  609.         if (GetObject() && drawOver == FALSE)
  610.             item->rclItem.xLeft += 12;
  611.     }
  612.     else if (drawOver == FALSE)
  613.         item->rclItem.xLeft += 3;
  614.  
  615.     if (bitmap)
  616.     {
  617.         RECTL rect;
  618.  
  619.         rect.yBottom = (item->rclItem.yTop - item->rclItem.yBottom - bitmap->cy) / 2 + item->rclItem.yBottom - (item->fsAttribute & MIA_HILITED ? 2 : 0) + 1;
  620.         rect.xLeft = item->rclItem.xLeft;
  621.  
  622.         if (type == 4)
  623.             rect.yBottom += 1;
  624.         rect.xRight = rect.xLeft + bitmap->width;
  625.         rect.yTop = rect.yBottom + bitmap->height;
  626.         WinDrawBitmap(item->hps, bitmap->hbm, NULL, (PPOINTL) & rect, 0, 0, DBM_NORMAL | DBM_STRETCH);
  627.     }
  628.  
  629.     if (title)
  630.     {
  631.         if (bitmap && drawOver == FALSE)
  632.             item->rclItem.xLeft += bitmap->cx + 3;
  633.         if (item->fsAttribute & MIA_HILITED && type == 4)
  634.         {
  635.             item->rclItem.yBottom -= 2;
  636.             item->rclItem.yTop -= 2;
  637.         }
  638.         LONG backCol, frontCol;
  639.  
  640.         switch (type)
  641.         {
  642.         case 4:
  643.             backCol = (item->fsAttribute & MIA_DISABLED ? SYSCLR_MENUDISABLEDTEXT : color);
  644.             frontCol = SYSCLR_MENU;
  645.             break;
  646.         case 37:
  647.             backCol = (item->fsAttribute & CRA_SELECTED ? SYSCLR_HILITEFOREGROUND : color);
  648.             frontCol = (item->fsAttribute & CRA_SELECTED ? SYSCLR_HILITEBACKGROUND : SYSCLR_WINDOW);
  649.             break;
  650.         default:
  651.             backCol = (item->fsState == 1 ? SYSCLR_HILITEFOREGROUND : color);
  652.             frontCol = (item->fsState == 1 ? SYSCLR_HILITEBACKGROUND : SYSCLR_ENTRYFIELD);
  653.             break;
  654.         }
  655.         if (textStyle & DT_WORDBREAK)
  656.         {
  657.             int drawn = 0, totalDrawn, length = strlen(title);
  658.             int fontSize = 12;
  659.  
  660.             for (totalDrawn = 0; totalDrawn < length; item->rclItem.yTop -= (LONG) (fontSize * 1.3))
  661.             {
  662.                 drawn = WinDrawText(item->hps, length - totalDrawn, (PSZ) title + totalDrawn, &item->rclItem, backCol, frontCol, textStyle);
  663.                 if (drawn)
  664.                     totalDrawn += drawn;
  665.                 else
  666.                     break;
  667.             }
  668.         }
  669.         else
  670.             WinDrawText(item->hps, strlen(title), (PCH) title, &item->rclItem, backCol, frontCol, textStyle);
  671. /*
  672.         else if(type == 37)
  673.            {
  674.                WinDrawText( item->hps, strlen(title), (PCH) title, &item->rclItem, backCol, , textStyle);
  675.            }
  676.         else
  677.             WinDrawText( item->hps, strlen(title), (PCH) title, &item->rclItem, backCol, (item->fsState == 1 ? SYSCLR_HILITEBACKGROUND : SYSCLR_ENTRYFIELD), textStyle);
  678. */
  679.     }
  680.     if (type != 4)
  681.         item->fsState = item->fsStateOld = 0;
  682.     else
  683.     {
  684.         if (item->fsAttribute & MIA_HILITED)
  685.             item->fsAttribute ^= MIA_HILITED;
  686.         if (item->fsAttributeOld & MIA_HILITED)
  687.             item->fsAttributeOld ^= MIA_HILITED;
  688.     }
  689. }
  690.  
  691.  
  692. /*@ XBackgroundDrawEvent::Draw(const XBitmap * bitmap)
  693. @group drawing
  694. @remarks Draws a bitmap
  695. @parameters XBitmap * bitmap     bitmap to draw
  696. */
  697. void XBackgroundDrawEvent::Draw(const XBitmap * bitmap)
  698. {
  699.     WinDrawBitmap(back->hps, bitmap->GetHandle(), (PRECTL) & back->rclBackground, (PPOINTL) & back->rclBackground, 0, 0, DBM_NORMAL);
  700. }
  701.  
  702.  
  703. ////////////////////////docs only
  704. /*@ XEvent::GetEventID()
  705. @remarks GetEventID return the ID of the event which ocures. Valid
  706. ID∩s are specified by the classes derived from XEvent
  707. @returns      ULONG theEventID
  708. */
  709.  
  710.  
  711.  
  712. /*@ XControlEvent::GetEventID()
  713. @remarks Returns a pointer to the window which has send the event
  714. @returns     LONG id                     the id of the event, see XControlEvent.
  715. */
  716.  
  717.  
  718.  
  719. /*@ XControlEvent::GetWindow()
  720. @remarks Returns a pointer to the window which has send the event
  721. @returns     XWindow * thePointer    the pointer of the sending window, if you
  722.                                      know the window type, you can typecast to
  723.                                      the needed class
  724. */
  725.  
  726.  
  727. /*@ XControlEvent::GetWindowID()
  728. @remarks Returns the ID of the window which has send the event
  729. @returns     LONG theWindowID        the ID of the sending window
  730. */
  731.  
  732.  
  733. /*@ XMouseEvent::GetEventID()
  734. @remarks Returns the ID of the mouse-event. To get a mouse-event you must
  735. register a XMouseHandler!
  736. @returns     LONG theID              the ID of the mouse-event, see XMouseEvent.
  737. */
  738.  
  739.  
  740. /*@ XMouseEvent::GetKeyInfo()
  741. @remarks Returns the state of the keyboard
  742. @returns     SHORT keyInfo           information of the keyboard
  743. */
  744.  
  745.  
  746. /*@ 
  747. @class XContainerEditEvent
  748. @parent XContainerEvent
  749. @type overview
  750. @symbol _
  751. @remarks An XContainerEditEvent is catched with a XContainerHandler. This event occures
  752. if the user edit the text of a container-item.
  753. */
  754.  
  755.  
  756. /*@ XContainerEditEvent :: GetText( XString * s)
  757. @remarks Returns the text of an edited item. On CON_REALLOC
  758. the old text is returned, on CON_ENDEDIT the new text is avaible.
  759. @parameters XString * buffer     buffer to hold the data
  760. */
  761.  
  762.  
  763. /*@ XContainerEditEvent::GetTextSize()
  764. @remarks Returns the length text of the edited text. On CON_REALLOC
  765. you must realloc the buffer which contains the text.
  766. @returns ULONG size
  767. */
  768.  
  769.  
  770. /*@ XContainerEditEvent::GetColumn()
  771. @remarks Returns a pointer to that column in which
  772. an item is edited;
  773. @returns XContainerColumn * theColumn
  774. */
  775.  
  776.  
  777. /*@ 
  778. @class XItemDrawEvent
  779. @parent XEvent
  780. @type overview
  781. @symbol _
  782. @remarks An XItemDrawEvent is catched with a XItemDrawHandler. This event occures
  783. if a listbox, menu or container is set with the style OWNERDRAW. In this case the
  784. items must be drwan by the application.
  785. */
  786.  
  787.  
  788. /*@ XItemDrawEvent::GetItemHandle()
  789. @group item-related
  790. @remarks Returns a handle to the item which must redrawn. Only use
  791. this function in listbox-controls! (There you can set the handle
  792. with XListBox::SetItemhandle() )
  793. @returns    ULONG theHandle
  794. */
  795.  
  796.  
  797. /*@ XItemDrawEvent::GetWindowID()
  798. @group misc
  799. @remarks Returns the ID of the window.
  800. @returns    LONG theID
  801. */
  802.  
  803.  
  804. /*@ XItemDrawEvent::GetItemID()
  805. @group item-related
  806. @remarks Returns the ID of the item to draw. Don∩t use
  807. this function in container-controls! (use XItemDrawEvent::GetObject() and XItemDrawEvent::GetColumn()
  808. to find out what you have to draw )
  809. @returns    LONG theID
  810. */
  811.  
  812.  
  813. /*@ XItemDrawEvent::GetWindowHandle()
  814. @remarks Returns the sytem-define window handle.
  815. @returns    OOL_WINDOWHANDLE handle
  816. */
  817.  
  818.  
  819. /*@ XItemDrawEvent::SetTextColor()
  820. @group colors
  821. @remarks Set the text color for non-selected items
  822. @parameters XColor * color    new color
  823. */
  824.  
  825.  
  826. /*@ XDragEvent::GetDragItemCount()
  827. @remarks Return the count of drag-items of this dragevent
  828. @returns       SHORT                     count of items
  829. */
  830.  
  831.  
  832. /*@ XDragEvent::GetSourceWindow()
  833. @remarks Query the system-define handle of the window where the objects
  834. were dropped.
  835. @returns:       OOL_WINDOWHANDLE          The system-defined window handle.
  836. */
  837.  
  838.  
  839. /*@ 
  840. @class XContainerDragEvent
  841. @parent XContainerEvent
  842. @type overview
  843. @symbol _
  844. @remarks Drag/drop events in a container generate a XContainerDragEvent which is derived
  845. from XContainerEvent and has the same functionality like XDragEvent (see there for
  846. further information).
  847. */
  848.  
  849.  
  850. /*@ XContainerEvent::GetObject()
  851. @remarks Query the object which belongs to the event.
  852. @returns XContainerObject * theObject
  853. */
  854.  
  855.  
  856. /*@ 
  857. @class XContainerEvent
  858. @parent XEvent
  859. @type overview
  860. @symbol _
  861. @remarks Events in a container generate a XContainerEvent, if you want to catch these
  862. events you must generate a XContainerHandler. Possible event-IDs are:
  863. <t '°' 2>
  864.    °CON_BEGINEDIT         °the user start to edit a field
  865.    °CON_COLLAPSTREE       °in tree-view the tree or a part of it is collapsed
  866.    °CON_CONTEXTMENU       °a context-menu is requested
  867.    °CON_DRAGOVER          °one or more objects fly over the container
  868.    °CON_DROP              °one or more objects are dropped
  869.    °CON_EMPHASIS          °the emphasis of an item has changed
  870.    °CON_ENDEDIT           °the user stopped to edit a field
  871.    °CON_ENTER             °ENTER was pressed
  872.    °CON_EXPANDTREE        °in tree-view the tree or a part of it is expanded
  873.    °CON_INITDRAG          °a drag-operation is requested
  874.    °CON_PAINTBACKGOUND    °the background of the container must be redrawn
  875.     °CON_REALLOC                °the user edited text and memory must be reallocated
  876. </t>
  877. which you can get with XEvent::GetEventID(). In the cases of CON_BEGINEDIT, CON_ENDEDIT and CON_REALLOC
  878. a event of the Type XContainerEditEvent is posted, in the case od CON_DROP and CON_DRAGOVER a XContainerDragEvent is posted, you can simple typecast to them.
  879. */
  880.  
  881.  
  882. /*@ 
  883. @class XControlEvent
  884. @parent XEvent
  885. @type overview
  886. @symbol _
  887. @remarks The XControlEvent is send to a XFrameWindow when the user has performed
  888. some interaction with a client window of the frame window. If you have caught the XControlEvent
  889. by overriding XFrameWindow::DoControl you can get information about the sending window
  890. and the type (ID) of the event. Valid event-ID∩s are:
  891. <t '°' 2>
  892.    °WIN_CHANGED          °the content of the client has changed
  893.    °WIN_DBLCLICK         °the user double-clicked on the window
  894.    °WIN_PAINT            °the window will be redrawn
  895.    °WIN_ENTER            °the user pressed ENTER
  896.    °WIN_SELECTED         °an item of the window was selected
  897.    °WIN_VSCROLL          °the window scrolls it contents
  898.    °WIN_HSCROLL          °the window scrolls it contents
  899.    °WIN_SETFOCUS         °the window recieves the focus
  900.    °WIN_KILLFOCUS        °the window lost the focus
  901.    °WIN_SHOWLIST         °the list of a XComboBox will be displayed
  902.    °WIN_TRACK            °the user tracks the window (in XSlider)
  903.    °WIN_ENDTRACK         °the user stopped tracking (in XSlider)
  904.    °WIN_UPARROW          °the user pressed the arrow "up" (in XSpinButton)
  905.    °WIN_DOWNARROW        °the user pressed the arrow "down" (in XSpinButton)
  906.    °MEDIA_PLAYED         °a media-window has completed playing a file
  907.    °MEDIA_PAUSED         °a media-window paused playing a file
  908.    °MEDIA_REWINDED       °a media-window completed rewinding a file
  909. </t>
  910. */
  911.  
  912.  
  913. /*@ 
  914. @class XDragEvent
  915. @parent XEvent
  916. @type overview
  917. @symbol _
  918. @remarks For drag-events a XDragEvent is generated, to catch them you need to install
  919. a XDragHandler. Possible event-IDs are:
  920. <t '°' 2>
  921.    °DRG_DROPPED          °An item was dropped.
  922.    °DRG_DRAGOVER         °An item fly over the window.
  923.    °DRG_ENDCONVERSATION  °The converation ends. No informations about dragitems avaible!
  924.    °DRG_DISCARDOBJECT    °Delete the items(s).
  925.    °DRG_PRINTOBJECT      °Print the item(s). Use QueryPrinterInfo() to get information about the requested printer.
  926. </t>
  927. For drag-events in a container see:
  928. <UL>
  929. <LI>XContainerDragEvent
  930. <LI>XContainerEvent
  931. <LI>XContainerHandler
  932. </UL>
  933. */
  934.  
  935.  
  936. /*@ 
  937. @class XMouseEvent
  938. @parent XEvent
  939. @type overview
  940. @symbol _
  941. @remarks To catch events from the mouse like moving using mouse-buttons etc you must
  942. install a XMouseHandler. If you use this handler you recieve XMouseEvents
  943. which contains information about the mouse-state. For drag/drop you don∩t
  944. need a XMousehandler but a XDragHandler. Possible event-IDs are
  945. <t '°' c=2>
  946.    °MOU_BTN1CLICK      °button 1 clicked
  947.    °MOU_BTN1DBLCLICK   °button 1 double-click
  948.    °MOU_BTN1DOWN       °button 1 down
  949.    °MOU_BTN1UP         °button 1 up
  950.    °MOU_BTN2CLICK      °button 2 clicked
  951.    °MOU_BTN2DBLCLICK   °button 2 double-click
  952.    °MOU_BTN2DOWN       °button 2 down
  953.    °MOU_BTN2UP         °button 2 up
  954.    °MOU_BTN3CLICK      °button 3 clicked
  955.    °MOU_BTN3DBLCLICK   °button 3 double-click
  956.    °MOU_BTN3DOWN       °button 3 down
  957.    °MOU_BTN3UP         °button 3 up
  958.    °MOU_INITDRAG       °the user requested a drag-operation
  959.    °MOU_MOVE           °mouse moved
  960. </t>
  961. */
  962.  
  963.  
  964. /*@ 
  965. @class XKeyboardEvent
  966. @parent XEvent
  967. @type overview
  968. @symbol _
  969. @remarks A XKeyboardEvent represents a user input to the keyboard, to catch these
  970. events install a XKeyboardHandler.<P>
  971. XKeyboardEvent::GetEventID() returns the ASCII-code of the key which was pressed, with XKeyboardEvent::GetVirtualKey() 
  972. and XKeyboardEvent::GetScanCode() you receivemore information.
  973. */
  974.  
  975.  
  976. /*@ XKeyboardEvent::GetVirtualKey
  977. @remarks Use this function to get the virtual key defined by the OS
  978. @returns 
  979. <t '°' c=2>
  980. °SHORT key    °virtual key, this value can be:
  981.                 <t '°' c=2>
  982.                °XKC_KEYUP           °The event is a key-up transition
  983.                °XKC_PREVDOWN           °The key has been previously down
  984.                °XKC_LONEKEY           °Indicates if the key is pressed and released without any other keys
  985.                °XKC_SHIFT                 °The SHIFT state is active
  986.                °XKC_ALT           °The ALT state is active
  987.                °XKC_CTRL           °The CTRL state was active
  988.                 </t>
  989.                 This values can be or-ed.
  990. </t>
  991. */  
  992.  
  993.  
  994. /*@ XKeyboardEvent::GetScanCode
  995. @remarks Use this function to get the scancode
  996. @returns SHORT code
  997. */
  998.