home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c082_144 / 9.ddi / TVSRC.ZIP / TINPUTLI.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-10  |  9.8 KB  |  336 lines
  1. /*------------------------------------------------------------*/
  2. /* filename -       tinputli.cpp                              */
  3. /*                                                            */
  4. /* function(s)                                                */
  5. /*                  TInputLine member functions               */
  6. /*------------------------------------------------------------*/
  7.  
  8. /*------------------------------------------------------------*/
  9. /*                                                            */
  10. /*    Turbo Vision -  Version 1.0                             */
  11. /*                                                            */
  12. /*                                                            */
  13. /*    Copyright (c) 1991 by Borland International             */
  14. /*    All Rights Reserved.                                    */
  15. /*                                                            */
  16. /*------------------------------------------------------------*/
  17.  
  18. #define Uses_TKeys
  19. #define Uses_TInputLine
  20. #define Uses_TDrawBuffer
  21. #define Uses_TEvent
  22. #define Uses_opstream
  23. #define Uses_ipstream
  24. #include <tv.h>
  25.  
  26. #if !defined( __CTYPE_H )
  27. #include <ctype.h>
  28. #endif  // __CTYPE_H
  29.  
  30. #if !defined( __STRING_H )
  31. #include <String.h>
  32. #endif  // __STRING_H
  33.  
  34. #if !defined( __DOS_H )
  35. #include <Dos.h>
  36. #endif  // __DOS_H
  37.  
  38. const int CONTROL_Y = 25;
  39.  
  40. char hotKey( const char *s )
  41. {
  42.     char *p;
  43.  
  44.     if( (p = strchr( s, '~' )) != 0 )
  45.         return toupper(p[1]);
  46.     else
  47.         return 0;
  48. }
  49.  
  50. #define cpInputLine "\x13\x13\x14\x15"
  51.  
  52. TInputLine::TInputLine( const TRect& bounds, int aMaxLen ) :
  53.     TView(bounds),
  54.     data( new char[aMaxLen] ),
  55.     maxLen( aMaxLen-1 ),
  56.     curPos( 0 ),
  57.     firstPos( 0 ),
  58.     selStart( 0 ),
  59.     selEnd( 0 )
  60. {
  61.     state |= sfCursorVis;
  62.     options |= ofSelectable | ofFirstClick;
  63.     *data = EOS;
  64. }
  65.  
  66. TInputLine::~TInputLine()
  67. {
  68.     delete data;
  69. }
  70.  
  71. Boolean TInputLine::canScroll( int delta )
  72. {
  73.     if( delta < 0 )
  74.         return Boolean( firstPos > 0 );
  75.     else
  76.         if( delta > 0 )
  77.             return Boolean( strlen(data) - firstPos + 2 > size.x );
  78.         else
  79.             return False;
  80. }
  81.  
  82. ushort TInputLine::dataSize()
  83. {
  84.     return maxLen+1;
  85. }
  86.  
  87. void TInputLine::draw()
  88. {
  89.     int l, r;
  90.     TDrawBuffer b;
  91.  
  92.     uchar color = (state & sfFocused) ? getColor( 2 ) : getColor( 1 );
  93.  
  94.     b.moveChar( 0, ' ', color, size.x );
  95.     char buf[256];
  96.     strncpy( buf, data+firstPos, size.x - 2 );
  97.     buf[size.x - 2 ] = EOS;
  98.     b.moveStr( 1, buf, color );
  99.  
  100.     if( canScroll(1) )
  101.         b.moveChar( size.x-1, rightArrow, getColor(4), 1 );
  102.     if( (state & sfSelected) != 0 )
  103.         {
  104.         if( canScroll(-1) )
  105.             b.moveChar( 0, leftArrow, getColor(4), 1 );
  106.         l = selStart - firstPos;
  107.         r = selEnd - firstPos;
  108.         l = max( 0, l );
  109.         r = min( size.x - 2, r );
  110.         if (l <  r)
  111.             b.moveChar( l+1, 0, getColor(3), r - l );
  112.         }
  113.     writeLine( 0, 0, size.x, size.y, b );
  114.     setCursor( curPos-firstPos+1, 0);
  115. }
  116.  
  117. void TInputLine::getData( void *rec )
  118. {
  119.     memcpy( rec, data, dataSize() );
  120. }
  121.  
  122. TPalette& TInputLine::getPalette() const
  123. {
  124.     static TPalette palette( cpInputLine, sizeof( cpInputLine )-1 );
  125.     return palette;
  126. }
  127.  
  128. int TInputLine::mouseDelta( TEvent& event )
  129. {
  130.     TPoint mouse = makeLocal( event.mouse.where );
  131.  
  132.     if( mouse.x <= 0 )
  133.         return -1;
  134.     else
  135.         if( mouse.x >= size.x - 1 )
  136.             return 1;
  137.         else
  138.             return 0;
  139. }
  140.  
  141. int TInputLine::mousePos( TEvent& event )
  142. {
  143.     TPoint mouse = makeLocal( event.mouse.where );
  144.     mouse.x = max( mouse.x, 1 );
  145.     int pos = mouse.x + firstPos - 1;
  146.     pos = max( pos, 0 );
  147.     pos = min( pos, strlen(data) );
  148.     return pos;
  149. }
  150.  
  151. void  TInputLine::deleteSelect()
  152. {
  153.     if( selStart < selEnd )
  154.         {
  155.         strcpy( data+selStart, data+selEnd );
  156.         curPos = selStart;
  157.         }
  158. }
  159.  
  160. void  TInputLine::handleEvent( TEvent& event )
  161. {
  162.     TView::handleEvent(event);
  163.  
  164.     int delta, anchor, i;
  165.     if( (state & sfSelected) != 0 )
  166.         switch( event.what )
  167.             {
  168.             case  evMouseDown:
  169.                 if( canScroll(delta = mouseDelta(event)) )
  170.                     do  {
  171.                         if( canScroll(delta) )
  172.                             {
  173.                             firstPos += delta;
  174.                             drawView();
  175.                             }
  176.                         } while( mouseEvent( event, evMouseAuto ) );
  177.                 else if (event.mouse.doubleClick)
  178.                         selectAll(True);
  179.                 else
  180.                     {
  181.                     anchor =  mousePos(event);
  182.                     do  {
  183.                         if( event.what == evMouseAuto &&
  184.                             canScroll( delta = mouseDelta(event) )
  185.                           )
  186.                             firstPos += delta;
  187.                         curPos = mousePos(event);
  188.                         if( curPos < anchor )
  189.                             {
  190.                             selStart = curPos;
  191.                             selEnd = anchor;
  192.                             }
  193.                         else
  194.                             {
  195.                             selStart = anchor;
  196.                             selEnd = curPos;
  197.                             }
  198.                         drawView();
  199.                         } while (mouseEvent(event, evMouseMove | evMouseAuto));
  200.                     }
  201.                 clearEvent(event);
  202.                 break;
  203.             case  evKeyDown:
  204.                 switch( ctrlToArrow(event.keyDown.keyCode) )
  205.                     {
  206.                     case kbLeft:
  207.                         if( curPos > 0 )
  208.                             curPos--;
  209.                         break;
  210.                     case kbRight:
  211.                         if( curPos < strlen(data) )
  212.                             curPos++;
  213.                         break;
  214.                     case kbHome:
  215.                         curPos =  0;
  216.                         break;
  217.                     case kbEnd:
  218.                         curPos = strlen(data);
  219.                         break;
  220.                     case kbBack:
  221.                         if( curPos > 0 )
  222.                             {
  223.                             strcpy( data+curPos-1, data+curPos );
  224.                             curPos--;
  225.                             if( firstPos > 0 )
  226.                                 firstPos--;
  227.                             }
  228.                         break;
  229.                     case kbDel:
  230.                         if( selStart == selEnd )
  231.                             if( curPos < strlen(data) )
  232.                                 {
  233.                                 selStart = curPos;
  234.                                 selEnd = curPos + 1;
  235.                                 }
  236.                         deleteSelect();
  237.                         break;
  238.                     case kbIns:
  239.                         setState(sfCursorIns, Boolean(!(state & sfCursorIns)));
  240.                         break;
  241.                     default:
  242.                         if( event.keyDown.charScan.charCode >= ' ' )
  243.                             {
  244.                             if( (state & sfCursorIns) != 0 )
  245.                                 strcpy( data + curPos, data + curPos + 1 );
  246.                             else
  247.                                 deleteSelect();
  248.                             if( strlen(data) < maxLen )
  249.                                 {
  250.                                 if( firstPos > curPos )
  251.                                     firstPos = curPos;
  252.                                 memmove( data + curPos + 1, data + curPos,
  253.                                          strlen(data+curPos)+1 );
  254.                                 data[curPos++] =
  255.                                     event.keyDown.charScan.charCode;
  256.                                 }
  257.                             }
  258.                         else if( event.keyDown.charScan.charCode == CONTROL_Y)
  259.                             {
  260.                             *data = EOS;
  261.                             curPos = 0;
  262.                             }
  263.                         else
  264.                             return;
  265.                     }
  266.                     selStart = 0;
  267.                     selEnd = 0;
  268.                     if( firstPos > curPos )
  269.                         firstPos = curPos;
  270.                     i = curPos - size.x + 3;
  271.                     if( firstPos < i )
  272.                         firstPos = i;
  273.                     drawView();
  274.                     clearEvent( event );
  275.                     break;
  276.             }
  277. }
  278.  
  279. void TInputLine::selectAll( Boolean enable )
  280. {
  281.     selStart = 0;
  282.     if( enable )
  283.         curPos = selEnd = strlen(data);
  284.     else
  285.         curPos = selEnd = 0;
  286.     firstPos = max( 0, curPos-size.x+3 );
  287.     drawView();
  288. }
  289.  
  290. void TInputLine::setData( void *rec )
  291. {
  292.     memcpy( data, rec, dataSize()-1 );
  293.     data[dataSize()-1] = EOS;
  294.     selectAll( True );
  295. }
  296.  
  297. void TInputLine::setState( ushort aState, Boolean enable )
  298. {
  299.     TView::setState( aState, enable );
  300.     if( aState == sfSelected ||
  301.         ( aState == sfActive && (state & sfSelected) != 0 )
  302.       )
  303.         selectAll( enable );
  304. }
  305.  
  306. void TInputLine::write( opstream& os )
  307. {
  308.     TView::write( os );
  309.     os << maxLen << curPos << firstPos
  310.        << selStart << selEnd;
  311.     os.writeString( data);
  312. }
  313.  
  314. void *TInputLine::read( ipstream& is )
  315. {
  316.     TView::read( is );
  317.     is >> maxLen >> curPos >> firstPos
  318.        >> selStart >> selEnd;
  319.     data = new char[maxLen + 1];
  320.     is.readString(data, maxLen+1);
  321.     state |= sfCursorVis;
  322.     options |= ofSelectable | ofFirstClick;
  323.     return this;
  324. }
  325.  
  326. TStreamable *TInputLine::build()
  327. {
  328.     return new TInputLine( streamableInit );
  329. }
  330.  
  331. TInputLine::TInputLine( StreamableInit ) : TView( streamableInit )
  332. {
  333. }
  334.  
  335.  
  336.