Shamusworld >> Repos - architektonas/blob - src/base/drawing.cpp

   1 // drawing.cpp
   2 //
   3 // Part of the Architektonas Project
   4 // Originally part of QCad Community Edition by Andrew Mustun
   5 // Extensively rewritten and refactored by James L. Hammons
   6 // (C) 2010 Underground Software
   7 //
   8 // JLH = James L. Hammons <jlhamm@acm.org>
   9 //
  10 // Who  When        What
  11 // ---  ----------  -----------------------------------------------------------
  12 // JLH  05/21/2010  Added this text. :-)
  13 // JLH  06/02/2010  Changed all references of this class from RS_Graphic to
  14 //                  Drawing, as that makes it more clear that this is what it
  15 //                  is (a CAD drawing, not a bitmap).
  16 //
  17
  18 #include "drawing.h"
  19
  20 #include "rs_debug.h"
  21 #include "rs_fileio.h"
  22 #include "rs_math.h"
  23 #include "rs_units.h"
  24 #include "settings.h"
  25
  26 /**
  27  * Default constructor.
  28  */
  29 Drawing::Drawing(RS_EntityContainer * parent): RS_Document(parent), layerList(),
  30         blockList(true)
  31 #ifdef RS_CAM
  32         , camData()
  33 #endif
  34 {
  35         settings.beginGroup("Defaults");
  36         setUnit(RS_Units::stringToUnit(settings.value("Unit", "None").toString()));
  37         settings.endGroup();
  38
  39         RS2::Unit unit = getUnit();
  40
  41         if (unit == RS2::Inch)
  42         {
  43                 addVariable("$DIMASZ", 0.1, 40);
  44                 addVariable("$DIMEXE", 0.05, 40);
  45                 addVariable("$DIMEXO", 0.025, 40);
  46                 addVariable("$DIMGAP", 0.025, 40);
  47                 addVariable("$DIMTXT", 0.1, 40);
  48         }
  49         else
  50         {
  51                 addVariable("$DIMASZ", RS_Units::convert(2.5, RS2::Millimeter, unit), 40);
  52                 addVariable("$DIMEXE", RS_Units::convert(1.25, RS2::Millimeter, unit), 40);
  53                 addVariable("$DIMEXO", RS_Units::convert(0.625, RS2::Millimeter, unit), 40);
  54                 addVariable("$DIMGAP", RS_Units::convert(0.625, RS2::Millimeter, unit), 40);
  55                 addVariable("$DIMTXT", RS_Units::convert(2.5, RS2::Millimeter, unit), 40);
  56         }
  57
  58         setModified(false);
  59 }
  60
  61 /**
  62  * Destructor.
  63  */
  64 Drawing::~Drawing()
  65 {
  66 }
  67
  68 /** @return RS2::EntityGraphic */
  69 /*virtual*/ RS2::EntityType Drawing::rtti() const
  70 {
  71         return RS2::EntityGraphic;
  72 }
  73
  74 /**
  75  * Counts the entities on the given layer.
  76  */
  77 unsigned long int Drawing::countLayerEntities(RS_Layer * layer)
  78 {
  79     int c = 0;
  80
  81     if (layer != NULL)
  82         {
  83         for(RS_Entity * t=firstEntity(RS2::ResolveNone); t!=NULL; t=nextEntity(RS2::ResolveNone))
  84                 {
  85             if (t->getLayer()!=NULL && t->getLayer()->getName()==layer->getName())
  86                         {
  87                 c += t->countDeep();
  88             }
  89         }
  90     }
  91
  92     return c;
  93 }
  94
  95 /*virtual*/ RS_LayerList * Drawing::getLayerList()
  96 {
  97         return &layerList;
  98 }
  99
 100 /*virtual*/ RS_BlockList * Drawing::getBlockList()
 101 {
 102         return &blockList;
 103 }
 104
 105 /**
 106  * Clears all layers, blocks and entities of this graphic.
 107  * A default layer (0) is created.
 108  */
 109 void Drawing::newDoc()
 110 {
 111         RS_DEBUG->print("Drawing::newDoc");
 112
 113         clear();
 114
 115         clearLayers();
 116         clearBlocks();
 117
 118         addLayer(new RS_Layer("0"));
 119         //addLayer(new RS_Layer("ByBlock"));
 120
 121         setModified(false);
 122 }
 123
 124 /**
 125  * Saves this graphic with the current filename and settings.
 126  */
 127 bool Drawing::save()
 128 {
 129         bool ret = false;
 130
 131         RS_DEBUG->print("Drawing::save");
 132         RS_DEBUG->print("  file: %s", filename.toLatin1().data());
 133         RS_DEBUG->print("  format: %d", (int)formatType);
 134
 135         RS_DEBUG->print("  export...");
 136         ret = RS_FILEIO->fileExport(*this, filename, formatType);
 137
 138         if (ret)
 139         {
 140                 setModified(false);
 141                 layerList.setModified(false);
 142                 blockList.setModified(false);
 143         }
 144
 145         RS_DEBUG->print("Drawing::save ok");
 146
 147         return ret;
 148 }
 149
 150 /**
 151  * Saves this graphic with the given filename and current settings.
 152  */
 153 bool Drawing::saveAs(const QString & filename, RS2::FormatType type)
 154 {
 155         RS_DEBUG->print("Drawing::saveAs");
 156
 157         this->filename = filename;
 158         this->formatType = type;
 159
 160         return save();
 161 }
 162
 163 /**
 164  * Loads the given fils into this graphic.
 165  */
 166 bool Drawing::open(const QString &filename, RS2::FormatType type)
 167 {
 168         RS_DEBUG->print("Drawing::open(%s)", filename.toLatin1().data());
 169
 170         bool ret = false;
 171
 172         this->filename = filename;
 173
 174         // clean all:
 175         newDoc();
 176
 177         // import file:
 178         ret = RS_FILEIO->fileImport(*this, filename, type);
 179
 180         setModified(false);
 181         layerList.setModified(false);
 182         blockList.setModified(false);
 183
 184         //cout << *((Drawing*)graphic);
 185         //calculateBorders();
 186
 187         RS_DEBUG->print("Drawing::open(%s): OK", filename.toLatin1().data());
 188
 189         return ret;
 190 }
 191
 192 // Wrappers for Layer functions:
 193 void Drawing::clearLayers()
 194 {
 195         layerList.clear();
 196 }
 197
 198 uint Drawing::countLayers() const
 199 {
 200         return layerList.count();
 201 }
 202
 203 RS_Layer * Drawing::layerAt(uint i)
 204 {
 205         return layerList.at(i);
 206 }
 207
 208 void Drawing::activateLayer(const QString & name)
 209 {
 210         layerList.activate(name);
 211 }
 212
 213 void Drawing::activateLayer(RS_Layer * layer)
 214 {
 215         layerList.activate(layer);
 216 }
 217
 218 RS_Layer * Drawing::getActiveLayer()
 219 {
 220         return layerList.getActive();
 221 }
 222
 223 /*virtual*/ void Drawing::addLayer(RS_Layer * layer)
 224 {
 225         layerList.add(layer);
 226 }
 227
 228 /**
 229  * Removes the given layer and undoes all entities on it.
 230  */
 231 /*virtual*/ void Drawing::removeLayer(RS_Layer * layer)
 232 {
 233         if (layer != NULL && layer->getName() != "0")
 234         {
 235                 // remove all entities on that layer:
 236                 startUndoCycle();
 237
 238                 for(RS_Entity * e=firstEntity(RS2::ResolveNone); e!=NULL; e=nextEntity(RS2::ResolveNone))
 239                 {
 240                         if (e->getLayer() != NULL && e->getLayer()->getName() == layer->getName())
 241                         {
 242                                 e->setUndoState(true);
 243                                 e->setLayer("0");
 244                                 addUndoable(e);
 245                         }
 246                 }
 247
 248                 endUndoCycle();
 249
 250                 // remove all entities in blocks that are on that layer:
 251                 for(uint bi=0; bi<blockList.count(); bi++)
 252                 {
 253                         RS_Block * blk = blockList.at(bi);
 254
 255                         if (blk != NULL)
 256                         {
 257                                 for(RS_Entity * e=blk->firstEntity(RS2::ResolveNone); e!=NULL; e=blk->nextEntity(RS2::ResolveNone))
 258                                 {
 259                                         if (e->getLayer() != NULL && e->getLayer()->getName() == layer->getName())
 260                                         {
 261                                                 e->setUndoState(true);
 262                                                 e->setLayer("0");
 263                                                 //addUndoable(e);
 264                                         }
 265                                 }
 266                         }
 267                 }
 268
 269                 layerList.remove(layer);
 270         }
 271 }
 272
 273 /*virtual*/ void Drawing::editLayer(RS_Layer * layer, const RS_Layer & source)
 274 {
 275         layerList.edit(layer, source);
 276 }
 277
 278 RS_Layer * Drawing::findLayer(const QString & name)
 279 {
 280         return layerList.find(name);
 281 }
 282
 283 void Drawing::toggleLayer(const QString & name)
 284 {
 285         layerList.toggle(name);
 286 }
 287
 288 void Drawing::toggleLayer(RS_Layer * layer)
 289 {
 290         layerList.toggle(layer);
 291 }
 292
 293 void Drawing::toggleLayerLock(RS_Layer * layer)
 294 {
 295         layerList.toggleLock(layer);
 296 }
 297
 298 void Drawing::freezeAllLayers(bool freeze)
 299 {
 300         layerList.freezeAll(freeze);
 301 }
 302
 303 void Drawing::addLayerListListener(RS_LayerListListener * listener)
 304 {
 305         layerList.addListener(listener);
 306 }
 307
 308 void Drawing::removeLayerListListener(RS_LayerListListener * listener)
 309 {
 310         layerList.removeListener(listener);
 311 }
 312
 313 // Wrapper for block functions:
 314
 315 void Drawing::clearBlocks()
 316 {
 317         blockList.clear();
 318 }
 319
 320 uint Drawing::countBlocks()
 321 {
 322         return blockList.count();
 323 }
 324
 325 RS_Block * Drawing::blockAt(uint i)
 326 {
 327         return blockList.at(i);
 328 }
 329
 330 void Drawing::activateBlock(const QString & name)
 331 {
 332         blockList.activate(name);
 333 }
 334
 335 void Drawing::activateBlock(RS_Block * block)
 336 {
 337         blockList.activate(block);
 338 }
 339
 340 RS_Block * Drawing::getActiveBlock()
 341 {
 342         return blockList.getActive();
 343 }
 344
 345 /*virtual*/ bool Drawing::addBlock(RS_Block * block, bool notify/*= true*/)
 346 {
 347         return blockList.add(block, notify);
 348 }
 349
 350 /*virtual*/ void Drawing::addBlockNotification()
 351 {
 352         blockList.addNotification();
 353 }
 354
 355 /*virtual*/ void Drawing::removeBlock(RS_Block * block)
 356 {
 357         blockList.remove(block);
 358 }
 359
 360 RS_Block * Drawing::findBlock(const QString & name)
 361 {
 362         return blockList.find(name);
 363 }
 364
 365 QString Drawing::newBlockName()
 366 {
 367         return blockList.newName();
 368 }
 369
 370 void Drawing::toggleBlock(const QString & name)
 371 {
 372         blockList.toggle(name);
 373 }
 374
 375 void Drawing::toggleBlock(RS_Block * block)
 376 {
 377         blockList.toggle(block);
 378 }
 379
 380 void Drawing::freezeAllBlocks(bool freeze)
 381 {
 382         blockList.freezeAll(freeze);
 383 }
 384
 385 void Drawing::addBlockListListener(RS_BlockListListener * listener)
 386 {
 387         blockList.addListener(listener);
 388 }
 389
 390 void Drawing::removeBlockListListener(RS_BlockListListener * listener)
 391 {
 392         blockList.removeListener(listener);
 393 }
 394
 395 // Wrappers for variable functions:
 396 void Drawing::clearVariables()
 397 {
 398         variableDict.clear();
 399 }
 400
 401 int Drawing::countVariables()
 402 {
 403         return variableDict.count();
 404 }
 405
 406 void Drawing::addVariable(const QString & key, const Vector & value, int code)
 407 {
 408         variableDict.add(key, value, code);
 409 }
 410
 411 void Drawing::addVariable(const QString & key, const QString & value, int code)
 412 {
 413         variableDict.add(key, value, code);
 414 }
 415
 416 void Drawing::addVariable(const QString & key, int value, int code)
 417 {
 418         variableDict.add(key, value, code);
 419 }
 420
 421 void Drawing::addVariable(const QString & key, double value, int code)
 422 {
 423         variableDict.add(key, value, code);
 424 }
 425
 426 Vector Drawing::getVariableVector(const QString & key, const Vector & def)
 427 {
 428         return variableDict.getVector(key, def);
 429 }
 430
 431 QString Drawing::getVariableString(const QString & key, const QString & def)
 432 {
 433         return variableDict.getString(key, def);
 434 }
 435
 436 int Drawing::getVariableInt(const QString & key, int def)
 437 {
 438         return variableDict.getInt(key, def);
 439 }
 440
 441 double Drawing::getVariableDouble(const QString & key, double def)
 442 {
 443         return variableDict.getDouble(key, def);
 444 }
 445
 446 void Drawing::removeVariable(const QString & key)
 447 {
 448         variableDict.remove(key);
 449 }
 450
 451 //Q3Dict<RS_Variable> & getVariableDict()
 452 QMultiHash<QString, RS_Variable *> & Drawing::getVariableDict()
 453 {
 454         return variableDict.getVariableDict();
 455 }
 456
 457 /**
 458  * @return true if the grid is switched on (visible).
 459  */
 460 bool Drawing::isGridOn()
 461 {
 462         int on = getVariableInt("$GRIDMODE", 1);
 463         return (on != 0);
 464 }
 465
 466 /**
 467  * Enables / disables the grid.
 468  */
 469 void Drawing::setGridOn(bool on)
 470 {
 471         addVariable("$GRIDMODE", (int)on, 70);
 472 }
 473
 474 /**
 475  * Sets the unit of this graphic to 'u'
 476  */
 477 void Drawing::setUnit(RS2::Unit u)
 478 {
 479         setPaperSize(RS_Units::convert(getPaperSize(), getUnit(), u));
 480
 481         addVariable("$INSUNITS", (int)u, 70);
 482
 483         //unit = u;
 484 }
 485
 486 /**
 487  * Gets the unit of this graphic
 488  */
 489 RS2::Unit Drawing::getUnit()
 490 {
 491         return (RS2::Unit)getVariableInt("$INSUNITS", 0);
 492         //return unit;
 493 }
 494
 495 /**
 496  * @return The linear format type for this document.
 497  * This is determined by the variable "$LUNITS".
 498  */
 499 RS2::LinearFormat Drawing::getLinearFormat()
 500 {
 501         int lunits = getVariableInt("$LUNITS", 2);
 502
 503         switch (lunits)
 504         {
 505         default:
 506         case 2:
 507                 return RS2::Decimal;
 508                 break;
 509
 510         case 1:
 511                 return RS2::Scientific;
 512                 break;
 513
 514         case 3:
 515                 return RS2::Engineering;
 516                 break;
 517
 518         case 4:
 519                 return RS2::Architectural;
 520                 break;
 521
 522         case 5:
 523                 return RS2::Fractional;
 524                 break;
 525         }
 526
 527         return RS2::Decimal;
 528 }
 529
 530 /**
 531  * @return The linear precision for this document.
 532  * This is determined by the variable "$LUPREC".
 533  */
 534 int Drawing::getLinearPrecision()
 535 {
 536         return getVariableInt("$LUPREC", 4);
 537 }
 538
 539 /**
 540  * @return The angle format type for this document.
 541  * This is determined by the variable "$AUNITS".
 542  */
 543 RS2::AngleFormat Drawing::getAngleFormat()
 544 {
 545         int aunits = getVariableInt("$AUNITS", 0);
 546
 547         switch (aunits)
 548         {
 549         default:
 550         case 0:
 551                 return RS2::DegreesDecimal;
 552                 break;
 553
 554         case 1:
 555                 return RS2::DegreesMinutesSeconds;
 556                 break;
 557
 558         case 2:
 559                 return RS2::Gradians;
 560                 break;
 561
 562         case 3:
 563                 return RS2::Radians;
 564                 break;
 565
 566         case 4:
 567                 return RS2::Surveyors;
 568                 break;
 569         }
 570
 571         return RS2::DegreesDecimal;
 572 }
 573
 574 /**
 575  * @return The linear precision for this document.
 576  * This is determined by the variable "$LUPREC".
 577  */
 578 int Drawing::getAnglePrecision()
 579 {
 580         return getVariableInt("$AUPREC", 4);
 581 }
 582
 583 /**
 584  * @return The insertion point of the drawing into the paper space.
 585  * This is the distance from the lower left paper edge to the zero
 586  * point of the drawing. DXF: $PINSBASE.
 587  */
 588 Vector Drawing::getPaperInsertionBase()
 589 {
 590         return getVariableVector("$PINSBASE", Vector(0.0,0.0));
 591 }
 592
 593 /**
 594  * Sets the PINSBASE variable.
 595  */
 596 void Drawing::setPaperInsertionBase(const Vector & p)
 597 {
 598         addVariable("$PINSBASE", p, 10);
 599 }
 600
 601 /**
 602  * @return Paper size in graphic units.
 603  */
 604 Vector Drawing::getPaperSize()
 605 {
 606         Vector def = RS_Units::convert(Vector(210.0, 297.0), RS2::Millimeter, getUnit());
 607
 608         Vector v1 = getVariableVector("$PLIMMIN", Vector(0.0, 0.0));
 609         Vector v2 = getVariableVector("$PLIMMAX", def);
 610
 611         return v2 - v1;
 612 }
 613
 614 /**
 615  * Sets a new paper size.
 616  */
 617 void Drawing::setPaperSize(const Vector & s)
 618 {
 619         addVariable("$PLIMMIN", Vector(0.0, 0.0), 10);
 620         addVariable("$PLIMMAX", s, 10);
 621 }
 622
 623 /**
 624  * @return Paper format.
 625  * This is determined by the variables "$PLIMMIN" and "$PLIMMAX".
 626  *
 627  * @param landscape will be set to true for landscape and false for portrait if not NULL.
 628  */
 629 RS2::PaperFormat Drawing::getPaperFormat(bool * landscape)
 630 {
 631         Vector size = RS_Units::convert(getPaperSize(), getUnit(), RS2::Millimeter);
 632
 633         if (landscape != NULL)
 634                 *landscape = (size.x > size.y);
 635
 636         return RS_Units::paperSizeToFormat(size);
 637 }
 638
 639 /**
 640  * Sets the paper format to the given format.
 641  */
 642 void Drawing::setPaperFormat(RS2::PaperFormat f, bool landscape)
 643 {
 644         Vector size = RS_Units::paperFormatToSize(f);
 645
 646         if (landscape)
 647         {
 648                 double tmp = size.x;
 649                 size.x = size.y;
 650                 size.y = tmp;
 651         }
 652
 653         if (f != RS2::Custom)
 654                 setPaperSize(RS_Units::convert(size, RS2::Millimeter, getUnit()));
 655 }
 656
 657 /**
 658  * @return Paper space scaling (DXF: $PSVPSCALE).
 659  */
 660 double Drawing::getPaperScale()
 661 {
 662         double ret;
 663
 664         ret = getVariableDouble("$PSVPSCALE", 1.0);
 665
 666         if (ret < 1.0e-6)
 667                 ret = 1.0;
 668
 669         return ret;
 670 }
 671
 672 /**
 673  * Sets a new scale factor for the paper space.
 674  */
 675 void Drawing::setPaperScale(double s)
 676 {
 677         addVariable("$PSVPSCALE", s, 40);
 678 }
 679
 680 /**
 681  * Centers drawing on page. Affects DXF variable $PINSBASE.
 682  */
 683 void Drawing::centerToPage()
 684 {
 685         Vector size = getPaperSize();
 686         double scale = getPaperScale();
 687         Vector pinsbase = (size - getSize() * scale) / 2.0 - getMin() * scale;
 688         setPaperInsertionBase(pinsbase);
 689 }
 690
 691 /**
 692  * Fits drawing on page. Affects DXF variable $PINSBASE.
 693  */
 694 void Drawing::fitToPage()
 695 {
 696         double border = RS_Units::convert(25.0, RS2::Millimeter, getUnit());
 697         Vector ps = getPaperSize() - Vector(border, border);
 698         Vector s = getSize();
 699         double fx = RS_MAXDOUBLE;
 700         double fy = RS_MAXDOUBLE;
 701         //double factor = 1.0;
 702
 703         //ps = RS_Units::convert(ps, getUnit(), RS2::Millimeter);
 704
 705         if (fabs(s.x) > 1.0e-6)
 706                 fx = ps.x / s.x;
 707
 708         if (fabs(s.y) > 1.0e-6)
 709                 fy = ps.y / s.y;
 710
 711         setPaperScale(std::min(fx, fy));
 712         centerToPage();
 713 }
 714
 715 /**
 716  * @retval true The document has been modified since it was last saved.
 717  * @retval false The document has not been modified since it was last saved.
 718  */
 719 /*virtual*/ bool Drawing::isModified() const
 720 {
 721         return modified || layerList.isModified() || blockList.isModified();
 722 }
 723
 724 /**
 725  * Sets the documents modified status to 'm'.
 726  */
 727 /*virtual*/ void Drawing::setModified(bool m)
 728 {
 729         modified = m;
 730         layerList.setModified(m);
 731         blockList.setModified(m);
 732 }
 733
 734 #ifdef RS_CAM
 735 RS_CamData & Drawing::getCamData()
 736 {
 737         return camData;
 738 }
 739
 740 void Drawing::setCamData(const RS_CamData & d)
 741 {
 742         camData = d;
 743 }
 744 #endif
 745
 746 /**
 747  * Dumps the entities to stdout.
 748  */
 749 std::ostream & operator<<(std::ostream & os, Drawing & g)
 750 {
 751     os << "--- Drawing: \n";
 752     os << "---" << *g.getLayerList() << "\n";
 753     os << "---" << *g.getBlockList() << "\n";
 754     os << "---" << (RS_Undo&)g << "\n";
 755     os << "---" << (RS_EntityContainer&)g << "\n";
 756
 757     return os;
 758 }