home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / screen.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  13KB  |  607 lines
  1. /* This file is part of
  2. * ======================================================
  3. * 
  4. *           LyX, The Document Processor
  5. *      
  6. *        Copyright (C) 1995 Matthias Ettrich
  7. *           Copyright (C) 1995-1998 The LyX Team
  8. *
  9. *======================================================*/
  10.  
  11. #include <config.h>
  12.  
  13. #ifdef __GNUG__
  14. #pragma implementation "lyxscreen.h"
  15. #endif
  16.  
  17. #include "lyxscreen.h"
  18. #include "lyxdraw.h"
  19. #include "lyxtext.h"
  20.  
  21. //     $Id: screen.C,v 1.1.1.1 1998/04/23 16:02:54 larsbj Exp $    
  22.  
  23. #if !defined(lint) && !defined(WITH_WARNINGS)
  24. static char vcid[] = "$Id: screen.C,v 1.1.1.1 1998/04/23 16:02:54 larsbj Exp $";
  25. #endif /* lint */
  26.  
  27. // Constructor
  28. LyXScreen::LyXScreen(Window window,
  29.              Dimension width, 
  30.              Dimension height,
  31.              Dimension offset_x,
  32.              Dimension offset_y,
  33.              LyXText *text_ptr)
  34.     : text(text_ptr),_window(window), 
  35.       _width(width),_height(height),
  36.       _offset_x(offset_x), _offset_y(offset_y)
  37. {
  38.     first = 0;
  39.    
  40.     /* the cursor isnt yet visible */ 
  41.     cursor_visible = false;
  42.     screen_refresh_y = -1;
  43.  
  44.     /* create the foreground pixmap */
  45.     foreground = XCreatePixmap (fl_display,
  46.                     RootWindow(fl_display, 0),
  47.                     _width, _height, 
  48.                     fl_get_visual_depth());
  49.     cursor_pixmap = 0;
  50.     cursor_pixmap_x = 0;
  51.     cursor_pixmap_y = 0;
  52.     cursor_pixmap_w = 0;
  53.     cursor_pixmap_h = 0;
  54. }
  55.  
  56.  
  57. // Destructor
  58. LyXScreen::~LyXScreen()
  59. {
  60.     XFreePixmap(fl_display, foreground);
  61. }
  62.  
  63.  
  64. void LyXScreen::Redraw()
  65. {
  66.     DrawFromTo(0, _height);
  67.     screen_refresh_y = -1;
  68.     expose(0, 0, _width, _height);
  69.     if (cursor_visible) {
  70.         cursor_visible = false;
  71.         ShowCursor();
  72.     }
  73. }
  74.  
  75.  
  76. void LyXScreen::expose(int x, int y, int exp_width, int exp_height)
  77. {
  78.     XCopyArea(fl_display,
  79.           foreground,
  80.           _window,
  81.           getGC(gc_copy),
  82.           x, y,
  83.           exp_width, exp_height,
  84.           x+_offset_x, y+_offset_y);
  85. }
  86.  
  87.  
  88. void LyXScreen::DrawFromTo(int y1, int y2)
  89. {
  90.     Row* row = 0;
  91.     long  y_text = 0;
  92.     long y = 0;
  93.     
  94.     y_text = first + y1;
  95.    
  96.     /* get the first needed row */ 
  97.     row = text->GetRowNearY(y_text);
  98.     /* y_text is now the real beginning of the row */
  99.    
  100.     y = y_text - first;
  101.     /* y1 is now the real beginning of row on the screen */
  102.     
  103.     while (row != NULL && y < y2) {
  104.  
  105.         text->GetVisibleRow(*this, y, row, y + first);
  106.         y += row->height;
  107.         row = row -> next;
  108.  
  109.     }
  110.    
  111.     /* maybe we have to clear the screen at the bottom */ 
  112.     if (y < y2) {
  113.         fillRectangle(gc_lighted,
  114.                   0,
  115.                   y,
  116.                   _width,
  117.                   y2 - y);
  118.     }
  119. }
  120.  
  121.  
  122. void LyXScreen::DrawOneRow(Row *row, long &y_text)
  123. {
  124.     long y = 0;
  125.    
  126.     y = y_text - first;
  127.       
  128.     if (y + row->height > 0 && y - row->height <= _height) {
  129.         /* ok there is something visible */
  130.         text->GetVisibleRow(*this, y, row, y + first);
  131.     }
  132.     y_text+=row->height;
  133. }
  134.  
  135.  
  136. /* draws the screen, starting with textposition y. uses as much already
  137. * printed pixels as possible */
  138. void LyXScreen::Draw(long  y)
  139. {
  140.     if (cursor_visible) HideCursor();
  141.  
  142.     if (y<0) y = 0;
  143.     long old_first = first;
  144.     first = y;
  145.  
  146.     /* is any optimiziation possible? */ 
  147.     if ((y - old_first) < _height 
  148.         && (old_first - y) < _height) {
  149.         if (first < old_first) {
  150.             DrawFromTo(0, old_first - first);
  151.             XCopyArea (fl_display,
  152.                    _window,
  153.                    _window,
  154.                    getGC(gc_copy),
  155.                    _offset_x, _offset_y, 
  156.                    _width , _height - old_first + first,
  157.                    _offset_x, _offset_y + old_first - first);
  158.             // expose the area drawn
  159.             expose(0, 0, _width, old_first - first);
  160.         } else  {
  161.             DrawFromTo(_height + old_first - first, _height);
  162.             XCopyArea (fl_display,
  163.                    _window,
  164.                    _window,
  165.                    getGC(gc_copy),
  166.                    _offset_x, _offset_y + first - old_first, 
  167.                    _width , _height + old_first - first, 
  168.                    _offset_x, _offset_y);
  169.             // expose the area drawn
  170.             expose(0, _height + old_first - first, 
  171.                    _width, first - old_first);
  172.         }
  173.     } else {
  174.         /* make a dumb new-draw */ 
  175.         DrawFromTo(0, _height);
  176.         expose(0, 0, _width, _height);
  177.     }
  178. }
  179.  
  180.  
  181. void LyXScreen::ShowCursor()
  182. {
  183.     long x = 0;
  184.     long y1 = 0;
  185.     long y2 = 0;
  186.    
  187.     if (cursor_visible) return;
  188.    
  189.     x = text->cursor.x;
  190.     
  191.     y1 = text->cursor.y - text->real_current_font.maxAscent() - first;
  192.     if (y1 < 0) y1 = 0;
  193.     
  194.     y2 = text->cursor.y + text->real_current_font.maxDescent() - first;
  195.     if (y2 > _height) y2 = _height;
  196.  
  197.     // Secure against very strange situations
  198.     if (y2 < y1) y2 = y1;
  199.  
  200.     if (cursor_pixmap){
  201.         XFreePixmap(fl_display, cursor_pixmap);
  202.         cursor_pixmap = 0;
  203.     }
  204.     
  205.     if (y2 > 0 && y1 < _height) {
  206.         cursor_pixmap_w = 1;
  207.         cursor_pixmap_h = y2 - y1 + 1;
  208.         cursor_pixmap_x = x;
  209.         cursor_pixmap_y = y1;
  210.         cursor_pixmap =
  211.             XCreatePixmap(fl_display,
  212.                       RootWindow(fl_display, 0),
  213.                       cursor_pixmap_w,
  214.                       cursor_pixmap_h,
  215.                       fl_get_visual_depth());
  216.         XCopyArea(fl_display,
  217.               _window,
  218.               cursor_pixmap,
  219.               getGC(gc_copy),
  220.               _offset_x + cursor_pixmap_x, 
  221.               _offset_y + cursor_pixmap_y,
  222.               cursor_pixmap_w, cursor_pixmap_h,
  223.               0, 0);
  224.         XDrawLine(fl_display,
  225.               _window, getGC(gc_copy),
  226.               x + _offset_x,
  227.               y1 + _offset_y,
  228.               x + _offset_x,
  229.               y2 + _offset_y); 
  230.         cursor_visible = true;
  231.     }
  232. }
  233.  
  234.  
  235. /* returns 1 if first has changed, otherwise 0 */ 
  236. int LyXScreen::FitManualCursor(long /*x*/, long y, int asc, int desc)
  237. {
  238.     long  newtop = first;
  239.   
  240.     if (y + desc  - first >= _height)
  241.         newtop = y - 3*_height / 4;   /* the scroll region must be so big!! */
  242.     else if (y - asc < first 
  243.          && first > 0) {
  244.         newtop = y - _height / 4;
  245.     }
  246.     if (newtop < 0)
  247.         newtop = 0;
  248.   
  249.     if (newtop != first){
  250.         Draw(newtop);
  251.         first = newtop;
  252.         return 1;
  253.     }
  254.     return 0;
  255. }
  256.  
  257.  
  258. void  LyXScreen::HideManualCursor(long /*x*/, long /*y*/,
  259.                   int /*asc*/, int /*desc*/)
  260. {
  261.     HideCursor();
  262. }
  263.  
  264.  
  265. void  LyXScreen::ShowManualCursor(long x, long y, int asc, int desc)
  266. {
  267.     long y1 = 0;
  268.     long y2 = 0;
  269.     
  270.     y1 = y - first - asc;
  271.     if (y1 < 0)
  272.         y1 =0;
  273.     y2 = y -first + desc;
  274.     if (y2 > _height)
  275.         y2 = _height;
  276.     
  277.     if (cursor_pixmap){
  278.         XFreePixmap(fl_display, cursor_pixmap);
  279.         cursor_pixmap = 0;
  280.     }
  281.     
  282.     if (y2 > 0 && y1 < _height) {
  283.         cursor_pixmap_w = 1;
  284.         cursor_pixmap_h = y2 - y1 + 1;
  285.         cursor_pixmap_x = x,
  286.             cursor_pixmap_y = y1;
  287.         cursor_pixmap =
  288.             XCreatePixmap (fl_display,
  289.                        RootWindow(fl_display, 0),
  290.                        cursor_pixmap_w,
  291.                        cursor_pixmap_h,
  292.                        fl_get_visual_depth());
  293.         
  294.         XCopyArea (fl_display,
  295.                _window,
  296.                cursor_pixmap,
  297.                getGC(gc_copy),
  298.                _offset_x + cursor_pixmap_x,
  299.                _offset_y + cursor_pixmap_y,
  300.                cursor_pixmap_w,
  301.                cursor_pixmap_h,
  302.                0, 0);
  303.         XDrawLine(fl_display,
  304.               _window, getGC(gc_copy),
  305.               x+_offset_x,
  306.               y1+_offset_y,
  307.               x+_offset_x,
  308.               y2+_offset_y);            
  309.     }
  310.     cursor_visible = true;
  311. }
  312.  
  313.  
  314. void LyXScreen::HideCursor()
  315. {
  316.     if (!cursor_visible) return;
  317.     
  318.     if (cursor_pixmap){
  319.         XCopyArea (fl_display, 
  320.                cursor_pixmap,
  321.                _window,
  322.                getGC(gc_copy),
  323.                0, 0, 
  324.                cursor_pixmap_w, cursor_pixmap_h,
  325.                cursor_pixmap_x + _offset_x,
  326.                cursor_pixmap_y + _offset_y);
  327.     }
  328.     cursor_visible = false;
  329. }
  330.  
  331.  
  332. void LyXScreen::CursorToggle()
  333. {
  334.     if (cursor_visible)
  335.         HideCursor();
  336.     else
  337.         ShowCursor();
  338. }
  339.  
  340.  
  341. /* returns a new top so that the cursor is visible */ 
  342. long LyXScreen::TopCursorVisible()
  343. {
  344.     long  newtop = first;
  345.  
  346.     if (text->cursor.y
  347.         - text->cursor.row->baseline
  348.         + text->cursor.row->height
  349.         - first >= _height) {
  350.         if (text->cursor.row->height < _height
  351.             && text->cursor.row->height > _height/4)
  352.             newtop = text->cursor.y
  353.                 + text->cursor.row->height
  354.                 - text->cursor.row->baseline - _height;
  355.         else
  356.             newtop = text->cursor.y
  357.                 - 3*_height / 4;   /* the scroll region must be so big!! */
  358.     } else if (text->cursor.y - text->cursor.row->baseline < first 
  359.            && first > 0) {
  360.         if (text->cursor.row->height < _height
  361.             && text->cursor.row->height > _height/4)
  362.             newtop = text->cursor.y - text->cursor.row->baseline;
  363.         else {
  364.             newtop = text->cursor.y - _height / 4;
  365.             if (newtop > first)
  366.                 newtop = first;
  367.         }
  368.     }
  369.     if (newtop < 0)
  370.         newtop = 0;
  371.     
  372.     return newtop;
  373. }
  374.  
  375.  
  376. /* scrolls the screen so that the cursor is visible, if necessary.
  377. * returns 1 if a change was made, otherwise 0 */ 
  378. int LyXScreen::FitCursor()
  379. {
  380.     /* is a change necessary */ 
  381.     long  newtop = TopCursorVisible();
  382.     int result = (newtop != first);
  383.     if (result)
  384.         Draw(newtop);
  385.     return result;
  386. }
  387.  
  388.    
  389. void LyXScreen::Update()
  390. {
  391.     long y = 0;
  392.  
  393.     if (text->status == LyXText::NEED_MORE_REFRESH
  394.         || screen_refresh_y > -1 ) {
  395.         if (screen_refresh_y > -1
  396.             && screen_refresh_y < text->refresh_y)
  397.             y = screen_refresh_y;
  398.         else
  399.             y = text->refresh_y;
  400.         
  401.         if (y < first) y = first;
  402.         
  403.         DrawFromTo(y - first, _height);
  404.         text->refresh_y = 0;
  405.         text->status = LyXText::UNCHANGED;
  406.         screen_refresh_y = -1;
  407.         expose(0, y-first, _width, _height - (y - first));
  408.     } else if (text->status == LyXText::NEED_VERY_LITTLE_REFRESH) {
  409.         /* ok I will update the current cursor row */
  410.         y = text->refresh_y;
  411.         DrawOneRow(text->refresh_row, y);
  412.         text->status = LyXText::UNCHANGED;
  413.         expose(0, text->refresh_y-first,
  414.              _width, text->refresh_row->height);
  415.     }
  416. }
  417.  
  418.  
  419. void LyXScreen::SmallUpdate()
  420. {
  421.     Row *row = 0;
  422.     long y = 0;
  423.     long y2 = 0;
  424.     
  425.     if (text->status == LyXText::NEED_MORE_REFRESH){
  426.         /* ok I will update till the current cursor row */
  427.         row = text->refresh_row;
  428.         y = text->refresh_y;
  429.         y2 = y;
  430.       
  431.         if (y > text->cursor.y) {
  432.             Update();
  433.             return;
  434.         }
  435.      
  436.         while (row && row != text->cursor.row && y < first + _height) {
  437.             DrawOneRow(row, y);
  438.             row = row->next;
  439.         }
  440.       
  441.         DrawOneRow(row, y);
  442.         screen_refresh_y = y;
  443.         screen_refresh_row = row->next;
  444.         text->status = LyXText::UNCHANGED;
  445.         // Is the right regin exposed?
  446.         expose(0, y2-first, _width, y-y2);
  447.     } else if (text->status == LyXText::NEED_VERY_LITTLE_REFRESH) {
  448.         /* ok I will update the current cursor row */
  449.         row = text->refresh_row;
  450.         y = text->refresh_y;
  451.         DrawOneRow(row, y);
  452.         text->status = LyXText::UNCHANGED;
  453.         expose(0, text->refresh_y - first,
  454.                _width, row->height);
  455.     }
  456. }
  457.  
  458.  
  459. void LyXScreen::ToggleSelection(bool kill_selection)
  460. {
  461.     long top = 0;
  462.     long bottom = 0;
  463.    
  464.     /* only if there is a selection */ 
  465.     if (!text->selection)
  466.         return;
  467.     
  468.     top = text->sel_start_cursor.y
  469.         - text->sel_start_cursor.row->baseline;
  470.     bottom = text->sel_end_cursor.y
  471.         - text->sel_end_cursor.row->baseline 
  472.         + text->sel_end_cursor.row->height;
  473.     
  474.     if (top - first < 0)
  475.         top = first;
  476.     if (bottom - first < 0)
  477.         bottom = first;
  478.     
  479.     if (bottom - first > _height)
  480.         bottom = first + _height;
  481.     if (top - first > _height)
  482.         top = first + _height;
  483.     
  484.     if (kill_selection)
  485.         text->selection = 0;
  486.     DrawFromTo(top - first, bottom - first);
  487.     expose(0, top - first, _width, bottom - first - (top - first));
  488. }
  489.   
  490.    
  491. void LyXScreen::ToggleToggle()
  492. {
  493.     long top = 0;
  494.     long bottom = 0;
  495.     
  496.     if (text->toggle_cursor.par == text->toggle_end_cursor.par
  497.         && text->toggle_cursor.pos == text->toggle_end_cursor.pos)
  498.         return;
  499.  
  500.     top = text->toggle_cursor.y
  501.         - text->toggle_cursor.row->baseline;
  502.     bottom = text->toggle_end_cursor.y
  503.         - text->toggle_end_cursor.row->baseline 
  504.         + text->toggle_end_cursor.row->height;
  505.     
  506.     if (top - first < 0)
  507.         top = first;
  508.     if (bottom - first < 0)
  509.         bottom = first;
  510.     
  511.     if (bottom - first > _height)
  512.         bottom = first + _height;
  513.     if (top - first > _height)
  514.         top = first + _height;
  515.     
  516.     DrawFromTo(top - first, bottom - first);
  517.     expose(0, top - first, _width, bottom - first - (top - first));
  518. }
  519.  
  520.  
  521.     
  522. void LyXScreen::drawTableLine(int baseline, int x, int length, bool on_off)
  523. {
  524.     GC gc;
  525.     if (on_off)
  526.         gc = getGC(gc_thin_on_off_line);
  527.     else
  528.         gc = getGC(gc_copy);
  529.     drawLine(gc,
  530.          x,
  531.          baseline,
  532.          x + length,
  533.          baseline);
  534. }
  535.  
  536.     
  537. void LyXScreen::drawVerticalTableLine(int x, int y1, int y2, bool on_off)
  538. {
  539.     GC gc;
  540.     if (on_off)
  541.         gc = getGC(gc_thin_on_off_line);
  542.     else
  543.         gc = getGC(gc_copy);
  544.     drawLine(gc,
  545.          x,
  546.          y1,
  547.          x,
  548.          y2);
  549. }
  550.  
  551.  
  552. void LyXScreen::drawFrame(int /*ft*/, int x, int y, int w, int h,
  553.               FL_COLOR /*col*/, int /*b*/)
  554. {
  555. // Everything works now isn't it?    
  556. // #ifdef WITH_WARNINGS
  557. // #warning Implement this using X11 calls, and the repaint problems are gone!
  558. // #endif
  559. // At least, I think that should do it since we only have them after
  560. // one of these buttons are displayed now! Lars, it seems you've hit the
  561. // nail :-) (Asger)
  562. //    fl_winset(foreground);
  563. //    fl_drw_frame(ft, x,  y,  w,  h, col, b);
  564.     // This should be changed to draw a button like frame, in the
  565.     // mean time we'll just use a regular rectangle
  566.      
  567.          // I want the buttons back before 0.12. OK, this is very simple,
  568.          // like what is done in xforms sources.  (Ale)
  569.  
  570.     // This one is too dirty. Get rid of it.
  571.     extern GC fl_gc;
  572.  
  573.     // Please comment this anonymous variable.
  574.     int d = 2;
  575.  
  576.     // I think these calls to fl_color might make xforms sometimes
  577.     // draw the wrong color on other objects.
  578.     fl_color(FL_TOP_BCOL);
  579.     XFillRectangle(fl_display, foreground, fl_gc,x-d,y-d,w+2*d,d);
  580.     fl_color(FL_BOTTOM_BCOL);
  581.     XFillRectangle(fl_display, foreground, fl_gc,x-d,y+h,w+2*d,d);
  582.  
  583.     // Now a couple of trapezoids
  584.     XPoint pl[4], pr[4]; 
  585.  
  586.     pl[0].x = x-d;   pl[0].y = y-d;
  587.     pl[1].x = x-d;   pl[1].y = y+h+d;
  588.     pl[2].x = x;     pl[2].y = y+h;
  589.     pl[3].x = x;     pl[3].y = y;
  590.     
  591.     pr[0].x = x+w+d; pr[0].y = y-d;
  592.     pr[1].x = x+w+d; pr[1].y = y+h+d;
  593.     pr[2].x = x+w;   pr[2].y = y+h;
  594.     pr[3].x = x+w;   pr[3].y = y;
  595.     
  596.     fl_color(FL_LEFT_BCOL);
  597.     XFillPolygon(fl_display,
  598.              foreground,
  599.              fl_gc, pl, 4,
  600.              Convex, CoordModeOrigin); 
  601.     fl_color(FL_RIGHT_BCOL);
  602.     XFillPolygon(fl_display,
  603.              foreground,
  604.              fl_gc, pr, 4,
  605.              Convex, CoordModeOrigin); 
  606. }
  607.