+ return QSize(style()->pixelMetric(QStyle::PM_TabCloseIndicatorWidth, 0, 0), style()->pixelMetric(QStyle::PM_TabCloseIndicatorHeight, 0, 0));

+ if (e->type() == QEvent::Enter || e->type() == QEvent::Leave) {

+ update();

+ }

+ return QAbstractButton::event(e);

+ QPainter painter(this);

+ painter.setRenderHint(QPainter::HighQualityAntialiasing);

+ QStyleOption opt;

+ opt.init(this);

+ opt.state |= QStyle::State_AutoRaise;

+ if (underMouse() && !isDown()) {

+ opt.state |= QStyle::State_Raised;

+ } else if (isDown()) {

+ opt.state |= QStyle::State_Sunken;

+ }

+ style()->drawPrimitive(QStyle::PE_IndicatorTabClose, &opt, &painter, this);

+ class QtCloseButton : public QAbstractButton {

+ Q_OBJECT

+ public:

+ explicit QtCloseButton(QWidget *parent = 0);

+ virtual QSize sizeHint() const;

+ protected:

+ virtual bool event(QEvent *e);

+ virtual void paintEvent(QPaintEvent* );

+ };

+ QStyleOption opt;

+ opt.state = option.state;

+ opt.state |= QStyle::State_AutoRaise;

+ if (option.state.testFlag(QStyle::State_MouseOver)) {

+ opt.state |= QStyle::State_Raised;

+ }

+ opt.rect = option.rect;

+ painter->save();

+ painter->fillRect(option.rect, option.state & QStyle::State_Selected ? option.palette.highlight() : option.palette.base());

+ if (index.data().toString().isEmpty()) {

+ // workaround for Qt not painting relative to the cell we're in, on OS X

+ int height = style->pixelMetric(QStyle::PM_TabCloseIndicatorWidth, 0, 0);

+ painter->translate(option.rect.x(), option.rect.y() + (option.rect.height() - height)/2);

+ style->drawPrimitive(QStyle::PE_IndicatorTabClose, &opt, painter);

+ }

+ painter->restore();

+ return NULL;

+ if (index.data().toString().isEmpty() && event->type() == QEvent::MouseButtonRelease) {

+ model->removeRow(index.row());

+ return true;

+ } else {

+ return QItemDelegate::editorEvent(event, model, option, index);

+ }

+ QSize size(style->pixelMetric(QStyle::PM_TabCloseIndicatorWidth, 0, 0) + 2, style->pixelMetric(QStyle::PM_TabCloseIndicatorHeight, 0, 0) + 2);

+ return size;

+ public:

+ QtRemovableItemDelegate(const QStyle* style);

+ virtual void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex&) const;

+ virtual QWidget* createEditor(QWidget*, const QStyleOptionViewItem&, const QModelIndex&) const;

+ virtual QSize sizeHint(const QStyleOptionViewItem&, const QModelIndex&) const;

+ protected:

+ virtual bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index);

+ private:

+ const QStyle* style;

