#include "TextCache.h"
#include "bufferlist.h"
#include "insets/insetbib.h"
-#include "menus.h"
#include "lyx_gui_misc.h"
#include "lyxrc.h"
#include "intl.h"
#include "support/LAssert.h"
#include "frontends/Dialogs.h"
+#ifndef NEW_MENUBAR
+# include "menus.h"
+#endif
+
+#ifdef SIGC_CXX_NAMESPACES
+using SigC::slot;
+#endif
using std::pair;
using std::endl;
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(Painter &, LyXFont const &);
+extern int bibitemMaxWidth(BufferView *, LyXFont const &);
static inline
{
buffer_ = 0;
workarea_ = new WorkArea(bv_, xpos, ypos, width, height);
- screen = 0;
+ screen_ = 0;
- cursor_timeout.callback(BufferView::cursorToggleCB, bv_);
+ cursor_timeout.timeout.connect(slot(this,
+ &BufferView::Pimpl::cursorToggle));
current_scrollbar_value = 0;
cursor_timeout.start();
workarea_->setFocus();
- work_area_focus = true;
- lyx_focus = false;
using_xterm_cursor = false;
}
// Nuke old image
// screen is always deleted when the buffer is changed.
- delete screen;
- screen = 0;
+ delete screen_;
+ screen_ = 0;
// If we are closing the buffer, use the first buffer as current
if (!buffer_) {
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();
updateScreen();
updateScrollbar();
}
- screen->first = screen->TopCursorVisible();
+ bv_->text->first = screen_->TopCursorVisible(bv_->text);
+#ifdef NEW_MENUBAR
+ owner_->updateMenubar();
+#else
+ owner_->getMenus()->showMenus();
+#endif
+ owner_->updateToolbar();
redraw();
owner_->getDialogs()->updateBufferDependent();
bv_->insetWakeup();
} else {
lyxerr[Debug::INFO] << " No Buffer!" << endl;
+#ifdef NEW_MENUBAR
+ owner_->updateMenubar();
+#else
owner_->getMenus()->hideMenus();
+#endif
+ owner_->updateToolbar();
updateScrollbar();
workarea_->redraw();
bool BufferView::Pimpl::fitCursor()
{
- Assert(screen); // it is a programming error to call fitCursor
+ Assert(screen_); // it is a programming error to call fitCursor
// without a valid screen.
- bool ret = screen->FitCursor();
+ bool ret = screen_->FitCursor(bv_->text);
if (ret) updateScrollbar();
return ret;
}
bv_->text->selection = false;
}
}
- screen->first = screen->TopCursorVisible(); /* this will scroll the
- * screen such that the
- * cursor becomes
- * visible */
+ bv_->text->first = screen_->TopCursorVisible(bv_->text);
+ buffer_->resizeInsets(bv_);
+ // this will scroll the screen such that the cursor becomes visible
updateScrollbar();
redraw();
owner_->getMiniBuffer()->Init();
void BufferView::Pimpl::gotoError()
{
- if (!screen)
+ if (!screen_)
return;
- screen->HideCursor();
+ screen_->HideCursor();
bv_->beforeChange();
update(BufferView::SELECT|BufferView::FITCUR);
LyXCursor tmp;
void BufferView::Pimpl::updateScreen()
{
// Regenerate the screen.
- delete screen;
- screen = new LyXScreen(*workarea_, bv_->text);
+ delete screen_;
+ screen_ = new LyXScreen(*workarea_);
}
unsigned long cbth = 0;
long cbsf = 0;
- if (bv_->text)
+ if (bv_->text) {
cbth = bv_->text->height;
- if (screen)
- cbsf = screen->first;
+ cbsf = bv_->text->first;
+ }
// check if anything has changed.
if (max2 == cbth &&
if (current_scrollbar_value < 0)
current_scrollbar_value = 0;
- if (!screen)
+ if (!screen_)
return;
- screen->Draw(current_scrollbar_value);
+ screen_->Draw(bv_->text, current_scrollbar_value);
if (cursor_follows_scrollbar) {
LyXText * vbt = bv_->text;
unsigned int height = vbt->DefaultHeight();
- if (vbt->cursor.y() < screen->first + height) {
+ if (vbt->cursor.y() < bv_->text->first + height) {
vbt->SetCursorFromCoordinates(bv_, 0,
- screen->first +
+ bv_->text->first +
height);
} else if (vbt->cursor.y() >
- screen->first + workarea_->height() - height) {
+ bv_->text->first + workarea_->height() - height) {
vbt->SetCursorFromCoordinates(bv_, 0,
- screen->first +
+ bv_->text->first +
workarea_->height() -
height);
}
int BufferView::Pimpl::scrollUp(long time)
{
if (buffer_ == 0) return 0;
- if (!screen) return 0;
+ if (!screen_) return 0;
double value = workarea_->getScrollbarValue();
int BufferView::Pimpl::scrollDown(long time)
{
if (buffer_ == 0) return 0;
- if (!screen) return 0;
+ if (!screen_) return 0;
double value= workarea_->getScrollbarValue();
pair<float, float> p = workarea_->getScrollbarBounds();
if (!(state & Button1MotionMask))
return;
- if (buffer_ == 0 || !screen) return;
+ if (buffer_ == 0 || !screen_) return;
// Check for inset locking
if (bv_->the_locking_inset) {
bv_->the_locking_inset->
InsetMotionNotify(bv_,
x - cursor.x(),
- y - cursor.y() + screen->first,
+ y - cursor.y() + bv_->text->first,
state);
return;
}
/* The selection possible is needed, that only motion events are
* used, where the bottom press event was on the drawing area too */
if (selection_possible) {
- screen->HideCursor();
+ screen_->HideCursor();
- bv_->text->SetCursorFromCoordinates(bv_, x, y + screen->first);
+ bv_->text->SetCursorFromCoordinates(bv_, x, y + bv_->text->first);
if (!bv_->text->selection)
update(BufferView::UPDATE); // Maybe an empty line was deleted
bv_->text->SetSelection();
- screen->ToggleToggle();
+ screen_->ToggleToggle(bv_->text);
fitCursor();
- screen->ShowCursor();
+ screen_->ShowCursor(bv_->text);
}
return;
}
last_click_x = -1;
last_click_y = -1;
- if (buffer_ == 0 || !screen) return;
+ if (buffer_ == 0 || !screen_) return;
- Inset * inset_hit = checkInsetHit(xpos, ypos, button);
+ Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos, button);
// ok ok, this is a hack.
if (button == 4 || button == 5) {
switch (button) {
case 4:
- scrollUp(100); // This number is only temporary
+ scrollUp(lyxrc.wheel_jump); // default 100, set in lyxrc
break;
case 5:
- scrollDown(100);
+ scrollDown(lyxrc.wheel_jump);
break;
}
}
if (!inset_hit)
selection_possible = true;
- screen->HideCursor();
+ 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 + screen->first))) {
+ bv_->text->MouseHitInTable(bv_, xpos, ypos + bv_->text->first))) {
// Set the cursor to the press-position
- bv_->text->SetCursorFromCoordinates(bv_, xpos, ypos + screen->first);
+ bv_->text->SetCursorFromCoordinates(bv_, xpos, ypos + bv_->text->first);
bool doit = true;
// Only show the table popup if the hit is in
// Hit above or below the table?
if (doit) {
if (!bv_->text->selection) {
- screen->ToggleSelection();
+ screen_->ToggleSelection(bv_->text);
bv_->text->ClearSelection();
bv_->text->FullRebreak(bv_);
- screen->Update();
+ screen_->Update(bv_->text);
updateScrollbar();
}
// Popup table popup when on a table.
}
#endif
- int screen_first = screen->first;
+ int screen_first = bv_->text->first;
// Middle button press pastes if we have a selection
bool paste_internally = false;
}
// Clear the selection
- screen->ToggleSelection();
+ screen_->ToggleSelection(bv_->text);
bv_->text->ClearSelection();
bv_->text->FullRebreak(bv_);
- screen->Update();
+ screen_->Update(bv_->text);
updateScrollbar();
// Single left click in math inset?
{
// select a word
if (buffer_ && !bv_->the_locking_inset) {
- if (screen && button == 1) {
- screen->HideCursor();
- screen->ToggleSelection();
+ if (screen_ && button == 1) {
+ screen_->HideCursor();
+ screen_->ToggleSelection(bv_->text);
bv_->text->SelectWord(bv_);
- screen->ToggleSelection(false);
+ screen_->ToggleSelection(bv_->text, 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) {
- screen->HideCursor();
- screen->ToggleSelection();
+ if (buffer_ && screen_ && button == 1) {
+ screen_->HideCursor();
+ screen_->ToggleSelection(bv_->text);
bv_->text->CursorHome(bv_);
bv_->text->sel_cursor = bv_->text->cursor;
bv_->text->CursorEnd(bv_);
bv_->text->SetSelection();
- screen->ToggleSelection(false);
+ screen_->ToggleSelection(bv_->text, false);
/* This will fit the cursor on the screen
* if necessary */
update(BufferView::SELECT|BufferView::FITCUR);
void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
unsigned int button)
{
- if (buffer_ == 0 || screen == 0) return;
+ if (buffer_ == 0 || screen_ == 0) return;
// If we hit an inset, we have the inset coordinates in these
// and inset_hit points to the inset. If we do not hit an
// inset, inset_hit is 0, and inset_x == x, inset_y == y.
- Inset * inset_hit = checkInsetHit(x, y, button);
+ Inset * inset_hit = checkInsetHit(bv_->text, x, y, button);
if (bv_->the_locking_inset) {
// We are in inset locking mode.
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 (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
int box_x = 20; // LYX_PAPER_MARGIN;
box_x += lyxfont::width(" wide-tab ", font);
- unsigned int screen_first = screen->first;
+ unsigned int screen_first = bv_->text->first;
if (x < box_x
&& y + screen_first > bv_->text->cursor.y() -
return;
}
}
+#endif
// Maybe we want to edit a bibitem ale970302
if (bv_->text->cursor.par()->bibkey && x < 20 +
- bibitemMaxWidth(bv_->painter(),
- textclasslist
- .TextClass(buffer_->
- params.textclass).defaultfont())) {
+ bibitemMaxWidth(bv_, textclasslist.
+ TextClass(buffer_->
+ params.textclass).defaultfont())) {
bv_->text->cursor.par()->bibkey->Edit(bv_, 0, 0, 0);
}
* If hit, the coordinates are changed relative to the inset.
* Otherwise coordinates are not changed, and false is returned.
*/
-Inset * BufferView::Pimpl::checkInsetHit(int & x, int & y,
+Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y,
unsigned int /* button */)
{
- if (!screen)
+ if (!screen_)
return 0;
- unsigned int y_tmp = y + screen->first;
+ unsigned int y_tmp = y + text->first;
LyXCursor cursor;
- bv_->text->SetCursorFromCoordinates(bv_, cursor, x, y_tmp);
+ text->SetCursorFromCoordinates(bv_, cursor, x, y_tmp);
#if 0 // Are you planning to use this Jürgen? (Lgb)
- bool move_cursor = ((cursor.par != bv_->text->cursor.par) ||
- (cursor.pos != bv_->text->cursor.pos()));
+ 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
// Check whether the inset really was hit
Inset * tmpinset = cursor.par()->GetInset(cursor.pos());
- LyXFont font = bv_->text->GetFont(bv_->buffer(),
+ 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_->painter(), font);
+ start_x = cursor.x() - tmpinset->width(bv_, font);
end_x = cursor.x();
} else {
start_x = cursor.x();
- end_x = cursor.x() + tmpinset->width(bv_->painter(), font);
+ end_x = cursor.x() + tmpinset->width(bv_, font);
}
if (x > start_x && x < end_x
- && y_tmp > cursor.y() - tmpinset->ascent(bv_->painter(), font)
- && y_tmp < cursor.y() + tmpinset->descent(bv_->painter(), font)) {
+ && 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
- bv_->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 - (bv_->text->cursor.y());
+ y = y_tmp - (text->cursor.y());
return tmpinset;
}
}
(cursor.par()->GetInset(cursor.pos() - 1)) &&
(cursor.par()->GetInset(cursor.pos() - 1)->Editable())) {
Inset * tmpinset = cursor.par()->GetInset(cursor.pos()-1);
- LyXFont font = bv_->text->GetFont(bv_->buffer(), cursor.par(),
+ LyXFont font = text->GetFont(bv_->buffer(), cursor.par(),
cursor.pos()-1);
bool is_rtl = font.isVisibleRightToLeft();
int start_x, end_x;
if (!is_rtl) {
- start_x = cursor.x() - tmpinset->width(bv_->painter(), font);
+ start_x = cursor.x() - tmpinset->width(bv_, font);
end_x = cursor.x();
} else {
start_x = cursor.x();
- end_x = cursor.x() + tmpinset->width(bv_->painter(), font);
+ end_x = cursor.x() + tmpinset->width(bv_, font);
}
if (x > start_x && x < end_x
- && y_tmp > cursor.y() - tmpinset->ascent(bv_->painter(), font)
- && y_tmp < cursor.y() + tmpinset->descent(bv_->painter(), font)) {
+ && 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
- bv_->text->SetCursor(bv_, cursor.par(),cursor.pos()-1,true);
+ text->SetCursor(bv_, cursor.par(),cursor.pos()-1,true);
x = x - start_x;
// The origin of an inset is on the baseline
- y = y_tmp - (bv_->text->cursor.y());
+ y = y_tmp - (text->cursor.y());
return tmpinset;
}
}
// ...including the minibuffer
owner_->getMiniBuffer()->Init();
- } else if (screen) screen->Redraw();
+ } else if (screen_) screen_->Redraw(bv_->text);
} else {
// Grey box when we don't have a buffer
workarea_->greyOut();
void BufferView::Pimpl::update()
{
- if (screen) screen->Update();
+ if (screen_) screen_->Update(bv_->text);
}
// Values used when calling update:
// update(1) -> update(1 + 2 + 4) -> update(7) -> update(SELECT|FITCUR|CHANGE)
// update(3) -> update(1) -> update(1) -> update(SELECT)
-//void BufferView::Pimpl::update(signed char f)
void BufferView::Pimpl::update(BufferView::UpdateCodes f)
{
owner_->updateLayoutChoice();
updatelist.update(bv_);
- if (!screen) {
+ 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;
+ if (!bv_->the_locking_inset) {
+ screen_->CursorToggle(bv_->text);
} 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;
- }
+ bv_->the_locking_inset->
+ ToggleInsetCursor(bv_);
}
-
+
set_timer_and_return:
cursor_timeout.restart();
- skip_timer:
return;
}
{
if (!bv_->text->cursor.row()->previous()) return;
- long y = screen->first;
+ long y = bv_->text->first;
Row * cursorrow = bv_->text->cursor.row();
bv_->text->SetCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y);
bv_->text->FinishUndo();
bv_->text->CursorUp(bv_);
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 );
+ screen_->Draw(bv_->text,
+ bv_->text->cursor.y()
+ - bv_->text->cursor.row()->baseline()
+ + bv_->text->cursor.row()->height()
+ - workarea_->height() + 1 );
updateScrollbar();
}
{
if (!bv_->text->cursor.row()->next()) return;
- long y = screen->first;
+ 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
bv_->text->CursorDown(bv_);
if (bv_->text->cursor.row()->height() < workarea_->height())
- screen->Draw(bv_->text->cursor.y()
+ screen_->Draw(bv_->text, bv_->text->cursor.y()
- bv_->text->cursor.row()->baseline());
updateScrollbar();
}
update(BufferView::SELECT|BufferView::FITCUR);
}
+
bool BufferView::Pimpl::NoSavedPositions()
{
return backstack.empty();
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->GetCursorPos(bv_, bv_->slx, bv_->sly);
bv_->the_locking_inset->InsetUnlock(bv_);
bv_->inset_slept = true;
}
void BufferView::Pimpl::showCursor()
{
- if (screen)
- screen->ShowCursor();
+ if (screen_)
+ screen_->ShowCursor(bv_->text);
}
void BufferView::Pimpl::hideCursor()
{
- if (screen)
- screen->HideCursor();
+ if (screen_)
+ screen_->HideCursor();
}
void BufferView::Pimpl::toggleSelection(bool b)
{
- if (screen)
- screen->ToggleSelection(b);
+ if (screen_)
+ screen_->ToggleSelection(bv_->text, b);
}
void BufferView::Pimpl::toggleToggle()
{
- if (screen)
- screen->ToggleToggle();
+ if (screen_)
+ screen_->ToggleToggle(bv_->text);
}
{
beforeChange();
if (bv_->text->cursor.y() > workarea_->height() / 2) {
- screen->Draw(bv_->text->cursor.y() - workarea_->height() / 2);
+ screen_->Draw(bv_->text, bv_->text->cursor.y() - workarea_->height() / 2);
} else {
- screen->Draw(0);
+ screen_->Draw(bv_->text, 0);
}
update(BufferView::SELECT|BufferView::FITCUR);
redraw();
{
if (buffer_ == 0) return;
- screen->HideCursor();
+ screen_->HideCursor();
bv_->beforeChange();
string clip(workarea_->getClipboard());