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