X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fscreen.C;h=66df051f80cfdf48e1d93db51512269a8203a9cd;hb=98c966c64594611e469313314abd1e59524adb4a;hp=d502a10ffd4da68cc44f28ee4ead2a69e6331899;hpb=7c6267e4b10364cc892776e0a426eb32ade6b0b4;p=lyx.git diff --git a/src/screen.C b/src/screen.C index d502a10ffd..66df051f80 100644 --- a/src/screen.C +++ b/src/screen.C @@ -1,8 +1,8 @@ /* This file is part of -* ====================================================== -* +* ====================================================== +* * LyX, The Document Processor -* +* * Copyright 1995 Matthias Ettrich * Copyright 1995-1998 The LyX Team * @@ -14,825 +14,523 @@ #pragma implementation "lyxscreen.h" #endif +#include + #include "lyxscreen.h" -#include "lyxdraw.h" #include "lyxtext.h" +#include "lyxrow.h" +#include "Painter.h" +#include "WorkArea.h" +#include "buffer.h" +#include "BufferView.h" +#include "font.h" +#include "insets/insettext.h" +#include "ColorHandler.h" +#include "language.h" + +using std::max; +using std::min; + +namespace { + +GC createGC() +{ + XGCValues val; + val.foreground = BlackPixel(fl_get_display(), + DefaultScreen(fl_get_display())); + + val.function = GXcopy; + val.graphics_exposures = false; + val.line_style = LineSolid; + val.line_width = 0; + return XCreateGC(fl_get_display(), RootWindow(fl_get_display(), 0), + GCForeground | GCFunction | GCGraphicsExposures + | GCLineWidth | GCLineStyle , &val); +} -extern int mono_video; -extern int fast_selection; +} // namespace anon // Constructor -LyXScreen::LyXScreen(Window window, - Dimension width, - Dimension height, - Dimension offset_x, - Dimension offset_y, - LyXText *text_ptr) - : text(text_ptr), _window(window), - _width(width), _height(height), - _offset_x(offset_x), _offset_y(offset_y) +LyXScreen::LyXScreen(WorkArea & o) + : owner(o), force_clear(true) { - first = 0; - - /* the cursor isnt yet visible */ + // the cursor isnt yet visible cursor_visible = false; - screen_refresh_y = -1; - - /* create the foreground pixmap */ - foreground = XCreatePixmap (fl_display, - fl_root, - _width, _height, - fl_get_visual_depth()); cursor_pixmap = 0; cursor_pixmap_x = 0; cursor_pixmap_y = 0; cursor_pixmap_w = 0; cursor_pixmap_h = 0; + + // We need this GC + gc_copy = createGC(); } -// Destructor LyXScreen::~LyXScreen() { - XFreePixmap(fl_display, foreground); + XFreeGC(fl_get_display(), gc_copy); } -void LyXScreen::Redraw() +void LyXScreen::setCursorColor() { - DrawFromTo(0, _height); - screen_refresh_y = -1; - expose(0, 0, _width, _height); + if (!lyxColorHandler.get()) return; + + GC gc = lyxColorHandler->getGCForeground(LColor::cursor); + + XGCValues val; + XGetGCValues(fl_get_display(), + gc, GCForeground, &val); + XChangeGC(fl_get_display(), gc_copy, GCForeground, &val); +} + + +void LyXScreen::redraw(LyXText * text, BufferView * bv) +{ + drawFromTo(text, bv, 0, owner.height(), 0, 0, text == bv->text); + expose(0, 0, owner.workWidth(), owner.height()); if (cursor_visible) { cursor_visible = false; - ShowCursor(); + bv->showCursor(); } } void LyXScreen::expose(int x, int y, int exp_width, int exp_height) { - XCopyArea(fl_display, - foreground, - _window, - getGC(gc_copy), + XCopyArea(fl_get_display(), + owner.getPixmap(), + owner.getWin(), + gc_copy, x, y, exp_width, exp_height, - x+_offset_x, y+_offset_y); + x + owner.xpos(), + y + owner.ypos()); } -void LyXScreen::DrawFromTo(int y1, int y2) +void LyXScreen::drawFromTo(LyXText * text, BufferView * bv, + int y1, int y2, int y_offset, int x_offset, + bool internal) { - long y_text = first + y1; - - /* get the first needed row */ - Row * row = text->GetRowNearY(y_text); - /* y_text is now the real beginning of the row */ - - long y = y_text - first; - /* y1 is now the real beginning of row on the screen */ - - while (row != 0 && y < y2) { + int y_text = text->first_y + y1; - text->GetVisibleRow(*this, y, row, y + first); - y += row->height; - row = row -> next; + // get the first needed row + Row * row = text->getRowNearY(y_text); + // y_text is now the real beginning of the row + int y = y_text - text->first_y; + // y1 is now the real beginning of row on the screen + + while (row != 0 && y < y2) { + LyXText::text_status st = text->status(); + text->getVisibleRow(bv, y + y_offset, + x_offset, row, y + text->first_y); + internal = internal && (st != LyXText::CHANGED_IN_DRAW); + while (internal && text->status() == LyXText::CHANGED_IN_DRAW) { + if (text->fullRebreak(bv)) { + st = LyXText::NEED_MORE_REFRESH; + text->setCursor(bv, text->cursor.par(), text->cursor.pos()); + } + text->status(bv, st); + text->getVisibleRow(bv, y + y_offset, + x_offset, row, y + text->first_y); + } + y += row->height(); + row = row->next(); } - - /* maybe we have to clear the screen at the bottom */ - if (y < y2) { - fillRectangle(gc_lighted, - 0, - y, - _width, - y2 - y); + force_clear = false; + + // maybe we have to clear the screen at the bottom + if ((y < y2) && text->bv_owner) { + owner.getPainter().fillRectangle(0, y, + owner.workWidth(), + y2 - y, + LColor::bottomarea); } } -void LyXScreen::DrawOneRow(Row * row, long & y_text) +void LyXScreen::drawOneRow(LyXText * text, BufferView * bv, Row * row, + int y_text, int y_offset, int x_offset) { - long y = y_text - first; - - if (y + row->height > 0 && y - row->height <= _height) { - /* ok there is something visible */ - text->GetVisibleRow(*this, y, row, y + first); + int const y = y_text - text->first_y + y_offset; + + if (((y + row->height()) > 0) && + ((y - row->height()) <= static_cast(owner.height()))) { + // ok there is something visible +#if 0 + LyXText::text_status st = bv->text->status(); + do { + bv->text->status(bv, st); + text->getVisibleRow(bv, y, x_offset, row, + y + text->first_y); + } while (!text->inset_owner && + text->status() == LyXText::CHANGED_IN_DRAW); + bv->text->status(bv, st); +#else + text->getVisibleRow(bv, y, x_offset, row, y + text->first_y); +#endif } - y_text+= row->height; + force_clear = false; } /* draws the screen, starting with textposition y. uses as much already -* printed pixels as possible */ -void LyXScreen::Draw(long y) + * printed pixels as possible */ +void LyXScreen::draw(LyXText * text, BufferView * bv, unsigned int y) { - if (cursor_visible) HideCursor(); - - if (y < 0) y = 0; - long old_first = first; - first = y; - - /* is any optimiziation possible? */ - if ((y - old_first) < _height - && (old_first - y) < _height) { - if (first < old_first) { - DrawFromTo(0, old_first - first); - XCopyArea (fl_display, - _window, - _window, - getGC(gc_copy), - _offset_x, _offset_y, - _width , _height - old_first + first, - _offset_x, _offset_y + old_first - first); + if (cursor_visible) hideCursor(); + + int const old_first = text->first_y; + bool internal = (text == bv->text); + text->first_y = y; + + // is any optimiziation possible? + if ((y - old_first) < owner.height() + && (old_first - y) < owner.height()) + { + if (text->first_y < old_first) { + drawFromTo(text, bv, 0, + old_first - text->first_y, 0, 0, internal); + XCopyArea (fl_get_display(), + owner.getWin(), + owner.getWin(), + gc_copy, + owner.xpos(), + owner.ypos(), + owner.workWidth(), + owner.height() - old_first + text->first_y, + owner.xpos(), + owner.ypos() + old_first - text->first_y + ); // expose the area drawn - expose(0, 0, _width, old_first - first); + expose(0, 0, + owner.workWidth(), + old_first - text->first_y); } else { - DrawFromTo(_height + old_first - first, _height); - XCopyArea (fl_display, - _window, - _window, - getGC(gc_copy), - _offset_x, _offset_y + first - old_first, - _width , _height + old_first - first, - _offset_x, _offset_y); + drawFromTo(text, bv, + owner.height() + old_first - text->first_y, + owner.height(), 0, 0, internal); + XCopyArea (fl_get_display(), + owner.getWin(), + owner.getWin(), + gc_copy, + owner.xpos(), + owner.ypos() + text->first_y - old_first, + owner.workWidth(), + owner.height() + old_first - text->first_y, + owner.xpos(), + owner.ypos()); // expose the area drawn - expose(0, _height + old_first - first, - _width, first - old_first); + expose(0, owner.height() + old_first - text->first_y, + owner.workWidth(), text->first_y - old_first); } } else { - /* make a dumb new-draw */ - DrawFromTo(0, _height); - expose(0, 0, _width, _height); + // make a dumb new-draw + drawFromTo(text, bv, 0, owner.height(), 0, 0, internal); + expose(0, 0, owner.workWidth(), owner.height()); } } -void LyXScreen::ShowCursor() +void LyXScreen::showCursor(LyXText const * text, BufferView const * bv) { - long x = 0; - long y1 = 0; - long y2 = 0; - - if (cursor_visible) return; - - x = text->cursor.x; - - y1 = text->cursor.y - text->real_current_font.maxAscent() - first; - if (y1 < 0) y1 = 0; - - y2 = text->cursor.y + text->real_current_font.maxDescent() - first; - if (y2 > _height) y2 = _height; - - // Secure against very strange situations - if (y2 < y1) y2 = y1; - - if (fast_selection || mono_video) { - if (y2 > 0 && y1 < _height) { - XDrawLine(fl_display, - _window, getGC(gc_select), - x + _offset_x, - y1 + _offset_y, - x + _offset_x, - y2 + _offset_y); - cursor_visible = true; - } - } else { - if (cursor_pixmap){ - XFreePixmap(fl_display, cursor_pixmap); - cursor_pixmap = 0; - } - - if (y2 > 0 && y1 < _height) { - cursor_pixmap_w = 1; - cursor_pixmap_h = y2 - y1 + 1; - cursor_pixmap_x = x; - cursor_pixmap_y = y1; - cursor_pixmap = - XCreatePixmap(fl_display, - fl_root, - cursor_pixmap_w, - cursor_pixmap_h, - fl_get_visual_depth()); - XCopyArea(fl_display, - _window, - cursor_pixmap, - getGC(gc_copy), - _offset_x + cursor_pixmap_x, - _offset_y + cursor_pixmap_y, - cursor_pixmap_w, cursor_pixmap_h, - 0, 0); - XDrawLine(fl_display, - _window, getGC(gc_copy), - x + _offset_x, - y1 + _offset_y, - x + _offset_x, - y2 + _offset_y); - cursor_visible = true; - } + if (!cursor_visible) { + Cursor_Shape shape = BAR_SHAPE; + if (text->real_current_font.language() != + bv->buffer()->params.language + || text->real_current_font.isVisibleRightToLeft() + != bv->buffer()->params.language->RightToLeft()) + shape = (text->real_current_font.isVisibleRightToLeft()) + ? REVERSED_L_SHAPE : L_SHAPE; + showManualCursor(text, text->cursor.x(), text->cursor.y(), + lyxfont::maxAscent(text->real_current_font), + lyxfont::maxDescent(text->real_current_font), + shape); } } -/* returns 1 if first has changed, otherwise 0 */ -int LyXScreen::FitManualCursor(long /*x*/, long y, int asc, int desc) +/* returns true if first has changed, otherwise false */ +bool LyXScreen::fitManualCursor(LyXText * text, BufferView * bv, + int /*x*/, int y, int asc, int desc) { - long newtop = first; - - if (y + desc - first >= _height) - newtop = y - 3*_height / 4; /* the scroll region must be so big!! */ - else if (y - asc < first - && first > 0) { - newtop = y - _height / 4; + int newtop = text->first_y; + + if (y + desc - text->first_y >= static_cast(owner.height())) + newtop = y - 3 * owner.height() / 4; // the scroll region must be so big!! + else if (y - asc < text->first_y + && text->first_y > 0) { + newtop = y - owner.height() / 4; } - if (newtop < 0) - newtop = 0; - - if (newtop != first){ - Draw(newtop); - first = newtop; - return 1; + + newtop = max(newtop, 0); // can newtop ever be < 0? (Lgb) + + if (newtop != text->first_y) { + draw(text, bv, newtop); + text->first_y = newtop; + return true; } - return 0; + return false; } -void LyXScreen::HideManualCursor(long x, long y, int asc, int desc) +void LyXScreen::showManualCursor(LyXText const * text, int x, int y, + int asc, int desc, Cursor_Shape shape) { - if (fast_selection || mono_video) - ShowManualCursor(x, y, asc, desc); - else - HideCursor(); -} + // Update the cursor color. + setCursorColor(); + int const y1 = max(y - text->first_y - asc, 0); + int const y_tmp = min(y - text->first_y + desc, + static_cast(owner.height())); -void LyXScreen::ShowManualCursor(long x, long y, int asc, int desc) -{ - long y1 = 0; - long y2 = 0; - - y1 = y - first - asc; - if (y1 < 0) - y1 = 0; - y2 = y -first + desc; - if (y2 > _height) - y2 = _height; - - if (fast_selection || mono_video){ - if (y2 > 0 && y1 < _height) { - XDrawLine(fl_display, - _window, getGC(gc_select), - x+_offset_x, - y1+_offset_y, - x+_offset_x, - y2+_offset_y); - } - } else { - if (cursor_pixmap){ - XFreePixmap(fl_display, cursor_pixmap); - cursor_pixmap = 0; - } - - if (y2 > 0 && y1 < _height) { + // Secure against very strange situations + int const y2 = max(y_tmp, y1); + + if (cursor_pixmap) { + XFreePixmap(fl_get_display(), cursor_pixmap); + cursor_pixmap = 0; + } + + if (y2 > 0 && y1 < int(owner.height())) { + cursor_pixmap_h = y2 - y1 + 1; + cursor_pixmap_y = y1; + + switch (shape) { + case BAR_SHAPE: cursor_pixmap_w = 1; - cursor_pixmap_h = y2 - y1 + 1; - cursor_pixmap_x = x, - cursor_pixmap_y = y1; - cursor_pixmap = - XCreatePixmap (fl_display, - fl_root, - cursor_pixmap_w, - cursor_pixmap_h, - fl_get_visual_depth()); - - XCopyArea (fl_display, - _window, - cursor_pixmap, - getGC(gc_copy), - _offset_x + cursor_pixmap_x, - _offset_y + cursor_pixmap_y, - cursor_pixmap_w, - cursor_pixmap_h, - 0, 0); - XDrawLine(fl_display, - _window, getGC(gc_copy), - x+_offset_x, - y1+_offset_y, - x+_offset_x, - y2+_offset_y); + cursor_pixmap_x = x; + break; + case L_SHAPE: + cursor_pixmap_w = cursor_pixmap_h/3; + cursor_pixmap_x = x; + break; + case REVERSED_L_SHAPE: + cursor_pixmap_w = cursor_pixmap_h/3; + cursor_pixmap_x = x - cursor_pixmap_w + 1; + break; + } + + cursor_pixmap = + XCreatePixmap (fl_get_display(), + fl_root, + cursor_pixmap_w, + cursor_pixmap_h, + fl_get_visual_depth()); + XCopyArea (fl_get_display(), + owner.getWin(), + cursor_pixmap, + gc_copy, + owner.xpos() + cursor_pixmap_x, + owner.ypos() + cursor_pixmap_y, + cursor_pixmap_w, + cursor_pixmap_h, + 0, 0); + XDrawLine(fl_get_display(), + owner.getWin(), + gc_copy, + x + owner.xpos(), + y1 + owner.ypos(), + x + owner.xpos(), + y2 + owner.ypos()); + switch (shape) { + case BAR_SHAPE: + break; + case L_SHAPE: + case REVERSED_L_SHAPE: + int const rectangle_h = (cursor_pixmap_h + 10) / 20; + XFillRectangle(fl_get_display(), + owner.getWin(), + gc_copy, + cursor_pixmap_x + owner.xpos(), + y2 - rectangle_h + 1 + owner.ypos(), + cursor_pixmap_w - 1, rectangle_h); + break; } - cursor_visible = true; + } + cursor_visible = true; } -void LyXScreen::HideCursor() +void LyXScreen::hideCursor() { if (!cursor_visible) return; - - if (fast_selection || mono_video){ - cursor_visible = false; - ShowCursor(); - cursor_visible = false; - } else { - if (cursor_pixmap){ - XCopyArea (fl_display, - cursor_pixmap, - _window, - getGC(gc_copy), - 0, 0, - cursor_pixmap_w, cursor_pixmap_h, - cursor_pixmap_x + _offset_x, - cursor_pixmap_y + _offset_y); - } - cursor_visible = false; + + if (cursor_pixmap) { + XCopyArea (fl_get_display(), + cursor_pixmap, + owner.getWin(), + gc_copy, + 0, 0, + cursor_pixmap_w, cursor_pixmap_h, + cursor_pixmap_x + owner.xpos(), + cursor_pixmap_y + owner.ypos()); } + cursor_visible = false; } -void LyXScreen::CursorToggle() +void LyXScreen::cursorToggle(BufferView * bv) const { if (cursor_visible) - HideCursor(); + bv->hideCursor(); else - ShowCursor(); + bv->showCursor(); } -/* returns a new top so that the cursor is visible */ -long LyXScreen::TopCursorVisible() +/* returns a new top so that the cursor is visible */ +unsigned int LyXScreen::topCursorVisible(LyXText const * text) { - long newtop = first; - - if (text->cursor.y - - text->cursor.row->baseline - + text->cursor.row->height - - first >= _height) { - if (text->cursor.row->height < _height - && text->cursor.row->height > _height/4) - newtop = text->cursor.y - + text->cursor.row->height - - text->cursor.row->baseline - _height; - else - newtop = text->cursor.y - - 3*_height / 4; /* the scroll region must be so big!! */ - } else if (text->cursor.y - text->cursor.row->baseline < first - && first > 0) { - if (text->cursor.row->height < _height - && text->cursor.row->height > _height/4) - newtop = text->cursor.y - text->cursor.row->baseline; - else { - newtop = text->cursor.y - _height / 4; - if (newtop > first) - newtop = first; + int newtop = text->first_y; + + Row * row = text->cursor.row(); + + // Is this a hack? Yes, probably... (Lgb) + if (!row) + return max(newtop, 0); + + if (text->cursor.y() - row->baseline() + row->height() + - text->first_y >= owner.height()) { + if (row->height() < owner.height() + && row->height() > owner.height() / 4) { + newtop = text->cursor.y() + + row->height() + - row->baseline() - owner.height(); + } else { + // scroll down + newtop = text->cursor.y() + - owner.height() / 2; /* the scroll region must be so big!! */ + } + + } else if (static_cast((text->cursor.y()) - row->baseline()) < + text->first_y && text->first_y > 0) { + if (row->height() < owner.height() + && row->height() > owner.height() / 4) { + newtop = text->cursor.y() - row->baseline(); + } else { + // scroll up + newtop = text->cursor.y() - owner.height() / 2; + newtop = min(newtop, text->first_y); } } - if (newtop < 0) - newtop = 0; - + + newtop = max(newtop, 0); + return newtop; } /* scrolls the screen so that the cursor is visible, if necessary. -* returns 1 if a change was made, otherwise 0 */ -int LyXScreen::FitCursor() +* returns true if a change was made, otherwise false */ +bool LyXScreen::fitCursor(LyXText * text, BufferView * bv) { - /* is a change necessary */ - long newtop = TopCursorVisible(); - int result = (newtop != first); + // Is a change necessary? + int const newtop = topCursorVisible(text); + bool const result = (newtop != text->first_y); if (result) - Draw(newtop); + draw(text, bv, newtop); return result; } - -void LyXScreen::Update() -{ - long y = 0; - - if (text->status == LyXText::NEED_MORE_REFRESH - || screen_refresh_y > -1 ) { - if (screen_refresh_y > -1 - && screen_refresh_y < text->refresh_y) - y = screen_refresh_y; - else - y = text->refresh_y; - - if (y < first) y = first; - - DrawFromTo(y - first, _height); - text->refresh_y = 0; - text->status = LyXText::UNCHANGED; - screen_refresh_y = -1; - expose(0, y-first, _width, _height - (y - first)); - } else if (text->status == LyXText::NEED_VERY_LITTLE_REFRESH) { - /* ok I will update the current cursor row */ - y = text->refresh_y; - DrawOneRow(text->refresh_row, y); - text->status = LyXText::UNCHANGED; - expose(0, text->refresh_y-first, - _width, text->refresh_row->height); - } -} - -void LyXScreen::SmallUpdate() +void LyXScreen::update(LyXText * text, BufferView * bv, + int y_offset, int x_offset) { - Row * row = 0; - long y = 0; - long y2 = 0; - - if (text->status == LyXText::NEED_MORE_REFRESH){ - /* ok I will update till the current cursor row */ - row = text->refresh_row; - y = text->refresh_y; - y2 = y; - - if (y > text->cursor.y) { - Update(); - return; - } - - while (row && row != text->cursor.row && y < first + _height) { - DrawOneRow(row, y); - row = row->next; - } - - DrawOneRow(row, y); - screen_refresh_y = y; - screen_refresh_row = row->next; - text->status = LyXText::UNCHANGED; - // Is the right regin exposed? - expose(0, y2-first, _width, y-y2); - } else if (text->status == LyXText::NEED_VERY_LITTLE_REFRESH) { - /* ok I will update the current cursor row */ - row = text->refresh_row; - y = text->refresh_y; - DrawOneRow(row, y); - text->status = LyXText::UNCHANGED; - expose(0, text->refresh_y - first, - _width, row->height); + switch (text->status()) { + case LyXText::NEED_MORE_REFRESH: + { + int const y = max(int(text->refresh_y - text->first_y), 0); + drawFromTo(text, bv, y, owner.height(), y_offset, x_offset); + text->refresh_y = 0; + // otherwise this is called ONLY from BufferView_pimpl(update) + // or we should see to set this flag accordingly + if (text != bv->text) + text->status(bv, LyXText::UNCHANGED); + expose(0, y, owner.workWidth(), owner.height() - y); } -} - - -void LyXScreen::ToggleSelection(bool kill_selection) -{ - /* only if there is a selection */ - if (!text->selection) - return; - - long top = 0; - long bottom = 0; - - - if (fast_selection || mono_video){ - - /* selection only in one row ?*/ - if (text->sel_start_cursor.y == text->sel_end_cursor.y) { - - /* only if something is visible */ - if (text->sel_start_cursor.y - - text->sel_start_cursor.row->baseline - - first < _height - && text->sel_start_cursor.y - - text->sel_start_cursor.row->baseline + - text->sel_start_cursor.row->height - first > 0) { - top = text->sel_start_cursor.y - - text->sel_start_cursor.row->baseline - - first; - bottom = top - + text->sel_start_cursor.row->height; - if (top<0) - top = 0; - if (bottom > _height) - bottom = _height; - XFillRectangle(fl_display, _window, - getGC(gc_select), - text->sel_start_cursor.x - +_offset_x, - top+_offset_y, - text->sel_end_cursor.x - - text->sel_start_cursor.x, - bottom - top); - } - } else { - /* the sel_start_cursor row first */ - /* only if anything is visible */ - if (text->sel_start_cursor.y - - text->sel_start_cursor.row->baseline - - first < _height - && text->sel_start_cursor.y - - text->sel_start_cursor.row->baseline + - text->sel_start_cursor.row->height - first > 0) { - top = text->sel_start_cursor.y - - text->sel_start_cursor.row->baseline - - first; - bottom = top - + text->sel_start_cursor.row->height; - if (top<0) - top = 0; - if (bottom > _height) - bottom = _height; - XFillRectangle(fl_display, _window, - getGC(gc_select), - text->sel_start_cursor.x - +_offset_x, - top+_offset_y, - _width - - text->sel_start_cursor.x, - bottom - top); - } - - /* the main body */ - - if (text->sel_start_cursor.row->next != - text->sel_end_cursor.row) { - top = text->sel_start_cursor.y - - text->sel_start_cursor.row->baseline - + text->sel_start_cursor.row->height; - bottom = text->sel_end_cursor.y - - text->sel_end_cursor.row->baseline; - - if (top - first < 0) - top = first; - if (bottom - first < 0) - bottom = first; - - if (bottom - first > _height) - bottom = first + _height; - if (top - first > _height) - top = first + _height; - - if (top != bottom) { - XFillRectangle(fl_display, - _window, - getGC(gc_select), - 0+_offset_x, - top - first+_offset_y, - _width, - bottom - top); - } - } - - /* the sel_end_cursor row last */ - if (text->sel_end_cursor.y - - text->sel_end_cursor.row->baseline - - first < _height - && text->sel_end_cursor.y - - text->sel_end_cursor.row->baseline + - text->sel_end_cursor.row->height - first > 0) { - top = text->sel_end_cursor.y - - text->sel_end_cursor.row->baseline - - first; - bottom = top - + text->sel_end_cursor.row->height; - if (top<0) - top = 0; - if (bottom > _height) - bottom = _height; - XFillRectangle(fl_display, _window, - getGC(gc_select), - 0+_offset_x, - top+_offset_y, - text->sel_end_cursor.x, - bottom - top); - } + break; + case LyXText::NEED_VERY_LITTLE_REFRESH: + { + // ok I will update the current cursor row + drawOneRow(text, bv, text->refresh_row, text->refresh_y, + y_offset, x_offset); + // this because if we had a major update the refresh_row could + // have been set to 0! + if (text->refresh_row) { + // otherwise this is called ONLY from BufferView_pimpl(update) + // or we should see to set this flag accordingly + if (text != bv->text) + text->status(bv, LyXText::UNCHANGED); + expose(0, text->refresh_y - text->first_y + y_offset, + owner.workWidth(), text->refresh_row->height()); } - } else { - top = text->sel_start_cursor.y - - text->sel_start_cursor.row->baseline; - bottom = text->sel_end_cursor.y - - text->sel_end_cursor.row->baseline - + text->sel_end_cursor.row->height; - - if (top - first < 0) - top = first; - if (bottom - first < 0) - bottom = first; - - if (bottom - first > _height) - bottom = first + _height; - if (top - first > _height) - top = first + _height; - - if (kill_selection) - text->selection = 0; - DrawFromTo(top - first, bottom - first); - expose(0, top - first, _width, bottom - first - (top - first)); } -} - - -void LyXScreen::ToggleToggle() -{ - long top = 0; - long bottom = 0; - - if (text->toggle_cursor.par == text->toggle_end_cursor.par - && text->toggle_cursor.pos == text->toggle_end_cursor.pos) - return; - - if (fast_selection || mono_video) { - - /* selection only in one row ?*/ - if (text->toggle_cursor.y == text->toggle_end_cursor.y) { - - /* only if anything is visible */ - if (text->toggle_cursor.y - text->toggle_cursor.row->baseline - first < _height - && text->toggle_cursor.y - text->toggle_cursor.row->baseline + - text->toggle_cursor.row->height - first > 0) { - top = text->toggle_cursor.y - text->toggle_cursor.row->baseline - first; - bottom = top + text->toggle_cursor.row->height; - if (top < 0) top = 0; - if (bottom > _height) bottom = _height; - XFillRectangle(fl_display, _window, - getGC(gc_select), - text->toggle_cursor.x+_offset_x, - top+_offset_y, - text->toggle_end_cursor.x - - text->toggle_cursor.x, - bottom - top); - } - } else { - /* the toggle_cursor row first */ - /* only if anything is visible */ - if (text->toggle_cursor.y - text->toggle_cursor.row->baseline - first < _height - && text->toggle_cursor.y - text->toggle_cursor.row->baseline + - text->toggle_cursor.row->height - first > 0) { - top = text->toggle_cursor.y - text->toggle_cursor.row->baseline - first; - bottom = top + text->toggle_cursor.row->height; - if (top<0) - top = 0; - if (bottom > _height) - bottom = _height; - XFillRectangle(fl_display, _window, - getGC(gc_select), - text->toggle_cursor.x+_offset_x, - top+_offset_y, - _width - text->toggle_cursor.x, - bottom - top); - } - - /* the main body */ - - if (text->toggle_cursor.row->next != - text->toggle_end_cursor.row) { - top = text->toggle_cursor.y - - text->toggle_cursor.row->baseline - + text->toggle_cursor.row->height; - bottom = text->toggle_end_cursor.y - - text->toggle_end_cursor.row->baseline; - - if (top - first < 0) - top = first; - if (bottom - first < 0) - bottom = first; - - if (bottom - first > _height) - bottom = first + _height; - if (top - first > _height) - top = first + _height; - - if (top != bottom) { - XFillRectangle(fl_display, _window, - getGC(gc_select), - 0+_offset_x, - top - first+_offset_y, - _width, - bottom - top); - } - } - - /* the toggle_end_cursor row last */ - if (text->toggle_end_cursor.y - text->toggle_end_cursor.row->baseline - first < _height - && text->toggle_end_cursor.y - text->toggle_end_cursor.row->baseline + - text->toggle_end_cursor.row->height - first > 0) { - top = text->toggle_end_cursor.y - - text->toggle_end_cursor.row->baseline - - first; - bottom = top - + text->toggle_end_cursor.row->height; - if (top<0) - top = 0; - if (bottom > _height) - bottom = _height; - XFillRectangle(fl_display, _window, - getGC(gc_select), - 0+_offset_x, - top+_offset_y, - text->toggle_end_cursor.x, - bottom - top); - } - } - } else { - top = text->toggle_cursor.y - - text->toggle_cursor.row->baseline; - bottom = text->toggle_end_cursor.y - - text->toggle_end_cursor.row->baseline - + text->toggle_end_cursor.row->height; - - if (top - first < 0) - top = first; - if (bottom - first < 0) - bottom = first; - - if (bottom - first > _height) - bottom = first + _height; - if (top - first > _height) - top = first + _height; - - DrawFromTo(top - first, bottom - first); - expose(0, top - first, _width, bottom - first - (top - first)); + break; + case LyXText::CHANGED_IN_DRAW: // just to remove the warning + case LyXText::UNCHANGED: + // Nothing needs done + break; } } - -void LyXScreen::drawTableLine(int baseline, int x, int length, bool on_off) -{ - GC gc; - if (on_off) - gc = getGC(gc_thin_on_off_line); - else - gc = getGC(gc_copy); - drawLine(gc, - x, - baseline, - x + length, - baseline); -} - - -void LyXScreen::drawVerticalTableLine(int x, int y1, int y2, bool on_off) +void LyXScreen::toggleSelection(LyXText * text, BufferView * bv, + bool kill_selection, + int y_offset, int x_offset) { - GC gc; - if (on_off) - gc = getGC(gc_thin_on_off_line); - else - gc = getGC(gc_copy); - drawLine(gc, - x, - y1, - x, - y2); + // only if there is a selection + if (!text->selection.set()) return; + + int const bottom = min( + max(static_cast(text->selection.end.y() + - text->selection.end.row()->baseline() + + text->selection.end.row()->height()), + text->first_y), + static_cast(text->first_y + owner.height())); + int const top = min( + max(static_cast(text->selection.start.y() - + text->selection.start.row()->baseline()), + text->first_y), + static_cast(text->first_y + owner.height())); + + if (kill_selection) + text->selection.set(false); + drawFromTo(text, bv, top - text->first_y, bottom - text->first_y, + y_offset, x_offset); + expose(0, top - text->first_y, + owner.workWidth(), + bottom - text->first_y - (top - text->first_y)); } -void LyXScreen::drawFrame(int /*ft*/, int x, int y, int w, int h, - FL_COLOR /*col*/, int /*b*/) +void LyXScreen::toggleToggle(LyXText * text, BufferView * bv, + int y_offset, int x_offset) { -// Implement this using X11 calls, and the repaint problems are gone! -// At least, I think that should do it since we only have them after -// one of these buttons are displayed now! Lars, it seems you've hit the -// nail :-) (Asger) -// fl_winset(foreground); -// fl_drw_frame(ft, x, y, w, h, col, b); - // This should be changed to draw a button like frame, in the - // mean time we'll just use a regular rectangle - - // I want the buttons back before 0.12. OK, this is very simple, - // like what is done in xforms sources. (Ale) - - // This one is too dirty. Get rid of it. - extern GC fl_gc; - - // Please comment this annonymous variable. - int d = 2; - - // I think these calls to fl_color might make xforms sometimes - // draw the wrong color on other objects. - fl_color(FL_TOP_BCOL); - XFillRectangle(fl_display, foreground, fl_gc, - x - d, y - d, w + 2 * d, d); - fl_color(FL_BOTTOM_BCOL); - XFillRectangle(fl_display, foreground, fl_gc, - x - d, y + h, w + 2 * d, d); - - // Now a couple of trapezoids - XPoint pl[4], pr[4]; - - pl[0].x = x - d; pl[0].y = y - d; - pl[1].x = x - d; pl[1].y = y + h + d; - pl[2].x = x; pl[2].y = y + h; - pl[3].x = x; pl[3].y = y; - - pr[0].x = x + w + d; pr[0].y = y - d; - pr[1].x = x + w + d; pr[1].y = y + h + d; - pr[2].x = x + w; pr[2].y = y + h; - pr[3].x = x + w; pr[3].y = y; + if (text->toggle_cursor.par() == text->toggle_end_cursor.par() + && text->toggle_cursor.pos() == text->toggle_end_cursor.pos()) + return; + + int const top_tmp = text->toggle_cursor.y() + - text->toggle_cursor.row()->baseline(); + int const bottom_tmp = text->toggle_end_cursor.y() + - text->toggle_end_cursor.row()->baseline() + + text->toggle_end_cursor.row()->height(); + + int const offset = y_offset < 0 ? y_offset : 0; + int const bottom = min(max(bottom_tmp, text->first_y), + static_cast(text->first_y + owner.height()))-offset; + int const top = min(max(top_tmp, text->first_y), + static_cast(text->first_y + owner.height()))-offset; - fl_color(FL_LEFT_BCOL); - XFillPolygon(fl_display, - foreground, - fl_gc, pl, 4, - Convex, CoordModeOrigin); - fl_color(FL_RIGHT_BCOL); - XFillPolygon(fl_display, - foreground, - fl_gc, pr, 4, - Convex, CoordModeOrigin); + drawFromTo(text, bv, top - text->first_y, + bottom - text->first_y, y_offset, + x_offset); + expose(0, top - text->first_y, owner.workWidth(), + bottom - text->first_y - (top - text->first_y)); }