+ QLineEdit(parent), editable(false) {

+ connect(this, SIGNAL(textChanged(QString)), SLOT(textChanged(QString)));

+ setMinimumWidth(30);

+ return editable;

+ this->editable = editable;

+ if (editable) {

+ setReadOnly(false);

+ } else {

+ setReadOnly(true);

+ }

+ int horizontalMargin = 10;

+ int verticalMargin = 6;

+ QSize textDimensions;

+ textDimensions = fontMetrics().boundingRect(text().isEmpty() ? placeholderText() : text()).size();

+ textDimensions = fontMetrics().boundingRect(text().isEmpty() ? QString(" ") : text()).size();

+ textDimensions.setWidth(textDimensions.width() + horizontalMargin);

+ textDimensions.setHeight(textDimensions.height() + verticalMargin);

+ return textDimensions;

+ updateGeometry();

+ class QtResizableLineEdit : public QLineEdit {

+ Q_OBJECT

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+ public:

+ explicit QtResizableLineEdit(QWidget* parent = 0);

+ ~QtResizableLineEdit();

+ bool isEditable() const;

+ void setEditable(const bool);

+ virtual QSize sizeHint() const;

+ private slots:

+ void textChanged(QString);

+ private:

+ bool editable;

+ };

+ setEditable(false);

+ displayModel = new QStandardItemModel(this);

+ displayItem = new QStandardItem();

+ displayItem->setText("");

+ displayModel->insertRow(0, displayItem);

+ editMenu = new QMenu(this);

+ this->setModel(displayModel);

+ editable = true;

+ return editable;

+ this->editable = editable;

+ QAction* tagAction = new QAction(editMenu);

+ tagAction->setText(label);

+ tagAction->setCheckable(true);

+ tagAction->setData(QString(id));

+ editMenu->addAction(tagAction);

+ QList<QAction*> tagActions = editMenu->actions();

+ foreach(QAction* action, tagActions) {

+ if (action->data() == id) {

+ action->setChecked(value);

+ updateDisplayItem();

+ return;

+ }

+ }

+ QList<QAction*> tagActions = editMenu->actions();

+ foreach(QAction* action, tagActions) {

+ if (action->data() == id) {

+ return action->isChecked();

+ }

+ }

+ return false;

+ if (event->type() == QEvent::MouseButtonPress ||

+ event->type() == QEvent::KeyRelease) {

+ if (!editable) return true;

+

+ QPoint p = mapToGlobal(QPoint(0,0));

+ p += QPoint(0, height());

+ editMenu->exec(p);

+ updateDisplayItem();

+ return true;

+ }

+ return QComboBox::event(event);

+ QList<QAction*> tagActions = editMenu->actions();

+ QString text = "";

+ foreach(QAction* action, tagActions) {

+ if (action->isChecked()) {

+ if (text != "") {

+ text += ", ";

+ }

+ text += action->text();

+ }

+ }

+ setItemText(0, text);

+ Q_OBJECT

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+ public:

+ explicit QtTagComboBox(QWidget* parent = 0);

+ ~QtTagComboBox();

+ bool isEditable() const;

+ void setEditable(const bool);

+ void addTag(const QString& id, const QString& label);

+ void setTag(const QString& id, bool value);

+ bool isTagSet(const QString& id) const;

+ virtual void showPopup();

+ virtual void hidePopup();

+ virtual bool event(QEvent* event);

+ private:

+ void updateDisplayItem();

+ private:

+ bool editable;

+ QStandardItemModel* displayModel;

+ QStandardItem* displayItem;

+ QMenu* editMenu;

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Address")), streetLineEdit(NULL), poboxLineEdit(NULL), addressextLineEdit(NULL), cityLineEdit(NULL), pocodeLineEdit(NULL), regionLineEdit(NULL), countryLineEdit(NULL), textFieldGridLayout(NULL), textFieldGridLayoutItem(NULL), deliveryTypeLabel(NULL), domesticRadioButton(NULL), internationalRadioButton(NULL), buttonGroup(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+ textFieldGridLayout = new QGridLayout();

+ streetLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(streetLineEdit, 0, 0, Qt::AlignVCenter);

+ poboxLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(poboxLineEdit, 0, 1, Qt::AlignVCenter);

+ addressextLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(addressextLineEdit, 1, 0, Qt::AlignVCenter);

+ cityLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(cityLineEdit, 2, 0, Qt::AlignVCenter);

+ pocodeLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(pocodeLineEdit, 2, 1, Qt::AlignVCenter);

+ regionLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(regionLineEdit, 3, 0, Qt::AlignVCenter);

+ countryLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(countryLineEdit, 4, 0, Qt::AlignVCenter);

+ textFieldGridLayout->setVerticalSpacing(2);

+ getGridLayout()->addLayout(textFieldGridLayout, getGridLayout()->rowCount()-1, 2, 5, 2, Qt::AlignVCenter);

+ textFieldGridLayoutItem = getGridLayout()->itemAtPosition(getGridLayout()->rowCount()-1, 2);

+ streetLineEdit->setPlaceholderText(tr("Street"));

+ poboxLineEdit->setPlaceholderText(tr("PO Box"));

+ addressextLineEdit->setPlaceholderText(tr("Address Extension"));

+ cityLineEdit->setPlaceholderText(tr("City"));

+ pocodeLineEdit->setPlaceholderText(tr("Postal Code"));

+ regionLineEdit->setPlaceholderText(tr("Region"));

+ countryLineEdit->setPlaceholderText(tr("Country"));

+ deliveryTypeLabel = new QtElidingLabel(this);

+ deliveryTypeLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

+ getGridLayout()->addWidget(deliveryTypeLabel, getGridLayout()->rowCount()-3, 4, Qt::AlignVCenter);

+ domesticRadioButton = new QRadioButton(tr("Domestic Delivery"), this);

+ getGridLayout()->addWidget(domesticRadioButton, getGridLayout()->rowCount()-2, 4, Qt::AlignVCenter);

+ internationalRadioButton = new QRadioButton(tr("International Delivery"), this);

+ getGridLayout()->addWidget(internationalRadioButton, getGridLayout()->rowCount()-1, 4, Qt::AlignVCenter);

+ buttonGroup = new QButtonGroup(this);

+ buttonGroup->addButton(domesticRadioButton);

+ buttonGroup->addButton(internationalRadioButton);

+ setTabOrder(internationalRadioButton, getTagComboBox());

+ getTagComboBox()->addTag("postal", tr("Postal"));

+ getTagComboBox()->addTag("parcel", tr("Parcel"));

+ QtVCardHomeWork::setTagComboBox(getTagComboBox());

+ textFields << streetLineEdit << poboxLineEdit << addressextLineEdit << cityLineEdit << pocodeLineEdit << regionLineEdit << countryLineEdit;

+ childWidgets << deliveryTypeLabel << domesticRadioButton << internationalRadioButton;

+ foreach(QWidget* widget, textFields) {

+ widget->hide();

+ textFieldGridLayout->removeWidget(widget);

+ }

+ getGridLayout()->removeItem(textFieldGridLayoutItem);

+ return streetLineEdit->text().isEmpty() &&

+ poboxLineEdit->text().isEmpty() &&

+ addressextLineEdit->text().isEmpty() &&

+ cityLineEdit->text().isEmpty() &&

+ pocodeLineEdit->text().isEmpty() &&

+ regionLineEdit->text().isEmpty() &&

+ countryLineEdit->text().isEmpty();

+ setPreferred(address.isPreferred);

+ setHome(address.isHome);

+ setWork(address.isWork);

+ getTagComboBox()->setTag("postal", address.isPostal);

+ getTagComboBox()->setTag("parcel", address.isParcel);

+ domesticRadioButton->setChecked(address.deliveryType == VCard::DomesticDelivery);

+ internationalRadioButton->setChecked(address.deliveryType == VCard::InternationalDelivery);

+ streetLineEdit->setText(P2QSTRING(address.street));

+ poboxLineEdit->setText(P2QSTRING(address.poBox));

+ addressextLineEdit->setText(P2QSTRING(address.addressExtension));

+ cityLineEdit->setText(P2QSTRING(address.locality));

+ pocodeLineEdit->setText(P2QSTRING(address.postalCode));

+ regionLineEdit->setText(P2QSTRING(address.region));

+ countryLineEdit->setText(P2QSTRING(address.country));

+ VCard::Address address;

+ address.isPreferred = getPreferred();

+ address.isHome = getHome();

+ address.isWork = getWork();

+ address.deliveryType = domesticRadioButton->isChecked() ? VCard::DomesticDelivery : (internationalRadioButton->isChecked() ? VCard::InternationalDelivery : VCard::None);

+ address.isPostal = getTagComboBox()->isTagSet("postal");

+ address.isParcel = getTagComboBox()->isTagSet("parcel");

+ address.street = Q2PSTRING(streetLineEdit->text());

+ address.poBox = Q2PSTRING(poboxLineEdit->text());

+ address.addressExtension = Q2PSTRING(addressextLineEdit->text());

+ address.locality = Q2PSTRING(cityLineEdit->text());

+ address.postalCode = Q2PSTRING(pocodeLineEdit->text());

+ address.region = Q2PSTRING(regionLineEdit->text());

+ address.country = Q2PSTRING(countryLineEdit->text());

+ return address;

+ assert(streetLineEdit);

+ assert(poboxLineEdit);

+ assert(addressextLineEdit);

+ assert(cityLineEdit);

+ assert(pocodeLineEdit);

+ assert(regionLineEdit);

+ assert(countryLineEdit);

+ assert(deliveryTypeLabel);

+ assert(domesticRadioButton);

+ assert(internationalRadioButton);

+

+ streetLineEdit->setEditable(isEditable);

+ poboxLineEdit->setEditable(isEditable);

+ addressextLineEdit->setEditable(isEditable);

+ cityLineEdit->setEditable(isEditable);

+ pocodeLineEdit->setEditable(isEditable);

+ regionLineEdit->setEditable(isEditable);

+ countryLineEdit->setEditable(isEditable);

+

+ deliveryTypeLabel->setText(buttonGroup->checkedButton() == 0 ? "" : buttonGroup->checkedButton()->text());

+ deliveryTypeLabel->setVisible(!isEditable);

+

+ domesticRadioButton->setVisible(isEditable);

+ internationalRadioButton->setVisible(isEditable);

+

+ foreach (QWidget* widget, textFields) {

+ QtResizableLineEdit* lineEdit;

+ if ((lineEdit = dynamic_cast<QtResizableLineEdit*>(widget))) {

+ lineEdit->setVisible(isEditable ? true : !lineEdit->text().isEmpty());

+ lineEdit->setStyleSheet(isEditable ? "" : "QLineEdit { border: none; background: transparent; }");

+ }

+ }

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("Address"), UNLIMITED_INSTANCES, QtVCardAddressField)

+

+ QtVCardAddressField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardAddressField();

+

+ virtual bool isEmpty() const;

+

+ void setAddress(const VCard::Address& address);

+ VCard::Address getAddress() const;

+

+ protected:

+ virtual void setupContentWidgets();

+ virtual void customCleanup();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QList<QWidget*> textFields;

+ QtResizableLineEdit* streetLineEdit;

+ QtResizableLineEdit* poboxLineEdit;

+ QtResizableLineEdit* addressextLineEdit;

+ QtResizableLineEdit* cityLineEdit;

+ QtResizableLineEdit* pocodeLineEdit;

+ QtResizableLineEdit* regionLineEdit;

+ QtResizableLineEdit* countryLineEdit;

+ QGridLayout* textFieldGridLayout;

+ QLayoutItem* textFieldGridLayoutItem;

+

+ QtElidingLabel* deliveryTypeLabel;

+ QRadioButton* domesticRadioButton;

+ QRadioButton* internationalRadioButton;

+ QButtonGroup* buttonGroup;

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Address Label")), addressLabelPlainTextEdit(NULL), deliveryTypeLabel(NULL), domesticRadioButton(NULL), internationalRadioButton(NULL), buttonGroup(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+ addressLabelPlainTextEdit = new QPlainTextEdit(this);

+ addressLabelPlainTextEdit->setTabChangesFocus(true);

+ getGridLayout()->addWidget(addressLabelPlainTextEdit, getGridLayout()->rowCount()-1, 2, 3, 2, Qt::AlignVCenter);

+ deliveryTypeLabel = new QtElidingLabel(this);

+ deliveryTypeLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

+ getGridLayout()->addWidget(deliveryTypeLabel, getGridLayout()->rowCount()-2, 4, Qt::AlignVCenter);

+ domesticRadioButton = new QRadioButton(tr("Domestic Delivery"), this);

+ getGridLayout()->addWidget(domesticRadioButton, getGridLayout()->rowCount()-2, 4, Qt::AlignVCenter);

+ internationalRadioButton = new QRadioButton(tr("International Delivery"), this);

+ getGridLayout()->addWidget(internationalRadioButton, getGridLayout()->rowCount()-1, 4, Qt::AlignVCenter);

+ buttonGroup = new QButtonGroup(this);

+ buttonGroup->addButton(domesticRadioButton);

+ buttonGroup->addButton(internationalRadioButton);

+ setTabOrder(internationalRadioButton, getTagComboBox());

+ getTagComboBox()->addTag("postal", tr("Postal"));

+ getTagComboBox()->addTag("parcel", tr("Parcel"));

+ QtVCardHomeWork::setTagComboBox(getTagComboBox());

+ deliveryTypeLabel->hide();

+ childWidgets << addressLabelPlainTextEdit << deliveryTypeLabel << domesticRadioButton << internationalRadioButton;

+ return addressLabelPlainTextEdit->toPlainText().isEmpty();

+ setPreferred(addressLabel.isPreferred);

