home *** CD-ROM | disk | FTP | other *** search
/ Mega Top 1 / os2_top1.zip / os2_top1 / APPS / FILEMAN / TV0001 / HOST_DIR.ZIP / win.cpp < prev    next >
C/C++ Source or Header  |  1994-04-12  |  6KB  |  213 lines
  1.  
  2. #include "win.h"
  3.  
  4. ////////////////////////////////////////////////////////////////////////////
  5. //    this function redraws the correct window frame and client area
  6. ///////////////////////////////////////////////////////////////////////////
  7. void WindowClass::redraw() {
  8.     register int count;
  9.     char h,v,c1,c2,c3,c4;                        // varibles for the line drawing
  10.     scrx = scry = 0;                                // unscroll
  11.     char barlist[ 85 ];
  12.     if ( status == FG ) {                          // frame drawing chars
  13.         h = 205;
  14.         v = 186;
  15.         c1 = 201;
  16.         c2 = 200;
  17.         c3 = 188;
  18.         c4 = 187;
  19.     }
  20.     else {
  21.         h = 196;
  22.         v = 179;
  23.         c1 = 218;
  24.         c2 = 192;
  25.         c3 = 217;
  26.         c4 = 191;
  27.     }
  28.  
  29.     textcolor( 7 );
  30.     textbackground( 0 );
  31.     gotoxy( x1, y1 );                            // draw top line
  32.     for( count = 0; count < ( x2 - x1) + 1; count++ )
  33.         barlist[ count ] = h;
  34.  
  35.     barlist[ count ] = '\0';
  36.     barlist[ 0 ] = c1;
  37.     barlist[ count - 1 ] = c4;
  38.     cprintf( "%s", barlist );
  39.  
  40.     gotoxy( x1, y2 );                            // draw bottom line
  41.     barlist[ 0 ] = c2;
  42.     barlist[ count - 1 ] = c3;
  43.     cprintf( "%s", barlist );
  44.  
  45.     for( count = 1; count < ( y2 - y1 ); count++ ){// draw sides of window
  46.         gotoxy( x1, y1 + count );
  47.         cprintf( "%c", v );
  48.         gotoxy( x2, y1 + count );
  49.         cprintf( "%c", v );
  50.     }
  51.  
  52.     gotoxy( x1 + 2, y1 );
  53.     cprintf( "[ %s ]", title );
  54.  
  55.     clientdraw();                                        // redraw client area
  56. }
  57.  
  58. ////////////////////////////////////////////////////////////////////////////
  59. // places the client area in the window
  60. ////////////////////////////////////////////////////////////////////////////
  61. void WindowClass::clientdraw() {
  62.     int x, y;
  63.     puttext( x1 + 1, y1 + 1, x2 - 1, y2 - 1, clientarea );
  64.     // now locate cursor to the proper place on the screen
  65.     if ( scrx > ( x2 - x1 - 1 ) ) 
  66.         x = x2 - 1;
  67.     else
  68.         x = x1 + scrx;
  69.  
  70.     if ( scry > ( y2 - y1 - 1 ) )
  71.         y = y2 - 1;
  72.     else
  73.         y = y1 + scry;
  74.  
  75.     gotoxy( x, y );
  76. }
  77.         
  78. ///////////////////////////////////////////////////////////////////////////
  79. //    brings the window foreground
  80. ///////////////////////////////////////////////////////////////////////////
  81. void WindowClass::gofg() {
  82.     status = FG;
  83. }
  84.  
  85. ///////////////////////////////////////////////////////////////////////////
  86. //    redraws the window as a background win
  87. ///////////////////////////////////////////////////////////////////////////
  88. void WindowClass::gobg() {
  89.     status = BG;
  90. }
  91.  
  92. /////////////////////////////////////////////////////////////////////////////
  93. //    moves the window the desired amount of x and y if possible
  94. /////////////////////////////////////////////////////////////////////////////
  95. void WindowClass::relocate( int x, int y ) {
  96.     if ( ( x1 + x < 1 )     ||                            // check to make sure we don't
  97.         ( x2 + x > 80 )     ||                            // exceed screen bounds
  98.         ( y1 + y < 1 )     ||
  99.         ( y2 + y > 25 ) )
  100.         return;                                            // ignore call if bounds exceed
  101.  
  102.     x1 += x;                                                // make location change
  103.     x2 += x;
  104.     y1 += y;
  105.     y2 += y;
  106.     redraw();
  107. }
  108.  
  109. //////////////////////////////////////////////////////////////////////////
  110. //    the cnostructor redies the windowclass
  111. //////////////////////////////////////////////////////////////////////////
  112. WindowClass::WindowClass() {
  113.     x1 = 15; 
  114.     x2 = 65;
  115.     y1 = 4; 
  116.     y2 = 15;
  117.  
  118.     title = new char[ 40 ];
  119.     title[ 0 ] = '\0';
  120.     clientarea = new char[ 4000 ];
  121.     scrx = scry = 0;
  122. }
  123.  
  124. WindowClass::~WindowClass() {
  125.     delete [] title;
  126.     delete [] clientarea;
  127. }
  128.  
  129. /////////////////////////////////////////////////////////////////////////////
  130. //    clientdata gets the 80x25 data and formats it for use with current win
  131. //    settings.
  132. /////////////////////////////////////////////////////////////////////////////
  133. void WindowClass::clientdata( char *data ) {
  134.     register int datapos = 0;                        // location within line
  135.     register int linecount = 0;                    // current line number
  136.     register int count = 0;                            // temp counter
  137.     register int finc = 0;                            // finished location
  138.     int xwidth = ( x2 - 1 ) - ( x1 + 1 ) + 1;
  139.     int ywidth = ( y2 - 1 ) - ( y1 + 1 ) + 1;
  140.  
  141.     if ( scry > ywidth )                             // scroll window text down to
  142.         datapos = ( scry - ywidth ) * 160;        // cursor position    
  143.  
  144.     for ( linecount = 0; linecount < ywidth; linecount++ ) {
  145.         // loop through building the data for each line
  146.  
  147.         // determine if we need to scroll horizantly.  If so, calc scroll
  148.         if ( scrx > xwidth )                         // scroll over for x position
  149.             datapos += ( scrx - xwidth ) * 2;
  150.  
  151.         // read in the data we actually need, saving the new stuff in the
  152.         // window's client area buffer
  153.         for ( count = 0; count < xwidth; count++ ) {
  154.             clientarea[ finc++ ] = data[ datapos++ ];    // copy char
  155.             clientarea[ finc++ ] = data[ datapos++ ];    // copy attributes
  156.         }
  157.  
  158.         // since the data is passed to use in a 80x25 format, we need to
  159.         // 'waiste off' the remaining chars at the end of the line.  If
  160.         //    scrx > xwidth, we need to account for the fact that some of these
  161.         // characters have already been removed.
  162.         if ( scrx > xwidth )
  163.             datapos += ( ( 80 - xwidth    ) - ( scrx - xwidth ) ) * 2;
  164.         else
  165.             datapos += ( 80 - xwidth ) * 2;
  166.     }// for linecount
  167. }
  168.     
  169. /////////////////////////////////////////////////////////////////////////////
  170. //    WinResize will, if allowable, resize the window so its view area is bigger
  171. /////////////////////////////////////////////////////////////////////////////
  172. void WindowClass::resize( int x, int y ) {
  173.     if    ( ( x2 + x > 80 ) ||
  174.         ( x2 + x <= x1 )    ||
  175.         ( y2 + y > 25 )    ||
  176.         ( y2 + y <= y1 ) )
  177.         return;                                    // out of bounds resize
  178.  
  179.     else {
  180.         x2 += x;
  181.         y2    += y;
  182.     }
  183.     redraw();
  184. }
  185.  
  186. ////////////////////////////////////////////////////////////////////////////
  187. // title sets the title of the window
  188. //////////////////////////////////////////////////////////
  189. void WindowClass::settitle( char *newtitle ) {
  190.     strcpy( title, newtitle );
  191. }
  192.  
  193. char* WindowClass::gettitle() {
  194.     return title;
  195. }
  196.  
  197. void WindowClass::scroll( int x, int y ) {
  198.     if(    ( x2 + x > 80 )     ||
  199.             ( x1 - x < 1 )     ||
  200.             ( y2 + y > 25 )    ||
  201.             ( y1 - y < 1 ) )
  202.             return;
  203.     else {
  204.         scrx += x;
  205.         scry += y;
  206.     }
  207. }
  208.  
  209. void WindowClass::setcurpos( int x, int y ) {
  210.     scrx = x;
  211.     scry = y;
  212. }
  213.