src/hbcore/utils/hbsmileytheme.cpp
changeset 21 4633027730f5
parent 0 16d8024aca5e
equal deleted inserted replaced
7:923ff622b8b9 21:4633027730f5
    28 #include <QVariant>
    28 #include <QVariant>
    29 #include <QSharedData>
    29 #include <QSharedData>
    30 #include <QHash>
    30 #include <QHash>
    31 #include <QSet>
    31 #include <QSet>
    32 
    32 
       
    33 
    33 class HbSmileyThemePrivate : public QSharedData
    34 class HbSmileyThemePrivate : public QSharedData
    34 {
    35 {
    35 public:
    36 public:
    36 
    37 
    37     HbSmileyThemePrivate();
    38     HbSmileyThemePrivate();
    40 
    41 
    41 public: // data
    42 public: // data
    42 
    43 
    43     QHash<QString,QSet<QString> > smileyToPatterns;
    44     QHash<QString,QSet<QString> > smileyToPatterns;
    44     QHash <QString, QString> patternToSmiley;
    45     QHash <QString, QString> patternToSmiley;
       
    46     mutable QRegExp regexp;
       
    47     mutable bool dirty;
    45 };
    48 };
    46 
    49 
    47 HbSmileyThemePrivate::HbSmileyThemePrivate()
    50 HbSmileyThemePrivate::HbSmileyThemePrivate()
    48 {
    51 {
    49 }
    52 }
    50 
    53 
    51 HbSmileyThemePrivate::HbSmileyThemePrivate(const HbSmileyThemePrivate &other) : QSharedData(other),
    54 HbSmileyThemePrivate::HbSmileyThemePrivate(const HbSmileyThemePrivate &other) : QSharedData(other),
    52         smileyToPatterns(other.smileyToPatterns),
    55         smileyToPatterns(other.smileyToPatterns),
    53         patternToSmiley(other.patternToSmiley)
    56         patternToSmiley(other.patternToSmiley),
       
    57         dirty(true)
    54 {
    58 {
    55 }
    59 }
    56 
    60 
    57 HbSmileyThemePrivate::~HbSmileyThemePrivate()
    61 HbSmileyThemePrivate::~HbSmileyThemePrivate()
    58 {
    62 {
   159 
   163 
   160     bool ret = parser.parseDefinitionFile(fileName,tmpTheme);
   164     bool ret = parser.parseDefinitionFile(fileName,tmpTheme);
   161     if (ret) {
   165     if (ret) {
   162         *this = tmpTheme;
   166         *this = tmpTheme;
   163     }
   167     }
       
   168 
       
   169     d->dirty = true;
       
   170 
   164     return ret;
   171     return ret;
   165 }
   172 }
   166 
   173 
   167 
   174 
   168 /*!
   175 /*!
   191         d.detach();
   198         d.detach();
   192         QSet<QString> patterns = d->smileyToPatterns.value(smiley);
   199         QSet<QString> patterns = d->smileyToPatterns.value(smiley);
   193         patterns << pattern;
   200         patterns << pattern;
   194         d->smileyToPatterns[smiley] = patterns;
   201         d->smileyToPatterns[smiley] = patterns;
   195         d->patternToSmiley[pattern] = smiley;
   202         d->patternToSmiley[pattern] = smiley;
   196     }
   203         d->dirty = true;
       
   204     }    
   197 }
   205 }
   198 
   206 
   199 
   207 
   200 /*!
   208 /*!
   201 * Inserts a smiley to the smiley theme with a given pattern list.
   209 * Inserts a smiley to the smiley theme with a given pattern list.
   253         d.detach();
   261         d.detach();
   254         d->smileyToPatterns.remove(smiley);
   262         d->smileyToPatterns.remove(smiley);
   255         foreach(QString pattern, tmpPatterns) {
   263         foreach(QString pattern, tmpPatterns) {
   256             d->patternToSmiley.remove(pattern);
   264             d->patternToSmiley.remove(pattern);
   257         }
   265         }
       
   266         d->dirty = true;
   258     }
   267     }
   259 }
   268 }
   260 
   269 
   261 /*!
   270 /*!
   262 * Removes \a pattern from the theme.
   271 * Removes \a pattern from the theme.
   276                 d->smileyToPatterns.remove(smiley);
   285                 d->smileyToPatterns.remove(smiley);
   277             } else {
   286             } else {
   278                 d->smileyToPatterns[smiley] = tmpPatterns;
   287                 d->smileyToPatterns[smiley] = tmpPatterns;
   279             }
   288             }
   280             d->patternToSmiley.remove(pattern);
   289             d->patternToSmiley.remove(pattern);
       
   290             d->dirty = true;
   281         }
   291         }
   282     }
   292     }
   283 }
   293 }
   284 
   294 
   285 /*!
   295 /*!
   292 void HbSmileyTheme::clear()
   302 void HbSmileyTheme::clear()
   293 {
   303 {
   294     if (!isNull()) {
   304     if (!isNull()) {
   295         d.detach();
   305         d.detach();
   296         d->smileyToPatterns.clear();
   306         d->smileyToPatterns.clear();
   297         d->patternToSmiley.clear();        
   307         d->patternToSmiley.clear();
       
   308         d->dirty = true;
   298     }
   309     }
   299 }
   310 }
   300 
   311 
   301 /*!
   312 /*!
   302 * Returns an existing smiley from the smiley theme for a given \a pattern
   313 * Returns an existing smiley from the smiley theme for a given \a pattern
   341 QStringList HbSmileyTheme::patterns() const
   352 QStringList HbSmileyTheme::patterns() const
   342 {
   353 {
   343     return d->patternToSmiley.keys();
   354     return d->patternToSmiley.keys();
   344 }
   355 }
   345 
   356 
       
   357 /*!
       
   358 * Returns the regular expression for matching the smiley patterns from the theme.
       
   359 *
       
   360 * \sa patterns()
       
   361 */
       
   362 const QRegExp& HbSmileyTheme::regExp() const
       
   363 {
       
   364     if (d->dirty) {
       
   365         QString regexpStr;
       
   366         foreach (QString pattern, patterns()) {
       
   367             regexpStr += QRegExp::escape(pattern) + "|";
       
   368         }
       
   369         regexpStr.remove(regexpStr.count()-1, 1);
       
   370 
       
   371         d->regexp.setPattern(regexpStr);
       
   372         d->dirty = false;
       
   373     }
       
   374 
       
   375     return d->regexp;
       
   376 }
   346 
   377 
   347 /*!
   378 /*!
   348 * Returns the smiley theme as a QVariant.
   379 * Returns the smiley theme as a QVariant.
   349 */
   380 */
   350 HbSmileyTheme::operator QVariant() const
   381 HbSmileyTheme::operator QVariant() const