home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / AP / JED / JED097-1.TAR / jed / src / window.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-12  |  6.7 KB  |  358 lines
  1. /*
  2.  *  Copyright (c) 1992, 1994 John E. Davis  (davis@amy.tch.harvard.edu)
  3.  *  All Rights Reserved.
  4.  */
  5. #include <stdio.h>
  6.  
  7. #ifdef __WATCOMC__
  8. # include <string.h> /* so we can get prototype for memset */
  9. #endif
  10.  
  11. #include "config.h"
  12. #include "buffer.h"
  13. #include "window.h"
  14. #include "screen.h"
  15. #include "misc.h"
  16. #include "ledit.h"
  17. #include "sysdep.h"
  18. #include "display.h"
  19.  
  20. Window_Type *JWindow;
  21. extern Window_Type *The_MiniWindow;
  22. int Top_Window_Row = 2;
  23.  
  24. Window_Type *create_window(int top, int rows, int col, int width)
  25. {
  26.     Window_Type *w;
  27.  
  28.     if (NULL == (w = (Window_Type *) SLMALLOC(sizeof(Window_Type))))
  29.       {
  30.       exit_error("create_window: malloc error.", 0);
  31.       }
  32.  
  33.    MEMSET ((char *) w, 0, sizeof (Window_Type));
  34.    w->top = top;
  35.    w->rows = rows;
  36.    w->width = width;
  37.    w->column = col;
  38.  
  39.    return(w);
  40. }
  41.  
  42. void window_buffer(Buffer *b)
  43. {
  44.    if (JWindow == NULL)
  45.      {
  46.     JWindow = create_window(Top_Window_Row, 
  47.                 *tt_Screen_Rows - 2 - (Top_Window_Row - 1),
  48.                 1, *tt_Screen_Cols);
  49.     JWindow->next = JWindow;
  50.      }
  51.  
  52.    touch_window();
  53.    JWindow->mark.line = b->line;
  54.    JWindow->mark.point = b->point;
  55.    JWindow->mark.n = b->linenum + b->nup;
  56.    JWindow->beg.line = b->line;
  57.    JWindow->beg.point = b->point;
  58.    JWindow->buffer = b;
  59.    JWindow->trashed = 1;
  60. }
  61.  
  62. int other_window()
  63. {
  64.    switch_to_buffer(JWindow->buffer);
  65.    /* CBuf->line = CLine;
  66.    CBuf->point = Point; */
  67.    JWindow->mark.point = Point;
  68.    JWindow->mark.line = CLine;
  69.    JWindow->mark.n = LineNum + CBuf->nup;
  70.    /* JWindow->buffer = CBuf; */
  71.  
  72.    JWindow = JWindow->next;
  73.    switch_to_buffer(JWindow->buffer);
  74.    /* CBuf = JWindow->buffer; */
  75.    Point = JWindow->mark.point;
  76.    CLine = JWindow->mark.line;
  77.    LineNum = JWindow->mark.n - CBuf->nup;
  78.    return(1);
  79. }
  80.  
  81. int find_screen_line(void)
  82. {
  83.    int i;
  84.    for (i = 0; i < *tt_Screen_Rows - 2; i++)
  85.      {
  86.     if (JScreen[i].line == CLine) return(i + 1);
  87.      }
  88.    return(0);
  89. }
  90.  
  91. int split_window()
  92. {
  93.    int n, top, width, row;
  94.    Window_Type *w, *neew;
  95.    Line *l;
  96.  
  97.     if (JWindow->rows < 5)
  98.       {
  99.       msg_error("Window too small.");
  100.       return(0);
  101.       }
  102.  
  103.    switch_to_buffer(JWindow->buffer);
  104.     n = JWindow->rows / 2;
  105.     top = JWindow->top + n + 1;
  106.     width = JWindow->width;
  107.     n = JWindow->rows - n - 1;
  108.     JWindow->rows = JWindow->rows / 2;
  109.  
  110.     JWindow->beg.line = find_top();
  111.     w = JWindow->next;
  112.     JWindow->next = neew = create_window(top, n, JWindow->column, width);
  113.  
  114.    neew->next = w;
  115.    neew->buffer = CBuf;
  116.    neew->mark.point = Point;
  117.    neew->mark.line = CLine;
  118.    neew->mark.n = LineNum + CBuf->nup;
  119.  
  120.     other_window();
  121.     touch_window();
  122.    l = JWindow->beg.line = find_top();
  123.    n = 0;
  124.    while (l != CLine) 
  125.      {
  126.     l = l->next;
  127.     n++;
  128.      }
  129.    JWindow->beg.n = LineNum + CBuf->nup - n;
  130.    
  131.    /* Try to leave Point on same line of display if possible */
  132.    if ((row = find_screen_line()) > 0)
  133.      {
  134.     w = JWindow;
  135.     do
  136.       {
  137.          if ((JWindow->buffer == CBuf) && (JWindow->top <= row)
  138.          && (JWindow->top + JWindow->rows > row)) break;
  139.          other_window();
  140.       }
  141.     while (w != JWindow);
  142.      }
  143.  
  144.     return(1);
  145. }
  146.  
  147. int one_window()
  148. {
  149.     Window_Type *w, *next, *mini;
  150.    Buffer *b;
  151.     mini = NULL;
  152.     if (JWindow->top == *tt_Screen_Rows) return(0);  /* mini-buffer */
  153.     w = JWindow->next;
  154.    b = JWindow->buffer;
  155.     while(w != JWindow)
  156.       {
  157.       next = w->next;
  158.       if (w != The_MiniWindow) 
  159.        {
  160.           if (w->buffer != b) touch_window_hard (w, 0);
  161.           SLFREE(w);
  162.        }
  163.      else mini = w;
  164.      w = next;
  165.       }
  166.     if (mini == NULL) mini = JWindow;
  167.     JWindow->next = mini;
  168.     mini->next = JWindow;
  169.     JWindow->top = Top_Window_Row;
  170.     JWindow->rows = *tt_Screen_Rows - 2 - (Top_Window_Row - 1);
  171.     touch_window();
  172.     return(1);
  173. }
  174.  
  175. int enlarge_window()
  176. {
  177.    Window_Type *w, *w1;
  178.    int min = 2;
  179.  
  180.    if (JWindow == The_MiniWindow) return(0);
  181.    /* if (IS_MINIBUFFER) return(0); */
  182.    if (JWindow == JWindow->next) return(0);
  183.    w = JWindow->next;
  184.    while(w->rows <= min) w = w->next;
  185.    if (w == JWindow) return(0);
  186.  
  187.    if (w->top < JWindow->top)
  188.      {
  189.     w->rows -= 1;
  190.     JWindow->rows += 1;
  191.     do
  192.       {
  193.          w = w->next;
  194.          w->top -= 1;
  195.       }
  196.     while (w != JWindow);
  197.      }
  198.    else
  199.      {
  200.     JWindow->rows += 1;
  201.     w1 = JWindow;
  202.     while(w1 != w)
  203.       {
  204.          w1 = w1->next;
  205.          w1->top += 1;
  206.       }
  207.     w->rows -= 1;
  208.      }
  209.    w = JWindow;
  210.    do
  211.      {
  212.     touch_window();
  213.     JWindow = JWindow->next;
  214.      }
  215.    while (w != JWindow);
  216.    return(1);
  217. }
  218.  
  219. void adjust_windows(int height)
  220. {
  221.    Window_Type *w = JWindow;
  222.    int rows;
  223.  
  224.    do
  225.      {
  226.     if (w->rows + w->top + 1 == *tt_Screen_Rows)
  227.       {
  228.          rows = height - 1 - w->top;
  229.          if (rows > 1)
  230.            {
  231.           w->rows = rows;
  232.           return;
  233.            }
  234.          while(JWindow->top != Top_Window_Row) other_window();
  235.          one_window();
  236.          JWindow->rows = height - 2;
  237.          return;
  238.       }
  239.     w = w->next;
  240.      }
  241.    while (w != JWindow);
  242.    /* not reached! */
  243. }
  244.  
  245. void change_screen_size(int width, int height)
  246. {
  247.    Window_Type *w;
  248.  
  249.    if (JWindow == NULL) return;
  250.  
  251.    if (height != *tt_Screen_Rows)
  252.      {
  253.     adjust_windows(height);
  254.      }
  255.    reset_display();
  256.    *tt_Screen_Cols = width;
  257.    *tt_Screen_Rows = height;
  258.    init_display(0);
  259.    w = JWindow;
  260.    do
  261.      {
  262.     JWindow->width = width;
  263.  
  264.     /* touch_window(); */
  265.     JWindow = JWindow->next;
  266.      }
  267.    while(w != JWindow);
  268.    if (The_MiniWindow != NULL)
  269.      {
  270.     The_MiniWindow->top = height;
  271.     The_MiniWindow->width = width;
  272.      }
  273.    /* cls();
  274.    update((Line*) NULL); */
  275.    redraw_screen (1);
  276. }
  277.  
  278. Window_Type *buffer_visible(Buffer *b)
  279. {
  280.    Window_Type *w = JWindow;
  281.  
  282.    do
  283.      {
  284.     if (w->buffer == b) return(w);
  285.     w = w->next;
  286.      }
  287.    while (w != JWindow);
  288.    return(NULL);
  289. }
  290.  
  291. int delete_window()
  292. {
  293.    Window_Type *tthis, *prev, *next;
  294.    int nr1;
  295.    
  296.    tthis = JWindow;
  297.    next = tthis->next;
  298.    if ((MiniBuffer_Active && ((tthis == The_MiniWindow) || (tthis == next->next)))
  299.        || (tthis == next)) return(0);
  300.    
  301.    
  302.    
  303.    nr1 = tthis->top + tthis->rows + 1;
  304.    if (nr1 != *tt_Screen_Rows)
  305.      {
  306.     while (JWindow->top != nr1) other_window();
  307.     JWindow->top = tthis->top;
  308.      }
  309.    else
  310.      {
  311.     while(JWindow->top + JWindow->rows + 1 != tthis->top) other_window();
  312.      }
  313.    
  314.    JWindow->rows += tthis->rows + 1;
  315.    touch_window();
  316.    
  317.    prev = next;
  318.    while(prev->next != tthis) prev = prev->next;
  319.    prev->next = next;
  320.  
  321.    SLFREE(tthis);
  322.    return(1);
  323. }
  324.  
  325. void touch_window_hard(Window_Type *w, int all)
  326. {
  327.    int i;
  328.    Window_Type *wsave = w;
  329.    
  330.    do 
  331.      {
  332.     for (i = 0; i < w->rows; i++)
  333.       {
  334.          JScreen[i + w->top - 1].flags = 1;
  335.          JScreen[i + w->top - 1].line = NULL;
  336.       }
  337.     w->trashed = 1;
  338.     w = w->next;
  339.      }
  340.    while (all && (w != wsave));
  341. }
  342.  
  343. void touch_screen_for_buffer(Buffer *b)
  344. {
  345.    Window_Type *w;
  346.    
  347.    w = JWindow;
  348.    do
  349.      {
  350.     if (w->buffer == b)
  351.       {
  352.          touch_window_hard (w, 0);
  353.       }
  354.     w = w->next;
  355.      }
  356.    while(w != JWindow);
  357. }
  358.