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

   1 /****************************************************************************
   2 ** $Id: rs_layerlist.cpp 1938 2004-12-09 23:09:53Z andrew $
   3 **
   4 ** Copyright (C) 2001-2003 RibbonSoft. All rights reserved.
   5 **
   6 ** This file is part of the qcadlib Library project.
   7 **
   8 ** This file may be distributed and/or modified under the terms of the
   9 ** GNU General Public License version 2 as published by the Free Software
  10 ** Foundation and appearing in the file LICENSE.GPL included in the
  11 ** packaging of this file.
  12 **
  13 ** Licensees holding valid qcadlib Professional Edition licenses may use
  14 ** this file in accordance with the qcadlib Commercial License
  15 ** Agreement provided with the Software.
  16 **
  17 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  18 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19 **
  20 ** See http://www.ribbonsoft.com for further details.
  21 **
  22 ** Contact info@ribbonsoft.com if any conditions of this licensing are
  23 ** not clear to you.
  24 **
  25 **********************************************************************/
  26
  27 #include "rs_layerlist.h"
  28
  29 #include "rs_layer.h"
  30 #include "rs_layerlistlistener.h"
  31 #include "rs_entity.h"
  32
  33 /**
  34  * Default constructor.
  35  */
  36 RS_LayerList::RS_LayerList()
  37 {
  38 // Good news, we don't have to screw with this shit
  39 //      layers.setAutoDelete(false);
  40 //      layerListListeners.setAutoDelete(false);
  41         activeLayer = NULL;
  42         setModified(false);
  43 }
  44
  45 /*virtual*/ RS_LayerList::~RS_LayerList()
  46 {
  47 }
  48
  49 /**
  50  * Removes all layers in the layerlist.
  51  */
  52 void RS_LayerList::clear()
  53 {
  54         layers.clear();
  55         setModified(true);
  56 }
  57
  58 /**
  59  * @return Number of layers in the list.
  60  */
  61 uint RS_LayerList::count() const
  62 {
  63         return layers.count();
  64 }
  65
  66 /**
  67  * @return Layer at given position or NULL if i is out of range.
  68  */
  69 RS_Layer * RS_LayerList::at(uint i)
  70 {
  71         return layers.at(i);
  72 }
  73
  74 /**
  75  * Activates the given layer.
  76  *
  77  * @param notify Notify listeners.
  78  */
  79 void RS_LayerList::activate(const QString & name, bool notify)
  80 {
  81         RS_DEBUG->print("RS_LayerList::activate: %s, notify: %d begin", name.toLatin1().data(), notify);
  82
  83         activate(find(name), notify);
  84         /*
  85         if (activeLayer==NULL) {
  86                 RS_DEBUG->print("activeLayer is NULL");
  87 } else {
  88                 RS_DEBUG->print("activeLayer is %s", activeLayer->getName().latin1());
  89 }
  90         */
  91
  92         RS_DEBUG->print("RS_LayerList::activate: %s end", name.toLatin1().data());
  93 }
  94
  95 /**
  96  * Activates the given layer.
  97  *
  98  * @param notify Notify listeners.
  99  */
 100 void RS_LayerList::activate(RS_Layer * layer, bool notify)
 101 {
 102         RS_DEBUG->print("RS_LayerList::activate notify: %d begin", notify);
 103
 104         /*if (layer!=NULL) {
 105                 RS_DEBUG->print("RS_LayerList::activate: %s",
 106                                                 layer->getName().latin1());
 107 } else {
 108                 RS_DEBUG->print("RS_LayerList::activate: NULL");
 109 }*/
 110
 111         activeLayer = layer;
 112
 113         if (notify)
 114         {
 115                 for(int i=0; i<layerListListeners.count(); ++i)
 116                 {
 117                         RS_LayerListListener * l = layerListListeners.at(i);
 118                         l->layerActivated(activeLayer);
 119                         RS_DEBUG->print("RS_LayerList::activate listener notified");
 120                 }
 121         }
 122
 123         RS_DEBUG->print("RS_LayerList::activate end");
 124 }
 125
 126 //! @return The active layer of NULL if no layer is activated.
 127 RS_Layer * RS_LayerList::getActive()
 128 {
 129         return activeLayer;
 130 }
 131
 132 /**
 133  * Adds a layer to the layer list.
 134  * If there is already a layer with the same name, no layer is
 135  * added. In that case the layer passed to the methode will be deleted!
 136  * If no layer was active so far, the new layer becomes the active one.
 137  *
 138  * Listeners are notified.
 139  */
 140 void RS_LayerList::add(RS_Layer * layer)
 141 {
 142         RS_DEBUG->print("RS_LayerList::addLayer()");
 143
 144         if (layer == NULL)
 145                 return;
 146
 147         // check if layer already exists:
 148         RS_Layer * l = find(layer->getName());
 149
 150         if (l == NULL)
 151         {
 152                 layers.append(layer);
 153
 154                 // notify listeners
 155                 for(int i=0; i<layerListListeners.count(); ++i)
 156                 {
 157                         RS_LayerListListener * l = layerListListeners.at(i);
 158                         l->layerAdded(layer);
 159                 }
 160
 161                 setModified(true);
 162
 163                 // if there was no active layer so far, activate this one.
 164                 if (activeLayer ==NULL)
 165                         activate(layer);
 166         }
 167         else
 168         {
 169                 // if there was no active layer so far, activate this one.
 170                 if (activeLayer == NULL)
 171                         activate(l);
 172
 173                 l->setPen(layer->getPen());
 174
 175                 delete layer;
 176                 layer = NULL;
 177         }
 178 }
 179
 180 /**
 181  * Removes a layer from the list.
 182  * Listeners are notified after the layer was removed from
 183  * the list but before it gets deleted.
 184  */
 185 void RS_LayerList::remove(RS_Layer * layer)
 186 {
 187         RS_DEBUG->print("RS_LayerList::removeLayer()");
 188
 189         if (layer == NULL)
 190                 return;
 191
 192         // here the layer is removed from the list but not deleted
 193 //      layers.remove(layer);
 194         int idx = layers.indexOf(layer);
 195
 196         if (idx != -1)
 197                 layers.takeAt(idx);
 198
 199         for(int i=0; i<layerListListeners.count(); ++i)
 200         {
 201                 RS_LayerListListener * l = layerListListeners.at(i);
 202                 l->layerRemoved(layer);
 203         }
 204
 205         setModified(true);
 206
 207         // activate an other layer if necessary:
 208         if (activeLayer == layer)
 209                 activate(layers.first());
 210
 211         // now it's save to delete the layer
 212         delete layer;
 213 }
 214
 215 /**
 216  * Changes a layer's attributes. The attributes of layer 'layer'
 217  * are copied from layer 'source'.
 218  * Listeners are notified.
 219  */
 220 void RS_LayerList::edit(RS_Layer * layer, const RS_Layer & source)
 221 {
 222         if (layer == NULL)
 223                 return;
 224
 225         *layer = source;
 226
 227         for(int i=0; i<layerListListeners.count(); ++i)
 228         {
 229                 RS_LayerListListener * l = layerListListeners.at(i);
 230                 l->layerEdited(layer);
 231         }
 232
 233         setModified(true);
 234 }
 235
 236 /**
 237  * @return Pointer to the layer with the given name or
 238  * \p NULL if no such layer was found.
 239  */
 240 RS_Layer * RS_LayerList::find(const QString & name)
 241 {
 242         //RS_DEBUG->print("RS_LayerList::find begin");
 243
 244         RS_Layer * ret = NULL;
 245
 246 //      for(RS_Layer * l=layers.first(); l!=NULL; l=layers.next())
 247         for(int i=0; i<layers.size(); i++)
 248         {
 249                 RS_Layer * l = layers[i];
 250
 251                 if (l->getName() == name)
 252                         ret = l;
 253         }
 254
 255         //RS_DEBUG->print("RS_LayerList::find end");
 256
 257         return ret;
 258 }
 259
 260 /**
 261  * @return Index of the given layer in the layer list or -1 if the layer
 262  * was not found.
 263  */
 264 int RS_LayerList::getIndex(const QString & name)
 265 {
 266 #if 0
 267         //RS_DEBUG->print("RS_LayerList::find begin");
 268
 269         int ret = -1;
 270         int i = 0;
 271
 272         for(RS_Layer * l=layers.first(); l!=NULL; l=layers.next())
 273         {
 274                 if (l->getName() == name)
 275                 {
 276                         ret = i;
 277                         break;
 278                 }
 279
 280                 i++;
 281         }
 282
 283         //RS_DEBUG->print("RS_LayerList::find end");
 284
 285         return ret;
 286 #else
 287         for(int i=0; i<layers.size(); i++)
 288         {
 289                 RS_Layer * l = layers[i];
 290
 291                 if (l->getName() == name)
 292                         return i;
 293         }
 294
 295         return -1;
 296 #endif
 297 }
 298
 299 /**
 300  * @return Index of the given layer in the layer list or -1 if the layer
 301  * was not found.
 302  */
 303 int RS_LayerList::getIndex(RS_Layer * layer)
 304 {
 305 #if 0
 306         //RS_DEBUG->print("RS_LayerList::find begin");
 307
 308         int ret = -1;
 309         int i = 0;
 310
 311         for(RS_Layer* l=layers.first(); l!=NULL; l=layers.next())
 312         {
 313                 if (l == layer)
 314                 {
 315                         ret = i;
 316                         break;
 317                 }
 318
 319                 i++;
 320         }
 321
 322         //RS_DEBUG->print("RS_LayerList::find end");
 323
 324         return ret;
 325 #else
 326         return layers.indexOf(layer);
 327 #endif
 328 }
 329
 330 /**
 331  * Switches on / off the given layer.
 332  * Listeners are notified.
 333  */
 334 void RS_LayerList::toggle(const QString & name)
 335 {
 336         toggle(find(name));
 337 }
 338
 339 /**
 340  * Switches on / off the given layer.
 341  * Listeners are notified.
 342  */
 343 void RS_LayerList::toggle(RS_Layer * layer)
 344 {
 345         if (layer == NULL)
 346                 return;
 347
 348         layer->toggle();
 349
 350         // Notify listeners:
 351         for(int i=0; i < layerListListeners.count(); ++i)
 352         {
 353                 RS_LayerListListener * l = layerListListeners.at(i);
 354                 l->layerToggled(layer);
 355         }
 356 }
 357
 358 /**
 359  * Locks or unlocks the given layer.
 360  * Listeners are notified.
 361  */
 362 void RS_LayerList::toggleLock(RS_Layer * layer)
 363 {
 364         if (layer == NULL)
 365                 return;
 366
 367         layer->toggleLock();
 368
 369         // Notify listeners:
 370         for(int i=0; i<layerListListeners.count(); ++i)
 371         {
 372                 RS_LayerListListener * l = layerListListeners.at(i);
 373                 l->layerToggled(layer);
 374         }
 375 }
 376
 377 /**
 378  * Freezes or defreezes all layers.
 379  *
 380  * @param freeze true: freeze, false: defreeze
 381  */
 382 void RS_LayerList::freezeAll(bool freeze)
 383 {
 384         for(uint l=0; l<count(); l++)
 385                 at(l)->freeze(freeze);
 386
 387         for(int i=0; i<layerListListeners.count(); ++i)
 388         {
 389                 RS_LayerListListener * l = layerListListeners.at(i);
 390                 l->layerToggled(NULL);
 391         }
 392 }
 393
 394 /**
 395  * adds a LayerListListener to the list of listeners. Listeners
 396  * are notified when the layer list changes.
 397  *
 398  * Typical listeners are: layer list widgets, pen toolbar, graphic view
 399  */
 400 void RS_LayerList::addListener(RS_LayerListListener * listener)
 401 {
 402         layerListListeners.append(listener);
 403 }
 404
 405 /**
 406  * removes a LayerListListener from the list of listeners.
 407  */
 408 void RS_LayerList::removeListener(RS_LayerListListener * listener)
 409 {
 410 //      layerListListeners.remove(listener);
 411
 412         int i = layerListListeners.indexOf(listener);
 413
 414         if (i != -1)
 415                 layerListListeners.takeAt(i);
 416 }
 417
 418 /**
 419  * Sets the layer lists modified status to 'm'.
 420  */
 421 void RS_LayerList::setModified(bool m)
 422 {
 423         modified = m;
 424 }
 425
 426 /**
 427  * @retval true The layer list has been modified.
 428  * @retval false The layer list has not been modified.
 429  */
 430 /*virtual*/ bool RS_LayerList::isModified() const
 431 {
 432         return modified;
 433 }
 434
 435 /**
 436  * Dumps the layers to stdout.
 437  */
 438 std::ostream & operator<<(std::ostream & os, RS_LayerList & l)
 439 {
 440         os << "Layerlist: \n";
 441
 442         for(uint i=0; i<l.count(); i++)
 443                 os << *(l.at(i)) << "\n";
 444
 445         return os;
 446 }