anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-09-21 07:12:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Cleaned up cruft in InsetGraphics.

Browse Source 
Added the auto-conversion of images to InsetGraphics, this adds support
for bitmap images.
Modified the mechanism of image loading for inline viewing - still not
working though.


git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@1457 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
Baruch Even 2001-02-08 13:06:55 +00:00
parent f490ae76ab
commit 39b3fd44b9
15 changed files with 284 additions and 627 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/frontends/support/ChangeLog
View File

@ -0,0 +1,10 @@
2001-01-21 Baruch Even <baruch@ev-en.org>
* LyXImage.h:
* LyXImage.C: Removal of the #pragma interface/implementation because of
bad interaction with the inclusion of the real implementation, it resulted
in errors while linking.
* LyXImage_X.h:
* LyXImage_X.C: Stored the width and height of the image in the image
object.

4
src/frontends/support/LyXImage.C
View File

@ -9,10 +9,6 @@
* This file Copyright 2000 Baruch Even
* ================================================= */
#ifdef __GNUG__
#pragma implementation
#endif
#include <config.h>
#include "LyXImage.h"

4
src/frontends/support/LyXImage.h
View File

@ -12,10 +12,6 @@
#ifndef LYXIMAGE_H
#define LYXIMAGE_H
#ifdef __GNUG__
#pragma interface
#endif
// We need it to know what version to use.
#include <config.h>

10
src/frontends/support/LyXImage_X.C
View File

@ -9,10 +9,6 @@
* This file Copyright 2000 Baruch Even
* ================================================= */
#ifdef __GNUG__
#pragma implementation
#endif
#include <config.h>
#include "LyXImage.h"
@ -21,11 +17,11 @@
#include "support/LAssert.h"
LyXImage::LyXImage()
: pixmap_(0), pixmapInitialized(false)
: pixmap_(0), pixmapInitialized(false), width_(0), height_(0)
{}
LyXImage::LyXImage(Pixmap pixmap)
: pixmap_(pixmap), pixmapInitialized(true)
LyXImage::LyXImage(Pixmap pixmap, unsigned int width, unsigned int height)
: pixmap_(pixmap), pixmapInitialized(true), width_(width), height_(height)
{}
LyXImage::~LyXImage()

16
src/frontends/support/LyXImage_X.h
View File

@ -12,10 +12,6 @@
#ifndef LYXIMAGE_X_H
#define LYXIMAGE_X_H
#ifdef __GNUG__
#pragma interface
#endif
#include "frontends/support/LyXImage.h"
#include <X11/Xlib.h>
@ -26,18 +22,28 @@ public:
///
LyXImage();
///
LyXImage(Pixmap pixmap);
LyXImage(Pixmap pixmap, unsigned int width, unsigned int height);
///
~LyXImage();
///
Pixmap getPixmap() const;
/// Get the image width
unsigned int getWidth() const { return width_; }
/// Get the image height
unsigned int getHeight() const { return height_; }
private:
/// The pixmap itself.
Pixmap pixmap_;
/// Is the pixmap initialized?
bool pixmapInitialized;
/// Width of the image
unsigned int width_;
/// Height of the image
unsigned int height_;
};
#endif

8
src/graphics/ChangeLog
View File

@ -0,0 +1,8 @@
2001-01-21 Baruch Even <baruch@ev-en.org>
* GraphicsCacheItem.[Ch]: Changes due to the storage of width and height
in the image itself and minor cleanups.
* GraphicsCacheItem_impl.[Ch]: Changes due to the switch to use a new
ImageLoader class instead of the older Renderer class. This means change
of responsibilities.

15
src/graphics/GraphicsCacheItem.C
View File

@ -43,8 +43,9 @@ GraphicsCacheItem::setFilename(string const & filename)
GraphicsCacheItem::GraphicsCacheItem(GraphicsCacheItem const & gci)
: pimpl(0)
{
pimpl = 0;
// copy will set the actual value of the pimpl.
copy(gci);
}
@ -88,7 +89,7 @@ GraphicsCacheItem::destroy()
// even before it is deleted.
GraphicsCacheItem_pimpl * temp = pimpl;
pimpl = 0;
delete temp;
delete temp; temp = 0;
}
GraphicsCache * gc = GraphicsCache::getInstance();
gc->removeFile(filename_);
@ -100,13 +101,5 @@ GraphicsCacheItem::destroy()
GraphicsCacheItem::ImageStatus
GraphicsCacheItem::getImageStatus() const { return pimpl->imageStatus_; }
int
GraphicsCacheItem::getHeight() const { return pimpl->height_; }
int
GraphicsCacheItem::getWidth() const { return pimpl->width_; }
LyXImage *
GraphicsCacheItem::getImage() const { return pimpl->pixmap_; }
GraphicsCacheItem::getImage() const { return pimpl->getImage(); }

6
src/graphics/GraphicsCacheItem.h
View File

