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

   1 /****************************************************************************
   2 ** $Id: rs_patternlist.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_patternlist.h"
  28
  29 #include "rs_system.h"
  30
  31 RS_PatternList * RS_PatternList::uniqueInstance = NULL;
  32
  33 /**
  34  * Default constructor.
  35  */
  36 RS_PatternList::RS_PatternList(): patternIterator(patterns)
  37 {
  38 #warning "!!! Need to deal with setAutoDelete() Qt3->Qt4 !!!"
  39 //    patterns.setAutoDelete(true);
  40     //patternListListeners.setAutoDelete(false);
  41 }
  42
  43 /*virtual*/ RS_PatternList::~RS_PatternList()
  44 {
  45 }
  46
  47 /**
  48  * @return Instance to the unique pattern list.
  49  */
  50 /*static*/ RS_PatternList * RS_PatternList::instance()
  51 {
  52         if (uniqueInstance == NULL)
  53                 uniqueInstance = new RS_PatternList();
  54
  55         return uniqueInstance;
  56 }
  57
  58 /**
  59  * Initializes the pattern list by creating empty RS_Pattern
  60  * objects, one for each pattern that could be found.
  61  */
  62 void RS_PatternList::init()
  63 {
  64     RS_DEBUG->print("RS_PatternList::initPatterns");
  65
  66     QStringList list = RS_SYSTEM->getPatternList();
  67     RS_Pattern * pattern;
  68
  69         patterns.clear();
  70
  71     for(QStringList::Iterator it=list.begin(); it!=list.end(); ++it)
  72         {
  73         RS_DEBUG->print("pattern: %s:", (*it).toLatin1().data());
  74
  75         QFileInfo fi(*it);
  76         pattern = new RS_Pattern(fi.baseName().toLower());
  77         patterns.append(pattern);
  78
  79         RS_DEBUG->print("base: %s", pattern->getFileName().toLatin1().data());
  80     }
  81 }
  82
  83 /**
  84  * Removes all patterns in the patternlist.
  85  */
  86 void RS_PatternList::clearPatterns()
  87 {
  88     patterns.clear();
  89 }
  90
  91 int RS_PatternList::countPatterns()
  92 {
  93         return patterns.count();
  94 }
  95
  96 /**
  97  * Removes a pattern from the list.
  98  * Listeners are notified after the pattern was removed from
  99  * the list but before it gets deleted.
 100  */
 101 void RS_PatternList::removePattern(RS_Pattern * pattern)
 102 {
 103         RS_DEBUG->print("RS_PatternList::removePattern()");
 104
 105         // here the pattern is removed from the list but not deleted
 106 //      patterns.remove(pattern);
 107 //Apparently we need to delete this shit here because of missing AutoDelete
 108 //function when going from Qt3->4
 109         int i = patterns.indexOf(pattern);
 110
 111         if (i != -1)
 112                 delete patterns.takeAt(i);
 113
 114         //for (uint i=0; i<patternListListeners.count(); ++i) {
 115         //    RS_PatternListListener* l = patternListListeners.at(i);
 116         //    l->patternRemoved(pattern);
 117         //}
 118 }
 119
 120 /**
 121  * @return Pointer to the pattern with the given name or
 122  * \p NULL if no such pattern was found. The pattern will be loaded into
 123  * memory if it's not already.
 124  */
 125 RS_Pattern * RS_PatternList::requestPattern(const QString & name)
 126 {
 127         RS_DEBUG->print("RS_PatternList::requestPattern %s", name.toLatin1().data());
 128
 129         QString name2 = name.toLower();
 130         RS_Pattern * foundPattern = NULL;
 131
 132         RS_DEBUG->print("name2: %s", name2.toLatin1().data());
 133
 134         // Search our list of available patterns:
 135 //      for(RS_Pattern * p=patterns.first(); p!=NULL; p=patterns.next())
 136         for(int i=0; i<patterns.size(); i++)
 137         {
 138                 RS_Pattern * p = patterns[i];
 139
 140                 if (p->getFileName() == name2)
 141                 {
 142                         // Make sure this pattern is loaded into memory:
 143                         p->loadPattern();
 144                         foundPattern = p;
 145                         break;
 146                 }
 147         }
 148
 149         //if (foundPattern==NULL && name!="standard") {
 150         //    foundPattern = requestPattern("standard");
 151         //}
 152
 153         return foundPattern;
 154 }
 155
 156 //! @return First pattern of the list.
 157 RS_Pattern * RS_PatternList::firstPattern()
 158 {
 159         patternIterator.toFront();
 160         return patternIterator.next();
 161 }
 162
 163 /**
 164  * @return Next pattern from the list after
 165  * calling firstPattern() or nextPattern().
 166  */
 167 RS_Pattern * RS_PatternList::nextPattern()
 168 {
 169         return patternIterator.next();
 170 }
 171
 172 bool RS_PatternList::contains(const QString & name)
 173 {
 174         QString name2 = name.toLower();
 175
 176         // Search our list of available patterns:
 177 //      for(RS_Pattern * p=patterns.first(); p!=NULL; p=patterns.next())
 178         for(int i=0; i<patterns.size(); i++)
 179         {
 180                 RS_Pattern * p = patterns[i];
 181
 182                 if (p->getFileName() == name2)
 183                         return true;
 184         }
 185
 186         return false;
 187 }
 188
 189 /**
 190  * Dumps the patterns to stdout.
 191  */
 192 std::ostream & operator<<(std::ostream & os, RS_PatternList & l)
 193 {
 194     os << "Patternlist: \n";
 195     for(RS_Pattern * p=l.firstPattern(); p!=NULL; p=l.nextPattern())
 196         os << *p << "\n";
 197
 198     return os;
 199 }