src/insets/insetgraphicsParams.C

   1 // -*- C++ -*-
   2 /* This file is part of
   3  * =================================================
   4  *
   5  *          LyX, The Document Processor
   6  *          Copyright 1995 Matthias Ettrich.
   7  *          Copyright 1995-2000 The LyX Team.
   8  *
   9  *          This file Copyright 2000 Baruch Even
  10  * ================================================= */
  11
  12 #include <config.h>
  13
  14 #ifdef __GNUG__
  15 #pragma implementation
  16 #endif
  17
  18 #include "insetgraphicsParams.h"
  19
  20 #include "support/translator.h"
  21 #include "support/filetools.h"
  22
  23 #include "support/LAssert.h"
  24
  25 using std::endl;
  26
  27 /// This variable keeps a tab on whether the translator was set with the
  28 /// translations.
  29 static bool translatorsSet = false;
  30
  31 /// This is the translator between the Resize enum and corresponding lyx
  32 /// file strings.
  33 static Translator < InsetGraphicsParams::Resize, string >
  34 resizeTranslator(InsetGraphicsParams::DEFAULT_SIZE, "default");
  35
  36 /// This is the translator between the Origin enum and corresponding lyx
  37 /// file strings.
  38 static Translator < InsetGraphicsParams::Origin, string >
  39 originTranslator(InsetGraphicsParams::DEFAULT, "default");
  40
  41 /// This is the translator between the Display enum and corresponding lyx
  42 /// file strings.
  43 static Translator < InsetGraphicsParams::DisplayType, string >
  44 displayTranslator(InsetGraphicsParams::MONOCHROME, "monochrome");
  45
  46
  47
  48 InsetGraphicsParams::InsetGraphicsParams()
  49 {
  50         init();
  51
  52         // Set translators
  53         if (! translatorsSet) {
  54                 translatorsSet = true;
  55
  56                 // Fill the resize translator
  57                 resizeTranslator.addPair(DEFAULT_SIZE, "default");
  58                 resizeTranslator.addPair(CM, "cm");
  59                 resizeTranslator.addPair(INCH, "inch");
  60                 resizeTranslator.addPair(PERCENT_PAGE, "percentOfPage");
  61                 resizeTranslator.addPair(PERCENT_COLUMN, "percentOfColumn");
  62
  63                 // Fill the origin translator
  64                 originTranslator.addPair(DEFAULT, "default");
  65                 originTranslator.addPair(LEFTTOP, "leftTop");
  66                 originTranslator.addPair(LEFTCENTER, "leftCenter");
  67                 originTranslator.addPair(LEFTBASELINE, "leftBaseLine");
  68                 originTranslator.addPair(LEFTBOTTOM, "leftBottom");
  69                 originTranslator.addPair(CENTERTOP, "centerTop");
  70                 originTranslator.addPair(CENTER, "center");
  71                 originTranslator.addPair(CENTERBASELINE, "centerBaseLine");
  72                 originTranslator.addPair(CENTERBOTTOM, "centerBottom");
  73                 originTranslator.addPair(RIGHTTOP, "rightTop");
  74                 originTranslator.addPair(RIGHTCENTER, "rightCenter");
  75                 originTranslator.addPair(RIGHTBASELINE, "rightBaseLine");
  76                 originTranslator.addPair(RIGHTBOTTOM, "rightBottom");
  77                 originTranslator.addPair(REFERENCE_POINT, "referencePoint");
  78
  79                 // Fill the display translator
  80                 displayTranslator.addPair(MONOCHROME, "monochrome");
  81                 displayTranslator.addPair(GRAYSCALE, "grayscale");
  82                 displayTranslator.addPair(COLOR, "color");
  83                 displayTranslator.addPair(NONE, "none");
  84         }
  85
  86 }
  87
  88
  89 InsetGraphicsParams::InsetGraphicsParams(InsetGraphicsParams const & igp)
  90 {
  91         // I decided to skip the initialization since the copy will overwrite
  92         // everything anyway.
  93         //    init();
  94         copy(igp);
  95 }
  96
  97 InsetGraphicsParams const &
  98 InsetGraphicsParams::operator=(InsetGraphicsParams const &params)
  99 {
 100         // Are we assigning the object into itself?
 101         if (this == &params)
 102                 return * this;
 103
 104         copy(params);
 105         return *this;
 106 }
 107
 108 void InsetGraphicsParams::init()
 109 {
 110         subcaptionText = filename = string();
 111         display = MONOCHROME;
 112         inlineFigure = false;
 113         subcaption = false;
 114         keepAspectRatio = true;
 115         widthResize = DEFAULT_SIZE;
 116         widthSize = 0.0;
 117         heightResize = DEFAULT_SIZE;
 118         heightSize = 0.0;
 119         rotateOrigin = DEFAULT;
 120         rotateAngle = 0;
 121
 122         testInvariant();
 123 }
 124
 125 void InsetGraphicsParams::copy(InsetGraphicsParams const & igp)
 126 {
 127         filename = igp.filename;
 128         display = igp.display;
 129         inlineFigure = igp.inlineFigure;
 130         subcaption = igp.subcaption;
 131         subcaptionText = igp.subcaptionText;
 132         keepAspectRatio = igp.keepAspectRatio;
 133         widthResize = igp.widthResize;
 134         widthSize = igp.widthSize;
 135         heightResize = igp.heightResize;
 136         heightSize = igp.heightSize;
 137         rotateOrigin = igp.rotateOrigin;
 138         rotateAngle = igp.rotateAngle;
 139
 140         testInvariant();
 141 }
 142
 143 void InsetGraphicsParams::testInvariant() const
 144 {
 145         // Filename might be empty (when the dialog is first created).
 146         // Assert(!filename.empty());
 147
 148         Assert(display == COLOR ||
 149                display == MONOCHROME ||
 150                display == GRAYSCALE ||
 151                display == NONE
 152               );
 153
 154         Assert(widthResize == DEFAULT_SIZE ||
 155                widthResize == CM ||
 156                widthResize == INCH ||
 157                widthResize == PERCENT_PAGE ||
 158                widthResize == PERCENT_COLUMN
 159               );
 160
 161         Assert(heightResize == DEFAULT_SIZE ||
 162                heightResize == CM ||
 163                heightResize == INCH ||
 164                heightResize == PERCENT_PAGE
 165               );
 166
 167         Assert(widthSize >= 0.0);
 168         Assert(heightSize >= 0.0);
 169
 170         // Angle is in degrees and ranges -360 < angle < 360
 171         // The reason for this is that in latex there is a meaning for the
 172         // different angles and they are not necessarliy interchangeable,
 173         // it depends on the rotation origin.
 174         Assert(rotateAngle < 360);
 175         Assert(rotateAngle > -360);
 176
 177 }
 178
 179 bool operator==(InsetGraphicsParams const & left,
 180                 InsetGraphicsParams const & right)
 181 {
 182         if (left.filename == right.filename &&
 183                 left.display == right.display &&
 184                 left.inlineFigure == right.inlineFigure &&
 185                 left.subcaption == right.subcaption &&
 186                 left.subcaptionText == right.subcaptionText &&
 187                 left.keepAspectRatio == right.keepAspectRatio &&
 188                 left.widthResize == right.widthResize &&
 189                 left.widthSize == right.widthSize &&
 190                 left.heightResize == right.heightResize &&
 191                 left.heightSize == right.heightSize &&
 192                 left.rotateOrigin == right.rotateOrigin &&
 193                 left.rotateAngle == right.rotateAngle
 194            )
 195                 return true;
 196
 197         return false;
 198 }
 199
 200 static void writeResize(ostream & os, char const * key,
 201                         InsetGraphicsParams::Resize resize, double size)
 202 {
 203         os << ' ' << key << "Resize ";
 204
 205         os << resizeTranslator.find(resize);
 206 #if 0
 207         // Old code, before using translators
 208         switch (resize) {
 209         case InsetGraphicsParams::DEFAULT_SIZE:
 210                 os << "default";
 211                 break;
 212
 213         case InsetGraphicsParams::CM:
 214                 os << "cm";
 215                 break;
 216
 217         case InsetGraphicsParams::INCH:
 218                 os << "inch";
 219                 break;
 220
 221         case InsetGraphicsParams::PERCENT_PAGE:
 222                 os << "percentOfPage";
 223                 break;
 224
 225         case InsetGraphicsParams::PERCENT_COLUMN:
 226                 os << "percentOfColumnt";
 227                 break;
 228         }
 229 #endif
 230         os << ' ' << key << ' ' << size << endl;
 231 }
 232
 233 static void writeOrigin(ostream & os,
 234                         InsetGraphicsParams::Origin origin)
 235 {
 236         os << " rotateOrigin " << originTranslator.find(origin);
 237
 238 #if 0
 239         // Old method.
 240         switch (origin) {
 241         case InsetGraphicsParams:: DEFAULT:
 242                 os << "default";
 243                 break;
 244         case InsetGraphicsParams::      LEFTTOP:
 245                 os << "LeftTop";
 246                 break;
 247         case InsetGraphicsParams::      LEFTCENTER:
 248                 os << "LeftCenter";
 249                 break;
 250         case InsetGraphicsParams::      LEFTBASELINE:
 251                 os << "LeftBaseLine";
 252                 break;
 253         case InsetGraphicsParams::      LEFTBOTTOM:
 254                 os << "LeftBottom";
 255                 break;
 256         case InsetGraphicsParams::      CENTERTOP:
 257                 os << "CenterTop";
 258                 break;
 259         case InsetGraphicsParams::      CENTER:
 260                 os << "Center";
 261                 break;
 262         case InsetGraphicsParams::      CENTERBASELINE:
 263                 os << "CenterBaseLine";
 264                 break;
 265         case InsetGraphicsParams::      CENTERBOTTOM:
 266                 os << "CenterBottom";
 267                 break;
 268         case InsetGraphicsParams::      RIGHTTOP:
 269                 os << "RightTop";
 270                 break;
 271         case InsetGraphicsParams::      RIGHTCENTER:
 272                 os << "RightCenter";
 273                 break;
 274         case InsetGraphicsParams::      RIGHTBASELINE:
 275                 os << "RightBaseLine";
 276                 break;
 277         case InsetGraphicsParams::      RIGHTBOTTOM:
 278                 os << "RightBottom";
 279                 break;
 280                 // Current REFERENCE_POINT is aliased to LEFTBASELINE
 281                 //    case InsetGraphicsParams::        REFERENCE_POINT:
 282         }
 283
 284 #endif
 285
 286         os << endl;
 287 }
 288
 289 void InsetGraphicsParams::Write(Buffer const * buf, ostream & os) const
 290 {
 291         // If there is no filename, write nothing for it.
 292         if (! filename.empty()) {
 293                 os << "filename "
 294                 << MakeRelPath(filename, OnlyPath(buf->fileName()))
 295                 << endl;
 296         }
 297
 298         // Save the display type
 299         os << " display " << displayTranslator.find(display) << endl;
 300 #if 0
 301         switch (display) {
 302         case COLOR:
 303                 os << "color";
 304                 break;
 305
 306         case GRAYSCALE:
 307                 os << "grayscale";
 308                 break;
 309
 310         case MONOCHROME:
 311                 os << "monochrome";
 312                 break;
 313
 314         case NONE:
 315                 os << "none";
 316                 break;
 317         }
 318         os << endl;
 319 #endif
 320
 321         // Save the inline status
 322         if (inlineFigure)
 323                 os << " inline";
 324
 325         // Save the subcaption status
 326         if (subcaption)
 327                 os << " subcaption";
 328
 329         if (! subcaptionText.empty())
 330                 os << " subcaptionText \"" << subcaptionText << '\"' << endl;
 331
 332         writeResize(os, "width", widthResize, widthSize);
 333         writeResize(os, "height", heightResize, heightSize);
 334
 335         writeOrigin(os, rotateOrigin);
 336         if (rotateAngle != 0)
 337                 os << " rotateAngle " << rotateAngle << endl;
 338 }
 339
 340 static void readResize(InsetGraphicsParams * igp, bool height,
 341                        string const & token)
 342 {
 343         InsetGraphicsParams::Resize resize = InsetGraphicsParams::DEFAULT_SIZE;
 344
 345         resize = resizeTranslator.find(token);
 346 #if 0
 347         // Old code, before translator.
 348         if (token == "default")
 349                 resize = InsetGraphicsParams::DEFAULT_SIZE;
 350         else if (token == "cm")
 351                 resize = InsetGraphicsParams::CM;
 352         else if (token == "inch")
 353                 resize = InsetGraphicsParams::INCH;
 354         else if (token == "percentOfPage")
 355                 resize = InsetGraphicsParams::PERCENT_PAGE;
 356         else if (token == "percentOfColumn")
 357                 resize = InsetGraphicsParams::PERCENT_COLUMN;
 358         else {
 359                 lyxerr << "BUG: When reading resize value of InsetGraphicsParam"
 360                 " unknown token found '" << token << '\'' << endl;
 361         }
 362 #endif
 363
 364         if (height)
 365                 igp->heightResize = resize;
 366         else
 367                 igp->widthResize = resize;
 368 }
 369
 370 static void readOrigin(InsetGraphicsParams * igp, string const & token)
 371 { // TODO: complete this function.
 372         igp->rotateOrigin = originTranslator.find(token);
 373 }
 374
 375 bool InsetGraphicsParams::Read(Buffer const * buf, LyXLex & lex,
 376                                string const& token)
 377 {
 378         if (token == "filename") {
 379                 lex.next();
 380                 filename = lex.GetString();
 381
 382                 if (!filename.empty()) {
 383                         // Make the filename with absolute directory.
 384                         filename = MakeAbsPath(filename, OnlyPath(buf->fileName()));
 385                 }
 386         } else if (token == "display") {
 387                 lex.next();
 388                 string const type = lex.GetString();
 389
 390                 display = displayTranslator.find(type);
 391 #if 0
 392                 if (type == "color")
 393                         display = COLOR;
 394                 else if (type == "grayscale")
 395                         display = GRAYSCALE;
 396                 else if (type == "monochrome")
 397                         display = MONOCHROME;
 398                 else if (type == "none")
 399                         display = NONE;
 400                 else {
 401                         display = MONOCHROME;
 402                         lyxerr << "BUG: When reading InsetGraphicsParams"
 403                         " display has an unknown type " << type << endl;
 404                 }
 405 #endif
 406         } else if (token == "inline") {
 407                 inlineFigure = true;
 408         } else if (token == "subcaption") {
 409                 subcaption = true;
 410         } else if (token == "subcaptionText") {
 411                 lex.next();
 412                 subcaptionText = lex.GetString();
 413         } else if (token == "widthResize") {
 414                 lex.next();
 415                 string const token = lex.GetString();
 416
 417                 readResize(this, false, token);
 418         } else if (token == "width") {
 419                 lex.next();
 420                 widthSize = lex.GetFloat();
 421         } else if (token == "heightResize") {
 422                 lex.next();
 423                 string const token = lex.GetString();
 424
 425                 readResize(this, true, token);
 426         } else if (token == "height") {
 427                 lex.next();
 428                 heightSize = lex.GetFloat();
 429         } else if (token == "rotateOrigin") {
 430                 lex.next();
 431                 string const token = lex.GetString();
 432
 433                 readOrigin(this, token);
 434         } else if (token == "rotateAngle") {
 435                 lex.next();
 436                 rotateAngle = lex.GetInteger();
 437         } else {
 438                 // If it's none of the above, its not ours.
 439                 return false;
 440         }
 441
 442         return true;
 443 }