+ setHome(addressLabel.isHome);

+ setWork(addressLabel.isWork);

+ getTagComboBox()->setTag("postal", addressLabel.isPostal);

+ getTagComboBox()->setTag("parcel", addressLabel.isParcel);

+ domesticRadioButton->setChecked(addressLabel.deliveryType == VCard::DomesticDelivery);

+ internationalRadioButton->setChecked(addressLabel.deliveryType == VCard::InternationalDelivery);

+ std::string joinedLines = boost::algorithm::join(addressLabel.lines, "\n");

+ addressLabelPlainTextEdit->setPlainText(P2QSTRING(joinedLines));

+ VCard::AddressLabel addressLabel;

+ addressLabel.isPreferred = getPreferred();

+ addressLabel.isHome = getHome();

+ addressLabel.isWork = getWork();

+ addressLabel.deliveryType = domesticRadioButton->isChecked() ? VCard::DomesticDelivery : (internationalRadioButton->isChecked() ? VCard::InternationalDelivery : VCard::None);

+ addressLabel.isPostal = getTagComboBox()->isTagSet("postal");

+ addressLabel.isParcel = getTagComboBox()->isTagSet("parcel");

+

+ std::string lines = Q2PSTRING(addressLabelPlainTextEdit->toPlainText());

+ boost::split(addressLabel.lines, lines, boost::is_any_of("\n"));

+ return addressLabel;

+ assert(addressLabelPlainTextEdit);

+ assert(deliveryTypeLabel);

+ assert(domesticRadioButton);

+ assert(internationalRadioButton);

+ addressLabelPlainTextEdit->setReadOnly(!isEditable);

+ addressLabelPlainTextEdit->setStyleSheet(isEditable ? "" : "QPlainTextEdit { background: transparent; }");

+ deliveryTypeLabel->setText(buttonGroup->checkedButton() == 0 ? "" : buttonGroup->checkedButton()->text());

+ deliveryTypeLabel->setVisible(!isEditable);

+ domesticRadioButton->setVisible(isEditable);

+ internationalRadioButton->setVisible(isEditable);

+ Q_OBJECT

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("Address Label"), UNLIMITED_INSTANCES, QtVCardAddressLabelField)

+ QtVCardAddressLabelField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardAddressLabelField();

+ virtual bool isEmpty() const;

+ void setAddressLabel(const VCard::AddressLabel& addressLabel);

+ VCard::AddressLabel getAddressLabel() const;

+ protected:

+ virtual void setupContentWidgets();

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+ private:

+ QPlainTextEdit* addressLabelPlainTextEdit;

+ QtElidingLabel* deliveryTypeLabel;

+ QRadioButton* domesticRadioButton;

+ QRadioButton* internationalRadioButton;

+ QButtonGroup* buttonGroup;

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Birthday"), false, false), birthdayLabel(NULL), birthdayDateEdit(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+ birthdayLabel = new QLabel(this);

+ birthdayLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

+ birthdayDateEdit = new QDateEdit(this);

+ birthdayDateEdit->setCalendarPopup(true);

+ QHBoxLayout* birthdayLayout = new QHBoxLayout();

+ birthdayLayout->addWidget(birthdayLabel);

+ birthdayLayout->addWidget(birthdayDateEdit);

+ getGridLayout()->addLayout(birthdayLayout, getGridLayout()->rowCount()-1, 2, Qt::AlignVCenter);

+ getTagComboBox()->hide();

+ birthdayLabel->hide();

+ childWidgets << birthdayLabel << birthdayDateEdit;

+ return false;

+ birthdayDateEdit->setDate(B2QDATE(birthday).date());

+ return boost::posix_time::from_time_t(QDateTime(birthdayDateEdit->date()).toTime_t());

+ birthdayLabel->setText(birthdayDateEdit->date().toString(Qt::DefaultLocaleLongDate));

+ birthdayDateEdit->setVisible(isEditable);

+ birthdayLabel->setVisible(!isEditable);

+ Q_OBJECT

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("Birthday"), 1, QtVCardBirthdayField)

+ QtVCardBirthdayField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardBirthdayField();

+ virtual bool isEmpty() const;

+ void setBirthday(const boost::posix_time::ptime& addressLabel);

+ boost::posix_time::ptime getBirthday() const;

+ protected:

+ virtual void setupContentWidgets();

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+ private:

+ QLabel* birthdayLabel;

+ QDateEdit* birthdayDateEdit;

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Description"), false, false), descriptionPlainTextEdit(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+ descriptionPlainTextEdit = new QPlainTextEdit(this);

+ descriptionPlainTextEdit->setMinimumHeight(70);

+ getGridLayout()->addWidget(descriptionPlainTextEdit, getGridLayout()->rowCount()-1, 2, 2, 2, Qt::AlignVCenter);

+ getTagComboBox()->hide();

+ childWidgets << descriptionPlainTextEdit;

+ return descriptionPlainTextEdit->toPlainText().isEmpty();

+ descriptionPlainTextEdit->setPlainText(P2QSTRING(description));

+ return Q2PSTRING(descriptionPlainTextEdit->toPlainText());

+ assert(descriptionPlainTextEdit);

+ if (isEditable) {

+ descriptionPlainTextEdit->setMinimumHeight(70);

+ } else {

+ QFontMetrics inputMetrics(descriptionPlainTextEdit->document()->defaultFont());

+ QRect horizontalBounds = contentsRect().adjusted(0,0,0,9999);

+ QRect boundingRect = inputMetrics.boundingRect(horizontalBounds, Qt::TextWordWrap, descriptionPlainTextEdit->toPlainText() + "A");

+ int left, top, right, bottom;

+ getContentsMargins(&left, &top, &right, &bottom);

+ int height = boundingRect.height() + top + bottom + inputMetrics.height();

+ descriptionPlainTextEdit->setMinimumHeight(height > 70 ? 70 : height);

+ }

+ descriptionPlainTextEdit->setReadOnly(!isEditable);

+ descriptionPlainTextEdit->setStyleSheet(isEditable ? "" : "QPlainTextEdit { background: transparent; }");

+ Q_OBJECT

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("Description"), 1, QtVCardDescriptionField)

+ QtVCardDescriptionField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardDescriptionField();

+ virtual bool isEmpty() const;

+ void setDescription(const std::string& description);

+ std::string getDescription() const;

+ protected:

+ virtual void setupContentWidgets();

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+ private:

+ QPlainTextEdit* descriptionPlainTextEdit;

+ class FieldInfo : public QtVCardFieldInfo { \

+ public: \

+ virtual ~FieldInfo() { \

+ } \

+ \

+ virtual QString getMenuName() const { \

+ return MENU_NAME; \

+ } \

+ \

+ virtual int getAllowedInstances() const { \

+ return ALLOWED_INSTANCES; \

+ } \

+ \

+ virtual QWidget* createFieldInstance(QWidget* parent, QGridLayout* layout, bool editable) const { \

+ return new FIELD_CLASS(parent, layout, editable); \

+ } \

+ \

+ virtual bool testInstance(QWidget* widget) const { \

+ return dynamic_cast<FIELD_CLASS*>(widget) != 0; \

+ } \

+ };

+ class QtVCardFieldInfo {

+ public:

+ static const int UNLIMITED_INSTANCES = -1;

+

+ virtual ~QtVCardFieldInfo() {

+ }

+ virtual QString getMenuName() const = 0;

+ virtual int getAllowedInstances() const = 0;

+ virtual QWidget* createFieldInstance(QWidget* parent, QGridLayout* layout, bool editable) const = 0;

+ virtual bool testInstance(QWidget*) const = 0;

+ };

+ QWidget(parent), editable(editable), preferrable(preferrable), starVisible(false), taggable(taggable), layout(layout), row(row), preferredCheckBox(0), label(0), labelText(label),