@ -49,12 +49,6 @@ public:
/// Assignment operator.
GraphicsCacheItem & operator=(GraphicsCacheItem const &);
/// Get the height of the image. Returns -1 on error.
int getHeight() const;
/// Get the width of the image. Returns -1 on error.
int getWidth() const;
/// Return a pixmap that can be displayed on X server.
LyXImage * getImage() const;
///

29
src/graphics/GraphicsCacheItem_pimpl.C
View File

@ -23,8 +23,7 @@
#include "GraphicsCacheItem_pimpl.h"
#include "frontends/support/LyXImage.h"
#include "graphics/XPM_Renderer.h"
#include "graphics/EPS_Renderer.h"
#include "ImageLoaderXPM.h"
#include "support/filetools.h"
#include "debug.h"
#include "support/LAssert.h"
@ -34,24 +33,24 @@ using std::map;
GraphicsCacheItem_pimpl::GraphicsCacheItem_pimpl()
: height_(-1), width_(-1), imageStatus_(GraphicsCacheItem::Loading),
pixmap_(0), renderer(0), refCount(0)
: imageStatus_(GraphicsCacheItem::Loading),
image_(0), imageLoader(0), refCount(0)
{}
GraphicsCacheItem_pimpl::~GraphicsCacheItem_pimpl()
{
delete pixmap_;
delete renderer;
delete image_; image_ = 0;
delete imageLoader; imageLoader = 0;
}
bool
GraphicsCacheItem_pimpl::setFilename(string const & filename)
{
imageLoader = new ImageLoaderXPM();
imageStatus_ = GraphicsCacheItem::Loading;
renderer = new XPM_Renderer();
if (renderXPM(filename))
return true;
@ -66,7 +65,7 @@ static CallbackMap callbackMap;
void
callback(string cmd, int retval)
static callback(string cmd, int retval)
{
lyxerr << "callback, cmd=" << cmd << ", retval=" << retval << endl;
@ -83,6 +82,8 @@ GraphicsCacheItem_pimpl::imageConverted(int retval)
lyxerr << "imageConverted, retval=" << retval << endl;
if (retval) {
lyxerr << "(GraphicsCacheItem_pimpl::imageConverter) "
"Error converting image." << endl;
imageStatus_ = GraphicsCacheItem::ErrorConverting;
return;
}
@ -133,16 +134,14 @@ GraphicsCacheItem_pimpl::renderXPM(string const & filename)
void
GraphicsCacheItem_pimpl::loadXPMImage()
{
if (!renderer->setFilename(xpmfile)) {
return;
}
lyxerr << "Loading XPM Image... ";
if (renderer->renderImage()) {
pixmap_ = renderer->getPixmap();
width_ = renderer->getWidth();
height_ = renderer->getHeight();
if (imageLoader->loadImage(xpmfile)) {
lyxerr << "Success." << endl;
image_ = imageLoader->getImage();
imageStatus_ = GraphicsCacheItem::Loaded;
} else {
lyxerr << "Fail." << endl;
imageStatus_ = GraphicsCacheItem::ErrorReading;
}

18
src/graphics/GraphicsCacheItem_pimpl.h
View File

@ -22,7 +22,7 @@
#include XPM_H_LOCATION
#include "LString.h"
#include "graphics/Renderer.h"
#include "graphics/ImageLoader.h"
#include "support/syscall.h"
#include "sigc++/signal_system.h"
@ -38,14 +38,8 @@ public:
/// d-tor, frees the image structures.
~GraphicsCacheItem_pimpl();
/// Get the height of the image. Returns -1 on error.
int getHeight() const;
/// Get the width of the image. Returns -1 on error.
int getWidth() const;
/// Return a pixmap that can be displayed on X server.
LyXImage * getImage() const;
LyXImage * getImage() const { return image_; };
typedef GraphicsCacheItem::ImageStatus ImageStatus;
@ -74,16 +68,12 @@ private:
/// The file name of the XPM file.
string xpmfile;
/// The image height
int height_;
/// The image width
int width_;
/// Is the pixmap loaded?
ImageStatus imageStatus_;
/// The image pixmap
LyXImage * pixmap_;
LyXImage * image_;
/// The rendering object.
Renderer * renderer;
ImageLoader * imageLoader;
/// The system caller, runs the convertor.
Systemcalls syscall;

10
src/graphics/Makefile.am
View File

@ -8,15 +8,13 @@ BOOST_INCLUDES = -I$(top_srcdir)/boost
INCLUDES = -I${srcdir}/../ $(SIGC_CFLAGS) $(BOOST_INCLUDES)
libgraphics_la_SOURCES = \
Renderer.h \
Renderer.C \
XPM_Renderer.h \
XPM_Renderer.C \
EPS_Renderer.h \
EPS_Renderer.C \
GraphicsCache.h \
GraphicsCache.C \
GraphicsCacheItem.h \
GraphicsCacheItem.C \
GraphicsCacheItem_pimpl.h \
GraphicsCacheItem_pimpl.C \
ImageLoaderXPM.h \
ImageLoaderXPM.C \
ImageLoader.h \
ImageLoader.C

16
src/insets/ChangeLog
View File

@ -1,3 +1,19 @@
2001-02-05 Baruch Even <baruch.even@writeme.com>
* insetgraphics.C: Updated automatic image conversion, it now goes into
temporary directory instead of with the image itself.
2001-01-21 Baruch Even <baruch@ev-en.org>
* insetgraphics.C: Added Docbook support. Added Automatic image conversion
to EPS or PNG when needed (support bitmap graphics).
2000-11-02 Baruch Even <baruch@ev-en.org>
* insetgraphics.C:
* insetgraphiscParams.C: Some cleaning up, changing from std::endl to '\n'
and removal of commented out code.
2001-01-31 Dekel Tsur <dekelts@tau.ac.il>
* insetbib.C (callback): Update citations if the key has changed.

456
src/insets/insetgraphics.C
View File

@ -17,9 +17,11 @@ How to use it for now:
Immediate tasks:
* Make the inline viewing work, there is a preliminary work going on,
need to finish it up.
* Support automatic image format conversion, create both a PNG and EPS output.
* Polishing tasks:
* Add messages in the empty rectangle to say how are we doing.
* Add messages in the empty rectangle (in the buffer view) to say how are
we doing.
- Implemented, needs testing.
* Clean up GraphicsCacheItem(_pimpl)
* Pop up a dialog if the widget version is higher than what we accept.
@ -40,26 +42,12 @@ Known BUGS:
* Bug in FileDlg class (src/filedlg.[hC]) when selecting a file and then
pressing ok, it counts as if no real selection done. Apparently
when choosing a file it doesn't update the select file input line.
* Inline viewing is still not completely operational, in fact it is no
* Inline viewing is still not completely operational, in fact it is now
disabled. To enable it enable the define:
INSETGRAPHICS_INLINE_VIEW
Current PROBLEMS:
* How to support both PDF and PS output, should we do the conversion
or should we just give the bounding box and tell latex how to do the
conversion itself?
I (Baruch Even) tend towards doing the conversion ourselves, otherwise
we need to give latex quite a few translation commands and from the
graphicx package docs it appears that it takes quite a bit of memory
on the side of TeXing.
TODO Basics:
* Add support for more features so that it will be better than insetfig.
* Keep aspect ratio radio button
* Work on inline viewing of image.
* If we are trying to create a file in a read-only directory and there
are graphics that need converting, the converting will fail because
it is done in-place, into the same directory as the original image.
TODO Before initial production release:
* Replace insetfig everywhere
@ -77,13 +65,14 @@ TODO Before initial production release:
TODO Extended features:
* Advanced Latex tab folder.
* Add even more options to make it better than insetfig.
* Add support for more features so that it will be better than insetfig.
* Keep aspect ratio radio button
* Support for complete control over the latex parameters for TeXperts
* What advanced features the users want to do?
Implement them in a non latex dependent way, but a logical way.
LyX should translate it to latex or any other fitting format.
* Add a way to roll the image file into the file format.
* When loading if the image is not found in the expected place, try
* When loading, if the image is not found in the expected place, try
to find it in the clipart, or in the same directory with the image.
* Keep a tab on the image file, if it changes, update the lyx view.
* The image choosing dialog could show thumbnails of the image formats
@ -134,36 +123,14 @@ TODO Extended features:
* documents (i.e. prefer imagemagick eps2png over eps2pdf)
*/
/* Current Stage:
* Embryonic.
*
* PLAN:
* Finish basic support:
* Inline image viewing
*
* Do Release quality support:
* Allow to change display depth
* Make default figure instead of InsetFig
* Add to LyX (probably after 1.1.6 is released)
*
* Extended features:
* Output format conversion
* Print depth changes
* Image file tracking of changes.
*
* Extended^2:
* Image roll-in (how? when? why?)
* This means to add the image inside the LyX file, usefull when
* transferring the file around.
*/
#include <config.h>
#ifdef __GNUG__
#pragma implementation
#endif
#define INSETGRAPHICS_INLINE_VIEW
#include "insets/insetgraphics.h"
#include "insets/insetgraphicsParams.h"
#include "graphics/GraphicsCache.h"
@ -177,29 +144,33 @@ TODO Extended features:
#include "frontends/support/LyXImage.h"
#include "Painter.h"
#include "lyx_gui_misc.h"
#include "filedlg.h"
#include "support/FileInfo.h"
#include "support/filetools.h"
#include "support/lyxlib.h"
#include "lyxtext.h"
#include "lyxrc.h"
#include "font.h" // For the lyxfont class.
#include <algorithm> // For the std::max
#include "lyxrc.h"
#include "support/lyxmanip.h"
#include "debug.h"
extern string system_tempdir;
using std::ostream;
using std::endl;
using std::max;
// This function is a utility function
inline
string const RemoveExtension(string const & filename)
{
return ChangeExtension(filename, string());
}
// Initialize only those variables that do not have a constructor.
InsetGraphics::InsetGraphics()
#ifdef IG_OLDPARAMS
: use_bb(false), hiresbb(false), angle(0.0), origin(DEFAULT)
, keepaspectratio(false), scale(0.0), clip(false), draft(false)
, cacheHandle(0)
#endif
: cacheHandle(0), pixmap(0), pixmapInitialized(false)
: cacheHandle(0), pixmap(0), updateImage(false)
{}
InsetGraphics::~InsetGraphics()
@ -214,7 +185,8 @@ InsetGraphics::statusMessage() const
char const * msg = 0;
#ifdef INSETGRAPHICS_INLINE_VIEW
switch (status) {
if (cacheHandle) {
switch (cacheHandle->getImageStatus()) {
case GraphicsCacheItem::UnknownError:
msg = _("Unknown Error");
break;
@ -235,6 +207,7 @@ InsetGraphics::statusMessage() const
// No message to write.
break;
}
}
#else
msg = _("Inline view disabled");
#endif
@ -244,8 +217,8 @@ InsetGraphics::statusMessage() const
int InsetGraphics::ascent(BufferView *, LyXFont const &) const
{
if (pixmapInitialized)
return cacheHandle->getHeight();
if (pixmap)
return pixmap->getHeight();
else
return 50;
}
@ -260,35 +233,46 @@ int InsetGraphics::descent(BufferView *, LyXFont const &) const
int InsetGraphics::width(BufferView *, LyXFont const & font) const
{
if (pixmapInitialized)
return cacheHandle->getWidth();
if (pixmap)
return pixmap->getWidth();
else {
char const * msg = statusMessage();
int font_width = lyxfont::width(msg, font);
int font_width = 0;
if (msg)
font_width = lyxfont::width(msg, font);
return max(50, font_width + 15);
}
}
void InsetGraphics::draw(BufferView * bv, LyXFont const & font,
int baseline, float & x, bool) const
{
Painter & paint = bv->painter();
int lwidth = width(bv, font);
int ldescent = descent(bv, font);
int lascent = ascent(bv, font);
int lwidth = width(bv, font);
// Make sure x is updated upon exit from this routine
float old_x = x;
x += lwidth;
// This will draw the graphics. If the graphics has not been loaded yet,
// we draw just a rectangle.
if (pixmapInitialized) {
if (pixmap) {
paint.image(int(x) + 2, baseline - lascent,
paint.image(int(old_x) + 2, baseline - lascent,
lwidth - 4, lascent + ldescent,
pixmap);
} else {
#ifdef INSETGRAPHICS_INLINE_VIEW
if (!updateImage) {
updateImage = true;
updateInset();
}
// Get the image status, default to unknown error.
GraphicsCacheItem::ImageStatus status = GraphicsCacheItem::UnknownError;
if (cacheHandle)
@ -298,7 +282,6 @@ void InsetGraphics::draw(BufferView * bv, LyXFont const & font,
if (status == GraphicsCacheItem::Loaded) {
// It is, get it and inform the world.
pixmap = cacheHandle->getImage();
pixmapInitialized = true;
// Tell BufferView we need to be updated!
bv->text->status = LyXText::CHANGED_IN_DRAW;
@ -308,7 +291,7 @@ void InsetGraphics::draw(BufferView * bv, LyXFont const & font,
char const * msg = statusMessage();
paint.rectangle(int(x) + 2, baseline - lascent,
paint.rectangle(int(old_x) + 2, baseline - lascent,
lwidth - 4,
lascent + ldescent);
@ -318,16 +301,15 @@ void InsetGraphics::draw(BufferView * bv, LyXFont const & font,
msgFont.setFamily(LyXFont::SANS_FAMILY);
msgFont.setSize(LyXFont::SIZE_FOOTNOTE);
string const justname = OnlyFilename (params.filename);
paint.text(int(x + 8), baseline - lyxfont::maxAscent(msgFont) - 4,
paint.text(int(old_x) + 8,
baseline - lyxfont::maxAscent(msgFont) - 4,
justname, msgFont);
msgFont.setSize(LyXFont::SIZE_TINY);
paint.text(int(x + 8), baseline - 4, msg, strlen(msg), msgFont);
paint.text(int(old_x) + 8, baseline - 4,
msg, strlen(msg), msgFont);
}
}
// Add the image width to the row width.
x += lwidth;
}
@ -350,60 +332,6 @@ void InsetGraphics::Write(Buffer const * buf, ostream & os) const
params.Write(buf, os);
}
#if 0
// Baruch Even 2000-07-08
// A Thought for another way to read the file...
// The map should be a static part of the object or a static part of this
// file and should be filled during program start.
// The questions are:
// 1. Is this cleaner?
// 2. Is there no hidden performance costs?
//
// Regarding 2 I can already see that we will have two copies of the strings
// one in the data part of the program and one in the map, but that won't be
// more than say 2K (overestimation here), there is no real benefit to put
// it in the map since there aren't that many configuration items that will
// make it a faster solution, it might just be a bit cleaner.
// (a map stores either in a hash or a kind of a balanced tree).
void InsetGraphics::Read(Buffer const * buf, LyXLex & lex)
{
typedef map < string, enum TOKENS > ReadActionMap;
static ReadActionMap const readMap;
bool finished = false;
while (lex.IsOK() && !finished) {
lex.next();
string const token = lex.GetString();
lyxerr.debug() << "Token: '" << token << '\'' << endl;
if (token.empty())
continue;
ReadActionMap::const_iterator it =
readMap.find(token);
if (it == readMap.end()) {
lyxerr << "Unknown keyword, skipping." << endl;
continue;
}
switch (it.second) {
case FILENAME_TOKEN:
break;
case VERSION_TOKEN:
break;
default:
break;
}
}
}
#endif
void InsetGraphics::Read(Buffer const * buf, LyXLex & lex)
{
@ -466,11 +394,80 @@ void formatResize(ostream & os, string const & key,
}
}
string const
InsetGraphics::createLatexOptions() const
{
// Calculate the options part of the command, we must do it to a string
// stream since we might have a trailing comma that we would like to remove
// before writing it to the output stream.
std::ostringstream options;
formatResize(options, "width", params.widthResize, params.widthSize);
formatResize(options, "height", params.heightResize, params.heightSize);
if (params.rotateAngle != 0) {
options << "angle="
<< params.rotateAngle << ',';
}
string opts = options.str().c_str();
opts = strip(opts, ',');
return opts;
}
string const
InsetGraphics::prepareFile(Buffer const *buf) const
{
// do_convert = Do we need to convert the file?
// nice = Do we create a nice version?
// This is used when exporting the latex file only.
//
//
// if (!do_convert)
// return original filename
//
// if (!nice)
// convert_place = temp directory
// return new filename in temp directory
// else
// convert_place = original file directory
// return original filename without the extension
//
// Get the extension (format) of the original file.
string const extension = GetExtension(params.filename);
// Are we creating a PDF or a PS file?
// (Should actually mean, are we usind latex or pdflatex).
string const image_target = (lyxrc.pdf_mode ? "png" : "eps");
if (extension == image_target)
return params.filename;
string outfile;
if (!buf->niceFile) {
string const temp = AddName(buf->tmppath, params.filename);
outfile = RemoveExtension(temp);
} else {
string const path = OnlyPath(buf->fileName());
string const relname = MakeRelPath(params.filename, path);
outfile = RemoveExtension(relname);
}
converters.Convert(buf, params.filename, outfile, extension, image_target);
return outfile;
}
int InsetGraphics::Latex(Buffer const *buf, ostream & os,
bool /*fragile*/, bool/*fs*/) const
{
// MISSING: We have to decide how to do the order of the options
// that is dependent of order, like witdth, height, angle. Should
// that is dependent of order, like width, height, angle. Should
// we rotate before scale? Should we let the user decide?
// bool rot_before_scale; ?
@ -486,193 +483,61 @@ int InsetGraphics::Latex(Buffer const *buf, ostream & os,
if (params.filename.empty()) {
os << "\\fbox{\\rule[-0.5in]{0pt}{1in}"
<< _("empty figure path")
<< '}'
<< endl;
<< "}\n";
return 1;
return 1; // One end of line marker added to the stream.
}
// Calculate the options part of the command, we must do it to a string
// stream since we might have a trailing comma that we would like to remove
// before writing it to the output stream.
std::ostringstream options;
formatResize(options, "width", params.widthResize, params.widthSize);
formatResize(options, "height", params.heightResize, params.heightSize);
if (params.rotateAngle != 0) {
options << "angle="
<< params.rotateAngle << ',';
}
#ifdef IG_OLDPARAMS
if (bb.isSet() && use_bb) {
options << "bb="
<< bb.llx << ' ' << bb.lly << ' '
<< bb.urx << ' ' << bb.ury << ',';
}
if (hiresbb) {
options << "hiresbb,";
}
if (viewport.isSet()) {
options << "viewport="
<< viewport.llx << ' ' << viewport.lly << ' '
<< viewport.urx << ' ' << viewport.ury << ',';
}
if (trim.isSet()) {
options << "trim="
<< trim.llx << ' ' << trim.lly << ' '
<< trim.urx << ' ' << trim.ury << ',';
}
if (natheight.value() != 0) {
options << "natheight=" << natheight.asString() << ',';
}
if (natwidth.value() != 0) {
options << "natwidth=" << natwidth.asString() << ',';
}
if (angle != 0.0) {
options << "angle=" << angle << ',';
}
if (origin != DEFAULT) {
switch (origin) {
case DEFAULT: break;
case LEFTTOP:
options << "origin=lt,";
break;
case LEFTCENTER:
options << "origin=lc,";
break;
case LEFTBASELINE:
options << "origin=lB,";
break;
case LEFTBOTTOM:
options << "origin=lb,";
break;
case CENTERTOP:
options << "origin=ct,";
break;
case CENTER:
options << "origin=c,";
break;
case CENTERBASELINE:
options << "origin=cB,";
break;
case CENTERBOTTOM:
options << "origin=cb,";
break;
case RIGHTTOP:
options << "origin=rt,";
break;
case RIGHTCENTER:
options << "origin=rc,";
break;
case RIGHTBASELINE:
options << "origin=rB,";
break;
case RIGHTBOTTOM:
options << "origin=rb,";
break;
}
}
if (g_width.value() != 0) {
options << "width=" << g_width.asString() << ',';
}
if (g_height.value() != 0) {
options << "height=" << g_height.asString() << ',';
}
if (totalheight.value() != 0) {
options << "totalheight=" << totalheight.asString() << ',';
}
if (keepaspectratio) {
options << "keepaspectratio,";
}
if (scale != 0.0) {
options << "scale=" << scale << ',';
}
if (clip) {
options << "clip,";
}
if (draft) {
options << "draft,";
}
if (!type.empty()) {
options << "type=" << type << ',';
// These should be present only when type is used.
if (!ext.empty()) {
options << "ext=" << type << ',';
}
if (!read.empty()) {
options << "read=" << type << ',';
}
if (!command.empty()) {
options << "command=" << type << ',';
}
}
#endif
string opts(options.str().c_str());
opts = strip(opts, ',');
// Keep count of newlines that we issued.
int newlines = 0;
// This variables collect all the latex code that should be before and
// after the actual includegraphics command.
string before;
string after;
// If it's not an inline image, surround it with the centering paragraph.
if (! params.inlineFigure) {
os << endl
<< "\\vspace{0.3cm}" << endl
<< "{\\par\\centering ";
before += "\n" "\\vspace{0.3cm}\n" "{\\par\\centering ";
after = " \\par}\n" "\\vspace{0.3cm}\n" + after;
newlines += 4;
}
// Do we want subcaptions?
if (params.subcaption) {
os << "\\subfigure[" << params.subcaptionText << "]{";
before += "\\subfigure[" + params.subcaptionText + "]{";
after = '}' + after;
}
// We never used the starred form, we use the "clip" option instead.
os << "\\includegraphics";
// We never use the starred form, we use the "clip" option instead.
os << before << "\\includegraphics";
// Write the options if there are any.
string const opts = createLatexOptions();
if (!opts.empty()) {
os << '[' << opts << ']';
}
// Make the filename relative to the lyx file
string filename = MakeRelPath(params.filename, OnlyPath(buf->fileName()));
// and remove the extension so the LaTeX will use whatever is
// appropriate (when there are several versions in different formats)
filename = ChangeExtension(filename, string());
string const filename = prepareFile(buf);
os << '{' << filename << '}';
os << '{' << filename << '}' << after;
// Do we want a subcaption?
if (params.subcaption) {
// Close the subcaption command
os << '}';
}
// Is this an inline graphics?
if (!params.inlineFigure) {
os << " \\par}" << endl
<< "\\vspace{0.3cm}" << endl;
}
// How do we decide to what format should we export?
string extension = GetExtension(params.filename);
if (lyxrc.pdf_mode) {
if (extension != "jpg")
converters.Convert(buf,
params.filename, params.filename,
extension, "png");
} else
converters.Convert(buf, params.filename, params.filename,
extension, "eps");
return 1;
// Return how many newlines we issued.
return newlines;
}
int InsetGraphics::Ascii(Buffer const *, ostream &, int) const
{
// No graphics in ascii output.
// No graphics in ascii output. Possible to use gifscii to convert
// images to ascii approximation.
// 1. Convert file to ascii using gifscii
// 2. Read ascii output file and add it to the output stream.
return 0;
}
@ -683,10 +548,19 @@ int InsetGraphics::Linuxdoc(Buffer const *, ostream &) const
return 0;
}
int InsetGraphics::DocBook(Buffer const *, ostream &) const
// For explanation on inserting graphics into DocBook checkout:
// http://linuxdoc.org/LDP/LDP-Author-Guide/inserting-pictures.html
// See also the docbook guide at http://www.docbook.org/
int InsetGraphics::DocBook(Buffer const * buf, ostream & os) const
{
// No graphics in DocBook output. Should check how/what to add.
// Change the path to be relative to the main file.
string const buffer_dir = OnlyPath(buf->fileName());
string const filename = RemoveExtension(MakeRelPath(params.filename, buffer_dir));
// In DocBook v5.0, the graphic tag will be eliminated from DocBook, will
// need to switch to MediaObject. However, for now this is sufficient and
// easier to use.
os << "<graphic fileref=\"" << filename << "\"></graphic>";
return 0;
}
@ -707,9 +581,8 @@ void InsetGraphics::Validate(LaTeXFeatures & features) const
// dialog.
void InsetGraphics::updateInset() const
{
// If file changed...
#ifdef INSETGRAPHICS_INLINE_VIEW
if (updateImage) {
GraphicsCache * gc = GraphicsCache::getInstance();
GraphicsCacheItem * temp = 0;
@ -719,6 +592,7 @@ void InsetGraphics::updateInset() const
delete cacheHandle;
cacheHandle = temp;
}
#else
cacheHandle = 0;
#endif
@ -754,7 +628,7 @@ Inset * InsetGraphics::Clone(Buffer const &) const
else
newInset->cacheHandle = 0;
newInset->pixmap = pixmap;
newInset->pixmapInitialized = pixmapInitialized;
newInset->updateImage = updateImage;
newInset->setParams(getParams());

102
src/insets/insetgraphics.h
View File

@ -106,6 +106,10 @@ private:
void updateInset() const;
/// Get the status message, depends on the image loading status.
char const * statusMessage() const;
/// Create the options for the latex command.
string const createLatexOptions() const;
/// Convert the file if needed, and return the location of the file.
string const prepareFile(Buffer const * buf) const;
/// The graphics cache handle.
mutable GraphicsCacheItem * cacheHandle;
@ -113,105 +117,9 @@ private:
/// The pixmap
mutable LyXImage * pixmap;
/// is the pixmap initialized?
mutable bool pixmapInitialized;
mutable bool updateImage;
InsetGraphicsParams params;
// Baruch Even (baruch.even@writeme.com) 2000-07-17
// This was the intended way however it is not flexible enough and
// only provides for LaTeX output.
#ifdef IG_OLDPARAMS
// We need variables to store the size of the boundingbox and
// to store a pointer to the pixmap in.. The question is if
// these should be in a "pixmap" class.
// We also need to have variables about rotation and scaling,
// width and height. in effect all the paramters that
// \includegraphics can handle. (the graphix.sty package)
/** The "bounding box" of the graphics image. Its value field
must contain four dimensions, separated by spaces. */
BoundingBox bb;
/** The bounding box above is used for display and file both.
But we need this variable below to know if we shall use the
bounding box in the LaTex command or not. (i.e. if the user
has manually set the bb.) */
bool use_bb;
/** When a graphics file is parsed we first check for BoundingBox
and then for HiResBoundingBox, and set hiresbb depending on this.
This key makes LaTeX search for %%HiResBoundingBox comments
instead of the normal %%BoundingBox. Some applications use
this to specify more precise bounding boxes, becase the numbers
can normally only have integer values. It is a Boolean, either
"true" or "false". */
bool hiresbb;
/** This key takes four arguments (like bb), but in this case the
origin is taken with respect to the bounding box specified in
the file. So to view a 20 bp square at the lower left-hand corner
of the picture, specify viewport=0 0 20 20. */
BoundingBox viewport;
/** Similar to the viewport key, but the four dimensions correspond
to the amount of space to be trimmed (cut off) at the left-hand
side, bottom, right-hand side and top of the included graphics. */
BoundingBox trim;
/// Natural height of figure
LyXLength natheight;
/// Natural width of figure.
LyXLength natwidth;
/// Rotation angle (in degrees, counterclockwise).
float angle;
/** Origin for rotation, similar to the origin parameter of
the \rotatebox command described on p.46 and Fig. 2.2 on p.46. */
Origin origin;
/// Required width (the width of the image is scaled to that value).
LyXLength g_width;
/// Required height (the height of the image is scaled to that value).
LyXLength g_height;
/** Required total height (the total height of the image is scaled
to that value). This key should be used instead of height if
images are rotated over 90 degrees, since the height can
disappear (and become the depth) and LaTeX will have difficulties
satisfying the user's request. */
LyXLength totalheight;
/** Boolean variable that can have the values "true" and "false"
(se above for defaults). When true, specifying both width and
height parameters does not distort the picture, but the image
is scaled so that neither of the width of height exceeds the
given dimensions. */
bool keepaspectratio;
/// Scale factor
float scale;
/** Clip the graphic to the bounding box. It is a Boolean, either
"true" or "false". */
bool clip;
/// Locally switch to draft mode. A Boolean valued key, like clip.
bool draft;
/// The graphics type.
string type;
/// The file extension of the file containing the image data.
string ext;
/// The file extension of the file "read" by LaTeX.
string read;
/// Any command to be applied to the file.
string command;
#endif
};
#endif

139
src/insets/insetgraphicsParams.C
View File

@ -22,8 +22,6 @@
#include "support/LAssert.h"
using std::endl;
/// This variable keeps a tab on whether the translator was set with the
/// translations.
static bool translatorsSet = false;
@ -205,87 +203,14 @@ void writeResize(ostream & os, string const & key,
os << ' ' << key << "Resize ";
os << resizeTranslator.find(resize);
#if 0
// Old code, before using translators
switch (resize) {
case InsetGraphicsParams::DEFAULT_SIZE:
os << "default";
break;
case InsetGraphicsParams::CM:
os << "cm";
break;
case InsetGraphicsParams::INCH:
os << "inch";
break;
case InsetGraphicsParams::PERCENT_PAGE:
os << "percentOfPage";
break;
case InsetGraphicsParams::PERCENT_COLUMN:
os << "percentOfColumnt";
break;
}
#endif
os << ' ' << key << ' ' << size << endl;
os << ' ' << key << ' ' << size << '\n';
}
static void writeOrigin(ostream & os,
InsetGraphicsParams::Origin origin)
{
os << " rotateOrigin " << originTranslator.find(origin);
#if 0
// Old method.
switch (origin) {
case InsetGraphicsParams:: DEFAULT:
os << "default";
break;
case InsetGraphicsParams:: LEFTTOP:
os << "LeftTop";
break;
case InsetGraphicsParams:: LEFTCENTER:
os << "LeftCenter";
break;
case InsetGraphicsParams:: LEFTBASELINE:
os << "LeftBaseLine";
break;
case InsetGraphicsParams:: LEFTBOTTOM:
os << "LeftBottom";
break;
case InsetGraphicsParams:: CENTERTOP:
os << "CenterTop";
break;
case InsetGraphicsParams:: CENTER:
os << "Center";
break;
case InsetGraphicsParams:: CENTERBASELINE:
os << "CenterBaseLine";
break;
case InsetGraphicsParams:: CENTERBOTTOM:
os << "CenterBottom";
break;
case InsetGraphicsParams:: RIGHTTOP:
os << "RightTop";
break;
case InsetGraphicsParams:: RIGHTCENTER:
os << "RightCenter";
break;
case InsetGraphicsParams:: RIGHTBASELINE:
os << "RightBaseLine";
break;
case InsetGraphicsParams:: RIGHTBOTTOM:
os << "RightBottom";
break;
// Current REFERENCE_POINT is aliased to LEFTBASELINE
// case InsetGraphicsParams:: REFERENCE_POINT:
}
#endif
os << endl;
os << '\n';
}
void InsetGraphicsParams::Write(Buffer const * buf, ostream & os) const
@ -294,31 +219,11 @@ void InsetGraphicsParams::Write(Buffer const * buf, ostream & os) const
if (! filename.empty()) {
os << "filename "
<< MakeRelPath(filename, OnlyPath(buf->fileName()))
<< endl;
<< '\n';
}
// Save the display type
os << " display " << displayTranslator.find(display) << endl;
#if 0
switch (display) {
case COLOR:
os << "color";
break;
case GRAYSCALE:
os << "grayscale";
break;
case MONOCHROME:
os << "monochrome";
break;
case NONE:
os << "none";
break;
}
os << endl;
#endif
os << " display " << displayTranslator.find(display) << '\n';
// Save the inline status
if (inlineFigure)
@ -329,14 +234,14 @@ void InsetGraphicsParams::Write(Buffer const * buf, ostream & os) const
os << " subcaption";
if (! subcaptionText.empty())
os << " subcaptionText \"" << subcaptionText << '\"' << endl;
os << " subcaptionText \"" << subcaptionText << '\"' << '\n';
writeResize(os, "width", widthResize, widthSize);
writeResize(os, "height", heightResize, heightSize);
writeOrigin(os, rotateOrigin);
if (rotateAngle != 0)
os << " rotateAngle " << rotateAngle << endl;
os << " rotateAngle " << rotateAngle << '\n';
}
@ -347,23 +252,6 @@ void readResize(InsetGraphicsParams * igp, bool height,
InsetGraphicsParams::Resize resize = InsetGraphicsParams::DEFAULT_SIZE;
resize = resizeTranslator.find(token);
#if 0
// Old code, before translator.
if (token == "default")
resize = InsetGraphicsParams::DEFAULT_SIZE;
else if (token == "cm")
resize = InsetGraphicsParams::CM;
else if (token == "inch")
resize = InsetGraphicsParams::INCH;
else if (token == "percentOfPage")
resize = InsetGraphicsParams::PERCENT_PAGE;
else if (token == "percentOfColumn")
resize = InsetGraphicsParams::PERCENT_COLUMN;
else {
lyxerr << "BUG: When reading resize value of InsetGraphicsParam"
" unknown token found '" << token << '\'' << endl;
}
#endif
if (height)
igp->heightResize = resize;
@ -394,21 +282,6 @@ bool InsetGraphicsParams::Read(Buffer const * buf, LyXLex & lex,
string const type = lex.GetString();
display = displayTranslator.find(type);
#if 0
if (type == "color")
display = COLOR;
else if (type == "grayscale")
display = GRAYSCALE;
else if (type == "monochrome")
display = MONOCHROME;
else if (type == "none")
display = NONE;
else {
display = MONOCHROME;
lyxerr << "BUG: When reading InsetGraphicsParams"
" display has an unknown type " << type << endl;
}
#endif
} else if (token == "inline") {
inlineFigure = true;
} else if (token == "subcaption") {