--- /dev/null
+/*
+ * \file QLImage.C
+ * Copyright 2002 the LyX Team
+ * Read the file COPYING
+ *
+ * \author Angus Leeming, a.leeming@ic.ac.uk
+ * \author John Levon <moz@compsoc.man.ac.uk>
+ */
+
+#include <config.h>
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "QLImage.h"
+#include "graphics/GraphicsParams.h"
+#include "converter.h"
+#include "debug.h"
+#include "support/LAssert.h"
+#include "support/lyxfunctional.h" // compare_memfun
+
+#include <qimage.h>
+#include <qwmatrix.h>
+#include <qpainter.h>
+
+#include <boost/tuple/tuple.hpp>
+
+using std::find_if;
+
+namespace grfx {
+
+/// Access to this class is through this static method.
+Image::ImagePtr QLImage::newImage()
+{
+ ImagePtr ptr;
+ ptr.reset(new QLImage);
+ return ptr;
+}
+
+
+/// Return the list of loadable formats.
+Image::FormatList QLImage::loadableFormats()
+{
+ static FormatList fmts;
+
+ if (!fmts.empty())
+ return fmts;
+
+ // The formats recognised by LyX
+ Formats::const_iterator begin = formats.begin();
+ Formats::const_iterator end = formats.end();
+
+ lyxerr[Debug::GRAPHICS]
+ << "\nThe image loader can load the following directly:\n";
+
+ QStrList qt_formats = QImageIO::inputFormats();
+
+ QStrListIterator it(qt_formats);
+
+ for (; it.current(); ++it) {
+ lyxerr[Debug::GRAPHICS] << it.current() << endl;
+
+ string ext = lowercase(it.current());
+
+ // special case
+ if (ext == "jpeg")
+ ext = "jpg";
+
+ Formats::const_iterator fit =
+ find_if(begin, end, lyx::compare_memfun(&Format::extension, ext));
+ if (fit != end)
+ fmts.push_back(fit->name());
+ }
+
+ lyxerr[Debug::GRAPHICS]
+ << "\nOf these, LyX recognises the following formats:\n";
+
+ FormatList::const_iterator fbegin = fmts.begin();
+ FormatList::const_iterator fend = fmts.end();
+ for (FormatList::const_iterator fit = fbegin; fit != fend; ++fit) {
+ if (fit != fbegin)
+ lyxerr[Debug::GRAPHICS] << ", ";
+ lyxerr[Debug::GRAPHICS] << *fit;
+ }
+ lyxerr[Debug::GRAPHICS] << '\n' << std::endl;
+
+ return fmts;
+}
+
+
+QLImage::QLImage()
+ : Image()
+{
+}
+
+
+QLImage::QLImage(QLImage const & other)
+ : Image(other), pixmap_(other.pixmap_)
+{
+}
+
+
+QLImage::~QLImage()
+{
+}
+
+
+Image * QLImage::clone() const
+{
+ return new QLImage(*this);
+}
+
+
+unsigned int QLImage::getWidth() const
+{
+ return pixmap_.width();
+}
+
+
+unsigned int QLImage::getHeight() const
+{
+ return pixmap_.height();
+}
+
+
+// FIXME
+Pixmap QLImage::getPixmap() const
+{
+ return 1;
+}
+
+
+void QLImage::load(string const & filename)
+{
+ if (!pixmap_.isNull()) {
+ lyxerr[Debug::GRAPHICS]
+ << "Image is loaded already!" << std::endl;
+ finishedLoading(false);
+ return;
+ }
+
+ if (!pixmap_.load(filename.c_str())) {
+ lyxerr[Debug::GRAPHICS]
+ << "Unable to open image" << std::endl;
+ finishedLoading(false);
+ return;
+ }
+ finishedLoading(true);
+}
+
+
+bool QLImage::setPixmap(Params const & params)
+{
+ if (pixmap_.isNull() || params.display == NoDisplay)
+ return false;
+
+// FIXME
+#if 0
+ int color_key;
+ switch (params.display) {
+ case MonochromeDisplay:
+ color_key = FL_IMAGE_MONO;
+ break;
+ case GrayscaleDisplay:
+ color_key = FL_IMAGE_GRAY;
+ break;
+ case ColorDisplay:
+ default: // NoDisplay cannot happen!
+ color_key = FL_IMAGE_RGB;
+ break;
+ }
+
+ if (color_key != FL_IMAGE_RGB) {
+ flimage_convert(image_, color_key, 0);
+ }
+
+ unsigned int fill = packedcolor(LColor::graphicsbg);
+ if (fill != image_->fill_color) {
+ // the background color has changed.
+ // Note that in grayscale/monochrome images the background is
+ // grayed also, so this call will have no visible effect. Sorry!
+ flimage_replace_pixel(image_, image_->fill_color, fill);
+ image_->fill_color = fill;
+ }
+#endif
+
+ xformed_pixmap_ = pixmap_;
+ return true;
+}
+
+
+void QLImage::clip(Params const & params)
+{
+ if (pixmap_.isNull())
+ return;
+
+ if (params.bb.empty())
+ // No clipping is necessary.
+ return;
+
+ int const new_width = params.bb.xr - params.bb.xl;
+ int const new_height = params.bb.yt - params.bb.yb;
+
+ // No need to check if the width, height are > 0 because the
+ // Bounding Box would be empty() in this case.
+ if (new_width > pixmap_.width() || new_height > pixmap_.height()) {
+ // Bounds are invalid.
+ return;
+ }
+
+ if (new_width == pixmap_.width() && new_height == pixmap_.height())
+ return;
+
+ int const xoffset_l = std::max(0, params.bb.xl);
+ int const yoffset_t = std::max(0, pixmap_.height() - params.bb.yt);
+
+ xformed_pixmap_.resize(new_width, new_height);
+ QPainter p;
+ p.begin(&xformed_pixmap_);
+ p.drawPixmap(0, 0, pixmap_, xoffset_l, yoffset_t, new_width, new_height);
+ p.end();
+}
+
+
+void QLImage::rotate(Params const & params)
+{
+ if (xformed_pixmap_.isNull())
+ return;
+
+ if (!params.angle)
+ return;
+
+ // The angle passed to flimage_rotate is the angle in one-tenth of a
+ // degree units.
+
+ QWMatrix m;
+ m.rotate(params.angle / 10.0);
+ xformed_pixmap_.xForm(m);
+}
+
+
+void QLImage::scale(Params const & params)
+{
+ if (xformed_pixmap_.isNull())
+ return;
+
+ unsigned int width;
+ unsigned int height;
+ boost::tie(width, height) = getScaledDimensions(params);
+
+ if (width == getWidth() && height == getHeight())
+ return;
+
+ xformed_pixmap_.resize(width, height);
+}
+
+} // namespace grfx
--- /dev/null
+// -*- C++ -*-
+/**
+ * \file QLImage.h
+ * Copyright 2002 the LyX Team
+ * Read the file COPYING
+ *
+ * \author Angus Leeming, a.leeming@ic.ac.uk
+ * \author John Levon <moz@compsoc.man.ac.uk>
+ */
+
+#ifndef QLIMAGE_H
+#define QLIMAGE_H
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "graphics/GraphicsImage.h"
+
+#include <qpixmap.h>
+
+namespace grfx {
+
+class QLImage : public Image
+{
+public:
+ /// Access to this class is through this static method.
+ static ImagePtr newImage();
+
+ /// Return the list of loadable formats.
+ static FormatList loadableFormats();
+
+ ~QLImage();
+
+ /// Create a copy
+ virtual Image * clone() const;
+
+ /// FIXME
+ virtual Pixmap getPixmap() const;
+
+ QPixmap const & qpixmap() const { return xformed_pixmap_; }
+
+ /// Get the image width
+ virtual unsigned int getWidth() const;
+
+ /// Get the image height
+ virtual unsigned int getHeight() const;
+
+ /**
+ * Load the image file into memory.
+ * The process is asynchronous, so this method starts the loading.
+ * When finished, the Image::finishedLoading signal is emitted.
+ */
+ virtual void load(string const & filename);
+
+ /**
+ * Generate the pixmap, based on the current state of
+ * image_ (clipped, rotated, scaled etc).
+ * Uses the params to decide on color, grayscale etc.
+ * Returns true if the pixmap is created.
+ */
+ virtual bool setPixmap(Params const & params);
+
+ /// Clip the image using params.
+ virtual void clip(Params const & params);
+
+ /// Rotate the image using params.
+ virtual void rotate(Params const & params);
+
+ /// Scale the image using params.
+ virtual void scale(Params const & params);
+
+private:
+ /// Access to the class is through newImage() and clone.
+ QLImage();
+ ///
+ QLImage(QLImage const &);
+
+ /// the original loaded image
+ QPixmap pixmap_;
+
+ /// the transformed pixmap for display
+ QPixmap xformed_pixmap_;
+};
+
+} // namespace grfx
+
+#endif // QLIMAGE_H
projects / features.git / commitdiff