X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffrontends%2Fscreen.C;h=d7a1f34e55dad26386c26ecefe6c9f32f52c53dc;hb=36945644e70db39a8316570bb44fabc7a3bd3d49;hp=3322d112f5f1f75990f6e410e4624d6235d5d5a9;hpb=1cadf458e39eed9570f13ebe0a1223a4fe7c282b;p=lyx.git diff --git a/src/frontends/screen.C b/src/frontends/screen.C index 3322d112f5..d7a1f34e55 100644 --- a/src/frontends/screen.C +++ b/src/frontends/screen.C @@ -1,354 +1,257 @@ /** * \file screen.C - * Copyright 2002 the LyX Team - * Read the file COPYING + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * \author John Levon + * \author John Levon + * + * Full author contact details are available in file CREDITS. + * + * Splash screen code added by Angus Leeming */ -#ifdef __GNUG__ -#pragma implementation -#endif - #include #include "screen.h" -#include "lyxtext.h" -#include "lyxrow.h" +#include "font_metrics.h" +#include "lyx_gui.h" +#include "Painter.h" +#include "WorkArea.h" + #include "BufferView.h" #include "buffer.h" -#include "WorkArea.h" -#include "Painter.h" -#include "font_metrics.h" -#include "language.h" +#include "bufferparams.h" +#include "coordcache.h" +#include "cursor.h" #include "debug.h" +#include "language.h" +#include "LColor.h" +#include "lyxfont.h" +#include "lyxrc.h" +#include "lyxrow.h" +#include "lyxtext.h" +#include "metricsinfo.h" +#include "paragraph.h" +#include "rowpainter.h" +#include "version.h" + +#include "graphics/GraphicsImage.h" +#include "graphics/GraphicsLoader.h" + +#include "support/filetools.h" // LibFileSearch +#include +#include +#include + +using lyx::support::LibFileSearch; + +using std::endl; using std::min; using std::max; -using std::endl; - -LyXScreen::LyXScreen() - : force_clear_(true), cursor_visible_(false) -{ -} +using std::string; + + +namespace { + +class SplashScreen : boost::noncopyable, boost::signals::trackable { +public: + /// This is a singleton class. Get the instance. + static SplashScreen const & get(); + /// + lyx::graphics::Image const * image() const { return loader_.image(); } + /// + string const & text() const { return text_; } + /// + LyXFont const & font() const { return font_; } + /// + void connect(lyx::graphics::Loader::slot_type const & slot) const { + loader_.connect(slot); + } + /// + void startLoading() const { + if (loader_.status() == lyx::graphics::WaitingToLoad) + loader_.startLoading(); + } +private: + /** Make the c-tor private so we can control how many objects + * are instantiated. + */ + SplashScreen(); -LyXScreen::~LyXScreen() + /// + lyx::graphics::Loader loader_; + /// 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; } -// FIXME: GUII these cursor methods need to decide -// whether the workarea is focused or not -void LyXScreen::showCursor(LyXText const * text, BufferView const * bv) +SplashScreen::SplashScreen() + : text_(lyx_version ? lyx_version : "unknown") { - if (cursor_visible_) + if (!lyxrc.show_banner) return; - - workarea().getPainter().start(); - - Cursor_Shape shape = BAR_SHAPE; - BufferParams const & bp(bv->buffer()->params); - LyXFont const & realfont(text->real_current_font); - - if (realfont.language() != bp.language - || realfont.isVisibleRightToLeft() - != bp.language->RightToLeft()) { - shape = (realfont.isVisibleRightToLeft()) - ? REVERSED_L_SHAPE : L_SHAPE; - } - - showManualCursor(text, text->cursor.x(), text->cursor.y(), - font_metrics::maxAscent(realfont), - font_metrics::maxDescent(realfont), - shape); - - workarea().getPainter().end(); + + string const file = LibFileSearch("images", "banner", "ppm"); + 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 + loader_.reset(file); } +} // namespace anon -bool LyXScreen::fitManualCursor(BufferView * bv, LyXText * text, - int /*x*/, int y, int asc, int desc) + +LyXScreen::LyXScreen() + : greyed_out_(true), cursor_visible_(false) { - int const vheight = workarea().workHeight(); - int newtop = text->first_y; - - if (y + desc - text->first_y >= vheight) - newtop = y - 3 * vheight / 4; // the scroll region must be so big!! - else if (y - asc < text->first_y - && text->first_y > 0) { - newtop = y - vheight / 4; + // Start loading the pixmap as soon as possible + if (lyxrc.show_banner) { + SplashScreen const & splash = SplashScreen::get(); + splash.connect(boost::bind(&LyXScreen::checkAndGreyOut, this)); + splash.startLoading(); } +} - newtop = max(newtop, 0); // can newtop ever be < 0? (Lgb) - - if (newtop != text->first_y) { - draw(text, bv, newtop); - text->first_y = newtop; - return true; - } - return false; + +LyXScreen::~LyXScreen() +{ } -void LyXScreen::cursorToggle(BufferView * bv) const +void LyXScreen::checkAndGreyOut() { - if (cursor_visible_) - bv->hideCursor(); - else - bv->showCursor(); + if (greyed_out_) + greyOut(); } -unsigned int LyXScreen::topCursorVisible(LyXCursor const & cursor, int top_y) +void LyXScreen::showCursor(BufferView & bv) { - int const vheight = workarea().workHeight(); - int newtop = top_y; - - Row * row = cursor.row(); - - // Is this a hack? Yes, probably... (Lgb) - if (!row) - return max(newtop, 0); - - if (cursor.y() - row->baseline() + row->height() - - top_y >= vheight) { - if (row->height() < vheight - && row->height() > vheight / 4) { - newtop = cursor.y() - + row->height() - - row->baseline() - vheight; - } else { - // scroll down - newtop = cursor.y() - - vheight / 2; /* the scroll region must be so big!! */ - } - - } else if (static_cast((cursor.y()) - row->baseline()) < - top_y && top_y > 0) { - if (row->height() < vheight - && row->height() > vheight / 4) { - newtop = cursor.y() - row->baseline(); - } else { - // scroll up - newtop = cursor.y() - vheight / 2; - newtop = min(newtop, top_y); - } - } + if (cursor_visible_) + return; + + if (!bv.available()) + return; - newtop = max(newtop, 0); + Cursor_Shape shape = BAR_SHAPE; - return newtop; -} + LyXText const & text = *bv.getLyXText(); + LyXFont const & realfont = text.real_current_font; + BufferParams const & bp = bv.buffer()->params(); + 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; + } -bool LyXScreen::fitCursor(LyXText * text, BufferView * bv) -{ - // Is a change necessary? - int const newtop = topCursorVisible(text->cursor, text->first_y); - bool const result = (newtop != text->first_y); - if (result) - draw(text, bv, newtop); - return result; + // The ERT language hack needs fixing up + if (realfont.language() == latex_language) + shape = BAR_SHAPE; + + LyXFont const font = bv.cursor().getFont(); + int const asc = font_metrics::maxAscent(font); + int const des = font_metrics::maxDescent(font); + int h = asc + des; + int x = 0; + int y = 0; + bv.cursor().getPos(x, y); + y -= asc; + //lyxerr << "LyXScreen::showCursor x: " << x << " y: " << y << endl; + + // if it doesn't touch the screen, don't try to show it + if (y + h < 0 || y >= workarea().workHeight()) + return; + + cursor_visible_ = true; + showCursor(x, y, h, shape); } - -void LyXScreen::update(LyXText * text, BufferView * bv, - int yo, int xo) + +void LyXScreen::hideCursor() { - int const vwidth = workarea().workWidth(); - int const vheight = workarea().workHeight(); + if (!cursor_visible_) + return; - workarea().getPainter().start(); - - switch (text->status()) { - case LyXText::NEED_MORE_REFRESH: - { - int const y = max(int(text->refresh_y - text->first_y), 0); - drawFromTo(text, bv, y, vheight, yo, xo); - text->refresh_y = 0; - // otherwise this is called ONLY from BufferView_pimpl(update) - // or we should see to set this flag accordingly - if (text != bv->text) - text->status(bv, LyXText::UNCHANGED); - expose(0, y, vwidth, vheight - y); - } - break; - case LyXText::NEED_VERY_LITTLE_REFRESH: - { - // ok I will update the current cursor row - drawOneRow(text, bv, text->refresh_row, text->refresh_y, - yo, xo); - // this because if we had a major update the refresh_row could - // have been set to 0! - if (text->refresh_row) { - // otherwise this is called ONLY from BufferView_pimpl(update) - // or we should see to set this flag accordingly - if (text != bv->text) - text->status(bv, LyXText::UNCHANGED); - expose(0, text->refresh_y - text->first_y + yo, - vwidth, text->refresh_row->height()); - } - } - break; - case LyXText::CHANGED_IN_DRAW: // just to remove the warning - case LyXText::UNCHANGED: - // Nothing needs done - break; - } - - workarea().getPainter().end(); + cursor_visible_ = false; + removeCursor(); } -void LyXScreen::toggleSelection(LyXText * text, BufferView * bv, - bool kill_selection, - int yo, int xo) +void LyXScreen::toggleCursor(BufferView & bv) { - // only if there is a selection - if (!text->selection.set()) return; - - int const bottom = min( - max(static_cast(text->selection.end.y() - - text->selection.end.row()->baseline() - + text->selection.end.row()->height()), - text->first_y), - static_cast(text->first_y + workarea().workHeight())); - int const top = min( - max(static_cast(text->selection.start.y() - - text->selection.start.row()->baseline()), - text->first_y), - static_cast(text->first_y + workarea().workHeight())); - - if (kill_selection) - text->selection.set(false); - - workarea().getPainter().start(); - - drawFromTo(text, bv, top - text->first_y, bottom - text->first_y, - yo, xo); - expose(0, top - text->first_y, - workarea().workWidth(), - bottom - text->first_y - (top - text->first_y)); - - workarea().getPainter().end(); + if (cursor_visible_) + hideCursor(); + else + showCursor(bv); } - - -void LyXScreen::toggleToggle(LyXText * text, BufferView * bv, - int yo, int xo) -{ - if (text->toggle_cursor.par() == text->toggle_end_cursor.par() - && text->toggle_cursor.pos() == text->toggle_end_cursor.pos()) - return; - - int const top_tmp = text->toggle_cursor.y() - - text->toggle_cursor.row()->baseline(); - int const bottom_tmp = text->toggle_end_cursor.y() - - text->toggle_end_cursor.row()->baseline() - + text->toggle_end_cursor.row()->height(); - - int const offset = yo < 0 ? yo : 0; - int const bottom = min(max(bottom_tmp, text->first_y), - static_cast(text->first_y + workarea().workHeight())) - offset; - int const top = min(max(top_tmp, text->first_y), - static_cast(text->first_y + workarea().workHeight())) - offset; - workarea().getPainter().start(); - drawFromTo(text, bv, top - text->first_y, - bottom - text->first_y, yo, - xo); - expose(0, top - text->first_y, workarea().workWidth(), - bottom - text->first_y - (top - text->first_y)); - - workarea().getPainter().end(); +void LyXScreen::prepareCursor() +{ + cursor_visible_ = false; } -void LyXScreen::redraw(LyXText * text, BufferView * bv) +void LyXScreen::redraw(BufferView & bv, ViewMetricsInfo const & vi) { + greyed_out_ = false; workarea().getPainter().start(); - - if (!text) { - greyOut(); - expose(0, 0, workarea().workWidth(), workarea().workHeight()); - workarea().getPainter().end(); - return; - } - - drawFromTo(text, bv, 0, workarea().workHeight(), 0, 0, text == bv->text); + paintText(bv, vi); + lyxerr[Debug::DEBUG] << "Redraw screen" << endl; expose(0, 0, workarea().workWidth(), workarea().workHeight()); - workarea().getPainter().end(); - - if (cursor_visible_) { - cursor_visible_ = false; - bv->showCursor(); - } - + theCoords.doneUpdating(); } void LyXScreen::greyOut() { + greyed_out_ = true; + workarea().getPainter().start(); + workarea().getPainter().fillRectangle(0, 0, workarea().workWidth(), workarea().workHeight(), LColor::bottomarea); -} + // Add a splash screen to the centre of the work area + SplashScreen const & splash = SplashScreen::get(); + lyx::graphics::Image const * const splash_image = splash.image(); + if (splash_image) { + int const w = splash_image->getWidth(); + int const h = splash_image->getHeight(); -void LyXScreen::drawFromTo(LyXText * text, BufferView * bv, - int y1, int y2, int yo, int xo, - bool internal) -{ - lyxerr[Debug::GUI] << "screen: drawFromTo " << y1 << "-" << y2 << endl; - - int y_text = text->first_y + y1; - - // get the first needed row - Row * row = text->getRowNearY(y_text); - // y_text is now the real beginning of the row - - int y = y_text - text->first_y; - // y1 is now the real beginning of row on the screen - - while (row != 0 && y < y2) { - LyXText::text_status st = text->status(); - text->getVisibleRow(bv, y + yo, - xo, row, y + text->first_y); - internal = internal && (st != LyXText::CHANGED_IN_DRAW); - while (internal && text->status() == LyXText::CHANGED_IN_DRAW) { - text->fullRebreak(bv); - st = LyXText::NEED_MORE_REFRESH; - text->setCursor(bv, text->cursor.par(), text->cursor.pos()); - text->status(bv, st); - text->getVisibleRow(bv, y + yo, - xo, row, y + text->first_y); - } - y += row->height(); - row = row->next(); - } - force_clear_ = false; - - // maybe we have to clear the screen at the bottom - if ((y < y2) && text->bv_owner) { - workarea().getPainter().fillRectangle(0, y, - workarea().workWidth(), y2 - y, - LColor::bottomarea); - } -} + int x = (workarea().workWidth() - w) / 2; + int y = (workarea().workHeight() - h) / 2; + workarea().getPainter().image(x, y, w, h, *splash_image); -void LyXScreen::drawOneRow(LyXText * text, BufferView * bv, Row * row, - int y_text, int yo, int xo) -{ - int const y = y_text - text->first_y + yo; + x += 260; + y += 265; - if (((y + row->height()) > 0) && - ((y - row->height()) <= static_cast(workarea().workHeight()))) { - text->getVisibleRow(bv, y, xo, row, y + text->first_y); + workarea().getPainter().text(x, y, splash.text(), splash.font()); } - force_clear_ = false; + expose(0, 0, workarea().workWidth(), workarea().workHeight()); + workarea().getPainter().end(); }