#include "TextCache.h"
#include "bufferlist.h"
#include "insets/insetbib.h"
-#include "menus.h"
#include "lyx_gui_misc.h"
#include "lyxrc.h"
#include "intl.h"
extern BufferList bufferlist;
extern char ascii_type;
+extern "C" void TimerCB(FL_OBJECT *, long);
extern void sigchldhandler(pid_t pid, int * status);
extern int bibitemMaxWidth(BufferView *, LyXFont const &);
static Cursor cursor;
static bool cursor_undefined = true;
if (cursor_undefined){
- cursor = XCreateFontCursor(fl_display, XC_xterm);
- XFlush(fl_display);
+ cursor = XCreateFontCursor(fl_get_display(), XC_xterm);
+ XFlush(fl_get_display());
cursor_undefined = false;
}
- XDefineCursor(fl_display, win, cursor);
- XFlush(fl_display);
+ XDefineCursor(fl_get_display(), win, cursor);
+ XFlush(fl_get_display());
}
: bv_(b), owner_(o), cursor_timeout(400)
{
buffer_ = 0;
+#if 0
workarea_ = new WorkArea(bv_, xpos, ypos, width, height);
+#else
+ workarea_ = new WorkArea(xpos, ypos, width, height);
+#endif
+ // Setup the signals
+ workarea_->scrollCB.connect(slot(this, &BufferView::Pimpl::scrollCB));
+ workarea_->workAreaExpose
+ .connect(slot(this, &BufferView::Pimpl::workAreaExpose));
+ workarea_->workAreaEnter
+ .connect(slot(this, &BufferView::Pimpl::enterView));
+ workarea_->workAreaLeave
+ .connect(slot(this, &BufferView::Pimpl::leaveView));
+ workarea_->workAreaButtonPress
+ .connect(slot(this, &BufferView::Pimpl::workAreaButtonPress));
+ workarea_->workAreaButtonRelease
+ .connect(slot(this,
+ &BufferView::Pimpl::workAreaButtonRelease));
+ workarea_->workAreaMotionNotify
+ .connect(slot(this, &BufferView::Pimpl::workAreaMotionNotify));
+ workarea_->workAreaDoubleClick
+ .connect(slot(this, &BufferView::Pimpl::doubleClick));
+ workarea_->workAreaTripleClick
+ .connect(slot(this, &BufferView::Pimpl::tripleClick));
+ workarea_->workAreaKeyPress
+ .connect(slot(this, &BufferView::Pimpl::workAreaKeyPress));
+
screen_ = 0;
cursor_timeout.timeout.connect(slot(this,
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();
updateScrollbar();
}
bv_->text->first = screen_->TopCursorVisible(bv_->text);
+ owner_->updateMenubar();
+ owner_->updateToolbar();
+ // Similarly, buffer-dependent dialogs should be updated or
+ // hidden. This should go here because some dialogs (eg ToC)
+ // require bv_->text.
+ owner_->getDialogs()->updateBufferDependent(true);
redraw();
- owner_->getDialogs()->updateBufferDependent();
bv_->insetWakeup();
} else {
lyxerr[Debug::INFO] << " No Buffer!" << endl;
- owner_->getMenus()->hideMenus();
+ owner_->updateMenubar();
+ owner_->updateToolbar();
+ owner_->getDialogs()->hideBufferDependent();
updateScrollbar();
workarea_->redraw();
}
-bool BufferView::Pimpl::fitCursor()
+bool BufferView::Pimpl::fitCursor(LyXText * text)
{
Assert(screen_); // it is a programming error to call fitCursor
// without a valid screen.
- bool ret = screen_->FitCursor(bv_->text);
- if (ret) updateScrollbar();
+ bool ret = screen_->FitCursor(text, bv_);
+ if (ret)
+ updateScrollbar();
return ret;
}
}
}
bv_->text->first = screen_->TopCursorVisible(bv_->text);
- /* this will scroll the
- * screen such that the
- * cursor becomes
- * visible */
+ buffer_->resizeInsets(bv_);
+ // this will scroll the screen such that the cursor becomes visible
updateScrollbar();
redraw();
owner_->getMiniBuffer()->Init();
// 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 (!screen_)
return;
- screen_->Draw(bv_->text, current_scrollbar_value);
+ screen_->Draw(bv_->text, bv_, current_scrollbar_value);
- if (cursor_follows_scrollbar) {
+ if (lyxrc.cursor_follows_scrollbar) {
LyXText * vbt = bv_->text;
- unsigned int height = vbt->DefaultHeight();
+ int height = vbt->DefaultHeight();
- if (vbt->cursor.y() < bv_->text->first + height) {
+ if (vbt->cursor.y() < static_cast<int>((bv_->text->first + height))) {
vbt->SetCursorFromCoordinates(bv_, 0,
bv_->text->first +
height);
} else if (vbt->cursor.y() >
- bv_->text->first + workarea_->height() - height) {
+ static_cast<int>((bv_->text->first+workarea_->height()-height)))
+ {
vbt->SetCursorFromCoordinates(bv_, 0,
bv_->text->first +
workarea_->height() -
workarea_->setScrollbarValue(value);
- bv_->scrollCB(value);
+ scrollCB(value);
return 0;
}
workarea_->setScrollbarValue(value);
- bv_->scrollCB(value);
+ scrollCB(value);
return 0;
}
+void BufferView::Pimpl::workAreaKeyPress(KeySym keysym, unsigned int state)
+{
+ bv_->owner()->getLyXFunc()->processKeySym(keysym, state);
+}
+
+
void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state)
{
// Only use motion with button 1
if (buffer_ == 0 || !screen_) return;
// Check for inset locking
- if (bv_->the_locking_inset) {
+ if (bv_->theLockingInset()) {
LyXCursor cursor = bv_->text->cursor;
- bv_->the_locking_inset->
+ LyXFont font = bv_->text->GetFont(bv_->buffer(),
+ cursor.par(), cursor.pos());
+ int width = bv_->theLockingInset()->width(bv_, font);
+ int inset_x = font.isVisibleRightToLeft()
+ ? cursor.x() - width : cursor.x();
+ int start_x = inset_x + bv_->theLockingInset()->scroll();
+ bv_->theLockingInset()->
InsetMotionNotify(bv_,
- x - cursor.x(),
+ x - start_x,
y - cursor.y() + bv_->text->first,
state);
return;
update(BufferView::UPDATE); // Maybe an empty line was deleted
bv_->text->SetSelection();
- screen_->ToggleToggle(bv_->text);
- fitCursor();
- screen_->ShowCursor(bv_->text);
+ screen_->ToggleToggle(bv_->text, bv_);
+ fitCursor(bv_->text);
+ screen_->ShowCursor(bv_->text, bv_);
}
return;
}
}
}
- if (bv_->the_locking_inset) {
+ if (bv_->theLockingInset()) {
// We are in inset locking mode
/* Check whether the inset was hit. If not reset mode,
otherwise give the event to the inset */
- if (inset_hit == bv_->the_locking_inset) {
- bv_->the_locking_inset->
+ if (inset_hit == bv_->theLockingInset()) {
+ bv_->theLockingInset()->
InsetButtonPress(bv_,
xpos, ypos,
button);
return;
} else {
- bv_->unlockInset(bv_->the_locking_inset);
+ bv_->unlockInset(bv_->theLockingInset());
}
}
selection_possible = true;
screen_->HideCursor();
-#ifndef NEW_TABULAR
- // Right button mouse click on a table
- if (button == 3 &&
- (bv_->text->cursor.par()->table ||
- bv_->text->MouseHitInTable(bv_, xpos, ypos + bv_->text->first))) {
- // Set the cursor to the press-position
- bv_->text->SetCursorFromCoordinates(bv_, xpos, ypos + bv_->text->first);
- bool doit = true;
-
- // Only show the table popup if the hit is in
- // the table, too
- if (!bv_->text->HitInTable(bv_,
- bv_->text->cursor.row(), xpos))
- doit = false;
-
- // Hit above or below the table?
- if (doit) {
- if (!bv_->text->selection) {
- screen_->ToggleSelection(bv_->text);
- bv_->text->ClearSelection();
- bv_->text->FullRebreak(bv_);
- screen_->Update(bv_->text);
- updateScrollbar();
- }
- // Popup table popup when on a table.
- // This is obviously temporary, since we
- // should be able to popup various
- // context-sensitive-menus with the
- // the right mouse. So this should be done more
- // general in the future. Matthias.
- selection_possible = false;
- owner_->getLyXFunc()
- ->Dispatch(LFUN_LAYOUT_TABLE,
- "true");
- return;
- }
- }
-#endif
-
- int screen_first = bv_->text->first;
+ int const screen_first = bv_->text->first;
// Middle button press pastes if we have a selection
bool paste_internally = false;
}
// Clear the selection
- screen_->ToggleSelection(bv_->text);
+ screen_->ToggleSelection(bv_->text, bv_);
bv_->text->ClearSelection();
bv_->text->FullRebreak(bv_);
- screen_->Update(bv_->text);
+ screen_->Update(bv_->text, bv_);
updateScrollbar();
// Single left click in math inset?
bv_->text->cursor.x_fix(bv_->text->cursor.x());
owner_->updateLayoutChoice();
- if (fitCursor()) {
+ if (fitCursor(bv_->text)) {
selection_possible = false;
}
void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, unsigned int button)
{
// select a word
- if (buffer_ && !bv_->the_locking_inset) {
+ if (buffer_ && !bv_->theLockingInset()) {
if (screen_ && button == 1) {
screen_->HideCursor();
- screen_->ToggleSelection(bv_->text);
+ screen_->ToggleSelection(bv_->text, bv_);
bv_->text->SelectWord(bv_);
- screen_->ToggleSelection(bv_->text, false);
+ screen_->ToggleSelection(bv_->text, bv_, false);
/* This will fit the cursor on the screen
* if necessary */
update(BufferView::SELECT|BufferView::FITCUR);
}
- }
+ }
}
void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button)
{
// select a line
- if (buffer_ && screen_ && button == 1) {
+ if (buffer_ && screen_ && !bv_->theLockingInset() && (button == 1)) {
screen_->HideCursor();
- screen_->ToggleSelection(bv_->text);
+ screen_->ToggleSelection(bv_->text, bv_);
bv_->text->CursorHome(bv_);
bv_->text->sel_cursor = bv_->text->cursor;
bv_->text->CursorEnd(bv_);
bv_->text->SetSelection();
- screen_->ToggleSelection(bv_->text, false);
+ screen_->ToggleSelection(bv_->text, bv_, false);
/* This will fit the cursor on the screen
* if necessary */
update(BufferView::SELECT|BufferView::FITCUR);
void BufferView::Pimpl::leaveView()
{
if (using_xterm_cursor) {
- XUndefineCursor(fl_display, workarea_->getWin());
+ XUndefineCursor(fl_get_display(), workarea_->getWin());
using_xterm_cursor = false;
}
}
// inset, inset_hit is 0, and inset_x == x, inset_y == y.
Inset * inset_hit = checkInsetHit(bv_->text, x, y, button);
- if (bv_->the_locking_inset) {
+ if (bv_->theLockingInset()) {
// We are in inset locking mode.
/* LyX does a kind of work-area grabbing for insets.
Only a ButtonPress Event outside the inset will
force a InsetUnlock. */
- bv_->the_locking_inset->
+ bv_->theLockingInset()->
InsetButtonRelease(bv_, x, y, button);
return;
}
selection_possible = false;
-#ifndef NEW_TABULAR
- if (bv_->text->cursor.par()->table) {
- int cell = bv_->text->
- NumberOfCell(bv_->text->cursor.par(),
- bv_->text->cursor.pos());
- if (bv_->text->cursor.par()->table->IsContRow(cell) &&
- bv_->text->cursor.par()->table->
- CellHasContRow(bv_->text->cursor.par()->table->
- GetCellAbove(cell))<0) {
- bv_->text->CursorUp(bv_);
- }
- }
-#endif
if (button >= 2) return;
bv_->setState();
- owner_->getMiniBuffer()->Set(CurrentState(bv_));
+ owner_->showState();
// Did we hit an editable inset?
if (inset_hit != 0) {
c = bv_->text->cursor.par()->
GetChar(bv_->text->cursor.pos());
}
+#ifndef NEW_INSETS
+ if(!bv_->text->selection)
if (c == LyXParagraph::META_FOOTNOTE
|| c == LyXParagraph::META_MARGIN
|| c == LyXParagraph::META_FIG
|| c == LyXParagraph::META_WIDE_TAB
|| c == LyXParagraph::META_ALGORITHM){
hit = true;
- } else if (bv_->text->cursor.pos() - 1 >= 0) {
+ } else
+#endif
+ if (bv_->text->cursor.pos() - 1 >= 0) {
c = bv_->text->cursor.par()->
GetChar(bv_->text->cursor.pos() - 1);
+#ifndef NEW_INSETS
if (c == LyXParagraph::META_FOOTNOTE
|| c == LyXParagraph::META_MARGIN
|| c == LyXParagraph::META_FIG
bv_->text->CursorLeft(bv_);
hit = true;
}
+#endif
}
if (hit == true) {
+#ifndef NEW_INSETS
bv_->toggleFloat();
+#endif
selection_possible = false;
return;
}
}
+#ifndef NEW_INSETS
// Do we want to close a float? (click on the float-label)
if (bv_->text->cursor.row()->par()->footnoteflag ==
LyXParagraph::OPEN_FOOTNOTE
return;
}
}
+#endif
// Maybe we want to edit a bibitem ale970302
if (bv_->text->cursor.par()->bibkey && x < 20 +
if (!screen_)
return 0;
- unsigned int y_tmp = y + text->first;
+ int y_tmp = y + text->first;
LyXCursor cursor;
text->SetCursorFromCoordinates(bv_, cursor, x, y_tmp);
-#if 0 // Are you planning to use this Jürgen? (Lgb)
- bool move_cursor = ((cursor.par != text->cursor.par) ||
- (cursor.pos != text->cursor.pos()));
-#endif
+
if (cursor.pos() < cursor.par()->Last()
&& cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET
&& cursor.par()->GetInset(cursor.pos())
Inset * tmpinset = cursor.par()->GetInset(cursor.pos());
LyXFont font = text->GetFont(bv_->buffer(),
cursor.par(), cursor.pos());
- bool is_rtl = font.isVisibleRightToLeft();
- int start_x, end_x;
-
- if (is_rtl) {
- start_x = cursor.x() - tmpinset->width(bv_, font);
- end_x = cursor.x();
- } else {
- start_x = cursor.x();
- end_x = cursor.x() + tmpinset->width(bv_, font);
- }
+ int width = tmpinset->width(bv_, font);
+ int inset_x = font.isVisibleRightToLeft()
+ ? cursor.x() - width : cursor.x();
+ int start_x = inset_x + tmpinset->scroll();
+ int end_x = inset_x + width;
if (x > start_x && x < end_x
&& y_tmp > cursor.y() - tmpinset->ascent(bv_, font)
&& y_tmp < cursor.y() + tmpinset->descent(bv_, font)) {
-#if 0
- if (move_cursor && (tmpinset != bv_->the_locking_inset))
-#endif
- text->SetCursor(bv_, cursor.par(),cursor.pos(),true);
+ text->SetCursor(bv_, cursor.par(),cursor.pos(),true);
x = x - start_x;
// The origin of an inset is on the baseline
y = y_tmp - (text->cursor.y());
Inset * tmpinset = cursor.par()->GetInset(cursor.pos()-1);
LyXFont font = text->GetFont(bv_->buffer(), cursor.par(),
cursor.pos()-1);
- bool is_rtl = font.isVisibleRightToLeft();
- int start_x, end_x;
+ int width = tmpinset->width(bv_, font);
+ int inset_x = font.isVisibleRightToLeft()
+ ? cursor.x() : cursor.x() - width;
+ int start_x = inset_x + tmpinset->scroll();
+ int end_x = inset_x + width;
- if (!is_rtl) {
- start_x = cursor.x() - tmpinset->width(bv_, font);
- end_x = cursor.x();
- } else {
- start_x = cursor.x();
- end_x = cursor.x() + tmpinset->width(bv_, font);
- }
if (x > start_x && x < end_x
&& y_tmp > cursor.y() - tmpinset->ascent(bv_, font)
&& y_tmp < cursor.y() + tmpinset->descent(bv_, font)) {
#if 0
- if (move_cursor && (tmpinset != bv_->the_locking_inset))
+ if (move_cursor && (tmpinset != bv_->theLockingInset()))
#endif
text->SetCursor(bv_, cursor.par(),cursor.pos()-1,true);
x = x - start_x;
// fitCursor() ensures we don't jump back
// to the start of the document on vertical
// resize
- fitCursor();
+ fitCursor(bv_->text);
// The main window size has changed, repaint most stuff
redraw();
// ...including the minibuffer
owner_->getMiniBuffer()->Init();
- } else if (screen_) screen_->Redraw(bv_->text);
+ } else if (screen_)
+ screen_->Redraw(bv_->text, bv_);
} else {
// Grey box when we don't have a buffer
workarea_->greyOut();
void BufferView::Pimpl::update()
{
- if (screen_) screen_->Update(bv_->text);
+ if (screen_) screen_->Update(bv_->text, bv_);
}
// Values used when calling update:
update();
if ((f & FITCUR)) {
- fitCursor();
+ fitCursor(bv_->text);
}
if ((f & CHANGE)) {
goto set_timer_and_return;
}
- if (!bv_->the_locking_inset) {
- screen_->CursorToggle(bv_->text);
+ if (!bv_->theLockingInset()) {
+ screen_->CursorToggle(bv_->text, bv_);
} else {
- bv_->the_locking_inset->
- ToggleInsetCursor(bv_);
+ bv_->theLockingInset()->ToggleInsetCursor(bv_);
}
set_timer_and_return:
}
-void BufferView::Pimpl::cursorPrevious()
+void BufferView::Pimpl::cursorPrevious(LyXText * text)
{
- if (!bv_->text->cursor.row()->previous()) return;
+ if (!text->cursor.row()->previous())
+ return;
- long y = bv_->text->first;
- Row * cursorrow = bv_->text->cursor.row();
- bv_->text->SetCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y);
+ int y = text->first;
+ if (text->inset_owner)
+ y += bv_->text->first;
+ Row * cursorrow = text->cursor.row();
+ text->SetCursorFromCoordinates(bv_, 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(bv_);
+ if ((cursorrow == text->cursor.row()))
+ text->CursorUp(bv_);
- if (bv_->text->cursor.row()->height() < workarea_->height())
- screen_->Draw(bv_->text,
- bv_->text->cursor.y()
- - bv_->text->cursor.row()->baseline()
- + bv_->text->cursor.row()->height()
+ if (text->inset_owner ||
+ text->cursor.row()->height() < workarea_->height())
+ screen_->Draw(bv_->text, bv_,
+ text->cursor.y()
+ - text->cursor.row()->baseline()
+ + text->cursor.row()->height()
- workarea_->height() + 1 );
updateScrollbar();
}
-void BufferView::Pimpl::cursorNext()
+void BufferView::Pimpl::cursorNext(LyXText * text)
{
- if (!bv_->text->cursor.row()->next()) return;
+ if (!text->cursor.row()->next())
+ return;
- long y = bv_->text->first;
- bv_->text->GetRowNearY(y);
- Row * cursorrow = bv_->text->cursor.row();
- bv_->text->SetCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y
- + workarea_->height());
+ int y = text->first + workarea_->height();
+// if (text->inset_owner)
+// y += bv_->text->first;
+ text->GetRowNearY(y);
+
+ Row * cursorrow = text->cursor.row();
+ 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(bv_);
+ text->CursorDown(bv_);
- if (bv_->text->cursor.row()->height() < workarea_->height())
- screen_->Draw(bv_->text, bv_->text->cursor.y()
- - bv_->text->cursor.row()->baseline());
+ if (text->inset_owner ||
+ text->cursor.row()->height() < workarea_->height())
+ screen_->Draw(bv_->text, bv_, text->cursor.y() -
+ text->cursor.row()->baseline());
updateScrollbar();
}
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);
+
+ if (fname != buffer_->fileName()) {
+ Buffer * b = bufferlist.exists(fname) ?
+ bufferlist.getBuffer(fname) :
+ bufferlist.loadLyXFile(fname); // don't ask, just load it
+ if (b != 0 ) buffer(b);
+ }
+
bv_->text->SetCursorFromCoordinates(bv_, x, y);
update(BufferView::SELECT|BufferView::FITCUR);
-}
+}
bool BufferView::Pimpl::NoSavedPositions()
if (!lyxrc.rtl_support)
return;
- if (bv_->text->real_current_font.isRightToLeft() &&
- bv_->text->real_current_font.latex() != LyXFont::ON) {
+ LyXText * text = bv_->getLyXText();
+ if (text->real_current_font.isRightToLeft() &&
+ text->real_current_font.latex() != LyXFont::ON) {
if (owner_->getIntl()->primarykeymap)
owner_->getIntl()->KeyMapSec();
} else {
void BufferView::Pimpl::insetSleep()
{
- if (bv_->the_locking_inset && !bv_->inset_slept) {
- bv_->the_locking_inset->GetCursorPos(bv_, bv_->slx, bv_->sly);
- bv_->the_locking_inset->InsetUnlock(bv_);
+ if (bv_->theLockingInset() && !bv_->inset_slept) {
+ bv_->theLockingInset()->GetCursorPos(bv_, bv_->slx, bv_->sly);
+ bv_->theLockingInset()->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);
+ if (bv_->theLockingInset() && bv_->inset_slept) {
+ bv_->theLockingInset()->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;
+ if (bv_->theLockingInset()) {
+ if (!bv_->inset_slept)
+ bv_->theLockingInset()->InsetUnlock(bv_);
+ bv_->theLockingInset(0);
bv_->text->FinishUndo();
bv_->inset_slept = false;
}
void BufferView::Pimpl::showCursor()
{
if (screen_)
- screen_->ShowCursor(bv_->text);
+ screen_->ShowCursor(bv_->text, bv_);
}
void BufferView::Pimpl::toggleSelection(bool b)
{
if (screen_)
- screen_->ToggleSelection(bv_->text, b);
+ screen_->ToggleSelection(bv_->text, bv_, b);
}
void BufferView::Pimpl::toggleToggle()
{
if (screen_)
- screen_->ToggleToggle(bv_->text);
+ screen_->ToggleToggle(bv_->text, bv_);
}
void BufferView::Pimpl::center()
{
beforeChange();
- if (bv_->text->cursor.y() > workarea_->height() / 2) {
- screen_->Draw(bv_->text, bv_->text->cursor.y() - workarea_->height() / 2);
+ if (bv_->text->cursor.y() > static_cast<int>((workarea_->height() / 2))) {
+ screen_->Draw(bv_->text, bv_, bv_->text->cursor.y() - workarea_->height() / 2);
} else {
- screen_->Draw(bv_->text, 0);
+ screen_->Draw(bv_->text, bv_, 0);
}
update(BufferView::SELECT|BufferView::FITCUR);
redraw();
screen_->HideCursor();
bv_->beforeChange();
- string clip(workarea_->getClipboard());
+ string const clip(workarea_->getClipboard());
if (clip.empty()) return;
projects / lyx.git / blobdiff