src/insets/insetgraphics.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *           Copyright 1995-2000 the LyX Team.
   7  *
   8  *           This file Copyright 2000 Baruch Even.
   9  * ====================================================== */
  10
  11 /*
  12 How to use it for now:
  13     * The lyxfunc 'graphics-insert' will insert this inset into the document.
  14 */
  15
  16 /*
  17 Major tasks:
  18         * Switch to convert the images in the background, this requires work on
  19                 the converter, the systemcontroller and the graphics cache.
  20
  21 Minor tasks:
  22     * Pop up a dialog if the widget version is higher than what we accept.
  23         * Prepare code to read FigInset insets to upgrade upwards
  24         * Provide sed/awk/C code to downgrade from InsetGraphics to FigInset(?)
  25
  26 */
  27
  28 /*
  29 Known BUGS:
  30
  31     * If the image is from the clipart, and the document is moved to another
  32        directory, the user is screwed. Need a way to handle it.
  33        This amounts to a problem of when to use relative or absolute file paths
  34        We should probably use what the user asks to use... but when he chooses
  35        by the file dialog we normally get an absolute path and this may not be
  36        what the user meant.
  37     * Bug in FileDlg class (src/filedlg.[hC]) when selecting a file and then
  38         pressing ok, it counts as if no real selection done. Apparently
  39         when choosing a file it doesn't update the select file input line.
  40
  41         * If we are trying to create a file in a read-only directory and there
  42                 are graphics that need converting, the converting will fail because
  43                 it is done in-place, into the same directory as the original image.
  44                 This needs to be fixed in the src/converter.C file
  45                 [ This is presumed to be fixed, needs testing.]
  46
  47         * We do not dither or resize the image in a WYSIWYM way, we load it at
  48                 its original size and color, resizing is done in the final output,
  49                 but not in the LyX window.
  50
  51 TODO Before initial production release:
  52     * Replace insetfig everywhere
  53         * Read it's file format
  54         * Get created by all commands used to create figinset currently.
  55         * Search for comments of the form
  56             // INSET_GRAPHICS: remove this when InsetFig is thrown.
  57           And act upon them.
  58
  59 TODO Extended features:
  60
  61     * Advanced Latex tab folder.
  62     * Add support for more features so that it will be better than insetfig.
  63         * Keep aspect ratio radio button
  64         * Support for complete control over the latex parameters for TeXperts
  65         * What advanced features the users want to do?
  66             Implement them in a non latex dependent way, but a logical way.
  67             LyX should translate it to latex or any other fitting format.
  68     * Add a way to roll the image file into the file format.
  69     * When loading, if the image is not found in the expected place, try
  70        to find it in the clipart, or in the same directory with the image.
  71     * Keep a tab on the image file, if it changes, update the lyx view.
  72         * The image choosing dialog could show thumbnails of the image formats
  73                 it knows of, thus selection based on the image instead of based on
  74                 filename.
  75         * Add support for the 'picins' package.
  76         * Add support for the 'picinpar' package.
  77         * Improve support for 'subfigure' - Allow to set the various options
  78                 that are possible.
  79  */
  80
  81 /* NOTES:
  82  *
  83  * Intentions:
  84  *  This is currently a moving target, I'm trying stuff and learning what
  85  *  is needed and how to accomplish it, since there is no predefined goal or
  86  *  way to go I invent it as I go.
  87  *
  88  *  My current intention is for seperation from LaTeX, the basic needs are
  89  *  resizing and rotating, displaying on screen in various depths and printing
  90  *  conversion of depths (independent of the display depth). For this I'll
  91  *  provide a simple interface.
  92  *
  93  *  The medium level includes clipping of the image, but in a limited way.
  94  *
  95  *  For the LaTeX gurus I'll provide a complete control over the output, but
  96  *  this is latex dependent and guru dependent so I'd rather avoid doing this
  97  *  for the normal user. This stuff includes clipping, special image size
  98  *  specifications (\textwidth\minus 2in) which I see no way to generalize
  99  *  to non-latex specific way.
 100  *
 101  * Used packages:
 102  *  'graphicx' for the graphics inclusion.
 103  *  'subfigure' for the subfigures.
 104  *
 105  * Fileformat:
 106  *
 107  * Current version is 1 (inset file format version), when changing it
 108  * it should be changed in the Write() function when writing in one place
 109  * and when reading one should change the version check and the error message.
 110  *
 111  * The filename is kept in  the lyx file in a relative way, so as to allow
 112  * moving the document file and its images with no problem.
 113  *
 114  * Conversions:
 115  *
 116  *  Apparently the PNG output is preferred over PDF images when doing PDF
 117  *  documents (i.e. prefer imagemagick eps2png over eps2pdf)
 118  */
 119
 120 #include <config.h>
 121
 122 #ifdef __GNUG__
 123 #pragma implementation
 124 #endif
 125
 126 #include "insets/insetgraphics.h"
 127 #include "insets/insetgraphicsParams.h"
 128 #include "graphics/GraphicsCache.h"
 129 #include "graphics/GraphicsCacheItem.h"
 130
 131 #include "frontends/Dialogs.h"
 132 #include "LyXView.h"
 133 #include "buffer.h"
 134 #include "BufferView.h"
 135 #include "converter.h"
 136 #include "frontends/support/LyXImage.h"
 137 #include "Painter.h"
 138 #include "lyx_gui_misc.h"
 139 #include "support/FileInfo.h"
 140 #include "support/filetools.h"
 141 #include "support/lyxlib.h"
 142 #include "lyxtext.h"
 143 #include "lyxrc.h"
 144 #include "font.h" // For the lyxfont class.
 145 #include <algorithm> // For the std::max
 146 #include "support/lyxmanip.h"
 147 #include "debug.h"
 148 #include "gettext.h"
 149
 150 extern string system_tempdir;
 151
 152 using std::ostream;
 153
 154 // This function is a utility function
 155 inline
 156 string const RemoveExtension(string const & filename)
 157 {
 158         return ChangeExtension(filename, string());
 159 }
 160
 161
 162 // Initialize only those variables that do not have a constructor.
 163 InsetGraphics::InsetGraphics()
 164         : cacheHandle(0), imageLoaded(false)
 165 {}
 166
 167
 168 InsetGraphics::~InsetGraphics()
 169 {
 170         // Emits the hide signal to the dialog connected (if any)
 171         hideDialog();
 172 }
 173
 174
 175 char const *
 176 InsetGraphics::statusMessage() const
 177 {
 178         char const * msg = 0;
 179
 180         if (cacheHandle.get()) {
 181                 switch (cacheHandle->getImageStatus()) {
 182                 case GraphicsCacheItem::UnknownError:
 183                         msg = _("Unknown Error");
 184                         break;
 185
 186                 case GraphicsCacheItem::Loading:
 187                         msg = _("Loading...");
 188                         break;
 189
 190                 case GraphicsCacheItem::ErrorReading:
 191                         msg = _("Error reading");
 192                         break;
 193
 194                 case GraphicsCacheItem::ErrorConverting:
 195                         msg = _("Error converting");
 196                         break;
 197
 198                 case GraphicsCacheItem::Loaded:
 199                         // No message to write.
 200                         break;
 201                 }
 202         }
 203
 204         return msg;
 205 }
 206
 207
 208 int InsetGraphics::ascent(BufferView *, LyXFont const &) const
 209 {
 210         LyXImage * pixmap = 0;
 211         if (cacheHandle.get() && (pixmap = cacheHandle->getImage()))
 212                 return pixmap->getHeight();
 213         else
 214                 return 50;
 215 }
 216
 217
 218 int InsetGraphics::descent(BufferView *, LyXFont const &) const
 219 {
 220         // this is not true if viewport is used and clip is not.
 221         return 0;
 222 }
 223
 224
 225 int InsetGraphics::width(BufferView *, LyXFont const & font) const
 226 {
 227         LyXImage * pixmap = 0;
 228
 229         if (cacheHandle.get() && (pixmap = cacheHandle->getImage()))
 230                 return pixmap->getWidth();
 231         else {
 232                 char const * msg = statusMessage();
 233                 int font_width = 0;
 234
 235                 if (msg)
 236                         font_width = lyxfont::width(msg, font);
 237
 238                 return std::max(50, font_width + 15);
 239         }
 240 }
 241
 242
 243 void InsetGraphics::draw(BufferView * bv, LyXFont const & font,
 244                          int baseline, float & x, bool) const
 245 {
 246         Painter & paint = bv->painter();
 247
 248         int ldescent = descent(bv, font);
 249         int lascent = ascent(bv, font);
 250         int lwidth = width(bv, font);
 251
 252         // Make sure x is updated upon exit from this routine
 253         float old_x = x;
 254         x += lwidth;
 255
 256         // This will draw the graphics. If the graphics has not been loaded yet,
 257         // we draw just a rectangle.
 258         if (imageLoaded) {
 259
 260                 paint.image(int(old_x) + 2, baseline - lascent,
 261                              lwidth - 4, lascent + ldescent,
 262                                          cacheHandle->getImage());
 263         } else {
 264
 265                 // Get the image status, default to unknown error.
 266                 GraphicsCacheItem::ImageStatus status = GraphicsCacheItem::UnknownError;
 267                 if (cacheHandle.get())
 268                         status = cacheHandle->getImageStatus();
 269
 270                 // Check if the image is now ready.
 271                 if (status == GraphicsCacheItem::Loaded) {
 272                         imageLoaded = true;
 273
 274                         // Tell BufferView we need to be updated!
 275                         bv->text->status = LyXText::CHANGED_IN_DRAW;
 276                         return;
 277                 }
 278
 279                 char const * msg = statusMessage();
 280
 281                 paint.rectangle(int(old_x) + 2, baseline - lascent,
 282                                 lwidth - 4,
 283                                 lascent + ldescent);
 284
 285                 if (msg) {
 286                         // Print the message.
 287                         LyXFont msgFont(font);
 288                         msgFont.setFamily(LyXFont::SANS_FAMILY);
 289                         msgFont.setSize(LyXFont::SIZE_FOOTNOTE);
 290                         string const justname = OnlyFilename (params.filename);
 291                         paint.text(int(old_x) + 8,
 292                                         baseline - lyxfont::maxAscent(msgFont) - 4,
 293                                     justname, msgFont);
 294
 295                         msgFont.setSize(LyXFont::SIZE_TINY);
 296                         paint.text(int(old_x) + 8, baseline - 4,
 297                                         msg, strlen(msg), msgFont);
 298                 }
 299         }
 300 }
 301
 302
 303 void InsetGraphics::Edit(BufferView *bv, int, int, unsigned int)
 304 {
 305         bv->owner()->getDialogs()->showGraphics(this);
 306 }
 307
 308
 309 Inset::EDITABLE InsetGraphics::Editable() const
 310 {
 311         return IS_EDITABLE;
 312 }
 313
 314
 315 void InsetGraphics::Write(Buffer const * buf, ostream & os) const
 316 {
 317         os << "GRAPHICS FormatVersion 1\n";
 318
 319         params.Write(buf, os);
 320 }
 321
 322
 323 void InsetGraphics::Read(Buffer const * buf, LyXLex & lex)
 324 {
 325         bool finished = false;
 326
 327         while (lex.IsOK() && !finished) {
 328                 lex.next();
 329
 330                 string const token = lex.GetString();
 331                 lyxerr.debug() << "Token: '" << token << '\'' << std::endl;
 332
 333                 if (token.empty()) {
 334                         continue;
 335                 } else if (token == "\\end_inset") {
 336                         finished = true;
 337                 } else if (token == "FormatVersion") {
 338                         lex.next();
 339                         int version = lex.GetInteger();
 340                         if (version > 1)
 341                                 lyxerr
 342                                 << "This document was created with a newer Graphics widget"
 343                                 ", You should use a newer version of LyX to read this"
 344                                 " file."
 345                                 << std::endl;
 346                         // TODO: Possibly open up a dialog?
 347                 }
 348                 else {
 349                         if (! params.Read(buf, lex, token))
 350                                 lyxerr << "Unknown token, " << token << ", skipping."
 351                                         << std::endl;
 352                 }
 353         }
 354
 355         updateInset();
 356 }
 357
 358
 359 namespace {
 360
 361 void formatResize(ostream & os, string const & key,
 362                   InsetGraphicsParams::Resize resizeType, double size)
 363 {
 364         switch (resizeType) {
 365         case InsetGraphicsParams::DEFAULT_SIZE:
 366                 break;
 367
 368         case InsetGraphicsParams::CM:
 369                 os << key << '=' << size << "cm,";
 370                 break;
 371
 372         case InsetGraphicsParams::INCH:
 373                 os << key << '=' << size << "in,";
 374                 break;
 375
 376         case InsetGraphicsParams::PERCENT_PAGE:
 377                 os << key << '=' << size / 100 << "\\text" << key << ',';
 378                 break;
 379
 380         case InsetGraphicsParams::PERCENT_COLUMN:
 381                 os << key << '=' << size / 100 << "\\column" << key << ',';
 382                 break;
 383
 384         }
 385 }
 386
 387 } // namespace anon
 388
 389
 390 string const
 391 InsetGraphics::createLatexOptions() const
 392 {
 393         // Calculate the options part of the command, we must do it to a string
 394         // stream since we might have a trailing comma that we would like to remove
 395         // before writing it to the output stream.
 396         std::ostringstream options;
 397
 398         formatResize(options, "width", params.widthResize, params.widthSize);
 399         formatResize(options, "height", params.heightResize, params.heightSize);
 400
 401         if (params.rotateAngle != 0) {
 402                 options << "angle="
 403                         << params.rotateAngle << ',';
 404         }
 405
 406         string opts = options.str().c_str();
 407         opts = strip(opts, ',');
 408
 409         return opts;
 410 }
 411
 412
 413 string const
 414 InsetGraphics::prepareFile(Buffer const *buf) const
 415 {
 416
 417         // do_convert = Do we need to convert the file?
 418         // nice = Do we create a nice version?
 419         //        This is used when exporting the latex file only.
 420         //
 421         //
 422         // if (!do_convert)
 423         //   return original filename
 424         //
 425         // if (!nice)
 426         //   convert_place = temp directory
 427         //   return new filename in temp directory
 428         // else
 429         //   convert_place = original file directory
 430         //   return original filename without the extension
 431         //
 432
 433         // Get the extension (format) of the original file.
 434         string const extension = GetExtension(params.filename);
 435
 436         // Are we creating a PDF or a PS file?
 437         // (Should actually mean, are we usind latex or pdflatex).
 438         string const image_target = (lyxrc.pdf_mode ? "png" : "eps");
 439
 440         if (extension == image_target)
 441                 return params.filename;
 442
 443         string outfile;
 444         if (!buf->niceFile) {
 445                 string const temp = AddName(buf->tmppath, params.filename);
 446                 outfile = RemoveExtension(temp);
 447
 448                 //lyxerr << "buf::tmppath = " << buf->tmppath << "\n";
 449                 //lyxerr << "filename = " << params.filename << "\n";
 450                 //lyxerr << "temp = " << temp << "\n";
 451                 //lyxerr << "outfile = " << outfile << endl;
 452         } else {
 453                 string const path = OnlyPath(buf->fileName());
 454                 string const relname = MakeRelPath(params.filename, path);
 455                 outfile = RemoveExtension(relname);
 456         }
 457
 458         converters.Convert(buf, params.filename, outfile, extension, image_target);
 459
 460         return outfile;
 461 }
 462
 463
 464 int InsetGraphics::Latex(Buffer const *buf, ostream & os,
 465                 bool /*fragile*/, bool/*fs*/) const
 466 {
 467         // MISSING: We have to decide how to do the order of the options
 468         // that is dependent of order, like width, height, angle. Should
 469         // we rotate before scale? Should we let the user decide?
 470         // bool rot_before_scale; ?
 471
 472         // (BE) As a first step we should do a scale before rotate since this is
 473         // more like the natural thought of how to do it.
 474         // (BE) I believe that a priority list presented to the user with
 475         // a default order would be the best, though it would be better to
 476         // hide such a thing in an "Advanced options" dialog.
 477         // (BE) This should go an advanced LaTeX options dialog.
 478
 479         // If there is no file specified, just output a message about it in
 480         // the latex output.
 481         if (params.filename.empty()) {
 482                 os  << "\\fbox{\\rule[-0.5in]{0pt}{1in}"
 483                         << _("empty figure path")
 484                         << "}\n";
 485
 486                 return 1; // One end of line marker added to the stream.
 487         }
 488
 489         // Keep count of newlines that we issued.
 490         int newlines = 0;
 491
 492         // This variables collect all the latex code that should be before and
 493         // after the actual includegraphics command.
 494         string before;
 495         string after;
 496
 497         // If it's not an inline image, surround it with the centering paragraph.
 498         if (! params.inlineFigure) {
 499                 before += "\n" "\\vspace{0.3cm}\n" "{\\par\\centering ";
 500                 after = " \\par}\n" "\\vspace{0.3cm}\n" + after;
 501                 newlines += 4;
 502         }
 503
 504         // Do we want subcaptions?
 505         if (params.subcaption) {
 506                 before += "\\subfigure[" + params.subcaptionText + "]{";
 507                 after = '}' + after;
 508         }
 509
 510         // We never use the starred form, we use the "clip" option instead.
 511         os << before << "\\includegraphics";
 512
 513         // Write the options if there are any.
 514         string const opts = createLatexOptions();
 515         if (!opts.empty()) {
 516                 os << '[' << opts << ']';
 517         }
 518
 519         // Make the filename relative to the lyx file
 520         // and remove the extension so the LaTeX will use whatever is
 521         // appropriate (when there are several versions in different formats)
 522         string const filename = prepareFile(buf);
 523
 524         os << '{' << filename << '}' << after;
 525
 526         // Return how many newlines we issued.
 527         return newlines;
 528 }
 529
 530
 531 int InsetGraphics::Ascii(Buffer const *, ostream &, int) const
 532 {
 533         // No graphics in ascii output. Possible to use gifscii to convert
 534         // images to ascii approximation.
 535
 536         // 1. Convert file to ascii using gifscii
 537         // 2. Read ascii output file and add it to the output stream.
 538
 539         return 0;
 540 }
 541
 542
 543 int InsetGraphics::Linuxdoc(Buffer const *, ostream &) const
 544 {
 545         // No graphics in LinuxDoc output. Should check how/what to add.
 546         return 0;
 547 }
 548
 549
 550 // For explanation on inserting graphics into DocBook checkout:
 551 // http://linuxdoc.org/LDP/LDP-Author-Guide/inserting-pictures.html
 552 // See also the docbook guide at http://www.docbook.org/
 553 int InsetGraphics::DocBook(Buffer const * buf, ostream & os) const
 554 {
 555         // Change the path to be relative to the main file.
 556         string const buffer_dir = OnlyPath(buf->fileName());
 557         string const filename = RemoveExtension(MakeRelPath(params.filename, buffer_dir));
 558
 559         // In DocBook v5.0, the graphic tag will be eliminated from DocBook, will
 560         // need to switch to MediaObject. However, for now this is sufficient and
 561         // easier to use.
 562         os << "<graphic fileref=\"" << filename << "\"></graphic>";
 563         return 0;
 564 }
 565
 566
 567 void InsetGraphics::Validate(LaTeXFeatures & features) const
 568 {
 569         // If we have no image, we should not require anything.
 570         if (params.filename.empty())
 571                 return ;
 572
 573         features.graphicx = true;
 574
 575         if (params.subcaption)
 576                 features.subfigure = true;
 577 }
 578
 579
 580 // Update the inset after parameters changed (read from file or changed in
 581 // dialog.
 582 void InsetGraphics::updateInset() const
 583 {
 584         GraphicsCache & gc = GraphicsCache::getInstance();
 585         boost::shared_ptr<GraphicsCacheItem> temp(0);
 586
 587         // We do it this way so that in the face of some error, we will still
 588         // be in a valid state.
 589         if (!params.filename.empty()) {
 590                 temp = gc.addFile(params.filename);
 591         }
 592
 593         // Mark the image as unloaded so that it gets updated.
 594         imageLoaded = false;
 595
 596         cacheHandle = temp;
 597 }
 598
 599
 600 bool InsetGraphics::setParams(InsetGraphicsParams const & params)
 601 {
 602         // If nothing is changed, just return and say so.
 603         if (this->params == params)
 604                 return false;
 605
 606         // Copy the new parameters.
 607         this->params = params;
 608
 609         // Update the inset with the new parameters.
 610         updateInset();
 611
 612         // We have changed data, report it.
 613         return true;
 614 }
 615
 616
 617 InsetGraphicsParams InsetGraphics::getParams() const
 618 {
 619         return params;
 620 }
 621
 622
 623 Inset * InsetGraphics::Clone(Buffer const &) const
 624 {
 625 #warning use the copy constructor instead. (Lgb)
 626         InsetGraphics * newInset = new InsetGraphics;
 627
 628         newInset->cacheHandle = cacheHandle;
 629         newInset->imageLoaded = imageLoaded;
 630
 631         newInset->setParams(getParams());
 632
 633         return newInset;
 634 }