Removed unnecessary RS_ prefix from classes and whatnot.

[architektonas] / src / base / patternlist.cpp

diff --git a/src/base/patternlist.cpp b/src/base/patternlist.cpp
index c9f1499510f377f8cbc181f501ddbb3ed6a80cf6..989d406bf3ef6c2b021344791e58cbc84f033df5 100644 (file)
--- a/src/base/patternlist.cpp
+++ b/src/base/patternlist.cpp
@@ -18,67 +18,67 @@
 
 #include "system.h"
 
-RS_PatternList * RS_PatternList::uniqueInstance = NULL;
+PatternList * PatternList::uniqueInstance = NULL;
 
 /**
  * Default constructor.
  */
-RS_PatternList::RS_PatternList(): patternIterator(patterns)
+PatternList::PatternList(): patternIterator(patterns)
 {
 #warning "!!! Need to deal with setAutoDelete() Qt3->Qt4 !!!"
 //    patterns.setAutoDelete(true);
     //patternListListeners.setAutoDelete(false);
 }
 
-/*virtual*/ RS_PatternList::~RS_PatternList()
+/*virtual*/ PatternList::~PatternList()
 {
 }
 
 /**
  * @return Instance to the unique pattern list.
  */
-/*static*/ RS_PatternList * RS_PatternList::instance()
+/*static*/ PatternList * PatternList::instance()
 {
        if (uniqueInstance == NULL)
-               uniqueInstance = new RS_PatternList();
+               uniqueInstance = new PatternList();
 
        return uniqueInstance;
 }
 
 /**
- * Initializes the pattern list by creating empty RS_Pattern
+ * Initializes the pattern list by creating empty Pattern
  * objects, one for each pattern that could be found.
  */
-void RS_PatternList::init()
+void PatternList::init()
 {
-    RS_DEBUG->print("RS_PatternList::initPatterns");
+    DEBUG->print("PatternList::initPatterns");
 
-    QStringList list = RS_SYSTEM->getPatternList();
-    RS_Pattern * pattern;
+    QStringList list = SYSTEM->getPatternList();
+    Pattern * pattern;
 
        patterns.clear();
 
     for(QStringList::Iterator it=list.begin(); it!=list.end(); ++it)
        {
-        RS_DEBUG->print("pattern: %s:", (*it).toLatin1().data());
+        DEBUG->print("pattern: %s:", (*it).toLatin1().data());
 
         QFileInfo fi(*it);
-        pattern = new RS_Pattern(fi.baseName().toLower());
+        pattern = new Pattern(fi.baseName().toLower());
         patterns.append(pattern);
 
-        RS_DEBUG->print("base: %s", pattern->getFileName().toLatin1().data());
+        DEBUG->print("base: %s", pattern->getFileName().toLatin1().data());
     }
 }
 
 /**
  * Removes all patterns in the patternlist.
  */
-void RS_PatternList::clearPatterns()
+void PatternList::clearPatterns()
 {
     patterns.clear();
 }
 
-int RS_PatternList::countPatterns()
+int PatternList::countPatterns()
 {
        return patterns.count();
 }
@@ -88,9 +88,9 @@ int RS_PatternList::countPatterns()
  * Listeners are notified after the pattern was removed from
  * the list but before it gets deleted.
  */
-void RS_PatternList::removePattern(RS_Pattern * pattern)
+void PatternList::removePattern(Pattern * pattern)
 {
-       RS_DEBUG->print("RS_PatternList::removePattern()");
+       DEBUG->print("PatternList::removePattern()");
 
        // here the pattern is removed from the list but not deleted
 //     patterns.remove(pattern);
@@ -102,7 +102,7 @@ void RS_PatternList::removePattern(RS_Pattern * pattern)
                delete patterns.takeAt(i);
 
        //for (uint i=0; i<patternListListeners.count(); ++i) {
-       //    RS_PatternListListener* l = patternListListeners.at(i);
+       //    PatternListListener* l = patternListListeners.at(i);
        //    l->patternRemoved(pattern);
        //}
 }
@@ -112,20 +112,20 @@ void RS_PatternList::removePattern(RS_Pattern * pattern)
  * \p NULL if no such pattern was found. The pattern will be loaded into
  * memory if it's not already.
  */
-RS_Pattern * RS_PatternList::requestPattern(const QString & name)
+Pattern * PatternList::requestPattern(const QString & name)
 {
-       RS_DEBUG->print("RS_PatternList::requestPattern %s", name.toLatin1().data());
+       DEBUG->print("PatternList::requestPattern %s", name.toLatin1().data());
 
        QString name2 = name.toLower();
-       RS_Pattern * foundPattern = NULL;
+       Pattern * foundPattern = NULL;
 
-       RS_DEBUG->print("name2: %s", name2.toLatin1().data());
+       DEBUG->print("name2: %s", name2.toLatin1().data());
 
        // Search our list of available patterns:
-//     for(RS_Pattern * p=patterns.first(); p!=NULL; p=patterns.next())
+//     for(Pattern * p=patterns.first(); p!=NULL; p=patterns.next())
        for(int i=0; i<patterns.size(); i++)
        {
-               RS_Pattern * p = patterns[i];
+               Pattern * p = patterns[i];
 
                if (p->getFileName() == name2)
                {
@@ -144,7 +144,7 @@ RS_Pattern * RS_PatternList::requestPattern(const QString & name)
 }
 
 //! @return First pattern of the list.
-RS_Pattern * RS_PatternList::firstPattern()
+Pattern * PatternList::firstPattern()
 {
        patternIterator.toFront();
        return patternIterator.next();
@@ -154,20 +154,20 @@ RS_Pattern * RS_PatternList::firstPattern()
  * @return Next pattern from the list after
  * calling firstPattern() or nextPattern().
  */
-RS_Pattern * RS_PatternList::nextPattern()
+Pattern * PatternList::nextPattern()
 {
        return patternIterator.next();
 }
 
-bool RS_PatternList::contains(const QString & name)
+bool PatternList::contains(const QString & name)
 {
        QString name2 = name.toLower();
 
        // Search our list of available patterns:
-//     for(RS_Pattern * p=patterns.first(); p!=NULL; p=patterns.next())
+//     for(Pattern * p=patterns.first(); p!=NULL; p=patterns.next())
        for(int i=0; i<patterns.size(); i++)
        {
-               RS_Pattern * p = patterns[i];
+               Pattern * p = patterns[i];
 
                if (p->getFileName() == name2)
                        return true;
@@ -179,10 +179,10 @@ bool RS_PatternList::contains(const QString & name)
 /**
  * Dumps the patterns to stdout.
  */
-std::ostream & operator<<(std::ostream & os, RS_PatternList & l)
+std::ostream & operator<<(std::ostream & os, PatternList & l)
 {
     os << "Patternlist: \n";
-    for(RS_Pattern * p=l.firstPattern(); p!=NULL; p=l.nextPattern())
+    for(Pattern * p=l.firstPattern(); p!=NULL; p=l.nextPattern())
         os << *p << "\n";
 
     return os;