src/frontends/screen.C

   1 /**
   2  * \file screen.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author John Levon
   7  *
   8  * Full author contact details are available in file CREDITS
   9  *
  10  * Splash screen code added by Angus Leeming
  11  */
  12
  13
  14 #include <config.h>
  15
  16 #include "screen.h"
  17 #include "lyxtext.h"
  18 #include "lyxrc.h"
  19 #include "lyxrow.h"
  20 #include "BufferView.h"
  21 #include "buffer.h"
  22 #include "WorkArea.h"
  23 #include "Painter.h"
  24 #include "font_metrics.h"
  25 #include "language.h"
  26 #include "debug.h"
  27 #include "rowpainter.h"
  28
  29 // Splash screen-specific stuff
  30 #include "lyxfont.h"
  31 #include "version.h"
  32
  33 #include "graphics/GraphicsLoader.h"
  34 #include "graphics/GraphicsImage.h"
  35
  36 #include "support/filetools.h" // LibFileSearch
  37
  38 #include <boost/utility.hpp>
  39 #include <boost/bind.hpp>
  40 #include <boost/signals/trackable.hpp>
  41
  42 using std::min;
  43 using std::max;
  44 using std::endl;
  45
  46 namespace {
  47
  48 class SplashScreen : boost::noncopyable, boost::signals::trackable {
  49 public:
  50         /// This is a singleton class. Get the instance.
  51         static SplashScreen const & get();
  52         ///
  53         grfx::Image const * image() const { return loader_.image(); }
  54         ///
  55         string const & text() const { return text_; }
  56         ///
  57         LyXFont const & font() const { return font_; }
  58         ///
  59         void connect(grfx::Loader::slot_type const & slot) const {
  60                 loader_.connect(slot);
  61         }
  62         ///
  63         void startLoading() const {
  64                 if (loader_.status() == grfx::WaitingToLoad)
  65                         loader_.startLoading();
  66         }
  67
  68 private:
  69         /** Make the c-tor private so we can control how many objects
  70          *  are instantiated.
  71          */
  72         SplashScreen();
  73
  74         ///
  75         grfx::Loader loader_;
  76         /// The text to be written on top of the pixmap
  77         string const text_;
  78         /// in this font...
  79         LyXFont font_;
  80 };
  81
  82
  83 SplashScreen const & SplashScreen::get()
  84 {
  85         static SplashScreen singleton;
  86         return singleton;
  87 }
  88
  89
  90 SplashScreen::SplashScreen()
  91         : text_(lyx_version ? lyx_version : "unknown")
  92 {
  93         if (!lyxrc.show_banner)
  94                 return;
  95
  96         string const file = LibFileSearch("images", "banner", "ppm");
  97         if (file.empty())
  98                 return;
  99
 100         // The font used to display the version info
 101         font_.setFamily(LyXFont::SANS_FAMILY);
 102         font_.setSeries(LyXFont::BOLD_SERIES);
 103         font_.setSize(LyXFont::SIZE_NORMAL);
 104         font_.setColor(LColor::yellow);
 105
 106         // Load up the graphics file
 107         loader_.reset(file);
 108 }
 109
 110 } // namespace anon
 111
 112
 113 LyXScreen::LyXScreen()
 114         : cursor_visible_(false), greyed_out_(true)
 115 {
 116         // Start loading the pixmap as soon as possible
 117         if (lyxrc.show_banner) {
 118                 SplashScreen const & splash = SplashScreen::get();
 119                 splash.connect(boost::bind(&LyXScreen::greyOut, this));
 120                 splash.startLoading();
 121         }
 122 }
 123
 124
 125 LyXScreen::~LyXScreen()
 126 {
 127 }
 128
 129 // FIXME: GUII these cursor methods need to decide
 130 // whether the workarea is focused or not
 131
 132 void LyXScreen::showCursor(LyXText const * text, BufferView const * bv)
 133 {
 134         if (cursor_visible_)
 135                 return;
 136
 137         workarea().getPainter().start();
 138
 139         Cursor_Shape shape = BAR_SHAPE;
 140         BufferParams const & bp(bv->buffer()->params);
 141         LyXFont const & realfont(text->real_current_font);
 142
 143         if (realfont.language() != bp.language
 144                 || realfont.isVisibleRightToLeft()
 145                 != bp.language->RightToLeft()) {
 146                 shape = (realfont.isVisibleRightToLeft())
 147                         ? REVERSED_L_SHAPE : L_SHAPE;
 148         }
 149
 150         showManualCursor(text, text->cursor.x(), text->cursor.y(),
 151                 font_metrics::maxAscent(realfont),
 152                 font_metrics::maxDescent(realfont),
 153                 shape);
 154
 155         workarea().getPainter().end();
 156 }
 157
 158
 159 bool LyXScreen::fitManualCursor(BufferView * bv, LyXText * text,
 160         int /*x*/, int y, int asc, int desc)
 161 {
 162         int const vheight = workarea().workHeight();
 163         int newtop = text->top_y();
 164
 165         if (y + desc - text->top_y() >= vheight)
 166                 newtop = y - 3 * vheight / 4;  // the scroll region must be so big!!
 167         else if (y - asc < text->top_y()
 168                 && text->top_y() > 0) {
 169                 newtop = y - vheight / 4;
 170         }
 171
 172         newtop = max(newtop, 0); // can newtop ever be < 0? (Lgb)
 173
 174         if (newtop != text->top_y()) {
 175                 draw(text, bv, newtop);
 176                 text->top_y(newtop);
 177                 return true;
 178         }
 179
 180         return false;
 181 }
 182
 183
 184 void LyXScreen::cursorToggle(BufferView * bv) const
 185 {
 186         if (cursor_visible_)
 187                 bv->hideCursor();
 188         else
 189                 bv->showCursor();
 190 }
 191
 192
 193 unsigned int LyXScreen::topCursorVisible(LyXCursor const & cursor, int top_y)
 194 {
 195         int const vheight = workarea().workHeight();
 196         int newtop = top_y;
 197
 198         RowList::iterator row = cursor.row();
 199
 200 #warning SUPER HACK DISABLED (Lgb)
 201 #if 0
 202         // Is this a hack? Yes, probably... (Lgb)
 203         if (!row)
 204                 return max(newtop, 0);
 205 #endif
 206         if (cursor.y() - row->baseline() + row->height() - top_y >= vheight) {
 207                 if (row->height() < vheight
 208                     && row->height() > vheight / 4) {
 209                         newtop = cursor.y()
 210                                 + row->height()
 211                                 - row->baseline() - vheight;
 212                 } else {
 213                         // scroll down
 214                         newtop = cursor.y()
 215                                 - vheight / 2;   /* the scroll region must be so big!! */
 216                 }
 217
 218         } else if (static_cast<int>((cursor.y()) - row->baseline()) <
 219                    top_y && top_y > 0) {
 220                 if (row->height() < vheight
 221                     && row->height() > vheight / 4) {
 222                         newtop = cursor.y() - row->baseline();
 223                 } else {
 224                         // scroll up
 225                         newtop = cursor.y() - vheight / 2;
 226                         newtop = min(newtop, top_y);
 227                 }
 228         }
 229
 230         newtop = max(newtop, 0);
 231
 232         return newtop;
 233 }
 234
 235
 236 bool LyXScreen::fitCursor(LyXText * text, BufferView * bv)
 237 {
 238         // Is a change necessary?
 239         int const newtop = topCursorVisible(text->cursor, text->top_y());
 240         bool const result = (newtop != text->top_y());
 241         if (result) {
 242                 draw(text, bv, newtop);
 243         }
 244
 245         return result;
 246 }
 247
 248
 249 void LyXScreen::update(BufferView & bv, int yo, int xo)
 250 {
 251         int const vwidth = workarea().workWidth();
 252         int const vheight = workarea().workHeight();
 253         LyXText * text = bv.text;
 254
 255         workarea().getPainter().start();
 256
 257         switch (text->refreshStatus()) {
 258         case LyXText::REFRESH_AREA:
 259         {
 260                 int const y = max(int(text->refresh_y - text->top_y()), 0);
 261                 drawFromTo(text, &bv, y, vheight, yo, xo);
 262                 expose(0, y, vwidth, vheight - y);
 263         }
 264         break;
 265         case LyXText::REFRESH_ROW:
 266         {
 267                 // ok I will update the current cursor row
 268                 drawOneRow(text, &bv, text->refresh_row, text->refresh_y,
 269                            yo, xo);
 270                 // this because if we had a major update the refresh_row could
 271                 // have been set to 0!
 272                 if (text->refresh_row != text->rows().end()) {
 273                         expose(0, text->refresh_y - text->top_y() + yo,
 274                                    vwidth, text->refresh_row->height());
 275                 }
 276         }
 277         break;
 278         case LyXText::REFRESH_NONE:
 279                 // Nothing needs done
 280                 break;
 281         }
 282
 283         workarea().getPainter().end();
 284 }
 285
 286
 287 void LyXScreen::toggleSelection(LyXText * text, BufferView * bv,
 288                                 bool kill_selection,
 289                                 int yo, int xo)
 290 {
 291         // only if there is a selection
 292         if (!text->selection.set()) return;
 293
 294         int const bottom = min(
 295                 max(static_cast<int>(text->selection.end.y()
 296                                      - text->selection.end.row()->baseline()
 297                                      + text->selection.end.row()->height()),
 298                     text->top_y()),
 299                 static_cast<int>(text->top_y() + workarea().workHeight()));
 300         int const top = min(
 301                 max(static_cast<int>(text->selection.start.y() -
 302                                      text->selection.start.row()->baseline()),
 303                     text->top_y()),
 304                 static_cast<int>(text->top_y() + workarea().workHeight()));
 305
 306         if (kill_selection)
 307                 text->selection.set(false);
 308
 309         workarea().getPainter().start();
 310
 311         drawFromTo(text, bv, top - text->top_y(), bottom - text->top_y(),
 312                    yo, xo);
 313         expose(0, top - text->top_y(),
 314                workarea().workWidth(),
 315                bottom - text->top_y() - (top - text->top_y()));
 316
 317         workarea().getPainter().end();
 318 }
 319
 320
 321 void LyXScreen::toggleToggle(LyXText * text, BufferView * bv,
 322                              int yo, int xo)
 323 {
 324         if (text->toggle_cursor.par() == text->toggle_end_cursor.par()
 325             && text->toggle_cursor.pos() == text->toggle_end_cursor.pos())
 326                 return;
 327
 328         int const top_tmp = text->toggle_cursor.y()
 329                 - text->toggle_cursor.row()->baseline();
 330         int const bottom_tmp = text->toggle_end_cursor.y()
 331                 - text->toggle_end_cursor.row()->baseline()
 332                 + text->toggle_end_cursor.row()->height();
 333
 334         int const offset = yo < 0 ? yo : 0;
 335         int const bottom = min(max(bottom_tmp, text->top_y()),
 336                 static_cast<int>(text->top_y() + workarea().workHeight())) - offset;
 337         int const top = min(max(top_tmp, text->top_y()),
 338                 static_cast<int>(text->top_y() + workarea().workHeight())) - offset;
 339
 340         workarea().getPainter().start();
 341
 342         drawFromTo(text, bv, top - text->top_y(), bottom - text->top_y(), yo, xo);
 343         expose(0, top - text->top_y(), workarea().workWidth(),
 344                bottom - text->top_y() - (top - text->top_y()));
 345
 346         workarea().getPainter().end();
 347 }
 348
 349
 350 void LyXScreen::redraw(LyXText * text, BufferView * bv)
 351 {
 352         greyed_out_ = !text;
 353
 354         if (greyed_out_) {
 355                 greyOut();
 356                 return;
 357         }
 358
 359         workarea().getPainter().start();
 360
 361         drawFromTo(text, bv, 0, workarea().workHeight(), 0, 0);
 362         expose(0, 0, workarea().workWidth(), workarea().workHeight());
 363
 364         workarea().getPainter().end();
 365
 366         if (cursor_visible_) {
 367                 cursor_visible_ = false;
 368                 bv->showCursor();
 369         }
 370 }
 371
 372
 373 void LyXScreen::greyOut()
 374 {
 375         if (!greyed_out_)
 376                 return;
 377
 378         workarea().getPainter().start();
 379
 380         workarea().getPainter().fillRectangle(0, 0,
 381                 workarea().workWidth(),
 382                 workarea().workHeight(),
 383                 LColor::bottomarea);
 384
 385         // Add a splash screen to the centre of the work area
 386         SplashScreen const & splash = SplashScreen::get();
 387         grfx::Image const * const splash_image = splash.image();
 388         if (splash_image) {
 389                 int const w = splash_image->getWidth();
 390                 int const h = splash_image->getHeight();
 391
 392                 int x = (workarea().workWidth() - w) / 2;
 393                 int y = (workarea().workHeight() - h) / 2;
 394
 395                 workarea().getPainter().image(x, y, w, h, *splash_image);
 396
 397                 string const & splash_text  = splash.text();
 398                 LyXFont const & splash_font = splash.font();
 399
 400                 x += 260;
 401                 y += 265;
 402
 403                 workarea().getPainter().text(x, y, splash_text, splash_font);
 404         }
 405         expose(0, 0, workarea().workWidth(), workarea().workHeight());
 406         workarea().getPainter().end();
 407 }
 408
 409
 410 void LyXScreen::drawFromTo(LyXText * text, BufferView * bv,
 411         int y1, int y2, int yo, int xo)
 412 {
 413         lyxerr[Debug::GUI] << "screen: drawFromTo " << y1 << '-' << y2 << endl;
 414
 415         int y_text = text->top_y() + y1;
 416
 417         // get the first needed row
 418         RowList::iterator row = text->getRowNearY(y_text);
 419         RowList::iterator end = text->rows().end();
 420
 421         // y_text is now the real beginning of the row
 422
 423         int y = y_text - text->top_y();
 424         // y1 is now the real beginning of row on the screen
 425
 426         while (row != end && y < y2) {
 427                 RowPainter rp(*bv, *text, row);
 428                 rp.paint(y + yo, xo, y + text->top_y());
 429                 y += row->height();
 430                 ++row;
 431         }
 432
 433         // maybe we have to clear the screen at the bottom
 434         if ((y < y2) && !text->isInInset()) {
 435                 workarea().getPainter().fillRectangle(0, y,
 436                         workarea().workWidth(), y2 - y,
 437                         LColor::bottomarea);
 438         }
 439 }
 440
 441
 442 void LyXScreen::drawOneRow(LyXText * text, BufferView * bv,
 443                            RowList::iterator row,
 444         int y_text, int yo, int xo)
 445 {
 446         int const y = y_text - text->top_y() + yo;
 447
 448         if (y + row->height() <= 0)
 449                 return;
 450
 451         if (y - row->height() > workarea().workHeight())
 452                 return;
 453
 454         RowPainter rp(*bv, *text, row);
 455         rp.paint(y, xo, y + text->top_y());
 456 }