anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-22 13:18:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

more changes to bufferview, fix cursorpositioning, correct color on insetinfos

Browse Source 
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@642 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
Lars Gullik Bjønnes 2000-04-09 22:48:51 +00:00
parent 76938908d7
commit 1136642d8a
10 changed files with 874 additions and 625 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
ChangeLog
View File

@ -1,3 +1,14 @@
2000-04-10 Lars Gullik Bjønnes <larsbj@lyx.org>
* 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 <larsbj@lyx.org>
* src/WorkArea.C (belowMouse): manually implement below mouse.

621
src/BufferView.C
View File

@ -11,61 +11,14 @@
#include <config.h>
#include <algorithm>
#include <cstdlib>
#include <csignal>
#include <unistd.h>
#include <sys/wait.h>
#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<BufferView*>(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<pid_t>(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();
}

2
src/BufferView.h
View File

@ -35,8 +35,6 @@ public:
///
Painter & painter();
///
Painter & getPainter() const;
///
void buffer(Buffer * b);
///
void resize(int, int, int, int);

738
src/BufferView_pimpl.C
View File

@ -1,6 +1,7 @@
#include <config.h>
//#include <utility>
#include <unistd.h>
#include <sys/wait.h>
#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<pid_t>(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();
}

71
src/BufferView_pimpl.h
View File

@ -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_;

2
src/insets/inset.C
View File

@ -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);
}

6
src/insets/insetcollapsable.C
View File

@ -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);
}

8
src/insets/insetinfo.C
View File

@ -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;

21
src/insets/insettext.C
View File

@ -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;
}
}

15
src/text2.C
View File

@ -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;
}
}