From 1136642d8a56dfad298906ba0f2b389722736c5d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20Gullik=20Bj=C3=B8nnes?= Date: Sun, 9 Apr 2000 22:48:51 +0000 Subject: [PATCH] more changes to bufferview, fix cursorpositioning, correct color on insetinfos git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@642 a592a061-630c-0410-9148-cb99ea01b6c8 --- ChangeLog | 11 + src/BufferView.C | 623 ++-------------------------- src/BufferView.h | 2 - src/BufferView_pimpl.C | 738 +++++++++++++++++++++++++++++++++- src/BufferView_pimpl.h | 71 +++- src/insets/inset.C | 2 +- src/insets/insetcollapsable.C | 6 +- src/insets/insetinfo.C | 10 +- src/insets/insettext.C | 21 +- src/text2.C | 15 +- 10 files changed, 874 insertions(+), 625 deletions(-) diff --git a/ChangeLog b/ChangeLog index ee83cf13ea..b22425a6de 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,14 @@ +2000-04-10 Lars Gullik Bjønnes + + * src/BufferView.[Ch], src/BufferView_pimpl.[Ch]: move more + functions from BufferView to BufferView::Pimpl to ease maintence. + + * src/text2.C (DeleteEmptyParagraphMechanism): update the cursor + correctly. Also use SetCursorIntern instead of SetCursor. + + * src/insets/insetinfo.C (draw): draw InsetInfo notes with the + correct color. + 2000-04-08 Lars Gullik Bjønnes * src/WorkArea.C (belowMouse): manually implement below mouse. diff --git a/src/BufferView.C b/src/BufferView.C index 35a33f5787..148c7bbd44 100644 --- a/src/BufferView.C +++ b/src/BufferView.C @@ -11,61 +11,14 @@ #include -#include - -#include -#include - -#include -#include - -#include "support/lstrings.h" - #ifdef __GNUG__ #pragma implementation #endif -#include "commandtags.h" #include "BufferView.h" -#include "bufferlist.h" -#include "LyXView.h" -#include "lyxfunc.h" -#include "insets/lyxinset.h" -#include "insets/insetbib.h" -#include "minibuffer.h" -#include "lyxscreen.h" -#include "menus.h" - -#include "debug.h" -#include "lyx_gui_misc.h" -#include "BackStack.h" -#include "lyxtext.h" -#include "lyx_cb.h" -#include "gettext.h" -#include "layout.h" -#include "TextCache.h" -#include "intl.h" -#include "lyxrc.h" -#include "lyxrow.h" -#include "WorkArea.h" -#include "font.h" #include "BufferView_pimpl.h" +#include "lyxtext.h" -using std::pair; -using std::for_each; -using std::find_if; -using std::endl; - -extern BufferList bufferlist; - -void sigchldhandler(pid_t pid, int * status); - -extern void SetXtermCursor(Window win); -extern bool input_prohibited; -extern bool selection_possible; -extern char ascii_type; -extern void MenuPasteSelection(char at); -extern void FreeUpdateTimer(); BufferView::BufferView(LyXView * o, int xpos, int ypos, int width, int height) @@ -104,296 +57,67 @@ void BufferView::pushIntoUpdateList(Inset * i) Painter & BufferView::painter() { - return pimpl_->workarea->getPainter(); + return pimpl_->painter(); } void BufferView::buffer(Buffer * b) { - lyxerr[Debug::INFO] << "Setting buffer in BufferView (" - << b << ")" << endl; - if (pimpl_->buffer_) { - insetSleep(); - pimpl_->buffer_->delUser(this); - - // Put the old text into the TextCache, but - // only if the buffer is still loaded. - // Also set the owner of the test to 0 - text->owner(0); - textcache.add(text); - if (lyxerr.debugging()) - textcache.show(lyxerr, "BufferView::buffer"); - - text = 0; - } - - // Set current buffer - pimpl_->buffer_ = b; - - if (bufferlist.getState() == BufferList::CLOSING) return; - - // Nuke old image - // screen is always deleted when the buffer is changed. - delete pimpl_->screen; - pimpl_->screen = 0; - - // If we are closing the buffer, use the first buffer as current - if (!pimpl_->buffer_) { - pimpl_->buffer_ = bufferlist.first(); - } - - if (pimpl_->buffer_) { - lyxerr[Debug::INFO] << "Buffer addr: " << pimpl_->buffer_ << endl; - pimpl_->buffer_->addUser(this); - pimpl_->owner_->getMenus()->showMenus(); - // If we don't have a text object for this, we make one - if (text == 0) - resizeCurrentBuffer(); - else { - pimpl_->updateScreen(); - updateScrollbar(); - } - pimpl_->screen->first = pimpl_->screen->TopCursorVisible(); - redraw(); - updateAllVisibleBufferRelatedPopups(); - insetWakeup(); - } else { - lyxerr[Debug::INFO] << " No Buffer!" << endl; - pimpl_->owner_->getMenus()->hideMenus(); - updateScrollbar(); - pimpl_->workarea->redraw(); - - // Also remove all remaining text's from the testcache. - // (there should not be any!) (if there is any it is a - // bug!) - if (lyxerr.debugging()) - textcache.show(lyxerr, "buffer delete all"); - textcache.clear(); - } - // should update layoutchoice even if we don't have a buffer. - pimpl_->owner_->updateLayoutChoice(); - pimpl_->owner_->getMiniBuffer()->Init(); - pimpl_->owner_->updateWindowTitle(); + pimpl_->buffer(b); } void BufferView::resize(int xpos, int ypos, int width, int height) { - pimpl_->workarea->resize(xpos, ypos, width, height); - update(3); - redraw(); + pimpl_->resize(xpos, ypos, width, height); } void BufferView::resize() { - // This will resize the buffer. (Asger) - if (pimpl_->buffer_) - resizeCurrentBuffer(); + pimpl_->resize(); } void BufferView::redraw() { - lyxerr[Debug::INFO] << "BufferView::redraw()" << endl; - pimpl_->workarea->redraw(); + pimpl_->redraw(); } void BufferView::fitCursor() { - if (pimpl_->screen) pimpl_->screen->FitCursor(); - updateScrollbar(); + pimpl_->fitCursor(); } void BufferView::update() { - if (pimpl_->screen) pimpl_->screen->Update(); + pimpl_->update(); } void BufferView::updateScrollbar() { - /* If the text is smaller than the working area, the scrollbar - * maximum must be the working area height. No scrolling will - * be possible */ - - if (!pimpl_->buffer_) { - pimpl_->workarea->setScrollbar(0, 1.0); - return; - } - - static long max2 = 0; - static long height2 = 0; - - long cbth = 0; - long cbsf = 0; - - if (text) - cbth = text->height; - if (pimpl_->screen) - cbsf = pimpl_->screen->first; - - // check if anything has changed. - if (max2 == cbth && - height2 == pimpl_->workarea->height() && - pimpl_->current_scrollbar_value == cbsf) - return; // no - max2 = cbth; - height2 = pimpl_->workarea->height(); - pimpl_->current_scrollbar_value = cbsf; - - if (cbth <= height2) { // text is smaller than screen - pimpl_->workarea->setScrollbar(0, 1.0); // right? - return; - } - - long maximum_height = pimpl_->workarea->height() * 3 / 4 + cbth; - long value = cbsf; - - // set the scrollbar - double hfloat = pimpl_->workarea->height(); - double maxfloat = maximum_height; - - float slider_size = 0.0; - int slider_value = value; - - pimpl_->workarea->setScrollbarBounds(0, text->height - pimpl_->workarea->height()); - double lineh = text->DefaultHeight(); - pimpl_->workarea->setScrollbarIncrements(lineh); - if (maxfloat > 0.0) { - if ((hfloat / maxfloat) * float(height2) < 3) - slider_size = 3.0/float(height2); - else - slider_size = hfloat / maxfloat; - } else - slider_size = hfloat; - - pimpl_->workarea->setScrollbar(slider_value, slider_size / pimpl_->workarea->height()); + pimpl_->updateScrollbar(); } void BufferView::redoCurrentBuffer() { - lyxerr[Debug::INFO] << "BufferView::redoCurrentBuffer" << endl; - if (pimpl_->buffer_ && text) { - resize(); - pimpl_->owner_->updateLayoutChoice(); - } + pimpl_->redoCurrentBuffer(); } int BufferView::resizeCurrentBuffer() { - lyxerr[Debug::INFO] << "resizeCurrentBuffer" << endl; - - LyXParagraph * par = 0; - LyXParagraph * selstartpar = 0; - LyXParagraph * selendpar = 0; - int pos = 0; - int selstartpos = 0; - int selendpos = 0; - int selection = 0; - int mark_set = 0; - - ProhibitInput(); - - pimpl_->owner_->getMiniBuffer()->Set(_("Formatting document...")); - - if (text) { - par = text->cursor.par; - pos = text->cursor.pos; - selstartpar = text->sel_start_cursor.par; - selstartpos = text->sel_start_cursor.pos; - selendpar = text->sel_end_cursor.par; - selendpos = text->sel_end_cursor.pos; - selection = text->selection; - mark_set = text->mark_set; - delete text; - text = new LyXText(this, pimpl_->workarea->workWidth(), pimpl_->buffer_); - } else { - // See if we have a text in TextCache that fits - // the new buffer_ with the correct width. - text = textcache.findFit(pimpl_->buffer_, pimpl_->workarea->workWidth()); - if (text) { - if (lyxerr.debugging()) { - lyxerr << "Found a LyXText that fits:\n"; - textcache.show(lyxerr, text); - } - // Set the owner of the newly found text - text->owner(this); - if (lyxerr.debugging()) - textcache.show(lyxerr, "resizeCurrentBuffer"); - } else { - text = new LyXText(this, pimpl_->workarea->workWidth(), pimpl_->buffer_); - } - } - pimpl_->updateScreen(); - - if (par) { - text->selection = true; - /* at this point just to avoid the Delete-Empty-Paragraph - * Mechanism when setting the cursor */ - text->mark_set = mark_set; - if (selection) { - text->SetCursor(selstartpar, selstartpos); - text->sel_cursor = text->cursor; - text->SetCursor(selendpar, selendpos); - text->SetSelection(); - text->SetCursor(par, pos); - } else { - text->SetCursor(par, pos); - text->sel_cursor = text->cursor; - text->selection = false; - } - } - pimpl_->screen->first = pimpl_->screen->TopCursorVisible(); /* this will scroll the - * screen such that the - * cursor becomes - * visible */ - updateScrollbar(); - redraw(); - pimpl_->owner_->getMiniBuffer()->Init(); - setState(); - AllowInput(); - - // Now if the title form still exist kill it - TimerCB(0, 0); - - return 0; + return pimpl_->resizeCurrentBuffer(); } void BufferView::gotoError() { - if (!pimpl_->screen) - return; - - pimpl_->screen->HideCursor(); - beforeChange(); - update(-2); - LyXCursor tmp; - - if (!text->GotoNextError()) { - if (text->cursor.pos - || text->cursor.par != text->FirstParagraph()) { - tmp = text->cursor; - text->cursor.par = text->FirstParagraph(); - text->cursor.pos = 0; - if (!text->GotoNextError()) { - text->cursor = tmp; - pimpl_->owner_->getMiniBuffer() - ->Set(_("No more errors")); - LyXBell(); - } - } else { - pimpl_->owner_->getMiniBuffer()->Set(_("No more errors")); - LyXBell(); - } - } - update(0); - text->sel_cursor = text->cursor; + pimpl_->gotoError(); } @@ -424,65 +148,17 @@ void BufferView::upCB(long time, int button) } -static inline -void waitForX() -{ - XSync(fl_get_display(), 0); -} - - // Callback for scrollbar slider void BufferView::scrollCB(double value) { - extern bool cursor_follows_scrollbar; - - if (pimpl_->buffer_ == 0) return; - - pimpl_->current_scrollbar_value = long(value); - if (pimpl_->current_scrollbar_value < 0) - pimpl_->current_scrollbar_value = 0; - - if (!pimpl_->screen) - return; - - pimpl_->screen->Draw(pimpl_->current_scrollbar_value); - - if (cursor_follows_scrollbar) { - LyXText * vbt = text; - int height = vbt->DefaultHeight(); - - if (vbt->cursor.y < pimpl_->screen->first + height) { - vbt->SetCursorFromCoordinates(0, - pimpl_->screen->first + - height); - } else if (vbt->cursor.y > - pimpl_->screen->first + pimpl_->workarea->height() - height) { - vbt->SetCursorFromCoordinates(0, - pimpl_->screen->first + - pimpl_->workarea->height() - - height); - } - } - waitForX(); + pimpl_->scrollCB(value); } // Callback for scrollbar down button void BufferView::downCB(long time, int button) { - if (pimpl_->buffer_ == 0) return; - - switch (button) { - case 2: - pimpl_->scrollUpOnePage(); - break; - case 3: - pimpl_->scrollDownOnePage(); - break; - default: - pimpl_->scrollDown(time); - break; - } + pimpl_->downCB(time, button); } @@ -526,108 +202,11 @@ void BufferView::workAreaExpose() } -// Callback for cursor timer -void BufferView::cursorToggleCB(FL_OBJECT * ob, long) +// // Callback for cursor timer +void BufferView::cursorToggleCB(FL_OBJECT * ob, long ) { BufferView * view = static_cast(ob->u_vdata); - - // Quite a nice place for asyncron Inset updating, isn't it? - // Actually no! This is run even if no buffer exist... so (Lgb) - if (view && !view->pimpl_->buffer_) { - goto set_timer_and_return; - } - - // NOTE: - // On my quest to solve the gs render hangups I am now - // disabling the SIGHUP completely, and will do a wait - // now and then instead. If the guess that xforms somehow - // destroys something is true, this is likely (hopefully) - // to solve the problem...at least I hope so. Lgb - - // ...Ok this seems to work...at least it does not make things - // worse so far. However I still see gs processes that hangs. - // I would really like to know _why_ they are hanging. Anyway - // the solution without the SIGCHLD handler seems to be easier - // to debug. - - // When attaching gdb to a a running gs that hangs it shows - // that it is waiting for input(?) Is it possible for us to - // provide that input somehow? Or figure what it is expecing - // to read? - - // One solution is to, after some time, look if there are some - // old gs processes still running and if there are: kill them - // and re render. - - // Another solution is to provide the user an option to rerender - // a picture. This would, for the picture in question, check if - // there is a gs running for it, if so kill it, and start a new - // rendering process. - - // these comments posted to lyx@via - { - int status = 1; - int pid = waitpid(static_cast(0), &status, WNOHANG); - if (pid == -1) // error find out what is wrong - ; // ignore it for now. - else if (pid > 0) - sigchldhandler(pid, &status); - } - - view->pimpl_->updatelist.update(view); - - if (view && !view->pimpl_->screen) { - goto set_timer_and_return; - } - - if (view->pimpl_->lyx_focus && view->pimpl_->work_area_focus) { - if (!view->the_locking_inset) { - view->pimpl_->screen->CursorToggle(); - } else { - view->the_locking_inset-> - ToggleInsetCursor(view); - } - goto set_timer_and_return; - } else { - // Make sure that the cursor is visible. - if (!view->the_locking_inset) { - view->pimpl_->screen->ShowCursor(); - } else { - if (!view->the_locking_inset->isCursorVisible()) - view->the_locking_inset-> - ToggleInsetCursor(view); - } - // This is only run when work_area_focus or lyx_focus is false. - Window tmpwin; - int tmp; - XGetInputFocus(fl_display, &tmpwin, &tmp); - // Commenting this out, we have not had problems with this - // for a long time. We will probably work on this code later - // and we can reenable this debug code then. Now it only - // anoying when debugging. (Lgb) - //if (lyxerr.debugging(Debug::INFO)) { - // lyxerr << "tmpwin: " << tmpwin - // << "\nwindow: " << view->owner_->getForm()->window - // << "\nwork_area_focus: " << view->work_area_focus - // << "\nlyx_focus : " << view->lyx_focus - // << endl; - //} - if (tmpwin != view->pimpl_->owner_->getForm()->window) { - view->pimpl_->lyx_focus = false; - goto skip_timer; - } else { - view->pimpl_->lyx_focus = true; - if (!view->pimpl_->work_area_focus) - goto skip_timer; - else - goto set_timer_and_return; - } - } - - set_timer_and_return: - fl_set_timer(ob, 0.4); - skip_timer: - return; + view->pimpl_->cursorToggle(); } @@ -639,204 +218,91 @@ void BufferView::workAreaSelectionNotify(Window win, XEvent * event) void BufferView::cursorPrevious() { - if (!text->cursor.row->previous) return; - - long y = pimpl_->screen->first; - Row * cursorrow = text->cursor.row; - text->SetCursorFromCoordinates(text->cursor.x_fix, y); - text->FinishUndo(); - // This is to allow jumping over large insets - if ((cursorrow == text->cursor.row)) - text->CursorUp(); - - if (text->cursor.row->height < pimpl_->workarea->height()) - pimpl_->screen->Draw(text->cursor.y - - text->cursor.row->baseline - + text->cursor.row->height - - pimpl_->workarea->height() + 1 ); + pimpl_->cursorPrevious(); } void BufferView::cursorNext() { - if (!text->cursor.row->next) return; - - long y = pimpl_->screen->first; - text->GetRowNearY(y); - Row * cursorrow = text->cursor.row; - text->SetCursorFromCoordinates(text->cursor.x_fix, y - + pimpl_->workarea->height()); - text->FinishUndo(); - // This is to allow jumping over large insets - if ((cursorrow == text->cursor.row)) - text->CursorDown(); - - if (text->cursor.row->height < pimpl_->workarea->height()) - pimpl_->screen->Draw(text->cursor.y - - text->cursor.row->baseline); + pimpl_->cursorNext(); } bool BufferView::available() const { - if (pimpl_->buffer_ && text) return true; - return false; + return pimpl_->available(); } void BufferView::beforeChange() { - toggleSelection(); - text->ClearSelection(); - FreeUpdateTimer(); + pimpl_->beforeChange(); } void BufferView::savePosition() { - pimpl_->backstack.push(buffer()->fileName(), - text->cursor.x, - text->cursor.y); + pimpl_->savePosition(); } void BufferView::restorePosition() { - if (pimpl_->backstack.empty()) return; - - int x, y; - string fname = pimpl_->backstack.pop(&x, &y); - - beforeChange(); - Buffer * b = bufferlist.exists(fname) ? - bufferlist.getBuffer(fname) : - bufferlist.loadLyXFile(fname); // don't ask, just load it - buffer(b); - text->SetCursorFromCoordinates(x, y); - update(0); -} + pimpl_->restorePosition(); +} void BufferView::update(signed char f) { - owner()->updateLayoutChoice(); - - if (!text->selection && f > -3) - text->sel_cursor = text->cursor; - - FreeUpdateTimer(); - text->FullRebreak(); - - update(); - - if (f != 3 && f != -3) { - fitCursor(); - updateScrollbar(); - } - - if (f == 1 || f == -1) { - if (buffer()->isLyxClean()) { - buffer()->markDirty(); - owner()->getMiniBuffer()->setTimer(4); - } else { - buffer()->markDirty(); - } - } + pimpl_->update(f); } void BufferView::smallUpdate(signed char f) { - pimpl_->screen->SmallUpdate(); - if (pimpl_->screen->TopCursorVisible() - != pimpl_->screen->first) { - update(f); - return; - } - - fitCursor(); - updateScrollbar(); - - if (!text->selection) - text->sel_cursor = text->cursor; - - if (f == 1 || f == -1) { - if (buffer()->isLyxClean()) { - buffer()->markDirty(); - owner()->getMiniBuffer()->setTimer(4); - } else { - buffer()->markDirty(); - } - } + pimpl_->smallUpdate(f); } void BufferView::setState() { - if (!lyxrc.rtl_support) - return; - - if (text->real_current_font.isVisibleRightToLeft()) { - if (pimpl_->owner_->getIntl()->primarykeymap) - pimpl_->owner_->getIntl()->KeyMapSec(); - } else { - if (!pimpl_->owner_->getIntl()->primarykeymap) - pimpl_->owner_->getIntl()->KeyMapPrim(); - } + pimpl_->setState(); } void BufferView::insetSleep() { - if (the_locking_inset && !inset_slept) { - the_locking_inset->GetCursorPos(slx, sly); - the_locking_inset->InsetUnlock(this); - inset_slept = true; - } + pimpl_->insetSleep(); } void BufferView::insetWakeup() { - if (the_locking_inset && inset_slept) { - the_locking_inset->Edit(this, slx, sly, 0); - inset_slept = false; - } + pimpl_->insetWakeup(); } void BufferView::insetUnlock() { - if (the_locking_inset) { - if (!inset_slept) the_locking_inset->InsetUnlock(this); - the_locking_inset = 0; - text->FinishUndo(); - inset_slept = false; - } + pimpl_->insetUnlock(); } bool BufferView::focus() const { - return pimpl_->workarea->hasFocus(); + return pimpl_->focus(); } void BufferView::focus(bool f) { - if (f) pimpl_->workarea->setFocus(); + pimpl_->focus(f); } bool BufferView::active() const { - return pimpl_->workarea->active(); -} - - -Painter & BufferView::getPainter() const -{ - return pimpl_->workarea->getPainter(); + return pimpl_->active(); } @@ -848,46 +314,35 @@ unsigned short BufferView::paperWidth() const bool BufferView::belowMouse() const { - return pimpl_->workarea->belowMouse(); + return pimpl_->belowMouse(); } void BufferView::showCursor() { - if (pimpl_->screen) - pimpl_->screen->ShowCursor(); + pimpl_->showCursor(); } void BufferView::hideCursor() { - if (pimpl_->screen) - pimpl_->screen->HideCursor(); + pimpl_->hideCursor(); } void BufferView::toggleSelection(bool b) { - if (pimpl_->screen) - pimpl_->screen->ToggleSelection(b); + pimpl_->toggleSelection(b); } void BufferView::toggleToggle() { - if (pimpl_->screen) - pimpl_->screen->ToggleToggle(); + pimpl_->toggleToggle(); } void BufferView::center() { - beforeChange(); - if (text->cursor.y > pimpl_->workarea->height() / 2) { - pimpl_->screen->Draw(text->cursor.y - pimpl_->workarea->height() / 2); - } else { - pimpl_->screen->Draw(0); - } - update(0); - redraw(); + pimpl_->center(); } diff --git a/src/BufferView.h b/src/BufferView.h index 11bc14f06e..d9d92636aa 100644 --- a/src/BufferView.h +++ b/src/BufferView.h @@ -35,8 +35,6 @@ public: /// Painter & painter(); /// - Painter & getPainter() const; - /// void buffer(Buffer * b); /// void resize(int, int, int, int); diff --git a/src/BufferView_pimpl.C b/src/BufferView_pimpl.C index 50a3ef5003..d82dc16d50 100644 --- a/src/BufferView_pimpl.C +++ b/src/BufferView_pimpl.C @@ -1,6 +1,7 @@ #include -//#include +#include +#include #ifdef __GNUG__ #pragma implementation @@ -20,19 +21,33 @@ #include "TextCache.h" #include "bufferlist.h" #include "insets/insetbib.h" +#include "menus.h" +#include "lyx_gui_misc.h" +#include "lyxrc.h" +#include "intl.h" using std::pair; +using std::endl; extern BufferList bufferlist; extern bool selection_possible; extern char ascii_type; +extern void sigchldhandler(pid_t pid, int * status); extern int bibitemMaxWidth(Painter &, LyXFont const &); +extern void FreeUpdateTimer(); extern "C" void C_BufferView_CursorToggleCB(FL_OBJECT * ob, long buf); +static inline +void waitForX() +{ + XSync(fl_get_display(), 0); +} + + BufferView::Pimpl::Pimpl(BufferView * b, LyXView * o, int xpos, int ypos, int width, int height) : bv_(b), owner_(o) @@ -49,6 +64,234 @@ BufferView::Pimpl::Pimpl(BufferView * b, LyXView * o, lyx_focus = false; } + +Painter & BufferView::Pimpl::painter() +{ + return workarea->getPainter(); +} + + +void BufferView::Pimpl::buffer(Buffer * b) +{ + lyxerr[Debug::INFO] << "Setting buffer in BufferView (" + << b << ")" << endl; + if (buffer_) { + bv_->insetSleep(); + buffer_->delUser(bv_); + + // Put the old text into the TextCache, but + // only if the buffer is still loaded. + // Also set the owner of the test to 0 + bv_->text->owner(0); + textcache.add(bv_->text); + if (lyxerr.debugging()) + textcache.show(lyxerr, "BufferView::buffer"); + + bv_->text = 0; + } + + // Set current buffer + buffer_ = b; + + if (bufferlist.getState() == BufferList::CLOSING) return; + + // Nuke old image + // screen is always deleted when the buffer is changed. + delete screen; + screen = 0; + + // If we are closing the buffer, use the first buffer as current + if (!buffer_) { + buffer_ = bufferlist.first(); + } + + if (buffer_) { + lyxerr[Debug::INFO] << "Buffer addr: " << buffer_ << endl; + buffer_->addUser(bv_); + owner_->getMenus()->showMenus(); + // If we don't have a text object for this, we make one + if (bv_->text == 0) + resizeCurrentBuffer(); + else { + updateScreen(); + updateScrollbar(); + } + screen->first = screen->TopCursorVisible(); + redraw(); + updateAllVisibleBufferRelatedPopups(); + bv_->insetWakeup(); + } else { + lyxerr[Debug::INFO] << " No Buffer!" << endl; + owner_->getMenus()->hideMenus(); + updateScrollbar(); + workarea->redraw(); + + // Also remove all remaining text's from the testcache. + // (there should not be any!) (if there is any it is a + // bug!) + if (lyxerr.debugging()) + textcache.show(lyxerr, "buffer delete all"); + textcache.clear(); + } + // should update layoutchoice even if we don't have a buffer. + owner_->updateLayoutChoice(); + owner_->getMiniBuffer()->Init(); + owner_->updateWindowTitle(); +} + +void BufferView::Pimpl::resize(int xpos, int ypos, int width, int height) +{ + workarea->resize(xpos, ypos, width, height); + update(3); + redraw(); +} + + +void BufferView::Pimpl::resize() +{ + // This will resize the buffer. (Asger) + if (buffer_) + resizeCurrentBuffer(); +} + + +void BufferView::Pimpl::redraw() +{ + lyxerr[Debug::INFO] << "BufferView::redraw()" << endl; + workarea->redraw(); +} + + +void BufferView::Pimpl::fitCursor() +{ + if (screen) screen->FitCursor(); + updateScrollbar(); +} + + +void BufferView::Pimpl::redoCurrentBuffer() +{ + lyxerr[Debug::INFO] << "BufferView::redoCurrentBuffer" << endl; + if (buffer_ && bv_->text) { + resize(); + owner_->updateLayoutChoice(); + } +} + + +int BufferView::Pimpl::resizeCurrentBuffer() +{ + lyxerr[Debug::INFO] << "resizeCurrentBuffer" << endl; + + LyXParagraph * par = 0; + LyXParagraph * selstartpar = 0; + LyXParagraph * selendpar = 0; + int pos = 0; + int selstartpos = 0; + int selendpos = 0; + int selection = 0; + int mark_set = 0; + + ProhibitInput(); + + owner_->getMiniBuffer()->Set(_("Formatting document...")); + + if (bv_->text) { + par = bv_->text->cursor.par; + pos = bv_->text->cursor.pos; + selstartpar = bv_->text->sel_start_cursor.par; + selstartpos = bv_->text->sel_start_cursor.pos; + selendpar = bv_->text->sel_end_cursor.par; + selendpos = bv_->text->sel_end_cursor.pos; + selection = bv_->text->selection; + mark_set = bv_->text->mark_set; + delete bv_->text; + bv_->text = new LyXText(bv_, workarea->workWidth(), buffer_); + } else { + // See if we have a text in TextCache that fits + // the new buffer_ with the correct width. + bv_->text = textcache.findFit(buffer_, workarea->workWidth()); + if (bv_->text) { + if (lyxerr.debugging()) { + lyxerr << "Found a LyXText that fits:\n"; + textcache.show(lyxerr, bv_->text); + } + // Set the owner of the newly found text + bv_->text->owner(bv_); + if (lyxerr.debugging()) + textcache.show(lyxerr, "resizeCurrentBuffer"); + } else { + bv_->text = new LyXText(bv_, workarea->workWidth(), buffer_); + } + } + updateScreen(); + + if (par) { + bv_->text->selection = true; + /* at this point just to avoid the Delete-Empty-Paragraph + * Mechanism when setting the cursor */ + bv_->text->mark_set = mark_set; + if (selection) { + bv_->text->SetCursor(selstartpar, selstartpos); + bv_->text->sel_cursor = bv_->text->cursor; + bv_->text->SetCursor(selendpar, selendpos); + bv_->text->SetSelection(); + bv_->text->SetCursor(par, pos); + } else { + bv_->text->SetCursor(par, pos); + bv_->text->sel_cursor = bv_->text->cursor; + bv_->text->selection = false; + } + } + screen->first = screen->TopCursorVisible(); /* this will scroll the + * screen such that the + * cursor becomes + * visible */ + updateScrollbar(); + redraw(); + owner_->getMiniBuffer()->Init(); + bv_->setState(); + AllowInput(); + + // Now if the title form still exist kill it + TimerCB(0, 0); + + return 0; +} + + +void BufferView::Pimpl::gotoError() +{ + if (!screen) + return; + + screen->HideCursor(); + bv_->beforeChange(); + update(-2); + LyXCursor tmp; + + if (!bv_->text->GotoNextError()) { + if (bv_->text->cursor.pos + || bv_->text->cursor.par != bv_->text->FirstParagraph()) { + tmp = bv_->text->cursor; + bv_->text->cursor.par = bv_->text->FirstParagraph(); + bv_->text->cursor.pos = 0; + if (!bv_->text->GotoNextError()) { + bv_->text->cursor = tmp; + owner_->getMiniBuffer() + ->Set(_("No more errors")); + LyXBell(); + } + } else { + owner_->getMiniBuffer()->Set(_("No more errors")); + LyXBell(); + } + } + update(0); + bv_->text->sel_cursor = bv_->text->cursor; +} + + void BufferView::Pimpl::updateScreen() { // Regenerate the screen. @@ -73,6 +316,122 @@ void BufferView::Pimpl::create_view() } +void BufferView::Pimpl::updateScrollbar() +{ + /* If the text is smaller than the working area, the scrollbar + * maximum must be the working area height. No scrolling will + * be possible */ + + if (!buffer_) { + workarea->setScrollbar(0, 1.0); + return; + } + + static long max2 = 0; + static long height2 = 0; + + long cbth = 0; + long cbsf = 0; + + if (bv_->text) + cbth = bv_->text->height; + if (screen) + cbsf = screen->first; + + // check if anything has changed. + if (max2 == cbth && + height2 == workarea->height() && + current_scrollbar_value == cbsf) + return; // no + max2 = cbth; + height2 = workarea->height(); + current_scrollbar_value = cbsf; + + if (cbth <= height2) { // text is smaller than screen + workarea->setScrollbar(0, 1.0); // right? + return; + } + + long maximum_height = workarea->height() * 3 / 4 + cbth; + long value = cbsf; + + // set the scrollbar + double hfloat = workarea->height(); + double maxfloat = maximum_height; + + float slider_size = 0.0; + int slider_value = value; + + workarea->setScrollbarBounds(0, bv_->text->height - workarea->height()); + double lineh = bv_->text->DefaultHeight(); + workarea->setScrollbarIncrements(lineh); + if (maxfloat > 0.0) { + if ((hfloat / maxfloat) * float(height2) < 3) + slider_size = 3.0/float(height2); + else + slider_size = hfloat / maxfloat; + } else + slider_size = hfloat; + + workarea->setScrollbar(slider_value, slider_size / workarea->height()); +} + + +// Callback for scrollbar slider +void BufferView::Pimpl::scrollCB(double value) +{ + extern bool cursor_follows_scrollbar; + + if (buffer_ == 0) return; + + current_scrollbar_value = long(value); + if (current_scrollbar_value < 0) + current_scrollbar_value = 0; + + if (!screen) + return; + + screen->Draw(current_scrollbar_value); + + if (cursor_follows_scrollbar) { + LyXText * vbt = bv_->text; + int height = vbt->DefaultHeight(); + + if (vbt->cursor.y < screen->first + height) { + vbt->SetCursorFromCoordinates(0, + screen->first + + height); + } else if (vbt->cursor.y > + screen->first + workarea->height() - height) { + vbt->SetCursorFromCoordinates(0, + screen->first + + workarea->height() - + height); + } + } + waitForX(); +} + + +// Callback for scrollbar down button +void BufferView::Pimpl::downCB(long time, int button) +{ + if (buffer_ == 0) return; + + switch (button) { + case 2: + scrollUpOnePage(); + break; + case 3: + scrollDownOnePage(); + break; + default: + scrollDown(time); + break; + } +} + + int BufferView::Pimpl::scrollUp(long time) { if (buffer_ == 0) return 0; @@ -196,12 +555,12 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state) bv_->text->SetCursorFromCoordinates(x, y + screen->first); if (!bv_->text->selection) - bv_->update(-3); // Maybe an empty line was deleted + update(-3); // Maybe an empty line was deleted bv_->text->SetSelection(); screen->ToggleToggle(); if (screen->FitCursor()) - bv_->updateScrollbar(); + updateScrollbar(); screen->ShowCursor(); } return; @@ -209,7 +568,8 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state) // Single-click on work area -void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, unsigned int button) +void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, + unsigned int button) { last_click_x = -1; last_click_y = -1; @@ -270,7 +630,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, unsigned int but bv_->text->ClearSelection(); bv_->text->FullRebreak(); screen->Update(); - bv_->updateScrollbar(); + updateScrollbar(); } // Popup table popup when on a table. // This is obviously temporary, since we @@ -301,7 +661,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, unsigned int but bv_->text->ClearSelection(); bv_->text->FullRebreak(); screen->Update(); - bv_->updateScrollbar(); + updateScrollbar(); // Single left click in math inset? if ((inset_hit != 0) && @@ -330,7 +690,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, unsigned int but owner_->updateLayoutChoice(); if (screen->FitCursor()){ - bv_->updateScrollbar(); + updateScrollbar(); selection_possible = false; } @@ -360,7 +720,7 @@ void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, unsigned int button) screen->ToggleSelection(false); /* This will fit the cursor on the screen * if necessary */ - bv_->update(0); + update(0); } } } @@ -379,7 +739,7 @@ void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button) screen->ToggleSelection(false); /* This will fit the cursor on the screen * if necessary */ - bv_->update(0); + update(0); } } @@ -656,10 +1016,10 @@ void BufferView::Pimpl::workAreaExpose() // fitCursor() ensures we don't jump back // to the start of the document on vertical // resize - bv_->fitCursor(); + fitCursor(); // The main window size has changed, repaint most stuff - bv_->redraw(); + redraw(); // ...including the minibuffer owner_->getMiniBuffer()->Init(); @@ -670,7 +1030,7 @@ void BufferView::Pimpl::workAreaExpose() } // always make sure that the scrollbar is sane. - bv_->updateScrollbar(); + updateScrollbar(); owner_->updateLayoutChoice(); return; } @@ -746,7 +1106,359 @@ void BufferView::Pimpl::workAreaSelectionNotify(Window win, XEvent * event) else bv_->text->InsertStringB(clb); - bv_->update(1); + update(1); } } + +void BufferView::Pimpl::update() +{ + if (screen) screen->Update(); +} + + +void BufferView::Pimpl::update(signed char f) +{ + owner_->updateLayoutChoice(); + + if (!bv_->text->selection && f > -3) + bv_->text->sel_cursor = bv_->text->cursor; + + FreeUpdateTimer(); + bv_->text->FullRebreak(); + + update(); + + if (f != 3 && f != -3) { + fitCursor(); + updateScrollbar(); + } + + if (f == 1 || f == -1) { + if (buffer_->isLyxClean()) { + buffer_->markDirty(); + owner_->getMiniBuffer()->setTimer(4); + } else { + buffer_->markDirty(); + } + } +} + + +void BufferView::Pimpl::smallUpdate(signed char f) +{ + screen->SmallUpdate(); + if (screen->TopCursorVisible() + != screen->first) { + update(f); + return; + } + + fitCursor(); + updateScrollbar(); + + if (!bv_->text->selection) + bv_->text->sel_cursor = bv_->text->cursor; + + if (f == 1 || f == -1) { + if (buffer_->isLyxClean()) { + buffer_->markDirty(); + owner_->getMiniBuffer()->setTimer(4); + } else { + buffer_->markDirty(); + } + } +} + + +// Callback for cursor timer +void BufferView::Pimpl::cursorToggle() +{ + // Quite a nice place for asyncron Inset updating, isn't it? + // Actually no! This is run even if no buffer exist... so (Lgb) + if (!buffer_) { + goto set_timer_and_return; + } + + // NOTE: + // On my quest to solve the gs render hangups I am now + // disabling the SIGHUP completely, and will do a wait + // now and then instead. If the guess that xforms somehow + // destroys something is true, this is likely (hopefully) + // to solve the problem...at least I hope so. Lgb + + // ...Ok this seems to work...at least it does not make things + // worse so far. However I still see gs processes that hangs. + // I would really like to know _why_ they are hanging. Anyway + // the solution without the SIGCHLD handler seems to be easier + // to debug. + + // When attaching gdb to a a running gs that hangs it shows + // that it is waiting for input(?) Is it possible for us to + // provide that input somehow? Or figure what it is expecing + // to read? + + // One solution is to, after some time, look if there are some + // old gs processes still running and if there are: kill them + // and re render. + + // Another solution is to provide the user an option to rerender + // a picture. This would, for the picture in question, check if + // there is a gs running for it, if so kill it, and start a new + // rendering process. + + // these comments posted to lyx@via + { + int status = 1; + int pid = waitpid(static_cast(0), &status, WNOHANG); + if (pid == -1) // error find out what is wrong + ; // ignore it for now. + else if (pid > 0) + sigchldhandler(pid, &status); + } + + updatelist.update(bv_); + + if (!screen) { + goto set_timer_and_return; + } + + if (lyx_focus && work_area_focus) { + if (!bv_->the_locking_inset) { + screen->CursorToggle(); + } else { + bv_->the_locking_inset-> + ToggleInsetCursor(bv_); + } + goto set_timer_and_return; + } else { + // Make sure that the cursor is visible. + if (!bv_->the_locking_inset) { + screen->ShowCursor(); + } else { + if (!bv_->the_locking_inset->isCursorVisible()) + bv_->the_locking_inset-> + ToggleInsetCursor(bv_); + } + // This is only run when work_area_focus or lyx_focus is false. + Window tmpwin; + int tmp; + XGetInputFocus(fl_display, &tmpwin, &tmp); + // Commenting this out, we have not had problems with this + // for a long time. We will probably work on this code later + // and we can reenable this debug code then. Now it only + // anoying when debugging. (Lgb) + //if (lyxerr.debugging(Debug::INFO)) { + // lyxerr << "tmpwin: " << tmpwin + // << "\nwindow: " << view->owner_->getForm()->window + // << "\nwork_area_focus: " << view->work_area_focus + // << "\nlyx_focus : " << view->lyx_focus + // << endl; + //} + if (tmpwin != owner_->getForm()->window) { + lyx_focus = false; + goto skip_timer; + } else { + lyx_focus = true; + if (!work_area_focus) + goto skip_timer; + else + goto set_timer_and_return; + } + } + + set_timer_and_return: + fl_set_timer(timer_cursor, 0.4); + skip_timer: + return; +} + + +void BufferView::Pimpl::cursorPrevious() +{ + if (!bv_->text->cursor.row->previous) return; + + long y = screen->first; + Row * cursorrow = bv_->text->cursor.row; + bv_->text->SetCursorFromCoordinates(bv_->text->cursor.x_fix, y); + bv_->text->FinishUndo(); + // This is to allow jumping over large insets + if ((cursorrow == bv_->text->cursor.row)) + bv_->text->CursorUp(); + + if (bv_->text->cursor.row->height < workarea->height()) + screen->Draw(bv_->text->cursor.y + - bv_->text->cursor.row->baseline + + bv_->text->cursor.row->height + - workarea->height() + 1 ); +} + + +void BufferView::Pimpl::cursorNext() +{ + if (!bv_->text->cursor.row->next) return; + + long y = screen->first; + bv_->text->GetRowNearY(y); + Row * cursorrow = bv_->text->cursor.row; + bv_->text->SetCursorFromCoordinates(bv_->text->cursor.x_fix, y + + workarea->height()); + bv_->text->FinishUndo(); + // This is to allow jumping over large insets + if ((cursorrow == bv_->text->cursor.row)) + bv_->text->CursorDown(); + + if (bv_->text->cursor.row->height < workarea->height()) + screen->Draw(bv_->text->cursor.y + - bv_->text->cursor.row->baseline); +} + + +bool BufferView::Pimpl::available() const +{ + if (buffer_ && bv_->text) return true; + return false; +} + + +void BufferView::Pimpl::beforeChange() +{ + toggleSelection(); + bv_->text->ClearSelection(); + FreeUpdateTimer(); +} + + +void BufferView::Pimpl::savePosition() +{ + backstack.push(buffer_->fileName(), + bv_->text->cursor.x, + bv_->text->cursor.y); +} + + +void BufferView::Pimpl::restorePosition() +{ + if (backstack.empty()) return; + + int x, y; + string fname = backstack.pop(&x, &y); + + beforeChange(); + Buffer * b = bufferlist.exists(fname) ? + bufferlist.getBuffer(fname) : + bufferlist.loadLyXFile(fname); // don't ask, just load it + buffer(b); + bv_->text->SetCursorFromCoordinates(x, y); + update(0); +} + + +void BufferView::Pimpl::setState() +{ + if (!lyxrc.rtl_support) + return; + + if (bv_->text->real_current_font.isVisibleRightToLeft()) { + if (owner_->getIntl()->primarykeymap) + owner_->getIntl()->KeyMapSec(); + } else { + if (!owner_->getIntl()->primarykeymap) + owner_->getIntl()->KeyMapPrim(); + } +} + + +void BufferView::Pimpl::insetSleep() +{ + if (bv_->the_locking_inset && !bv_->inset_slept) { + bv_->the_locking_inset->GetCursorPos(bv_->slx, bv_->sly); + bv_->the_locking_inset->InsetUnlock(bv_); + bv_->inset_slept = true; + } +} + + +void BufferView::Pimpl::insetWakeup() +{ + if (bv_->the_locking_inset && bv_->inset_slept) { + bv_->the_locking_inset->Edit(bv_, bv_->slx, bv_->sly, 0); + bv_->inset_slept = false; + } +} + + +void BufferView::Pimpl::insetUnlock() +{ + if (bv_->the_locking_inset) { + if (!bv_->inset_slept) bv_->the_locking_inset->InsetUnlock(bv_); + bv_->the_locking_inset = 0; + bv_->text->FinishUndo(); + bv_->inset_slept = false; + } +} + + +bool BufferView::Pimpl::focus() const +{ + return workarea->hasFocus(); +} + + +void BufferView::Pimpl::focus(bool f) +{ + if (f) workarea->setFocus(); +} + + +bool BufferView::Pimpl::active() const +{ + return workarea->active(); +} + + +bool BufferView::Pimpl::belowMouse() const +{ + return workarea->belowMouse(); +} + + +void BufferView::Pimpl::showCursor() +{ + if (screen) + screen->ShowCursor(); +} + + +void BufferView::Pimpl::hideCursor() +{ + if (screen) + screen->HideCursor(); +} + + +void BufferView::Pimpl::toggleSelection(bool b) +{ + if (screen) + screen->ToggleSelection(b); +} + + +void BufferView::Pimpl::toggleToggle() +{ + if (screen) + screen->ToggleToggle(); +} + + +void BufferView::Pimpl::center() +{ + beforeChange(); + if (bv_->text->cursor.y > workarea->height() / 2) { + screen->Draw(bv_->text->cursor.y - workarea->height() / 2); + } else { + screen->Draw(0); + } + update(0); + redraw(); +} diff --git a/src/BufferView_pimpl.h b/src/BufferView_pimpl.h index 25f4715165..c0d09c806b 100644 --- a/src/BufferView_pimpl.h +++ b/src/BufferView_pimpl.h @@ -18,12 +18,41 @@ class LyXScreen; struct BufferView::Pimpl { Pimpl(BufferView * i, LyXView * o, int xpos, int ypos, int width, int height); - + /// + Painter & painter(); + /// + void buffer(Buffer *); + /// + void resize(int xpos, int ypos, int width, int height); + /// + void resize(); + /// + void redraw(); + /// + void fitCursor(); + /// + void redoCurrentBuffer(); + /// + int resizeCurrentBuffer(); + /// + void update(); + /// + void update(signed char f); + /// + void smallUpdate(signed char f); + /// + void gotoError(); /// Update pixmap of screen void updateScreen(); /// void workAreaExpose(); /// + void updateScrollbar(); + /// + void scrollCB(double value); + /// + void downCB(long time, int button); + /// void scrollUpOnePage(); /// void scrollDownOnePage(); @@ -48,6 +77,46 @@ struct BufferView::Pimpl { /// void tripleClick(int x, int y, unsigned int button); /// + void cursorToggle(); + /// + void cursorPrevious(); + /// + void cursorNext(); + /// + bool available() const; + /// + void beforeChange(); + /// + void savePosition(); + /// + void restorePosition(); + /// + void setState(); + /// + void insetSleep(); + /// + void insetWakeup(); + /// + void insetUnlock(); + /// + bool focus() const; + /// + void focus(bool); + /// + bool active() const; + /// + bool belowMouse() const; + /// + void showCursor(); + /// + void hideCursor(); + /// + void toggleSelection(bool = true); + /// + void toggleToggle(); + /// + void center(); + /// BufferView * bv_; /// LyXView * owner_; diff --git a/src/insets/inset.C b/src/insets/inset.C index f2515bbbc0..430dca4c75 100644 --- a/src/insets/inset.C +++ b/src/insets/inset.C @@ -129,7 +129,7 @@ void UpdatableInset::Edit(BufferView * bv, int, int, unsigned int) scx = 0; - mx_scx = abs((width(bv->getPainter(), font) - bv->paperWidth()) / 2); + mx_scx = abs((width(bv->painter(), font) - bv->paperWidth()) / 2); } diff --git a/src/insets/insetcollapsable.C b/src/insets/insetcollapsable.C index 532abb133b..a8d0254882 100644 --- a/src/insets/insetcollapsable.C +++ b/src/insets/insetcollapsable.C @@ -165,10 +165,10 @@ void InsetCollapsable::InsetUnlock(BufferView *bv) } -void InsetCollapsable::UpdateLocal(BufferView *bv, bool flag) +void InsetCollapsable::UpdateLocal(BufferView * bv, bool flag) { - maxWidth = getMaxWidth(bv->getPainter()) - - width_collapsed(bv->getPainter(), labelfont); + maxWidth = getMaxWidth(bv->painter()) - + width_collapsed(bv->painter(), labelfont); InsetText::UpdateLocal(bv, flag); } diff --git a/src/insets/insetinfo.C b/src/insets/insetinfo.C index 2a03b97462..1047de11a2 100644 --- a/src/insets/insetinfo.C +++ b/src/insets/insetinfo.C @@ -81,16 +81,18 @@ void InsetInfo::draw(Painter & pain, LyXFont const & f, LyXFont font(f); /* Info-insets are never LaTeX, so just correct the font */ - font.setLatex(LyXFont::OFF); - + font.setLatex(LyXFont::OFF).setColor(LColor::note); + // Draw as "Note" in a yellow box x += 1; pain.fillRectangle(int(x), baseline - ascent(pain, font) + 1, width(pain, font) - 2, - ascent(pain, font) + descent(pain, font) - 2); + ascent(pain, font) + descent(pain, font) - 2, + LColor::notebg); pain.rectangle(int(x), baseline - ascent(pain, font) + 1, width(pain, font) - 2, - ascent(pain, font) + descent(pain, font) - 2); + ascent(pain, font) + descent(pain, font) - 2, + LColor::noteframe); pain.text(int(x + 2), baseline, _("Note"), font); x += width(pain, font) - 1; diff --git a/src/insets/insettext.C b/src/insets/insettext.C index 70f180d387..b3f756ea9e 100644 --- a/src/insets/insettext.C +++ b/src/insets/insettext.C @@ -370,7 +370,7 @@ bool InsetText::UpdateInsetInInset(BufferView * bv, Inset * inset) if (the_locking_inset != inset) return the_locking_inset->UpdateInsetInInset(bv, inset); float x = inset_x; - inset->draw(bv->getPainter(), real_current_font, inset_y, x); + inset->draw(bv->painter(), real_current_font, inset_y, x); UpdateLocal(bv, true); return true; } @@ -626,8 +626,8 @@ InsetText::LocalDispatch(BufferView * bv, case LFUN_HOME: bv->text->FinishUndo(); for(; actpos > rows[actrow].pos; --actpos) - cx -= SingleWidth(bv->getPainter(), par, actpos); - cx -= SingleWidth(bv->getPainter(), par, actpos); + cx -= SingleWidth(bv->painter(), par, actpos); + cx -= SingleWidth(bv->painter(), par, actpos); if (hasSelection()) { selection_start = selection_end = actpos; UpdateLocal(bv, false); @@ -642,7 +642,7 @@ InsetText::LocalDispatch(BufferView * bv, if ((actrow + 2) < (int)rows.size()) --checkpos; for(; actpos < checkpos; ++actpos) - cx += SingleWidth(bv->getPainter(), par, actpos); + cx += SingleWidth(bv->painter(), par, actpos); if (hasSelection()) { selection_start = selection_end = actpos; UpdateLocal(bv, false); @@ -906,19 +906,16 @@ void InsetText::setPos(BufferView * bv, int x, int y, bool activate_inset) x += top_x; int swh; - int sw; - int checkpos; - - sw = swh = SingleWidth(bv->getPainter(), par,actpos); + int sw = swh = SingleWidth(bv->painter(), par,actpos); if (par->GetChar(actpos)!=LyXParagraph::META_INSET) swh /= 2; - checkpos = rows[actrow + 1].pos; + int checkpos = rows[actrow + 1].pos; if ((actrow+2) < (int)rows.size()) --checkpos; while ((actpos < checkpos) && ((cx + swh) < x)) { cx += sw; ++actpos; - sw = swh = SingleWidth(bv->getPainter(), par,actpos); + sw = swh = SingleWidth(bv->painter(), par,actpos); if (par->GetChar(actpos)!=LyXParagraph::META_INSET) swh /= 2; } @@ -965,7 +962,7 @@ bool InsetText::moveLeft(BufferView * bv, bool activate_inset) inset_y = cy; inset_pos = actpos; the_locking_inset->Edit(bv, the_locking_inset-> - width(bv->getPainter(), GetFont(par,actpos)), + width(bv->painter(), GetFont(par,actpos)), 0, 0); } else { resetPos(bv); @@ -1012,7 +1009,7 @@ void InsetText::resetPos(BufferView * bv) setPos(bv, 0, cy, false); cx = top_x; while(actpos < old_pos) { - cx += SingleWidth(bv->getPainter(), par,actpos); + cx += SingleWidth(bv->painter(), par,actpos); ++actpos; } } diff --git a/src/text2.C b/src/text2.C index 3b47d059d7..625d145f09 100644 --- a/src/text2.C +++ b/src/text2.C @@ -3348,10 +3348,8 @@ void LyXText::DeleteEmptyParagraphMechanism(LyXCursor const & old_cursor) const // correct cursor if (old_cursor.par == cursor.par && cursor.pos > old_cursor.pos) { - //SetCursor(cursor.par, cursor.pos - 1); - cursor.pos--; - } //else - // SetCursor(cursor.par, cursor.pos); + SetCursorIntern(cursor.par, cursor.pos - 1); + } return; } } @@ -3459,8 +3457,11 @@ void LyXText::DeleteEmptyParagraphMechanism(LyXCursor const & old_cursor) const } // correct cursor y +#if 1 + SetCursorIntern(cursor.par, cursor.pos); +#else SetCursor(cursor.par, cursor.pos); - +#endif /* if (cursor.y > old_cursor.y) cursor.y -= old_cursor.row->height; */ @@ -3475,7 +3476,11 @@ void LyXText::DeleteEmptyParagraphMechanism(LyXCursor const & old_cursor) const if (old_cursor.par->ClearParagraph()) { RedoParagraphs(old_cursor, old_cursor.par->Next()); // correct cursor y +#if 1 + SetCursorIntern(cursor.par, cursor.pos); +#else SetCursor(cursor.par, cursor.pos); +#endif sel_cursor = cursor; } }