home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / powergui / extlib / valueset / testvset.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-29  |  14.6 KB  |  508 lines
  1. //************************************************************
  2. // Extending the Library - Value Set Example
  3. //
  4. // Copyright (C) 1994, Law, Leong, Love, Olson, Tsuji.
  5. // All Rights Reserved.
  6. //************************************************************
  7. #define INCL_WIN
  8. #include <os2.h>
  9.  
  10. #include <iframe.hpp>
  11. #include <iapp.hpp>
  12. #include <imnitem.hpp>
  13. #include <icmdhdr.hpp>
  14. #include <imenuhdr.hpp>
  15. #include <ientryfd.hpp>
  16. #include <istattxt.hpp>
  17. #include <imenubar.hpp>
  18. #include <isubmenu.hpp>
  19. #include <ilistbox.hpp>
  20.  
  21. #include "valueset.hpp"
  22. #include "vsethdr.hpp"
  23. #include "testvset.h"
  24.  
  25. class CmdHandler : public ICommandHandler {
  26. public:
  27.   CmdHandler ( ValueSet &vset,
  28.                IEntryField &input,
  29.                IStaticText &output,
  30.                IMenuBar    &menu,
  31.                ValueSet    &palette )
  32.     : ICommandHandler(),
  33.       vset( vset ),
  34.       in( input ),
  35.       out( output ),
  36.       menu( menu ),
  37.       palette( palette )
  38.     {
  39.     this->handleEventsFor( &vset );
  40.     }
  41. protected:
  42. virtual Boolean
  43.   command ( ICommandEvent &cmd )
  44.     {
  45.     out.setText( "Ok" );
  46.     switch ( cmd.commandId() )
  47.       {
  48.       case M_STYLE_BORDER:     // 101
  49.         {
  50.         vset.enableBorder( !vset.hasBorder() );
  51.         vset.refresh();
  52.         break;
  53.         }
  54.       case M_STYLE_ITEMBORDER: // 102
  55.         {
  56.         vset.enableItemBorder( !vset.hasItemBorder() );
  57.         vset.refresh();
  58.         break;
  59.         }
  60.       case M_STYLE_RTL:        // 103
  61.         break;
  62.       case M_STYLE_SCALE:      // 104
  63.         {
  64.         vset.enableBitmapScaling( !vset.willScaleBitmaps() );
  65.         vset.refresh();
  66.         break;
  67.         }
  68.       case M_STYLE_OWNERDRAW:  // 105
  69.         {
  70.         vset.enableDrawItem( !vset.isDrawItem() );
  71.         vset.refresh();
  72.         break;
  73.         }
  74.  
  75.       case M_DIMENSIONS_QUERY:          // 201
  76.         {
  77.         ISize
  78.           size = vset.dimensions();
  79.         out.setText( "Value Set Size = " + size.asString() );
  80.         break;
  81.         }
  82.       case M_DIMENSIONS_SET:            // 202
  83.         {
  84.         ISize
  85.           size = ISize( in.text().word(1).asUnsigned(),
  86.                         in.text().word(2).asUnsigned() );
  87.         vset.setDimensions( size );
  88.         break;
  89.         }
  90.       case M_DIMENSIONS_ITEMSIZE_QUERY: // 211
  91.         {
  92.         ISize
  93.           size = vset.itemSize();
  94.         out.setText( "Item Size = " + size.asString() );
  95.         break;
  96.         }
  97.       case M_DIMENSIONS_ITEMSIZE_SET:   // 212
  98.         {
  99.         ISize
  100.           size = ISize( in.text().word(1).asUnsigned(),
  101.                         in.text().word(2).asUnsigned() );
  102.         vset.setItemSize( size );
  103.         break;
  104.         }
  105.       case M_DIMENSIONS_SPACING_QUERY:  // 221
  106.         {
  107.         ISize
  108.           size = vset.itemSpacing();
  109.         out.setText( "Item Spacing = " + size.asString() );
  110.         break;
  111.         }
  112.       case M_DIMENSIONS_SPACING_SET:    // 222
  113.         {
  114.         ISize
  115.           size = ISize( in.text().word(1).asUnsigned(),
  116.                         in.text().word(2).asUnsigned() );
  117.         vset.setItemSpacing( size );
  118.         break;
  119.         }
  120.       case M_DIMENSIONS_MIN_QUERY:      // 231
  121.         {
  122.         ISize
  123.           size = vset.minimumSize();
  124.         out.setText( "Min Size = " + size.asString() );
  125.         break;
  126.         }
  127.       case M_DIMENSIONS_MIN_SIZE:       // 232
  128.         {
  129.         IFrameWindow
  130.          *frame = (IFrameWindow*)( vset.parent() );
  131.         frame->moveSizeToClient( IRectangle( frame->position(),
  132.                                              vset.minimumSize() ) );
  133.         break;
  134.         }
  135.  
  136.       case M_ITEMS_BITMAP: // 301
  137.         {
  138.         IPoint
  139.           cell = vset.selection();
  140.         static IBitmapHandle
  141.           bmp = 0;
  142.         if ( !bmp )
  143.           bmp = IApplication::current().userResourceLibrary()
  144.                   .loadBitmap( IC_DEFAULT_FRAME_ID );
  145.         vset.setItemContents( cell.y(),
  146.                               cell.x(),
  147.                               bmp );
  148.         break;
  149.         }
  150.       case M_ITEMS_COLOR:  // 302
  151.         {
  152.         IPoint
  153.           cell = vset.selection();
  154.         vset.setItemContents( cell.y(),
  155.                               cell.x(),
  156.                               palette.selectedItem().color() );
  157.         break;
  158.         }
  159.       case M_ITEMS_ICON:   // 303
  160.         {
  161.         IPoint
  162.           cell = vset.selection();
  163.         static IPointerHandle
  164.           ptr = 0;
  165.         if ( !ptr )
  166.           ptr = IApplication::current().userResourceLibrary()
  167.                   .loadIcon( IC_DEFAULT_FRAME_ID );
  168.         vset.setItemContents( cell.y(),
  169.                               cell.x(),
  170.                               ptr );
  171.         break;
  172.         }
  173.       case M_ITEMS_TEXT:   // 304
  174.         {
  175.         IPoint
  176.           cell = vset.selection();
  177.         vset.setItemContents( cell.y(),
  178.                               cell.x(),
  179.                               in.text() );
  180.         break;
  181.         }
  182.                         
  183.       case M_ITEMSTYLE_SET:       // 401
  184.         {
  185.         IWindowHandle
  186.           subHandle = menu.menuItem( M_ITEMSTYLE ).submenuHandle();
  187.         ISubmenu
  188.           subMenu( subHandle );
  189.         ValueSet::ItemStyle
  190.           style = ValueSet::noItemStyle;
  191.         if ( subMenu.isItemChecked( M_ITEMSTYLE_DISABLED ) )
  192.           style |= ValueSet::disabled;
  193.         if ( subMenu.isItemChecked( M_ITEMSTYLE_DRAG ) )
  194.           style |= ValueSet::dragSource;
  195.         if ( subMenu.isItemChecked( M_ITEMSTYLE_DROP ) )
  196.           style |= ValueSet::dropTarget;
  197.         if ( subMenu.isItemChecked( M_ITEMSTYLE_OWNERDRAW ) )
  198.           style |= ValueSet::itemOwnerDraw;
  199.         IPoint
  200.           cell = vset.selection();
  201.         vset.setItemStyle( cell.y(),
  202.                            cell.x(),
  203.                            style );
  204.         break;
  205.         }
  206.       case M_ITEMSTYLE_ENABLE:    // 402
  207.         {
  208.         IPoint
  209.           cell = ISize( in.text().word(1).asUnsigned(),
  210.                         in.text().word(2).asUnsigned() );
  211.         vset.setItemStyle( cell.y(),
  212.                            cell.x(),
  213.                            vset.item( cell.y(), cell.x() ).style() 
  214.                              & ~ValueSet::disabled );
  215.         break;
  216.         }
  217.       case M_ITEMSTYLE_DISABLED:  // 403
  218.       case M_ITEMSTYLE_DRAG:      // 404
  219.       case M_ITEMSTYLE_DROP:      // 405
  220.       case M_ITEMSTYLE_OWNERDRAW: // 406
  221.         {
  222.         IWindowHandle
  223.           subHandle = menu.menuItem( M_ITEMSTYLE ).submenuHandle();
  224.         ISubmenu
  225.           subMenu( subHandle );
  226.         subMenu
  227.           .checkItem( cmd.commandId(),
  228.                       !subMenu.isItemChecked( cmd.commandId() ) );
  229.         break;
  230.         }
  231.       case M_COLORS_BACK:         // 501
  232.         vset.setColor( ValueSet::background, 
  233.                        palette.selectedItem().color() );
  234.         break;
  235.       case M_COLORS_BORDERS:      // 502
  236.         vset.setColor( ValueSet::borders,
  237.                        palette.selectedItem().color() );
  238.         break;
  239.       case M_COLORS_FORE:         // 503
  240.         vset.setColor( ValueSet::foreground,
  241.                        palette.selectedItem().color() );
  242.         break;
  243.       case M_COLORS_HILITE:       // 504
  244.         vset.setColor( ValueSet::highlightBackground,
  245.                        palette.selectedItem().color() );
  246.         break;
  247.       }
  248.     return false;
  249.     }
  250. private:
  251. ValueSet
  252.  &vset;
  253. IEntryField
  254.  ∈
  255. IStaticText
  256.  &out;
  257. IMenuBar
  258.  &menu;
  259. ValueSet
  260.  &palette;
  261. CmdHandler (const CmdHandler&);
  262. CmdHandler& operator=(const CmdHandler&);
  263. };
  264.  
  265. class MenuHandler : public IMenuHandler {
  266. public:
  267.   MenuHandler ( ValueSet &vset,
  268.                 IEntryField &input,
  269.                 ValueSet    &palette )
  270.     : IMenuHandler(),
  271.       vset( vset ),
  272.       in( input ),
  273.       palette( palette )
  274.     {
  275.     this->handleEventsFor( &vset );
  276.     }
  277. protected:
  278. virtual Boolean
  279.   menuShowing ( IMenuEvent &event,
  280.                 ISubmenu   &subMenu )
  281.     {
  282.     switch ( subMenu.id() )
  283.       {
  284.       case M_STYLE:     // 100
  285.         {
  286.         subMenu.checkItem( M_STYLE_BORDER, vset.hasBorder() );
  287.         subMenu.checkItem( M_STYLE_ITEMBORDER, vset.hasItemBorder() );
  288.         subMenu.checkItem( M_STYLE_RTL, vset.isRightToLeft() );
  289.         subMenu.checkItem( M_STYLE_SCALE, vset.willScaleBitmaps() );
  290.         subMenu.checkItem( M_STYLE_OWNERDRAW, vset.isDrawItem() );
  291.         break;
  292.         }
  293.       case M_ITEMS:     // 300
  294.         {
  295.         Boolean
  296.           active = vset.hasSelection();
  297.         subMenu
  298.           .enableItem( M_ITEMS_BITMAP, active )
  299.           .checkItem ( M_ITEMS_BITMAP, false )
  300.           .enableItem( M_ITEMS_COLOR, active )
  301.           .checkItem ( M_ITEMS_COLOR, false )
  302.           .enableItem( M_ITEMS_ICON, active )
  303.           .checkItem ( M_ITEMS_ICON, false )
  304.           .enableItem( M_ITEMS_TEXT, active )
  305.           .checkItem ( M_ITEMS_TEXT, false );
  306.         if ( active )
  307.           {
  308.           if ( vset.selectedItem().containsBitmap() 
  309.                && 
  310.                vset.selectedItem().bitmap() )
  311.             subMenu
  312.               .checkItem( M_ITEMS_BITMAP )
  313.               .disableItem( M_ITEMS_BITMAP );
  314.           else if ( vset.selectedItem().containsColor() )
  315.             subMenu.checkItem( M_ITEMS_COLOR );
  316.           else if ( vset.selectedItem().containsIcon() )
  317.             subMenu
  318.               .checkItem( M_ITEMS_ICON )
  319.               .disableItem( M_ITEMS_ICON );
  320.           else if ( vset.selectedItem().containsText() )
  321.             subMenu.checkItem( M_ITEMS_TEXT );
  322.           if ( !palette.hasSelection() )
  323.             subMenu.disableItem( M_ITEMS_COLOR );
  324.           }
  325.         break;
  326.         }
  327.       case M_ITEMSTYLE: // 400
  328.         {
  329.         subMenu
  330.           .disableItem( M_ITEMSTYLE_SET )
  331.           .disableItem( M_ITEMSTYLE_ENABLE )
  332.           .disableItem( M_ITEMSTYLE_DISABLED )
  333.           .disableItem( M_ITEMSTYLE_DRAG )
  334.           .disableItem( M_ITEMSTYLE_DROP )
  335.           .disableItem( M_ITEMSTYLE_OWNERDRAW );
  336.         if ( vset.hasSelection() )
  337.           {
  338.           ValueSet::Item
  339.             item = vset.selectedItem();
  340.           subMenu
  341.             .enableItem( M_ITEMSTYLE_SET )
  342.             .enableItem( M_ITEMSTYLE_DISABLED )
  343.             .checkItem( M_ITEMSTYLE_DISABLED, false )
  344.             .enableItem( M_ITEMSTYLE_DRAG )
  345.             .checkItem( M_ITEMSTYLE_DRAG, item.canBeDragged() )
  346.             .enableItem( M_ITEMSTYLE_DROP )
  347.             .checkItem( M_ITEMSTYLE_DROP, item.canBeDroppedOn() )
  348.             .enableItem( M_ITEMSTYLE_OWNERDRAW )
  349.             .checkItem( M_ITEMSTYLE_OWNERDRAW, item.isOwnerDraw() );
  350.           }
  351.         IPoint
  352.           cell = ISize( in.text().word(1).asUnsigned(),
  353.                         in.text().word(2).asUnsigned() );
  354.         if ( cell > IPoint()
  355.              && 
  356.              cell <= vset.dimensions()
  357.              &&
  358.              vset.item( cell.y(), cell.x() ).isDisabled() )
  359.           subMenu.enableItem( M_ITEMSTYLE_ENABLE );
  360.         break;
  361.         }
  362.       case M_COLORS: // 500
  363.         {
  364.         Boolean
  365.           flag = palette.hasSelection();
  366.         subMenu
  367.           .enableItem( M_COLORS_BACK, flag )
  368.           .enableItem( M_COLORS_BORDERS, flag )
  369.           .enableItem( M_COLORS_FORE, flag )
  370.           .enableItem( M_COLORS_HILITE, flag );
  371.         break;
  372.         }
  373.       default:
  374.         break;
  375.       }
  376.     return false;
  377.     }
  378. private:
  379. ValueSet
  380.  &vset;
  381. IEntryField
  382.  ∈
  383. ValueSet
  384.  &palette;
  385. MenuHandler (const MenuHandler&);
  386. MenuHandler& operator= (const MenuHandler&);
  387. };
  388.  
  389. class MyVSetHandler : public ValueSetHandler {
  390. public:
  391.   MyVSetHandler ( ValueSet &vset,
  392.                   IListBox &out )
  393.     : ValueSetHandler( vset ),
  394.       out( out )
  395.     {
  396.     }
  397. protected:
  398. virtual Boolean
  399.   enter ( ValueSetEvent &event )
  400.     {
  401.     out.addAsLast( id(event) + ": enter "
  402.                    + 
  403.                    IPoint( event.column(),
  404.                            event.row() ).asString() );
  405.     return true;
  406.     }
  407. virtual Boolean
  408.   selected ( ValueSetEvent &event )
  409.     {
  410.     out.addAsLast( id(event) + ": selected "
  411.                    + 
  412.                    IPoint( event.column(),
  413.                            event.row() ).asString() );
  414.     return true;
  415.     }
  416. virtual Boolean
  417.   gotFocus ( ValueSetEvent &event )
  418.     {
  419.     out.addAsLast( id(event) + ": gotFocus" );
  420.     return true;
  421.     }
  422. virtual Boolean
  423.   lostFocus ( ValueSetEvent &event )
  424.     {
  425.     out.addAsLast( id(event) + ": lostFocus" );
  426.     return true;
  427.     }
  428. virtual Boolean
  429.   help ( ValueSetEvent &event )
  430.     {
  431.     out.addAsLast( id(event) + ": help "
  432.                    + 
  433.                    IPoint( event.column(),
  434.                            event.row() ).asString() );
  435.     return true;
  436.     }
  437. private:
  438. IListBox
  439.  &out;
  440. IString
  441.   id ( ValueSetEvent &event ) const
  442.   {
  443.   return ( event.valueSet()->id() != ID_PALETTE ) ?
  444.              "Client"
  445.            :
  446.              "Colors";
  447.   }
  448. MyVSetHandler (const MyVSetHandler&);
  449. MyVSetHandler& operator= (const MyVSetHandler&);
  450. };
  451.  
  452. void main()
  453.   {
  454.   IFrameWindow
  455.     frame;
  456.   IMenuBar
  457.     menu( IC_DEFAULT_FRAME_ID, &frame );
  458.   IListBox
  459.     lb( 0, &frame, &frame );
  460.   ValueSet
  461.     vsetClient( 0,
  462.                 &frame,
  463.                 &frame,
  464.                 ISize( 3, 4 ) );
  465.   ValueSet
  466.     palette( ID_PALETTE,
  467.              &frame,
  468.              &frame,
  469.              ISize( 8, 2 ) );
  470.   IColor
  471.     colors[16] = { IColor::white, IColor::black, 
  472.                    IColor::blue, IColor::red, 
  473.                    IColor::pink, IColor::green, 
  474.                    IColor::cyan, IColor::yellow, 
  475.                    IColor::darkGray, IColor::darkBlue, 
  476.                    IColor::darkRed, IColor::darkPink, 
  477.                    IColor::darkGreen, IColor::darkCyan, 
  478.                    IColor::brown, IColor::paleGray };
  479.   for ( int i = 0; i < 16; i++ )
  480.     {
  481.     int
  482.       row = ( i / 8 ) + 1,
  483.       col = ( i % 8 ) + 1;
  484.     palette.setItemContents( row, col, colors[i] );
  485.     }
  486.   IEntryField
  487.     input( 0, &frame, &frame );
  488.   IStaticText
  489.     output( 0, &frame, &frame );
  490.   CmdHandler
  491.     cmdHandler( vsetClient, input, output, menu, palette );
  492.   MenuHandler
  493.     menuHandler( vsetClient, input, palette );
  494.   MyVSetHandler
  495.     vsetHandler( vsetClient, lb );
  496.   vsetHandler.handleEventsFor( &palette );
  497.   frame
  498.     .addExtension( &palette, frame.aboveClient, 100 )
  499.     .addExtension( &input, frame.aboveClient, 30 )
  500.     .addExtension( &output, frame.belowClient, 30 )
  501.     .addExtension( &lb, frame.rightOfClient, 250 )
  502.     .setIcon( IC_DEFAULT_FRAME_ID )
  503.  
  504.     .setClient( &vsetClient )
  505.     .setFocus(); 
  506.   frame.showModally();
  507.   }
  508.