lyx_mirror/src/insets/render_graphic.C

/**
 * \file render_graphic.C
 * This file is part of LyX, the document processor.
 * Licence details can be found in the file COPYING.
 *
 * \author Angus Leeming
 *
 * Full author contact details are available in file CREDITS.
 */

#include <config.h>

#include "render_graphic.h"

#include "insets/inset.h"

#include "gettext.h"
#include "LColor.h"
#include "lyx_main.h"
#include "lyxrc.h"
#include "metricsinfo.h"

#include "frontends/Application.h"
#include "frontends/FontLoader.h"
#include "frontends/FontMetrics.h"
#include "frontends/Painter.h"

#include "graphics/GraphicsImage.h"

#include "support/filetools.h"

#include <boost/bind.hpp>

namespace graphics = lyx::graphics;

using lyx::docstring;
using lyx::support::absolutePath;
using lyx::support::onlyFilename;

using std::string;
using std::auto_ptr;


RenderGraphic::RenderGraphic(InsetBase const * inset)
{
	loader_.connect(boost::bind(&LyX::updateInset,
				    boost::cref(LyX::cref()), inset));
}


RenderGraphic::RenderGraphic(RenderGraphic const & other,
			     InsetBase const * inset)
	: RenderBase(other),
	  loader_(other.loader_),
	  params_(other.params_)
{
	loader_.connect(boost::bind(&LyX::updateInset,
				    boost::cref(LyX::cref()), inset));
}


auto_ptr<RenderBase> RenderGraphic::clone(InsetBase const * inset) const
{
	return auto_ptr<RenderBase>(new RenderGraphic(*this, inset));
}


void RenderGraphic::update(graphics::Params const & params)
{
	params_ = params;

	if (!params_.filename.empty()) {
		BOOST_ASSERT(absolutePath(params_.filename));
		loader_.reset(params_.filename, params_);
	}
}


namespace {

bool displayGraphic(graphics::Params const & params)
{
	return params.display != graphics::NoDisplay &&
		lyxrc.display_graphics != graphics::NoDisplay;
}


string const statusMessage(graphics::Params const & params,
			   graphics::ImageStatus status)
{
	docstring ret;

	if (!displayGraphic(params))
		ret = _("Not shown.");
	else {
		switch (status) {
		case graphics::WaitingToLoad:
			ret = _("Not shown.");
			break;
		case graphics::Loading:
			ret = _("Loading...");
			break;
		case graphics::Converting:
			ret = _("Converting to loadable format...");
			break;
		case graphics::Loaded:
			ret = _("Loaded into memory. Generating pixmap...");
			break;
		case graphics::ScalingEtc:
			ret = _("Scaling etc...");
			break;
		case graphics::Ready:
			ret = _("Ready to display");
			break;
		case graphics::ErrorNoFile:
			ret = _("No file found!");
			break;
		case graphics::ErrorConverting:
			ret = _("Error converting to loadable format");
			break;
		case graphics::ErrorLoading:
			ret = _("Error loading file into memory");
			break;
		case graphics::ErrorGeneratingPixmap:
			ret = _("Error generating the pixmap");
			break;
		case graphics::ErrorUnknown:
			ret = _("No image");
			break;
		}
	}

	// FIXME UNICODE
	return lyx::to_utf8(ret);
}


bool readyToDisplay(graphics::Loader const & loader)
{
	if (!loader.image() || loader.status() != graphics::Ready)
		return false;
	return loader.image()->isDrawable();
}

} // namespace anon


void RenderGraphic::metrics(MetricsInfo & mi, Dimension & dim) const
{
	bool image_ready = displayGraphic(params_) && readyToDisplay(loader_);

	dim.asc = image_ready ? loader_.image()->getHeight() : 50;
	dim.des = 0;

	if (image_ready) {
		dim.wid = loader_.image()->getWidth() +
			2 * InsetOld::TEXT_TO_INSET_OFFSET;
	} else {
		int font_width = 0;

		LyXFont msgFont(mi.base.font);
		msgFont.setFamily(LyXFont::SANS_FAMILY);

		string const justname = onlyFilename(params_.filename);
		docstring djust(justname.begin(), justname.end());
		if (!justname.empty()) {
			msgFont.setSize(LyXFont::SIZE_FOOTNOTE);
			font_width = theApp->fontLoader().metrics(msgFont)
				.width(djust);
		}

		string const msg = statusMessage(params_, loader_.status());
		if (!msg.empty()) {
			docstring dmsg(msg.begin(), msg.end());
			msgFont.setSize(LyXFont::SIZE_TINY);
			font_width = std::max(font_width, theApp->fontLoader()
				.metrics(msgFont).width(dmsg));
		}

		dim.wid = std::max(50, font_width + 15);
	}

	dim_ = dim;
}


void RenderGraphic::draw(PainterInfo & pi, int x, int y) const
{
	if (displayGraphic(params_)) {
		if (loader_.status() == graphics::WaitingToLoad)
			loader_.startLoading();
		if (!loader_.monitoring())
			loader_.startMonitoring();
	}

	// This will draw the graphics. If the graphics has not been
	// loaded yet, we draw just a rectangle.

	if (displayGraphic(params_) && readyToDisplay(loader_)) {
		pi.pain.image(x + InsetOld::TEXT_TO_INSET_OFFSET,
			      y - dim_.asc,
			      dim_.wid - 2 * InsetOld::TEXT_TO_INSET_OFFSET,
			      dim_.asc + dim_.des,
			      *loader_.image());

	} else {
		pi.pain.rectangle(x + InsetOld::TEXT_TO_INSET_OFFSET,
				  y - dim_.asc,
				  dim_.wid - 2 * InsetOld::TEXT_TO_INSET_OFFSET,
				  dim_.asc + dim_.des,
				  LColor::foreground);

		// Print the file name.
		LyXFont msgFont = pi.base.font;
		msgFont.setFamily(LyXFont::SANS_FAMILY);
		string const justname = onlyFilename(params_.filename);

		if (!justname.empty()) {
			docstring djust(justname.begin(), justname.end());
			msgFont.setSize(LyXFont::SIZE_FOOTNOTE);
			pi.pain.text(x + InsetOld::TEXT_TO_INSET_OFFSET + 6,
				   y - theApp->fontLoader().metrics(msgFont).maxAscent() - 4,
				   djust, msgFont);
		}

		// Print the message.
		string const msg = statusMessage(params_, loader_.status());
		if (!msg.empty()) {
			docstring dmsg(msg.begin(), msg.end());
			msgFont.setSize(LyXFont::SIZE_TINY);
			pi.pain.text(x + InsetOld::TEXT_TO_INSET_OFFSET + 6,
				     y - 4, dmsg, msgFont);
		}
	}
}