+ tagComboBox(0), tagLabel(NULL), closeButton(0) {

+ if (preferrable) {

+ preferredCheckBox = new QCheckBox(this);

+ preferredCheckBox->setToolTip(tr("Stars can be used to mark preferred contact details."));

+ preferredCheckBox->setStyleSheet(

+ "QCheckBox::indicator { width: 18px; height: 18px; }"

+ "QCheckBox::indicator:checked { image: url(:/icons/star-checked.png); }"

+ "QCheckBox::indicator:unchecked { image: url(:/icons/star-unchecked.png); }"

+ );

+ layout->addWidget(preferredCheckBox, row, 0, Qt::AlignVCenter);

+ childWidgets << preferredCheckBox;

+ connect(preferredCheckBox, SIGNAL(stateChanged(int)), SLOT(handlePreferredStarStateChanged(int)));

+ }

+ label = new QLabel(this);

+ label->setText(labelText);

+ layout->addWidget(label, row, 1, Qt::AlignVCenter | Qt::AlignRight);

+

+ tagLabel = new QtElidingLabel(this);

+ tagLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

+

+ tagComboBox = new QtTagComboBox(this);

+ closeButton = new QtCloseButton(this);

+ connect(closeButton, SIGNAL(clicked()), SLOT(handleCloseButtonClicked()));

+

+ QHBoxLayout* tagLayout = new QHBoxLayout();

+ tagLayout->addWidget(tagLabel);

+ tagLayout->addWidget(tagComboBox);

+

+ setupContentWidgets();

+ layout->addLayout(tagLayout, row, 4, Qt::AlignTop);

+ layout->addWidget(closeButton, row, 5, Qt::AlignCenter);

+ closeButton->resize(12, 12);

+ tagLabel->hide();

+

+ childWidgets << label << tagComboBox << tagLabel << closeButton;

+ setEditable(editable);

+ return editable;

+ assert(tagComboBox);

+ assert(closeButton);

+

+ this->editable = editable;

+ if (taggable) {

+ tagLabel->setText(tagComboBox->itemText(0));

+ tagComboBox->setVisible(editable);

+ tagLabel->setVisible(!editable);

+ } else {

+ tagLabel->hide();

+ tagComboBox->hide();

+ }

+ closeButton->setVisible(editable);

+ updatePreferredStarVisibility();

+ editableChanged(this->editable);

+ starVisible = isVisible;

+ updatePreferredStarVisibility();

+ return starVisible;

+ if (preferredCheckBox) preferredCheckBox->setChecked(preferred);

+ updatePreferredStarVisibility();

+ return preferredCheckBox ? preferredCheckBox->isChecked() : false;

+ return tagComboBox;

+ return layout;

+ customCleanup();

+ foreach(QWidget* widget, childWidgets) {

+ widget->hide();

+ layout->removeWidget(widget);

+ }

+ deleteField(this);

+ if (state == Qt::Checked) {

+ QToolTip::showText(QCursor::pos(), tr("Marked as your preferred %1. Click again to undo.").arg(labelText));

+ }

+ if (preferredCheckBox) {

+ bool showStar = false;

+ if (editable) {

+ if (starVisible) {

+ showStar = true;

+ }

+ else {

+ showStar = preferredCheckBox->isChecked();

+ }

+ }

+ else {

+ showStar = preferredCheckBox->isChecked();

+ }

+ preferredCheckBox->setVisible(showStar);

+ preferredCheckBox->setEnabled(editable);

+ }

+ * covers features like:

+ * - preffered (star ceckbox)

+ * - combo check box

+ * - label

+ * - remove button

+ Q_OBJECT

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable NOTIFY editableChanged)

+ Q_PROPERTY(bool empty READ isEmpty)

+

+ public:

+ explicit QtVCardGeneralField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false, int row = 0, QString label = QString(),

+ bool preferrable = true, bool taggable = true);

+ virtual ~QtVCardGeneralField();

+

+ void initialize();

+

+ virtual bool isEditable() const;

+ virtual void setEditable(bool);

+

+ virtual bool isEmpty() const = 0;

+

+ void setStarVisible(const bool isVisible);

+ bool getStarVisible() const;

+

+ void setPreferred(const bool preferred);

+ bool getPreferred() const;

+

+ protected:

+ virtual void setupContentWidgets() = 0;

+ virtual void customCleanup();

+

+ QtTagComboBox* getTagComboBox() const;

+ QGridLayout* getGridLayout() const;

+

+ signals:

+ void editableChanged(bool);

+ void deleteField(QtVCardGeneralField*);

+

+ public slots:

+ void handleCloseButtonClicked();

+ void handlePreferredStarStateChanged(int statte);

+

+ protected:

+ QList<QWidget*> childWidgets;

+

+ private:

+ void updatePreferredStarVisibility();

+

+ private:

+ bool editable;

+ bool preferrable;

+ bool starVisible;

+ bool taggable;

+ QGridLayout* layout;

+ int row;

+ QCheckBox* preferredCheckBox;

+ QLabel* label;

+ QString labelText;

+ QtTagComboBox* tagComboBox;

+ QtElidingLabel* tagLabel;

+ QtCloseButton* closeButton;

+ tagComboBox = tagBox;

+ tagComboBox->addTag("home", QObject::tr("Home"));

+ tagComboBox->addTag("work", QObject::tr("Work"));

+ tagComboBox->setTag("home", home);

+ return tagComboBox->isTagSet("home");

+ tagComboBox->setTag("work", work);

+ return tagComboBox->isTagSet("work");

+ public:

+ QtVCardHomeWork();

+ virtual ~QtVCardHomeWork();

+ void setTagComboBox(QtTagComboBox* tagBox);

+ void setHome(const bool home);

+ bool getHome() const;

+ void setWork(const bool work);

+ bool getWork() const;

+ private:

+ QtTagComboBox* tagComboBox;

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("E-Mail")), emailLineEdit(NULL), emailLabel(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+ emailLabel = new QLabel(this);

+ emailLabel->setOpenExternalLinks(true);

+ emailLabel->setTextInteractionFlags(Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard);

+ emailLineEdit = new QtResizableLineEdit(this);

+ emailLineEdit->setPlaceholderText(tr("alice@wonderland.lit"));

+ QHBoxLayout* emailLayout = new QHBoxLayout();

+ emailLayout->addWidget(emailLabel);

+ emailLayout->addWidget(emailLineEdit);

+ getGridLayout()->addLayout(emailLayout, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ setTabOrder(emailLineEdit, getTagComboBox());

+ QtVCardHomeWork::setTagComboBox(getTagComboBox());

+ emailLabel->hide();

+ childWidgets << emailLabel << emailLineEdit;

+ return emailLineEdit->text().isEmpty();

+ assert(address.isInternet);

+ setPreferred(address.isPreferred);

+ setHome(address.isHome);

+ setWork(address.isWork);

+ emailLineEdit->setText(P2QSTRING(address.address));

+ VCard::EMailAddress address;

+ address.isInternet = true;

+ address.isPreferred = getPreferred();

+ address.isHome = getHome();

+ address.isWork = getWork();

+ address.address = Q2PSTRING(emailLineEdit->text());

+ return address;

+ assert(emailLineEdit);

+ assert(emailLabel);

+ if (isEditable) {

+ emailLineEdit->show();

+ emailLabel->hide();

+ } else {

+ emailLineEdit->hide();

+ emailLabel->setText(QString("<a href=\"mailto:%1\">%1</a>").arg(QtUtilities::htmlEscape(emailLineEdit->text())));

+ emailLabel->show();

+ }

+ Q_OBJECT

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("E-Mail"), UNLIMITED_INSTANCES, QtVCardInternetEMailField)

+ QtVCardInternetEMailField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardInternetEMailField();

+ virtual bool isEmpty() const;

+ void setInternetEMailAddress(const VCard::EMailAddress& address);

+ VCard::EMailAddress getInternetEMailAddress() const;

+ protected:

+ virtual void setupContentWidgets();

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+ private:

+ QtResizableLineEdit* emailLineEdit;

+ QLabel* emailLabel;

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("JID"), false, false), jidLabel(NULL), jidLineEdit(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+ jidLabel = new QLabel(this);

+ jidLabel->setOpenExternalLinks(true);

+ jidLabel->setTextInteractionFlags(Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard);

+ jidLineEdit = new QtResizableLineEdit(this);

+ jidLineEdit->setPlaceholderText(tr("alice@wonderland.lit"));

+ QHBoxLayout* jidLayout = new QHBoxLayout();

+ jidLayout->addWidget(jidLabel);

+ jidLayout->addWidget(jidLineEdit);

+ getGridLayout()->addLayout(jidLayout, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ jidLabel->hide();

+ getTagComboBox()->hide();

+ childWidgets << jidLabel << jidLineEdit;

+ return jidLineEdit->text().isEmpty();

+ std::string jidStr = jid.toBare().toString();

+ jidLineEdit->setText(P2QSTRING(jidStr));

+ return JID(Q2PSTRING(jidLineEdit->text()));

+ assert(jidLineEdit);

+ assert(jidLabel);

+

+ if (isEditable) {

+ jidLineEdit->show();

+ jidLabel->hide();

+ } else {

+ jidLineEdit->hide();

+ jidLabel->setText(QString("<a href=\"xmpp:%1\">%1</a>").arg(QtUtilities::htmlEscape(jidLineEdit->text())));

+ jidLabel->show();

+ }

+ Q_OBJECT

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("JID"), UNLIMITED_INSTANCES, QtVCardJIDField)

+ QtVCardJIDField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardJIDField();

+ virtual bool isEmpty() const;

+ void setJID(const JID& jid);

+ JID getJID() const;

+ protected:

+ virtual void setupContentWidgets();

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+ private:

+ QLabel* jidLabel;

+ QtResizableLineEdit* jidLineEdit;

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Organization"), false, false), organizationLabel(NULL), organizationLineEdit(NULL), unitsTreeWidget(NULL), itemDelegate(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+ organizationLabel = new QLabel(this);

+ organizationLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

+ organizationLineEdit = new QtResizableLineEdit(this);

+ QHBoxLayout* organizationLayout = new QHBoxLayout();

+ organizationLayout->addWidget(organizationLabel);

+ organizationLayout->addWidget(organizationLineEdit);

+ getGridLayout()->addLayout(organizationLayout, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ itemDelegate = new QtRemovableItemDelegate(style());

+ unitsTreeWidget = new QTreeWidget(this);

+ connect(unitsTreeWidget->model(), SIGNAL(rowsRemoved(QModelIndex, int, int)), SLOT(handleRowsRemoved(QModelIndex,int,int)));

+ unitsTreeWidget->setColumnCount(2);

+ unitsTreeWidget->header()->setStretchLastSection(false);

+ unitsTreeWidget->header()->resizeSection(1, itemDelegate->sizeHint(QStyleOptionViewItem(), QModelIndex()).width());

+ unitsTreeWidget->header()->setSectionResizeMode(0, QHeaderView::Stretch);

+ unitsTreeWidget->header()->setResizeMode(0, QHeaderView::Stretch);

+ unitsTreeWidget->setHeaderHidden(true);

+ unitsTreeWidget->setRootIsDecorated(false);

+ unitsTreeWidget->setEditTriggers(QAbstractItemView::DoubleClicked);

+ unitsTreeWidget->setItemDelegateForColumn(1, itemDelegate);

+ connect(unitsTreeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)), SLOT(handleItemChanged(QTreeWidgetItem*,int)));

