2002-06-18 15:44:30 +00:00
|
|
|
/**
|
|
|
|
* \file screen.C
|
2002-09-05 15:14:23 +00:00
|
|
|
* This file is part of LyX, the document processor.
|
|
|
|
* Licence details can be found in the file COPYING.
|
2002-06-18 15:44:30 +00:00
|
|
|
*
|
2002-11-27 10:30:28 +00:00
|
|
|
* \author John Levon
|
2002-09-05 14:10:50 +00:00
|
|
|
*
|
|
|
|
* Full author contact details are available in file CREDITS
|
2002-06-25 15:59:10 +00:00
|
|
|
*
|
|
|
|
* Splash screen code added by Angus Leeming
|
2002-06-18 15:44:30 +00:00
|
|
|
*/
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
#include <config.h>
|
2000-02-18 22:22:42 +00:00
|
|
|
|
2002-05-23 15:43:25 +00:00
|
|
|
#include "screen.h"
|
1999-09-27 18:44:28 +00:00
|
|
|
#include "lyxtext.h"
|
2002-08-06 13:00:50 +00:00
|
|
|
#include "lyxrc.h"
|
2000-02-04 09:38:32 +00:00
|
|
|
#include "lyxrow.h"
|
2001-06-25 00:06:33 +00:00
|
|
|
#include "BufferView.h"
|
2002-06-18 15:44:30 +00:00
|
|
|
#include "buffer.h"
|
|
|
|
#include "WorkArea.h"
|
|
|
|
#include "Painter.h"
|
2002-05-24 14:34:32 +00:00
|
|
|
#include "font_metrics.h"
|
2001-04-05 12:26:41 +00:00
|
|
|
#include "language.h"
|
2002-06-18 15:44:30 +00:00
|
|
|
#include "debug.h"
|
2003-02-26 17:04:10 +00:00
|
|
|
#include "rowpainter.h"
|
2003-05-03 18:05:53 +00:00
|
|
|
#include "insets/updatableinset.h"
|
2003-06-03 19:32:08 +00:00
|
|
|
#include "lyx_gui.h"
|
2003-07-22 15:12:04 +00:00
|
|
|
#include "metricsinfo.h"
|
1999-09-27 18:44:28 +00:00
|
|
|
|
2002-06-25 15:59:10 +00:00
|
|
|
// Splash screen-specific stuff
|
|
|
|
#include "lyxfont.h"
|
|
|
|
#include "version.h"
|
|
|
|
|
2002-06-26 14:15:08 +00:00
|
|
|
#include "graphics/GraphicsLoader.h"
|
2002-06-25 15:59:10 +00:00
|
|
|
#include "graphics/GraphicsImage.h"
|
|
|
|
|
|
|
|
#include "support/filetools.h" // LibFileSearch
|
|
|
|
|
|
|
|
#include <boost/utility.hpp>
|
|
|
|
#include <boost/bind.hpp>
|
2002-06-26 14:15:08 +00:00
|
|
|
#include <boost/signals/trackable.hpp>
|
2002-06-25 15:59:10 +00:00
|
|
|
|
2003-06-30 23:56:22 +00:00
|
|
|
using namespace lyx::support;
|
|
|
|
|
2000-02-18 22:22:42 +00:00
|
|
|
using std::min;
|
2002-06-18 15:44:30 +00:00
|
|
|
using std::max;
|
|
|
|
using std::endl;
|
2002-06-21 17:16:35 +00:00
|
|
|
|
2002-06-25 15:59:10 +00:00
|
|
|
namespace {
|
|
|
|
|
2002-06-26 14:15:08 +00:00
|
|
|
class SplashScreen : boost::noncopyable, boost::signals::trackable {
|
2002-06-25 15:59:10 +00:00
|
|
|
public:
|
|
|
|
/// This is a singleton class. Get the instance.
|
|
|
|
static SplashScreen const & get();
|
|
|
|
///
|
2003-07-21 21:30:57 +00:00
|
|
|
lyx::graphics::Image const * image() const { return loader_.image(); }
|
2002-06-25 15:59:10 +00:00
|
|
|
///
|
|
|
|
string const & text() const { return text_; }
|
|
|
|
///
|
|
|
|
LyXFont const & font() const { return font_; }
|
2003-02-26 12:49:01 +00:00
|
|
|
///
|
2003-07-21 21:30:57 +00:00
|
|
|
void connect(lyx::graphics::Loader::slot_type const & slot) const {
|
2003-02-26 12:49:01 +00:00
|
|
|
loader_.connect(slot);
|
|
|
|
}
|
|
|
|
///
|
|
|
|
void startLoading() const {
|
2003-07-21 21:30:57 +00:00
|
|
|
if (loader_.status() == lyx::graphics::WaitingToLoad)
|
2003-02-26 12:49:01 +00:00
|
|
|
loader_.startLoading();
|
|
|
|
}
|
2002-06-25 15:59:10 +00:00
|
|
|
|
|
|
|
private:
|
2002-06-26 14:15:08 +00:00
|
|
|
/** Make the c-tor private so we can control how many objects
|
2002-06-25 15:59:10 +00:00
|
|
|
* are instantiated.
|
|
|
|
*/
|
|
|
|
SplashScreen();
|
|
|
|
|
2002-06-26 14:15:08 +00:00
|
|
|
///
|
2003-07-21 21:30:57 +00:00
|
|
|
lyx::graphics::Loader loader_;
|
2002-06-25 15:59:10 +00:00
|
|
|
/// The text to be written on top of the pixmap
|
|
|
|
string const text_;
|
|
|
|
/// in this font...
|
|
|
|
LyXFont font_;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
SplashScreen const & SplashScreen::get()
|
|
|
|
{
|
|
|
|
static SplashScreen singleton;
|
|
|
|
return singleton;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
SplashScreen::SplashScreen()
|
2002-06-26 14:15:08 +00:00
|
|
|
: text_(lyx_version ? lyx_version : "unknown")
|
2002-06-25 15:59:10 +00:00
|
|
|
{
|
2002-08-06 13:00:50 +00:00
|
|
|
if (!lyxrc.show_banner)
|
|
|
|
return;
|
|
|
|
|
2003-01-12 19:35:40 +00:00
|
|
|
string const file = LibFileSearch("images", "banner", "ppm");
|
2002-06-25 15:59:10 +00:00
|
|
|
if (file.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// The font used to display the version info
|
|
|
|
font_.setFamily(LyXFont::SANS_FAMILY);
|
|
|
|
font_.setSeries(LyXFont::BOLD_SERIES);
|
|
|
|
font_.setSize(LyXFont::SIZE_NORMAL);
|
|
|
|
font_.setColor(LColor::yellow);
|
|
|
|
|
|
|
|
// Load up the graphics file
|
2002-06-26 14:15:08 +00:00
|
|
|
loader_.reset(file);
|
2002-06-25 15:59:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace anon
|
|
|
|
|
2002-06-21 17:16:35 +00:00
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
LyXScreen::LyXScreen()
|
2003-03-17 01:34:36 +00:00
|
|
|
: cursor_visible_(false), greyed_out_(true)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2002-06-25 15:59:10 +00:00
|
|
|
// Start loading the pixmap as soon as possible
|
2003-02-26 12:49:01 +00:00
|
|
|
if (lyxrc.show_banner) {
|
|
|
|
SplashScreen const & splash = SplashScreen::get();
|
|
|
|
splash.connect(boost::bind(&LyXScreen::greyOut, this));
|
|
|
|
splash.startLoading();
|
|
|
|
}
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
LyXScreen::~LyXScreen()
|
2001-06-25 00:06:33 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2002-03-21 17:27:08 +00:00
|
|
|
|
2003-05-03 18:05:53 +00:00
|
|
|
void LyXScreen::showCursor(BufferView & bv)
|
2002-06-11 23:47:58 +00:00
|
|
|
{
|
2003-06-03 19:32:08 +00:00
|
|
|
// this is needed to make sure we copy back the right
|
|
|
|
// pixmap on the hide for the Qt frontend
|
|
|
|
lyx_gui::sync_events();
|
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
if (cursor_visible_)
|
|
|
|
return;
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2003-05-03 18:05:53 +00:00
|
|
|
if (!bv.available())
|
|
|
|
return;
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
Cursor_Shape shape = BAR_SHAPE;
|
2003-05-03 18:05:53 +00:00
|
|
|
|
|
|
|
LyXText const & text = *bv.getLyXText();
|
2003-07-22 15:12:04 +00:00
|
|
|
LyXFont const & realfont = text.real_current_font;
|
|
|
|
BufferParams const & bp = bv.buffer()->params;
|
2003-05-03 18:05:53 +00:00
|
|
|
bool const samelang = realfont.language() == bp.language;
|
|
|
|
bool const isrtl = realfont.isVisibleRightToLeft();
|
|
|
|
|
|
|
|
if (!samelang || isrtl != bp.language->RightToLeft()) {
|
|
|
|
shape = L_SHAPE;
|
|
|
|
if (isrtl)
|
|
|
|
shape = REVERSED_L_SHAPE;
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2003-05-03 18:05:53 +00:00
|
|
|
int ascent = font_metrics::maxAscent(realfont);
|
|
|
|
int descent = font_metrics::maxDescent(realfont);
|
|
|
|
int h = ascent + descent;
|
|
|
|
int x = 0;
|
|
|
|
int y = 0;
|
|
|
|
int const top_y = bv.text->top_y();
|
|
|
|
|
|
|
|
if (bv.theLockingInset()) {
|
|
|
|
// Would be nice to clean this up to make some understandable sense...
|
|
|
|
UpdatableInset * inset = bv.theLockingInset();
|
|
|
|
inset->getCursor(bv, x, y);
|
|
|
|
|
|
|
|
// Non-obvious. The reason we have to have these
|
|
|
|
// extra checks is that the ->getCursor() calls rely
|
|
|
|
// on the inset's own knowledge of its screen position.
|
|
|
|
// If we scroll up or down in a big enough increment, the
|
|
|
|
// inset->draw() is not called: this doesn't update
|
|
|
|
// inset.top_baseline, so getCursor() returns an old value.
|
|
|
|
// Ugly as you like.
|
|
|
|
int bx, by;
|
|
|
|
inset->getCursorPos(&bv, bx, by);
|
|
|
|
by += inset->insetInInsetY() + bv.text->cursor.iy();
|
|
|
|
if (by < top_y)
|
|
|
|
return;
|
|
|
|
if (by > top_y + workarea().workHeight())
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
x = bv.text->cursor.x();
|
|
|
|
y = bv.text->cursor.y();
|
|
|
|
y -= top_y;
|
|
|
|
}
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2003-05-03 18:05:53 +00:00
|
|
|
y -= ascent;
|
|
|
|
|
|
|
|
// if it doesn't fit entirely on the screen, don't try to show it
|
|
|
|
if (y < 0 || y + h > workarea().workHeight())
|
|
|
|
return;
|
|
|
|
|
|
|
|
cursor_visible_ = true;
|
2003-06-03 19:32:08 +00:00
|
|
|
showCursor(x, y, h, shape);
|
2003-05-03 18:05:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LyXScreen::hideCursor()
|
|
|
|
{
|
|
|
|
if (!cursor_visible_)
|
|
|
|
return;
|
|
|
|
|
|
|
|
cursor_visible_ = false;
|
2003-06-03 19:32:08 +00:00
|
|
|
removeCursor();
|
2003-05-03 18:05:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LyXScreen::toggleCursor(BufferView & bv)
|
|
|
|
{
|
|
|
|
if (cursor_visible_)
|
|
|
|
hideCursor();
|
|
|
|
else
|
|
|
|
showCursor(bv);
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
bool LyXScreen::fitManualCursor(BufferView * bv, LyXText * text,
|
|
|
|
int /*x*/, int y, int asc, int desc)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2002-06-18 15:44:30 +00:00
|
|
|
int const vheight = workarea().workHeight();
|
2003-03-06 20:21:21 +00:00
|
|
|
int newtop = text->top_y();
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2003-03-06 20:21:21 +00:00
|
|
|
if (y + desc - text->top_y() >= vheight)
|
2002-06-18 15:44:30 +00:00
|
|
|
newtop = y - 3 * vheight / 4; // the scroll region must be so big!!
|
2003-03-06 20:21:21 +00:00
|
|
|
else if (y - asc < text->top_y()
|
|
|
|
&& text->top_y() > 0) {
|
2002-06-18 15:44:30 +00:00
|
|
|
newtop = y - vheight / 4;
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
2000-05-20 21:37:05 +00:00
|
|
|
|
2000-09-29 18:44:07 +00:00
|
|
|
newtop = max(newtop, 0); // can newtop ever be < 0? (Lgb)
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2003-03-06 20:21:21 +00:00
|
|
|
if (newtop != text->top_y()) {
|
2001-07-04 07:19:09 +00:00
|
|
|
draw(text, bv, newtop);
|
2003-03-06 20:21:21 +00:00
|
|
|
text->top_y(newtop);
|
2000-04-26 13:57:28 +00:00
|
|
|
return true;
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
2002-12-03 09:57:59 +00:00
|
|
|
|
2000-04-26 13:57:28 +00:00
|
|
|
return false;
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-06-27 08:38:41 +00:00
|
|
|
unsigned int LyXScreen::topCursorVisible(LyXText * text)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2003-06-27 08:38:41 +00:00
|
|
|
LyXCursor const & cursor = text->cursor;
|
|
|
|
int top_y = text->top_y();
|
2002-06-18 15:44:30 +00:00
|
|
|
int newtop = top_y;
|
2003-06-27 08:38:41 +00:00
|
|
|
int const vheight = workarea().workHeight();
|
1999-09-27 18:44:28 +00:00
|
|
|
|
2003-06-27 08:38:41 +00:00
|
|
|
RowList::iterator row = text->cursorRow();
|
2001-12-28 21:52:59 +00:00
|
|
|
|
2003-04-01 10:10:28 +00:00
|
|
|
#warning SUPER HACK DISABLED (Lgb)
|
|
|
|
#if 0
|
2001-12-28 21:52:59 +00:00
|
|
|
// Is this a hack? Yes, probably... (Lgb)
|
|
|
|
if (!row)
|
|
|
|
return max(newtop, 0);
|
2003-04-01 10:10:28 +00:00
|
|
|
#endif
|
2002-07-04 17:45:35 +00:00
|
|
|
if (cursor.y() - row->baseline() + row->height() - top_y >= vheight) {
|
2002-06-12 10:31:34 +00:00
|
|
|
if (row->height() < vheight
|
|
|
|
&& row->height() > vheight / 4) {
|
|
|
|
newtop = cursor.y()
|
2001-12-28 21:52:59 +00:00
|
|
|
+ row->height()
|
2002-06-12 10:31:34 +00:00
|
|
|
- row->baseline() - vheight;
|
2001-12-02 23:20:56 +00:00
|
|
|
} else {
|
2003-06-27 08:38:41 +00:00
|
|
|
// scroll down, the scroll region must be so big!!
|
2003-06-30 23:56:22 +00:00
|
|
|
newtop = cursor.y() - vheight / 2;
|
2001-12-02 23:20:56 +00:00
|
|
|
}
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
} else if (static_cast<int>((cursor.y()) - row->baseline()) <
|
2002-06-12 10:31:34 +00:00
|
|
|
top_y && top_y > 0) {
|
|
|
|
if (row->height() < vheight
|
|
|
|
&& row->height() > vheight / 4) {
|
|
|
|
newtop = cursor.y() - row->baseline();
|
2001-12-02 23:20:56 +00:00
|
|
|
} else {
|
|
|
|
// scroll up
|
2002-06-12 10:31:34 +00:00
|
|
|
newtop = cursor.y() - vheight / 2;
|
|
|
|
newtop = min(newtop, top_y);
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
}
|
2000-05-20 21:37:05 +00:00
|
|
|
|
2000-09-29 18:44:07 +00:00
|
|
|
newtop = max(newtop, 0);
|
2000-04-26 13:57:28 +00:00
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
return newtop;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
bool LyXScreen::fitCursor(LyXText * text, BufferView * bv)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2000-04-26 13:57:28 +00:00
|
|
|
// Is a change necessary?
|
2003-06-27 08:38:41 +00:00
|
|
|
int const newtop = topCursorVisible(text);
|
2003-03-06 20:21:21 +00:00
|
|
|
bool const result = (newtop != text->top_y());
|
2002-12-03 09:57:59 +00:00
|
|
|
if (result) {
|
2001-07-04 07:19:09 +00:00
|
|
|
draw(text, bv, newtop);
|
2002-12-03 09:57:59 +00:00
|
|
|
}
|
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2003-03-17 01:34:36 +00:00
|
|
|
void LyXScreen::update(BufferView & bv, int yo, int xo)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2003-03-17 01:34:36 +00:00
|
|
|
LyXText * text = bv.text;
|
2002-06-18 15:44:30 +00:00
|
|
|
|
|
|
|
workarea().getPainter().start();
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2003-07-15 11:08:02 +00:00
|
|
|
if (text->needRefresh()) {
|
|
|
|
int const vwidth = workarea().workWidth();
|
|
|
|
int const vheight = workarea().workHeight();
|
2003-04-12 23:03:05 +00:00
|
|
|
text->updateRowPositions();
|
2003-07-15 16:25:02 +00:00
|
|
|
int const y = 0;
|
2003-03-17 01:34:36 +00:00
|
|
|
drawFromTo(text, &bv, y, vheight, yo, xo);
|
2002-06-18 15:44:30 +00:00
|
|
|
expose(0, y, vwidth, vheight - y);
|
2000-04-26 13:57:28 +00:00
|
|
|
}
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
workarea().getPainter().end();
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
void LyXScreen::toggleSelection(LyXText * text, BufferView * bv,
|
2001-01-02 16:06:14 +00:00
|
|
|
bool kill_selection,
|
2002-06-18 15:44:30 +00:00
|
|
|
int yo, int xo)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2000-05-20 21:37:05 +00:00
|
|
|
// only if there is a selection
|
2001-05-31 02:23:46 +00:00
|
|
|
if (!text->selection.set()) return;
|
1999-12-16 06:43:25 +00:00
|
|
|
|
2000-11-21 15:46:13 +00:00
|
|
|
int const bottom = min(
|
2001-05-31 02:23:46 +00:00
|
|
|
max(static_cast<int>(text->selection.end.y()
|
2003-06-27 08:38:41 +00:00
|
|
|
- text->getRow(text->selection.end)->baseline()
|
|
|
|
+ text->getRow(text->selection.end)->height()),
|
2003-03-06 20:21:21 +00:00
|
|
|
text->top_y()),
|
|
|
|
static_cast<int>(text->top_y() + workarea().workHeight()));
|
2000-11-21 15:46:13 +00:00
|
|
|
int const top = min(
|
2001-05-31 02:23:46 +00:00
|
|
|
max(static_cast<int>(text->selection.start.y() -
|
2003-06-27 08:38:41 +00:00
|
|
|
text->getRow(text->selection.start)->baseline()),
|
2003-03-06 20:21:21 +00:00
|
|
|
text->top_y()),
|
|
|
|
static_cast<int>(text->top_y() + workarea().workHeight()));
|
2000-02-18 22:22:42 +00:00
|
|
|
|
2000-02-17 19:59:08 +00:00
|
|
|
if (kill_selection)
|
2001-05-31 02:23:46 +00:00
|
|
|
text->selection.set(false);
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
workarea().getPainter().start();
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2003-03-06 20:21:21 +00:00
|
|
|
drawFromTo(text, bv, top - text->top_y(), bottom - text->top_y(),
|
2002-06-18 15:44:30 +00:00
|
|
|
yo, xo);
|
2003-03-06 20:21:21 +00:00
|
|
|
expose(0, top - text->top_y(),
|
2002-06-18 15:44:30 +00:00
|
|
|
workarea().workWidth(),
|
2003-03-06 20:21:21 +00:00
|
|
|
bottom - text->top_y() - (top - text->top_y()));
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
workarea().getPainter().end();
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
2002-06-24 20:28:12 +00:00
|
|
|
|
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
void LyXScreen::toggleToggle(LyXText * text, BufferView * bv,
|
|
|
|
int yo, int xo)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2000-06-08 23:16:16 +00:00
|
|
|
if (text->toggle_cursor.par() == text->toggle_end_cursor.par()
|
|
|
|
&& text->toggle_cursor.pos() == text->toggle_end_cursor.pos())
|
1999-09-27 18:44:28 +00:00
|
|
|
return;
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2000-11-21 15:46:13 +00:00
|
|
|
int const top_tmp = text->toggle_cursor.y()
|
2003-06-27 08:38:41 +00:00
|
|
|
- text->getRow(text->toggle_cursor)->baseline();
|
2000-11-21 15:46:13 +00:00
|
|
|
int const bottom_tmp = text->toggle_end_cursor.y()
|
2003-06-27 08:38:41 +00:00
|
|
|
- text->getRow(text->toggle_end_cursor)->baseline()
|
|
|
|
+ text->getRow(text->toggle_end_cursor)->height();
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
int const offset = yo < 0 ? yo : 0;
|
2003-03-06 20:21:21 +00:00
|
|
|
int const bottom = min(max(bottom_tmp, text->top_y()),
|
|
|
|
static_cast<int>(text->top_y() + workarea().workHeight())) - offset;
|
|
|
|
int const top = min(max(top_tmp, text->top_y()),
|
|
|
|
static_cast<int>(text->top_y() + workarea().workHeight())) - offset;
|
2002-06-18 15:44:30 +00:00
|
|
|
|
|
|
|
workarea().getPainter().start();
|
2002-04-05 15:17:24 +00:00
|
|
|
|
2003-03-22 17:26:03 +00:00
|
|
|
drawFromTo(text, bv, top - text->top_y(), bottom - text->top_y(), yo, xo);
|
2003-03-06 20:21:21 +00:00
|
|
|
expose(0, top - text->top_y(), workarea().workWidth(),
|
|
|
|
bottom - text->top_y() - (top - text->top_y()));
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
workarea().getPainter().end();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LyXScreen::redraw(LyXText * text, BufferView * bv)
|
|
|
|
{
|
2003-02-26 12:49:01 +00:00
|
|
|
greyed_out_ = !text;
|
|
|
|
|
|
|
|
if (greyed_out_) {
|
2002-06-18 15:44:30 +00:00
|
|
|
greyOut();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2003-02-27 09:39:24 +00:00
|
|
|
workarea().getPainter().start();
|
|
|
|
|
2003-04-17 08:07:07 +00:00
|
|
|
text->updateRowPositions();
|
2003-03-22 17:26:03 +00:00
|
|
|
drawFromTo(text, bv, 0, workarea().workHeight(), 0, 0);
|
2002-06-18 15:44:30 +00:00
|
|
|
expose(0, 0, workarea().workWidth(), workarea().workHeight());
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
workarea().getPainter().end();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LyXScreen::greyOut()
|
|
|
|
{
|
2003-02-26 12:49:01 +00:00
|
|
|
if (!greyed_out_)
|
|
|
|
return;
|
|
|
|
|
2003-02-27 09:39:24 +00:00
|
|
|
workarea().getPainter().start();
|
|
|
|
|
2002-06-18 15:44:30 +00:00
|
|
|
workarea().getPainter().fillRectangle(0, 0,
|
|
|
|
workarea().workWidth(),
|
|
|
|
workarea().workHeight(),
|
|
|
|
LColor::bottomarea);
|
2002-06-21 04:40:40 +00:00
|
|
|
|
|
|
|
// Add a splash screen to the centre of the work area
|
2002-06-25 15:59:10 +00:00
|
|
|
SplashScreen const & splash = SplashScreen::get();
|
2003-07-21 21:30:57 +00:00
|
|
|
lyx::graphics::Image const * const splash_image = splash.image();
|
2002-06-25 15:59:10 +00:00
|
|
|
if (splash_image) {
|
|
|
|
int const w = splash_image->getWidth();
|
|
|
|
int const h = splash_image->getHeight();
|
|
|
|
|
2002-07-04 17:45:35 +00:00
|
|
|
int x = (workarea().workWidth() - w) / 2;
|
|
|
|
int y = (workarea().workHeight() - h) / 2;
|
2002-06-21 17:16:35 +00:00
|
|
|
|
2002-06-25 15:59:10 +00:00
|
|
|
workarea().getPainter().image(x, y, w, h, *splash_image);
|
2002-06-21 17:16:35 +00:00
|
|
|
|
2002-06-25 15:59:10 +00:00
|
|
|
string const & splash_text = splash.text();
|
|
|
|
LyXFont const & splash_font = splash.font();
|
2002-07-04 17:45:35 +00:00
|
|
|
|
2002-06-25 15:59:10 +00:00
|
|
|
x += 260;
|
|
|
|
y += 265;
|
|
|
|
|
|
|
|
workarea().getPainter().text(x, y, splash_text, splash_font);
|
2002-06-21 17:16:35 +00:00
|
|
|
}
|
2003-02-26 12:49:01 +00:00
|
|
|
expose(0, 0, workarea().workWidth(), workarea().workHeight());
|
|
|
|
workarea().getPainter().end();
|
2002-06-18 15:44:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LyXScreen::drawFromTo(LyXText * text, BufferView * bv,
|
2003-03-22 17:26:03 +00:00
|
|
|
int y1, int y2, int yo, int xo)
|
2002-06-18 15:44:30 +00:00
|
|
|
{
|
2002-11-27 10:30:28 +00:00
|
|
|
lyxerr[Debug::GUI] << "screen: drawFromTo " << y1 << '-' << y2 << endl;
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2003-04-12 23:03:05 +00:00
|
|
|
int const topy = text->top_y();
|
|
|
|
int y_text = topy + y1;
|
|
|
|
RowList::iterator rit = text->getRowNearY(y_text);
|
|
|
|
int y = y_text - topy;
|
2002-06-18 15:44:30 +00:00
|
|
|
// y1 is now the real beginning of row on the screen
|
2002-06-24 20:28:12 +00:00
|
|
|
|
2003-05-03 18:05:53 +00:00
|
|
|
hideCursor();
|
|
|
|
|
2003-07-22 15:12:04 +00:00
|
|
|
#if 0
|
|
|
|
// some day it should look like that:
|
|
|
|
// redo metrics
|
|
|
|
Dimension dim;
|
|
|
|
LyXFont font;
|
|
|
|
MetricsInfo mi(bv, font, workarea().workWidth());
|
|
|
|
text->metrics(mi, dim);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// draw it
|
2003-04-12 23:03:05 +00:00
|
|
|
RowList::iterator const rend = text->rows().end();
|
2003-07-28 13:18:35 +00:00
|
|
|
int yf = y;
|
|
|
|
while (rit != rend && yf < y2) {
|
|
|
|
paintRows(*bv, *text, rit,
|
|
|
|
y + yo, xo, y + topy);
|
2003-04-12 23:03:05 +00:00
|
|
|
y += rit->height();
|
2003-07-28 13:18:35 +00:00
|
|
|
yf += rit->height();
|
2003-04-12 23:03:05 +00:00
|
|
|
++rit;
|
2002-06-18 15:44:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// maybe we have to clear the screen at the bottom
|
2003-03-17 16:25:00 +00:00
|
|
|
if ((y < y2) && !text->isInInset()) {
|
2002-06-18 15:44:30 +00:00
|
|
|
workarea().getPainter().fillRectangle(0, y,
|
|
|
|
workarea().workWidth(), y2 - y,
|
|
|
|
LColor::bottomarea);
|
|
|
|
}
|
|
|
|
}
|