src/screen.C

   1 /* This file is part of
   2 * ======================================================
   3 *
   4 *           LyX, The Document Processor
   5 *
   6 *           Copyright 1995 Matthias Ettrich
   7 *           Copyright 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 <algorithm>
  18
  19 #include "lyxscreen.h"
  20 #include "lyxtext.h"
  21 #include "lyxrow.h"
  22 #include "Painter.h"
  23 #include "WorkArea.h"
  24 #include "buffer.h"
  25 #include "font.h"
  26 #include "insets/insettext.h"
  27
  28 using std::max;
  29 using std::min;
  30
  31 static
  32 GC createGC()
  33 {
  34         XGCValues val;
  35         val.foreground = BlackPixel(fl_display,
  36                                     DefaultScreen(fl_display));
  37
  38         val.function=GXcopy;
  39         val.graphics_exposures = false;
  40         val.line_style = LineSolid;
  41         val.line_width = 0;
  42         return XCreateGC(fl_display, RootWindow(fl_display, 0),
  43                          GCForeground | GCFunction | GCGraphicsExposures
  44                          | GCLineWidth | GCLineStyle , &val);
  45 }
  46
  47
  48 // Constructor
  49 LyXScreen::LyXScreen(WorkArea & o) //, LyXText * text_ptr)
  50         : owner(o), force_clear(true) //, text(text_ptr)
  51 {
  52         // the cursor isnt yet visible
  53         cursor_visible = false;
  54         cursor_pixmap = 0;
  55         cursor_pixmap_x = 0;
  56         cursor_pixmap_y = 0;
  57         cursor_pixmap_w = 0;
  58         cursor_pixmap_h = 0;
  59
  60         // We need this GC
  61         gc_copy = createGC();
  62 }
  63
  64
  65 void LyXScreen::Redraw(LyXText * text)
  66 {
  67         DrawFromTo(text, 0, owner.height());
  68         expose(0, 0, owner.workWidth(), owner.height());
  69         if (cursor_visible) {
  70                 cursor_visible = false;
  71                 ShowCursor(text);
  72         }
  73 }
  74
  75
  76 void LyXScreen::expose(int x, int y, int exp_width, int exp_height)
  77 {
  78         XCopyArea(fl_display,
  79                   owner.getPixmap(),
  80                   owner.getWin(),
  81                   gc_copy,
  82                   x, y,
  83                   exp_width, exp_height,
  84                   x + owner.xpos(),
  85                   y + owner.ypos());
  86 }
  87
  88
  89 void LyXScreen::DrawFromTo(LyXText * text,
  90                            int y1, int y2, int y_offset, int x_offset)
  91 {
  92         int y_text = text->first + y1;
  93
  94         // get the first needed row
  95         Row * row = text->GetRowNearY(y_text);
  96         // y_text is now the real beginning of the row
  97
  98         int y = y_text - text->first;
  99         // y1 is now the real beginning of row on the screen
 100
 101         while (row != 0 && y < y2) {
 102                 LyXText::text_status st = text->status;
 103                 do {
 104                         text->status = st;
 105                         text->GetVisibleRow(owner.owner(), y+y_offset,
 106                                             x_offset, row, y + text->first);
 107                 } while (text->status == LyXText::CHANGED_IN_DRAW);
 108                 text->status = st;
 109                 y += row->height();
 110                 row = row->next();
 111         }
 112         force_clear = false;
 113
 114         // maybe we have to clear the screen at the bottom
 115         if ((y < y2) && text->bv_owner) {
 116                 owner.getPainter().fillRectangle(0, y,
 117                                                  owner.workWidth(),
 118                                                  y2 - y,
 119                                                LColor::bottomarea);
 120         }
 121 }
 122
 123
 124 void LyXScreen::DrawOneRow(LyXText * text, Row * row, int y_text,
 125                            int y_offset, int x_offset)
 126 {
 127         int y = y_text - text->first + y_offset;
 128
 129         if (y + row->height() > 0
 130             && y - row->height() <= owner.height()) {
 131                 // ok there is something visible
 132                 LyXText::text_status st = text->status;
 133                 do {
 134                         text->status = st;
 135                         text->GetVisibleRow(owner.owner(), y, x_offset, row,
 136                                             y + text->first);
 137                 } while (text->status == LyXText::CHANGED_IN_DRAW);
 138                 text->status = st;
 139         }
 140         force_clear = false;
 141 }
 142
 143
 144 /* draws the screen, starting with textposition y. uses as much already
 145 * printed pixels as possible */
 146 void LyXScreen::Draw(LyXText * text, unsigned int y)
 147 {
 148         if (cursor_visible) HideCursor();
 149
 150         unsigned int old_first = text->first;
 151         text->first = y;
 152
 153         // is any optimiziation possible?
 154         if ((y - old_first) < owner.height()
 155             && (old_first - y) < owner.height()) {
 156                 if (text->first < old_first) {
 157                         DrawFromTo(text, 0, old_first - text->first);
 158                         XCopyArea (fl_display,
 159                                    owner.getWin(),
 160                                    owner.getWin(),
 161                                    gc_copy,
 162                                    owner.xpos(),
 163                                    owner.ypos(),
 164                                    owner.workWidth(),
 165                                    owner.height() - old_first + text->first,
 166                                    owner.xpos(),
 167                                    owner.ypos() + old_first - text->first
 168                                 );
 169                         // expose the area drawn
 170                         expose(0, 0,
 171                                owner.workWidth(),
 172                                old_first - text->first);
 173                 } else  {
 174                         DrawFromTo(text,
 175                                    owner.height() + old_first - text->first,
 176                                    owner.height());
 177                         XCopyArea (fl_display,
 178                                    owner.getWin(),
 179                                    owner.getWin(),
 180                                    gc_copy,
 181                                    owner.xpos(),
 182                                    owner.ypos() + text->first - old_first,
 183                                    owner.workWidth(),
 184                                    owner.height() + old_first - text->first,
 185                                    owner.xpos(),
 186                                    owner.ypos());
 187                         // expose the area drawn
 188                         expose(0, owner.height() + old_first - text->first,
 189                                owner.workWidth(), text->first - old_first);
 190                 }
 191         } else {
 192                 // make a dumb new-draw
 193                 DrawFromTo(text, 0, owner.height());
 194                 expose(0, 0, owner.workWidth(), owner.height());
 195         }
 196 }
 197
 198
 199 void LyXScreen::ShowCursor(LyXText const * text)
 200 {
 201         if (!cursor_visible) {
 202                 Cursor_Shape shape = BAR_SHAPE;
 203                 if (text->real_current_font.language() !=
 204                     owner.owner()->buffer()->params.language_info
 205                     || text->real_current_font.isVisibleRightToLeft()
 206                     != owner.owner()->buffer()->params.language_info->RightToLeft())
 207                         shape = (text->real_current_font.isVisibleRightToLeft())
 208                                 ? REVERSED_L_SHAPE : L_SHAPE;
 209                 ShowManualCursor(text, text->cursor.x(), text->cursor.y(),
 210                                  lyxfont::maxAscent(text->real_current_font),
 211                                  lyxfont::maxDescent(text->real_current_font),
 212                                  shape);
 213         }
 214 }
 215
 216
 217 /* returns true if first has changed, otherwise false */
 218 bool LyXScreen::FitManualCursor(LyXText * text,
 219                                 int /*x*/, int y, int asc, int desc)
 220 {
 221         int newtop = text->first;
 222
 223         if (y + desc - text->first >= owner.height())
 224                 newtop = y - 3 * owner.height() / 4;  // the scroll region must be so big!!
 225         else if (y - asc < text->first
 226                 && text->first > 0) {
 227                 newtop = y - owner.height() / 4;
 228         }
 229
 230         newtop = max(newtop, 0); // can newtop ever be < 0? (Lgb)
 231
 232         if (newtop != text->first) {
 233                 Draw(text, newtop);
 234                 text->first = newtop;
 235                 return true;
 236         }
 237         return false;
 238 }
 239
 240
 241 void LyXScreen::ShowManualCursor(LyXText const * text, int x, int y,
 242                                  int asc, int desc, Cursor_Shape shape)
 243 {
 244         unsigned int y1 = max(y - text->first - asc, 0U);
 245         typedef unsigned int uint;
 246
 247         unsigned int y2 = min(y - text->first + desc, owner.height());
 248
 249         // Secure against very strange situations
 250         y2 = max(y2, y1);
 251
 252         if (cursor_pixmap){
 253                 XFreePixmap(fl_display, cursor_pixmap);
 254                 cursor_pixmap = 0;
 255         }
 256
 257         if (y2 > 0 && y1 < owner.height()) {
 258                 cursor_pixmap_h = y2 - y1 + 1;
 259                 cursor_pixmap_y = y1;
 260
 261                 switch(shape) {
 262                 case BAR_SHAPE:
 263                         cursor_pixmap_w = 1;
 264                         cursor_pixmap_x = x;
 265                         break;
 266                 case L_SHAPE:
 267                         cursor_pixmap_w = cursor_pixmap_h/3;
 268                         cursor_pixmap_x = x;
 269                         break;
 270                 case REVERSED_L_SHAPE:
 271                         cursor_pixmap_w = cursor_pixmap_h/3;
 272                         cursor_pixmap_x = x - cursor_pixmap_w + 1;
 273                         break;
 274                 }
 275
 276                 cursor_pixmap =
 277                         XCreatePixmap (fl_display,
 278                                        fl_root,
 279                                        cursor_pixmap_w,
 280                                        cursor_pixmap_h,
 281                                        fl_get_visual_depth());
 282                 XCopyArea (fl_display,
 283                            owner.getWin(),
 284                            cursor_pixmap,
 285                            gc_copy,
 286                            owner.xpos() + cursor_pixmap_x,
 287                            owner.ypos() + cursor_pixmap_y,
 288                            cursor_pixmap_w,
 289                            cursor_pixmap_h,
 290                            0, 0);
 291                 XDrawLine(fl_display,
 292                           owner.getWin(),
 293                           gc_copy,
 294                           x + owner.xpos(),
 295                           y1 + owner.ypos(),
 296                           x + owner.xpos(),
 297                           y2 + owner.ypos());
 298                 switch(shape) {
 299                 case BAR_SHAPE:
 300                         break;
 301                 case L_SHAPE:
 302                 case REVERSED_L_SHAPE:
 303                         int rectangle_h = (cursor_pixmap_h+10)/20;
 304                         XFillRectangle(fl_display,
 305                                        owner.getWin(),
 306                                        gc_copy,
 307                                        cursor_pixmap_x + owner.xpos(),
 308                                        y2 - rectangle_h + 1 + owner.ypos(),
 309                                        cursor_pixmap_w - 1, rectangle_h);
 310                         break;
 311                 }
 312
 313         }
 314         cursor_visible = true;
 315 }
 316
 317
 318 void LyXScreen::HideCursor()
 319 {
 320         if (!cursor_visible) return;
 321
 322         if (cursor_pixmap){
 323                 XCopyArea (fl_display,
 324                            cursor_pixmap,
 325                            owner.getWin(),
 326                            gc_copy,
 327                            0, 0,
 328                            cursor_pixmap_w, cursor_pixmap_h,
 329                            cursor_pixmap_x + owner.xpos(),
 330                            cursor_pixmap_y + owner.ypos());
 331         }
 332         cursor_visible = false;
 333 }
 334
 335
 336 void LyXScreen::CursorToggle(LyXText const * text)
 337 {
 338         if (cursor_visible)
 339                 HideCursor();
 340         else
 341                 ShowCursor(text);
 342 }
 343
 344
 345 /* returns a new top so that the cursor is visible */
 346 unsigned int LyXScreen::TopCursorVisible(LyXText const * text)
 347 {
 348         int newtop = text->first;
 349
 350         if (text->cursor.y()
 351             - text->cursor.row()->baseline()
 352             + text->cursor.row()->height()
 353             - text->first >= owner.height()) {
 354                 if (text->cursor.row()->height() < owner.height()
 355                     && text->cursor.row()->height() > owner.height() / 4)
 356                         newtop = text->cursor.y()
 357                                 + text->cursor.row()->height()
 358                                 - text->cursor.row()->baseline() - owner.height();
 359                 else
 360                         newtop = text->cursor.y()
 361                                 - 3 * owner.height() / 4;   /* the scroll region must be so big!! */
 362         } else if (text->cursor.y() - text->cursor.row()->baseline() < text->first
 363                    && text->first > 0) {
 364                 if (text->cursor.row()->height() < owner.height()
 365                     && text->cursor.row()->height() > owner.height() / 4)
 366                         newtop = text->cursor.y() - text->cursor.row()->baseline();
 367                 else {
 368                         newtop = text->cursor.y() - owner.height() / 4;
 369                         newtop = min(newtop, int(text->first));
 370                 }
 371         }
 372
 373         newtop = max(newtop, 0);
 374
 375         return newtop;
 376 }
 377
 378
 379 /* scrolls the screen so that the cursor is visible, if necessary.
 380 * returns true if a change was made, otherwise false */
 381 bool LyXScreen::FitCursor(LyXText * text)
 382 {
 383         // Is a change necessary?
 384         unsigned int newtop = TopCursorVisible(text);
 385         bool result = (newtop != text->first);
 386         if (result)
 387                 Draw(text, newtop);
 388         return result;
 389 }
 390
 391
 392 void LyXScreen::Update(LyXText * text, int y_offset, int x_offset)
 393 {
 394         switch(text->status) {
 395         case LyXText::NEED_MORE_REFRESH:
 396         {
 397                 int y = max(int(text->refresh_y - text->first), 0);
 398                 int height;
 399                 if (text->inset_owner)
 400                         height = text->inset_owner->ascent(owner.owner(),
 401                                                            text->real_current_font)
 402                                 + text->inset_owner->descent(owner.owner(),
 403                                                              text->real_current_font);
 404                 else
 405                         height = owner.height();
 406                 DrawFromTo(text, y, owner.height(), y_offset, x_offset);
 407                 text->refresh_y = 0;
 408                 text->status = LyXText::UNCHANGED;
 409                 expose(0, y,
 410                        owner.workWidth(), owner.height() - y);
 411         }
 412         break;
 413         case LyXText::NEED_VERY_LITTLE_REFRESH:
 414         {
 415                 // ok I will update the current cursor row
 416                 DrawOneRow(text, text->refresh_row, text->refresh_y,
 417                            y_offset, x_offset);
 418                 text->status = LyXText::UNCHANGED;
 419                 expose(0, text->refresh_y - text->first + y_offset,
 420                        owner.workWidth(), text->refresh_row->height());
 421         }
 422         break;
 423         case LyXText::CHANGED_IN_DRAW: // just to remove the warning
 424         case LyXText::UNCHANGED:
 425                 // Nothing needs done
 426                 break;
 427         }
 428 }
 429
 430
 431 void LyXScreen::ToggleSelection(LyXText * text,  bool kill_selection,
 432                                 int y_offset, int x_offset)
 433 {
 434         // only if there is a selection
 435         if (!text->selection) return;
 436
 437         int bottom = min(max(text->sel_end_cursor.y()
 438                               - text->sel_end_cursor.row()->baseline()
 439                               + text->sel_end_cursor.row()->height(), text->first),
 440                           text->first + owner.height());
 441         int top = min(max(text->sel_start_cursor.y()
 442                            - text->sel_start_cursor.row()->baseline(), text->first),
 443                        text->first + owner.height());
 444
 445         if (kill_selection)
 446                 text->selection = 0;
 447         DrawFromTo(text, top - text->first, bottom - text->first,
 448                    y_offset, x_offset);
 449         expose(0, top - text->first,
 450                owner.workWidth(),
 451                bottom - text->first - (top - text->first));
 452 }
 453
 454
 455 void LyXScreen::ToggleToggle(LyXText * text, int y_offset, int x_offset)
 456 {
 457         if (text->toggle_cursor.par() == text->toggle_end_cursor.par()
 458             && text->toggle_cursor.pos() == text->toggle_end_cursor.pos())
 459                 return;
 460
 461         int top = text->toggle_cursor.y()
 462                 - text->toggle_cursor.row()->baseline();
 463         int bottom = text->toggle_end_cursor.y()
 464                 - text->toggle_end_cursor.row()->baseline()
 465                 + text->toggle_end_cursor.row()->height();
 466
 467         typedef unsigned int uint;
 468
 469         bottom = min(max(uint(bottom), text->first), text->first + owner.height());
 470         top = min(max(uint(top), text->first), text->first + owner.height());
 471
 472         DrawFromTo(text, top - text->first, bottom - text->first, y_offset,
 473                    x_offset);
 474         expose(0, top - text->first, owner.workWidth(),
 475                bottom - text->first - (top - text->first));
 476 }