home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c082_122 / 10.ddi / TVSRC.ZIP / COLORSEL.CPP next >
Encoding:
C/C++ Source or Header  |  1992-06-10  |  18.3 KB  |  734 lines
  1. /*------------------------------------------------------------*/
  2. /* filename -       colorsel.cpp                              */
  3. /*                                                            */
  4. /* function(s)                                                */
  5. /*                  Member function(s) of following classes   */
  6. /*                      TColorSelector                        */
  7. /*                      TMonoSelector                         */
  8. /*                      TColorDisplay                         */
  9. /*                      TColorItem                            */
  10. /*                      TColorItemList                        */
  11. /*                      TColorGroup                           */
  12. /*                      TColorGroupList                       */
  13. /*                      TColorDialog                          */
  14. /*------------------------------------------------------------*/
  15.  
  16. /*------------------------------------------------------------*/
  17. /*                                                            */
  18. /*    Turbo Vision -  Version 1.0                             */
  19. /*                                                            */
  20. /*                                                            */
  21. /*    Copyright (c) 1991 by Borland International             */
  22. /*    All Rights Reserved.                                    */
  23. /*                                                            */
  24. /*------------------------------------------------------------*/
  25.  
  26. #define Uses_TKeys
  27. #define Uses_TColorSelector
  28. #define Uses_TMonoSelector
  29. #define Uses_TColorDisplay
  30. #define Uses_TColorItem
  31. #define Uses_TColorItemList
  32. #define Uses_TColorGroup
  33. #define Uses_TColorGroupList
  34. #define Uses_TColorDialog
  35. #define Uses_TEvent
  36. #define Uses_TDrawBuffer
  37. #define Uses_TGroup
  38. #define Uses_TSItem
  39. #define Uses_TScrollBar
  40. #define Uses_TLabel
  41. #define Uses_TButton
  42. #define Uses_TRect
  43. #define Uses_opstream
  44. #define Uses_ipstream
  45. #include <tv.h>
  46.  
  47. #if !defined( __STRING_H )
  48. #include <STring.h>
  49. #endif  // __STRING_H
  50.  
  51. TColorItem::TColorItem( const char *nm, uchar idx, TColorItem *nxt )
  52. {
  53.     index = idx;
  54.     next = nxt;
  55.     name = newStr( nm );
  56. }
  57.  
  58. TColorItem::~TColorItem()
  59. {
  60.     delete (char *)name;
  61. }
  62.  
  63. TColorGroup::TColorGroup( const char *nm, TColorItem *itm, TColorGroup *nxt )
  64. {
  65.     items = itm;
  66.     next = nxt;
  67.     name = newStr( nm );
  68. }
  69.  
  70. TColorGroup::~TColorGroup()
  71. { 
  72.     delete (char *)name;
  73. }
  74.  
  75. TColorItem& operator + ( TColorItem& i1, TColorItem& i2 )
  76. {
  77.     TColorItem *cur = &i1;
  78.     while( cur->next != 0 )
  79.         cur = cur->next;
  80.     cur->next = &i2;
  81.     return i1;
  82. }
  83.  
  84. TColorGroup& operator + ( TColorGroup& g, TColorItem& i )
  85. {
  86.     TColorGroup *grp = &g;
  87.     while( grp->next != 0 )
  88.         grp = grp->next;
  89.  
  90.     if( grp->items == 0 )
  91.         grp->items = &i;
  92.     else
  93.         {
  94.         TColorItem *cur = grp->items;
  95.         while( cur->next != 0 )
  96.             cur = cur->next;
  97.         cur->next = &i;
  98.         }
  99.     return g;
  100. }
  101.  
  102. TColorGroup& operator + ( TColorGroup& g1, TColorGroup& g2 )
  103. {
  104.     TColorGroup *cur = &g1;
  105.     while( cur->next != 0 )
  106.         cur = cur->next;
  107.     cur->next = &g2;
  108.     return g1;
  109. }
  110.  
  111.  
  112. TColorSelector::TColorSelector( const TRect& bounds, ColorSel aSelType ) :
  113.     TView( bounds )
  114. {
  115.     options |= ofSelectable | ofFirstClick | ofFramed;
  116.     eventMask |= evBroadcast;
  117.     selType = aSelType;
  118.     color = 0;
  119. }
  120.  
  121. void TColorSelector::draw()
  122. {
  123.     TDrawBuffer b;
  124.     b.moveChar( 0, ' ', 0x70, size.x );
  125.     for(int i = 0; i <= size.y; i++ )
  126.         {
  127.         if( i < 4 )
  128.             {
  129.             for( int j = 0; j < 4; j++ )
  130.                 {
  131.                 int c = i*4+j;
  132.                 b.moveChar( j*3, icon, c, 3 );
  133.                 if( c == color )
  134.                     {
  135.                     b.putChar( j*3+1, 8 );
  136.                     if( c == 0 )
  137.                         b.putAttribute( j*3+1, 0x70 );
  138.                     }
  139.                 }
  140.             }
  141.         writeLine( 0, i, size.x, 1, b );
  142.         }
  143. }
  144.  
  145. void TColorSelector::colorChanged()
  146. {
  147.     int msg;
  148.     if( selType == csForeground )
  149.         msg = cmColorForegroundChanged;
  150.     else
  151.         msg = cmColorBackgroundChanged;
  152.     message( owner, evBroadcast, msg, (void *)color );
  153. }
  154.  
  155. void TColorSelector::handleEvent( TEvent& event )
  156. {
  157.     const width = 4;
  158.  
  159.     TView::handleEvent( event );
  160.  
  161.     switch( event.what )
  162.         {
  163.  
  164.         case evMouseDown:
  165.             uchar oldColor = color;
  166.             do  {
  167.                 if( mouseInView( event.mouse.where ) )
  168.                     {
  169.                     TPoint mouse = makeLocal( event.mouse.where );
  170.                     color = mouse.y*4 + mouse.x/3;
  171.                     }
  172.                 else
  173.                     color = oldColor;
  174.                 colorChanged();
  175.                 drawView();
  176.                 } while( mouseEvent( event, evMouseMove ) );
  177.             break;
  178.  
  179.         case evKeyDown:
  180.             int maxCol = (selType == csBackground) ? 7 : 15;
  181.  
  182.             switch( ctrlToArrow( event.keyDown.keyCode ) )
  183.                 {
  184.                 case kbLeft:
  185.                     if( color > 0 )
  186.                         color--;
  187.                     else
  188.                         color = maxCol;
  189.                     break;
  190.  
  191.                 case kbRight:
  192.                     if( color < maxCol )
  193.                         color++;
  194.                     else
  195.                         color = 0;
  196.                     break;
  197.  
  198.                 case kbUp:
  199.                     if( color > width-1 )
  200.                         color -= width;
  201.                     else if( color == 0 )
  202.                         color = maxCol;
  203.                     else
  204.                         color += maxCol - width;
  205.                     break;
  206.  
  207.                 case kbDown:
  208.                     if( color < maxCol - (width-1) )
  209.                         color += width;
  210.                     else if( color == maxCol )
  211.                         color = 0;
  212.                     else
  213.                         color -= maxCol - width;
  214.                     break;
  215.  
  216.                 default:
  217.                     return;
  218.                 }
  219.             break;
  220.  
  221.         case evBroadcast:
  222.             if( event.message.command == cmColorSet )
  223.                 {
  224.                 if( selType == csBackground )
  225.                     color = event.message.infoByte >> 4;
  226.                 else
  227.                     color = event.message.infoByte & 0x0F;
  228.                 drawView();
  229.                 return ;
  230.                 }
  231.             else
  232.                 return;
  233.         default:
  234.             return ;
  235.         }
  236.     drawView();
  237.     colorChanged();
  238.     clearEvent( event );
  239. }
  240.  
  241. void TColorSelector::write( opstream& os )
  242. {
  243.     TView::write( os );
  244.     os << color << (int)selType;
  245. }
  246.  
  247. void *TColorSelector::read( ipstream& is )
  248. {
  249.     int temp;
  250.     TView::read( is );
  251.     is >> color >> temp;
  252.     selType = ColorSel(temp);
  253.     return this;
  254. }
  255.  
  256. TStreamable *TColorSelector::build()
  257. {
  258.     return new TColorSelector( streamableInit );
  259. }
  260.  
  261. TColorSelector::TColorSelector( StreamableInit ) : TView( streamableInit )
  262. {
  263. }
  264.  
  265. const uchar monoColors[] = { 0x07, 0x0F, 0x01, 0x70, 0x09 };
  266.  
  267. TMonoSelector::TMonoSelector( const TRect& bounds ) :
  268.     TCluster( bounds, new TSItem( normal,
  269.                       new TSItem( highlight,
  270.                       new TSItem( underline,
  271.                       new TSItem( inverse,  0 )))))
  272. {
  273.     eventMask |= evBroadcast;
  274. }
  275.  
  276. void TMonoSelector::draw()
  277. {
  278.     drawBox( button, 0x07 );
  279. }
  280.  
  281. void TMonoSelector::handleEvent( TEvent& event )
  282. {
  283.     TCluster::handleEvent( event );
  284.     if( event.what == evBroadcast && event.message.command == cmColorSet )
  285.         {
  286.         value = event.message.infoByte;
  287.         drawView();
  288.         }
  289. }
  290.  
  291. Boolean TMonoSelector::mark( int item )
  292. {
  293.     return Boolean(monoColors[item] == value);
  294. }
  295.  
  296. void TMonoSelector::newColor()
  297. {
  298.     message( owner, evBroadcast, cmColorForegroundChanged,
  299.         (void *)(value & 0x0F) );
  300.     message( owner, evBroadcast, cmColorBackgroundChanged,
  301.         (void *)((value >> 4) & 0x0F));
  302. }
  303.  
  304. void TMonoSelector::press( int item )
  305. {
  306.     value = monoColors[item];
  307.     newColor();
  308. }
  309.  
  310. void TMonoSelector::movedTo( int item )
  311. {
  312.     value = monoColors[item];
  313.     newColor();
  314. }
  315.  
  316. TStreamable *TMonoSelector::build()
  317. {
  318.     return new TMonoSelector( streamableInit );
  319. }
  320.  
  321. TMonoSelector::TMonoSelector( StreamableInit ) : TCluster( streamableInit )
  322. {
  323. }
  324.  
  325. TColorDisplay::TColorDisplay( const TRect& bounds, const char *aText ) :
  326.     TView( bounds ),
  327.     text( newStr( aText ) ),
  328.     color( 0 )
  329. {
  330.   eventMask |= evBroadcast;
  331. }
  332.  
  333. TColorDisplay::~TColorDisplay()
  334. {
  335.     delete (char *)text;
  336. }
  337.  
  338. void TColorDisplay::draw()
  339. {
  340.     uchar c = *color;
  341.     if( c == 0 )
  342.         c = errorAttr;
  343.     const int len = strlen( text );
  344.     TDrawBuffer b;
  345.     for( int i = 0; i <= size.x/len; i++ )
  346.         b.moveStr( i*len, text, c );
  347.     writeLine( 0, 0, size.x, size.y, b );
  348. }
  349.  
  350. void TColorDisplay::handleEvent( TEvent& event )
  351. {
  352.     TView::handleEvent( event );
  353.     if( event.what == evBroadcast )
  354.         switch( event.message.command )
  355.             {
  356.             case cmColorBackgroundChanged:
  357.                 *color = (*color & 0x0F) | ((event.message.infoByte << 4) & 0xF0);
  358.                 drawView();
  359.                 break;
  360.  
  361.             case cmColorForegroundChanged:
  362.                 *color = (*color & 0xF0) | (event.message.infoByte & 0x0F);
  363.                 drawView();
  364.             }
  365. }
  366.  
  367. void TColorDisplay::setColor( uchar *aColor )
  368. {
  369.     color = aColor;
  370.     message( owner, evBroadcast, cmColorSet, (void *)(*color) );
  371.     drawView();
  372. }
  373.  
  374. void TColorDisplay::write( opstream& os )
  375. {
  376.     TView::write( os );
  377.     os.writeString( text );
  378. }
  379.  
  380. void *TColorDisplay::read( ipstream& is )
  381. {
  382.     TView::read( is );
  383.     text = is.readString();
  384.     color = 0;
  385.     return this;
  386. }
  387.  
  388. TStreamable *TColorDisplay::build()
  389. {
  390.     return new TColorDisplay( streamableInit );
  391. }
  392.  
  393. TColorDisplay::TColorDisplay( StreamableInit ) : TView( streamableInit )
  394. {
  395. }
  396.  
  397. TColorGroupList::TColorGroupList( const TRect& bounds,
  398.                                   TScrollBar *aScrollBar,
  399.                                   TColorGroup *aGroups
  400.                                 ) :
  401.     TListViewer( bounds, 1, 0, aScrollBar ),
  402.     groups( aGroups )
  403. {
  404.     int i = 0;
  405.     while( aGroups != 0 )
  406.         {
  407.         aGroups = aGroups->next;
  408.         i++;
  409.         }
  410.     setRange(i);
  411. }
  412.  
  413. static void freeItems( TColorItem *curItem )
  414. {
  415.     while( curItem != 0 )
  416.         {
  417.         TColorItem *p = curItem;
  418.         curItem = curItem->next;
  419.         delete p;
  420.         }
  421. }
  422.  
  423. static void freeGroups( TColorGroup *curGroup )
  424. {
  425.     while( curGroup != 0 )
  426.         {
  427.         TColorGroup *p = curGroup;
  428.         freeItems( curGroup->items );
  429.         curGroup = curGroup->next;
  430.         delete p;
  431.         }
  432. }
  433.  
  434. TColorGroupList::~TColorGroupList()
  435. {
  436.     freeGroups( groups );
  437. }
  438.  
  439. void TColorGroupList::focusItem( short item )
  440. {
  441.     TListViewer::focusItem( item );
  442.     TColorGroup *curGroup = groups;
  443.     while( item-- > 0 )
  444.         curGroup = curGroup->next;
  445.     message( owner, evBroadcast, cmNewColorItem, curGroup->items);
  446. }
  447.  
  448. void TColorGroupList::getText( char *dest, short item, short maxChars )
  449. {
  450.     TColorGroup *curGroup = groups;
  451.     while( item-- > 0 )
  452.         curGroup = curGroup->next;
  453.     strncpy( dest, curGroup->name, maxChars );
  454.     dest[maxChars] = '\0';
  455. }
  456.  
  457. void TColorGroupList::writeItems( opstream& os, TColorItem *items )
  458. {
  459.     int count = 0;
  460.     TColorItem *cur;
  461.  
  462.     for( cur = items; cur != 0; cur = cur->next )
  463.         count++;
  464.  
  465.     os << count;
  466.  
  467.     for( cur = items; cur != 0; cur = cur->next )
  468.         {
  469.         os.writeString( cur->name );
  470.         os << cur->index;
  471.         }
  472. }
  473.  
  474. void TColorGroupList::writeGroups( opstream& os, TColorGroup *groups )
  475. {
  476.     int count = 0;
  477.     TColorGroup *cur;
  478.  
  479.     for( cur = groups; cur != 0; cur = cur->next )
  480.         count++;
  481.  
  482.     os << count;
  483.  
  484.     for( cur = groups; cur != 0; cur = cur->next )
  485.         {
  486.         os.writeString( cur->name );
  487.         writeItems( os, cur->items );
  488.         }
  489. }
  490.                                     
  491. void TColorGroupList::write( opstream& os )
  492. {
  493.     TListViewer::write( os );
  494.     writeGroups( os, groups );
  495. }
  496.  
  497. TColorItem *TColorGroupList::readItems( ipstream& is )
  498. {
  499.     int count;
  500.     is >> count;
  501.     TColorItem *items = 0;
  502.     TColorItem **cur = &items;
  503.     while( count-- > 0 )
  504.         {
  505.         const char *nm = is.readString();
  506.         uchar index;
  507.         is >> index;
  508.         *cur = new TColorItem( nm, index );
  509.         cur = &((*cur)->next);
  510.         }
  511.     *cur = 0;
  512.     return items;
  513. }
  514.  
  515. TColorGroup *TColorGroupList::readGroups( ipstream& is )
  516. {
  517.     int count;
  518.     is >> count;
  519.     TColorGroup *groups = 0;
  520.     TColorGroup **cur = &groups;
  521.     while( count-- > 0 )
  522.         {
  523.         const char *nm = is.readString();
  524.         TColorItem *grp = readItems( is );
  525.         *cur = new TColorGroup( nm, grp );
  526.         cur = &((*cur)->next);
  527.         }
  528.     *cur = 0;
  529.     return groups;
  530. }
  531.  
  532. void *TColorGroupList::read( ipstream& is )
  533. {
  534.     TListViewer::read( is );
  535.     groups = readGroups( is );
  536.     return this;
  537. }
  538.  
  539. TStreamable *TColorGroupList::build()
  540. {
  541.     return new TColorGroupList( streamableInit );
  542. }
  543.  
  544. TColorGroupList::TColorGroupList( StreamableInit ) :
  545.     TListViewer( streamableInit )
  546. {
  547. }
  548.  
  549. TColorItemList::TColorItemList( const TRect& bounds,
  550.                                 TScrollBar *aScrollBar,
  551.                                 TColorItem *aItems
  552.                               ) :
  553.     TListViewer( bounds, 1, 0, aScrollBar ),
  554.     items( aItems )
  555. {
  556.     eventMask |= evBroadcast;
  557.     int i = 0;
  558.     while( aItems != 0 )
  559.         {
  560.         aItems = aItems->next;
  561.         i++;
  562.         }
  563.     setRange( i );
  564. }
  565.  
  566. void TColorItemList::focusItem( short item )
  567. {
  568.     TListViewer::focusItem( item );
  569.     TColorItem *curItem = items;
  570.     while( item-- > 0 )
  571.         curItem = curItem->next;
  572.     message( owner, evBroadcast, cmNewColorIndex, (void *)(curItem->index));
  573. }
  574.  
  575. void TColorItemList::getText( char *dest, short item, short maxChars )
  576. {
  577.     TColorItem *curItem = items;
  578.     while( item-- > 0 )
  579.         curItem = curItem->next;
  580.     strncpy( dest, curItem->name, maxChars );
  581.     dest[maxChars] = '\0';
  582. }
  583.  
  584. void TColorItemList::handleEvent( TEvent& event )
  585. {
  586.     TListViewer::handleEvent( event );
  587.     if( event.what == evBroadcast && event.message.command == cmNewColorItem )
  588.         {
  589.         items = (TColorItem *)event.message.infoPtr;
  590.         TColorItem *curItem = items;
  591.         int i = 0;
  592.         while( curItem != 0 )
  593.             {
  594.             curItem = curItem->next;
  595.             i++;
  596.             }
  597.         setRange( i );
  598.         focusItem( 0 );
  599.         drawView();
  600.         }
  601. }
  602.  
  603. TStreamable *TColorItemList::build()
  604. {
  605.     return new TColorItemList( streamableInit );
  606. }
  607.  
  608. TColorItemList::TColorItemList( StreamableInit ) :
  609.     TListViewer( streamableInit )
  610. {
  611. }
  612.  
  613. TColorDialog::TColorDialog( TPalette *aPalette, TColorGroup *aGroups ):
  614.     TDialog( TRect( 0, 0, 61, 18 ), colors ),
  615.     TWindowInit( &TColorDialog::initFrame )
  616. {
  617.     options |= ofCentered;
  618.     pal = aPalette;
  619.  
  620.     TScrollBar *sb = new TScrollBar( TRect( 18, 3, 19, 14 ) );
  621.     insert( sb );
  622.  
  623.     groups = new TColorGroupList( TRect( 3, 3, 18, 14 ), sb, aGroups);
  624.     insert( groups );
  625.     insert( new TLabel( TRect( 2, 2, 8, 3 ), groupText, groups ) );
  626.  
  627.     sb = new TScrollBar( TRect( 41, 3, 42, 14 ) );
  628.     insert( sb );
  629.  
  630.     TView *p = new TColorItemList( TRect( 21, 3, 41, 14 ), sb, aGroups->items );
  631.     insert( p );
  632.     insert( new TLabel( TRect( 20, 2, 25, 3 ), itemText, p ) );
  633.  
  634.     forSel = new TColorSelector( TRect( 45, 3, 57, 7 ),
  635.                                  TColorSelector::csForeground );
  636.     insert( forSel );
  637.     forLabel = new TLabel( TRect( 45, 2, 57, 3 ), forText, forSel );
  638.     insert( forLabel );
  639.  
  640.     bakSel = new TColorSelector( TRect( 45, 9, 57, 11 ),
  641.                                  TColorSelector::csBackground );
  642.     insert( bakSel );
  643.     bakLabel = new TLabel( TRect( 45, 8, 57, 9 ), bakText, bakSel );
  644.     insert( bakLabel );
  645.  
  646.     display = new TColorDisplay( TRect( 44, 12, 58, 14 ), textText );
  647.     insert( display );
  648.  
  649.     monoSel = new TMonoSelector( TRect( 44, 3, 59, 8 ) );
  650.     monoSel->hide();
  651.     insert( monoSel );
  652.     monoLabel = new TLabel( TRect( 43, 2, 49, 3 ), colorText, monoSel );
  653.     monoLabel->hide();
  654.     insert( monoLabel );
  655.  
  656.     if( aGroups != 0 && aGroups->items != 0 )
  657.         display->setColor( (uchar *)&pal->data[ aGroups->items->index ] );
  658.  
  659.     insert( new TButton( TRect( 36, 15, 46, 17 ), okText, cmOK, bfDefault ) );
  660.     insert( new TButton( TRect( 48, 15, 58, 17 ),
  661.                          cancelText,
  662.                          cmCancel,
  663.                          bfNormal ) );
  664.     selectNext( False );
  665. }
  666.  
  667. TColorDialog::~TColorDialog()
  668. { 
  669. }  
  670.  
  671. void TColorDialog::handleEvent( TEvent& event )
  672. {
  673.     TDialog::handleEvent( event );
  674.     if( event.what==evBroadcast && event.message.command==cmNewColorIndex )
  675.         display->setColor( (uchar *)&pal->data[event.message.infoByte] );
  676. }
  677.  
  678. ushort TColorDialog::dataSize()
  679. {
  680.     return *pal->data + 1;
  681. }
  682.  
  683. void TColorDialog::getData( void *rec )
  684. {
  685.     memcpy( rec, pal->data, *pal->data+1 );
  686. }
  687.  
  688. void TColorDialog::setData( void *rec)
  689. {
  690.     TPalette *p = (TPalette *)rec;
  691.  
  692.     memcpy( pal->data, p->data, *p->data+1 );
  693.     display->setColor( (uchar *)&pal->data[1] );
  694.     groups->focusItem( 0 );
  695.     if( showMarkers )
  696.         {
  697.         forLabel->hide();
  698.         forSel->hide();
  699.         bakLabel->hide();
  700.         bakSel->hide();
  701.         monoLabel->show();
  702.         monoSel->show();
  703.         }
  704.     groups->select();
  705. }
  706.  
  707. void TColorDialog::write( opstream& os )
  708. {
  709.     TDialog::write( os );
  710.     os << display << groups << forLabel << forSel
  711.        << bakLabel << bakSel << monoLabel << monoSel;
  712. }
  713.  
  714. void *TColorDialog::read( ipstream& is )
  715. {
  716.     TDialog::read( is );
  717.     is >> display >> groups >> forLabel >> forSel
  718.        >> bakLabel >> bakSel >> monoLabel >> monoSel;
  719.     pal = 0;
  720.     return this;
  721. }
  722.  
  723. TStreamable *TColorDialog::build()
  724. {
  725.     return new TColorDialog( streamableInit );
  726. }
  727.  
  728. TColorDialog::TColorDialog( StreamableInit ) :
  729.     TDialog( streamableInit ),
  730.     TWindowInit( streamableInit )
  731. {
  732. }
  733.  
  734.