+ getGridLayout()->addWidget(unitsTreeWidget, getGridLayout()->rowCount()-1, 4, 2, 1);

+ QTreeWidgetItem* item = new QTreeWidgetItem(QStringList("") << "");

+ item->setFlags(item->flags() | Qt::ItemIsEditable);

+ unitsTreeWidget->addTopLevelItem(item);

+ getTagComboBox()->hide();

+ organizationLabel->hide();

+ childWidgets << organizationLabel << organizationLineEdit << unitsTreeWidget;

+ return organizationLineEdit->text().isEmpty() && unitsTreeWidget->model()->rowCount() != 0;

+ organizationLineEdit->setText(P2QSTRING(organization.name));

+ unitsTreeWidget->clear();

+ foreach(std::string unit, organization.units) {

+ QTreeWidgetItem* item = new QTreeWidgetItem(QStringList(P2QSTRING(unit)) << "");

+ item->setFlags(item->flags() | Qt::ItemIsEditable);

+ unitsTreeWidget->addTopLevelItem(item);

+ }

+

+ QTreeWidgetItem* item = new QTreeWidgetItem(QStringList("") << "");

+ item->setFlags(item->flags() | Qt::ItemIsEditable);

+ unitsTreeWidget->addTopLevelItem(item);

+ VCard::Organization organization;

+ organization.name = Q2PSTRING(organizationLineEdit->text());

+ for(int i=0; i < unitsTreeWidget->topLevelItemCount(); ++i) {

+ QTreeWidgetItem* row = unitsTreeWidget->topLevelItem(i);

+ if (!row->text(0).isEmpty()) {

+ organization.units.push_back(Q2PSTRING(row->text(0)));

+ }

+ }

+

+ return organization;

+ assert(organizationLineEdit);

+ assert(unitsTreeWidget);

+

+ organizationLineEdit->setVisible(isEditable);

+ organizationLabel->setVisible(!isEditable);

+

+ if (!isEditable) {

+ QString label;

+ for(int i=0; i < unitsTreeWidget->topLevelItemCount(); ++i) {

+ QTreeWidgetItem* row = unitsTreeWidget->topLevelItem(i);

+ if (!row->text(0).isEmpty()) {

+ label += row->text(0) + ", ";

+ }

+ }

+ label += organizationLineEdit->text();

+ organizationLabel->setText(label);

+ }

+ unitsTreeWidget->setVisible(isEditable);

+ guaranteeEmptyRow();

+ guaranteeEmptyRow();

+ bool hasEmptyRow = false;

+ QList<QTreeWidgetItem*> rows = unitsTreeWidget->findItems("", Qt::MatchFixedString);

+ foreach(QTreeWidgetItem* row, rows) {

+ if (row->text(0).isEmpty()) {

+ hasEmptyRow = true;

+ }

+ }

+

+ if (!hasEmptyRow) {

+ QTreeWidgetItem* item = new QTreeWidgetItem(QStringList("") << "");

+ item->setFlags(item->flags() | Qt::ItemIsEditable);

+ unitsTreeWidget->addTopLevelItem(item);

+ unitsTreeWidget->setCurrentItem(item);

+ }

+ Q_OBJECT

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("Organization"), UNLIMITED_INSTANCES, QtVCardOrganizationField)

+ QtVCardOrganizationField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardOrganizationField();

+ virtual bool isEmpty() const;

+ void setOrganization(const VCard::Organization& organization);

+ VCard::Organization getOrganization() const;

+ protected:

+ virtual void setupContentWidgets();

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+ private slots:

+ void handleItemChanged(QTreeWidgetItem*, int);

+ void handleRowsRemoved(const QModelIndex&, int, int);

+ private:

+ void guaranteeEmptyRow();

+ private:

+ QLabel* organizationLabel;

+ QtResizableLineEdit* organizationLineEdit;

+ QTreeWidget* unitsTreeWidget;

+ QtRemovableItemDelegate* itemDelegate;

+ QWidget(parent),

