/**
* Default constructor.
*/
-Drawing::Drawing(RS_EntityContainer * parent): RS_Document(parent), layerList(),
+Drawing::Drawing(EntityContainer * parent): Document(parent), layerList(),
blockList(true)
#ifdef RS_CAM
, camData()
#endif
{
settings.beginGroup("Defaults");
- setUnit(RS_Units::stringToUnit(settings.value("Unit", "None").toString()));
+ setUnit(Units::stringToUnit(settings.value("Unit", "None").toString()));
settings.endGroup();
RS2::Unit unit = getUnit();
}
else
{
- addVariable("$DIMASZ", RS_Units::convert(2.5, RS2::Millimeter, unit), 40);
- addVariable("$DIMEXE", RS_Units::convert(1.25, RS2::Millimeter, unit), 40);
- addVariable("$DIMEXO", RS_Units::convert(0.625, RS2::Millimeter, unit), 40);
- addVariable("$DIMGAP", RS_Units::convert(0.625, RS2::Millimeter, unit), 40);
- addVariable("$DIMTXT", RS_Units::convert(2.5, RS2::Millimeter, unit), 40);
+ addVariable("$DIMASZ", Units::convert(2.5, RS2::Millimeter, unit), 40);
+ addVariable("$DIMEXE", Units::convert(1.25, RS2::Millimeter, unit), 40);
+ addVariable("$DIMEXO", Units::convert(0.625, RS2::Millimeter, unit), 40);
+ addVariable("$DIMGAP", Units::convert(0.625, RS2::Millimeter, unit), 40);
+ addVariable("$DIMTXT", Units::convert(2.5, RS2::Millimeter, unit), 40);
}
setModified(false);
/**
* Counts the entities on the given layer.
*/
-unsigned long int Drawing::countLayerEntities(RS_Layer * layer)
+unsigned long int Drawing::countLayerEntities(Layer * layer)
{
int c = 0;
if (layer != NULL)
{
- for(RS_Entity * t=firstEntity(RS2::ResolveNone); t!=NULL; t=nextEntity(RS2::ResolveNone))
+ for(Entity * t=firstEntity(RS2::ResolveNone); t!=NULL; t=nextEntity(RS2::ResolveNone))
{
if (t->getLayer()!=NULL && t->getLayer()->getName()==layer->getName())
{
return c;
}
-/*virtual*/ RS_LayerList * Drawing::getLayerList()
+/*virtual*/ LayerList * Drawing::getLayerList()
{
return &layerList;
}
-/*virtual*/ RS_BlockList * Drawing::getBlockList()
+/*virtual*/ BlockList * Drawing::getBlockList()
{
return &blockList;
}
*/
void Drawing::newDoc()
{
- RS_DEBUG->print("Drawing::newDoc");
+ DEBUG->print("Drawing::newDoc");
clear();
clearLayers();
clearBlocks();
- addLayer(new RS_Layer("0"));
- //addLayer(new RS_Layer("ByBlock"));
+ addLayer(new Layer("0"));
+ //addLayer(new Layer("ByBlock"));
setModified(false);
}
{
bool ret = false;
- RS_DEBUG->print("Drawing::save");
- RS_DEBUG->print(" file: %s", filename.toLatin1().data());
- RS_DEBUG->print(" format: %d", (int)formatType);
- RS_DEBUG->print(" export...");
- ret = RS_FILEIO->fileExport(*this, filename, formatType);
+ DEBUG->print("Drawing::save");
+ DEBUG->print(" file: %s", filename.toLatin1().data());
+ DEBUG->print(" format: %d", (int)formatType);
+ DEBUG->print(" export...");
+ ret = FILEIO->fileExport(*this, filename, formatType);
if (ret)
{
blockList.setModified(false);
}
- RS_DEBUG->print("Drawing::save ok");
+ DEBUG->print("Drawing::save ok");
return ret;
}
*/
bool Drawing::saveAs(const QString & filename, RS2::FormatType type)
{
- RS_DEBUG->print("Drawing::saveAs");
+ DEBUG->print("Drawing::saveAs");
this->filename = filename;
this->formatType = type;
*/
bool Drawing::open(const QString & filename, RS2::FormatType type)
{
- RS_DEBUG->print("Drawing::open(%s)", filename.toLatin1().data());
+ DEBUG->print("Drawing::open(%s)", filename.toLatin1().data());
bool ret = false;
this->filename = filename;
// clean all:
newDoc();
// import file:
- ret = RS_FILEIO->fileImport(*this, filename, type);
+ ret = FILEIO->fileImport(*this, filename, type);
setModified(false);
layerList.setModified(false);
blockList.setModified(false);
//cout << *((Drawing*)graphic);
//calculateBorders();
- RS_DEBUG->print("Drawing::open(%s): OK", filename.toLatin1().data());
+ DEBUG->print("Drawing::open(%s): OK", filename.toLatin1().data());
return ret;
}
return layerList.count();
}
-RS_Layer * Drawing::layerAt(uint i)
+Layer * Drawing::layerAt(uint i)
{
return layerList.at(i);
}
layerList.activate(name);
}
-void Drawing::activateLayer(RS_Layer * layer)
+void Drawing::activateLayer(Layer * layer)
{
layerList.activate(layer);
}
-RS_Layer * Drawing::getActiveLayer()
+Layer * Drawing::getActiveLayer()
{
return layerList.getActive();
}
-/*virtual*/ void Drawing::addLayer(RS_Layer * layer)
+/*virtual*/ void Drawing::addLayer(Layer * layer)
{
layerList.add(layer);
}
/**
* Removes the given layer and undoes all entities on it.
*/
-/*virtual*/ void Drawing::removeLayer(RS_Layer * layer)
+/*virtual*/ void Drawing::removeLayer(Layer * layer)
{
if (layer != NULL && layer->getName() != "0")
{
// remove all entities on that layer:
startUndoCycle();
- for(RS_Entity * e=firstEntity(RS2::ResolveNone); e!=NULL; e=nextEntity(RS2::ResolveNone))
+ for(Entity * e=firstEntity(RS2::ResolveNone); e!=NULL; e=nextEntity(RS2::ResolveNone))
{
if (e->getLayer() && e->getLayer()->getName() == layer->getName())
{
// remove all entities in blocks that are on that layer:
for(uint bi=0; bi<blockList.count(); bi++)
{
- RS_Block * blk = blockList.at(bi);
+ Block * blk = blockList.at(bi);
if (blk)
{
- for(RS_Entity * e=blk->firstEntity(RS2::ResolveNone); e!=NULL; e=blk->nextEntity(RS2::ResolveNone))
+ for(Entity * e=blk->firstEntity(RS2::ResolveNone); e!=NULL; e=blk->nextEntity(RS2::ResolveNone))
{
if (e->getLayer() != NULL && e->getLayer()->getName() == layer->getName())
{
}
}
-/*virtual*/ void Drawing::editLayer(RS_Layer * layer, const RS_Layer & source)
+/*virtual*/ void Drawing::editLayer(Layer * layer, const Layer & source)
{
layerList.edit(layer, source);
}
-RS_Layer * Drawing::findLayer(const QString & name)
+Layer * Drawing::findLayer(const QString & name)
{
return layerList.find(name);
}
layerList.toggle(name);
}
-void Drawing::toggleLayer(RS_Layer * layer)
+void Drawing::toggleLayer(Layer * layer)
{
layerList.toggle(layer);
}
-void Drawing::toggleLayerLock(RS_Layer * layer)
+void Drawing::toggleLayerLock(Layer * layer)
{
layerList.toggleLock(layer);
}
}
#if 0
-void Drawing::addLayerListListener(RS_LayerListListener * listener)
+void Drawing::addLayerListListener(LayerListListener * listener)
{
layerList.addListener(listener);
}
-void Drawing::removeLayerListListener(RS_LayerListListener * listener)
+void Drawing::removeLayerListListener(LayerListListener * listener)
{
layerList.removeListener(listener);
}
return blockList.count();
}
-RS_Block * Drawing::blockAt(uint i)
+Block * Drawing::blockAt(uint i)
{
return blockList.at(i);
}
blockList.activate(name);
}
-void Drawing::activateBlock(RS_Block * block)
+void Drawing::activateBlock(Block * block)
{
blockList.activate(block);
}
-RS_Block * Drawing::getActiveBlock()
+Block * Drawing::getActiveBlock()
{
return blockList.getActive();
}
-/*virtual*/ bool Drawing::addBlock(RS_Block * block, bool notify/*= true*/)
+/*virtual*/ bool Drawing::addBlock(Block * block, bool notify/*= true*/)
{
return blockList.add(block, notify);
}
blockList.addNotification();
}
-/*virtual*/ void Drawing::removeBlock(RS_Block * block)
+/*virtual*/ void Drawing::removeBlock(Block * block)
{
blockList.remove(block);
}
-RS_Block * Drawing::findBlock(const QString & name)
+Block * Drawing::findBlock(const QString & name)
{
return blockList.find(name);
}
blockList.toggle(name);
}
-void Drawing::toggleBlock(RS_Block * block)
+void Drawing::toggleBlock(Block * block)
{
blockList.toggle(block);
}
}
#if 0
-void Drawing::addBlockListListener(RS_BlockListListener * listener)
+void Drawing::addBlockListListener(BlockListListener * listener)
{
blockList.addListener(listener);
}
-void Drawing::removeBlockListListener(RS_BlockListListener * listener)
+void Drawing::removeBlockListListener(BlockListListener * listener)
{
blockList.removeListener(listener);
}
variableDict.remove(key);
}
-//Q3Dict<RS_Variable> & getVariableDict()
-QMultiHash<QString, RS_Variable *> & Drawing::getVariableDict()
+//Q3Dict<Variable> & getVariableDict()
+QMultiHash<QString, Variable *> & Drawing::getVariableDict()
{
return variableDict.getVariableDict();
}
*/
void Drawing::setUnit(RS2::Unit u)
{
- setPaperSize(RS_Units::convert(getPaperSize(), getUnit(), u));
+ setPaperSize(Units::convert(getPaperSize(), getUnit(), u));
addVariable("$INSUNITS", (int)u, 70);
//unit = u;
}
*/
Vector Drawing::getPaperSize()
{
- Vector def = RS_Units::convert(Vector(210.0, 297.0), RS2::Millimeter, getUnit());
+ Vector def = Units::convert(Vector(210.0, 297.0), RS2::Millimeter, getUnit());
Vector v1 = getVariableVector("$PLIMMIN", Vector(0.0, 0.0));
Vector v2 = getVariableVector("$PLIMMAX", def);
*/
RS2::PaperFormat Drawing::getPaperFormat(bool * landscape)
{
- Vector size = RS_Units::convert(getPaperSize(), getUnit(), RS2::Millimeter);
+ Vector size = Units::convert(getPaperSize(), getUnit(), RS2::Millimeter);
if (landscape != NULL)
*landscape = (size.x > size.y);
- return RS_Units::paperSizeToFormat(size);
+ return Units::paperSizeToFormat(size);
}
/**
*/
void Drawing::setPaperFormat(RS2::PaperFormat f, bool landscape)
{
- Vector size = RS_Units::paperFormatToSize(f);
+ Vector size = Units::paperFormatToSize(f);
if (landscape)
{
}
if (f != RS2::Custom)
- setPaperSize(RS_Units::convert(size, RS2::Millimeter, getUnit()));
+ setPaperSize(Units::convert(size, RS2::Millimeter, getUnit()));
}
/**
*/
void Drawing::fitToPage()
{
- double border = RS_Units::convert(25.0, RS2::Millimeter, getUnit());
+ double border = Units::convert(25.0, RS2::Millimeter, getUnit());
Vector ps = getPaperSize() - Vector(border, border);
Vector s = getSize();
double fx = RS_MAXDOUBLE;
double fy = RS_MAXDOUBLE;
//double factor = 1.0;
- //ps = RS_Units::convert(ps, getUnit(), RS2::Millimeter);
+ //ps = Units::convert(ps, getUnit(), RS2::Millimeter);
if (fabs(s.x) > 1.0e-6)
fx = ps.x / s.x;
os << "--- Drawing: \n";
os << "---" << *g.getLayerList() << "\n";
os << "---" << *g.getBlockList() << "\n";
- os << "---" << (RS_Undo &)g << "\n";
- os << "---" << (RS_EntityContainer &)g << "\n";
+ os << "---" << (Undo &)g << "\n";
+ os << "---" << (EntityContainer &)g << "\n";
return os;
}