Changeset 216:e49a3bb2b796 in SMSSender


Ignore:
Timestamp:
May 6, 2012 4:55:49 PM (8 years ago)
Author:
Sämy Zehnder <saemy.zehnder@…>
Branch:
default
Message:
  • Showing account creation dialog on startup if no account is created yet.
  • SContact, SGroup and SNumber are implemented using shared data pointers now.
Files:
3 added
52 edited

Legend:

Unmodified
Added
Removed
  • gateways/ETHZ/src/business/bcaccount_task_sendsms.cpp

    r198 r216  
    2020#include <math.h>
    2121
     22#include <snumber.h>
    2223#include <exceptions/eabortloadingexception.h>
    2324
     
    117118    posts.append(SKeyValueParam("action",     "sendsms"));
    118119    posts.append(SKeyValueParam("originator", "auto"));
    119     posts.append(SKeyValueParam("number",     recipient->number().toString("'00'CCAAAu").toUtf8()));
     120    posts.append(SKeyValueParam("number",     recipient.number().toString("'00'CCAAAu").toUtf8()));
    120121    posts.append(SKeyValueParam("message",    text.toUtf8()));
    121122
  • gateways/ETHZ/src/business/contactimporter/bccontactimporter.cpp

    r198 r216  
    9494            if (!name.isEmpty() && number.isValid()) {
    9595                SContact contact;
    96                 contact->setName(name);
    97                 contact->setNumber(number);
     96                contact.setName(name);
     97                contact.setNumber(number);
    9898
    9999                contacts.insert(contact);
  • gateways/Post/src/business/bcaccount_task_sendsms.cpp

    r198 r216  
    2020#include <math.h>
    2121
     22#include <snumber.h>
    2223#include <exceptions/eabortloadingexception.h>
    2324
     
    115116void BCSMSSendTaskPriv::addRecipient(const SContact& recipient) {
    116117    haltIfCancelRequested();
    117     qDebug() << "Starting adding recipient " + recipient->number().toString();
     118    qDebug() << "Starting adding recipient " + recipient.number().toString();
    118119
    119120    setDetails(Account::Action::AddingRecipients);
     
    121122        recipientsStr_ += ",";
    122123    }
    123     recipientsStr_ += recipient->number().toString("aaau");
     124    recipientsStr_ += recipient.number().toString("aaau");
    124125
    125126    qDebug() << "Recipient added";
  • gateways/Post/src/business/contactimporter/bccontactimporter.cpp

    r198 r216  
    101101            if (!name.isEmpty() && number.isValid()) {
    102102                SContact contact;
    103                 contact->setName(name);
    104                 contact->setNumber(number);
     103                contact.setName(name);
     104                contact.setNumber(number);
    105105
    106106                contacts.insert(contact);
  • gateways/Schoolnet/src/business/bcaccount_task_sendsms.cpp

    r198 r216  
    2020#include <math.h>
    2121
     22#include <snumber.h>
    2223#include <exceptions/eabortloadingexception.h>
    2324
     
    118119void BCSMSSendTaskPriv::addRecipient(const SContact& recipient) {
    119120    //TODO: haltIfCancelled();
    120     qDebug() << "Starting adding recipient " + recipient->number().toString();
     121    qDebug() << "Starting adding recipient " + recipient.number().toString();
    121122
    122123    setDetails(Account::Action::AddingRecipients);
    123124
    124125    QList<IParam> posts;
    125     posts.append(SKeyValueParam("Layout1:PresentationModeControlsContainer:_ctl2:_ctl0:_ctl0:txtSmsListPrefix", recipient->number().toString("aaa").toUtf8()));
    126     posts.append(SKeyValueParam("Layout1:PresentationModeControlsContainer:_ctl2:_ctl0:_ctl0:txtSmsListHandy", recipient->number().toString("u").toUtf8()));
     126    posts.append(SKeyValueParam("Layout1:PresentationModeControlsContainer:_ctl2:_ctl0:_ctl0:txtSmsListPrefix", recipient.number().toString("aaa").toUtf8()));
     127    posts.append(SKeyValueParam("Layout1:PresentationModeControlsContainer:_ctl2:_ctl0:_ctl0:txtSmsListHandy", recipient.number().toString("u").toUtf8()));
    127128    posts.append(SKeyValueParam("Layout1:PresentationModeControlsContainer:_ctl2:_ctl0:_ctl0:imgBtnAddrAddToGridForSms.x", "10"));
    128129    posts.append(SKeyValueParam("Layout1:PresentationModeControlsContainer:_ctl2:_ctl0:_ctl0:imgBtnAddrAddToGridForSms.y", "10"));
  • gateways/Schoolnet/src/business/contactimporter/bccontactimporter.cpp

    r198 r216  
    112112
    113113                SContact contact;
    114                 contact->setName(name);
     114                contact.setName(name);
    115115
    116116                QString imgAddr = rx.cap(1);
    117117                if (imgAddr != "../images/anonymous.gif") {
    118118                    QImage img = QImage::fromData(account->httpHelper()->syncGet(imgAddr));
    119                     contact->setImage(img);
     119                    contact.setImage(img);
    120120                }
    121121
    122                 contact->setNumber(SNumber(rx.cap(3), "'+'ccaa' 'u"));
     122                contact.setNumber(SNumber(rx.cap(3), "'+'ccaa' 'u"));
    123123                contacts.insert(contact);
    124124
  • gateways/Sunrise/src/business/bcaccount_task_sendsms.cpp

    r198 r216  
    2424#include <math.h>
    2525
     26#include <snumber.h>
    2627#include <exceptions/eabortloadingexception.h>
    2728
     
    145146void BCSMSSendTaskPriv::addRecipient(const SContact& recipient) {
    146147    haltIfCancelRequested();
    147     qDebug() << "Starting adding recipient " + recipient->number().toString();
     148    qDebug() << "Starting adding recipient " + recipient.number().toString();
    148149
    149150    setDetails(Account::Action::AddingRecipients);
     
    151152        recipientsStr_ += ",";
    152153    }
    153     recipientsStr_ += recipient->number().toString("'+'ccaau");
     154    recipientsStr_ += recipient.number().toString("'+'ccaau");
    154155
    155156    qDebug() << "Recipient added";
  • gateways/Sunrise/src/business/contactimporter/bccontactimporter.cpp

    r198 r216  
    8181        while ((pos = rx.indexIn(html, pos)) != -1) {
    8282            SContact contact;
    83             contact->setName(rx.cap(2));
    84             contact->setNumber(rx.cap(1));
     83            contact.setName(rx.cap(2));
     84            contact.setNumber(rx.cap(1));
    8585
    8686            contacts.insert(contact);
  • gateways/SwisscomXtraZone/src/business/bcaccount_task_sendsms.cpp

    r198 r216  
    2020#include <math.h>
    2121
     22#include <snumber.h>
    2223#include <exceptions/eabortloadingexception.h>
    2324
     
    115116void BCSMSSendTaskPriv::addRecipient(const SContact& recipient) {
    116117    haltIfCancelRequested();
    117     qDebug() << "Starting adding recipient " + recipient->number().toString();
     118    qDebug() << "Starting adding recipient " + recipient.number().toString();
    118119
    119120    setDetails(Account::Action::AddingRecipients);
     
    121122        recipientsStr_ += ",";
    122123    }
    123     recipientsStr_ += recipient->number().toString("aaau");
     124    recipientsStr_ += recipient.number().toString("aaau");
    124125
    125126    qDebug() << "Recipient added";
  • gateways/SwisscomXtraZone/src/business/contactimporter/bccontactimporter.cpp

    r198 r216  
    106106            if (!name.isEmpty() && number.isValid()) {
    107107                SContact contact;
    108                 contact->setName(name);
    109                 contact->setNumber(number);
     108                contact.setName(name);
     109                contact.setNumber(number);
    110110
    111111                if (rx.cap(1) != "/img/common/img_contact_50.jpg") {
    112112                    try {
    113113                        QImage img = QImage::fromData(account->networkHelper()->syncGet(QUrl("https://xtrazone.sso.bluewin.ch" + rx.cap(1)))->readAll());
    114                         contact->setImage(img);
     114                        contact.setImage(img);
    115115                    } catch (...) {
    116116                    }
  • lib/datatypes/datatypes.pro

    r198 r216  
    2424# Input
    2525HEADERS += src/scontact.h \
     26    src/scontact_p.h \
    2627    src/sdatatypes.h \
    2728    src/sdummyaccount.h \
    2829    src/sgroup.h \
     30    src/sgroup_p.h \
    2931    src/smacros.h \
    3032    src/snetworkhelper.h \ # src/snotifyparam.h \
     
    3234    src/snumber.h \
    3335    src/snumber_p.h \
     36    src/sshared.h \
    3437    src/ssharedpointer.h \
    3538    src/ssingleton.h \
  • lib/datatypes/src/interfaces/imanagers.h

    r194 r216  
    119119    virtual SContact       getContact(int contactId) const =0;
    120120    virtual QSet<SContact> getContactList() const =0;
    121     virtual void           saveContact(const SContact& contact) =0;
     121    virtual void           saveContact(SContact& contact) =0;
    122122    virtual void           removeContact(int contactId) =0;
    123123    virtual bool           hasContact(int contactId) const =0;
     
    157157    virtual SGroup       getGroup(int groupId) =0;
    158158    virtual QSet<SGroup> getGroupList() =0;
    159     virtual void         saveGroup(const SGroup& group) =0;
     159    virtual void         saveGroup(SGroup& group) =0;
    160160    virtual void         removeGroup(int groupId) =0;
    161161    virtual bool         hasGroup(int groupId) const =0;
  • lib/datatypes/src/interfaces/persistence/icontactstoragemanager.h

    r194 r216  
    3131    virtual QSet<SContact> getContactList() =0;
    3232
    33     virtual void saveContact(const SContact& contact) =0;
     33    virtual void saveContact(SContact& contact) =0;
    3434    virtual void removeContact(const SContact& contact) =0;
    3535    virtual void removeContact(int contactId) =0;
  • lib/datatypes/src/interfaces/persistence/igroupstoragemanager.h

    r194 r216  
    3232    virtual QSet<SGroup> getGroupList() =0;
    3333
    34     virtual void saveGroup(const SGroup& group) =0;
     34    virtual void saveGroup(SGroup& group) =0;
    3535    virtual void removeGroup(const SGroup& group) =0;
    3636    virtual void removeGroup(int groupId) =0;
  • lib/datatypes/src/interfaces/persistence/istorage.cpp

    r194 r216  
    2222#include "sgroup.h"
    2323
    24 void IStoragePriv::setContactId(const SContact& contact, int id) {
    25     contact->setId(id);
     24void IStoragePriv::setContactId(SContact& contact, int id) {
     25    contact.setId(id);
    2626}
    27 void IStoragePriv::setGroupId(const SGroup& group, int id) {
    28     group->setId(id);
     27void IStoragePriv::setGroupId(SGroup& group, int id) {
     28    group.setId(id);
    2929}
    3030
  • lib/datatypes/src/interfaces/persistence/istorage.h

    r194 r216  
    5555    virtual void writeEncryptedString(const QString& _namespace, const QString& key, const QString& password, const QString& value) =0;
    5656    virtual void writeImage(const QString& _namespace, const QString& key, const QImage& image) =0;
    57     virtual void writeContact(const SContact& contact) =0;
    58     virtual void writeGroup(const SGroup& group) =0;
     57    virtual void writeContact(SContact& contact) =0;
     58    virtual void writeGroup(SGroup& group) =0;
    5959    virtual void writeShortcut(const QString& key, const QKeySequence& shortcut) =0;
    6060
     
    7272
    7373protected:
    74     void setContactId(const SContact& contact, int id);
    75     void setGroupId(const SGroup& group, int id);
     74    void setContactId(SContact& contact, int id);
     75    void setGroupId(SGroup& group, int id);
    7676};
    7777Q_DECLARE_INTERFACE(IStoragePriv, "ch.gorrion.smssender.IStoragePriv/1.0")
  • lib/datatypes/src/scontact.cpp

    r194 r216  
    1717 */
    1818#include "scontact.h"
     19#include "scontact_p.h"
    1920
    2021#include "smacros.h"
    21 #include "snumber.h"
    2222
    23 SContactPriv::SContactPriv()
    24     : id_(-1)
    25 {
     23S_SHARED2_INTERFACE_NOPUREVIRTUAL_IMPL(SContact)
     24S_SHARED2_FINAL_IMPL(SContact)
     25
     26int SContact::id() const {
     27    return d()->id;
     28}
     29QString SContact::name() const {
     30    return d()->name;
     31}
     32SNumber SContact::number() const {
     33    return d()->number;
     34}
     35QStringList SContact::aliases() const {
     36    return d()->aliases;
     37}
     38QImage SContact::image() const {
     39    return d()->image;
    2640}
    2741
    28 void SContactPriv::assign(const SContact& other) {
    29     id_ = other->id_;
    30     name_ = other->name_;
    31     number_ = other->number_;
    32     aliases_ = other->aliases_;
    33     image_ = other->image_;
     42void SContact::setId(int id) {
     43    int oldId = d()->id;
     44    SET_IF_DIFFERENT(d()->id, id);
     45
     46    emit d()->idChanged(*this, oldId);
     47    emit d()->dataChanged(*this);
     48}
     49void SContact::setName(const QString& name) {
     50    SET_IF_DIFFERENT(d()->name, name.trimmed());
     51    d()->aliases.removeAll(d()->name);
     52    emit d()->dataChanged(*this);
     53}
     54void SContact::setNumber(const SNumber& number) {
     55    SET_IF_DIFFERENT(d()->number, number);
     56    emit d()->dataChanged(*this);
     57}
     58void SContact::setAliases(const QStringList& aliases) {
     59    SET_IF_DIFFERENT(d()->aliases, aliases);
     60    d()->aliases.removeDuplicates();
     61    d()->aliases.removeAll(name());
     62    emit d()->dataChanged(*this);
     63}
     64void SContact::setImage(const QImage& image) {
     65    SET_IF_DIFFERENT(d()->image, image);
     66    if (!d()->image.isNull()) {
     67        d()->image = d()->image.scaledToWidth(50, Qt::SmoothTransformation);
     68    }
     69    emit d()->dataChanged(*this);
    3470}
    3571
    36 int SContactPriv::id() const {
    37     return id_;
     72SContact SContact::clone() const {
     73    SContact c(*this);
     74    c.d().detach();
     75    return c;
    3876}
    39 QString SContactPriv::name() const {
    40     return name_;
    41 }
    42 SNumber SContactPriv::number() const {
    43     return number_;
    44 }
    45 QStringList SContactPriv::aliases() const {
    46     return aliases_;
    47 }
    48 QImage SContactPriv::image() const {
    49     return image_;
    50 }
    51 
    52 void SContactPriv::setId(int id) {
    53     int oldId = id_;
    54     SET_IF_DIFFERENT(id_, id);
    55 
    56     emit idChanged(oldId, id_);
    57     emit dataChanged();
    58 }
    59 void SContactPriv::setName(const QString& name){
    60     SET_IF_DIFFERENT(name_, name.trimmed());
    61     aliases_.removeAll(name_);
    62     emit dataChanged();
    63 }
    64 void SContactPriv::setNumber(const SNumber& number){
    65     SET_IF_DIFFERENT(number_, number);
    66     emit dataChanged();
    67 }
    68 void SContactPriv::setAliases(const QStringList& aliases){
    69     SET_IF_DIFFERENT(aliases_, aliases);
    70     aliases_.removeDuplicates();
    71     aliases_.removeAll(name());
    72     emit dataChanged();
    73 }
    74 void SContactPriv::setImage(const QImage& image){
    75     SET_IF_DIFFERENT(image_, image);
    76     if (!image_.isNull()) {
    77         image_ = image_.scaledToWidth(50, Qt::SmoothTransformation);
    78     }
    79     emit dataChanged();
    80 }
    81 
    82 bool SContactPriv::operator==(const SContactPriv& other) const {
    83     return id() == other.id();
    84 }
  • lib/datatypes/src/scontact.h

    r194 r216  
    1919#define SCONTACT_H_
    2020
    21 #include <QHash>
     21#include <QMetaType>
    2222#include <QImage>
    2323#include <QStringList>
    2424
    25 #include "snumber.h"
    26 #include "ssharedpointer.h"
     25#include "sshared.h"
    2726
    28 class SContact;
    29 class SContactPriv : public QObject, public SShareable {
    30     Q_OBJECT
     27class SContactData;
     28class SNumber;
     29
     30class SContact {
     31    S_SHARED2_INTERFACE_NOPUREVIRTUAL(SContact)
     32    S_SHARED2_FINAL(SContact)
    3133
    3234    friend class IStoragePriv; // setId
    3335
    3436public:
    35     SContactPriv();
    36 
    3737    int         id() const;
    3838    QString     name() const;
     
    4646    void        setImage(const QImage& image);
    4747
    48 public:
    49     void        assign(const SContact& other);
    50 
    51 public:
    52     bool        operator==(const SContactPriv& other) const;
    53     inline bool operator!=(const SContactPriv& other) const { return !(*this == other); }
    54 
    55 signals:
    56     void idChanged(int oldId, int newId);
    57     void dataChanged();
     48    SContact    clone() const;
    5849
    5950protected:
    60     void          setId(int id);
    61 
    62 private:
    63     SContactPriv& operator=(const SContactPriv&);
    64 
    65 private:
    66     int         id_;
    67     QString     name_;
    68     SNumber     number_;
    69     QStringList aliases_;
    70     QImage      image_;
    71 };
    72 
    73 
    74 class SContact : protected SSharedQObj<SContactPriv> {
    75     friend uint qHash(const SContact& priv);
    76     S_SHARED_INTERNAL(SContact, SSharedQObj<SContactPriv>, SSharedQObj<SContactPriv>)
    77     S_SHARED_QOBJ_INTERNAL(SContact, SSharedQObj<SContactPriv>, SSharedQObj<SContactPriv>)
    78 
    79 public:
    80     SContact()
    81         : SSharedQObj<SContactPriv>(new SContactPriv)
    82     {};
    83 
    84     SContact clone() const {
    85         SContact ret;
    86         ret->assign(*this);
    87         return ret;
    88     }
     51    void        setId(int id);
    8952};
    9053Q_DECLARE_METATYPE(SContact)
    91 S_SHARED_QHASH(SContact)
     54S_SHARED2_QHASH(SContact)
    9255
    9356#endif /* SCONTACT_H_ */
  • lib/datatypes/src/sgroup.cpp

    r194 r216  
    1717 */
    1818#include "sgroup.h"
     19#include "sgroup_p.h"
    1920
     21#include "scontact.h"
    2022#include "smacros.h"
    2123
    22 SGroupPriv::SGroupPriv()
    23     : id_(-1)
    24 {
     24S_SHARED2_INTERFACE_NOPUREVIRTUAL_IMPL(SGroup)
     25S_SHARED2_FINAL_IMPL(SGroup)
     26
     27int SGroup::id() const{
     28    return d()->id;
    2529}
    26 
    27 int SGroupPriv::id() const{
    28     return id_;
     30QString SGroup::name() const{
     31    return d()->name;
    2932}
    30 QString SGroupPriv::name() const{
    31     return name_;
     33QImage SGroup::image() const{
     34    return d()->image;
    3235}
    33 QImage SGroupPriv::image() const{
    34     return image_;
    35 }
    36 QSet<SContact> SGroupPriv::contacts() const{
    37     return contactList_.values().toSet();
     36QSet<SContact> SGroup::contacts() const{
     37    return d()->contactList;
    3838}
    3939
    4040
    41 void SGroupPriv::setId(int id){
    42     int oldId = id_;
    43     SET_IF_DIFFERENT(id_, id);
     41void SGroup::setId(int id){
     42    int oldId = d()->id;
     43    SET_IF_DIFFERENT(d()->id, id);
    4444
    45     emit idChanged(oldId, id_);
    46     emit dataChanged();
     45    emit d()->idChanged(*this, oldId);
     46    emit d()->dataChanged(*this);
    4747}
    48 void SGroupPriv::setName(const QString& name){
    49     SET_IF_DIFFERENT(name_, name.trimmed());
    50     emit dataChanged();
     48void SGroup::setName(const QString& name){
     49    SET_IF_DIFFERENT(d()->name, name.trimmed());
     50    emit d()->dataChanged(*this);
    5151}
    52 void SGroupPriv::setImage(const QImage& image){
    53     SET_IF_DIFFERENT(image_, image);
    54     if (!image_.isNull()) {
    55         image_ = image_.scaledToWidth(50, Qt::SmoothTransformation);
     52void SGroup::setImage(const QImage& image){
     53    SET_IF_DIFFERENT(d()->image, image);
     54    if (!d()->image.isNull()) {
     55        d()->image = d()->image.scaledToWidth(50, Qt::SmoothTransformation);
    5656    }
    57     emit dataChanged();
     57    emit d()->dataChanged(*this);
    5858}
    59 void SGroupPriv::setContacts(const QSet<SContact>& contacts){
    60     foreach (SContact contact, contactList_) {
     59void SGroup::setContacts(const QSet<SContact>& contacts){
     60    foreach (SContact contact, d()->contactList) {
    6161        removeContactFromList(contact);
    6262    }
     
    6565    }
    6666}
    67 void SGroupPriv::addContact(const SContact& contact){
     67void SGroup::addContact(const SContact& contact){
    6868    addContactToList(contact);
    6969}
    70 void SGroupPriv::removeContact(const SContact& contact){
     70void SGroup::removeContact(const SContact& contact){
    7171    removeContactFromList(contact);
    7272}
    7373
    7474
    75 void SGroupPriv::addContactToList(const SContact& contact) {
    76     if (contactList_.contains(contact)) {
     75void SGroup::addContactToList(const SContact& contact) {
     76    if (d()->contactList.contains(contact)) {
    7777        return;
    7878    }
    7979
    80     contactList_.insert(contact);
    81     emit contactAdded(contact);
     80    d()->contactList.insert(contact);
     81    emit d()->contactAdded(*this, contact);
    8282}
    83 void SGroupPriv::removeContactFromList(const SContact& contact) {
    84     if (!contactList_.contains(contact)) {
     83void SGroup::removeContactFromList(const SContact& contact) {
     84    if (!d()->contactList.contains(contact)) {
    8585        return;
    8686    }
    8787
    88     contactList_.remove(contact);
    89     emit contactRemoved(contact);
     88    d()->contactList.remove(contact);
     89    emit d()->contactRemoved(*this, contact);
    9090}
    91 
    92 
    93 bool SGroupPriv::operator==(const SGroupPriv& other) const {
    94     return id() == other.id();
    95 }
  • lib/datatypes/src/sgroup.h

    r194 r216  
    1919#define SGROUP_H_
    2020
    21 #include <QHash>
     21#include <QMetaType>
    2222#include <QImage>
    2323#include <QSet>
    2424#include <QString>
    2525
    26 #include "scontact.h"
    27 #include "ssharedpointer.h"
     26#include "sshared.h"
    2827
    29 class SGroup;
    30 class SGroupPrivate;
     28class SContact;
     29class SGroupData;
    3130
    32 class SGroupPriv : public QObject, public SShareable {
    33     Q_OBJECT
     31class SGroup {
     32    S_SHARED2_INTERFACE_NOPUREVIRTUAL(SGroup)
     33    S_SHARED2_FINAL(SGroup)
    3434
    3535    friend class IStoragePriv; // setId
    3636
    3737public:
    38     SGroupPriv();
    39 
    4038    int            id() const;
    4139    QString        name() const;
     
    5048    void           removeContact(const SContact& contact);
    5149
    52     bool           operator==(const SGroupPriv& other) const;
    53 
    54 signals:
    55     void idChanged(int oldId, int newId);
    56     void dataChanged();
    57     void contactAdded(const SContact& contact);
    58     void contactRemoved(const SContact& contact);
    59 
    6050protected:
    6151    void           setId(int id);
     
    6454    void           addContactToList(const SContact& contact);
    6555    void           removeContactFromList(const SContact& contact);
    66 
    67 private:
    68     int            id_;
    69     QString        name_;
    70     QSet<SContact> contactList_;
    71     QImage         image_;
    72 };
    73 
    74 class SGroup : protected SSharedQObj<SGroupPriv> {
    75     friend uint qHash(const SGroup& priv);
    76     S_SHARED_INTERNAL(SGroup, SSharedQObj<SGroupPriv>, SSharedQObj<SGroupPriv>)
    77     S_SHARED_QOBJ_INTERNAL(SGroup, SSharedQObj<SGroupPriv>, SSharedQObj<SGroupPriv>)
    78 
    79 public:
    80     SGroup()
    81         : SSharedQObj<SGroupPriv>(new SGroupPriv)
    82     {};
    8356};
    8457Q_DECLARE_METATYPE(SGroup)
    85 S_SHARED_QHASH(SGroup)
     58S_SHARED2_QHASH(SGroup)
    8659
    8760#endif /* SGROUP_H_ */
  • lib/datatypes/src/snumber.cpp

    r194 r216  
    1616 along with this program.  If not, see <http://www.gnu.org/licenses/>.
    1717 */
     18#include "snumber.h"
    1819#include "snumber_p.h"
    19 #include "snumber.h"
    20 
    21 #include <QDebug>
     20
    2221#include <QStringList>
    2322
    2423#include "smacros.h"
    2524
     25S_SHARED2_INTERFACE_NOPUREVIRTUAL_NOEQUALS_IMPL(SNumber)
     26S_SHARED2_FINAL_IMPL(SNumber)
    2627
    2728/****************************************************/
    2829
    29 SNumberData::SNumberData()
    30     : countryCode(0)
    31     , areaCode(0)
    32     , userNumber("")
    33 {
    34 }
    35 SNumberData::SNumberData(const SNumberData& other)
    36     : QSharedData(other)
    37     , countryCode(other.countryCode)
    38     , areaCode(other.areaCode)
    39     , userNumber(other.userNumber)
    40 {
    41 }
    42 SNumberData::~SNumberData()
    43 {
    44 }
    4530
    4631/****************************************************/
     
    6550const QString SNumber::GuessFormat    = "%%guess%%";
    6651
    67 SNumber::SNumber()
    68     : d(new SNumberData)
    69 {
    70 }
    7152SNumber::SNumber(const QString& numberStr, const QString& format)
    72     : d(new SNumberData)
     53    : d_(SNumber::createD())
    7354{
    7455    setNumber(numberStr, format);
    7556}
    76 SNumber::SNumber(const SNumber& other)
    77     : d(other.d)
    78 {
    79 }
    80 SNumber::~SNumber() {
    81 }
    8257
    8358void SNumber::clear() {
    84     d->countryCode = 0;
    85     d->areaCode    = 0;
    86     d->userNumber  = "";
     59    d()->countryCode = 0;
     60    d()->areaCode    = 0;
     61    d()->userNumber  = "";
    8762}
    8863
     
    9873
    9974short SNumber::countryCode() const{
    100     return d->countryCode;
     75    return d()->countryCode;
    10176}
    10277short SNumber::areaCode() const{
    103     return d->areaCode;
     78    return d()->areaCode;
    10479}
    10580QString SNumber::userNumber() const{
    106     return d->userNumber;
     81    return d()->userNumber;
    10782}
    10883
     
    238213        return;
    239214
    240     SET_IF_DIFFERENT(d->countryCode, countryCode);
     215    SET_IF_DIFFERENT(d()->countryCode, countryCode);
    241216}
    242217void SNumber::setAreaCode(short areaCode){
     
    244219        return;
    245220
    246     SET_IF_DIFFERENT(d->areaCode, areaCode);
     221    SET_IF_DIFFERENT(d()->areaCode, areaCode);
    247222}
    248223void SNumber::setUserNumber(const QString& userNumberStr){
     
    250225        return;
    251226
    252     SET_IF_DIFFERENT(d->userNumber, userNumberStr);
     227    SET_IF_DIFFERENT(d()->userNumber, userNumberStr);
    253228}
    254229
     
    304279}
    305280
    306 bool SNumber::readFromString(const QString& string, const QString& format) {
     281bool SNumber::fromString(const QString& string, const QString& format) {
    307282    return setNumber(string, format);
    308283}
    309 SNumber SNumber::fromString(const QString& string, const QString& format) {
    310     return SNumber(string, format);
    311 }
    312 
    313 SNumber& SNumber::operator=(const SNumber& other) {
    314     d = other.d;
    315     return *this;
    316 }
    317 bool SNumber::operator==(const SNumber& other) const {
     284
     285bool SNumber::operator ==(const SNumber& other) const {
    318286    return toString() == other.toString();
    319287}
  • lib/datatypes/src/snumber.h

    r194 r216  
    2020
    2121#include <QMetaType>
    22 #include <QSharedDataPointer>
    2322#include <QString>
    2423
    2524#include "sdatatypes.h"
     25#include "sshared.h"
    2626
    2727class SNumberData;
    2828
    2929class SNumber {
     30    S_SHARED2_INTERFACE_NOPUREVIRTUAL_NOEQUALS(SNumber)
     31    S_SHARED2_FINAL(SNumber)
     32
    3033public:
    3134    static const QString IsoFormat;
     
    3437
    3538public:
    36     SNumber();
    3739    SNumber(const QString& numberStr, const QString& format = SNumber::GuessFormat);
    38     SNumber(const SNumber& other);
    39     ~SNumber();
    4040
    4141    short   countryCode() const;
     
    5050
    5151    QString toString(const QString& format = SNumber::IsoFormat) const;
    52     bool    readFromString(const QString& string, const QString& format = SNumber::GuessFormat);
    53 
    54     static SNumber fromString(const QString& string, const QString& format = SNumber::GuessFormat);
     52    bool    fromString(const QString& string, const QString& format = SNumber::GuessFormat);
    5553
    5654public:
    57     SNumber&    operator=(const SNumber& other);
    58     bool        operator==(const SNumber& other) const;
    59     inline bool operator!=(const SNumber& other) const { return !(*this == other); }
     55    bool operator ==(const SNumber& other) const;
    6056
    6157private:
     
    6763
    6864    short toShort(const QString& str, bool* ok);
    69 
    70 private:
    71     QSharedDataPointer<SNumberData> d;
    7265};
     66Q_DECLARE_METATYPE(SNumber)
     67S_SHARED2_QHASH(SNumber)
    7368
    7469#endif /* SNUMBER_H_ */
  • lib/datatypes/src/snumber_p.h

    r194 r216  
    2020#define SNUMBER_P_H_
    2121
    22 #include <QSharedData>
    2322#include <QString>
    2423
    25 class SNumberData : public QSharedData {
     24#include "sshared.h"
     25
     26class SNumberData : public SShareable2 {
    2627public:
    27     SNumberData();
    28     SNumberData(const SNumberData& other);
    29     ~SNumberData();
     28    SNumberData()
     29        : countryCode(0)
     30        , areaCode(0)
     31        , userNumber("")
     32    {};
     33    SNumberData(const SNumberData& other)
     34        : SShareable2()
     35        , countryCode(other.countryCode)
     36        , areaCode(other.areaCode)
     37        , userNumber(other.userNumber)
     38    {};
    3039
    3140public:
     
    3342    short   areaCode;
    3443    QString userNumber;
    35 
    36 private:
    37     SNumberData& operator=(const SNumberData&) { return *this; }
    3844};
    3945
  • lib/datatypes/src/ssharedpointer.h

    r198 r216  
    3434
    3535private:
    36     SShareable(const SShareable& other);
     36    Q_DISABLE_COPY(SShareable)
    3737};
    3838
  • src/business/bccontactmanager.cpp

    r194 r216  
    2929void BCContactManagerPriv::addContactToList(const SContact& contact) {
    3030    Q_ASSERT(contact);
    31     if (contactList_.contains(contact->id()))
     31    if (contactList_.contains(contact.id()))
    3232        return;
    3333
    34     contactList_.insert(contact->id(), contact);
     34    contactList_.insert(contact.id(), contact);
    3535
    36     connect(contact, SIGNAL(idChanged(int, int)),
    37             this, SLOT(onContactIdChanged(int, int)));
    38     connect(contact, SIGNAL(dataChanged()),
    39             this, SLOT(onContactDataChanged()));
     36    connect(contact, SIGNAL(idChanged(SContact, int)),
     37            this, SLOT(onContactIdChanged(SContact, int)));
     38    connect(contact, SIGNAL(dataChanged(SContact)),
     39            this, SIGNAL(contactUpdated(SContact)));
    4040
    4141    emit contactAdded(contact);
     
    4343
    4444void BCContactManagerPriv::removeContactFromList(const SContact& contact) {
    45     Q_ASSERT(contact);
    46     if (!contactList_.contains(contact->id()))
     45    if (!contactList_.contains(contact.id()))
    4746        return;
    4847
    4948    disconnect(contact, 0, this, 0);
    5049
    51     contactList_.remove(contact->id());
     50    contactList_.remove(contact.id());
    5251    emit contactRemoved(contact);
    5352}
     
    7372}
    7473
    75 void BCContactManagerPriv::saveContact(const SContact& contact){
     74void BCContactManagerPriv::saveContact(SContact& contact){
    7675    Q_ASSERT(contact);
    7776    PersistenceFactory::instance()->getContactManager()->saveContact(contact);
     
    9695SContact BCContactManagerPriv::getContactByNumber(const SNumber& number) const {
    9796    foreach (SContact contact, getContactList()) {
    98         if (number == contact->number()) {
     97        if (number == contact.number()) {
    9998            return contact;
    10099        }
     
    104103
    105104
    106 void BCContactManagerPriv::onContactIdChanged(int oldId, int newId) {
     105void BCContactManagerPriv::onContactIdChanged(SContact contact, int oldId) {
    107106    if (!hasContact(oldId)) {
    108107        return;
    109108    }
    110109
    111     SContact contact = contactList_.take(oldId);
    112     Q_ASSERT(contact);
    113     contactList_.insert(newId, contact);
     110    SContact c = contactList_.take(oldId);
     111    Q_ASSERT(c == contact);
     112    contactList_.insert(contact.id(), contact);
    114113}
    115 void BCContactManagerPriv::onContactDataChanged() {
    116     SContact contact = SContact::fromQObject(sender());
    117     Q_ASSERT(contact);
    118 
    119     emit contactUpdated(contact);
    120 }
  • src/business/bccontactmanager.h

    r194 r216  
    3939    SContact       getContact(int contactId) const;
    4040    QSet<SContact> getContactList() const;
    41     void           saveContact(const SContact& contact);
     41    void           saveContact(SContact& contact);
    4242    void           removeContact(int contactId);
    4343    bool           hasContact(int contactId) const;
     
    5454
    5555private slots:
    56     void           onContactIdChanged(int oldId, int newId);
    57     void           onContactDataChanged();
     56    void           onContactIdChanged(SContact contact, int oldId);
    5857};
    5958S_SINGLETON_QOBJ_DERIV(BCContactManager, IContactManager, IContactManager)
  • src/business/bcgroupmanager.cpp

    r194 r216  
    2929void BCGroupManagerPriv::addGroupToList(const SGroup& group) {
    3030    Q_ASSERT(group);
    31     if (groupList_.contains(group->id())) {
     31    if (groupList_.contains(group.id())) {
    3232        return;
    3333    }
    3434
    35     groupList_.insert(group->id(), group);
     35    groupList_.insert(group.id(), group);
    3636
    37     connect(group, SIGNAL(idChanged(int, int)),
    38             this, SLOT(onGroupIdChanged(int, int)));
    39     connect(group, SIGNAL(dataChanged()),
    40             this, SLOT(onGroupDataChanged()));
     37    connect(group, SIGNAL(idChanged(SGroup, int)),
     38            this, SLOT(onGroupIdChanged(SGroup, int)));
     39    connect(group, SIGNAL(dataChanged(SGroup)),
     40            this, SIGNAL(groupUpdated(SGroup)));
    4141
    4242    emit groupAdded(group);
     
    4545void BCGroupManagerPriv::removeGroupFromList(const SGroup& group) {
    4646    Q_ASSERT(group);
    47     if (!groupList_.contains(group->id())) {
     47    if (!groupList_.contains(group.id())) {
    4848        return;
    4949    }
     
    5151    disconnect(group, 0, this, 0);
    5252
    53     groupList_.remove(group->id());
     53    groupList_.remove(group.id());
    5454    emit groupRemoved(group);
    5555}
     
    7979}
    8080
    81 void BCGroupManagerPriv::saveGroup(const SGroup& group){
     81void BCGroupManagerPriv::saveGroup(SGroup& group){
    8282    PersistenceFactory::instance()->getGroupManager()->saveGroup(group);
    8383    addGroupToList(group);
     
    9696
    9797
    98 void BCGroupManagerPriv::onGroupIdChanged(int oldId, int newId) {
     98void BCGroupManagerPriv::onGroupIdChanged(SGroup group, int oldId) {
    9999    if (!hasGroup(oldId)) {
    100100        return;
    101101    }
    102102
    103     SGroup group = groupList_.take(oldId);
    104     Q_ASSERT(group);
    105     groupList_.insert(newId, group);
     103    SGroup g = groupList_.take(oldId);
     104    Q_ASSERT(g == group);
     105    groupList_.insert(group.id(), g);
    106106}
    107 void BCGroupManagerPriv::onGroupDataChanged() {
    108     SGroup group = SGroup::fromQObject(sender());
    109     Q_ASSERT(group);
    110     emit groupUpdated(group);
    111 }
  • src/business/bcgroupmanager.h

    r194 r216  
    3838    SGroup            getGroup(int groupId);
    3939    QSet<SGroup>      getGroupList();
    40     void              saveGroup(const SGroup& group);
     40    void              saveGroup(SGroup& group);
    4141    void              removeGroup(int groupId);
    4242    bool              hasGroup(int groupId) const;
     
    5252
    5353private slots:
    54     void              onGroupIdChanged(int oldId, int newId);
    55     void              onGroupDataChanged();
     54    void              onGroupIdChanged(SGroup group, int oldId);
    5655};
    5756S_SINGLETON_QOBJ_DERIV(BCGroupManager, IGroupManager, IGroupManager)
  • src/business/contactimporters/contactfilesimporter.cpp

    r194 r216  
    110110        SNumber number(ini.value("contacts/contact_" + QString::number(i) + "_nr").toString());
    111111        if (!name.trimmed().isEmpty() && number.isValid()) {
    112             SContact c;
    113             c->setName(name);
    114             c->setNumber(number);
    115 
    116             result.insert(c);
     112            SContact contact;
     113            contact.setName(name);
     114            contact.setNumber(number);
     115
     116            result.insert(contact);
    117117        }
    118118
     
    129129        SNumber number(ini.value(name + "/" + "number").toString());
    130130        if (!name.trimmed().isEmpty() && number.isValid()) {
    131             SContact c;
    132             c->setName(name);
    133             c->setNumber(number);
    134 
    135             result.insert(c);
     131            SContact contact;
     132            contact.setName(name);
     133            contact.setNumber(number);
     134
     135            result.insert(contact);
    136136        }
    137137    }
     
    228228        SNumber number;
    229229        if (csv.keys.contains("Mobile Phone")) {
    230             number.readFromString(csvLine.value("Mobile Phone"));
     230            number.fromString(csvLine.value("Mobile Phone"));
    231231        }
    232232
     
    238238            int j = 0;
    239239            while (!number.isValid() && (j < numberStrings.count())) {
    240                 number.readFromString(numberStrings.at(j).trimmed());
     240                number.fromString(numberStrings.at(j).trimmed());
    241241                ++j;
    242242            }
     
    248248        if ((names.count() > 0) && number.isValid()) {
    249249            SContact contact;
    250             contact->setName(names.takeFirst());
    251             contact->setNumber(number);
    252             contact->setAliases(names);
     250            contact.setName(names.takeFirst());
     251            contact.setNumber(number);
     252            contact.setAliases(names);
    253253
    254254            result.insert(contact);
  • src/business/contactimporters/googlecontactimporter.cpp

    r198 r216  
    119119            if (!name.isEmpty() && number.isValid()) {
    120120                SContact contact;
    121                 contact->setName(name);
    122                 contact->setNumber(number);
     121                contact.setName(name);
     122                contact.setNumber(number);
    123123
    124124                rx2.setPattern("<gContact:nickname>(.*)</gContact:nickname>");
     
    127127                    QStringList aliases;
    128128                    aliases.append(rx2.cap(1));
    129                     contact->setAliases(aliases);
     129                    contact.setAliases(aliases);
    130130                }
    131131
     
    134134                    QImage img = QImage::fromData(networkHelper_->syncGet(rx2.cap(1))->readAll());
    135135                    if (!img.isNull()) {
    136                         contact->setImage(img);
     136                        contact.setImage(img);
    137137                    }
    138138                }
  • src/persistence/dacontactmanager.cpp

    r194 r216  
    3535
    3636
    37 void DAContactManagerPriv::saveContact(const SContact& contact){
     37void DAContactManagerPriv::saveContact(SContact& contact){
    3838    storage()->writeContact(contact);
    3939}
    4040
    4141void DAContactManagerPriv::removeContact(const SContact& contact){
    42     removeContact(contact->id());
     42    removeContact(contact.id());
    4343}
    4444
  • src/persistence/dacontactmanager.h

    r194 r216  
    3636    virtual QSet<SContact>  getContactList();
    3737
    38     virtual void saveContact(const SContact& contact);
     38    virtual void saveContact(SContact& contact);
    3939    virtual void removeContact(const SContact& contact);
    4040    virtual void removeContact(int contactId);
  • src/persistence/dagroupmanager.cpp

    r194 r216  
    3535
    3636
    37 void DAGroupManagerPriv::saveGroup(const SGroup& group){
     37void DAGroupManagerPriv::saveGroup(SGroup& group){
    3838    storage()->writeGroup(group);
    3939}
    4040
    4141void DAGroupManagerPriv::removeGroup(const SGroup& group){
    42     removeGroup(group->id());
     42    removeGroup(group.id());
    4343}
    4444
  • src/persistence/dagroupmanager.h

    r194 r216  
    3636    virtual QSet<SGroup>  getGroupList();
    3737
    38     virtual void saveGroup(const SGroup& group);
     38    virtual void saveGroup(SGroup& group);
    3939    virtual void removeGroup(const SGroup& group);
    4040    virtual void removeGroup(int groupId);
  • src/persistence/storage/dastorage.cpp

    r194 r216  
    186186
    187187    setContactId(contact, contactId);
    188     contact->setName(query.value(0).toString());
    189     contact->setNumber(query.value(1).toString());
     188    contact.setName(query.value(0).toString());
     189    contact.setNumber(query.value(1).toString());
    190190
    191191    QString aliasesStr  = readString("contact_" + QString::number(contactId), "aliases", "");
    192192    QStringList aliases = aliasesStr.split("\t", QString::SkipEmptyParts);
    193     contact->setAliases(aliases);
    194 
    195     contact->setImage(readImage("contact_" + QString::number(contactId), "image", QImage()));
     193    contact.setAliases(aliases);
     194
     195    contact.setImage(readImage("contact_" + QString::number(contactId), "image", QImage()));
    196196    return contact;
    197197}
     
    212212
    213213    setGroupId(group, groupId);
    214     group->setName(query.value(0).toString());
    215     group->setImage(readImage("group_" + QString::number(groupId), "image", QImage()));
     214    group.setName(query.value(0).toString());
     215    group.setImage(readImage("group_" + QString::number(groupId), "image", QImage()));
    216216
    217217    QString contactIdsStr  = readString("group_" + QString::number(groupId), "contacts", "");
     
    222222        if (ok) {
    223223            SContact contact = BCContactManager::instance()->getContact(contactId);
    224             group->addContact(contact);
     224            group.addContact(contact);
    225225        }
    226226    }
     
    341341
    342342
    343 void DAStoragePriv::writeContact(const SContact& contact) {
     343void DAStoragePriv::writeContact(SContact& contact) {
    344344    Q_ASSERT(contact);
    345345    QSqlQuery query = createQuery();
    346346    query.exec("SELECT contactId "
    347347                 "FROM t_contacts "
    348                  "WHERE (contactId = '" + QString::number(contact->id()) + "'); ");
     348                 "WHERE (contactId = '" + QString::number(contact.id()) + "'); ");
    349349
    350350    if (!query.next()){
     
    352352        query.prepare("INSERT INTO t_contacts (name, number) "
    353353                        "VALUES (:name, :number);");
    354         query.bindValue(":name", contact->name());
    355         query.bindValue(":number", contact->number().toString());
     354        query.bindValue(":name", contact.name());
     355        query.bindValue(":number", contact.number().toString());
    356356        if (!query.exec()) {
    357357            Storage::EWriteException(QObject::tr("The contact could not have been written to the database."))
    358                             .addDebugInfo("contactId", contact->id())
     358                            .addDebugInfo("contactId", contact.id())
    359359                            .addDebugInfo("sql-error", query.lastError().text())
    360360                            .raise();
     
    364364        query.exec("SELECT contactId "
    365365                     "FROM t_contacts "
    366                      "WHERE (name = '" + contact->name() + "'); ");
     366                     "WHERE (name = '" + contact.name() + "'); ");
    367367        if (!query.next()) {
    368368            Storage::EWriteException(QObject::tr("The contact could not have been written to the database."))
    369                             .addDebugInfo("contactId", contact->id())
     369                            .addDebugInfo("contactId", contact.id())
    370370                            .addDebugInfo("sql-error", query.lastError().text())
    371371                            .raise();
     
    378378                        "number=:number "
    379379                      "WHERE (contactId = :contactId); ");
    380         query.bindValue(":name", contact->name());
    381         query.bindValue(":number", contact->number().toString());
    382         query.bindValue(":contactId", contact->id());
     380        query.bindValue(":name", contact.name());
     381        query.bindValue(":number", contact.number().toString());
     382        query.bindValue(":contactId", contact.id());
    383383
    384384        if (!query.exec()) {
    385385            Storage::EWriteException(QObject::tr("The contact could not have been written to the database."))
    386                             .addDebugInfo("contactId", contact->id())
     386                            .addDebugInfo("contactId", contact.id())
    387387                            .addDebugInfo("sql-error", query.lastError().text())
    388388                            .raise();
     
    392392    // Save the aliases of the contact
    393393    QString aliasesStr = "";
    394     foreach (QString alias, contact->aliases()) {
     394    foreach (QString alias, contact.aliases()) {
    395395        alias.replace("\t", " ");
    396396        aliasesStr += alias + "\t";
     
    398398    aliasesStr.remove(QRegExp("\\t$")); // Remove last "\t"
    399399    if (!aliasesStr.isEmpty()) {
    400         writeString("contact_" + QString::number(contact->id()), "aliases", aliasesStr);
     400        writeString("contact_" + QString::number(contact.id()), "aliases", aliasesStr);
    401401    } else {
    402         removeValue("contact_" + QString::number(contact->id()), "aliases");
    403     }
    404 
    405     if (!contact->image().isNull()) {
    406         writeImage("contact_" + QString::number(contact->id()), "image", contact->image());
     402        removeValue("contact_" + QString::number(contact.id()), "aliases");
     403    }
     404
     405    if (!contact.image().isNull()) {
     406        writeImage("contact_" + QString::number(contact.id()), "image", contact.image());
    407407    } else {
    408         removeValue("contact_" + QString::number(contact->id()), "image");
    409     }
    410 }
    411 
    412 void DAStoragePriv::writeGroup(const SGroup& group){
     408        removeValue("contact_" + QString::number(contact.id()), "image");
     409    }
     410}
     411
     412void DAStoragePriv::writeGroup(SGroup& group){
    413413    Q_ASSERT(group);
    414414    QSqlQuery query = createQuery();
    415415    query.exec("SELECT groupId "
    416416                 "FROM t_groups "
    417                  "WHERE (groupId = '" + QString::number(group->id()) + "'); ");
     417                 "WHERE (groupId = '" + QString::number(group.id()) + "'); ");
    418418    if (!query.next()) {
    419419        // Insert
    420420        query.prepare("INSERT INTO t_groups (name) "
    421421                        "VALUES (:name);");
    422         query.bindValue(":name", group->name());
     422        query.bindValue(":name", group.name());
    423423        if (!query.exec()) {
    424424            Storage::EWriteException(QObject::tr("The group could not have been written to the database."))
    425                             .addDebugInfo("groupId", group->id())
     425                            .addDebugInfo("groupId", group.id())
    426426                            .addDebugInfo("sql-error", query.lastError().text())
    427427                            .raise();
     
    431431        query.exec("SELECT groupId "
    432432                     "FROM t_groups "
    433                      "WHERE (name = '" + group->name() + "'); ");
     433                     "WHERE (name = '" + group.name() + "'); ");
    434434        if (!query.next()) {
    435435            Storage::EWriteException(QObject::tr("The group could not have been written to the database."))
    436                             .addDebugInfo("groupId", group->id())
     436                            .addDebugInfo("groupId", group.id())
    437437                            .addDebugInfo("sql-error", query.lastError().text())
    438438                            .raise();
     
    444444                        "name=:name "
    445445                      "WHERE (groupId = :groupId); ");
    446         query.bindValue(":name", group->name());
    447         query.bindValue(":groupId", group->id());
     446        query.bindValue(":name", group.name());
     447        query.bindValue(":groupId", group.id());
    448448
    449449        if (!query.exec()) {
    450450            Storage::EWriteException(QObject::tr("The group could not have been written to the database."))
    451                             .addDebugInfo("groupId", group->id())
     451                            .addDebugInfo("groupId", group.id())
    452452                            .addDebugInfo("sql-error", query.lastError().text())
    453453                            .raise();
    454454        }
    455455    }
    456     writeImage("group_" + QString::number(group->id()), "image", group->image());
     456    writeImage("group_" + QString::number(group.id()), "image", group.image());
    457457
    458458    // Save the contacts of the group
    459459    QString contactIdsStr = "";
    460     foreach (SContact contact, group->contacts()) {
    461         contactIdsStr += QString::number(contact->id()) + "\t";
     460    foreach (SContact contact, group.contacts()) {
     461        contactIdsStr += QString::number(contact.id()) + "\t";
    462462    }
    463463    contactIdsStr.resize(contactIdsStr.size() - 1); // Remove last "\t"
    464     writeString("group_" + QString::number(group->id()), "contacts", contactIdsStr);
     464    writeString("group_" + QString::number(group.id()), "contacts", contactIdsStr);
    465465}
    466466
  • src/persistence/storage/dastorage.h

    r194 r216  
    5353    virtual void writeEncryptedString(const QString& _namespace, const QString& key, const QString& password, const QString& value);
    5454    virtual void writeImage(const QString& _namespace, const QString& key, const QImage& image);
    55     virtual void writeContact(const SContact& contact);
    56     virtual void writeGroup(const SGroup& group);
     55    virtual void writeContact(SContact& contact);
     56    virtual void writeGroup(SGroup& group);
    5757    virtual void writeShortcut(const QString& key, const QKeySequence& shortcut);
    5858
  • src/ui/models/contactgroupmodel.cpp

    r194 r216  
    2525{
    2626    connect(BCContactManager::instance(), SIGNAL(contactAdded(const SContact&)),
    27             this, SLOT(listAltered()));
     27            this, SLOT(onListAltered()));
    2828    connect(BCContactManager::instance(), SIGNAL(contactUpdated(const SContact&)),
    29             this, SLOT(dataUpdated(const SContact&)));
     29            this, SLOT(onDataUpdated(const SContact&)));
    3030    connect(BCContactManager::instance(), SIGNAL(contactRemoved(const SContact&)),
    31             this, SLOT(listAltered()));
     31            this, SLOT(onListAltered()));
    3232
    3333    connect(BCGroupManager::instance(), SIGNAL(groupAdded(const SGroup&)),
    34             this, SLOT(listAltered()));
     34            this, SLOT(onListAltered()));
    3535    connect(BCGroupManager::instance(), SIGNAL(groupUpdated(const SGroup&)),
    36             this, SLOT(dataUpdated(const SGroup&)));
     36            this, SLOT(onDataUpdated(const SGroup&)));
    3737    connect(BCGroupManager::instance(), SIGNAL(groupRemoved(const SGroup&)),
    38             this, SLOT(listAltered()));
     38            this, SLOT(onListAltered()));
    3939
    4040    reloadList();
    4141}
    4242
    43 void ContactGroupListModel::listAltered() {
     43void ContactGroupListModel::onListAltered() {
    4444    reloadList();
    4545}
    4646
    47 void ContactGroupListModel::dataUpdated(const SContact& contact) {
     47void ContactGroupListModel::onDataUpdated(const SContact& contact) {
    4848    dataUpdated(contact);
    4949}
    50 void ContactGroupListModel::dataUpdated(const SGroup& group) {
     50void ContactGroupListModel::onDataUpdated(const SGroup& group) {
    5151    dataUpdated(group);
    5252}
     
    8181    foreach (const SGroup& group, groups()) {
    8282        bool hasUnfilteredContacts = false;
    83         foreach (const SContact& contact, group->contacts()) {
     83        foreach (const SContact& contact, group.contacts()) {
    8484            if (items_.contains(contact)) {
    8585                hasUnfilteredContacts = true;
     
    103103    foreach (const SGroup& group, filteredGroups()) {
    104104        bool hasFilteredContacts = false;
    105         foreach (const SContact& contact, group->contacts()) {
     105        foreach (const SContact& contact, group.contacts()) {
    106106            if (filteredItems_.contains(contact)) {
    107107                hasFilteredContacts = true;
     
    136136            if (container.isContact) {
    137137                SContact contact = container.contact;
    138                 QString contactStr = contact->name();
     138                QString contactStr = contact.name();
    139139                QString aliasStr   = "";
    140                 foreach(QString alias, contact->aliases()) {
     140                foreach(QString alias, contact.aliases()) {
    141141                    aliasStr += alias + ", ";
    142142                }
     
    148148            } else {
    149149                SGroup group = container.group;
    150                 return "<" + group->name() + ">";
     150                return "<" + group.name() + ">";
    151151            }
    152152            break;
     
    154154        case Qt::EditRole:
    155155            if (container.isContact) {
    156                 return container.contact->name();
     156                return container.contact.name();
    157157            } else {
    158                 return container.group->name();
     158                return container.group.name();
    159159            }
    160160            break;
     
    163163            QImage img;
    164164            if (container.isContact) {
    165                 img = container.contact->image();
     165                img = container.contact.image();
    166166            } else {
    167                 img = container.group->image();
     167                img = container.group.image();
    168168            }
    169169
  • src/ui/models/contactgroupmodel.h

    r194 r216  
    7575
    7676private slots:
    77     void dataUpdated(const SContact& contact);
    78     void dataUpdated(const SGroup& group);
    79     void listAltered();
     77    void onDataUpdated(const SContact& contact);
     78    void onDataUpdated(const SGroup& group);
     79    void onListAltered();
    8080
    8181private:
  • src/ui/models/contacttablemodel.cpp

    r205 r216  
    9292                return "";
    9393            case ColName:
    94                 return contact->name();
     94                return contact.name();
    9595            case ColNumber:
    96                 return contact->number().toString(SNumber::IsoFormatShort);
     96                return contact.number().toString(SNumber::IsoFormatShort);
    9797            case ColAliases:
    9898                return getAliasesStr(contact);
     
    102102        switch (index.column()) {
    103103            case ColImage:
    104                 return QIcon(QPixmap::fromImage(contact->image()));
     104                return QIcon(QPixmap::fromImage(contact.image()));
    105105        }
    106106    }
     
    124124    beginRemoveRows(parent, row, lastRow);
    125125    for (int i = lastRow; i >= row; --i) {
    126         BCContactManager::instance()->removeContact(contacts_.at(i)->id());
     126        BCContactManager::instance()->removeContact(contacts_.at(i));
    127127    }
    128128    endRemoveRows();
     
    132132
    133133QString ContactTableModel::getAliasesStr(const SContact& contact) const {
    134     QStringList aliases = contact->aliases();
     134    QStringList aliases = contact.aliases();
    135135    aliases.sort();
    136136    return aliases.join(", ");
  • src/ui/models/grouptablemodel.cpp

    r205 r216  
    2020#include <QDebug>
    2121#include <QIcon>
     22
     23#include <scontact.h>
    2224
    2325#include "business/bcgroupmanager.h"
     
    9193                return "";
    9294            case ColName:
    93                 return group->name();
     95                return group.name();
    9496            case ColMembers:
    9597                return getMembersStr(group);
     
    99101        switch (index.column()) {
    100102            case ColImage:
    101                 return QIcon(QPixmap::fromImage(group->image()));
     103                return QIcon(QPixmap::fromImage(group.image()));
    102104        }
    103105    }
     
    120122    beginRemoveRows(parent, row, lastRow);
    121123    for (int i = lastRow; i >= row; --i) {
    122         BCGroupManager::instance()->removeGroup(groups_.at(i)->id());
     124        BCGroupManager::instance()->removeGroup(groups_.at(i));
    123125    }
    124126    endRemoveRows();
     
    129131QString GroupTableModel::getMembersStr(const SGroup& group) const {
    130132    QStringList members;
    131     foreach (SContact contact, group->contacts()) {
    132         members.append(contact->name());
     133    foreach (SContact contact, group.contacts()) {
     134        members.append(contact.name());
    133135    }
    134136    members.sort();
  • src/ui/vcaddressbook/vcaddressbook.h

    r194 r216  
    4848    SContact getContactFromRow(int rowId) const;
    4949    SContact getSelectedContact() const;
    50     void     editContact(const SContact& contact);
     50    void     editContact(SContact& contact);
    5151
    5252
     
    5757    SGroup   getGroupFromRow(int rowId) const;
    5858    SGroup   getSelectedGroup() const;
    59     void     editGroup(const SGroup& group);
     59    void     editGroup(SGroup& group);
    6060
    6161private slots:
  • src/ui/vcaddressbook/vcaddressbook_contact.cpp

    r194 r216  
    4040
    4141
    42 void VCAddressBook::editContact(const SContact& contact){
     42void VCAddressBook::editContact(SContact& contact){
    4343    VCEditContact* ec = new VCEditContact(contact, false, this);
    4444    if (ec->exec() == QDialog::Accepted){ // Wait for return
     
    5555        return;
    5656
    57     editContact(SContact());
     57    SContact newContact;
     58    editContact(newContact);
    5859}
    5960
     
    8384
    8485        //TODO: do this eventually over the model...
    85         BCContactManager::instance()->removeContact(contact->id());
     86        BCContactManager::instance()->removeContact(contact.id());
    8687        on_tblViewContacts_selectionChanged();
    8788    }
  • src/ui/vcaddressbook/vcaddressbook_group.cpp

    r194 r216  
    3939
    4040
    41 void VCAddressBook::editGroup(const SGroup& group){
     41void VCAddressBook::editGroup(SGroup& group){
    4242    VCEditGroup* eg = new VCEditGroup(group, this);
    4343    if (eg->exec() == QDialog::Accepted){ // Wait for return
     
    5353        return;
    5454
    55     editGroup(SGroup());
     55    SGroup newGroup;
     56    editGroup(newGroup);
    5657}
    5758
     
    8182
    8283        //TODO: do this eventually over the model...
    83         BCGroupManager::instance()->removeGroup(group->id());
     84        BCGroupManager::instance()->removeGroup(group.id());
    8485        on_tblViewGroups_selectionChanged();
    8586    }
  • src/ui/vceditcontact/vceditcontact.cpp

    r194 r216  
    4141        defaultIcon_ = ui.btnIcon->icon();
    4242
    43         ui.edtName->setText(contact->name());
    44         if (!contact->number().isValid()) {
     43        ui.edtName->setText(contact.name());
     44        if (!contact.number().isValid()) {
    4545            ui.edtCountryCode->setText("+41");
    4646            ui.edtNumber->setText("");
    4747        } else {
    48         ui.edtCountryCode->setText(contact->number().toString("'+'CC"));
    49         ui.edtNumber->setText(contact->number().toString("aaa' 'u"));
     48        ui.edtCountryCode->setText(contact.number().toString("'+'CC"));
     49        ui.edtNumber->setText(contact.number().toString("aaa' 'u"));
    5050        }
    5151
    5252        // Load aliases
    53         foreach (QString alias, contact->aliases()) {
     53        foreach (QString alias, contact.aliases()) {
    5454            addAliasItem(alias);
    5555        }
     
    6060        model->sort(0, Qt::AscendingOrder);
    6161
    62     setIcon(contact->image());
     62    setIcon(contact.image());
    6363
    6464    on_lstAliases_itemSelectionChanged();
     
    226226
    227227    // Validate the number
    228     SNumber no(ui.edtCountryCode->text() + " " + ui.edtNumber->text());
    229     if (!no.isValid()) {
     228    SNumber number(ui.edtCountryCode->text() + " " + ui.edtNumber->text());
     229    if (!number.isValid()) {
    230230        errorMessages += tr("The given phone number is not valid.") + "\n";
    231231    } else {
    232         SContact c = BCContactManager::instance()->getContactByNumber(no);
    233         if (c && (c != contact_)) {
     232        SContact contact = BCContactManager::instance()->getContactByNumber(number);
     233        if (contact && (contact != contact_)) {
    234234            if (ignoreAlreadyExisting_) {
    235                 contactList.remove(c);
     235                contactList.remove(contact);
    236236            } else {
    237                 errorMessages += tr("\"%1\" is already in the adressbook with the same number.").arg(c->name()) + "\n";
     237                errorMessages += tr("\"%1\" is already in the adressbook with the same number.").arg(contact.name()) + "\n";
    238238            }
    239239        }
     
    246246            continue;
    247247
    248         reservedNames.append(contact->name());
    249         reservedNames.append(contact->aliases());
     248        reservedNames.append(contact.name());
     249        reservedNames.append(contact.aliases());
    250250    }
    251251    foreach (SGroup group, BCGroupManager::instance()->getGroupList()) {
    252         reservedNames.append(group->name());
     252        reservedNames.append(group.name());
    253253    }
    254254
     
    284284    }
    285285
    286     contact_->setName(ui.edtName->text());
    287     contact_->setNumber(SNumber(ui.edtCountryCode->text() + " " + ui.edtNumber->text(), SNumber::GuessFormat));
     286    contact_.setName(ui.edtName->text());
     287    contact_.setNumber(SNumber(ui.edtCountryCode->text() + " " + ui.edtNumber->text(), SNumber::GuessFormat));
    288288    QStringList aliases;
    289289    for (int x = 0; x < ui.lstAliases->count(); x++){
     
    293293        }
    294294    }
    295     contact_->setAliases(aliases);
    296 
    297     contact_->setImage(contactImage_);
     295    contact_.setAliases(aliases);
     296
     297    contact_.setImage(contactImage_);
    298298
    299299    done(QDialog::Accepted);
  • src/ui/vceditgroup/vceditgroup.cpp

    r194 r216  
    3535    defaultIcon_ = ui.btnIcon->icon();
    3636
    37     ui.edtName->setText(group->name());
     37    ui.edtName->setText(group.name());
    3838
    3939    contactNameToContact_.clear();
     
    4141    // Load member contacts
    4242    ui.lstMemberContacts->clear();
    43     QSet<SContact> members = group->contacts();
     43    QSet<SContact> members = group.contacts();
    4444    foreach (SContact contact, members) {
    45         ui.lstMemberContacts->addItem(contact->name());
    46         contactNameToContact_.insert(contact->name(), contact);
     45        ui.lstMemberContacts->addItem(contact.name());
     46        contactNameToContact_.insert(contact.name(), contact);
    4747    }
    4848    ui.lstMemberContacts->sortItems();
     
    5454    available.subtract(members);
    5555    foreach (SContact contact, available) {
    56         ui.lstAvailableContacts->addItem(contact->name());
    57         contactNameToContact_.insert(contact->name(), contact);
     56        ui.lstAvailableContacts->addItem(contact.name());
     57        contactNameToContact_.insert(contact.name(), contact);
    5858    }
    5959    ui.lstAvailableContacts->sortItems();
    6060
    61     setGroupImage(group->image());
     61    setGroupImage(group.image());
    6262}
    6363
     
    200200            continue;
    201201
    202         reservedNames.append(group->name());
     202        reservedNames.append(group.name());
    203203    }
    204204    foreach (SContact contact, BCContactManager::instance()->getContactList()) {
    205         reservedNames.append(contact->name());
    206         reservedNames.append(contact->aliases());
     205        reservedNames.append(contact.name());
     206        reservedNames.append(contact.aliases());
    207207    }
    208208
     
    232232    }
    233233
    234     group_->setName(ui.edtName->text());
     234    group_.setName(ui.edtName->text());
    235235
    236236    QSet<SContact> contacts;
     
    238238        contacts.insert(contactNameToContact_.value(ui.lstMemberContacts->item(x)->text()));
    239239    }
    240     group_->setContacts(contacts);
    241 
    242     group_->setImage(groupImage_);
     240    group_.setContacts(contacts);
     241
     242    group_.setImage(groupImage_);
    243243
    244244    done(QDialog::Accepted);
  • src/ui/vceditgroup/vceditgroup.h

    r194 r216  
    2626#include <QMap>
    2727
     28#include <scontact.h>
    2829#include <sgroup.h>
    2930
  • src/ui/vcimportcontacts/vcimportcontacts_importedcontacttablemodel.cpp

    r194 r216  
    7070                return "";
    7171            case ColName:
    72                 return contact->name();
     72                return contact.name();
    7373            case ColNumber:
    74                 return contact->number().toString(SNumber::IsoFormatShort);
     74                return contact.number().toString(SNumber::IsoFormatShort);
    7575            case ColAliases:
    7676                return getAliasesStr(contact);
     
    8080        switch (index.column()) {
    8181            case ColImage:
    82                 return QIcon(QPixmap::fromImage(contact->image()));
     82                return QIcon(QPixmap::fromImage(contact.image()));
    8383        }
    8484    }
     
    135135
    136136QString VCImportContactsImportedContactTableModel::getAliasesStr(const SContact& contact) const {
    137     QStringList aliases = contact->aliases();
     137    QStringList aliases = contact.aliases();
    138138    aliases.sort();
    139139    return aliases.join(", ");
     
    147147    importedContacts_ = dataManager_->importedContacts().toList();
    148148    foreach (SContact contact, importedContacts_) {
    149         connect(contact, SIGNAL(dataChanged()),
     149        connect(contact, SIGNAL(dataChanged(SContact)),
    150150                this, SLOT(contactListAltered()));
    151151    }
  • src/ui/vcimportcontacts/vcimportcontacts_page_conclusion.cpp

    r194 r216  
    8888        emit progressChanged((int)(i*100 / contacts.size()));
    8989
    90         SContact existing = BCContactManager::instance()->getContactByNumber(contact->number());
     90        SContact existing = BCContactManager::instance()->getContactByNumber(contact.number());
    9191        if (existing) {
    92             existing->setName(contact->name());
    93             existing->setImage(contact->image());
    94             existing->setAliases(contact->aliases());
     92            existing.setName(contact.name());
     93            existing.setImage(contact.image());
     94            existing.setAliases(contact.aliases());
    9595
    9696            BCContactManager::instance()->saveContact(existing);
  • src/ui/vcimportcontacts/vcimportcontacts_page_import.cpp

    r194 r216  
    4646    existingContacts_.clear();
    4747    foreach (SContact contact, BCContactManager::instance()->getContactList()) {
    48         existingContacts_.insert(contact->number().toString(), contact);
     48        existingContacts_.insert(contact.number().toString(), contact);
    4949    }
    5050
     
    9090}
    9191
    92 void VCImportContactsPageImport::addImportedContact(const SContact& contact) {
    93     if (!contact->number().isValid()) {
     92void VCImportContactsPageImport::addImportedContact(SContact& contact) {
     93    if (!contact.number().isValid()) {
    9494        return;
    9595    }
    9696
    97     QString number = contact->number().toString();
     97    QString number = contact.number().toString();
    9898
    9999    // Save a list of the names of this contact
    100100    QSet<QString> contactNames;
    101     contactNames.insert(contact->name().toLower());
    102     foreach (QString alias, contact->aliases()) {
     101    contactNames.insert(contact.name().toLower());
     102    foreach (QString alias, contact.aliases()) {
    103103        contactNames.insert(alias.toLower());
    104104    }
     
    109109
    110110        QSet<QString> existingNames;
    111         existingNames.insert(existing->name().toLower());
    112         foreach (QString alias, existing->aliases()) {
     111        existingNames.insert(existing.name().toLower());
     112        foreach (QString alias, existing.aliases()) {
    113113            existingNames.insert(alias.toLower());
    114114        }
     
    117117        bool someDataDiffers = false;
    118118        someDataDiffers     |= newNames.subtract(existingNames).size() > 0;
    119         someDataDiffers     |= existing->image().isNull() && !contact->image().isNull();
     119        someDataDiffers     |= existing.image().isNull() && !contact.image().isNull();
    120120        if (someDataDiffers) {
    121             _addImportedContact(existing.clone()); // Make a copy to not really change it
     121            SContact clone = existing.clone(); // Make a copy to not really change it
     122            _addImportedContact(clone);
    122123            _addImportedContact(contact);
    123124        }
     
    126127    }
    127128}
    128 void VCImportContactsPageImport::_addImportedContact(const SContact& contact) {
    129     QString number = contact->number().toString();
     129void VCImportContactsPageImport::_addImportedContact(SContact& contact) {
     130    QString number = contact.number().toString();
    130131
    131132    // Make the names unique, since already used names are very bad!
     
    135136    QSet<QString> contactNames;
    136137    QSet<QString> contactNamesNC;
    137     contactNames.insert(contact->name().toLower());
    138     contactNamesNC.insert(contact->name());
    139     foreach (QString alias, contact->aliases()) {
     138    contactNames.insert(contact.name().toLower());
     139    contactNamesNC.insert(contact.name());
     140    foreach (QString alias, contact.aliases()) {
    140141        contactNames.insert(alias.toLower());
    141142        contactNamesNC.insert(alias);
     
    147148
    148149        QSet<QString> existingNames;
    149         existingNames.insert(existing->name().toLower());
    150         foreach (QString alias, existing->aliases()) {
     150        existingNames.insert(existing.name().toLower());
     151        foreach (QString alias, existing.aliases()) {
    151152            existingNames.insert(alias.toLower());
    152153        }
     
    155156        if (newNames.subtract(existingNames).size() > 0) { // Some names are new
    156157            // Extend the existings names
    157             QStringList aliases = existing->aliases();
     158            QStringList aliases = existing.aliases();
    158159            foreach (QString name, newNames) {
    159160                foreach (QString nameNC, contactNamesNC) {
     
    164165                }
    165166            }
    166             existing->setAliases(aliases);
    167         }
    168 
    169         if (existing->image().isNull() && !contact->image().isNull()) {
    170             existing->setImage(contact->image());
     167            existing.setAliases(aliases);
     168        }
     169
     170        if (existing.image().isNull() && !contact.image().isNull()) {
     171            existing.setImage(contact.image());
    171172        }
    172173    } else {
    173         importedContacts_.insert(contact->number().toString(), contact);
    174     }
    175 }
    176 
    177 void VCImportContactsPageImport::adjustNames(const SContact& contact) {
     174        importedContacts_.insert(contact.number().toString(), contact);
     175    }
     176}
     177
     178void VCImportContactsPageImport::adjustNames(SContact& contact) {
    178179    // List all contacts
    179180    QList<SContact> contacts = existingContacts_.values();
     
    183184    QStringList usedNames;
    184185    foreach (SContact c, existingContacts_) {
    185         if (contact->number() != c->number()) { // Do not check our own names
    186             usedNames.append(c->name().toLower());
    187             foreach (QString alias, c->aliases()) {
     186        if (contact.number() != c.number()) { // Do not check our own names
     187            usedNames.append(c.name().toLower());
     188            foreach (QString alias, c.aliases()) {
    188189                usedNames.append(alias.toLower());
    189190            }
     
    192193
    193194    // Change the names which are already in use
    194     contact->setName(getUnusedName(contact->name(), usedNames));
     195    contact.setName(getUnusedName(contact.name(), usedNames));
    195196    QStringList aliases;
    196     foreach (QString alias, contact->aliases()) {
     197    foreach (QString alias, contact.aliases()) {
    197198        aliases.append(getUnusedName(alias, usedNames));
    198199    }
    199     contact->setAliases(aliases);
     200    contact.setAliases(aliases);
    200201}
    201202QString VCImportContactsPageImport::getUnusedName(const QString& originalName, const QStringList& usedNames) {
  • src/ui/vcimportcontacts/vcimportcontacts_page_import.h

    r194 r216  
    4646
    4747private:
    48     void addImportedContact(const SContact& contact);
    49     void _addImportedContact(const SContact& contact);
     48    void addImportedContact(SContact& contact);
     49    void _addImportedContact(SContact& contact);
    5050
    51     void adjustNames(const SContact& contact);
     51    void adjustNames(SContact& contact);
    5252    QString getUnusedName(const QString& originalName, const QStringList& usedNames);
    5353
  • src/ui/vcmain/vcmain.cpp

    r194 r216  
    2929#include "business/bcaccountmanager.h"
    3030#include "business/bccontactmanager.h"
     31#include "business/bcgatewaymanager.h"
    3132#include "business/bcgroupmanager.h"
    3233#include "business/bcguimanager.h"
     
    3637#include "ui/vcaccountlist/vcaccountlist.h"
    3738#include "ui/vcaddressbook/vcaddressbook.h"
     39#include "ui/vceditaccount/vceditaccount.h"
    3840#include "ui/vceditcontact/vceditcontact.h"
    3941#include "ui/vcsettings/vcsettings.h"
     
    139141    BCGuiManager::instance()->setMainMenu(IGuiManager::Edit, ui.menuEdit, ui.actionPreferences);
    140142    BCGuiManager::instance()->setMainMenu(IGuiManager::Help, ui.menuHelp, ui.actionAbout);
     143
     144    QTimer::singleShot(500, this, SLOT(checkForAccounts()));
     145}
     146
     147/**
     148 * Check if an account is already created or show the account creation dialog otherwise.
     149 */
     150void VCMain::checkForAccounts() {
     151    if (BCGatewayManager::instance()->getGatewayList().size() == 0) {
     152        // If no gateway is there, then abort.
     153        return;
     154    }
     155
     156    if (BCAccountManager::instance()->getAccountList().size() == 0) {
     157        VCEditAccount* ea = new VCEditAccount();
     158        ea->exec();
     159        delete ea;
     160    }
    141161}
    142162
     
    270290    }
    271291
    272     node->setText(0, contact->name());
    273     node->setIcon(0, QPixmap::fromImage(contact->image()));
     292    node->setText(0, contact.name());
     293    node->setIcon(0, QPixmap::fromImage(contact.image()));
    274294    nodeToContact.insert(node, contact);
    275295}
     
    283303    ui.treeRecipients->addTopLevelItem(node);
    284304
    285     node->setText(0, group->name());
    286     node->setIcon(0, QPixmap::fromImage(group->image()));
     305    node->setText(0, group.name());
     306    node->setIcon(0, QPixmap::fromImage(group.image()));
    287307    nodeToGroup.insert(node, group);
    288308
    289     foreach (SContact contact, group->contacts()) {
     309    foreach (SContact contact, group.contacts()) {
    290310        addRecipient(contact, node);
    291311    }
     
    387407void VCMain::on_lstContacts_returnPressed() {
    388408    if (ui.lstContacts->currentIndex() < 0) {
    389         SNumber number = SNumber::fromString(ui.lstContacts->lineEdit()->text().trimmed(), SNumber::GuessFormat);
     409        SNumber number(ui.lstContacts->lineEdit()->text().trimmed(), SNumber::GuessFormat);
    390410        if (!number.isValid()) {
    391411            // If nothing is selected in the completion, just use the topmost completion
     
    421441        }
    422442    } else {
    423         SNumber number = SNumber::fromString(ui.lstContacts->lineEdit()->text().trimmed(), SNumber::GuessFormat);
     443        SNumber number(ui.lstContacts->lineEdit()->text().trimmed(), SNumber::GuessFormat);
    424444        if (number.isValid()) {
    425445            SContact recipient = BCContactManager::instance()->getContactByNumber(number);
     
    429449            } else {
    430450                SContact recipient;
    431                 recipient->setNumber(number);
     451                recipient.setNumber(number);
    432452
    433453                if (QMessageBox::Yes == QMessageBox::question(this, tr("SMSSender"),
     
    441461                    delete ec;
    442462                }
    443                 if (recipient->name() == "") {
    444                     recipient->setName(number.toString(SNumber::IsoFormatShort));
     463                if (recipient.name() == "") {
     464                    recipient.setName(number.toString(SNumber::IsoFormatShort));
    445465                }
    446466                addRecipient(recipient);
  • src/ui/vcmain/vcmain.h

    r194 r216  
    150150    void onSMSSendingErrorOccured(const EException& exceptionCtr);
    151151
     152    void onUpdateAvailable(const SVersion& newVersion, BCUpdateManager::UpdateType type);
     153
    152154private slots:
    153     void onUpdateAvailable(const SVersion& newVersion, BCUpdateManager::UpdateType type);
     155    void checkForAccounts();
    154156};
    155157
Note: See TracChangeset for help on using the changeset viewer.