home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / opendc12.zip / od124os2.exe / od12osp1.exe / src / basecntr / os2plat.cpp < prev   
C/C++ Source or Header  |  1997-04-02  |  15KB  |  488 lines
  1. /* @(#) 1.6 os2/src/samples/basecntr/os2plat.cpp, odbasepart, od96os2, odos29712d 2/25/97 22:19:07 [3/21/97 17:42:03] */
  2.  
  3. //====START_GENERATED_PROLOG======================================
  4. //
  5. //
  6. //   COMPONENT_NAME: odsamples
  7. //
  8. //   CLASSES: none
  9. //
  10. //   ORIGINS: 82,27
  11. //
  12. //
  13. //   (C) COPYRIGHT International Business Machines Corp. 1995,1996
  14. //   All Rights Reserved
  15. //   Licensed Materials - Property of IBM
  16. //   US Government Users Restricted Rights - Use, duplication or
  17. //   disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  18. //
  19. //   IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  20. //   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  21. //   PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  22. //   CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  23. //   USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  24. //   OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
  25. //   OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
  26. //   OR PERFORMANCE OF THIS SOFTWARE.
  27. //
  28. //====END_GENERATED_PROLOG========================================
  29.  
  30. #define INCL_DOSMODULEMGR 
  31. #define INCL_GPILOGCOLORTABLE 
  32. #define INCL_WINDIALOGS 
  33. #define INCL_WINMENUS 
  34. #define INCL_WINSTDSLIDER 
  35. #define INCL_WINSTDSPIN 
  36. #define INCL_WINWINDOWMGR 
  37. #include <ODos2.h> 
  38. #include "iodbcres.h" 
  39.  
  40. extern "C" MRESULT EXPENTRY ColorProc( HWND hwndDlg, ULONG msg, MPARAM mp1, MPARAM mp2 ); 
  41. extern "C" MRESULT EXPENTRY fnwpColorSample( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ); 
  42.  
  43. // Array of binary values for RGB value 
  44. SHORT RGBColors[3] = {0, 0, 0}; 
  45.  
  46. // Array of fill color for sliders 
  47. LONG RibbonColors[3] = {CLR_DARKRED, CLR_DARKGREEN, CLR_DARKBLUE}; 
  48. LONG ShaftColors[3]  = {CLR_RED,     CLR_GREEN,     CLR_BLUE    }; 
  49.  
  50. // Composite color value 
  51. LONG  Color = 0; 
  52.  
  53. const unsigned long ColorChoices = 9; 
  54. /* 
  55.  * Local method to display values of property in a modal window 
  56.  * returning a non-empty string if value selected.  Return value 
  57.  * is return value from WinDlgBox 
  58.  */ 
  59.  
  60. BOOL ColorWindow(HMODULE dllHandle, HWND ParentWindow, SHORT *BakColor) 
  61. { 
  62.  
  63.  
  64.     // take initial background color to start
  65.       RGBColors[RED]   = BakColor[RED];
  66.       RGBColors[GREEN] = BakColor[GREEN];
  67.       RGBColors[BLUE]  = BakColor[BLUE];
  68.  
  69.     // Register a window class to handle the user control 
  70.     WinRegisterClass(WinQueryAnchorBlock(ParentWindow), 
  71.                      "ColorMix", 
  72.                      fnwpColorSample, 
  73.                      0L, 
  74.                      0); 
  75.  
  76.     // Execute color dialog passing in the current color value 
  77.     ULONG rc = WinDlgBox(HWND_DESKTOP,
  78.                          ParentWindow,
  79.                          ColorProc,
  80.                          dllHandle,
  81.                          ID_COLORS,
  82.                          0); 
  83.  
  84.     // If user terminated with the OK button 
  85.     if (rc != DID_CANCEL) 
  86.     {
  87.      BakColor[RED] = RGBColors[RED];
  88.      BakColor[GREEN] = RGBColors[GREEN];
  89.      BakColor[BLUE] = RGBColors[BLUE]; 
  90.      return 0;
  91.     }
  92.  
  93.     // If canceled then don't change color
  94.     return 1; 
  95. } 
  96.  
  97.  
  98. MRESULT EXPENTRY ColorProc( HWND hwndDlg, ULONG msg, MPARAM mp1, MPARAM mp2 ) 
  99. { 
  100.  // This global variable prevents us from infinitely looping setting PM control 
  101.  // values.  The slider set the spin button and the spin button sets the 
  102.  // slider. 
  103.  static boolean Setting = FALSE; 
  104.  
  105.   // Switch on the PM message type 
  106.   switch (msg) 
  107.   { 
  108.     // case Initialize dialog 
  109.     case WM_INITDLG: 
  110.     { 
  111.       // We're setting values 
  112.       Setting = TRUE; 
  113.  
  114.       // For all three colors 
  115.       for (int Index = RED; 
  116.            Index <= BLUE; 
  117.            Index++) 
  118.       { 
  119.         // Set spin fields range from 0 to 255 
  120.         WinSendDlgItemMsg(hwndDlg, 
  121.                           ID_SPIN_RED + Index, 
  122.                           SPBM_SETLIMITS, 
  123.                           MPFROMLONG(255), 
  124.                           MPFROMLONG(0)); 
  125.  
  126.         // Initialize slider 
  127.         WinSendDlgItemMsg(hwndDlg, 
  128.                           ID_SLIDER_RED + Index, 
  129.                           SLM_SETSLIDERINFO, 
  130.                           MPFROM2SHORT(SMA_SLIDERARMPOSITION, 
  131.                                        SMA_INCREMENTVALUE), 
  132.                           MPFROMSHORT(RGBColors[Index])); 
  133.  
  134.         // Set spin field 
  135.         WinSendDlgItemMsg(hwndDlg, 
  136.                           ID_SPIN_RED + Index, 
  137.                           SPBM_SETCURRENTVALUE, 
  138.                           MPFROMLONG((long) RGBColors[Index]), 
  139.                           0); 
  140.       } 
  141.  
  142.       // Invalidate the mix window so it will repaint 
  143.       WinInvalidateRect(WinWindowFromID(hwndDlg, 
  144.                                         ID_MIX), 
  145.                         NULL, 
  146.                         FALSE); 
  147.  
  148.       // No longer setting values 
  149.       Setting = FALSE; 
  150.  
  151.       break; 
  152.     } 
  153.  
  154.     // Case draw item for owner drawn portion of sliders 
  155.     case WM_DRAWITEM: 
  156.     { 
  157.       // Get control identifier 
  158.       SHORT ID = SHORT1FROMMP(mp1); 
  159.  
  160.       // Switch on the control identifier 
  161.       switch (ID) 
  162.       { 
  163.         // case red, green or blue slider 
  164.         case ID_SLIDER_RED: 
  165.         case ID_SLIDER_GREEN: 
  166.         case ID_SLIDER_BLUE: 
  167.           { 
  168.             // Get owner item structure 
  169.             POWNERITEM POwnerItem = (POWNERITEM) PVOIDFROMMP(mp2); 
  170.  
  171.             // If drawing the ribbon strip 
  172.             if (POwnerItem->idItem == SDA_RIBBONSTRIP) 
  173.             { 
  174.               // Get color index 
  175.               int Index = ID - ID_SLIDER_RED; 
  176.  
  177.               // Fill in the ribbon strip with appropriate color 
  178.               WinFillRect(POwnerItem->hps, 
  179.                           &POwnerItem->rclItem, 
  180.                           RibbonColors[Index]); 
  181.  
  182.               // Return TRUE so the slider won't draw its own ribbon strip 
  183.               return (MRESULT) TRUE; 
  184.             } 
  185.             else 
  186.             { 
  187.               // If drawing the slider shaft 
  188.               if (POwnerItem->idItem == SDA_SLIDERSHAFT) 
  189.               { 
  190.                 // Get color index 
  191.                 int Index = ID - ID_SLIDER_RED; 
  192.  
  193.                 // Fill in the slider shaft with appropriate color 
  194.                 WinFillRect(POwnerItem->hps, 
  195.                             &POwnerItem->rclItem, 
  196.                             ShaftColors[Index]); 
  197.  
  198.                 // Return TRUE so the slider won't draw its own slider shaft 
  199.                 return (MRESULT) TRUE; 
  200.               } 
  201.             } 
  202.           } 
  203.  
  204.           break; 
  205.       } 
  206.  
  207.       break; 
  208.     } 
  209.  
  210.     // case Command 
  211.     case WM_COMMAND: 
  212.  
  213.       // switch on the dialog item 
  214.       switch (SHORT1FROMMP(mp1)) 
  215.       { 
  216.         // case OK 
  217.         // case Cancel 
  218.         case DID_OK: 
  219.         case DID_CANCEL: 
  220.  
  221.           // Dismiss the dialog 
  222.           WinDismissDlg(hwndDlg, (ULONG) SHORT1FROMMP(mp1)); 
  223.  
  224.           break; 
  225.  
  226.         // default case 
  227.         default: 
  228.  
  229.           // get PM's default procedure to handle the request 
  230.           return WinDefDlgProc(hwndDlg, 
  231.                                msg, 
  232.                                mp1, 
  233.                                mp2); 
  234.  
  235.           break; 
  236.       } 
  237.  
  238.       break; 
  239.  
  240.     // case Control 
  241.     case WM_CONTROL: 
  242.     { 
  243.       // Get control identifier 
  244.       SHORT ID = SHORT1FROMMP(mp1); 
  245.  
  246.       // switch on the dialog item 
  247.       switch (ID) 
  248.       { 
  249.         // case red, green or blue slider 
  250.         case ID_SLIDER_RED: 
  251.         case ID_SLIDER_GREEN: 
  252.         case ID_SLIDER_BLUE: 
  253.  
  254.           // switch on the PM action 
  255.           switch (SHORT2FROMMP(mp1)) 
  256.           { 
  257.             // case slider change 
  258.             case SLN_CHANGE: 
  259.             case SLN_SLIDERTRACK: 
  260.             { 
  261.               // If not already setting values 
  262.               if (Setting == FALSE) 
  263.               { 
  264.                 // Get index for red, green, blue 
  265.                 SHORT Index = ID - ID_SLIDER_RED; 
  266.  
  267.                 // get the new color value 
  268.                 RGBColors[Index] = SHORT1FROMMR(WinSendDlgItemMsg(hwndDlg, 
  269.                                                 ID, 
  270.                                                 SLM_QUERYSLIDERINFO, 
  271.                                                 MPFROM2SHORT(SMA_SLIDERARMPOSITION, 
  272.                                                              SMA_INCREMENTVALUE), 
  273.                                                 MPFROMLONG(0))); 
  274.  
  275.                 // We're setting values 
  276.                 Setting = TRUE; 
  277.  
  278.                 // Set corresponding spin button 
  279.                 WinSendDlgItemMsg(hwndDlg, 
  280.                                   ID_SPIN_RED + Index, 
  281.                                   SPBM_SETCURRENTVALUE, 
  282.                                   MPFROMLONG((long) RGBColors[Index]), 
  283.                                   0); 
  284.  
  285.                 // We're no longer setting values 
  286.                 Setting = FALSE; 
  287.  
  288.                 // invalidate the mix window so it will get redrawn 
  289.                 WinInvalidateRect(WinWindowFromID(hwndDlg, 
  290.                                                   ID_MIX), 
  291.                                   NULL, 
  292.                                   FALSE); 
  293.               } 
  294.  
  295.               break; 
  296.             } 
  297.  
  298.             // default case 
  299.             default: 
  300.  
  301.               // get PM's default procedure to handle the request 
  302.               return WinDefDlgProc(hwndDlg, 
  303.                                    msg, 
  304.                                    mp1, 
  305.                                    mp2); 
  306.  
  307.               break; 
  308.           } 
  309.           // endswitch - switch on the PM action 
  310.  
  311.           break; 
  312.  
  313.         // case red, green or blue spin button 
  314.         case ID_SPIN_RED: 
  315.         case ID_SPIN_GREEN: 
  316.         case ID_SPIN_BLUE: 
  317.  
  318.           // switch on the PM action 
  319.           switch (SHORT2FROMMP(mp1)) 
  320.           { 
  321.             // case value change 
  322.             case SPBN_CHANGE: 
  323.             { 
  324.               // If not already setting values 
  325.               if (Setting == FALSE) 
  326.               { 
  327.                 // Get index for red, green, blue 
  328.                 SHORT Index = ID - ID_SPIN_RED; 
  329.  
  330.                 // get the new color value 
  331.                 long NewValue; 
  332.                 WinSendDlgItemMsg(hwndDlg, 
  333.                                   ID, 
  334.                                   SPBM_QUERYVALUE, 
  335.                                   MRFROMP(&NewValue), 
  336.                                   MRFROM2SHORT(0, 
  337.                                                SPBQ_ALWAYSUPDATE)); 
  338.                 RGBColors[Index] = (SHORT) NewValue; 
  339.  
  340.                 // We're setting values 
  341.                 Setting = TRUE; 
  342.  
  343.                 // Set slider value 
  344.                 WinSendDlgItemMsg(hwndDlg, 
  345.                                   ID_SLIDER_RED + Index, 
  346.                                   SLM_SETSLIDERINFO, 
  347.                                   MPFROM2SHORT(SMA_SLIDERARMPOSITION, 
  348.                                                SMA_INCREMENTVALUE), 
  349.                                   MPFROMSHORT(RGBColors[Index])); 
  350.  
  351.                 // We're no longer setting values 
  352.                 Setting = FALSE; 
  353.  
  354.                 // invalidate the mix window so it will get redrawn 
  355.                 WinInvalidateRect(WinWindowFromID(hwndDlg, 
  356.                                                   ID_MIX), 
  357.                                   NULL, 
  358.                                   FALSE); 
  359.               } 
  360.               else 
  361.  
  362.               break; 
  363.             } 
  364.  
  365.             // default case 
  366.             default: 
  367.  
  368.               // get PM's default procedure to handle the request 
  369.               return WinDefDlgProc(hwndDlg, 
  370.                                    msg, 
  371.                                    mp1, 
  372.                                    mp2); 
  373.  
  374.               break; 
  375.           } 
  376.           // endswitch - switch on the PM action 
  377.  
  378.           break; 
  379.  
  380.         // default case 
  381.         default: 
  382.  
  383.           // get PM's default procedure to handle the request 
  384.           return WinDefDlgProc(hwndDlg, 
  385.                                msg, 
  386.                                mp1, 
  387.                                mp2); 
  388.  
  389.           break; 
  390.       } 
  391.       // endswitch - switch on the dialog item 
  392.       break; 
  393.     } 
  394.  
  395.     // default case 
  396.     default: 
  397.  
  398.       // get PM's default procedure to handle the request 
  399.       return WinDefDlgProc(hwndDlg, 
  400.                            msg, 
  401.                            mp1, 
  402.                            mp2); 
  403.  
  404.       break; 
  405.   } 
  406.  
  407.   return FALSE; 
  408. } 
  409.  
  410.  
  411. MRESULT EXPENTRY fnwpColorSample( HWND hwnd, ULONG msg, 
  412.                                   MPARAM mp1, MPARAM mp2 ) 
  413. { 
  414.   // If processing the paint message 
  415.   if (msg == WM_PAINT) 
  416.   { 
  417.     HPS    hps; 
  418.     RECTL  rcl,rcl1; 
  419.  
  420.     // Issue the begin paint 
  421.     hps = WinBeginPaint(hwnd, 
  422.                         NULL, 
  423.                         &rcl); 
  424.  
  425.     // Override the rectangle returned from WinBeginPaint with the 
  426.     // window's entire rectangle 
  427.     WinQueryWindowRect(hwnd, &rcl); 
  428.  
  429.     // Compose the color value needed by GpiCreateLogColorTable 
  430.     Color =                RGBColors[BLUE]   + 
  431.           (256L   * (LONG) RGBColors[GREEN]) + 
  432.           (65536L * (LONG) RGBColors[RED  ]); 
  433.  
  434.     // Create a color log table with one entry 
  435.     GpiCreateLogColorTable(hps, 
  436.                            LCOL_RESET, 
  437.                            LCOLF_RGB, 
  438.                            0L, 
  439.                            1L, 
  440.                            &Color); 
  441.  
  442.     // Issue four fills to outline the color in black 
  443.     rcl1.xLeft=rcl.xLeft; 
  444.     rcl1.xRight=rcl.xRight; 
  445.     rcl1.yTop=rcl.yTop; 
  446.     rcl1.yBottom=rcl.yTop - 4; 
  447.     WinFillRect(hps, &rcl1, CLR_BLACK); 
  448.  
  449.     rcl1.xLeft=rcl.xLeft; 
  450.     rcl1.xRight=rcl.xRight; 
  451.     rcl1.yTop=rcl.yBottom + 4; 
  452.     rcl1.yBottom=rcl.yBottom; 
  453.     WinFillRect(hps, &rcl1, CLR_BLACK); 
  454.  
  455.     rcl1.xLeft=rcl.xLeft; 
  456.     rcl1.xRight=rcl.xLeft + 4; 
  457.     rcl1.yTop=rcl.yTop - 4; 
  458.     rcl1.yBottom=rcl.yBottom + 4; 
  459.     WinFillRect(hps, &rcl1, CLR_BLACK); 
  460.  
  461.     rcl1.xLeft=rcl.xRight - 4; 
  462.     rcl1.xRight=rcl.xRight; 
  463.     rcl1.yTop=rcl.yTop - 4; 
  464.     rcl1.yBottom=rcl.yBottom + 4; 
  465.     WinFillRect(hps, &rcl1, CLR_BLACK); 
  466.  
  467.     // Fill the rest of the rectangle with the current color 
  468.     rcl.xLeft += 5; 
  469.     rcl.yBottom += 5; 
  470.     rcl.xRight -= 5; 
  471.     rcl.yTop -= 5; 
  472.     WinFillRect(hps, &rcl, Color); 
  473.  
  474.     // Issue the end paint 
  475.     WinEndPaint( hps ); 
  476.  
  477.     // Return value is unimportant 
  478.     return FALSE; 
  479.   } 
  480.   else 
  481.   { 
  482.     // Pass all other messages to the default window procedure 
  483.     return WinDefWindowProc(hwnd, msg, mp1, mp2); 
  484.   } 
  485. } 
  486.  
  487.  
  488.