src/frontends/xforms/xformsGImage.C

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