src/frontends/xforms/xformsImage.C

   1 /**
   2  * \file xformsImage.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Angus Leeming
   7  *
   8  * Full author contact details are available in file CREDITS
   9  */
  10
  11 #include <config.h>
  12
  13 #ifdef __GNUG__
  14 #pragma implementation
  15 #endif
  16
  17 #include "xformsImage.h"
  18 #include "graphics/GraphicsParams.h"
  19 #include "LColor.h"
  20 #include "converter.h"              // formats
  21 #include "debug.h"
  22 #include "support/LAssert.h"
  23 #include "support/lyxfunctional.h"  // compare_memfun
  24
  25 #include FORMS_H_LOCATION
  26
  27 #ifdef HAVE_FLIMAGE_H
  28 # include <flimage.h>
  29 #else
  30 # ifdef HAVE_X11_FLIMAGE_H
  31 # include <X11/flimage.h>
  32 # endif
  33 #endif
  34
  35 #include <boost/tuple/tuple.hpp>
  36
  37 using std::find_if;
  38
  39 namespace {
  40
  41 void init_graphics();
  42
  43 unsigned int packedcolor(LColor::color c);
  44
  45 } // namespace anon
  46
  47
  48 namespace grfx {
  49
  50 /// Access to this class is through this static method.
  51 Image::ImagePtr xformsImage::newImage()
  52 {
  53         init_graphics();
  54
  55         ImagePtr ptr;
  56         ptr.reset(new xformsImage);
  57         return ptr;
  58 }
  59
  60
  61 /// Return the list of loadable formats.
  62 Image::FormatList xformsImage::loadableFormats()
  63 {
  64         static FormatList fmts;
  65         if (!fmts.empty())
  66                 return fmts;
  67
  68         init_graphics();
  69
  70         // The formats recognised by LyX
  71         Formats::const_iterator begin = formats.begin();
  72         Formats::const_iterator end   = formats.end();
  73
  74         lyxerr[Debug::GRAPHICS]
  75                 << "\nThe image loader can load the following directly:\n";
  76
  77         // Don't forget the Fortran numbering used by xforms!
  78         int const nformats = flimage_get_number_of_formats();
  79         for (int i = 1; i <= nformats; ++i) {
  80
  81                 FLIMAGE_FORMAT_INFO const * info = flimage_get_format_info(i);
  82                 string const formal_name =
  83                         info->formal_name ? info->formal_name : string();
  84                 string ext =
  85                         info->extension   ? info->extension   : string();
  86
  87                 if (ext.empty() || ext == "gz")
  88                         continue;
  89
  90                 if (ext == "rgb") ext = "sgi";
  91
  92                 lyxerr[Debug::GRAPHICS]
  93                         << formal_name << ", extension \"" << ext << "\"\n";
  94
  95                 Formats::const_iterator it =
  96                         find_if(begin, end,
  97                                 lyx::compare_memfun(&Format::extension, ext));
  98                 if (it != end)
  99                         fmts.push_back(it->name());
 100         }
 101
 102         lyxerr[Debug::GRAPHICS]
 103                 << "\nOf these, LyX recognises the following formats:\n";
 104
 105         FormatList::const_iterator fbegin = fmts.begin();
 106         FormatList::const_iterator fend   = fmts.end();
 107         for (FormatList::const_iterator fit = fbegin; fit != fend; ++fit) {
 108                 if (fit != fbegin)
 109                         lyxerr[Debug::GRAPHICS] << ", ";
 110                 lyxerr[Debug::GRAPHICS] << *fit;
 111         }
 112         lyxerr[Debug::GRAPHICS] << '\n' << std::endl;
 113
 114         return fmts;
 115 }
 116
 117
 118 xformsImage::xformsImage()
 119         : image_(0),
 120           pixmap_(0),
 121           pixmap_status_(PIXMAP_UNINITIALISED)
 122 {}
 123
 124
 125 xformsImage::xformsImage(xformsImage const & other)
 126         : Image(other),
 127           image_(0),
 128           pixmap_(0),
 129           pixmap_status_(PIXMAP_UNINITIALISED)
 130 {
 131         if (other.image_) {
 132                 image_ = flimage_dup(other.image_);
 133                 image_->u_vdata = this;
 134         }
 135 }
 136
 137
 138 xformsImage::~xformsImage()
 139 {
 140         if (image_)
 141                 flimage_free(image_);
 142         if (pixmap_)
 143                 XFreePixmap(fl_get_display(), pixmap_);
 144 }
 145
 146
 147 Image * xformsImage::clone() const
 148 {
 149         return new xformsImage(*this);
 150 }
 151
 152
 153 unsigned int xformsImage::getWidth() const
 154 {
 155         if (!image_)
 156                 return 0;
 157
 158         // Why, oh why, do we need such hacks?
 159         // Angus 12 July 2002
 160         return image_->w + 4;
 161 }
 162
 163
 164 unsigned int xformsImage::getHeight() const
 165 {
 166         if (!image_)
 167                 return 0;
 168         return image_->h;
 169 }
 170
 171
 172 bool xformsImage::isDrawable() const
 173 {
 174         return pixmap_;
 175 }
 176
 177
 178 Pixmap xformsImage::getPixmap() const
 179 {
 180         if (!pixmap_status_ == PIXMAP_SUCCESS)
 181                 return 0;
 182         return pixmap_;
 183 }
 184
 185
 186 void xformsImage::load(string const & filename)
 187 {
 188         if (image_) {
 189                 lyxerr[Debug::GRAPHICS]
 190                         << "Image is loaded already!" << std::endl;
 191                 finishedLoading(false);
 192                 return;
 193         }
 194
 195         image_ = flimage_open(filename.c_str());
 196         if (!image_) {
 197                 lyxerr[Debug::GRAPHICS]
 198                         << "Unable to open image" << std::endl;
 199                 finishedLoading(false);
 200                 return;
 201         }
 202
 203         // Set this now and we won't need to bother again.
 204         image_->fill_color = packedcolor(LColor::graphicsbg);
 205
 206         // Used by the callback routines to return to this
 207         image_->u_vdata = this;
 208
 209         // Begin the reading process.
 210         flimage_read(image_);
 211 }
 212
 213
 214 bool xformsImage::setPixmap(Params const & params)
 215 {
 216         if (!image_ || params.display == NoDisplay)
 217                 return false;
 218
 219         Display * display = fl_get_display();
 220
 221         if (pixmap_ && pixmap_status_ == PIXMAP_SUCCESS)
 222                 XFreePixmap(display, pixmap_);
 223
 224         int color_key;
 225         switch (params.display) {
 226         case MonochromeDisplay:
 227                 color_key = FL_IMAGE_MONO;
 228                 break;
 229         case GrayscaleDisplay:
 230                 color_key = FL_IMAGE_GRAY;
 231                 break;
 232         case ColorDisplay:
 233         default: // NoDisplay cannot happen!
 234                 color_key = FL_IMAGE_RGB;
 235                 break;
 236         }
 237
 238         if (color_key != FL_IMAGE_RGB) {
 239                 flimage_convert(image_, color_key, 0);
 240         }
 241
 242         unsigned int fill = packedcolor(LColor::graphicsbg);
 243         if (fill != image_->fill_color) {
 244                 // the background color has changed.
 245                 // Note that in grayscale/monochrome images the background is
 246                 // grayed also, so this call will have no visible effect. Sorry!
 247                 flimage_replace_pixel(image_, image_->fill_color, fill);
 248                 image_->fill_color = fill;
 249         }
 250
 251         image_->xdisplay = display;
 252         Screen * screen  = ScreenOfDisplay(display, fl_screen);
 253
 254         pixmap_ = flimage_to_pixmap(image_, XRootWindowOfScreen(screen));
 255         pixmap_status_ = pixmap_ ? PIXMAP_SUCCESS : PIXMAP_FAILED;
 256
 257         return pixmap_status_ == PIXMAP_SUCCESS;
 258 }
 259
 260
 261 void xformsImage::clip(Params const & params)
 262 {
 263         if (!image_)
 264                 return;
 265
 266         if (params.bb.empty())
 267                 // No clipping is necessary.
 268                 return;
 269
 270         int const new_width  = params.bb.xr - params.bb.xl;
 271         int const new_height = params.bb.yt - params.bb.yb;
 272
 273         // No need to check if the width, height are > 0 because the
 274         // Bounding Box would be empty() in this case.
 275         if (new_width > image_->w || new_height > image_->h)
 276                 // Bounds are invalid.
 277                 return;
 278
 279         if (new_width == image_->w && new_height == image_->h)
 280                 // Bounds are unchanged.
 281                 return;
 282
 283         // flimage.h: image_ members w and h are of type int
 284         // (though always >= 0)
 285         // GraphicsParams.h: params.bb members xl, xr, yt and yb are of
 286         // type unsigned int.
 287         // We must, therefore, be careful...
 288         int const xoffset_l = params.bb.xl;
 289         int const yoffset_b = params.bb.yb;
 290         int const xoffset_r = image_->w > params.bb.xr ?
 291                 image_->w - params.bb.xr : 0;
 292         int const yoffset_t = image_->h > params.bb.yt ?
 293                 image_->h - params.bb.yt : 0;
 294
 295         flimage_crop(image_, xoffset_l, yoffset_t, xoffset_r, yoffset_b);
 296 }
 297
 298
 299 void xformsImage::rotate(Params const & params)
 300 {
 301         if (!image_)
 302                 return ;
 303
 304         if (!params.angle)
 305                 // No rotation is necessary.
 306                 return;
 307
 308         // The angle passed to flimage_rotate is the angle in one-tenth of a
 309         // degree units.
 310
 311         // Work around xforms bug when params.angle == 270
 312         // the 'InternalError: bad special angle' error.
 313         // This bug fix is not needed in xforms 1.0 and greater.
 314         if (params.angle == 270) {
 315                 flimage_rotate(image_,  900, FLIMAGE_SUBPIXEL);
 316                 flimage_rotate(image_, 1800, FLIMAGE_SUBPIXEL);
 317         } else {
 318                 flimage_rotate(image_,
 319                                int(params.angle * 10),
 320                                FLIMAGE_SUBPIXEL);
 321         }
 322 }
 323
 324
 325 void xformsImage::scale(Params const & params)
 326 {
 327         if (!image_)
 328                 return;
 329
 330         unsigned int width;
 331         unsigned int height;
 332         boost::tie(width, height) = getScaledDimensions(params);
 333
 334         if (width == getWidth() && height == getHeight())
 335                 // No scaling needed
 336                 return;
 337
 338         flimage_scale(image_, width, height, FLIMAGE_SUBPIXEL);
 339 }
 340
 341
 342 void xformsImage::statusCB(string const & status_message)
 343 {
 344         if (status_message.empty())
 345                 return;
 346
 347         if (prefixIs(status_message, "Done Reading")) {
 348                 if (image_) {
 349                         flimage_close(image_);
 350                 }
 351
 352                 finishedLoading(true);
 353         }
 354 }
 355
 356
 357 void xformsImage::errorCB(string const & error_message)
 358 {
 359         if (error_message.empty())
 360                 return;
 361
 362         if (image_) {
 363                 flimage_close(image_);
 364         }
 365
 366         finishedLoading(false);
 367 }
 368
 369 } // namespace grfx
 370
 371
 372 namespace {
 373
 374 extern "C" {
 375
 376 int status_report(FL_IMAGE * ob, const char *s)
 377 {
 378         lyx::Assert(ob && ob->u_vdata);
 379
 380         string const str = s ? rtrim(s) : string();
 381         if (str.empty())
 382                 return 0;
 383
 384         lyxerr[Debug::GRAPHICS]
 385                 << "xforms image loader. Status : " << str << std::endl;
 386
 387         grfx::xformsImage * ptr =
 388                 static_cast<grfx::xformsImage *>(ob->u_vdata);
 389         ptr->statusCB(str);
 390
 391         return 0;
 392 }
 393
 394
 395 static void error_report(FL_IMAGE * ob, const char *s)
 396 {
 397         lyx::Assert(ob && ob->u_vdata);
 398
 399         string const str = s ? rtrim(s) : string();
 400         if (str.empty())
 401                 return;
 402
 403         lyxerr[Debug::GRAPHICS]
 404                 << "xforms image loader. Error : " << str << std::endl;
 405
 406         grfx::xformsImage * ptr =
 407                 static_cast<grfx::xformsImage *>(ob->u_vdata);
 408         ptr->errorCB(str);
 409 }
 410
 411 } // extern "C"
 412
 413
 414 void init_graphics()
 415 {
 416         // Paranoia check
 417         static bool initialised = false;
 418         if (initialised)
 419                 return;
 420         initialised = true;
 421
 422         flimage_enable_bmp();
 423         flimage_enable_fits();
 424         flimage_enable_gif();
 425 #ifdef HAVE_FLIMAGE_ENABLE_JPEG
 426         flimage_enable_jpeg();
 427 #endif
 428
 429         // xforms itself uses pngtopnm to convert to a loadable format.
 430         // We prefer to use our own conversion mechanism, therefore.
 431         // flimage_enable_png();
 432
 433         flimage_enable_pnm();
 434
 435 #ifdef HAVE_FLIMAGE_ENABLE_PS
 436         // xforms recognises PS but not EPS
 437         // It dies horribly with lots of older PostScript files.
 438         // Easiest, therefore, to disable PS support and insist that a PS-type
 439         // file is converted to a bitmap format.
 440         // flimage_enable_ps();
 441 #endif
 442
 443         flimage_enable_sgi();
 444         flimage_enable_tiff();
 445         flimage_enable_xbm();
 446         flimage_enable_xwd();
 447         flimage_enable_xpm();
 448
 449         // xforms stores this permanently (does not make a copy) so
 450         // this should never be destroyed.
 451         static FLIMAGE_SETUP setup;
 452         setup.visual_cue    = status_report;
 453         setup.error_message = error_report;
 454         flimage_setup(&setup);
 455 }
 456
 457
 458 unsigned int packedcolor(LColor::color c)
 459 {
 460         string const x11color = lcolor.getX11Name(c);
 461
 462         Display * display = fl_get_display();
 463         Colormap cmap     = fl_state[fl_get_vclass()].colormap;
 464         XColor xcol;
 465         XColor ccol;
 466         if (XLookupColor(display, cmap, x11color.c_str(), &xcol, &ccol) == 0)
 467                 // Unable to parse x11color.
 468                 return FL_PACK(255,255,255);
 469
 470         // Note that X stores the RGB values in the range 0 - 65535
 471         // whilst we require them in the range 0 - 255.
 472         unsigned int const r = xcol.red   / 256;
 473         unsigned int const g = xcol.green / 256;
 474         unsigned int const b = xcol.blue  / 256;
 475
 476         return FL_PACK(r, g, b);
 477 }
 478
 479 } // namespace anon