home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / powervww / pvbutton.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-05  |  11.1 KB  |  480 lines
  1. //  ____________________________________________________
  2. // |                                                    |
  3. // |  Project:     POWER VIEW INTERFACE                 |
  4. // |  File:        PVBUTTON.CPP                         |
  5. // |  Compiler:    WPP386 (10.6)                        |
  6. // |                                                    |
  7. // |  Subject:     Buttons implementation               |
  8. // |                                                    |
  9. // |  Author:      Emil Dotchevski                      |
  10. // |____________________________________________________|
  11. //
  12. // E-mail: zajo@geocities.com
  13. // URL:    http://www.geocities.com/SiliconValley/Bay/3577
  14.  
  15. #define uses_string
  16. #define uses_button
  17. #define uses_colors
  18. #define uses_dc
  19. #define uses_dialog
  20. #define uses_icons
  21. #define uses_system
  22.  
  23. #include "PVuses.h"
  24.  
  25. //Tbutton publics:
  26.  
  27. Tbutton::Tbutton( char *t, uint cmd ):
  28.   Titem( smart_len( t ) + 2, 1 )
  29. {
  30.   title = STRDUP( t );
  31.   shortcut = 0;
  32.   command = cmd;
  33.   pressed = 0;
  34. #ifndef NOMOUSE
  35.   if( flags( bfREPEAT ) ) set_events_mask( evMOUSE_REP, 1 );
  36. #endif
  37.   if( flags( bfDEFAULT ) )
  38.   {
  39.     set_state( bsDEFAULT, 1 );
  40.     shortcut = kENTER;
  41.   }
  42.   if( command ) set_state( isDISABLED, cdisabled( command ) );
  43. }
  44.  
  45. Tbutton::~Tbutton( void )
  46. {
  47.   FREE( title );
  48. }
  49.  
  50. void Tbutton::set_flags( uint _flags_word, boolean enable )
  51. {
  52.   Titem::set_flags( _flags_word, enable );
  53.   if( flags_word & bfDEFAULT )
  54.   {
  55.     shortcut = kENTER;
  56.     grab_default();
  57.   }
  58.   if( !( _flags_word & bfREPEAT ) ) return;
  59. #ifndef NOMOUSE
  60.   set_events_mask( evMOUSE_REP, flags( bfREPEAT ) );
  61. #endif
  62. }
  63.  
  64. void Tbutton::set_state( uint _state_word, boolean enable )
  65. {
  66.   uint st;
  67.  
  68.   st = state_word;
  69.   Titem::set_state( _state_word, enable );
  70.   if( ( st & bsDEFAULT ) != ( state_word & bsDEFAULT ) ) redraw();
  71. }
  72.  
  73. void Tbutton::set_title( char *t )
  74. {
  75.   FREE( title );
  76.   title = STRDUP( t );
  77.   resize( smart_len( t ), 1 );
  78.   redraw();
  79. }
  80.  
  81. void Tbutton::set_cmd( uint cmd )
  82. {
  83.   command = cmd;
  84. }
  85.  
  86. //Tbutton protected:
  87.  
  88. void Tbutton::set_palette( void )
  89. {
  90.   Titem::set_palette();
  91.   attr[0] = pal_buttons.normal;
  92.   attr[1] = pal_buttons.selected;
  93.   attr[3] = pal_buttons._default;
  94.   attr[4] = pal_buttons.pressed;
  95.   attr[2] = pal_buttons.disabled;
  96.   attr[9] = (char) ( text_attr & 0xF0 );
  97.   attr[5] = (char) ( attr[9] | ( ( attr[0] >> 4 ) & 0x0F ) );
  98.   attr[6] = (char) ( attr[9] | ( ( attr[1] >> 4 ) & 0x0F ) );
  99.   attr[7] = (char) ( attr[9] | ( ( attr[2] >> 4 ) & 0x0F ) );
  100.   attr[8] = (char) ( attr[9] | ( ( attr[3] >> 4 ) & 0x0F ) );
  101.   attr[9] = (char) ( attr[9] | ( ( attr[4] >> 4 ) & 0x0F ) );
  102.   if( state( isDISABLED ) ) shortcut_attr = 0;
  103.   bold_attr = (char) ( ( pal_buttons.normal & 0xF0 ) | shortcut_attr );
  104. }
  105.  
  106. void Tbutton::draw( void )
  107. {
  108.   static char *t = "|0%s|0%s|r%c |0%s";
  109.   char s, b, l, xx;
  110.  
  111.   if( pressed )
  112.     { s = '4'; b = '9'; }
  113.   else
  114.     if( state( isDISABLED ) )
  115.       { s = '2'; b = '7'; }
  116.     else
  117.       if( state( isSELECTED ) )
  118.         { s = '1'; b = '6'; }
  119.       else
  120.         if( state( bsDEFAULT ) )
  121.           { s = '3'; b = '8'; }
  122.         else
  123.           { s = '0'; b = '5'; }
  124.   t[1] = b; t[5] = s; t[14] = b;
  125.   xx = (char) ( xl - 2 ); l = (char) smart_len( title );
  126.   if( l < xx ) xx -= l; else xx = 0;
  127.   txtf( t, i_buttonl, title, xx, i_buttonr );
  128. }
  129.  
  130. void Tbutton::get_focused( void )
  131. {
  132.   grab_default();
  133. }
  134.  
  135. boolean Tbutton::release_focus( void )
  136. {
  137.   if( Titem::release_focus() )
  138.   {
  139.     if( !flags( bfDEFAULT ) ) release_default();
  140.     return 1;
  141.   }
  142.   return 0;
  143. }
  144.  
  145. void Tbutton::event_handler( Tevent &ev )
  146. {
  147.   uint xx;
  148.   boolean fl;
  149.  
  150.   if( ev.code == evCOMMAND )
  151.   {
  152.     switch( ev.CMD_CODE )
  153.     {
  154.       case cmAPP_COMMANDS_CHANGED:
  155.         if( state( isACCESSABLE ) )
  156.       case cmDLG_RESET:
  157.         if( command )
  158.         {
  159.           fl = cdisabled( command );
  160.           if( state( isDISABLED ) != fl ) set_state( isDISABLED, fl );
  161.         }
  162.     }
  163.     if( ev.CMD_INFO != this )
  164.       switch( ev.CMD_CODE )
  165.       {
  166.         case cmBTN_GRAB_DEFAULT:
  167.           if( state( bsDEFAULT ) && ( owner == ((Titem *) ev.CMD_INFO)->owner ) )
  168.           {
  169.             pressed = 0;
  170.             set_state( bsDEFAULT, 0 );
  171.             handled( ev );
  172.           }
  173.           break;
  174.         case cmBTN_RELEASE_DEFAULT:
  175.           if( flags( bfDEFAULT ) && ( owner == ((Titem *) ev.CMD_INFO)->owner ) )
  176.           {
  177.             set_state( bsDEFAULT, 1 );
  178.             handled( ev );
  179.           }
  180.       }
  181.   }
  182.   switch( ev.code )
  183.   {
  184.     case evKEY_PRESS:
  185.       if( ( state( isFOCUSED ) && ( ev.ASCII==kSPACE || ev.ASCII==kENTER ) ) ||
  186.           ( ev.ASCII==get_shortcut( title ) ) ||
  187.           ( upcased( ev.ASCII )==shortcut && ( shortcut!=kENTER || !flags( ifSELECTABLE ) || state( bsDEFAULT ) ) ) )
  188.       {
  189.         if( flags( bfGRAB_FOCUS ) ) focus();
  190.         xx = ev.SCAN_CODE;
  191.         pressed = 1; redraw();
  192.         do
  193.         {
  194.           if( flags( bfREPEAT ) && ( ev.code == evKEY_PRESS ) &&
  195.              ( ( ev.ASCII == shortcut ) || ( ev.ASCII == get_shortcut( title ) ) ) ) press();
  196.           get_key( ev, evKEY_PRESS|evKEY_UP );
  197.         }
  198.         while( !state( isHIDDEN ) && ( ( ev.code != evKEY_UP ) || ( xx != ev.SCAN_CODE ) ) );
  199.         if( !flags( bfREPEAT ) ) press();
  200.         pressed = 0; redraw();
  201.         handled( ev );
  202.       }
  203.       break;
  204. #ifndef NOMOUSE
  205.     case evMOUSE_DOWN:
  206.       if( ev.INSIDE )
  207.       {
  208.         if( flags( bfGRAB_FOCUS ) ) focus(); else owner->focus();
  209.         ev.code = evMOUSE_REP;
  210.         do
  211.         {
  212.           if( ev.INSIDE != pressed )
  213.           {
  214.             pressed = ev.INSIDE;
  215.             redraw();
  216.           }
  217.           if( pressed && ( ev.code==evMOUSE_REP ) && flags( bfREPEAT ) ) press();
  218.         }
  219.         while( !state( isHIDDEN ) && get_mouse( ev, evMOUSE_DRAG|evMOUSE_REP ) );
  220.         if( pressed )
  221.         {
  222.           if( !flags( bfREPEAT ) ) press();
  223.           pressed = 0;
  224.           redraw();
  225.         }
  226.         handled( ev );
  227.       }
  228.       break;
  229. #endif
  230.   }
  231.   Titem::event_handler( ev );
  232. }
  233.  
  234. void Tbutton::press( void )
  235. {
  236.   if( flags( bfSTOP_MODAL ) )
  237.     stop( command );
  238.   else
  239.   {
  240.     _command_info( this, 0 );
  241.     if( flags( bfBROADCAST ) )
  242.       put_command( NULL, command );
  243.     else
  244.       if( command == cmDONE )
  245.         put_command( owner, command );
  246.       else
  247.         message( owner, command );
  248.   }
  249. }
  250.  
  251. void Tbutton::grab_default( void )
  252. {
  253.   _command_info( this, 0 ); broadcast( cmBTN_GRAB_DEFAULT );
  254.   set_state( bsDEFAULT, 1 );
  255. }
  256.  
  257. void Tbutton::release_default( void )
  258. {
  259.   _command_info( this, 0 ); broadcast( cmBTN_RELEASE_DEFAULT );
  260.   set_state( bsDEFAULT, 0 );
  261. }
  262.  
  263. //Ticon publics:
  264.  
  265. Ticon::Ticon( char *t, uint cmd, uint _shortcut ):
  266.   Tbutton( t, cmd )
  267. {
  268.   set_flags( ifSELECTABLE, 0 ); set_flags( ifPRE_PROCESS, 1 );
  269.   resize( smart_len( t ), 1 ); shortcut = _shortcut;
  270.   set_state( isON_TOP, 1 );
  271. }
  272.  
  273. //Ticon protected:
  274.  
  275. void Ticon::calc_bounds( int delta_xl, int delta_yl )
  276. {
  277.   int xx;
  278.  
  279.   xx = smart_len( title );
  280.   if( xl != xx ) resize( xx, 1 );
  281.   Tbutton::calc_bounds( delta_xl, delta_yl );
  282. }
  283.  
  284. void Ticon::set_palette( void )
  285. {
  286.   Titem::set_palette();
  287. }
  288.  
  289. void Ticon::draw( void )
  290. {
  291.   char s;
  292.  
  293.   if( window_state( isACTIVE ) )
  294.     if( pressed )
  295.       s = '4';
  296.     else
  297.       s = '3';
  298.   else
  299.     s = '2';
  300.   txtf( "|%c%s", s, title );
  301. }
  302.  
  303. void Ticon::event_handler( Tevent &ev )
  304. {
  305.   if( !( ev.code & evKEYBOARD ) || window_state( isFOCUSED|isMODAL ) )
  306.     Tbutton::event_handler( ev );
  307. }
  308.  
  309. //Tkey publics:
  310.  
  311. Tkey::Tkey( uint k, uint cmd ):
  312.   Titem( 0, 0 )
  313. {
  314.   set_flags( ifVISIBLE+ifSELECTABLE, 0 ); set_flags( bfBROADCAST, 1 );
  315.   set_events_mask( (uint)-1,0 );
  316.   set_events_mask( evCOMMAND+evKEY_PRESS, 1 );
  317.   shortcut = k; command = cmd;
  318. }
  319.  
  320. //Tkey protected:
  321.  
  322. void Tkey::event_handler( Tevent &ev )
  323. {
  324.   boolean fl;
  325.  
  326.   Titem::event_handler( ev );
  327.   switch( ev.code )
  328.   {
  329.     case evKEY_PRESS:
  330.       if( ev.ASCII == shortcut )
  331.       {
  332.         if( flags( bfSTOP_MODAL ) )
  333.           stop( command );
  334.         else
  335.         {
  336.           _command_info( this ,0 );
  337.           if( flags( bfBROADCAST ) )
  338.             put_command( NULL, command );
  339.           else
  340.             if( command == cmDONE )
  341.               put_command( owner, command );
  342.             else
  343.               message( owner,command );
  344.         }
  345.         handled( ev );
  346.       }
  347.       break;
  348.     case evCOMMAND:
  349.       if( ev.CMD_CODE == cmAPP_COMMANDS_CHANGED )
  350.         if( state( isACCESSABLE ) )
  351.         {
  352.           fl = cdisabled( command );
  353.           if( state( isDISABLED ) != fl ) set_state( isDISABLED, fl );
  354.         }
  355.   }
  356. }
  357.  
  358. //CONSTRUCTORS FOR USE WITH DIALOG BOXES
  359.  
  360. /*
  361.   Description:
  362.     Construct a button and insert it in the dialog box.
  363.   Entry:
  364.     t - title of the button, shortcut prefix '|~';
  365.     cmd - command to be generated by the button.
  366.   Exit:
  367.     Return pointer to the button.
  368. */
  369. Tbutton *button( char *t, uint cmd )
  370. {
  371.   Tbutton *b;
  372.  
  373.   b = NEW( Tbutton( t, cmd ) ); b->set_flags( bfSTOP_MODAL, 1 );
  374.   put_item( b, b->xl, 1 );
  375.   if( !fill() ) vspace();
  376.   return b;
  377. }
  378.  
  379. /*
  380.   Description:
  381.     Construct a default accept button and insert it in the dialog box.
  382.   Entry:
  383.     t - title of the button, shortcut prefix '|~';
  384.     cmd - command to be generated by the button.
  385.   Exit:
  386.     Return pointer to the button.
  387. */
  388. Tbutton *dbutton( char *t, uint cmd )
  389. {
  390.   Tbutton *b;
  391.  
  392.   b = button( t, cmd );
  393.   b->set_flags( bfDEFAULT, 1 );
  394.   return b;
  395. }
  396.  
  397. /*
  398.   Description:
  399.     Construct a default cancel button and insert it in the dialog box.
  400.   Entry:
  401.     t - title of the button, shortcut prefix '|~';
  402.     cmd - command to be generated by the button.
  403.   Exit:
  404.     Return pointer to the button.
  405. */
  406. Tbutton *dcbutton( char *t, uint cmd )
  407. {
  408.   Tbutton *b;
  409.  
  410.   b = button( t, cmd ); b->shortcut = kESC;
  411.   return b;
  412. }
  413.  
  414. /*
  415.   Description:
  416.     Construct 'OK' button and insert it in the dialog box.
  417.   Entry:
  418.     t - title of the button, shortcut prefix '|~'.
  419.   Exit:
  420.     Return pointer to the button.
  421. */
  422. Tbutton *kbutton( char *t )
  423. {
  424.   return dbutton( t, cmOK );
  425. }
  426.  
  427. /*
  428.   Description:
  429.     Construct 'Cancel' button and insert it in the dialog box.
  430.   Entry:
  431.     t - title of the button, shortcut prefix '|~'.
  432.   Exit:
  433.     Return pointer to the button.
  434. */
  435. Tbutton *cbutton( char *t )
  436. {
  437.   return dcbutton( t,cmCANCEL );
  438. }
  439.  
  440. /*
  441.   Description:
  442.     Construct 'Help' button and insert it in the dialog box.
  443.   Entry:
  444.     t - title of the button, shortcut prefix '|~'.
  445.   Exit:
  446.     Return pointer to the button.
  447. */
  448. #pragma off( unreferenced )
  449. Tbutton *hbutton( char *t )
  450. {
  451. #ifdef NOHELP
  452.   return NULL;
  453. #else
  454.   Tbutton *b;
  455.  
  456.   b = button( t,cmHELP );
  457.   b->set_flags( bfSTOP_MODAL, 0 );
  458.   return b;
  459. #endif
  460. }
  461. #pragma on( unreferenced )
  462.  
  463. /*
  464.   Description:
  465.     Construct key ( accelerator ) item and insert it in the dialog box.
  466.   Entry:
  467.     k   - key code;
  468.     cmd - command to be generated.
  469.   Exit:
  470.     Return pointer to the key item.
  471. */
  472. Tkey *key( uint k, uint cmd )
  473. {
  474.   Tkey *ki;
  475.  
  476.   ki = NEW( Tkey( k, cmd ) ); ki->set_flags( bfSTOP_MODAL, 1 );
  477.   put_item( ki, 0, 0 );
  478.   return ki;
  479. }
  480.