src/insets/insetgraphics.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *           Copyright 1995-2001 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(InsetGraphics const & ig, bool same_id)
 169         : Inset(), SigC::Object()
 170         , cacheHandle(ig.cacheHandle)
 171         , imageLoaded(ig.imageLoaded)
 172 {
 173         setParams(ig.getParams());
 174         if (same_id)
 175                 id_ = ig.id_;
 176 }
 177
 178
 179 InsetGraphics::~InsetGraphics()
 180 {
 181         // Emits the hide signal to the dialog connected (if any)
 182         hideDialog();
 183 }
 184
 185
 186 string const
 187 InsetGraphics::statusMessage() const
 188 {
 189         string msg;
 190
 191         if (cacheHandle.get()) {
 192                 switch (cacheHandle->getImageStatus()) {
 193                 case GraphicsCacheItem::UnknownError:
 194                         msg = _("Unknown Error");
 195                         break;
 196
 197                 case GraphicsCacheItem::Loading:
 198                         msg = _("Loading...");
 199                         break;
 200
 201                 case GraphicsCacheItem::ErrorReading:
 202                         msg = _("Error reading");
 203                         break;
 204
 205                 case GraphicsCacheItem::ErrorConverting:
 206                         msg = _("Error converting");
 207                         break;
 208
 209                 case GraphicsCacheItem::Loaded:
 210                         // No message to write.
 211                         break;
 212                 }
 213         }
 214
 215         return msg;
 216 }
 217
 218
 219 int InsetGraphics::ascent(BufferView *, LyXFont const &) const
 220 {
 221         LyXImage * pixmap = 0;
 222         if (cacheHandle.get() && (pixmap = cacheHandle->getImage()))
 223                 return pixmap->getHeight();
 224         else
 225                 return 50;
 226 }
 227
 228
 229 int InsetGraphics::descent(BufferView *, LyXFont const &) const
 230 {
 231         // this is not true if viewport is used and clip is not.
 232         return 0;
 233 }
 234
 235
 236 int InsetGraphics::width(BufferView *, LyXFont const & font) const
 237 {
 238         LyXImage * pixmap = 0;
 239
 240         if (cacheHandle.get() && (pixmap = cacheHandle->getImage()))
 241                 return pixmap->getWidth();
 242         else {
 243                 string const msg = statusMessage();
 244                 int font_width = 0;
 245
 246                 if (!msg.empty())
 247                         font_width = lyxfont::width(msg, font);
 248
 249                 return std::max(50, font_width + 15);
 250         }
 251 }
 252
 253
 254 void InsetGraphics::draw(BufferView * bv, LyXFont const & font,
 255                          int baseline, float & x, bool) const
 256 {
 257         Painter & paint = bv->painter();
 258
 259         int ldescent = descent(bv, font);
 260         int lascent = ascent(bv, font);
 261         int lwidth = width(bv, font);
 262
 263         // Make sure x is updated upon exit from this routine
 264         int old_x = int(x);
 265         x += lwidth;
 266
 267         // This will draw the graphics. If the graphics has not been loaded yet,
 268         // we draw just a rectangle.
 269         if (imageLoaded) {
 270
 271                 paint.image(old_x + 2, baseline - lascent,
 272                             lwidth - 4, lascent + ldescent,
 273                             cacheHandle->getImage());
 274         } else {
 275
 276                 // Get the image status, default to unknown error.
 277                 GraphicsCacheItem::ImageStatus status = GraphicsCacheItem::UnknownError;
 278                 if (cacheHandle.get())
 279                         status = cacheHandle->getImageStatus();
 280
 281                 // Check if the image is now ready.
 282                 if (status == GraphicsCacheItem::Loaded) {
 283                         imageLoaded = true;
 284
 285                         // Tell BufferView we need to be updated!
 286                         bv->text->status(bv, LyXText::CHANGED_IN_DRAW);
 287                         return;
 288                 }
 289
 290
 291                 paint.rectangle(old_x + 2, baseline - lascent,
 292                                 lwidth - 4,
 293                                 lascent + ldescent);
 294
 295                 string const msg = statusMessage();
 296                 if (!msg.empty()) {
 297                         // Print the message.
 298                         LyXFont msgFont(font);
 299                         msgFont.setFamily(LyXFont::SANS_FAMILY);
 300                         msgFont.setSize(LyXFont::SIZE_FOOTNOTE);
 301                         string const justname = OnlyFilename (params.filename);
 302                         paint.text(old_x + 8,
 303                                    baseline - lyxfont::maxAscent(msgFont) - 4,
 304                                    justname, msgFont);
 305
 306                         msgFont.setSize(LyXFont::SIZE_TINY);
 307                         paint.text(old_x + 8, baseline - 4, msg, msgFont);
 308                 }
 309         }
 310 }
 311
 312
 313 void InsetGraphics::edit(BufferView *bv, int, int, unsigned int)
 314 {
 315         bv->owner()->getDialogs()->showGraphics(this);
 316 }
 317
 318
 319 void InsetGraphics::edit(BufferView * bv, bool)
 320 {
 321         edit(bv, 0, 0, 0);
 322 }
 323
 324
 325 Inset::EDITABLE InsetGraphics::editable() const
 326 {
 327         return IS_EDITABLE;
 328 }
 329
 330
 331 void InsetGraphics::write(Buffer const * buf, ostream & os) const
 332 {
 333         os << "GRAPHICS FormatVersion 1\n";
 334
 335         params.Write(buf, os);
 336 }
 337
 338
 339 void InsetGraphics::read(Buffer const * buf, LyXLex & lex)
 340 {
 341         bool finished = false;
 342
 343         while (lex.IsOK() && !finished) {
 344                 lex.next();
 345
 346                 string const token = lex.GetString();
 347                 lyxerr[Debug::INFO] << "Token: '" << token << '\''
 348                                     << std::endl;
 349
 350                 if (token.empty()) {
 351                         continue;
 352                 } else if (token == "\\end_inset") {
 353                         finished = true;
 354                 } else if (token == "FormatVersion") {
 355                         lex.next();
 356                         int version = lex.GetInteger();
 357                         if (version > 1)
 358                                 lyxerr
 359                                 << "This document was created with a newer Graphics widget"
 360                                 ", You should use a newer version of LyX to read this"
 361                                 " file."
 362                                 << std::endl;
 363                         // TODO: Possibly open up a dialog?
 364                 }
 365                 else {
 366                         if (! params.Read(buf, lex, token))
 367                                 lyxerr << "Unknown token, " << token << ", skipping."
 368                                         << std::endl;
 369                 }
 370         }
 371
 372         updateInset();
 373 }
 374
 375
 376 namespace {
 377
 378 void formatResize(ostream & os, string const & key,
 379                   InsetGraphicsParams::Resize resizeType, double size)
 380 {
 381         switch (resizeType) {
 382         case InsetGraphicsParams::DEFAULT_SIZE:
 383                 break;
 384
 385         case InsetGraphicsParams::CM:
 386                 os << key << '=' << size << "cm,";
 387                 break;
 388
 389         case InsetGraphicsParams::INCH:
 390                 os << key << '=' << size << "in,";
 391                 break;
 392
 393         case InsetGraphicsParams::PERCENT_PAGE:
 394                 os << key << '=' << size / 100 << "\\text" << key << ',';
 395                 break;
 396
 397         case InsetGraphicsParams::PERCENT_COLUMN:
 398                 os << key << '=' << size / 100 << "\\column" << key << ',';
 399                 break;
 400
 401         }
 402 }
 403
 404 } // namespace anon
 405
 406
 407 string const
 408 InsetGraphics::createLatexOptions() const
 409 {
 410         // Calculate the options part of the command, we must do it to a string
 411         // stream since we might have a trailing comma that we would like to remove
 412         // before writing it to the output stream.
 413         ostringstream options;
 414
 415         formatResize(options, "width", params.widthResize, params.widthSize);
 416         formatResize(options, "height", params.heightResize, params.heightSize);
 417
 418         if (params.rotateAngle != 0) {
 419                 options << "angle="
 420                         << params.rotateAngle << ',';
 421         }
 422
 423         string opts = options.str().c_str();
 424         opts = strip(opts, ',');
 425
 426         return opts;
 427 }
 428
 429
 430 string const
 431 InsetGraphics::prepareFile(Buffer const *buf) const
 432 {
 433
 434         // do_convert = Do we need to convert the file?
 435         // nice = Do we create a nice version?
 436         //        This is used when exporting the latex file only.
 437         //
 438         //
 439         // if (!do_convert)
 440         //   return original filename
 441         //
 442         // if (!nice)
 443         //   convert_place = temp directory
 444         //   return new filename in temp directory
 445         // else
 446         //   convert_place = original file directory
 447         //   return original filename without the extension
 448         //
 449
 450         // Get the extension (format) of the original file.
 451         string const extension = GetExtension(params.filename);
 452
 453         // Are we creating a PDF or a PS file?
 454         // (Should actually mean, are we usind latex or pdflatex).
 455         string const image_target = (lyxrc.pdf_mode ? "png" : "eps");
 456
 457         if (extension == image_target)
 458                 return params.filename;
 459
 460         string outfile;
 461         if (!buf->niceFile) {
 462                 string const temp = AddName(buf->tmppath, params.filename);
 463                 outfile = RemoveExtension(temp);
 464
 465                 //lyxerr << "buf::tmppath = " << buf->tmppath << "\n";
 466                 //lyxerr << "filename = " << params.filename << "\n";
 467                 //lyxerr << "temp = " << temp << "\n";
 468                 //lyxerr << "outfile = " << outfile << endl;
 469         } else {
 470                 string const path = OnlyPath(buf->fileName());
 471                 string const relname = MakeRelPath(params.filename, path);
 472                 outfile = RemoveExtension(relname);
 473         }
 474
 475         converters.Convert(buf, params.filename, outfile, extension, image_target);
 476
 477         return outfile;
 478 }
 479
 480
 481 int InsetGraphics::latex(Buffer const *buf, ostream & os,
 482                          bool /*fragile*/, bool/*fs*/) const
 483 {
 484         // MISSING: We have to decide how to do the order of the options
 485         // that is dependent of order, like width, height, angle. Should
 486         // we rotate before scale? Should we let the user decide?
 487         // bool rot_before_scale; ?
 488
 489         // (BE) As a first step we should do a scale before rotate since this is
 490         // more like the natural thought of how to do it.
 491         // (BE) I believe that a priority list presented to the user with
 492         // a default order would be the best, though it would be better to
 493         // hide such a thing in an "Advanced options" dialog.
 494         // (BE) This should go an advanced LaTeX options dialog.
 495
 496         // If there is no file specified, just output a message about it in
 497         // the latex output.
 498         if (params.filename.empty()) {
 499                 os  << "\\fbox{\\rule[-0.5in]{0pt}{1in}"
 500                         << _("empty figure path")
 501                         << "}\n";
 502
 503                 return 1; // One end of line marker added to the stream.
 504         }
 505
 506         // Keep count of newlines that we issued.
 507         int newlines = 0;
 508
 509         // This variables collect all the latex code that should be before and
 510         // after the actual includegraphics command.
 511         string before;
 512         string after;
 513
 514         // If it's not an inline image, surround it with the centering paragraph.
 515         if (! params.inlineFigure) {
 516                 before += "\n" "\\vspace{0.3cm}\n" "{\\par\\centering ";
 517                 after = " \\par}\n" "\\vspace{0.3cm}\n" + after;
 518                 newlines += 4;
 519         }
 520
 521         // Do we want subcaptions?
 522         if (params.subcaption) {
 523                 before += "\\subfigure[" + params.subcaptionText + "]{";
 524                 after = '}' + after;
 525         }
 526
 527         // We never use the starred form, we use the "clip" option instead.
 528         os << before << "\\includegraphics";
 529
 530         // Write the options if there are any.
 531         string const opts = createLatexOptions();
 532         if (!opts.empty()) {
 533                 os << '[' << opts << ']';
 534         }
 535
 536         // Make the filename relative to the lyx file
 537         // and remove the extension so the LaTeX will use whatever is
 538         // appropriate (when there are several versions in different formats)
 539         string const filename = prepareFile(buf);
 540
 541         os << '{' << filename << '}' << after;
 542
 543         // Return how many newlines we issued.
 544         return newlines;
 545 }
 546
 547
 548 int InsetGraphics::ascii(Buffer const *, ostream &, int) const
 549 {
 550         // No graphics in ascii output. Possible to use gifscii to convert
 551         // images to ascii approximation.
 552
 553         // 1. Convert file to ascii using gifscii
 554         // 2. Read ascii output file and add it to the output stream.
 555
 556         return 0;
 557 }
 558
 559
 560 int InsetGraphics::linuxdoc(Buffer const *, ostream &) const
 561 {
 562         // No graphics in LinuxDoc output. Should check how/what to add.
 563         return 0;
 564 }
 565
 566
 567 // For explanation on inserting graphics into DocBook checkout:
 568 // http://linuxdoc.org/LDP/LDP-Author-Guide/inserting-pictures.html
 569 // See also the docbook guide at http://www.docbook.org/
 570 int InsetGraphics::docBook(Buffer const * buf, ostream & os) const
 571 {
 572         // Change the path to be relative to the main file.
 573         string const buffer_dir = OnlyPath(buf->fileName());
 574         string const filename = RemoveExtension(
 575                                    MakeRelPath(params.filename, buffer_dir));
 576
 577         // In DocBook v5.0, the graphic tag will be eliminated from DocBook, will
 578         // need to switch to MediaObject. However, for now this is sufficient and
 579         // easier to use.
 580         os << "<graphic fileref=\"" << filename << "\"></graphic>";
 581         return 0;
 582 }
 583
 584
 585 void InsetGraphics::validate(LaTeXFeatures & features) const
 586 {
 587         // If we have no image, we should not require anything.
 588         if (params.filename.empty())
 589                 return ;
 590
 591         features.graphicx = true;
 592
 593         if (params.subcaption)
 594                 features.subfigure = true;
 595 }
 596
 597
 598 // Update the inset after parameters changed (read from file or changed in
 599 // dialog.
 600 void InsetGraphics::updateInset() const
 601 {
 602         GraphicsCache & gc = GraphicsCache::getInstance();
 603         boost::shared_ptr<GraphicsCacheItem> temp(0);
 604
 605         // We do it this way so that in the face of some error, we will still
 606         // be in a valid state.
 607         if (!params.filename.empty()) {
 608                 temp = gc.addFile(params.filename);
 609         }
 610
 611         // Mark the image as unloaded so that it gets updated.
 612         imageLoaded = false;
 613
 614         cacheHandle = temp;
 615 }
 616
 617
 618 bool InsetGraphics::setParams(InsetGraphicsParams const & p)
 619 {
 620         // If nothing is changed, just return and say so.
 621         if (params == p)
 622                 return false;
 623
 624         // Copy the new parameters.
 625         params = p;
 626
 627         // Update the inset with the new parameters.
 628         updateInset();
 629
 630         // We have changed data, report it.
 631         return true;
 632 }
 633
 634
 635 InsetGraphicsParams InsetGraphics::getParams() const
 636 {
 637         return params;
 638 }
 639
 640
 641 Inset * InsetGraphics::clone(Buffer const &, bool same_id) const
 642 {
 643         return new InsetGraphics(*this, same_id);
 644 }