]> Shamusworld >> Repos - architektonas/blob - src/base/blocklist.cpp
Bugfixes related to removing Snapper class.
[architektonas] / src / base / blocklist.cpp
1 // blocklist.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 // Portions copyright (C) 2001-2003 RibbonSoft
7 // Copyright (C) 2010 Underground Software
8 // See the README and GPLv2 files for licensing and warranty information
9 //
10 // JLH = James L. Hammons <jlhamm@acm.org>
11 //
12 // Who  When        What
13 // ---  ----------  -----------------------------------------------------------
14 // JLH  05/28/2010  Added this text. :-)
15 //
16
17 #include "blocklist.h"
18
19 #include "debug.h"
20
21 /**
22  * Constructor.
23  *
24  * @param owner true if this is the owner of the blocks added.
25  *              If so, the blocks will be deleted when the block
26  *              list is deleted.
27  */
28 BlockList::BlockList(bool owner)
29 {
30         this->owner = owner;
31         //blocks.setAutoDelete(owner);
32 //OK, this is good. We don't have to fuck with this shit.
33 //      blocks.setAutoDelete(false);
34 //      blockListListeners.setAutoDelete(false);
35         activeBlock = NULL;
36         setModified(false);
37 }
38
39 /*virtual*/ BlockList::~BlockList()
40 {
41 }
42
43 /**
44  * Removes all blocks in the blocklist.
45  */
46 void BlockList::clear()
47 {
48         blocks.clear();
49         setModified(true);
50 }
51
52 /**
53  * @return Number of blocks available.
54  */
55 uint BlockList::count()
56 {
57         return blocks.count();
58 }
59
60 /**
61  * @return Block at given position or NULL if i is out of range.
62  */
63 Block * BlockList::at(uint i)
64 {
65         return blocks.at(i);
66 }
67
68 /**
69  * Activates the given block.
70  * Listeners are notified.
71  */
72 void BlockList::activate(const QString & name)
73 {
74         DEBUG->print("BlockList::activateBlock");
75
76         activate(find(name));
77 }
78
79 /**
80  * Activates the given block.
81  * Listeners are notified.
82  */
83 void BlockList::activate(Block * block)
84 {
85         DEBUG->print("BlockList::activateBlock");
86         activeBlock = block;
87
88         /*
89                 for (uint i=0; i<blockListListeners.count(); ++i) {
90                         BlockListListener* l = blockListListeners.at(i);
91                 if (l!=NULL) {
92                         l->blockActivated(activeBlock);
93                 }
94                 }
95         */
96 }
97
98 //! @return The active block of NULL if no block is activated.
99 Block * BlockList::getActive()
100 {
101         return activeBlock;
102 }
103
104 /**
105  * Adds a block to the block list. If a block with the same name
106  * exists already, the given block will be deleted if the blocklist
107  * owns the blocks.
108  *
109  * @param notify true if you want listeners to be notified.
110  *
111  * @return false: block already existed and was deleted.
112  */
113 bool BlockList::add(Block * block, bool notify)
114 {
115         DEBUG->print("BlockList::add()");
116
117         if (block == NULL)
118                 return false;
119
120         // check if block already exists:
121         Block * b = find(block->getName());
122
123         if (b == NULL)
124         {
125                 blocks.append(block);
126
127                 if (notify)
128                         addNotification();
129
130                 setModified(true);
131
132                 return true;
133         }
134         else
135         {
136                 if (owner)
137                 {
138                         delete block;
139                         block = NULL;
140                 }
141
142                 return false;
143         }
144 }
145
146 /**
147  * Notifies the listeners about blocks that were added. This can be
148  * used after adding a lot of blocks without auto-update or simply
149  * to force an update of GUI blocklists.
150  */
151 void BlockList::addNotification()
152 {
153 #if 0
154         for(int i=0; i<blockListListeners.count(); ++i)
155         {
156                 BlockListListener * l = blockListListeners.at(i);
157                 l->blockAdded(NULL);
158         }
159 #endif
160 }
161
162 /**
163  * Removes a block from the list.
164  * Listeners are notified after the block was removed from
165  * the list but before it gets deleted.
166  */
167 void BlockList::remove(Block * block)
168 {
169         DEBUG->print("BlockList::removeBlock()");
170
171         // here the block is removed from the list but not deleted
172 //      blocks.remove(block);
173         blocks.removeAll(block);
174
175 #if 0
176         for(int i=0; i<blockListListeners.count(); ++i)
177         {
178                 BlockListListener * l = blockListListeners.at(i);
179                 l->blockRemoved(block);
180         }
181 #endif
182
183         setModified(true);
184
185         // / *
186         // activate an other block if necessary:
187         if (activeBlock == block)
188         {
189                 //activate(blocks.first());
190                 activeBlock = NULL;
191         }
192         // * /
193
194         // now it's safe to delete the block
195         if (owner)
196                 delete block;
197 }
198
199 /**
200  * Tries to rename the given block to 'name'. Block names are unique in the
201  * block list.
202  *
203  * @retval true block was successfully renamed.
204  * @retval false block couldn't be renamed.
205  */
206 bool BlockList::rename(Block * block, const QString & name)
207 {
208         if (block != NULL)
209         {
210                 if (find(name) == NULL)
211                 {
212                         block->setName(name);
213                         setModified(true);
214                         return true;
215                 }
216         }
217
218         return false;
219 }
220
221 /**
222  * Changes a block's attributes. The attributes of block 'block'
223  * are copied from block 'source'.
224  * Listeners are notified.
225  */
226 /*
227 void BlockList::editBlock(Block* block, const Block& source) {
228         *block = source;
229
230         for (uint i=0; i<blockListListeners.count(); ++i) {
231                 BlockListListener* l = blockListListeners.at(i);
232
233                 l->blockEdited(block);
234         }
235 }
236 */
237
238 /**
239  * @return Pointer to the block with the given name or
240  * \p NULL if no such block was found.
241  */
242 Block * BlockList::find(const QString & name)
243 {
244         //DEBUG->print("BlockList::find");
245
246         for(uint i=0; i<count(); i++)
247         {
248                 Block * b = at(i);
249
250                 if (b->getName() == name)
251                         return b;
252         }
253
254         return NULL;
255 }
256
257 /**
258  * Finds a new unique block name.
259  *
260  * @param suggestion Suggested name the new name will be based on.
261  */
262 QString BlockList::newName(const QString & suggestion)
263 {
264         QString name;
265
266         for(int i=0; i<1e5; ++i)
267         {
268                 name = QString("%1-%2").arg(suggestion).arg(i);
269
270                 if (find(name) == NULL)
271                         return name;
272         }
273
274         return "0";
275 }
276
277 /**
278  * Switches on / off the given block.
279  * Listeners are notified.
280  */
281 void BlockList::toggle(const QString & name)
282 {
283         toggle(find(name));
284 }
285
286 /**
287  * Switches on / off the given block.
288  * Listeners are notified.
289  */
290 void BlockList::toggle(Block * block)
291 {
292         if (block == NULL)
293                 return;
294
295         block->toggle();
296
297 #if 0
298         // Notify listeners:
299         for(int i=0; i<blockListListeners.count(); ++i)
300         {
301                 BlockListListener * l = blockListListeners.at(i);
302
303                 l->blockToggled(block);
304         }
305 #endif
306 }
307
308 /**
309  * Freezes or defreezes all blocks.
310  *
311  * @param freeze true: freeze, false: defreeze
312  */
313 void BlockList::freezeAll(bool freeze)
314 {
315         for(uint l=0; l<count(); l++)
316                 at(l)->freeze(freeze);
317
318 #if 0
319         for(int i=0; i<blockListListeners.count(); ++i)
320         {
321                 BlockListListener * l = blockListListeners.at(i);
322                 l->blockToggled(NULL);
323         }
324 #endif
325 }
326
327 /**
328  * Switches on / off the given block.
329  * Listeners are notified.
330  */
331 /*
332 void BlockList::toggleBlock(const QString& name) {
333         Block* block = findBlock(name);
334         block->toggle();
335
336     // Notify listeners:
337         for (uint i=0; i<blockListListeners.count(); ++i) {
338                 BlockListListener* l = blockListListeners.at(i);
339
340                 l->blockToggled(block);
341         }
342 }
343 */
344
345 /**
346  * adds a BlockListListener to the list of listeners. Listeners
347  * are notified when the block list changes.
348  */
349 #if 0
350 void BlockList::addListener(BlockListListener * listener)
351 {
352         blockListListeners.append(listener);
353 }
354
355 /**
356  * removes a BlockListListener from the list of listeners.
357  */
358 void BlockList::removeListener(BlockListListener * listener)
359 {
360         blockListListeners.removeAll(listener);
361 }
362 #endif
363
364 /**
365  * Sets the layer lists modified status to 'm'.
366  */
367 void BlockList::setModified(bool m)
368 {
369         modified = m;
370 }
371
372 /**
373  * @retval true The layer list has been modified.
374  * @retval false The layer list has not been modified.
375  */
376 /*virtual*/ bool BlockList::isModified() const
377 {
378         return modified;
379 }
380
381 /**
382  * Dumps the blocks to stdout.
383  */
384 std::ostream & operator<<(std::ostream & os, BlockList & b)
385 {
386         os << "Blocklist: \n";
387
388         for(uint i=0; i<b.count(); ++i)
389         {
390                 Block * blk = b.at(i);
391
392                 os << *blk << "\n";
393         }
394
395         return os;
396 }