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         Row * row = cursor.row();
 199
 200         // Is this a hack? Yes, probably... (Lgb)
 201         if (!row)
 202                 return max(newtop, 0);
 203
 204         if (cursor.y() - row->baseline() + row->height() - top_y >= vheight) {
 205                 if (row->height() < vheight
 206                     && row->height() > vheight / 4) {
 207                         newtop = cursor.y()
 208                                 + row->height()
 209                                 - row->baseline() - vheight;
 210                 } else {
 211                         // scroll down
 212                         newtop = cursor.y()
 213                                 - vheight / 2;   /* the scroll region must be so big!! */
 214                 }
 215
 216         } else if (static_cast<int>((cursor.y()) - row->baseline()) <
 217                    top_y && top_y > 0) {
 218                 if (row->height() < vheight
 219                     && row->height() > vheight / 4) {
 220                         newtop = cursor.y() - row->baseline();
 221                 } else {
 222                         // scroll up
 223                         newtop = cursor.y() - vheight / 2;
 224                         newtop = min(newtop, top_y);
 225                 }
 226         }
 227
 228         newtop = max(newtop, 0);
 229
 230         return newtop;
 231 }
 232
 233
 234 bool LyXScreen::fitCursor(LyXText * text, BufferView * bv)
 235 {
 236         // Is a change necessary?
 237         int const newtop = topCursorVisible(text->cursor, text->top_y());
 238         bool const result = (newtop != text->top_y());
 239         if (result) {
 240                 draw(text, bv, newtop);
 241         }
 242
 243         return result;
 244 }
 245
 246
 247 void LyXScreen::update(BufferView & bv, int yo, int xo)
 248 {
 249         int const vwidth = workarea().workWidth();
 250         int const vheight = workarea().workHeight();
 251         LyXText * text = bv.text;
 252
 253         workarea().getPainter().start();
 254
 255         switch (text->status()) {
 256         case LyXText::NEED_MORE_REFRESH:
 257         {
 258                 int const y = max(int(text->refresh_y - text->top_y()), 0);
 259                 drawFromTo(text, &bv, y, vheight, yo, xo);
 260                 expose(0, y, vwidth, vheight - y);
 261         }
 262         break;
 263         case LyXText::NEED_VERY_LITTLE_REFRESH:
 264         {
 265                 // ok I will update the current cursor row
 266                 drawOneRow(text, &bv, text->refresh_row, text->refresh_y,
 267                            yo, xo);
 268                 // this because if we had a major update the refresh_row could
 269                 // have been set to 0!
 270                 if (text->refresh_row) {
 271                         expose(0, text->refresh_y - text->top_y() + yo,
 272                                    vwidth, text->refresh_row->height());
 273                 }
 274         }
 275         break;
 276         case LyXText::CHANGED_IN_DRAW: // just to remove the warning
 277         case LyXText::UNCHANGED:
 278                 // Nothing needs done
 279                 break;
 280         }
 281
 282         workarea().getPainter().end();
 283 }
 284
 285
 286 void LyXScreen::toggleSelection(LyXText * text, BufferView * bv,
 287                                 bool kill_selection,
 288                                 int yo, int xo)
 289 {
 290         // only if there is a selection
 291         if (!text->selection.set()) return;
 292
 293         int const bottom = min(
 294                 max(static_cast<int>(text->selection.end.y()
 295                                      - text->selection.end.row()->baseline()
 296                                      + text->selection.end.row()->height()),
 297                     text->top_y()),
 298                 static_cast<int>(text->top_y() + workarea().workHeight()));
 299         int const top = min(
 300                 max(static_cast<int>(text->selection.start.y() -
 301                                      text->selection.start.row()->baseline()),
 302                     text->top_y()),
 303                 static_cast<int>(text->top_y() + workarea().workHeight()));
 304
 305         if (kill_selection)
 306                 text->selection.set(false);
 307
 308         workarea().getPainter().start();
 309
 310         drawFromTo(text, bv, top - text->top_y(), bottom - text->top_y(),
 311                    yo, xo);
 312         expose(0, top - text->top_y(),
 313                workarea().workWidth(),
 314                bottom - text->top_y() - (top - text->top_y()));
 315
 316         workarea().getPainter().end();
 317 }
 318
 319
 320 void LyXScreen::toggleToggle(LyXText * text, BufferView * bv,
 321                              int yo, int xo)
 322 {
 323         if (text->toggle_cursor.par() == text->toggle_end_cursor.par()
 324             && text->toggle_cursor.pos() == text->toggle_end_cursor.pos())
 325                 return;
 326
 327         int const top_tmp = text->toggle_cursor.y()
 328                 - text->toggle_cursor.row()->baseline();
 329         int const bottom_tmp = text->toggle_end_cursor.y()
 330                 - text->toggle_end_cursor.row()->baseline()
 331                 + text->toggle_end_cursor.row()->height();
 332
 333         int const offset = yo < 0 ? yo : 0;
 334         int const bottom = min(max(bottom_tmp, text->top_y()),
 335                 static_cast<int>(text->top_y() + workarea().workHeight())) - offset;
 336         int const top = min(max(top_tmp, text->top_y()),
 337                 static_cast<int>(text->top_y() + workarea().workHeight())) - offset;
 338
 339         workarea().getPainter().start();
 340
 341         drawFromTo(text, bv, top - text->top_y(),
 342                    bottom - text->top_y(), yo,
 343                    xo);
 344         expose(0, top - text->top_y(), workarea().workWidth(),
 345                bottom - text->top_y() - (top - text->top_y()));
 346
 347         workarea().getPainter().end();
 348 }
 349
 350
 351 void LyXScreen::redraw(LyXText * text, BufferView * bv)
 352 {
 353         greyed_out_ = !text;
 354
 355         if (greyed_out_) {
 356                 greyOut();
 357                 return;
 358         }
 359
 360
 361
 362         workarea().getPainter().start();
 363
 364         drawFromTo(text, bv, 0, workarea().workHeight(), 0, 0, text == bv->text);
 365         expose(0, 0, workarea().workWidth(), workarea().workHeight());
 366
 367         workarea().getPainter().end();
 368
 369         if (cursor_visible_) {
 370                 cursor_visible_ = false;
 371                 bv->showCursor();
 372         }
 373 }
 374
 375
 376 void LyXScreen::greyOut()
 377 {
 378         if (!greyed_out_)
 379                 return;
 380
 381         workarea().getPainter().start();
 382
 383         workarea().getPainter().fillRectangle(0, 0,
 384                 workarea().workWidth(),
 385                 workarea().workHeight(),
 386                 LColor::bottomarea);
 387
 388         // Add a splash screen to the centre of the work area
 389         SplashScreen const & splash = SplashScreen::get();
 390         grfx::Image const * const splash_image = splash.image();
 391         if (splash_image) {
 392                 int const w = splash_image->getWidth();
 393                 int const h = splash_image->getHeight();
 394
 395                 int x = (workarea().workWidth() - w) / 2;
 396                 int y = (workarea().workHeight() - h) / 2;
 397
 398                 workarea().getPainter().image(x, y, w, h, *splash_image);
 399
 400                 string const & splash_text  = splash.text();
 401                 LyXFont const & splash_font = splash.font();
 402
 403                 x += 260;
 404                 y += 265;
 405
 406                 workarea().getPainter().text(x, y, splash_text, splash_font);
 407         }
 408         expose(0, 0, workarea().workWidth(), workarea().workHeight());
 409         workarea().getPainter().end();
 410 }
 411
 412
 413 void LyXScreen::drawFromTo(LyXText * text, BufferView * bv,
 414         int y1, int y2, int yo, int xo,
 415         bool internal)
 416 {
 417         lyxerr[Debug::GUI] << "screen: drawFromTo " << y1 << '-' << y2 << endl;
 418
 419         int y_text = text->top_y() + y1;
 420
 421         // get the first needed row
 422         Row * row = text->getRowNearY(y_text);
 423         // y_text is now the real beginning of the row
 424
 425         int y = y_text - text->top_y();
 426         // y1 is now the real beginning of row on the screen
 427
 428
 429         while (row != 0 && y < y2) {
 430                 LyXText::text_status st = text->status();
 431                 // we need this here as the row pointer may be illegal
 432                 // at a later time (Jug20020502)
 433                 Row * prev = row->previous();
 434                 RowPainter rp(*bv, *text, *row);
 435
 436                 if (rp.paint(y + yo, xo, y + text->top_y()))
 437                         text->markChangeInDraw(bv, row, prev);
 438
 439                 internal = internal && (st != LyXText::CHANGED_IN_DRAW);
 440                 while (internal && text->status() == LyXText::CHANGED_IN_DRAW) {
 441                         text->fullRebreak(bv);
 442                         text->setCursor(bv, text->cursor.par(), text->cursor.pos());
 443                         text->postPaint(*bv, 0);
 444                         Row * prev = row->previous();
 445                         RowPainter rp(*bv, *text, *row);
 446                         if (rp.paint(y + yo, xo, y + text->top_y()))
 447                                 text->markChangeInDraw(bv, row, prev);
 448                 }
 449                 y += row->height();
 450                 row = row->next();
 451         }
 452
 453         // maybe we have to clear the screen at the bottom
 454         if ((y < y2) && text->isTopLevel()) {
 455                 workarea().getPainter().fillRectangle(0, y,
 456                         workarea().workWidth(), y2 - y,
 457                         LColor::bottomarea);
 458         }
 459 }
 460
 461
 462 void LyXScreen::drawOneRow(LyXText * text, BufferView * bv, Row * row,
 463         int y_text, int yo, int xo)
 464 {
 465         int const y = y_text - text->top_y() + yo;
 466
 467         if (((y + row->height()) > 0) &&
 468             ((y - row->height()) <= static_cast<int>(workarea().workHeight()))) {
 469                 Row * prev = row->previous();
 470                 RowPainter rp(*bv, *text, *row);
 471                 if (rp.paint(y, xo, y + text->top_y()))
 472                         text->markChangeInDraw(bv, row, prev);
 473         }
 474 }