home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_300 / 337_01 / l_win2.c < prev    next >
C/C++ Source or Header  |  1991-01-14  |  6KB  |  219 lines
  1. /* Copyright (c) James L. Pinson 1990,1991  */
  2.  
  3. /**********************   L_WIN2.C   ***************************/
  4.  
  5. #include "mydef.h"
  6. #include <dos.h>
  7.  
  8. #if defined QUICKC
  9.  
  10. #include "malloc.h"
  11. #include "memory.h"
  12.  
  13. #endif
  14.  
  15. # if defined TURBOC
  16.  
  17. #include "alloc.h"    /* Turbo C header file */
  18. #include "mem.h"
  19. #include "string.h"
  20. #include "stdlib.h"
  21.  
  22. #endif
  23.  
  24.  
  25. /*****************************************************************
  26.  
  27.  Usage: void win_pop_top(int handle);
  28.  
  29.  int handle = window handle.
  30.  
  31.  Moves the window indicated by "handle" to the top of the stack.
  32.  Updates the window list and redraws the screen.
  33.  
  34. *****************************************************************/
  35.  
  36. void win_pop_top(int handle)
  37. {
  38. extern struct screen_structure scr;
  39. extern struct window_structure w[];
  40.  
  41. int location,i;
  42.  
  43.  if (handle==0) return;  /* can't delete initial window */
  44.  if(handle==scr.active)return;  /* already on top */
  45.  
  46.  /* get location of window(handle) in list */
  47.  location=win_validate(handle);   
  48.  
  49.  if(location==-1)return;  /* invalid handle */
  50.  win_save(); /* save current window, it is about to be overdrawn */
  51.  
  52.  /* Popping a window to the top requires that the window list be
  53.     rearranged. We shift all values after the window being popped
  54.     (handle) forward one, then put the popped window at the end  */
  55.  
  56.  for(i=location;i<scr.ptr+1;i++)
  57.      scr.list[i]=scr.list[i+1];  /* shuffle */
  58.  scr.list[scr.ptr]=handle;  /* move window to top of list */
  59.  
  60.  win_redraw(handle); /* redraw the window to make it appear on top */
  61.  
  62.  scr.active=scr.list[scr.ptr];/* reset pointer to reflect new list */
  63.  
  64.  /* do if window has allocated memory */
  65.  if (w[scr.active].buffer !=NULL){ 
  66.   free(w[scr.active].buffer);     /* free buffer of new top window */
  67.   w[scr.active].buffer=NULL;      /* null the pointer */
  68.  }
  69.   update_margins(); /* a new window is on top,
  70.                        update screen margins */
  71.  
  72.   display_cursor(); /* display cursor for new window */
  73.  
  74. }
  75.  
  76.  
  77. /*****************************************************************
  78.  
  79.  Usage: void display_cursor(void);
  80.  
  81.  Moves the cursor to the location indicated by the variables for
  82.  the active window.  Also resets the cursor starting/ending
  83.  scan lines.
  84.  
  85.  Mostly used when a window redraw occurs.
  86.  
  87. *****************************************************************/
  88.  
  89.  
  90. void display_cursor(void)
  91. {
  92. extern struct screen_structure scr;
  93. extern struct window_structure w[];
  94.  
  95. gotoxy(w[scr.active].x,w[scr.active].y);  /* position cursor */
  96.  
  97. /* set cursor shape */
  98. set_cursor(w[scr.active].start,w[scr.active].end); 
  99. }
  100.  
  101.  
  102. /*****************************************************************
  103.  
  104.  Usage: void win_redraw(int handle);
  105.  
  106.  int handle = handle of window to redraw.
  107.  
  108.  Redraws the specified window. Does not rearrange the list.
  109.  
  110. *****************************************************************/
  111.  
  112. static void win_redraw(int handle)
  113. {
  114. extern struct screen_structure scr;
  115. extern struct window_structure w[];
  116.  
  117. int t,b,l,r;
  118. char far *source_ptr;
  119. char far *scrn_ptr;
  120.  
  121. int i;
  122.  
  123.  if(w[handle].buffer==NULL) return; /* window is not virtual,
  124.                                        cannot redraw */
  125.  /* is handle requested in list? */
  126.  if(win_validate(handle)==-1 ) return; 
  127.  
  128.   /* if the window is framed, the margins must be adjusted */
  129.  
  130.   if(w[handle].frame==TRUE){
  131.     t=w[handle].top-1;b=w[handle].bottom+1;
  132.     l=w[handle].left-1;r=w[handle].right+1;
  133.   } else{
  134.       t=w[handle].top;b=w[handle].bottom;
  135.       l=w[handle].left;r=w[handle].right;
  136.      }
  137.  
  138.       /* initialize pointers */
  139.       scrn_ptr=scr.buffer;
  140.       scrn_ptr=scrn_ptr+((t-1)*scr.columns*2)+(2*(l-1));
  141.  
  142.       source_ptr=w[handle].buffer;
  143.  
  144.  for(i=1 ;i<=b-t+1;i++){  /*do for each row in window*/
  145.    move_scr_mem((char far *)source_ptr,
  146.      (char far *)scrn_ptr,2*(r-l+1));
  147.    /* update screen and destination pointer */
  148.    scrn_ptr=scrn_ptr +(2*scr.columns);
  149.    source_ptr=source_ptr+ (2*(r-l+1));
  150.  }
  151. }
  152.  
  153.  
  154. /*****************************************************************
  155.  
  156.  Usage: void win_redraw_all(void);
  157.  
  158.  Redraws all the windows.
  159.  The redraw is done on a virtual screen which is then copied to
  160.  the true screen buffer.
  161.  
  162. *****************************************************************/
  163.  
  164. void win_redraw_all(void)
  165. {
  166. extern struct screen_structure scr;
  167. extern struct window_structure w[];
  168.  
  169. char far *hold_buffer;
  170. char *new_buffer;
  171. int i,loc,buffsize;
  172. int oldsnow=scr.snow;
  173. hold_buffer=scr.buffer;
  174.  
  175. buffsize=scr.rows*scr.columns*2;  /* calc size of buffer */
  176.  
  177. new_buffer= NULL;
  178.  
  179.  /* save top window as all will be redrawn */
  180.   loc=scr.list[scr.ptr];   /* loc= top window */
  181.  
  182.  if(w[loc].buffer==NULL)  /* save only if it is not virtual */
  183.    win_save();
  184.  
  185. /* allocate memory */
  186. new_buffer= malloc (buffsize*sizeof(unsigned char)); 
  187.  
  188. /* if we got a new buffer set external screen pointer to it */
  189. /* write routine will now write to new buffer */
  190.  
  191. if (new_buffer!=NULL) scr.buffer=(char far *)new_buffer;
  192.  
  193. /* turn of snow flag, we are not writing to screen buffer */
  194. scr.snow=FALSE;   
  195.  
  196. /* redraw all windows */
  197. for(i=0;i<scr.ptr+1;i++)
  198.     win_redraw(scr.list[i]);
  199.  
  200. scr.snow=oldsnow; /* turn snow flag back on */
  201.  
  202. /* free up buffer of top window */
  203.  
  204.   if(w[loc].buffer!=NULL){  /* be sure it is allocated */
  205.     free(w[loc].buffer);    /* free it */
  206.     w[loc].buffer=NULL;     /* mark it as freed */
  207.   }
  208.  
  209. /* if we did get a new buffer, move it to screen */
  210.  
  211.  if(new_buffer!=NULL){
  212.   scr.buffer =hold_buffer;   /* restore original screen buffer */
  213.   move_scr_mem((char far *)new_buffer,scr.buffer,buffsize);
  214.   free(new_buffer);  /*free memory */
  215.   new_buffer=NULL;   /* mark it */
  216.   display_cursor();  /* redisplay cursor */
  217.  }
  218. }
  219.