+ ui(new Ui::QtVCardPhotoAndNameFields) {

+ ui->setupUi(this);

+ ui->lineEditPREFIX->hide();

+ ui->lineEditMIDDLE->hide();

+ ui->lineEditSUFFIX->hide();

+ ui->lineEditFN->hide();

+ ui->lineEditNICKNAME->hide();

+ ui->labelFN->hide();

+ ui->labelNICKNAME->hide();

+ ui->labelFULLNAME->hide();

+ ui->lineEditFN->setPlaceholderText(tr("Formatted Name"));

+ ui->lineEditNICKNAME->setPlaceholderText(tr("Nickname"));

+ ui->lineEditPREFIX->setPlaceholderText(tr("Prefix"));

+ ui->lineEditGIVEN->setPlaceholderText(tr("Given Name"));

+ ui->lineEditMIDDLE->setPlaceholderText(tr("Middle Name"));

+ ui->lineEditFAMILY->setPlaceholderText(tr("Last Name"));

+ ui->lineEditSUFFIX->setPlaceholderText(tr("Suffix"));

+ setEditable(false);

+ delete ui;

+ return editable;

+ this->editable = editable;

+ ui->avatarWidget->setEditable(editable);

+ ui->lineEditFN->setVisible(editable);

+ ui->labelFN->setVisible(!editable);

+ ui->lineEditNICKNAME->setVisible(editable);

+ ui->labelNICKNAME->setVisible(!editable);

+ // prefix given middle last suffix

+ ui->lineEditPREFIX->setVisible(editable);

+ ui->lineEditGIVEN->setVisible(editable);

+ ui->lineEditMIDDLE->setVisible(editable);

+ ui->lineEditFAMILY->setVisible(editable);

+ ui->lineEditSUFFIX->setVisible(editable);

+ ui->labelFULLNAME->setVisible(!editable);

+ QStringList fullname;

+ fullname << ui->lineEditPREFIX->text() << ui->lineEditGIVEN->text() << ui->lineEditMIDDLE->text();

+ fullname << ui->lineEditFAMILY->text() << ui->lineEditSUFFIX->text();

+ for (QStringList::iterator i = fullname.begin(); i != fullname.end(); i++) {

+ *i = i->trimmed();

+ }

+ ui->labelFULLNAME->setText((fullname.filter(QRegExp(".+"))).join(" "));

+ ui->avatarWidget->setAvatar(data, type);

+ return ui->avatarWidget->getAvatarData();

+ return ui->avatarWidget->getAvatarType();

+ ui->lineEditFN->setText(formattedName);

+ ui->labelFN->setText(formattedName);

+ return ui->lineEditFN->text();

+ ui->lineEditNICKNAME->setText(nickname);

+ ui->labelNICKNAME->setText(nickname);

+ return ui->lineEditNICKNAME->text();

+ ui->lineEditPREFIX->setText(prefix);

+ return ui->lineEditPREFIX->text();

+ ui->lineEditGIVEN->setText(givenName);

+ return ui->lineEditGIVEN->text();

+ ui->lineEditMIDDLE->setText(middleName);

+ return ui->lineEditMIDDLE->text();

+ ui->lineEditFAMILY->setText(familyName);

+ return ui->lineEditFAMILY->text();

+ ui->lineEditSUFFIX->setText(suffix);

+ return ui->lineEditSUFFIX->text();

+ class QtVCardPhotoAndNameFields;

+ class QtVCardPhotoAndNameFields : public QWidget {

+ Q_OBJECT

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+ public:

+ explicit QtVCardPhotoAndNameFields(QWidget* parent = 0);

+ ~QtVCardPhotoAndNameFields();

+ bool isEditable() const;

+ void setEditable(bool);

+ void setAvatar(const ByteArray& data, const std::string& type);

+ ByteArray getAvatarData() const;

+ std::string getAvatarType() const;

+ void setFormattedName(const QString& formattedName);

+ QString getFormattedName() const;

+ void setNickname(const QString& nickname);

+ QString getNickname() const;

+ void setPrefix(const QString& prefix);

+ QString getPrefix() const;

+ void setGivenName(const QString& givenName);

+ QString getGivenName() const;

+ void setMiddleName(const QString& middleName);

+ QString getMiddleName() const;

+ void setFamilyName(const QString& familyName);

+ QString getFamilyName() const;

+ void setSuffix(const QString& suffix);

+ QString getSuffix() const;

+ private:

+ Ui::QtVCardPhotoAndNameFields* ui;

+ bool editable;

+ };

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Role"), false, false), roleLineEdit(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ roleLineEdit = new QtResizableLineEdit(this);

+ getGridLayout()->addWidget(roleLineEdit, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ getTagComboBox()->hide();

+ childWidgets << roleLineEdit;

+ return roleLineEdit->text().isEmpty();

+ roleLineEdit->setText(P2QSTRING(role));

+ return Q2PSTRING(roleLineEdit->text());

+ assert(roleLineEdit);

+ roleLineEdit->setEditable(isEditable);

+ roleLineEdit->setStyleSheet(isEditable ? "" : "QLineEdit { border: none; background: transparent; }");

+ Q_OBJECT

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("Role"), UNLIMITED_INSTANCES, QtVCardRoleField)

+ QtVCardRoleField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardRoleField();

+ virtual bool isEmpty() const;

+ void setRole(const std::string& role);

+ std::string getRole() const;

+ protected:

+ virtual void setupContentWidgets();

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+ private:

+ QtResizableLineEdit* roleLineEdit;

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Telephone")), telephoneLineEdit(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+ telephoneLineEdit = new QtResizableLineEdit(this);

+ telephoneLineEdit->setPlaceholderText(tr("0118 999 881 999 119 7253"));

+ getGridLayout()->addWidget(telephoneLineEdit, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ setTabOrder(telephoneLineEdit, getTagComboBox());

+ QtVCardHomeWork::setTagComboBox(getTagComboBox());

+

+ getTagComboBox()->addTag("voice", QObject::tr("Voice"));

+ getTagComboBox()->addTag("fax", QObject::tr("Fax"));

+ getTagComboBox()->addTag("pager", QObject::tr("Pager"));

+ getTagComboBox()->addTag("msg", QObject::tr("Voice Messaging"));

+ getTagComboBox()->addTag("cell", QObject::tr("Cell"));

+ getTagComboBox()->addTag("video", QObject::tr("Video"));

+ getTagComboBox()->addTag("bbs", QObject::tr("Bulletin Board System"));

+ getTagComboBox()->addTag("modem", QObject::tr("Modem"));

+ getTagComboBox()->addTag("isdn", QObject::tr("ISDN"));

+ getTagComboBox()->addTag("pcs", QObject::tr("Personal Communication Services"));

+

+ childWidgets << telephoneLineEdit;

+ return telephoneLineEdit->text().isEmpty();

+ setPreferred(telephone.isPreferred);

+ setHome(telephone.isHome);

+ setWork(telephone.isWork);

+

+ telephoneLineEdit->setText(P2QSTRING(telephone.number));

+

+ getTagComboBox()->setTag("voice", telephone.isVoice);

+ getTagComboBox()->setTag("fax", telephone.isFax);

+ getTagComboBox()->setTag("pager", telephone.isPager);

+ getTagComboBox()->setTag("msg", telephone.isMSG);

+ getTagComboBox()->setTag("cell", telephone.isCell);

+ getTagComboBox()->setTag("video", telephone.isVideo);

+ getTagComboBox()->setTag("bbs", telephone.isBBS);

+ getTagComboBox()->setTag("modem", telephone.isModem);

+ getTagComboBox()->setTag("isdn", telephone.isISDN);

+ getTagComboBox()->setTag("pcs", telephone.isPCS);

+ VCard::Telephone telephone;

+

+ telephone.number = Q2PSTRING(telephoneLineEdit->text());

+

+ telephone.isPreferred = getPreferred();

+ telephone.isHome = getHome();

+ telephone.isWork = getWork();

+

+ telephone.isVoice = getTagComboBox()->isTagSet("voice");

+ telephone.isFax = getTagComboBox()->isTagSet("fax");

+ telephone.isPager = getTagComboBox()->isTagSet("pager");

+ telephone.isMSG = getTagComboBox()->isTagSet("msg");

+ telephone.isCell = getTagComboBox()->isTagSet("cell");

+ telephone.isVideo = getTagComboBox()->isTagSet("video");

+ telephone.isBBS = getTagComboBox()->isTagSet("bbs");

+ telephone.isModem = getTagComboBox()->isTagSet("modem");

+ telephone.isISDN = getTagComboBox()->isTagSet("isdn");

+ telephone.isPCS = getTagComboBox()->isTagSet("pcs");

+

+ return telephone;

+ assert(telephoneLineEdit);

+ telephoneLineEdit->setEditable(isEditable);

+ telephoneLineEdit->setStyleSheet(isEditable ? "" : "QLineEdit { border: none; background: transparent; }");

+ Q_OBJECT

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("Telephone"), UNLIMITED_INSTANCES, QtVCardTelephoneField)

+ QtVCardTelephoneField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardTelephoneField();

+ virtual bool isEmpty() const;

+ void setTelephone(const VCard::Telephone& telephone);

+ VCard::Telephone getTelephone() const;

+ protected:

+ virtual void setupContentWidgets();

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+ private:

+ QtResizableLineEdit* telephoneLineEdit;

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Title"), false, false), titleLineEdit(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+ titleLineEdit = new QtResizableLineEdit(this);

+ getGridLayout()->addWidget(titleLineEdit, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ getTagComboBox()->hide();

+ childWidgets << titleLineEdit;

+ return titleLineEdit->text().isEmpty();

+ titleLineEdit->setText(P2QSTRING(title));

+ return Q2PSTRING(titleLineEdit->text());

+ assert(titleLineEdit);

+ titleLineEdit->setEditable(isEditable);

+ titleLineEdit->setStyleSheet(isEditable ? "" : "QLineEdit { border: none; background: transparent; }");

+ Q_OBJECT

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("Title"), UNLIMITED_INSTANCES, QtVCardTitleField)

+ QtVCardTitleField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardTitleField();

+ virtual bool isEmpty() const;

+ void setTitle(const std::string& title);

+ std::string getTitle() const;

+ protected:

+ virtual void setupContentWidgets();

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+ private:

+ QtResizableLineEdit* titleLineEdit;

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("URL"), false, false), urlLabel(NULL), urlLineEdit(NULL) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+ urlLabel = new QLabel(this);

