Replaced field pointers with references wherever possible.
Change-Id: I6c732068c67915c98ecf3510bbfcad1da37fdbf1
Signed-off-by: Eugene Kurzberg <i.kurtsberg@samsung.com>
* @brief Create control
* @param[in] object Contact compound object
*/
- ContactCompoundObjectControl(Model::ContactCompoundObject *object);
+ ContactCompoundObjectControl(Model::ContactCompoundObject &object);
private:
virtual void onCreated() override;
void onUnfocused(Evas_Object *entry, void *eventInfo);
- Model::ContactCompoundObject *m_Object;
+ Model::ContactCompoundObject &m_Object;
};
}
}
* @brief Create control
* @param[in] field Contact date field to edit
*/
- ContactDateFieldControl(Model::ContactDateField *field);
+ ContactDateFieldControl(Model::ContactDateField &field);
private:
virtual Evas_Object *onCreate(Evas_Object *parent) override;
void setButtonDate(tm date);
void onButtonPressed(Evas_Object *button, void *eventInfo);
- Model::ContactDateField *m_Field;
+ Model::ContactDateField &m_Field;
Evas_Object *m_Button;
};
}
*
*/
-#ifndef CONTACTS_INPUT_CONTACT_OBJECT_ITEM_H
-#define CONTACTS_INPUT_CONTACT_OBJECT_ITEM_H
+#ifndef CONTACTS_INPUT_CONTACT_FIELD_ITEM_H
+#define CONTACTS_INPUT_CONTACT_FIELD_ITEM_H
-#include "Contacts/Model/ContactField.h"
#include "Contacts/Input/ContactFieldSubItem.h"
#include "Ui/GenlistGroupItem.h"
#include <functional>
* @param[in] Genlist item to be removed
* @param[in] Field to be removed
*/
- typedef std::function<void(ContactFieldItem *, Model::ContactFieldPtr)> RemoveCallback;
+ typedef std::function<void(ContactFieldItem *)> RemoveCallback;
/**
* @brief Create genlist item representing ContactObject.
* @param[in] object Contact field of TypeObject type
*/
- ContactFieldItem(Model::ContactFieldPtr object);
+ ContactFieldItem(Model::ContactObject &object);
/**
* @brief Set remove field callback.
private:
void onRemovePressed(Evas_Object *button, void *eventInfo);
- Model::ContactFieldPtr m_Object;
+ Model::ContactObject &m_Object;
RemoveCallback m_OnRemove;
};
}
}
-#endif /* CONTACTS_INPUT_CONTACT_OBJECT_ITEM_H */
+#endif /* CONTACTS_INPUT_CONTACT_FIELD_ITEM_H */
*
*/
-#ifndef CONTACTS_INPUT_CONTACT_FIELD_ITEM_H
-#define CONTACTS_INPUT_CONTACT_FIELD_ITEM_H
+#ifndef CONTACTS_INPUT_CONTACT_FIELD_SUB_ITEM_H
+#define CONTACTS_INPUT_CONTACT_FIELD_SUB_ITEM_H
-#include "Contacts/Model/ContactField.h"
#include "Ui/GenlistItem.h"
namespace Contacts
{
+ namespace Model
+ {
+ class ContactField;
+ }
+
namespace Input
{
/**
* @brief Create field genlist item.
* @param[in] field Contact field of TypeText or TypeDate type
*/
- ContactFieldSubItem(Model::ContactFieldPtr field);
+ ContactFieldSubItem(Model::ContactField &field);
/**
* @return ContactField associated with the item.
void onEntryFocused(Evas_Object *entry, void *eventInfo);
void onEntryActivated(Evas_Object *entry, void *eventInfo);
- Model::ContactFieldPtr m_Field;
+ Model::ContactField &m_Field;
Ui::GenlistItem *m_NextFocusItem;
};
}
}
-#endif /* CONTACTS_INPUT_CONTACT_FIELD_ITEM_H */
+#endif /* CONTACTS_INPUT_CONTACT_FIELD_SUB_ITEM_H */
* @brief Create control
* @param[in] field Contact image path field
*/
- ContactImageFieldControl(Model::ContactTextField *field);
+ ContactImageFieldControl(Model::ContactTextField &field);
private:
virtual void onCreated() override;
app_control_result_e result);
void onImagePressed(Evas_Object *image, void *eventInfo);
- Model::ContactTextField *m_Field;
+ Model::ContactTextField &m_Field;
App::AppControl m_AppControl;
};
}
* @param[in] typeField Object's "type" field
* @param[in] labelField Object's custom type label field
*/
- ContactObjectTypeControl(Model::ContactEnumField *typeField,
- Model::ContactTextField *labelField);
+ ContactObjectTypeControl(Model::ContactEnumField &typeField,
+ Model::ContactTextField &labelField);
private:
virtual void onCreated() override;
bool onSelected(int value);
- Model::ContactEnumField *m_TypeField;
- Model::ContactTextField *m_LabelField;
+ Model::ContactEnumField &m_TypeField;
+ Model::ContactTextField &m_LabelField;
};
}
}
* @brief Create control
* @param[in] field Contact text field to edit
*/
- ContactTextFieldControl(Model::ContactTextField *field);
+ ContactTextFieldControl(Model::ContactTextField &field);
private:
virtual void onCreated() override;
void onUnfocused(Evas_Object *entry, void *eventInfo);
- Model::ContactTextField *m_Field;
+ Model::ContactTextField &m_Field;
};
}
}
*
*/
-#ifndef CONTACTS_INPUT_CONTACT_TYPED_OBJECT_ITEM_H
-#define CONTACTS_INPUT_CONTACT_TYPED_OBJECT_ITEM_H
+#ifndef CONTACTS_INPUT_CONTACT_TYPED_FIELD_ITEM_H
+#define CONTACTS_INPUT_CONTACT_TYPED_FIELD_ITEM_H
#include "Contacts/Input/ContactFieldItem.h"
namespace Model
{
class ContactTypedObject;
+ class ContactEnumField;
+ class ContactTextField;
}
namespace Input
{
public:
/**
- * @see ContactObjectItem::ContactObjectItem()
+ * @see ContactFieldItem::ContactFieldItem()
*/
- ContactTypedFieldItem(Model::ContactFieldPtr object);
+ ContactTypedFieldItem(Model::ContactObject &object);
protected:
/**
*/
virtual Eina_Bool getState(Evas_Object *parent, const char *part) override;
- Model::ContactFieldPtr m_TypeField;
- Model::ContactFieldPtr m_LabelField;
+ private:
+ Model::ContactEnumField &m_TypeField;
+ Model::ContactTextField &m_LabelField;
};
}
}
-#endif /* CONTACTS_INPUT_CONTACT_TYPED_OBJECT_ITEM_H */
+#endif /* CONTACTS_INPUT_CONTACT_TYPED_FIELD_ITEM_H */
virtual void onCreated() override;
virtual void onPageAttached() override;
- ContactFieldItem *createFieldItem(Model::ContactFieldPtr field);
+ ContactFieldItem *createFieldItem(Model::ContactObject &field);
Ui::GenlistItem *getNextFieldItem(Model::ContactFieldId fieldId);
- Model::ContactFieldPtr addField(Model::ContactFieldId fieldId);
- void removeField(Model::ContactFieldPtr field);
+ Model::ContactObject &addField(Model::ContactFieldId fieldId);
+ void removeField(Model::ContactObject &field);
- ContactFieldItem *addFieldItem(Model::ContactFieldPtr field);
- void removeFieldItem(ContactFieldItem *item, Model::ContactFieldId fieldId);
+ ContactFieldItem *addFieldItem(Model::ContactObject &field);
+ void removeFieldItem(ContactFieldItem *item);
void onAddField(Model::ContactFieldId fieldId);
- void onRemoveField(ContactFieldItem *item, Model::ContactFieldPtr field);
+ void onRemoveField(ContactFieldItem *item);
void onDonePressed(Evas_Object *button, void *eventInfo);
void onCancelPressed(Evas_Object *button, void *eventInfo);
Contact(const Contact &that) = delete;
virtual ~Contact() override;
-
/**
* @brief Initialize contact object.
* @param[in] id Database record ID or 0 to create new contact
* limitations under the License.
*
*/
+
#ifndef CONTACTS_MODEL_CONTACT_ARRAY_H
#define CONTACTS_MODEL_CONTACT_ARRAY_H
public:
using ContactField::ContactField;
+ /**
+ * @see ContactField::initialize()
+ */
+ virtual void initialize() override;
+
/**
* @see ContactField::isEmpty()
*/
* @param[in] index Child field index
* @return Child field.
*/
- ContactFieldPtr getField(unsigned index) const;
+ ContactField *getField(unsigned index) const;
/**
* @brief Add new child field.
* @return New child field.
*/
- ContactFieldPtr addField();
+ ContactField &addField();
/**
* @brief Remove child field and destroy the object.
* @param[in] childField Child field.
*/
- void removeField(ContactFieldPtr field);
+ void removeField(ContactField &field);
private:
const ContactArrayMetadata &getArrayMetadata() const;
+
+ ContactFields m_Fields;
};
}
}
* limitations under the License.
*
*/
+
#ifndef CONTACTS_MODEL_CONTACT_FIELD_FACTORY_H
#define CONTACTS_MODEL_CONTACT_FIELD_FACTORY_H
* limitations under the License.
*
*/
+
#ifndef CONTACTS_MODEL_CONTACT_FIELD_H
#define CONTACTS_MODEL_CONTACT_FIELD_H
#include <contacts.h>
#include <memory>
+#include <vector>
#include "Contacts/Model/ContactFields.h"
#include "Contacts/Model/ContactTypes.h"
virtual ~ContactField() { }
/**
- * @return Whether field has no value.
+ * @brief Initialize the adapter.
+ * @remark This method should be called before using the object
*/
- virtual bool isEmpty() const { return false; }
+ virtual void initialize() { }
/**
* @brief Reset field values to default.
*/
virtual void reset() { }
+ /**
+ * @return Whether field has no value.
+ */
+ virtual bool isEmpty() const { return false; }
+
/**
* @brief Cast field to derived type.
*/
};
typedef std::unique_ptr<ContactField> ContactFieldPtr;
+ typedef std::vector<ContactFieldPtr> ContactFields;
}
}
*/
template <typename FieldContainer>
class ContactIterator :
- public std::iterator<std::input_iterator_tag, ContactFieldPtr>
+ public std::iterator<std::input_iterator_tag, ContactField>
{
public:
/**
/**
* @brief Get field pointed by iterator.
*/
- ContactFieldPtr operator*() const { return m_Container.getField(m_Index); }
+ ContactField &operator*() const { return *m_Container.getField(m_Index); }
/**
* @brief Compare iterators for inequality.
public:
using ContactField::ContactField;
+ /**
+ * @see ContactField::initialize()
+ */
+ virtual void initialize() override;
+
/**
* @see ContactField::isEmpty()
*/
* @param[in] index Child field index
* @return Child field.
*/
- ContactFieldPtr getField(unsigned index) const;
+ ContactField *getField(unsigned index) const;
/**
* @brief Get child field by id.
* @param[in] id Child field id
* @return Child field.
*/
- ContactFieldPtr getFieldById(unsigned id) const;
+ ContactField *getFieldById(unsigned id) const;
protected:
const ContactObjectMetadata &getObjectMetadata() const;
+
+ private:
+ ContactFields m_Fields;
};
}
}
public:
using ContactObject::ContactObject;
+ /**
+ * @see ContactField::initialize()
+ */
+ virtual void initialize() override;
+
/**
* @see ContactField::reset()
*/
/**
* @return Field that represents object's type.
*/
- ContactFieldPtr getTypeField() const;
+ ContactEnumField &getTypeField() const;
/**
* @return Field that stores object's custom type label.
*/
- ContactFieldPtr getLabelField() const;
+ ContactTextField &getLabelField() const;
private:
const ContactTypedObjectMetadata &getTypedObjectMetadata() const;
+
+ ContactFieldPtr m_TypeField;
+ ContactFieldPtr m_LabelField;
};
}
}
Evas_Object *ContactCompoundFieldItem::createCompoundControl(Evas_Object *parent)
{
- auto control = new ContactCompoundObjectControl(&getObject().cast<ContactCompoundObject>());
+ auto control = new ContactCompoundObjectControl(getObject().cast<ContactCompoundObject>());
control->create(parent);
enableEntryReturnButton(control->getEntry());
using namespace Contacts::Input;
using namespace Contacts::Model;
-ContactCompoundObjectControl::ContactCompoundObjectControl(ContactCompoundObject *object)
+ContactCompoundObjectControl::ContactCompoundObjectControl(ContactCompoundObject &object)
: m_Object(object)
{
}
void ContactCompoundObjectControl::onCreated()
{
- setGuideText(Common::getContactFieldName(ContactFieldId(m_Object->getId())));
+ setGuideText(Common::getContactFieldName(ContactFieldId(m_Object.getId())));
Evas_Object *entry = getEntry();
elm_entry_autocapital_type_set(entry, ELM_AUTOCAPITAL_TYPE_WORD);
evas_object_smart_callback_add(entry, "unfocused",
makeCallback(&ContactCompoundObjectControl::onUnfocused), this);
- char *text = elm_entry_utf8_to_markup(m_Object->getValue().c_str());
+ char *text = elm_entry_utf8_to_markup(m_Object.getValue().c_str());
elm_entry_entry_set(entry, text);
free(text);
}
void ContactCompoundObjectControl::onUnfocused(Evas_Object *entry, void *eventInfo)
{
char *text = elm_entry_markup_to_utf8(elm_entry_entry_get(getEntry()));
- m_Object->setValue(text);
+ m_Object.setValue(text);
free(text);
}
using namespace Contacts::Input;
using namespace Contacts::Model;
-ContactDateFieldControl::ContactDateFieldControl(Model::ContactDateField *field)
+ContactDateFieldControl::ContactDateFieldControl(Model::ContactDateField &field)
: m_Field(field), m_Button(nullptr)
{
}
void ContactDateFieldControl::onCreated()
{
- setButtonDate(m_Field->getValue());
+ setButtonDate(m_Field.getValue());
}
void ContactDateFieldControl::setButtonDate(tm date)
void ContactDateFieldControl::onButtonPressed(Evas_Object *button, void *eventInfo)
{
- Ui::DatePopup *popup = new Ui::DatePopup(m_Field->getValue());
+ Ui::DatePopup *popup = new Ui::DatePopup(m_Field.getValue());
popup->setResultCallback([this](const tm &date) {
- m_Field->setValue(date);
+ m_Field.setValue(date);
setButtonDate(date);
});
popup->create(getEvasObject());
using namespace Contacts::Input;
using namespace Contacts::Model;
-ContactFieldItem::ContactFieldItem(ContactFieldPtr object)
- : ContactFieldSubItem(object->cast<ContactObject>().getField(0)),
- m_Object(std::move(object))
+ContactFieldItem::ContactFieldItem(ContactObject &object)
+ : ContactFieldSubItem(*object.getField(0)),
+ m_Object(object)
{
unsigned firstFieldId = getField().getId();
for (auto &&field : getObject()) {
- if (field->getId() != firstFieldId) {
- insertSubItem(new ContactFieldSubItem(std::move(field)));
+ if (field.getId() != firstFieldId) {
+ insertSubItem(new ContactFieldSubItem(field));
}
}
}
ContactObject &ContactFieldItem::getObject() const
{
- return m_Object->cast<ContactObject>();
+ return m_Object;
}
Elm_Genlist_Item_Class *ContactFieldItem::getItemClass() const
void ContactFieldItem::onRemovePressed(Evas_Object *button, void *eventInfo)
{
if (m_OnRemove) {
- m_OnRemove(this, std::move(m_Object));
+ m_OnRemove(this);
}
- delete this;
}
#include "Contacts/Input/ContactFieldItem.h"
#include "Contacts/Input/ContactDateFieldControl.h"
#include "Contacts/Input/ContactTextFieldControl.h"
+#include "Contacts/Model/ContactField.h"
#include "Utils/Callback.h"
#include "InputItemLayout.h"
using namespace Contacts::Input;
using namespace Contacts::Model;
-ContactFieldSubItem::ContactFieldSubItem(ContactFieldPtr field)
- : m_Field(std::move(field)), m_NextFocusItem(nullptr)
+ContactFieldSubItem::ContactFieldSubItem(ContactField &field)
+ : m_Field(field), m_NextFocusItem(nullptr)
{
}
ContactField &ContactFieldSubItem::getField() const
{
- return *m_Field;
+ return m_Field;
}
bool ContactFieldSubItem::isFocusable() const
{
- return m_Field->getType() == TypeText;
+ return m_Field.getType() == TypeText;
}
Elm_Genlist_Item_Class *ContactFieldSubItem::getItemClass() const
Evas_Object *ContactFieldSubItem::getContent(Evas_Object *parent, const char *part)
{
- if (m_Field && strcmp(part, PART_MIDDLE) == 0) {
- switch (m_Field->getType()) {
+ if (strcmp(part, PART_MIDDLE) == 0) {
+ switch (m_Field.getType()) {
case TypeText:
{
- auto control = new ContactTextFieldControl(&m_Field->cast<ContactTextField>());
+ auto control = new ContactTextFieldControl(m_Field.cast<ContactTextField>());
control->create(parent);
enableEntryReturnButton(control->getEntry());
}
case TypeDate:
{
- auto control = new ContactDateFieldControl(&m_Field->cast<ContactDateField>());
+ auto control = new ContactDateFieldControl(m_Field.cast<ContactDateField>());
return control->create(parent);
}
default:
Ui::Control *control = Ui::Control::getControl(content);
if (control) {
- if (m_Field->getType() == TypeText) {
+ if (m_Field.getType() == TypeText) {
Evas_Object *entry = static_cast<Ui::Editfield *>(control)->getEntry();
elm_object_focus_set(entry, EINA_TRUE);
}
using namespace Contacts::Input;
using namespace Contacts::Model;
-ContactImageFieldControl::ContactImageFieldControl(ContactTextField *field)
+ContactImageFieldControl::ContactImageFieldControl(ContactTextField &field)
: Thumbnail(Thumbnail::SizeLarge), m_Field(field)
{
}
void ContactImageFieldControl::updateImage()
{
- setImagePath(m_Field->getValue());
+ setImagePath(m_Field.getValue());
}
void ContactImageFieldControl::onImageResult(app_control_h request, app_control_h reply,
app_control_result_e result)
{
- m_Field->setValue(App::getSingleExtraData(reply, APP_CONTROL_DATA_SELECTED).c_str());
+ m_Field.setValue(App::getSingleExtraData(reply, APP_CONTROL_DATA_SELECTED).c_str());
updateImage();
}
m_AppControl.launch(makeCallbackWithLastParam(&ContactImageFieldControl::onImageResult), this);
});
- if (!m_Field->isEmpty()) {
+ if (!m_Field.isEmpty()) {
popup->addItem("IDS_PB_OPT_REMOVE", [this] {
- m_Field->reset();
+ m_Field.reset();
updateImage();
});
}
#include "Contacts/Input/ContactImageFieldItem.h"
#include "Contacts/Input/ContactImageFieldControl.h"
+#include "Contacts/Model/ContactField.h"
#include "InputItemLayout.h"
using namespace Contacts::Input;
Evas_Object *ContactImageFieldItem::getContent(Evas_Object *parent, const char *part)
{
- auto control = new ContactImageFieldControl(&getField().cast<ContactTextField>());
+ auto control = new ContactImageFieldControl(getField().cast<ContactTextField>());
return control->create(parent);
}
using namespace Contacts::Input;
using namespace Contacts::Model;
-ContactObjectTypeControl::ContactObjectTypeControl(ContactEnumField *typeField,
- ContactTextField *labelField)
+ContactObjectTypeControl::ContactObjectTypeControl(ContactEnumField &typeField,
+ ContactTextField &labelField)
: m_TypeField(typeField), m_LabelField(labelField)
{
}
void ContactObjectTypeControl::onCreated()
{
- int currentValue = m_TypeField->getValue();
+ int currentValue = m_TypeField.getValue();
- auto names = Common::getContactEnumValueNames(ContactEnumType(m_TypeField->getSubType()));
- auto values = m_TypeField->getValues();
+ auto names = Common::getContactEnumValueNames(ContactEnumType(m_TypeField.getSubType()));
+ auto values = m_TypeField.getValues();
RETM_IF(names.count() != values.count(), "names.count() != values.count()");
for (size_t i = 0; i < values.count(); ++i) {
}
}
- if (m_TypeField->hasCustomValue()) {
- setText(m_LabelField->getValue());
+ if (m_TypeField.hasCustomValue()) {
+ setText(m_LabelField.getValue());
}
setSelectedCallback(std::bind(&ContactObjectTypeControl::onSelected, this,
bool ContactObjectTypeControl::onSelected(int value)
{
- if (value == m_TypeField->getCustomValue()) {
+ if (value == m_TypeField.getCustomValue()) {
auto popup = new ContactObjectCustomTypePopup();
popup->setResultCallback([this, value](const char *label) {
- m_TypeField->setValue(value);
- m_LabelField->setValue(label);
+ m_TypeField.setValue(value);
+ m_LabelField.setValue(label);
setText(label);
});
popup->create(getEvasObject());
return false;
} else {
- if (m_TypeField->hasCustomValue()) {
- m_LabelField->reset();
+ if (m_TypeField.hasCustomValue()) {
+ m_LabelField.reset();
}
- m_TypeField->setValue(value);
+ m_TypeField.setValue(value);
return true;
}
}
};
}
-ContactTextFieldControl::ContactTextFieldControl(Model::ContactTextField *field)
+ContactTextFieldControl::ContactTextFieldControl(Model::ContactTextField &field)
: m_Field(field)
{
}
void ContactTextFieldControl::onCreated()
{
- setGuideText(Common::getContactChildFieldName(m_Field->getId()));
+ setGuideText(Common::getContactChildFieldName(m_Field.getId()));
Evas_Object *entry = getEntry();
- elm_entry_input_panel_layout_set(entry, Utils::at(inputLayout, m_Field->getSubType()));
+ elm_entry_input_panel_layout_set(entry, Utils::at(inputLayout, m_Field.getSubType()));
evas_object_smart_callback_add(entry, "unfocused",
makeCallback(&ContactTextFieldControl::onUnfocused), this);
- char *text = elm_entry_utf8_to_markup(m_Field->getValue());
+ char *text = elm_entry_utf8_to_markup(m_Field.getValue());
elm_entry_entry_set(entry, text);
free(text);
}
void ContactTextFieldControl::onUnfocused(Evas_Object *entry, void *eventInfo)
{
char *text = elm_entry_markup_to_utf8(elm_entry_entry_get(getEntry()));
- m_Field->setValue(text);
+ m_Field.setValue(text);
free(text);
}
using namespace Contacts::Input;
using namespace Contacts::Model;
-ContactTypedFieldItem::ContactTypedFieldItem(Model::ContactFieldPtr object)
- : ContactFieldItem(std::move(object))
+ContactTypedFieldItem::ContactTypedFieldItem(Model::ContactObject &object)
+ : ContactFieldItem(object),
+ m_TypeField(getTypedObject().getTypeField()),
+ m_LabelField(getTypedObject().getLabelField())
{
- m_TypeField = getTypedObject().getTypeField();
- m_LabelField = getTypedObject().getLabelField();
}
const ContactTypedObject &ContactTypedFieldItem::getTypedObject() const
Evas_Object *ContactTypedFieldItem::getContent(Evas_Object *parent, const char *part)
{
if (strcmp(part, PART_LEFT) == 0) {
- Ui::Control *control = new ContactObjectTypeControl(
- &m_TypeField->cast<ContactEnumField>(),
- &m_LabelField->cast<ContactTextField>());
+ Ui::Control *control = new ContactObjectTypeControl(m_TypeField, m_LabelField);
return control->create(parent);
} else {
return ContactFieldItem::getContent(parent, part);
}
for (auto &&field : m_Contact) {
- switch (field->getType()) {
+ switch (field.getType()) {
case TypeArray:
- for (auto &&element : field->cast<ContactArray>()) {
- addFieldItem(std::move(element));
+ for (auto &&element : field.cast<ContactArray>()) {
+ addFieldItem(element.cast<ContactObject>());
}
break;
case TypeObject:
- if (!m_Items[field->getId()] && !field->isEmpty()) {
- m_AddFieldsItem->setAddFieldState(ContactFieldId(field->getId()), false);
- addFieldItem(std::move(field));
+ if (!m_Items[field.getId()] && !field.isEmpty()) {
+ m_AddFieldsItem->setAddFieldState(ContactFieldId(field.getId()), false);
+ addFieldItem(field.cast<ContactObject>());
}
break;
default:
page->setContent("title_left_btn", cancelButton);
}
-ContactFieldItem *InputView::createFieldItem(ContactFieldPtr field)
+ContactFieldItem *InputView::createFieldItem(ContactObject &field)
{
ContactFieldItem *item = nullptr;
- if (field->getId() == FieldImage) {
- item = new ContactImageFieldItem(std::move(field));
- } else if (field->getId() == FieldRelationship) {
- item = new ContactRelationshipFieldItem(std::move(field));
- } else if (field->getSubType() & ObjectTyped) {
- item = new ContactTypedFieldItem(std::move(field));
- } else if (field->getSubType() & ObjectCompound) {
- item = new ContactCompoundFieldItem(std::move(field));
+ if (field.getId() == FieldImage) {
+ item = new ContactImageFieldItem(field);
+ } else if (field.getId() == FieldRelationship) {
+ item = new ContactRelationshipFieldItem(field);
+ } else if (field.getSubType() & ObjectTyped) {
+ item = new ContactTypedFieldItem(field);
+ } else if (field.getSubType() & ObjectCompound) {
+ item = new ContactCompoundFieldItem(field);
} else {
- item = new ContactFieldItem(std::move(field));
+ item = new ContactFieldItem(field);
}
- item->setRemoveCallback(std::bind(&InputView::onRemoveField, this, _1, _2));
+ item->setRemoveCallback(std::bind(&InputView::onRemoveField, this, _1));
return item;
}
return m_AddFieldsItem;
}
-ContactFieldPtr InputView::addField(ContactFieldId fieldId)
+ContactObject &InputView::addField(ContactFieldId fieldId)
{
- ContactFieldPtr parentField = m_Contact.getFieldById(fieldId);
- if (parentField->getType() == TypeArray) {
- return parentField->cast<ContactArray>().addField();
+ ContactField &parentField = *m_Contact.getFieldById(fieldId);
+ if (parentField.getType() == TypeArray) {
+ return parentField.cast<ContactArray>().addField().cast<ContactObject>();
} else {
m_AddFieldsItem->setAddFieldState(fieldId, false);
- return parentField;
+ return parentField.cast<ContactObject>();
}
}
-void InputView::removeField(ContactFieldPtr field)
+void InputView::removeField(ContactObject &field)
{
- ContactFieldId fieldId = ContactFieldId(field->getId());
- ContactFieldPtr parentField = m_Contact.getFieldById(fieldId);
- if (parentField->getType() == TypeArray) {
- parentField->cast<ContactArray>().removeField(std::move(field));
+ ContactFieldId fieldId = ContactFieldId(field.getId());
+ ContactField &parentField = *m_Contact.getFieldById(fieldId);
+ if (parentField.getType() == TypeArray) {
+ parentField.cast<ContactArray>().removeField(field);
} else {
m_AddFieldsItem->setAddFieldState(fieldId, true);
- field->reset();
+ field.reset();
}
}
-ContactFieldItem *InputView::addFieldItem(Model::ContactFieldPtr field)
+ContactFieldItem *InputView::addFieldItem(Model::ContactObject &field)
{
- ContactFieldId fieldId = ContactFieldId(field->getId());
+ ContactFieldId fieldId = ContactFieldId(field.getId());
- ContactFieldItem *item = createFieldItem(std::move(field));
+ ContactFieldItem *item = createFieldItem(field);
m_Genlist->insert(item, nullptr, getNextFieldItem(fieldId));
if (!m_Items[fieldId]) {
return item;
}
-void InputView::removeFieldItem(ContactFieldItem *item, ContactFieldId fieldId)
+void InputView::removeFieldItem(ContactFieldItem *item)
{
+ ContactFieldId fieldId = ContactFieldId(item->getObject().getId());
+
if (item == m_Items[fieldId]) {
ContactFieldItem *nextItem = static_cast<ContactFieldItem *>(item->getNextGroupItem());
if (nextItem && nextItem->getObject().getId() == fieldId) {
m_Items[fieldId] = nullptr;
}
}
+
+ delete item;
}
void InputView::onAddField(ContactFieldId fieldId)
item->focus(ELM_GENLIST_ITEM_SCROLLTO_TOP);
}
-void InputView::onRemoveField(ContactFieldItem *item, ContactFieldPtr field)
+void InputView::onRemoveField(ContactFieldItem *item)
{
- removeFieldItem(item, ContactFieldId(field->getId()));
- removeField(std::move(field));
+ ContactObject &field = item->getObject();
+ removeFieldItem(item);
+ removeField(field);
}
void InputView::onDonePressed(Evas_Object *button, void *eventInfo)
}
setRecord(record);
+ ContactObject::initialize();
+
return err;
}
#include "Contacts/Model/ContactFactory.h"
#include "Contacts/Model/ContactFieldMetadata.h"
+#include <algorithm>
+
using namespace Contacts::Model;
+void ContactArray::initialize()
+{
+ int count = 0;
+ contacts_record_get_child_record_count(getRecord(), getPropertyId(), &count);
+
+ for (int i = 0; i < count; ++i) {
+ contacts_record_h record = nullptr;
+ contacts_record_get_child_record_at_p(getRecord(), getPropertyId(), i, &record);
+ m_Fields.push_back(ContactFactory::createField(record, getArrayMetadata().element));
+ }
+}
+
bool ContactArray::isEmpty() const
{
bool isEmpty = true;
for (auto &&field : *this) {
- if (!field->isEmpty()) {
+ if (!field.isEmpty()) {
isEmpty = false;
break;
}
ContactArrayIterator ContactArray::end() const
{
- int count = 0;
- contacts_record_get_child_record_count(getRecord(), getPropertyId(), &count);
- return ContactArrayIterator(*this, count);
+ return ContactArrayIterator(*this, m_Fields.size());
}
-ContactFieldPtr ContactArray::getField(unsigned index) const
+ContactField *ContactArray::getField(unsigned index) const
{
- contacts_record_h record = nullptr;
- contacts_record_get_child_record_at_p(getRecord(), getPropertyId(), index, &record);
- if (record) {
- return ContactFactory::createField(record, getArrayMetadata().element);
+ if (index < m_Fields.size()) {
+ return m_Fields[index].get();
}
return nullptr;
}
-ContactFieldPtr ContactArray::addField()
+ContactField &ContactArray::addField()
{
const ContactFieldMetadata *elementMetadata = &getArrayMetadata().element;
const char *uri = ((const ContactObjectMetadata *) elementMetadata->typeMetadata)->uri;
ContactFieldPtr field = ContactFactory::createField(record, getArrayMetadata().element);
field->reset();
- return field;
+
+ m_Fields.push_back(std::move(field));
+ return *m_Fields.back().get();
}
-void ContactArray::removeField(ContactFieldPtr field)
+void ContactArray::removeField(ContactField &field)
{
- contacts_record_remove_child_record(getRecord(), getPropertyId(), field->getRecord());
- contacts_record_destroy(field->getRecord(), true);
+ auto comp = [&field](ContactFieldPtr &ptr) {
+ return ptr.get() == &field;
+ };
+
+ m_Fields.erase(std::remove_if(m_Fields.begin(), m_Fields.end(), comp), m_Fields.end());
+
+ contacts_record_remove_child_record(getRecord(), getPropertyId(), field.getRecord());
+ contacts_record_destroy(field.getRecord(), true);
}
const ContactArrayMetadata &ContactArray::getArrayMetadata() const
break;
}
+ if (field) {
+ field->initialize();
+ }
+
return ContactFieldPtr(field);
}
using namespace Contacts::Model;
+void ContactObject::initialize()
+{
+ for (auto &&field : getObjectMetadata().fields) {
+ m_Fields.push_back(ContactFactory::createField(getRecord(), field));
+ }
+}
+
bool ContactObject::isEmpty() const
{
bool isEmpty = true;
for (auto &&field : *this) {
- if (!field->isEmpty()) {
+ if (!field.isEmpty()) {
isEmpty = false;
break;
}
void ContactObject::reset()
{
for (auto &&field : *this) {
- field->reset();
+ field.reset();
}
}
ContactObjectIterator ContactObject::end() const
{
- return ContactObjectIterator(*this, getObjectMetadata().fields.count());
+ return ContactObjectIterator(*this, m_Fields.size());
}
-ContactFieldPtr ContactObject::getField(unsigned index) const
+ContactField *ContactObject::getField(unsigned index) const
{
- const ContactObjectMetadata &metadata = getObjectMetadata();
- const ContactFieldMetadata *field = metadata.fields.begin() + index;
- if (field < metadata.fields.end()) {
- return ContactFactory::createField(getRecord(), *field);
+ if (index < m_Fields.size()) {
+ return m_Fields[index].get();
}
return nullptr;
}
-ContactFieldPtr ContactObject::getFieldById(unsigned id) const
+ContactField *ContactObject::getFieldById(unsigned id) const
{
- for (auto &&field : getObjectMetadata().fields) {
- if (field.id == id) {
- return ContactFactory::createField(getRecord(), field);
+ for (auto &&field : m_Fields) {
+ if (field->getId() == id) {
+ return field.get();
}
}
using namespace Contacts::Model;
+void ContactTypedObject::initialize()
+{
+ ContactObject::initialize();
+ m_TypeField = ContactFactory::createField(getRecord(), getTypedObjectMetadata().typeField);
+ m_LabelField = ContactFactory::createField(getRecord(), getTypedObjectMetadata().labelField);
+}
+
void ContactTypedObject::reset()
{
- getTypeField()->reset();
- getLabelField()->reset();
ContactObject::reset();
+ m_TypeField->reset();
+ m_LabelField->reset();
}
-ContactFieldPtr ContactTypedObject::getTypeField() const
+ContactEnumField &ContactTypedObject::getTypeField() const
{
- return ContactFactory::createField(getRecord(), getTypedObjectMetadata().typeField);
+ return m_TypeField->cast<ContactEnumField>();
}
-ContactFieldPtr ContactTypedObject::getLabelField() const
+ContactTextField &ContactTypedObject::getLabelField() const
{
- return ContactFactory::createField(getRecord(), getTypedObjectMetadata().labelField);
+ return m_LabelField->cast<ContactTextField>();
}
const ContactTypedObjectMetadata &ContactTypedObject::getTypedObjectMetadata() const
projects / profile / mobile / apps / native / phone-contacts.git / commitdiff