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                 text->updateRowPositions();
 261                 int const y = max(int(text->refresh_y - text->top_y()), 0);
 262                 drawFromTo(text, &bv, y, vheight, yo, xo);
 263                 expose(0, y, vwidth, vheight - y);
 264         }
 265         break;
 266         case LyXText::REFRESH_ROW:
 267         {
 268                 text->updateRowPositions();
 269                 // ok I will update the current cursor row
 270                 drawOneRow(text, &bv, text->refresh_row, text->refresh_y,
 271                            yo, xo);
 272                 // this because if we had a major update the refresh_row could
 273                 // have been set to 0!
 274                 if (text->refresh_row != text->rows().end()) {
 275                         expose(0, text->refresh_y - text->top_y() + yo,
 276                                    vwidth, text->refresh_row->height());
 277                 }
 278         }
 279         break;
 280         case LyXText::REFRESH_NONE:
 281                 // Nothing needs done
 282                 break;
 283         }
 284
 285         workarea().getPainter().end();
 286 }
 287
 288
 289 void LyXScreen::toggleSelection(LyXText * text, BufferView * bv,
 290                                 bool kill_selection,
 291                                 int yo, int xo)
 292 {
 293         // only if there is a selection
 294         if (!text->selection.set()) return;
 295
 296         int const bottom = min(
 297                 max(static_cast<int>(text->selection.end.y()
 298                                      - text->selection.end.row()->baseline()
 299                                      + text->selection.end.row()->height()),
 300                     text->top_y()),
 301                 static_cast<int>(text->top_y() + workarea().workHeight()));
 302         int const top = min(
 303                 max(static_cast<int>(text->selection.start.y() -
 304                                      text->selection.start.row()->baseline()),
 305                     text->top_y()),
 306                 static_cast<int>(text->top_y() + workarea().workHeight()));
 307
 308         if (kill_selection)
 309                 text->selection.set(false);
 310
 311         workarea().getPainter().start();
 312
 313         drawFromTo(text, bv, top - text->top_y(), bottom - text->top_y(),
 314                    yo, xo);
 315         expose(0, top - text->top_y(),
 316                workarea().workWidth(),
 317                bottom - text->top_y() - (top - text->top_y()));
 318
 319         workarea().getPainter().end();
 320 }
 321
 322
 323 void LyXScreen::toggleToggle(LyXText * text, BufferView * bv,
 324                              int yo, int xo)
 325 {
 326         if (text->toggle_cursor.par() == text->toggle_end_cursor.par()
 327             && text->toggle_cursor.pos() == text->toggle_end_cursor.pos())
 328                 return;
 329
 330         int const top_tmp = text->toggle_cursor.y()
 331                 - text->toggle_cursor.row()->baseline();
 332         int const bottom_tmp = text->toggle_end_cursor.y()
 333                 - text->toggle_end_cursor.row()->baseline()
 334                 + text->toggle_end_cursor.row()->height();
 335
 336         int const offset = yo < 0 ? yo : 0;
 337         int const bottom = min(max(bottom_tmp, text->top_y()),
 338                 static_cast<int>(text->top_y() + workarea().workHeight())) - offset;
 339         int const top = min(max(top_tmp, text->top_y()),
 340                 static_cast<int>(text->top_y() + workarea().workHeight())) - offset;
 341
 342         workarea().getPainter().start();
 343
 344         drawFromTo(text, bv, top - text->top_y(), bottom - text->top_y(), yo, xo);
 345         expose(0, top - text->top_y(), workarea().workWidth(),
 346                bottom - text->top_y() - (top - text->top_y()));
 347
 348         workarea().getPainter().end();
 349 }
 350
 351
 352 void LyXScreen::redraw(LyXText * text, BufferView * bv)
 353 {
 354         greyed_out_ = !text;
 355
 356         if (greyed_out_) {
 357                 greyOut();
 358                 return;
 359         }
 360
 361         workarea().getPainter().start();
 362
 363         text->updateRowPositions();
 364         drawFromTo(text, bv, 0, workarea().workHeight(), 0, 0);
 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 {
 416         lyxerr[Debug::GUI] << "screen: drawFromTo " << y1 << '-' << y2 << endl;
 417
 418         int const topy = text->top_y();
 419         int y_text = topy + y1;
 420         RowList::iterator rit = text->getRowNearY(y_text);
 421         int y = y_text - topy;
 422         // y1 is now the real beginning of row on the screen
 423
 424         RowList::iterator const rend = text->rows().end();
 425         while (rit != rend && y < y2) {
 426                 RowPainter rp(*bv, *text, rit);
 427                 rp.paint(y + yo, xo, y + topy);
 428                 y += rit->height();
 429                 ++rit;
 430         }
 431
 432         // maybe we have to clear the screen at the bottom
 433         if ((y < y2) && !text->isInInset()) {
 434                 workarea().getPainter().fillRectangle(0, y,
 435                         workarea().workWidth(), y2 - y,
 436                         LColor::bottomarea);
 437         }
 438 }
 439
 440
 441 void LyXScreen::drawOneRow(LyXText * text, BufferView * bv,
 442                            RowList::iterator row,
 443         int y_text, int yo, int xo)
 444 {
 445         int const y = y_text - text->top_y() + yo;
 446
 447         if (y + row->height() <= 0)
 448                 return;
 449
 450         if (y - row->height() > workarea().workHeight())
 451                 return;
 452
 453         RowPainter rp(*bv, *text, row);
 454         rp.paint(y, xo, y + text->top_y());
 455 }