+ urlLabel->setOpenExternalLinks(true);

+ urlLabel->setTextInteractionFlags(Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard);

+ urlLineEdit = new QtResizableLineEdit(this);

+

+ QHBoxLayout* urlLayout = new QHBoxLayout();

+ urlLayout->addWidget(urlLabel);

+ urlLayout->addWidget(urlLineEdit);

+

+ getGridLayout()->addLayout(urlLayout, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ getTagComboBox()->hide();

+ urlLabel->hide();

+ childWidgets << urlLabel << urlLineEdit;

+ return urlLineEdit->text().isEmpty();

+ urlLineEdit->setText(P2QSTRING(url));

+ return Q2PSTRING(urlLineEdit->text());

+ assert(urlLineEdit);

+ assert(urlLabel);

+

+ if (isEditable) {

+ urlLineEdit->show();

+ urlLabel->hide();

+ } else {

+ urlLineEdit->hide();

+ urlLabel->setText(QString("<a href=\"%1\">%1</a>").arg(QtUtilities::htmlEscape(urlLineEdit->text())));

+ urlLabel->show();

+ }

+ Q_OBJECT

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO(tr("URL"), UNLIMITED_INSTANCES, QtVCardURLField)

+ QtVCardURLField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardURLField();

+ virtual bool isEmpty() const;

+ void setURL(const std::string& url);

+ std::string getURL() const;

+ protected:

+ virtual void setupContentWidgets();

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+ private:

+ QLabel* urlLabel;

+ QtResizableLineEdit* urlLineEdit;

+ QWidget(parent),

+ ui(new ::Ui::QtVCardWidget) {

+ ui->setupUi(this);

+

+ ui->cardFields->setColumnStretch(0,0);

+ ui->cardFields->setColumnStretch(1,0);

+ ui->cardFields->setColumnStretch(2,2);

+ ui->cardFields->setColumnStretch(3,1);

+ ui->cardFields->setColumnStretch(4,2);

+ menu = new QMenu(this);

+

+ toolButton = new QToolButton(this);

+ toolButton->setText(tr("Add Field"));

+ toolButton->setArrowType(Qt::NoArrow);

+ toolButton->setAutoRaise(false);

+ toolButton->setPopupMode(QToolButton::InstantPopup);

+ toolButton->hide();

+ toolButton->setMenu(menu);

+

+ addFieldType(menu, boost::make_shared<QtVCardInternetEMailField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardTelephoneField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardAddressField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardAddressLabelField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardBirthdayField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardJIDField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardDescriptionField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardRoleField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardTitleField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardOrganizationField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardURLField::FieldInfo>());

+

+ setEditable(false);

+ setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);

+ delete ui;

+ QSize newSizeHint = ui->photoAndName->sizeHint();

+ // use mininmal size that does not require scrolling

+ QSize fieldsWidgetSize = ui->scrollArea->widget()->minimumSize();

+ fieldsWidgetSize.setWidth(ui->scrollArea->widget()->sizeHint().width());

+ newSizeHint += QSize(0, ui->line->height());

+ newSizeHint = QSize(std::max(newSizeHint.width(), fieldsWidgetSize.width()), newSizeHint.height() + fieldsWidgetSize.height());

+ // add layout margin

+ newSizeHint += QSize(layout()->contentsMargins().left() + layout()->contentsMargins().right(), layout()->contentsMargins().top() + layout()->contentsMargins().bottom());

+ // the spaceing before and after the line between the profile header and its fields

+ newSizeHint += QSize(0, layout()->spacing() * 2);

+ return newSizeHint;

+ return editable;

+ this->editable = editable;

+ ui->photoAndName->setProperty("editable", QVariant(editable));

+ foreach(QtVCardGeneralField* field, fields) {

+ field->setEditable(editable);

+ }

+ toolButton->setVisible(editable);

+ editableChanged(editable);

+ clearFields();

+ this->vcard = boost::make_shared<VCard>(*vcard);

+ ui->photoAndName->setFormattedName(P2QSTRING(vcard->getFullName()));

+ ui->photoAndName->setNickname(P2QSTRING(vcard->getNickname()));

+ ui->photoAndName->setPrefix(P2QSTRING(vcard->getPrefix()));

+ ui->photoAndName->setGivenName(P2QSTRING(vcard->getGivenName()));

+ ui->photoAndName->setMiddleName(P2QSTRING(vcard->getMiddleName()));

+ ui->photoAndName->setFamilyName(P2QSTRING(vcard->getFamilyName()));

+ ui->photoAndName->setSuffix(P2QSTRING(vcard->getSuffix()));

+ ui->photoAndName->setAvatar(vcard->getPhoto(), vcard->getPhotoType());

+

+ foreach (const VCard::EMailAddress& address, vcard->getEMailAddresses()) {

+ if (address.isInternet) {

+ QtVCardInternetEMailField* internetEmailField = new QtVCardInternetEMailField(this, ui->cardFields);

+ internetEmailField->initialize();

+ internetEmailField->setInternetEMailAddress(address);

+ appendField(internetEmailField);

+ }

+ }

+

+ foreach (const VCard::Telephone& telephone, vcard->getTelephones()) {

+ QtVCardTelephoneField* telField = new QtVCardTelephoneField(this, ui->cardFields);

+ telField->initialize();

+ telField->setTelephone(telephone);

+ appendField(telField);

+ }

+

+ foreach (const VCard::Address& address, vcard->getAddresses()) {

+ QtVCardAddressField* addressField = new QtVCardAddressField(this, ui->cardFields);

+ addressField->initialize();

+ addressField->setAddress(address);

+ appendField(addressField);

+ }

+

+ foreach (const VCard::AddressLabel& label, vcard->getAddressLabels()) {

+ QtVCardAddressLabelField* addressLabelField = new QtVCardAddressLabelField(this, ui->cardFields);

+ addressLabelField->initialize();

+ addressLabelField->setAddressLabel(label);

+ appendField(addressLabelField);

+ }

+

+ if (!vcard->getBirthday().is_not_a_date_time()) {

+ QtVCardBirthdayField* bdayField = new QtVCardBirthdayField(this, ui->cardFields);

+ bdayField->initialize();

+ bdayField->setBirthday(vcard->getBirthday());

+ appendField(bdayField);

+ }

+

+ foreach (const JID& jid, vcard->getJIDs()) {

+ QtVCardJIDField* jidField = new QtVCardJIDField(this, ui->cardFields);

+ jidField->initialize();

+ jidField->setJID(jid);

+ appendField(jidField);

+ }

+

+ if (!vcard->getDescription().empty()) {

+ QtVCardDescriptionField* descField = new QtVCardDescriptionField(this, ui->cardFields);

+ descField->initialize();

+ descField->setDescription(vcard->getDescription());

+ appendField(descField);

+ }

+

+ foreach (const VCard::Organization& org, vcard->getOrganizations()) {

+ QtVCardOrganizationField* orgField = new QtVCardOrganizationField(this, ui->cardFields);

+ orgField->initialize();

+ orgField->setOrganization(org);

+ appendField(orgField);

+ }

+

+ foreach (const std::string& role, vcard->getRoles()) {

+ QtVCardRoleField* roleField = new QtVCardRoleField(this, ui->cardFields);

+ roleField->initialize();

+ roleField->setRole(role);

+ appendField(roleField);

+ }

+

+ foreach (const std::string& title, vcard->getTitles()) {

+ QtVCardTitleField* titleField = new QtVCardTitleField(this, ui->cardFields);

+ titleField->initialize();

+ titleField->setTitle(title);

+ appendField(titleField);

+ }

+

+ foreach (const std::string& url, vcard->getURLs()) {

+ QtVCardURLField* urlField = new QtVCardURLField(this, ui->cardFields);

+ urlField->initialize();

+ urlField->setURL(url);

+ appendField(urlField);

+ }

+

+ relayoutToolButton();

+ setEditable(editable);

+ clearEmptyFields();

+ vcard->setFullName(Q2PSTRING(ui->photoAndName->getFormattedName()));

+ vcard->setNickname(Q2PSTRING(ui->photoAndName->getNickname()));

+ vcard->setPrefix(Q2PSTRING(ui->photoAndName->getPrefix()));

+ vcard->setGivenName(Q2PSTRING(ui->photoAndName->getGivenName()));

+ vcard->setMiddleName(Q2PSTRING(ui->photoAndName->getMiddleName()));

+ vcard->setFamilyName(Q2PSTRING(ui->photoAndName->getFamilyName()));

+ vcard->setSuffix(Q2PSTRING(ui->photoAndName->getSuffix()));

+ vcard->setPhoto(ui->photoAndName->getAvatarData());

+ vcard->setPhotoType(ui->photoAndName->getAvatarType());

+

+ vcard->clearEMailAddresses();

+ vcard->clearJIDs();

+ vcard->clearURLs();

+ vcard->clearTelephones();

+ vcard->clearRoles();

+ vcard->clearTitles();

+ vcard->clearOrganizations();

+ vcard->clearAddresses();

+ vcard->clearAddressLabels();

+

+

+ QtVCardBirthdayField* bdayField = NULL;

+ QtVCardDescriptionField* descriptionField = NULL;

+

+ foreach(QtVCardGeneralField* field, fields) {

+ QtVCardInternetEMailField* emailField;

+ if ((emailField = dynamic_cast<QtVCardInternetEMailField*>(field))) {

+ vcard->addEMailAddress(emailField->getInternetEMailAddress());

+ continue;

+ }

+

+ QtVCardTelephoneField* telephoneField;

+ if ((telephoneField = dynamic_cast<QtVCardTelephoneField*>(field))) {

+ vcard->addTelephone(telephoneField->getTelephone());

+ continue;

+ }

+

+ QtVCardAddressField* addressField;

+ if ((addressField = dynamic_cast<QtVCardAddressField*>(field))) {

+ vcard->addAddress(addressField->getAddress());

+ continue;

+ }

+

+ QtVCardAddressLabelField* addressLabelField;

+ if ((addressLabelField = dynamic_cast<QtVCardAddressLabelField*>(field))) {

+ vcard->addAddressLabel(addressLabelField->getAddressLabel());

+ continue;

+ }

+

+ if ((bdayField = dynamic_cast<QtVCardBirthdayField*>(field))) {

+ continue;

+ }

+

+ QtVCardJIDField* jidField;

+ if ((jidField = dynamic_cast<QtVCardJIDField*>(field))) {

+ vcard->addJID(jidField->getJID());

+ continue;

+ }

+

+ if ((descriptionField = dynamic_cast<QtVCardDescriptionField*>(field))) {

+ continue;

+ }

+

+ QtVCardOrganizationField* orgField;

+ if ((orgField = dynamic_cast<QtVCardOrganizationField*>(field))) {

+ vcard->addOrganization(orgField->getOrganization());

+ continue;

+ }

+

+ QtVCardRoleField* roleField;

+ if ((roleField = dynamic_cast<QtVCardRoleField*>(field))) {

+ vcard->addRole(roleField->getRole());

+ continue;

+ }

+

+ QtVCardTitleField* titleField;

+ if ((titleField = dynamic_cast<QtVCardTitleField*>(field))) {

+ vcard->addTitle(titleField->getTitle());

+ continue;

+ }

+

+ QtVCardURLField* urlField;

+ if ((urlField = dynamic_cast<QtVCardURLField*>(field))) {

+ vcard->addURL(urlField->getURL());

+ continue;

+ }

+ }

+

+ if (bdayField) {

+ vcard->setBirthday(bdayField->getBirthday());

+ } else {

+ vcard->setBirthday(boost::posix_time::ptime());

+ }

+

+ if (descriptionField) {

+ vcard->setDescription(descriptionField->getDescription());

+ } else {

+ vcard->setDescription("");

+ }

+

+ return vcard;

+ QAction* action = NULL;

+ if ((action = dynamic_cast<QAction*>(sender()))) {

+ boost::shared_ptr<QtVCardFieldInfo> fieldInfo = actionFieldInfo[action];

+ QWidget* newField = fieldInfo->createFieldInstance(this, ui->cardFields, true);

+ QtVCardGeneralField* newGeneralField = dynamic_cast<QtVCardGeneralField*>(newField);

+ if (newGeneralField) {

+ newGeneralField->initialize();

+ }

+ appendField(newGeneralField);

+ relayoutToolButton();

+ }

+ int sameFields = 0;

+ QtVCardGeneralField* fieldToChange = NULL;

+ foreach (QtVCardGeneralField* vcardField, fields) {

+ if ((vcardField != field) && (typeid(*vcardField) == typeid(*field))) {

+ sameFields++;

+ fieldToChange = vcardField;

+ }

+ }

+

+ if ((sameFields == 1) && fieldToChange) {

+ fieldToChange->setStarVisible(false);

+ }

+

+ fields.remove(field);

+ delete field;

+ if (!fieldType->getMenuName().isEmpty()) {

+ QAction* action = new QAction(tr("Add %1").arg(fieldType->getMenuName()), this);

+ actionFieldInfo[action] = fieldType;

+ connect(action, SIGNAL(triggered()), this, SLOT(addField()));

+ menu->addAction(action);

+ }

+ int instances = 0;

+ for (int n = 0; n < ui->cardFields->count(); n++) {

+ if (fieldType->testInstance(ui->cardFields->itemAt(n)->widget())) instances++;

+ }

+ return instances;

+ while(layout->count() > 0) {

+ QLayoutItem* child;

+ if ((child = layout->takeAt(0)) != 0) {

+ if (child->layout()) {

+ layoutDeleteChildren(child->layout());

+ }

+ if (dynamic_cast<QToolButton*>(child->widget())) {

+ delete child;

+ break;

+ }

+ delete child->widget();

+ delete child;

+ }

+ }

+ foreach(QtVCardGeneralField* field, fields) {

+ delete field;

+ }

+ fields.clear();

+ assert(ui->cardFields->count() >= 0);

+ layoutDeleteChildren(ui->cardFields);

+ std::vector<QtVCardGeneralField*> items_to_remove;

+ foreach (QtVCardGeneralField* field, fields) {

+ if (field->property("empty").isValid() && field->property("empty").toBool()) {

+ ui->cardFields->removeWidget(field);

+ items_to_remove.push_back(field);

+ delete field;

+ }

+ }

+

+ foreach(QtVCardGeneralField* field, items_to_remove) {

+ fields.remove(field);

+ }

+ connect(field, SIGNAL(deleteField(QtVCardGeneralField*)), SLOT(removeField(QtVCardGeneralField*)));

+

+ QtVCardGeneralField* fieldToChange = NULL;

+ foreach (QtVCardGeneralField* vcardField, fields) {

+ if (typeid(*vcardField) == typeid(*field)) {

+ fieldToChange = vcardField;

+ break;

+ }

+ }

+

+ if (fieldToChange) {

+ fieldToChange->setStarVisible(true);

+ field->setStarVisible(true);

+ }

+

+ fields.push_back(field);

+ ui->cardFields->addWidget(toolButton, ui->cardFields->rowCount(), ui->cardFields->columnCount()-2, 1, 1, Qt::AlignRight);

+ class QtVCardWidget;

+ class QtVCardWidget : public QWidget {

+ Q_OBJECT

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+

+ public :

+ explicit QtVCardWidget(QWidget* parent = 0);

+ ~QtVCardWidget();

+

+ bool isEditable() const;

+ void setEditable(bool);

+

+ void setVCard(VCard::ref vcard);

+ VCard::ref getVCard();

+

+ virtual QSize sizeHint() const;

+

+ signals:

+ void editableChanged(bool editable);

+

+ private slots:

+ void addField();

+ void removeField(QtVCardGeneralField* field);

+

+ private:

+ void addFieldType(QMenu*, boost::shared_ptr<QtVCardFieldInfo>);

+ int fieldTypeInstances(boost::shared_ptr<QtVCardFieldInfo>);

+ void clearFields();

+ void clearEmptyFields();

+ void appendField(QtVCardGeneralField* field);

+ void relayoutToolButton();

+

+ private:

+ VCard::ref vcard;

+ Ui::QtVCardWidget* ui;

+ QToolButton* toolButton;

+ bool editable;

+ QMenu* menu;

+ std::list<QtVCardGeneralField*> fields;

+ std::map<QAction*, boost::shared_ptr<QtVCardFieldInfo> > actionFieldInfo;

+ };