home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / powergui / extlib / valueset / valueset.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-29  |  24.4 KB  |  962 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. #define INCL_GPI
  9. #include <os2.h>
  10.  
  11. #include "valueset.hpp"
  12.  
  13. #include <iexcept.hpp>
  14. #include <ireslib.hpp>
  15.  
  16. // Static Data Member Definitions
  17.  
  18. const ValueSet::Style
  19.   ValueSet::border            = VS_BORDER,
  20.   ValueSet::itemBorder        = VS_ITEMBORDER,
  21.   ValueSet::rightToLeft       = VS_RIGHTTOLEFT,
  22.   ValueSet::scaleBitmaps      = VS_SCALEBITMAPS,
  23.   ValueSet::drawItem          = VS_OWNERDRAW,
  24.   ValueSet::classDefaultStyle = WS_VISIBLE;
  25.  
  26. ValueSet::Style
  27.   ValueSet::dfltStyle = WS_VISIBLE;
  28.  
  29. const ValueSet::ItemStyle
  30.   ValueSet::noItemStyle   = 0,
  31.   ValueSet::disabled      = VIA_DISABLED,
  32.   ValueSet::dragSource    = VIA_DRAGGABLE,
  33.   ValueSet::dropTarget    = VIA_DROPONABLE,
  34.   ValueSet::itemOwnerDraw = VIA_OWNERDRAW;
  35.  
  36. ValueSet::ItemStyle
  37.   ValueSet::Item::dfltStyle = ValueSet::noItemStyle;
  38.  
  39. // ValueSet
  40.  
  41. ValueSet :: ValueSet ( const IWindowHandle &hwnd )
  42.   : IControl()
  43.   {
  44.   this -> initialize( hwnd );
  45.   }
  46.  
  47. ValueSet :: ValueSet ( IWindow *parent,
  48.                        unsigned long id )
  49.   : IControl()
  50.   {
  51.   this -> initialize( WinWindowFromID( parent->handle(), id ) );
  52.   }
  53.  
  54. ValueSet :: ValueSet ( unsigned long     id,
  55.                        IWindow          *parent,
  56.                        IWindow          *owner,
  57.                        const IRectangle &initial,
  58.                        const Style      &style )
  59.   : IControl()
  60.   {
  61.   this -> initialize ( ISize(0,0),
  62.                        id,
  63.                        parent,
  64.                        owner,
  65.                        initial,
  66.                        style );
  67.   }
  68.  
  69. ValueSet :: ValueSet ( unsigned long     id,
  70.                        IWindow          *parent,
  71.                        IWindow          *owner,
  72.                        const ISize      &rowsAndColumns,
  73.                        const IRectangle &initial,
  74.                        const Style      &style )
  75.   : IControl()
  76.   {
  77.   this -> initialize( rowsAndColumns,
  78.                       id, 
  79.                       parent, 
  80.                       owner, 
  81.                       initial,
  82.                       style );
  83.   }
  84.  
  85. ValueSet :: ~ValueSet ()
  86.   {
  87.   }
  88.  
  89. ValueSet::Style ValueSet :: defaultStyle ( )
  90.   {
  91.   return ValueSet::dfltStyle;
  92.   }
  93.  
  94. void ValueSet :: setDefaultStyle ( const Style &style ) 
  95.   {
  96.   ValueSet::dfltStyle = style;
  97.   }
  98.  
  99. Boolean ValueSet :: hasBorder ( ) const
  100.   {
  101.   return this->style() & VS_BORDER;
  102.   }
  103.  
  104. Boolean ValueSet :: hasItemBorder ( ) const
  105.   {
  106.   return this->style() & VS_ITEMBORDER;
  107.   }
  108.  
  109. Boolean ValueSet :: isRightToLeft ( ) const
  110.   {
  111.   return this->style() & VS_RIGHTTOLEFT;
  112.   }
  113.  
  114. Boolean ValueSet :: willScaleBitmaps ( ) const
  115.   {
  116.   return this->style() & VS_SCALEBITMAPS;
  117.   }
  118.  
  119. Boolean ValueSet :: isDrawItem ( ) const
  120.   {
  121.   return this->style() & VS_OWNERDRAW;
  122.   }
  123.  
  124. ValueSet &ValueSet :: enableBorder ( Boolean flag )
  125.   {
  126.   if ( flag )
  127.     this->setStyle( this->style() | VS_BORDER );
  128.   else
  129.     this->setStyle( this->style() & ~VS_BORDER );
  130.   return *this;
  131.   }
  132.  
  133. ValueSet &ValueSet :: disableBorder ( )
  134.   {
  135.   return this->enableBorder( false );
  136.   }
  137.  
  138. ValueSet &ValueSet :: enableItemBorder ( Boolean flag )
  139.   {
  140.   if ( flag )
  141.     this->setStyle( this->style() | VS_ITEMBORDER );
  142.   else
  143.     this->setStyle( this->style() & ~VS_ITEMBORDER );
  144.   return *this;
  145.   }
  146.  
  147. ValueSet &ValueSet :: disableItemBorder ( )
  148.   {
  149.   return this->enableItemBorder( false );
  150.   }
  151.  
  152. ValueSet &ValueSet :: enableBitmapScaling ( Boolean flag )
  153.   {
  154.   if ( flag )
  155.     this->setStyle( this->style() | VS_SCALEBITMAPS );
  156.   else
  157.     this->setStyle( this->style() & ~VS_SCALEBITMAPS );
  158.   return *this;
  159.   }
  160.  
  161. ValueSet &ValueSet :: disableBitmapScaling ( )
  162.   {
  163.   return this->enableBitmapScaling( false );
  164.   }
  165.  
  166. ValueSet &ValueSet :: enableDrawItem ( Boolean flag )
  167.   {
  168.   if ( flag )
  169.     this->setStyle( this->style() | VS_OWNERDRAW );
  170.   else
  171.     this->setStyle( this->style() & ~VS_OWNERDRAW );
  172.   return *this;
  173.   }
  174.  
  175. ValueSet &ValueSet :: disableDrawItem ( )
  176.   {
  177.   return this->enableDrawItem( false );
  178.   }
  179.  
  180. ISize ValueSet :: dimensions ( ) const
  181.   {
  182.   ISize
  183.     result;
  184.   IString
  185.     ctlData = ValueSet::controlData( ISize( 0, 0 ) );
  186.   WNDPARAMS
  187.     parms = { WPM_CTLDATA,
  188.               0,
  189.               0,
  190.               0,
  191.               0,
  192.               ((VSCDATA*)(char*)ctlData)->cbSize,
  193.               (char*)ctlData };
  194.   if ( sendEvent( WM_QUERYWINDOWPARAMS, &parms ) != 0 )
  195.     {
  196.     VSCDATA
  197.      *p = (VSCDATA*)( parms.pCtlData );
  198.     result = ISize( p->usColumnCount, p->usRowCount );
  199.     }
  200.   else
  201.     ITHROWGUIERROR( "WM_QUERYWINDOWPARAMS" );
  202.   return result;
  203.   }
  204.  
  205. unsigned long ValueSet :: numberOfRows ( ) const
  206.   {
  207.   return this->dimensions().height();
  208.   }
  209.  
  210. unsigned long ValueSet :: numberOfColumns ( ) const
  211.   {
  212.   return this->dimensions().width();
  213.   }
  214.  
  215. ValueSet &ValueSet :: setDimensions ( const ISize &dimensions )
  216.   {
  217.   IString
  218.     ctlData = ValueSet::controlData( dimensions );
  219.   WNDPARAMS
  220.     parms = { WPM_CTLDATA,
  221.               0,
  222.               0,
  223.               0,
  224.               0,
  225.               0,
  226.               (char*)ctlData };
  227.   if ( sendEvent( WM_SETWINDOWPARAMS, &parms ) == 0 )
  228.     ITHROWGUIERROR( "WM_SETWINDOWPARAMS" );
  229.   return *this;
  230.   }
  231.  
  232. ValueSet &ValueSet :: setNumberOfRows ( unsigned long rows )
  233.   {
  234.   return this->setDimensions( this->dimensions().setHeight( rows ) );
  235.   }
  236.  
  237. ValueSet &ValueSet :: setNumberOfColumns ( unsigned long columns )
  238.   {
  239.   return this->setDimensions( this->dimensions().setWidth( columns ) );
  240.   }
  241.  
  242. ValueSet::Item ValueSet :: item ( unsigned long row,
  243.                                   unsigned long column ) const
  244.   {
  245.   Item
  246.     result;
  247.   IEventParameter1
  248.     rowAndCol( row, column );
  249.   unsigned short
  250.     attr = sendEvent( VM_QUERYITEMATTR, rowAndCol );
  251.   if ( attr == VSERR_INVALID_PARAMETERS )
  252.     ITHROWGUIERROR( "VM_QUERYITEMATTR" );
  253.   else if ( attr & VIA_BITMAP )
  254.     result = Item( IBitmapHandle( itemHandle( row, column ) ),
  255.                    ItemStyle( attr & ~VIA_BITMAP ) );
  256.   else if ( attr & VIA_ICON )
  257.     result = Item( IPointerHandle( itemHandle( row, column ) ),
  258.                    ItemStyle( attr & ~VIA_ICON ) );
  259.   else if ( attr & VIA_TEXT )
  260.     {
  261.     VSTEXT
  262.       vstext = { 0, 0 };
  263.     unsigned
  264.       size = sendEvent( VM_QUERYITEM, rowAndCol, &vstext );
  265.     if ( size == VSERR_INVALID_PARAMETERS )
  266.       ITHROWGUIERROR( "VM_QUERYITEM" );
  267.     IString
  268.       text( 0, size );
  269.     vstext.ulBufLen = size + 1;
  270.     vstext.pszItemText = text;
  271.     unsigned
  272.       rc = sendEvent( VM_QUERYITEM, rowAndCol, &vstext );
  273.     if ( rc == VSERR_INVALID_PARAMETERS )
  274.       ITHROWGUIERROR( "VM_QUERYITEM" );
  275.     result = Item( text, ItemStyle( attr & ~VIA_TEXT ) );
  276.     }
  277.   else 
  278.     {
  279.     unsigned
  280.       index = itemHandle( row, column );
  281.     if ( attr & VIA_RGB )
  282.       {
  283.       unsigned
  284.         red   = index >> 16,
  285.         green = ( index >> 8 ) % 256,
  286.         blue  = index % 256;
  287.       result = Item( IColor( red, green, blue ),
  288.                      ItemStyle( attr & ~VIA_RGB ) );
  289.       }
  290.     else
  291.       {
  292.       IPresSpaceHandle
  293.         hps = presSpace();
  294.       long
  295.         rgbIndex = GpiQueryRGBColor( hps, 0, index );
  296.       releasePresSpace( hps );
  297.       if ( rgbIndex >= 0 )
  298.         {
  299.         unsigned
  300.           red   = rgbIndex >> 16,
  301.           green = ( rgbIndex >> 8 ) % 256,
  302.           blue  = rgbIndex % 256;
  303.         result = Item( IColor( red, green, blue ),
  304.                        ItemStyle( attr & ~VIA_COLORINDEX ) );
  305.         }
  306.       else
  307.         ITHROWSYSTEMERROR( rgbIndex, 
  308.                            "GpiQueryRGBColor", 
  309.                            ISystemErrorInfo::accessError,
  310.                            recoverable );
  311.       }
  312.     }
  313.   return result;
  314.   }
  315.  
  316. ValueSet &ValueSet :: setItem ( unsigned long  row,
  317.                                 unsigned long  column,
  318.                                 const Item    &item )
  319.   {
  320.   unsigned long
  321.     attr = item.style().asUnsignedLong();
  322.   IEventParameter2
  323.     mp2 = 0;
  324.   IString
  325.     text = item.text();
  326.   if ( item.containsBitmap() )
  327.     {
  328.     attr |= VIA_BITMAP;
  329.     mp2 = IEventParameter2( item.bitmap() );
  330.     }
  331.   else if ( item.containsIcon() )
  332.     {
  333.     attr |= VIA_ICON;
  334.     mp2 = IEventParameter2( item.icon() );
  335.     }
  336.   else if ( item.containsText() )
  337.     {
  338.     attr |= VIA_TEXT;
  339.     mp2 = (char*)text;
  340.     }
  341.   else if ( item.containsColor() )
  342.     {
  343.     attr |= VIA_RGB;
  344.     mp2 = (int)( item.color().asRGBLong() );
  345.     }
  346.   else
  347.     return *this;
  348.  
  349.   // Turn off all zero bits:
  350.   setItemAttributes( row, 
  351.                      column,
  352.                      IEventParameter2( ~attr & 0x1e0, false ) );
  353.   // Turn on all one bits.
  354.   setItemAttributes( row, 
  355.                      column,
  356.                      IEventParameter2( attr, true ) );
  357.   // Set item contents.
  358.   setItem( row, column, mp2 );
  359.  
  360.   return *this;
  361.   }
  362.  
  363. ValueSet &ValueSet :: setItemContents ( unsigned long      row,
  364.                                         unsigned long      column,
  365.                                         const IResourceId &resId,
  366.                                         ItemType           type )
  367.   {
  368.   const IResourceLibrary
  369.    &resLib = resId.resourceLibrary();
  370.   switch ( type )
  371.     {
  372.     case bitmapItem:
  373.       setItemContents( row, column, resLib.loadBitmap( resId.id() ) );
  374.       break;
  375.     case iconItem:
  376.       setItemContents( row, column, resLib.loadIcon( resId.id() ) );
  377.       break;
  378.     case textItem:
  379.       setItemContents( row, column, resLib.loadString( resId.id() ) );
  380.       break;
  381.     }
  382.   return *this;
  383.   }
  384.  
  385. ValueSet &ValueSet :: setItemContents ( unsigned long row,
  386.                                         unsigned long column,
  387.                                         const IBitmapHandle &bmp )
  388.   {
  389.   setItemAttributes( row,
  390.                      column,
  391.                      IEventParameter2( VIA_BITMAP, true ) );
  392.   setItem( row,
  393.            column,
  394.            IEventParameter2( bmp ) );
  395.   return *this;
  396.   }
  397.  
  398. ValueSet &ValueSet :: setItemContents ( unsigned long row,
  399.                                         unsigned long column,
  400.                                         const IPointerHandle &icon )
  401.   {
  402.   setItemAttributes( row,
  403.                      column,
  404.                      IEventParameter2( VIA_ICON, true ) );
  405.   setItem( row,
  406.            column,
  407.            IEventParameter2( icon ) );
  408.   return *this;
  409.   }
  410.  
  411. ValueSet &ValueSet :: setItemContents ( unsigned long  row,
  412.                                         unsigned long  column,
  413.                                         const IString &text )
  414.   {
  415.   setItemAttributes( row,
  416.                      column,
  417.                      IEventParameter2( VIA_TEXT, true ) );
  418.   setItem( row,
  419.            column,
  420.            (char*)text );
  421.   return *this;
  422.   }
  423.  
  424. ValueSet &ValueSet :: setItemContents ( unsigned long row,
  425.                                         unsigned long column,
  426.                                         const IColor &color )
  427.   {
  428.   setItemAttributes( row,
  429.                      column,
  430.                      IEventParameter2( VIA_RGB, true ) );
  431.   setItem( row,
  432.            column,
  433.            (int)( color.asRGBLong() ) );
  434.   return *this;
  435.   }
  436.  
  437. ValueSet &ValueSet :: setItemStyle ( unsigned long row,
  438.                                      unsigned long column,
  439.                                      const ItemStyle &style )
  440.   {
  441.   unsigned long
  442.     attr = style.asUnsignedLong();
  443.   // Turn off all zero bits.
  444.   setItemAttributes( row,
  445.                      column,
  446.                      IEventParameter2( ~attr & 0x1e0, false ) );
  447.   // Turn on all one bits.
  448.   setItemAttributes( row,
  449.                      column,
  450.                      IEventParameter2( attr, true ) );
  451.   return *this;
  452.   }
  453.  
  454. Boolean ValueSet :: hasSelection ( ) const
  455.   {
  456.   return selection() != IPoint( 0, 0 );
  457.   }
  458.  
  459. ValueSet &ValueSet :: setSelection ( unsigned row,
  460.                                      unsigned column )
  461.   {
  462.   unsigned long
  463.     rc = sendEvent( VM_SELECTITEM,
  464.                     IEventParameter1( row, column ) );
  465.   if ( !rc )
  466.     ITHROWGUIERROR( "VM_SELECTITEM" );
  467.   return *this;
  468.   }
  469.  
  470. ValueSet::Item ValueSet :: selectedItem ( ) const
  471.   {
  472.   IPoint
  473.     pt = selection();
  474.   return item( pt.y(), pt.x() );
  475.   }
  476.  
  477. IPoint ValueSet :: selection ( ) const
  478.   {
  479.   unsigned long
  480.     rowAndCol = sendEvent( VM_QUERYSELECTEDITEM );
  481.   return IPoint( rowAndCol >> 16,
  482.                  rowAndCol & 0xffffU );
  483.   }
  484.  
  485. unsigned long ValueSet :: selectedRow ( ) const
  486.   {
  487.   return selection().y();
  488.   }
  489.  
  490. unsigned long ValueSet :: selectedColumn ( ) const
  491.   {
  492.   return selection().x();
  493.   }
  494.  
  495. ISize ValueSet :: itemSize ( ) const
  496.   {
  497.   return metrics( VMA_ITEMSIZE );
  498.   }
  499.  
  500. ISize ValueSet :: itemSpacing ( ) const
  501.   {
  502.   return metrics( VMA_ITEMSPACING );
  503.   }
  504.  
  505. ValueSet &ValueSet :: setItemSize ( const ISize &size )
  506.   {
  507.   setMetrics( VMA_ITEMSIZE,
  508.               size );
  509.   return *this;
  510.   }
  511.  
  512. ValueSet &ValueSet :: setItemSpacing ( const ISize &size )
  513.   {
  514.   setMetrics( VMA_ITEMSPACING,
  515.               size );
  516.   return *this;
  517.   }
  518.  
  519. IColor ValueSet :: color ( ColorArea area ) const
  520.   {
  521.   unsigned long
  522.     colorArea;
  523.   IGUIColor
  524.     defaultColor( IGUIColor::windowBgnd );
  525.   switch ( area )
  526.     {
  527.     case borders:
  528.       colorArea    = PP_BORDERCOLOR;
  529.       defaultColor = IGUIColor::frameBorder;
  530.       break;
  531.     case foreground:
  532.       colorArea    = PP_FOREGROUNDCOLOR;
  533.       defaultColor = IGUIColor::windowText;
  534.       break;
  535.     case background:
  536.       colorArea    = PP_BACKGROUNDCOLOR;
  537.       defaultColor = IGUIColor::windowBgnd;
  538.       break;
  539.     case highlightBackground:
  540.       colorArea    = PP_HILITEBACKGROUNDCOLOR;
  541.       defaultColor = IGUIColor::hiliteBgnd;
  542.       break;
  543.     }
  544.   return IWindow::color( colorArea, defaultColor );
  545.   }
  546.  
  547. ValueSet &ValueSet :: setColor ( ColorArea     area,
  548.                                  const IColor &color )
  549.   {
  550.   unsigned long
  551.     colorArea;
  552.   switch ( area )
  553.     {
  554.     case borders:
  555.       colorArea    = PP_BORDERCOLOR;
  556.       break;
  557.     case foreground:
  558.       colorArea    = PP_FOREGROUNDCOLOR;
  559.       break;
  560.     case background:
  561.       colorArea    = PP_BACKGROUNDCOLOR;
  562.       break;
  563.     case highlightBackground:
  564.       colorArea    = PP_HILITEBACKGROUNDCOLOR;
  565.       break;
  566.     }
  567.   IWindow::setColor( colorArea, color );
  568.   return *this;
  569.   }
  570.  
  571. void ValueSet :: initialize ( const ISize      &size,
  572.                               unsigned long     id,
  573.                               IWindow          *parent,
  574.                               IWindow          *owner,
  575.                               const IRectangle &initial,
  576.                               const Style      &style )
  577.   {
  578.   IString
  579.     ctlData = ValueSet::controlData( size );
  580.   IWindowHandle
  581.     hwnd = this -> create( id,
  582.                            0,
  583.                            style.asUnsignedLong(),
  584.                            WC_VALUESET,
  585.                            parent->handle(),
  586.                            owner ? owner->handle() : IWindowHandle(0),
  587.                            initial,
  588.                            (char*)ctlData,
  589.                            0 );
  590.   this -> startHandlingEventsFor( hwnd );
  591.   }
  592.  
  593. void ValueSet :: initialize ( const IWindowHandle &hwnd )
  594.   {
  595.   IASSERTPARM( hwnd.isValid() );
  596.   IString
  597.     className( "#nn" );
  598.   WinQueryClassName( hwnd, 4, className );
  599.   IASSERTSTATE( className == "#39" );
  600.   this -> startHandlingEventsFor( hwnd );
  601.   this -> setAutoDestroyWindow( false );
  602.   }
  603.  
  604. void ValueSet :: setItemAttributes ( unsigned long           row,
  605.                                      unsigned long           column,
  606.                                      const IEventParameter2 &attr )
  607.   {
  608.   IEventParameter1
  609.     coord( row, column );
  610.   if ( sendEvent( VM_SETITEMATTR,
  611.                   coord,
  612.                   attr ) == 0 )
  613.     ITHROWGUIERROR( "VM_SETITEMATTR" );
  614.   }
  615.  
  616. void ValueSet :: setItem ( unsigned long           row,
  617.                            unsigned long           column,
  618.                            const IEventParameter2 &contents )
  619.   {
  620.   IEventParameter1
  621.     coord( row, column );
  622.   if ( sendEvent( VM_SETITEM,
  623.                   coord,
  624.                   contents ) == 0 )
  625.     ITHROWGUIERROR( "VM_SETITEM" );
  626.   }
  627.  
  628. void ValueSet :: setMetrics ( const IEventParameter1 &mp1,
  629.                               const ISize            &size )
  630.   {
  631.   unsigned long
  632.     rc = sendEvent( VM_SETMETRICS,
  633.                     mp1,
  634.                     IEventParameter2( size.width(), size.height() ) );
  635.   if ( !rc )
  636.     ITHROWGUIERROR( "VM_SETMETRICS" );
  637.   }
  638.  
  639. IString ValueSet :: controlData ( const ISize &size )
  640.   {
  641.   IString
  642.     result( 0, sizeof( VSCDATA ) );
  643.   VSCDATA
  644.    *p = (VSCDATA*)(char*)result;
  645.   p->cbSize = sizeof( VSCDATA );
  646.   p->usRowCount = size.height();
  647.   p->usColumnCount = size.width();
  648.   return result;
  649.   }
  650.  
  651. unsigned long ValueSet :: itemHandle ( unsigned long row,
  652.                                        unsigned long column ) const
  653.   {
  654.   IEventParameter1
  655.     rowAndCol( row, column );
  656.   unsigned long
  657.     rc = sendEvent( VM_QUERYITEM, rowAndCol, 0 );
  658.   IASSERTSTATE( rc != VSERR_INVALID_PARAMETERS );
  659.   return rc;
  660.   }
  661.  
  662. ISize ValueSet :: metrics ( const IEventParameter1 &mp1 ) const
  663.   {
  664.   unsigned long
  665.     rc = sendEvent( VM_QUERYMETRICS,
  666.                     mp1 );
  667.   if ( rc == VSERR_INVALID_PARAMETERS )
  668.     ITHROWGUIERROR( "VM_QUERYMETRICS" );
  669.   return ISize( rc & 0xffffU,
  670.                 rc >> 16 );
  671.   }
  672.  
  673. ISize ValueSet :: calcMinimumSize ( ) const
  674.   {
  675.   ISize
  676.     dim = dimensions();
  677.   // Find widest and tallest items...
  678.   unsigned
  679.     widest  = 0,
  680.     tallest = 0;
  681.   for ( unsigned row = 0; row < dim.height(); row++ )
  682.     for ( unsigned col = 0; col < dim.width(); col++ )
  683.       {
  684.       Item
  685.         cell = item( row+1, col+1 );
  686.       ISize
  687.         size;
  688.       switch ( cell.itemType )
  689.         {
  690.         case ValueSet::Item::emptyItem:
  691.           // Empty items must be at least 2x2.
  692.           size = ISize( 2, 2 );
  693.           break;
  694.         case ValueSet::Item::colorItem:
  695.           // We'll make color items at least 5x5.
  696.           size = ISize( 5, 5 );
  697.           break;
  698.         case ValueSet::Item::bitmapItem:
  699.           // We'll make bitmap items at least 50x50.
  700.           size = ISize( 50, 50 );
  701.           break;
  702.         case ValueSet::Item::iconItem:
  703.           // We'll make icon items at least 32x32.
  704.           size = ISize( 32, 32 );
  705.           break;
  706.         case ValueSet::Item::textItem:
  707.           // We'll make text items average char size * length of text.
  708.           size = ((ValueSet*)this)->characterSize()
  709.                    .scaledBy( cell.text().length(), 1 );
  710.           break;
  711.         }
  712.       // Update maximums if this item is bigger...
  713.       if ( size.width() > widest )
  714.         widest = size.width();
  715.       if ( size.height() > tallest )
  716.         tallest = size.height();
  717.       }
  718.   // Calculate size that will hold all items + 12 for border:
  719.   ISize
  720.     min = ISize( widest  * dim.width() + 12,
  721.                  tallest * dim.height() + 12 );
  722.   ISize
  723.     space = itemSpacing();
  724.   // Add horizontal space, including 7 for border/highlighting:
  725.   if ( dim.width() > 1 )
  726.     min.setWidth( min.width() 
  727.                   + 
  728.                   (dim.width()-1)*( space.width() + 7 ) );
  729.   // Add vertical space, including 7 for border/highlighting:
  730.   if ( dim.height() > 1 )
  731.     min.setHeight( min.height() 
  732.                    + 
  733.                    (dim.height()-1)*( space.height() + 7 ) );
  734.   return min;
  735.   }
  736.  
  737. //============================== ValueSet::Item ================================
  738.  
  739. ValueSet::Item :: Item ( )
  740.   : itemType( emptyItem ),
  741.     itemColor( IColor::white ),
  742.     itemStyle( defaultStyle() )
  743.   {
  744.   }
  745.  
  746. ValueSet::Item :: Item ( const IResourceId &resId,
  747.                          ItemType           type,
  748.                          const ItemStyle   &style )
  749.   : itemType( emptyItem ),
  750.     itemColor( IColor::white ),
  751.     itemStyle( style )
  752.   {
  753.   switch ( type )
  754.     {
  755.     case bitmapItem:
  756.       itemBmpHandle = resId.resourceLibrary().loadBitmap( resId.id() );
  757.       itemType = bitmapItem;
  758.       break;
  759.     case iconItem:
  760.       itemPtrHandle = resId.resourceLibrary().loadPointer( resId.id() );
  761.       itemType = iconItem;
  762.       break;
  763.     case textItem:
  764.       itemText = resId.resourceLibrary().loadString( resId.id() );
  765.       itemType = textItem;
  766.       break;
  767.     default:
  768.       break;
  769.     }
  770.   }
  771.  
  772. ValueSet::Item :: Item ( const IBitmapHandle &bmp,
  773.                          const ItemStyle     &style )
  774.   : itemType( bitmapItem ),
  775.     itemBmpHandle( bmp ),
  776.     itemColor( IColor::white ),
  777.     itemStyle( style )
  778.   {
  779.   }
  780.  
  781. ValueSet::Item :: Item ( const IPointerHandle &ptr,
  782.                          const ItemStyle      &style )
  783.   : itemType( iconItem ),
  784.     itemPtrHandle( ptr ),
  785.     itemColor( IColor::white ),
  786.     itemStyle( style )
  787.   {
  788.   }
  789.  
  790. ValueSet::Item :: Item ( const IString   &text,
  791.                          const ItemStyle &style )
  792.   : itemType( textItem ),
  793.     itemText( text ),
  794.     itemColor( IColor::white ),
  795.     itemStyle( style )
  796.   {
  797.   }
  798.  
  799. ValueSet::Item :: Item ( const IColor    &color,
  800.                          const ItemStyle &style )
  801.   : itemType( colorItem ),
  802.     itemColor( color ),
  803.     itemStyle( style )
  804.   {
  805.   }
  806.  
  807. ValueSet::Item :: Item ( const Item &item )
  808.   : itemType     ( item.itemType ),
  809.     itemBmpHandle( item.itemBmpHandle ),
  810.     itemPtrHandle( item.itemPtrHandle ),
  811.     itemColor    ( item.itemColor ),
  812.     itemText     ( item.itemText  ),
  813.     itemStyle    ( item.itemStyle )
  814.   {
  815.   }
  816.  
  817. ValueSet::Item :: ~Item ( )
  818.   {
  819.   }
  820.  
  821. ValueSet::ItemStyle ValueSet::Item :: style ( ) const
  822.   {
  823.   return itemStyle;
  824.   }
  825.  
  826. ValueSet::Item &ValueSet::Item :: setStyle ( const ItemStyle &style )
  827.   {
  828.   itemStyle = style;
  829.   return *this;
  830.   }
  831.  
  832. ValueSet::ItemStyle ValueSet::Item :: defaultStyle ( )
  833.   {
  834.   return dfltStyle;
  835.   }
  836.  
  837. void ValueSet::Item :: setDefaultStyle ( const ItemStyle &style )
  838.   {
  839.   dfltStyle = style;
  840.   }
  841.  
  842. Boolean ValueSet::Item :: isDisabled ( ) const
  843.   {
  844.   return itemStyle & disabled;
  845.   }
  846.  
  847. Boolean ValueSet::Item :: isEnabled ( ) const
  848.   {
  849.   return !isDisabled();
  850.   }
  851.  
  852. Boolean ValueSet::Item :: canBeDragged ( ) const
  853.   {
  854.   return itemStyle & dragSource;
  855.   }
  856.  
  857. Boolean ValueSet::Item :: canBeDroppedOn ( ) const
  858.   {
  859.   return itemStyle & dropTarget;
  860.   }
  861.  
  862. Boolean ValueSet::Item :: isOwnerDraw ( ) const
  863.   {
  864.   return itemStyle & itemOwnerDraw;
  865.   }
  866.  
  867. ValueSet::Item &ValueSet::Item :: enable ( Boolean enable )
  868.   {
  869.   if ( enable )
  870.     setStyle( style() | disabled );
  871.   else
  872.     setStyle( style() & ~disabled );
  873.   return *this;
  874.   }
  875.  
  876. ValueSet::Item &ValueSet::Item :: disable ( )
  877.   {
  878.   return enable( false );
  879.   }
  880.  
  881. ValueSet::Item &ValueSet::Item :: enableDrag ( Boolean enable )
  882.   {
  883.   if ( enable )
  884.     setStyle( style() | dragSource );
  885.   else
  886.     setStyle( style() & ~dragSource );
  887.   return *this;
  888.   }
  889.  
  890. ValueSet::Item &ValueSet::Item :: disableDrag ( )
  891.   {
  892.   return enableDrag( false );
  893.   }
  894.  
  895. ValueSet::Item &ValueSet::Item :: enableDrop ( Boolean enable )
  896.   {
  897.   if ( enable )
  898.     setStyle( style() | dropTarget );
  899.   else
  900.     setStyle( style() & ~dropTarget );
  901.   return *this;
  902.   }
  903.  
  904. ValueSet::Item &ValueSet::Item :: disableDrop ( )
  905.   {
  906.   return enableDrop( false );
  907.   }
  908.  
  909. ValueSet::Item &ValueSet::Item :: setOwnerDraw ( Boolean setting )
  910.   {
  911.   if ( enable )
  912.     setStyle( style() | itemOwnerDraw );
  913.   else
  914.     setStyle( style() & ~itemOwnerDraw );
  915.   return *this;
  916.   }
  917.  
  918. Boolean ValueSet::Item :: isEmpty ( ) const
  919.   {
  920.   return itemType == emptyItem;
  921.   }
  922.  
  923. Boolean ValueSet::Item :: containsBitmap ( ) const
  924.   {
  925.   return itemType == bitmapItem;
  926.   }
  927.  
  928. Boolean ValueSet::Item :: containsIcon   ( ) const
  929.   {
  930.   return itemType == iconItem;
  931.   }
  932.  
  933. Boolean ValueSet::Item :: containsText   ( ) const 
  934.   {
  935.   return itemType == textItem;
  936.   }
  937.  
  938. Boolean ValueSet::Item :: containsColor  ( ) const
  939.   {
  940.   return itemType == colorItem;
  941.   }
  942.  
  943. IBitmapHandle ValueSet::Item :: bitmap ( ) const
  944.   {
  945.   return itemBmpHandle;
  946.   }
  947.  
  948. IPointerHandle ValueSet::Item :: icon ( ) const
  949.   {
  950.   return itemPtrHandle;
  951.   }
  952.  
  953. IString ValueSet::Item :: text ( ) const
  954.   {
  955.   return itemText;
  956.   }
  957.  
  958. IColor ValueSet::Item :: color ( ) const
  959.   {
  960.   return itemColor;
  961.   }
  962.