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 > image_->w || new_height > image_->h)
 255                 // Bounds are invalid.
 256                 return;
 257
 258         if (new_width == image_->w && new_height == image_->h)
 259                 // Bounds are unchanged.
 260                 return;
 261
 262         int const xoffset_l = params.bb.xl;
 263         int const xoffset_r = image_->w - params.bb.xr;
 264         int const yoffset_t = image_->h - params.bb.yt;
 265         int const yoffset_b = params.bb.yb;
 266
 267         flimage_crop(image_, xoffset_l, yoffset_t, xoffset_r, yoffset_b);
 268 }
 269
 270
 271 void xformsGImage::rotate(GParams const & params)
 272 {
 273         if (!image_)
 274                 return ;
 275
 276         if (!params.angle)
 277                 // No rotation is necessary.
 278                 return;
 279
 280         // The angle passed to flimage_rotate is the angle in one-tenth of a
 281         // degree units.
 282         flimage_rotate(image_, params.angle * 10, FLIMAGE_SUBPIXEL);
 283 }
 284
 285
 286 void xformsGImage::scale(GParams const & params)
 287 {
 288         if (!image_)
 289                 return;
 290
 291         // boost::tie produces horrible compilation errors on my machine
 292         // Angus 25 Feb 2002
 293         std::pair<unsigned int, unsigned int> d = getScaledDimensions(params);
 294         unsigned int const width  = d.first;
 295         unsigned int const height = d.second;
 296
 297         if (width == getWidth() && height == getHeight())
 298                 // No scaling needed
 299                 return;
 300
 301         flimage_scale(image_, width, height, FLIMAGE_SUBPIXEL);
 302 }
 303
 304
 305 void xformsGImage::statusCB(string const & status_message)
 306 {
 307         if (status_message.empty() || !on_finish_.get())
 308                 return;
 309
 310         if (prefixIs(status_message, "Done Reading")) {
 311                 on_finish_->emit(true);
 312                 on_finish_.reset();
 313         }
 314 }
 315
 316
 317 void xformsGImage::errorCB(string const & error_message)
 318 {
 319         if (error_message.empty() || !on_finish_.get())
 320                 return;
 321
 322         on_finish_->emit(false);
 323         on_finish_.reset();
 324 }
 325
 326 } // namespace grfx
 327
 328
 329 namespace {
 330
 331 extern "C" {
 332
 333 int status_report(FL_IMAGE * ob, const char *s)
 334 {
 335         lyx::Assert(ob && ob->u_vdata);
 336
 337         string const str = s ? strip(s) : string();
 338         if (str.empty())
 339                 return 0;
 340
 341         lyxerr[Debug::GRAPHICS]
 342                 << "xforms image loader. Status : " << str << std::endl;
 343
 344         grfx::xformsGImage * ptr =
 345                 static_cast<grfx::xformsGImage *>(ob->u_vdata);
 346         ptr->statusCB(str);
 347
 348         return 0;
 349 }
 350
 351
 352 static void error_report(FL_IMAGE * ob, const char *s)
 353 {
 354         lyx::Assert(ob && ob->u_vdata);
 355
 356         string const str = s ? strip(s) : string();
 357         if (str.empty())
 358                 return;
 359
 360         lyxerr[Debug::GRAPHICS]
 361                 << "xforms image loader. Error : " << str << std::endl;
 362
 363         grfx::xformsGImage * ptr =
 364                 static_cast<grfx::xformsGImage *>(ob->u_vdata);
 365         ptr->errorCB(str);
 366 }
 367
 368 } // extern "C"
 369
 370
 371 void init_graphics()
 372 {
 373         // Paranoia check
 374         static bool initialised = false;
 375         if (initialised)
 376                 return;
 377         initialised = true;
 378
 379         flimage_enable_bmp();
 380         flimage_enable_fits();
 381         flimage_enable_gif();
 382         flimage_enable_jpeg();
 383
 384         // xforms itself uses pngtopnm to convert to a loadable format.
 385         // We prefer to use our own conversion mechanism, therefore.
 386         // flimage_enable_png();
 387
 388         flimage_enable_pnm();
 389
 390 #ifdef HAVE_FLIMAGE_ENABLE_PS
 391         // xforms recognises PS but not EPS
 392         flimage_enable_ps();
 393 #endif
 394
 395         flimage_enable_sgi();
 396         flimage_enable_tiff();
 397         flimage_enable_xbm();
 398         flimage_enable_xwd();
 399         flimage_enable_xpm();
 400
 401         FLIMAGE_SETUP setup;
 402         setup.visual_cue    = status_report;
 403         setup.error_message = error_report;
 404         flimage_setup(&setup);
 405 }
 406
 407
 408 unsigned int packedcolor(LColor::color c)
 409 {
 410         string const x11color = lcolor.getX11Name(c);
 411
 412         Display * display = GUIRunTime::x11Display();
 413         Colormap cmap     = GUIRunTime::x11Colormap();
 414         XColor xcol;
 415         XColor ccol;
 416         if (XLookupColor(display, cmap, x11color.c_str(), &xcol, &ccol) == 0)
 417                 // Unable to parse x11color.
 418                 return FL_PACK(255,255,255);
 419
 420         // Note that X stores the RGB values in the range 0 - 65535
 421         // whilst we require them in the range 0 - 255.
 422         unsigned int const r = xcol.red   / 256;
 423         unsigned int const g = xcol.green / 256;
 424         unsigned int const b = xcol.blue  / 256;
 425
 426         return FL_PACK(r, g, b);
 427 }
 428
 429 } // namespace anon