rimmed pushed a commit to branch master.

http://git.enlightenment.org/tools/eflete.git/commit/?id=54bf381eaaaa45071841755b8117c5c22fbf6d67

commit 54bf381eaaaa45071841755b8117c5c22fbf6d67
Author: Vitalii Vorobiov <vi.vorob...@samsung.com>
Date:   Fri Sep 9 18:59:27 2016 +0300

    resource_manager2: proxy between editor and eflete
---
 src/bin/Makefile.am                                |   1 +
 src/bin/common/signals.h                           |  25 +-
 src/bin/editor/editor.h                            | 399 ++++++++++-----------
 src/bin/editor/editor_group.c                      |  20 +-
 src/bin/editor/editor_macro.h                      | 114 +++---
 src/bin/editor/editor_part.c                       | 142 ++++----
 src/bin/editor/editor_program.c                    | 106 +++---
 src/bin/editor/editor_states.c                     | 180 +++++-----
 src/bin/editor/editor_text.c                       |  34 +-
 src/bin/editor/editor_top_level.c                  |  22 +-
 src/bin/resource_manager/resource_manager2.h       |   1 +
 src/bin/resource_manager/resource_manager_react.c  | 281 ++++++++-------
 .../resource_manager/resource_manager_signals.h    | 228 ++++++++++++
 src/bin/ui/main_window.h                           |   1 +
 14 files changed, 904 insertions(+), 650 deletions(-)

diff --git a/src/bin/Makefile.am b/src/bin/Makefile.am
index a33c1d7..a29e38f 100644
--- a/src/bin/Makefile.am
+++ b/src/bin/Makefile.am
@@ -32,6 +32,7 @@ EXTRA_DIST = \
        project_manager/resource_manager.h \
        resource_manager/resource_manager2.h \
        resource_manager/resource_manager_private.h \
+       resource_manager/resource_manager_signals.h \
        ui/cursor.h \
        ui/history_ui.h \
        ui/main_window.h \
diff --git a/src/bin/common/signals.h b/src/bin/common/signals.h
index 35492be..45290d3 100644
--- a/src/bin/common/signals.h
+++ b/src/bin/common/signals.h
@@ -329,13 +329,15 @@ typedef struct {
  */
 #define SIGNAL_PROPERTY_ATTRIBUTE_CHANGED "SIGNAL_PROPERTY_ATTRIBUTE_CHANGED"
 
+
 /**
- * emited when any attribute is changed in editor.
+ * emited when any attribute is changed.
+ * This signal goes into resource manager
  * eventinfo - Pointer to Attribute
  *
  * @ingroup Window
  */
-#define SIGNAL_EDITOR_ATTRIBUTE_CHANGED "SIGNAL_EDITOR_ATTRIBUTE_CHANGED"
+#define SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED "SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED"
 
 /**
  * emited when any attribute of top level resource (image, colorclass etc) is 
changed in editor.
@@ -343,7 +345,24 @@ typedef struct {
  *
  * @ingroup Window
  */
-#define SIGNAL_EDITOR_RESOURCE_ATTRIBUTE_CHANGED 
"SIGNAL_EDITOR_RESOURCE_ATTRIBUTE_CHANGED"
+#define SIGNAL_EDITOR_RM_RESOURCE_ATTRIBUTE_CHANGED 
"SIGNAL_EDITOR_RM_RESOURCE_ATTRIBUTE_CHANGED"
+
+/**
+ * emited when any attribute is sent by resource manager (after editor).
+ * eventinfo - Pointer to Attribute
+ *
+ * @ingroup Window
+ */
+#define SIGNAL_EDITOR_ATTRIBUTE_CHANGED "SIGNAL_EDITOR_ATTRIBUTE_CHANGED"
+
+/**
+ * emited when any attribute of top level resource (image, colorclass etc)
+ * is sent by resource manager (after editor).
+ * eventinfo - Pointer to Attribute
+ *
+ * @ingroup Window
+ */
+#define SIGNAL_EDITOR_RESOURCE_ATTRIBUTE_CHANGED 
"SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED"
 
 typedef struct {
    const char *part_name;
diff --git a/src/bin/editor/editor.h b/src/bin/editor/editor.h
index e7a8522..31a13db 100644
--- a/src/bin/editor/editor.h
+++ b/src/bin/editor/editor.h
@@ -25,210 +25,209 @@
 #include "default.h"
 
 typedef enum {
-   ATTRIBUTE_NONE,
-
-   ATTRIBUTE_GROUP_NAME,
-   ATTRIBUTE_GROUP_MIN_W,
-   ATTRIBUTE_GROUP_MIN_H,
-   ATTRIBUTE_GROUP_MAX_W,
-   ATTRIBUTE_GROUP_MAX_H,
-   ATTRIBUTE_GROUP_DATA_NAME,
-   ATTRIBUTE_GROUP_DATA_VALUE,
-   ATTRIBUTE_STATE_NAME,
-   ATTRIBUTE_STATE_MIN_W,
-   ATTRIBUTE_STATE_MIN_H,
-   ATTRIBUTE_STATE_MAX_W,
-   ATTRIBUTE_STATE_MAX_H,
-   ATTRIBUTE_STATE_ALIGN_X,
-   ATTRIBUTE_STATE_ALIGN_Y,
-   ATTRIBUTE_STATE_REL1_RELATIVE_X,
-   ATTRIBUTE_STATE_REL1_RELATIVE_Y,
-   ATTRIBUTE_STATE_REL2_RELATIVE_X,
-   ATTRIBUTE_STATE_REL2_RELATIVE_Y,
-   ATTRIBUTE_STATE_REL1_OFFSET_X,
-   ATTRIBUTE_STATE_REL1_OFFSET_Y,
-   ATTRIBUTE_STATE_REL2_OFFSET_X,
-   ATTRIBUTE_STATE_REL2_OFFSET_Y,
-   ATTRIBUTE_STATE_ASPECT_MIN,
-   ATTRIBUTE_STATE_ASPECT_MAX,
-   ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_X,
-   ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_Y,
-   ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_X,
-   ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_Y,
-   ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_X,
-   ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_Y,
-   ATTRIBUTE_STATE_FILL_SIZE_OFFSET_X,
-   ATTRIBUTE_STATE_FILL_SIZE_OFFSET_Y,
-   ATTRIBUTE_STATE_TEXT_ALIGN_X,
-   ATTRIBUTE_STATE_TEXT_ALIGN_Y,
-   ATTRIBUTE_STATE_TEXT_ELIPSIS,
-   ATTRIBUTE_STATE_TEXT_ELIPSIS_ENABLE /* virtual attribute */,
-   ATTRIBUTE_STATE_TEXT_SIZE,
-   ATTRIBUTE_STATE_TEXT_FIT_X,
-   ATTRIBUTE_STATE_TEXT_FIT_Y,
-   ATTRIBUTE_STATE_TEXT_MAX_X,
-   ATTRIBUTE_STATE_TEXT_MAX_Y,
-   ATTRIBUTE_STATE_TEXT_MIN_X,
-   ATTRIBUTE_STATE_TEXT_MIN_Y,
-   ATTRIBUTE_STATE_FIXED_H,
-   ATTRIBUTE_STATE_FIXED_W,
-   ATTRIBUTE_STATE_FILL_SMOOTH,
-   ATTRIBUTE_STATE_VISIBLE,
-   ATTRIBUTE_STATE_IMAGE,
-   ATTRIBUTE_STATE_IMAGE_TWEEN,
-   ATTRIBUTE_STATE_COLOR_CLASS,
-   ATTRIBUTE_STATE_REL1_TO_X,
-   ATTRIBUTE_STATE_REL1_TO_Y,
-   ATTRIBUTE_STATE_REL2_TO_X,
-   ATTRIBUTE_STATE_REL2_TO_Y,
-   ATTRIBUTE_STATE_TEXT_SOURCE,
-   ATTRIBUTE_STATE_TEXT_TEXT_SOURCE,
-   ATTRIBUTE_STATE_TEXT,
-   ATTRIBUTE_STATE_FONT,
-   ATTRIBUTE_STATE_TEXT_STYLE,
-   ATTRIBUTE_STATE_COLOR,
-   ATTRIBUTE_STATE_OUTLINE_COLOR,
-   ATTRIBUTE_STATE_SHADOW_COLOR,
-   ATTRIBUTE_STATE_IMAGE_BORDER_TOP,
-   ATTRIBUTE_STATE_IMAGE_BORDER_BOTTOM,
-   ATTRIBUTE_STATE_IMAGE_BORDER_LEFT,
-   ATTRIBUTE_STATE_IMAGE_BORDER_RIGHT,
-   ATTRIBUTE_STATE_IMAGE_BORDER_FILL,
-   ATTRIBUTE_STATE_ASPECT_PREF,
-   ATTRIBUTE_PART_TEXT_EFFECT,
-   ATTRIBUTE_PART_TEXT_SHADOW_DIRECTION,
-   ATTRIBUTE_PART_IGNORE_FLAGS,
-   ATTRIBUTE_PART_MOUSE_EVENTS,
-   ATTRIBUTE_PART_REPEAT_EVENTS,
-   ATTRIBUTE_PART_SCALE,
-   ATTRIBUTE_PART_DRAG_COUNT_X,
-   ATTRIBUTE_PART_DRAG_COUNT_Y,
-   ATTRIBUTE_PART_DRAG_X,
-   ATTRIBUTE_PART_DRAG_Y,
-   ATTRIBUTE_PART_DRAG_STEP_X,
-   ATTRIBUTE_PART_DRAG_STEP_Y,
-   ATTRIBUTE_PART_CLIP_TO,
-   ATTRIBUTE_PART_DRAG_CONFINE,
-   ATTRIBUTE_PART_DRAG_THRESHOLD,
-   ATTRIBUTE_PART_DRAG_EVENT,
-   ATTRIBUTE_PART_NAME,
-   ATTRIBUTE_PART_TYPE,
-   ATTRIBUTE_PART_GROUP_SOURCE,
-   ATTRIBUTE_PART_TEXTBLOCK_SELECTION_UNDER,
-   ATTRIBUTE_PART_TEXTBLOCK_SELECTION_OVER,
-   ATTRIBUTE_PART_TEXTBLOCK_CURSOR_UNDER,
-   ATTRIBUTE_PART_TEXTBLOCK_CURSOR_OVER,
-   ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_UNDER,
-   ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_OVER,
-   ATTRIBUTE_PART_ITEM_ASPECT_MODE,
-   ATTRIBUTE_PART_ITEM_ALIGN_X,
-   ATTRIBUTE_PART_ITEM_ALIGN_Y,
-   ATTRIBUTE_PART_ITEM_WEIGHT_X,
-   ATTRIBUTE_PART_ITEM_WEIGHT_Y,
-   ATTRIBUTE_PART_ITEM_ASPECT_H,
-   ATTRIBUTE_PART_ITEM_ASPECT_W,
-   ATTRIBUTE_PART_ITEM_MAX_H,
-   ATTRIBUTE_PART_ITEM_MAX_W,
-   ATTRIBUTE_PART_ITEM_MIN_H,
-   ATTRIBUTE_PART_ITEM_MIN_W,
-   ATTRIBUTE_PART_ITEM_NAME,
-   ATTRIBUTE_PART_ITEM_PREFER_H,
-   ATTRIBUTE_PART_ITEM_PREFER_W,
-   ATTRIBUTE_PART_ITEM_SPREAD_H,
-   ATTRIBUTE_PART_ITEM_SPREAD_W,
-   ATTRIBUTE_PART_ITEM_SPAN_COL,
-   ATTRIBUTE_PART_ITEM_SPAN_ROW,
-   ATTRIBUTE_PART_ITEM_POSITION_COL,
-   ATTRIBUTE_PART_ITEM_POSITION_ROW,
-   ATTRIBUTE_PART_ITEM_SOURCE,
-   ATTRIBUTE_PART_ITEM_PADDING_TOP,
-   ATTRIBUTE_PART_ITEM_PADDING_BOTTOM,
-   ATTRIBUTE_PART_ITEM_PADDING_LEFT,
-   ATTRIBUTE_PART_ITEM_PADDING_RIGHT,
-   ATTRIBUTE_STATE_CONTAINER_ALIGN_X,
-   ATTRIBUTE_STATE_CONTAINER_ALIGN_Y,
-   ATTRIBUTE_STATE_CONTAINER_MIN_H,
-   ATTRIBUTE_STATE_CONTAINER_MIN_V,
-   ATTRIBUTE_STATE_TABLE_HOMOGENEOUS,
-   ATTRIBUTE_STATE_CONTAINER_PADING_X,
-   ATTRIBUTE_STATE_CONTAINER_PADING_Y,
-   ATTRIBUTE_STATE_MINMUL_H,
-   ATTRIBUTE_STATE_MINMUL_W,
-   ATTRIBUTE_PART_MULTILINE,
-   ATTRIBUTE_STATE_PROXY_SOURCE,
-   ATTRIBUTE_PART_SELECT_MODE,
-   ATTRIBUTE_PART_ENTRY_MODE,
-   ATTRIBUTE_PART_POINTER_MODE,
-   ATTRIBUTE_PART_CURSOR_MODE,
-   ATTRIBUTE_STATE_FILL_TYPE,
-   ATTRIBUTE_STATE_MAP_ON,
-   ATTRIBUTE_STATE_MAP_PERSPECTIVE_ON,
-   ATTRIBUTE_STATE_MAP_PERSPECTIVE,
-   ATTRIBUTE_STATE_MAP_LIGHT,
-   ATTRIBUTE_STATE_MAP_SMOOTH,
-   ATTRIBUTE_STATE_MAP_ALPHA,
-   ATTRIBUTE_STATE_MAP_BACKFACE_CULL,
-   ATTRIBUTE_STATE_MAP_PERSPECTIVE_FOCAL,
-   ATTRIBUTE_STATE_MAP_PERSPECTIVE_ZPLANE,
-   ATTRIBUTE_STATE_MAP_ROTATION_CENTER,
-   ATTRIBUTE_STATE_MAP_ROTATION_X,
-   ATTRIBUTE_STATE_MAP_ROTATION_Y,
-   ATTRIBUTE_STATE_MAP_ROTATION_Z,
-   ATTRIBUTE_STATE_MAP_POINT_COLOR_1,
-   ATTRIBUTE_STATE_MAP_POINT_COLOR_2,
-   ATTRIBUTE_STATE_MAP_POINT_COLOR_3,
-   ATTRIBUTE_STATE_MAP_POINT_COLOR_4,
-   ATTRIBUTE_PROGRAM_TRANSITION_TYPE,
-   ATTRIBUTE_PROGRAM_TRANSITION_FROM_CURRENT,
-   ATTRIBUTE_PROGRAM_ACTION,
-   ATTRIBUTE_PROGRAM_CHANNEL,
-   ATTRIBUTE_PROGRAM_TONE_DURATION,
-   ATTRIBUTE_PROGRAM_IN_FROM,
-   ATTRIBUTE_PROGRAM_IN_RANGE,
-   ATTRIBUTE_PROGRAM_TRANSITION_TIME,
-   ATTRIBUTE_PROGRAM_SAMPLE_SPEED,
-   ATTRIBUTE_PROGRAM_VALUE,
-   ATTRIBUTE_PROGRAM_TRANSITION_FACTOR,
-   ATTRIBUTE_PROGRAM_TRANSITION_GRADIENT,
-   ATTRIBUTE_PROGRAM_TRANSITION_DECAY,
-   ATTRIBUTE_PROGRAM_TRANSITION_BOUNCES,
-   ATTRIBUTE_PROGRAM_TRANSITION_SWINGS,
-   ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_X1,
-   ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_Y1,
-   ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_X2,
-   ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_Y2,
-   ATTRIBUTE_PROGRAM_FILTER_PART,
-   ATTRIBUTE_PROGRAM_FILTER_STATE,
-   ATTRIBUTE_PROGRAM_API_NAME,
-   ATTRIBUTE_PROGRAM_API_DESCRIPTION,
-   ATTRIBUTE_PROGRAM_SAMPLE_NAME,
-   ATTRIBUTE_PROGRAM_TONE_NAME,
-   ATTRIBUTE_PROGRAM_SIGNAL,
-   ATTRIBUTE_PROGRAM_SOURCE,
-   ATTRIBUTE_PROGRAM_STATE,
-   ATTRIBUTE_PROGRAM_EMIT_SIGNAL,
-   ATTRIBUTE_PROGRAM_EMIT_SOURCE,
-   ATTRIBUTE_PROGRAM_DRAG_VALUE_X,
-   ATTRIBUTE_PROGRAM_DRAG_VALUE_Y,
-   ATTRIBUTE_PROGRAM_NAME,
-   ATTRIBUTE_PROGRAM_TARGET,
-   ATTRIBUTE_PROGRAM_AFTER,
-   ATTRIBUTE_PROGRAM_SCRIPT,
-
-   ATTRIBUTE_LAST
-} Attribute;
-
+   RM_ATTRIBUTE_NONE,
+
+   RM_ATTRIBUTE_GROUP_NAME,
+   RM_ATTRIBUTE_GROUP_MIN_W,
+   RM_ATTRIBUTE_GROUP_MIN_H,
+   RM_ATTRIBUTE_GROUP_MAX_W,
+   RM_ATTRIBUTE_GROUP_MAX_H,
+   RM_ATTRIBUTE_GROUP_DATA_NAME,
+   RM_ATTRIBUTE_GROUP_DATA_VALUE,
+   RM_ATTRIBUTE_STATE_NAME,
+   RM_ATTRIBUTE_STATE_MIN_W,
+   RM_ATTRIBUTE_STATE_MIN_H,
+   RM_ATTRIBUTE_STATE_MAX_W,
+   RM_ATTRIBUTE_STATE_MAX_H,
+   RM_ATTRIBUTE_STATE_ALIGN_X,
+   RM_ATTRIBUTE_STATE_ALIGN_Y,
+   RM_ATTRIBUTE_STATE_REL1_RELATIVE_X,
+   RM_ATTRIBUTE_STATE_REL1_RELATIVE_Y,
+   RM_ATTRIBUTE_STATE_REL2_RELATIVE_X,
+   RM_ATTRIBUTE_STATE_REL2_RELATIVE_Y,
+   RM_ATTRIBUTE_STATE_REL1_OFFSET_X,
+   RM_ATTRIBUTE_STATE_REL1_OFFSET_Y,
+   RM_ATTRIBUTE_STATE_REL2_OFFSET_X,
+   RM_ATTRIBUTE_STATE_REL2_OFFSET_Y,
+   RM_ATTRIBUTE_STATE_ASPECT_MIN,
+   RM_ATTRIBUTE_STATE_ASPECT_MAX,
+   RM_ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_X,
+   RM_ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_Y,
+   RM_ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_X,
+   RM_ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_Y,
+   RM_ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_X,
+   RM_ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_Y,
+   RM_ATTRIBUTE_STATE_FILL_SIZE_OFFSET_X,
+   RM_ATTRIBUTE_STATE_FILL_SIZE_OFFSET_Y,
+   RM_ATTRIBUTE_STATE_TEXT_ALIGN_X,
+   RM_ATTRIBUTE_STATE_TEXT_ALIGN_Y,
+   RM_ATTRIBUTE_STATE_TEXT_ELIPSIS,
+   RM_ATTRIBUTE_STATE_TEXT_ELIPSIS_ENABLE /* virtual attribute */,
+   RM_ATTRIBUTE_STATE_TEXT_SIZE,
+   RM_ATTRIBUTE_STATE_TEXT_FIT_X,
+   RM_ATTRIBUTE_STATE_TEXT_FIT_Y,
+   RM_ATTRIBUTE_STATE_TEXT_MAX_X,
+   RM_ATTRIBUTE_STATE_TEXT_MAX_Y,
+   RM_ATTRIBUTE_STATE_TEXT_MIN_X,
+   RM_ATTRIBUTE_STATE_TEXT_MIN_Y,
+   RM_ATTRIBUTE_STATE_FIXED_H,
+   RM_ATTRIBUTE_STATE_FIXED_W,
+   RM_ATTRIBUTE_STATE_FILL_SMOOTH,
+   RM_ATTRIBUTE_STATE_VISIBLE,
+   RM_ATTRIBUTE_STATE_IMAGE,
+   RM_ATTRIBUTE_STATE_IMAGE_TWEEN,
+   RM_ATTRIBUTE_STATE_COLOR_CLASS,
+   RM_ATTRIBUTE_STATE_REL1_TO_X,
+   RM_ATTRIBUTE_STATE_REL1_TO_Y,
+   RM_ATTRIBUTE_STATE_REL2_TO_X,
+   RM_ATTRIBUTE_STATE_REL2_TO_Y,
+   RM_ATTRIBUTE_STATE_TEXT_SOURCE,
+   RM_ATTRIBUTE_STATE_TEXT_TEXT_SOURCE,
+   RM_ATTRIBUTE_STATE_TEXT,
+   RM_ATTRIBUTE_STATE_FONT,
+   RM_ATTRIBUTE_STATE_TEXT_STYLE,
+   RM_ATTRIBUTE_STATE_COLOR,
+   RM_ATTRIBUTE_STATE_OUTLINE_COLOR,
+   RM_ATTRIBUTE_STATE_SHADOW_COLOR,
+   RM_ATTRIBUTE_STATE_IMAGE_BORDER_TOP,
+   RM_ATTRIBUTE_STATE_IMAGE_BORDER_BOTTOM,
+   RM_ATTRIBUTE_STATE_IMAGE_BORDER_LEFT,
+   RM_ATTRIBUTE_STATE_IMAGE_BORDER_RIGHT,
+   RM_ATTRIBUTE_STATE_IMAGE_BORDER_FILL,
+   RM_ATTRIBUTE_STATE_ASPECT_PREF,
+   RM_ATTRIBUTE_PART_TEXT_EFFECT,
+   RM_ATTRIBUTE_PART_TEXT_SHADOW_DIRECTION,
+   RM_ATTRIBUTE_PART_IGNORE_FLAGS,
+   RM_ATTRIBUTE_PART_MOUSE_EVENTS,
+   RM_ATTRIBUTE_PART_REPEAT_EVENTS,
+   RM_ATTRIBUTE_PART_SCALE,
+   RM_ATTRIBUTE_PART_DRAG_COUNT_X,
+   RM_ATTRIBUTE_PART_DRAG_COUNT_Y,
+   RM_ATTRIBUTE_PART_DRAG_X,
+   RM_ATTRIBUTE_PART_DRAG_Y,
+   RM_ATTRIBUTE_PART_DRAG_STEP_X,
+   RM_ATTRIBUTE_PART_DRAG_STEP_Y,
+   RM_ATTRIBUTE_PART_CLIP_TO,
+   RM_ATTRIBUTE_PART_DRAG_CONFINE,
+   RM_ATTRIBUTE_PART_DRAG_THRESHOLD,
+   RM_ATTRIBUTE_PART_DRAG_EVENT,
+   RM_ATTRIBUTE_PART_NAME,
+   RM_ATTRIBUTE_PART_TYPE,
+   RM_ATTRIBUTE_PART_GROUP_SOURCE,
+   RM_ATTRIBUTE_PART_TEXTBLOCK_SELECTION_UNDER,
+   RM_ATTRIBUTE_PART_TEXTBLOCK_SELECTION_OVER,
+   RM_ATTRIBUTE_PART_TEXTBLOCK_CURSOR_UNDER,
+   RM_ATTRIBUTE_PART_TEXTBLOCK_CURSOR_OVER,
+   RM_ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_UNDER,
+   RM_ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_OVER,
+   RM_ATTRIBUTE_PART_ITEM_ASPECT_MODE,
+   RM_ATTRIBUTE_PART_ITEM_ALIGN_X,
+   RM_ATTRIBUTE_PART_ITEM_ALIGN_Y,
+   RM_ATTRIBUTE_PART_ITEM_WEIGHT_X,
+   RM_ATTRIBUTE_PART_ITEM_WEIGHT_Y,
+   RM_ATTRIBUTE_PART_ITEM_ASPECT_H,
+   RM_ATTRIBUTE_PART_ITEM_ASPECT_W,
+   RM_ATTRIBUTE_PART_ITEM_MAX_H,
+   RM_ATTRIBUTE_PART_ITEM_MAX_W,
+   RM_ATTRIBUTE_PART_ITEM_MIN_H,
+   RM_ATTRIBUTE_PART_ITEM_MIN_W,
+   RM_ATTRIBUTE_PART_ITEM_NAME,
+   RM_ATTRIBUTE_PART_ITEM_PREFER_H,
+   RM_ATTRIBUTE_PART_ITEM_PREFER_W,
+   RM_ATTRIBUTE_PART_ITEM_SPREAD_H,
+   RM_ATTRIBUTE_PART_ITEM_SPREAD_W,
+   RM_ATTRIBUTE_PART_ITEM_SPAN_COL,
+   RM_ATTRIBUTE_PART_ITEM_SPAN_ROW,
+   RM_ATTRIBUTE_PART_ITEM_POSITION_COL,
+   RM_ATTRIBUTE_PART_ITEM_POSITION_ROW,
+   RM_ATTRIBUTE_PART_ITEM_SOURCE,
+   RM_ATTRIBUTE_PART_ITEM_PADDING_TOP,
+   RM_ATTRIBUTE_PART_ITEM_PADDING_BOTTOM,
+   RM_ATTRIBUTE_PART_ITEM_PADDING_LEFT,
+   RM_ATTRIBUTE_PART_ITEM_PADDING_RIGHT,
+   RM_ATTRIBUTE_STATE_CONTAINER_ALIGN_X,
+   RM_ATTRIBUTE_STATE_CONTAINER_ALIGN_Y,
+   RM_ATTRIBUTE_STATE_CONTAINER_MIN_H,
+   RM_ATTRIBUTE_STATE_CONTAINER_MIN_V,
+   RM_ATTRIBUTE_STATE_TABLE_HOMOGENEOUS,
+   RM_ATTRIBUTE_STATE_CONTAINER_PADING_X,
+   RM_ATTRIBUTE_STATE_CONTAINER_PADING_Y,
+   RM_ATTRIBUTE_STATE_MINMUL_H,
+   RM_ATTRIBUTE_STATE_MINMUL_W,
+   RM_ATTRIBUTE_PART_MULTILINE,
+   RM_ATTRIBUTE_STATE_PROXY_SOURCE,
+   RM_ATTRIBUTE_PART_SELECT_MODE,
+   RM_ATTRIBUTE_PART_ENTRY_MODE,
+   RM_ATTRIBUTE_PART_POINTER_MODE,
+   RM_ATTRIBUTE_PART_CURSOR_MODE,
+   RM_ATTRIBUTE_STATE_FILL_TYPE,
+   RM_ATTRIBUTE_STATE_MAP_ON,
+   RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE_ON,
+   RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE,
+   RM_ATTRIBUTE_STATE_MAP_LIGHT,
+   RM_ATTRIBUTE_STATE_MAP_SMOOTH,
+   RM_ATTRIBUTE_STATE_MAP_ALPHA,
+   RM_ATTRIBUTE_STATE_MAP_BACKFACE_CULL,
+   RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE_FOCAL,
+   RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE_ZPLANE,
+   RM_ATTRIBUTE_STATE_MAP_ROTATION_CENTER,
+   RM_ATTRIBUTE_STATE_MAP_ROTATION_X,
+   RM_ATTRIBUTE_STATE_MAP_ROTATION_Y,
+   RM_ATTRIBUTE_STATE_MAP_ROTATION_Z,
+   RM_ATTRIBUTE_STATE_MAP_POINT_COLOR_1,
+   RM_ATTRIBUTE_STATE_MAP_POINT_COLOR_2,
+   RM_ATTRIBUTE_STATE_MAP_POINT_COLOR_3,
+   RM_ATTRIBUTE_STATE_MAP_POINT_COLOR_4,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_TYPE,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_FROM_CURRENT,
+   RM_ATTRIBUTE_PROGRAM_ACTION,
+   RM_ATTRIBUTE_PROGRAM_CHANNEL,
+   RM_ATTRIBUTE_PROGRAM_TONE_DURATION,
+   RM_ATTRIBUTE_PROGRAM_IN_FROM,
+   RM_ATTRIBUTE_PROGRAM_IN_RANGE,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_TIME,
+   RM_ATTRIBUTE_PROGRAM_SAMPLE_SPEED,
+   RM_ATTRIBUTE_PROGRAM_VALUE,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_FACTOR,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_GRADIENT,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_DECAY,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_BOUNCES,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_SWINGS,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_X1,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_Y1,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_X2,
+   RM_ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_Y2,
+   RM_ATTRIBUTE_PROGRAM_FILTER_PART,
+   RM_ATTRIBUTE_PROGRAM_FILTER_STATE,
+   RM_ATTRIBUTE_PROGRAM_API_NAME,
+   RM_ATTRIBUTE_PROGRAM_API_DESCRIPTION,
+   RM_ATTRIBUTE_PROGRAM_SAMPLE_NAME,
+   RM_ATTRIBUTE_PROGRAM_TONE_NAME,
+   RM_ATTRIBUTE_PROGRAM_SIGNAL,
+   RM_ATTRIBUTE_PROGRAM_SOURCE,
+   RM_ATTRIBUTE_PROGRAM_STATE,
+   RM_ATTRIBUTE_PROGRAM_EMIT_SIGNAL,
+   RM_ATTRIBUTE_PROGRAM_EMIT_SOURCE,
+   RM_ATTRIBUTE_PROGRAM_DRAG_VALUE_X,
+   RM_ATTRIBUTE_PROGRAM_DRAG_VALUE_Y,
+   RM_ATTRIBUTE_PROGRAM_NAME,
+   RM_ATTRIBUTE_PROGRAM_TARGET,
+   RM_ATTRIBUTE_PROGRAM_AFTER,
+   RM_ATTRIBUTE_PROGRAM_SCRIPT,
+
+   RM_ATTRIBUTE_LAST
+} RM_Attribute;
 
 typedef enum {
-   ATTRIBUTE_RESOURCES_NONE,
+   RM_ATTRIBUTE_RESOURCES_NONE,
 
-   ATTRIBUTE_RESOURCES_COLORCLASS_DESCRIPTION,
-   ATTRIBUTE_RESOURCES_COLORCLASS_COLORS,
-   ATTRIBUTE_RESOURCES_STYLE_TAG_ADDED,
-   ATTRIBUTE_RESOURCES_STYLE_TAG_DELETED,
+   RM_ATTRIBUTE_RESOURCES_COLORCLASS_DESCRIPTION,
+   RM_ATTRIBUTE_RESOURCES_COLORCLASS_COLORS,
+   RM_ATTRIBUTE_RESOURCES_STYLE_TAG_ADDED,
+   RM_ATTRIBUTE_RESOURCES_STYLE_TAG_DELETED,
 
-   ATTRIBUTE_RESOURCES_LAST
-} Attribute_Resource;
+   RM_ATTRIBUTE_RESOURCES_LAST
+} RM_Attribute_Resources;
 
 
 void
diff --git a/src/bin/editor/editor_group.c b/src/bin/editor/editor_group.c
index 8e43527..358cd7d 100644
--- a/src/bin/editor/editor_group.c
+++ b/src/bin/editor/editor_group.c
@@ -126,7 +126,7 @@ editor_group_max_## VAL ##_set(Evas_Object *obj, Change 
*change, Eina_Bool merge
    int old_value; \
    int min_value; \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE_GROUP_MAX_##VAL_CAPS; \
+   RM_Attribute attribute = RM_ATTRIBUTE_GROUP_MAX_##VAL_CAPS; \
  \
    assert(obj != NULL); \
    assert(new_value >= 0); \
@@ -155,7 +155,7 @@ editor_group_max_## VAL ##_set(Evas_Object *obj, Change 
*change, Eina_Bool merge
      { \
         CRIT_ON_FAIL(edje_edit_group_max_## VAL ##_set(obj, new_value)); \
         _editor_project_changed(); \
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
@@ -171,7 +171,7 @@ editor_group_min_## VAL ##_set(Evas_Object *obj, Change 
*change, Eina_Bool merge
    int old_value; \
    int max_value; \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE_GROUP_MIN_##VAL_CAPS; \
+   RM_Attribute attribute = RM_ATTRIBUTE_GROUP_MIN_##VAL_CAPS; \
  \
    assert(obj != NULL); \
    assert(new_value >= 0); \
@@ -200,7 +200,7 @@ editor_group_min_## VAL ##_set(Evas_Object *obj, Change 
*change, Eina_Bool merge
      { \
         CRIT_ON_FAIL(edje_edit_group_min_## VAL ##_set(obj, new_value)); \
         _editor_project_changed(); \
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
@@ -213,7 +213,7 @@ editor_group_name_set(Evas_Object *edit_object, Change 
*change, Eina_Bool merge,
                       const char *new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_GROUP_NAME;
+   RM_Attribute attribute = RM_ATTRIBUTE_GROUP_NAME;
    assert(edit_object != NULL);
    assert(new_val != NULL);
    if (change)
@@ -236,7 +236,7 @@ editor_group_name_set(Evas_Object *edit_object, Change 
*change, Eina_Bool merge,
      {
         CRIT_ON_FAIL(edje_edit_group_name_set(edit_object, new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -246,7 +246,7 @@ editor_group_data_value_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
                             const char *item_name, const char *new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_GROUP_DATA_VALUE;
+   RM_Attribute attribute = RM_ATTRIBUTE_GROUP_DATA_VALUE;
    assert(edit_object != NULL);
    assert(item_name != NULL);
    assert(new_val != NULL);
@@ -271,7 +271,7 @@ editor_group_data_value_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
      {
         CRIT_ON_FAIL(edje_edit_group_data_value_set(edit_object, item_name, 
new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -282,7 +282,7 @@ editor_group_data_name_set(Evas_Object *edit_object, Change 
*change, Eina_Bool m
 {
    Diff *diff;
    Rename ren;
-   Attribute attribute = ATTRIBUTE_GROUP_DATA_NAME;
+   RM_Attribute attribute = RM_ATTRIBUTE_GROUP_DATA_NAME;
    assert(edit_object != NULL);
    assert(item_name != NULL);
    assert(new_val != NULL);
@@ -309,7 +309,7 @@ editor_group_data_name_set(Evas_Object *edit_object, Change 
*change, Eina_Bool m
         ren.old_name = item_name;
         ren.new_name = new_val;
         if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_GROUP_DATA_RENAMED, &ren);
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
diff --git a/src/bin/editor/editor_macro.h b/src/bin/editor/editor_macro.h
index 6eb4f6b..98afcba 100644
--- a/src/bin/editor/editor_macro.h
+++ b/src/bin/editor/editor_macro.h
@@ -17,13 +17,13 @@
  * along with this program; If not, see www.gnu.org/licenses/lgpl.html.
  */
 
-#define EDITOR_STATE_DOUBLE(FUNC, ATTRIBUTE) \
+#define EDITOR_STATE_DOUBLE(FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, double new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -53,18 +53,18 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
        CRIT_ON_FAIL(edje_edit_state_## FUNC ##_set(edit_object, part_name, 
state_name, state_val, new_val)); \
        _editor_project_changed(); \
         CRIT_ON_FAIL(editor_save(edit_object)); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_STATE_BOOL(FUNC, ATTRIBUTE) \
+#define EDITOR_STATE_BOOL(FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, Eina_Bool new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -94,18 +94,18 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
        CRIT_ON_FAIL(edje_edit_state_## FUNC ##_set(edit_object, part_name, 
state_name, state_val, new_val)); \
        _editor_project_changed(); \
        CRIT_ON_FAIL(editor_save(edit_object)); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_STATE_STRING(FUNC, ATTRIBUTE, SAVE) \
+#define EDITOR_STATE_STRING(FUNC, RM_ATTRIBUTE, SAVE) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, const char *new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -135,18 +135,18 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
        CRIT_ON_FAIL(edje_edit_state_## FUNC ##_set(edit_object, part_name, 
state_name, state_val, new_val)); \
        if (SAVE) CRIT_ON_FAIL(editor_save(edit_object)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_STATE_STRING_WITH_RESET(FUNC, ATTRIBUTE, SAVE, RESET) \
+#define EDITOR_STATE_STRING_WITH_RESET(FUNC, RM_ATTRIBUTE, SAVE, RESET) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, const char *new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -177,18 +177,18 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
       if (SAVE) CRIT_ON_FAIL(editor_save(edit_object)); \
       _editor_project_changed(); \
       if (!new_val) editor_state_## RESET ##_reset(edit_object, change, apply, 
part_name, state_name, state_val); \
-      if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+      if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
    } \
    return true; \
 }
 
-#define EDITOR_STATE_STRING_WITH_FALLBACK(FUNC, ATTRIBUTE, FALLBACK_VAL, SAVE) 
\
+#define EDITOR_STATE_STRING_WITH_FALLBACK(FUNC, RM_ATTRIBUTE, FALLBACK_VAL, 
SAVE) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, const char *new_val) \
 { \
    Diff *diff = NULL; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -230,7 +230,7 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
          } \
        if (SAVE) CRIT_ON_FAIL(editor_save(edit_object)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    else \
      { \
@@ -245,7 +245,7 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
    return true; \
 }
 
-#define EDITOR_STATE_INT_INT_INT_INT(FUNC, REAL_FUNC, ATTRIBUTE) \
+#define EDITOR_STATE_INT_INT_INT_INT(FUNC, REAL_FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, \
@@ -253,7 +253,7 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
 { \
    Diff *diff; \
    int o4, o5, o6, o7; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -288,19 +288,19 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
      { \
        CRIT_ON_FAIL(edje_edit_state_## REAL_FUNC ##_set(edit_object, 
part_name, state_name, state_val, n4, n5, n6, n7)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_STATE_INT_INT_INT_INT_INT(FUNC, REAL_FUNC, ATTRIBUTE, NUMBER) \
+#define EDITOR_STATE_INT_INT_INT_INT_INT(FUNC, REAL_FUNC, RM_ATTRIBUTE, 
NUMBER) \
 Eina_Bool \
 editor_state_## FUNC ##_## NUMBER ##_set(Evas_Object *edit_object, Change 
*change, Eina_Bool merge, Eina_Bool apply, \
                                  const char *part_name, const char 
*state_name, double state_val, int n4, int n5, int n6, int n7) \
 { \
    Diff *diff; \
    int o4, o5, o6, o7; \
-   Attribute attribute = ATTRIBUTE ##_## NUMBER; \
+   RM_Attribute attribute = RM_ATTRIBUTE ##_## NUMBER; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -336,18 +336,18 @@ editor_state_## FUNC ##_## NUMBER ##_set(Evas_Object 
*edit_object, Change *chang
         CRIT_ON_FAIL(edje_edit_state_## REAL_FUNC ##_set(edit_object, 
part_name, state_name, state_val, NUMBER - 1, n4, n5, n6, n7)); \
         _editor_project_changed(); \
         CRIT_ON_FAIL(editor_save(edit_object)); \
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_STATE_UCHAR(FUNC, ATTRIBUTE, SAVE) \
+#define EDITOR_STATE_UCHAR(FUNC, RM_ATTRIBUTE, SAVE) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, unsigned char new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -377,18 +377,18 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
        CRIT_ON_FAIL(edje_edit_state_## FUNC ##_set(edit_object, part_name, 
state_name, state_val, new_val)); \
        if (SAVE) CRIT_ON_FAIL(editor_save(edit_object)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_PART_BOOL(FUNC, ATTRIBUTE) \
+#define EDITOR_PART_BOOL(FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_part_## FUNC ##_set(Evas_Object *edit_object, Change *change, Eina_Bool 
merge, Eina_Bool apply, \
                            const char *part_name, Eina_Bool new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    if (change) \
@@ -412,18 +412,18 @@ editor_part_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool m
      { \
        CRIT_ON_FAIL(edje_edit_part_## FUNC ##_set(edit_object, part_name, 
new_val)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_PART_INT(FUNC, ATTRIBUTE) \
+#define EDITOR_PART_INT(FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_part_## FUNC ##_set(Evas_Object *edit_object, Change *change, Eina_Bool 
merge, Eina_Bool apply, \
                            const char *part_name, int new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    if (change) \
@@ -447,18 +447,18 @@ editor_part_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool m
      { \
        CRIT_ON_FAIL(edje_edit_part_## FUNC ##_set(edit_object, part_name, 
new_val)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_STRING_STRING(FUNC, REAL_FUNC, ATTRIBUTE) \
+#define EDITOR_STRING_STRING(FUNC, REAL_FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_## FUNC ##_set(Evas_Object *edit_object, Change *change, Eina_Bool 
merge, Eina_Bool apply, \
                       const char *name, const char *new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(name != NULL); \
    if (change) \
@@ -482,18 +482,18 @@ editor_## FUNC ##_set(Evas_Object *edit_object, Change 
*change, Eina_Bool merge,
      { \
        CRIT_ON_FAIL(edje_edit_## REAL_FUNC ##_set(edit_object, name, 
new_val)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_PART_ITEM_DOUBLE(FUNC, ATTRIBUTE) \
+#define EDITOR_PART_ITEM_DOUBLE(FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_part_item_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                                 const char *part_name, const char *item_name, 
double new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(item_name != NULL); \
@@ -521,18 +521,18 @@ editor_part_item_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_B
        CRIT_ON_FAIL(edje_edit_part_item_## FUNC ##_set(edit_object, part_name, 
item_name, new_val)); \
        CRIT_ON_FAIL(editor_save(edit_object)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_PART_ITEM_INT(FUNC, ATTRIBUTE, SAVE) \
+#define EDITOR_PART_ITEM_INT(FUNC, RM_ATTRIBUTE, SAVE) \
 Eina_Bool \
 editor_part_item_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                                 const char *part_name, const char *item_name, 
int new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(item_name != NULL); \
@@ -561,17 +561,17 @@ editor_part_item_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_B
        if (SAVE) CRIT_ON_FAIL(editor_save(edit_object)); \
        _editor_project_changed(); \
      } \
-   if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+   if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
    return true; \
 }
 
-#define EDITOR_PART_ITEM_USHORT(FUNC, ATTRIBUTE, SAVE) \
+#define EDITOR_PART_ITEM_USHORT(FUNC, RM_ATTRIBUTE, SAVE) \
 Eina_Bool \
 editor_part_item_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                                 const char *part_name, const char *item_name, 
unsigned short new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(item_name != NULL); \
@@ -599,18 +599,18 @@ editor_part_item_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_B
        CRIT_ON_FAIL(edje_edit_part_item_## FUNC ##_set(edit_object, part_name, 
item_name, new_val)); \
        if (SAVE) CRIT_ON_FAIL(editor_save(edit_object)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_STATE_INT(FUNC, ATTRIBUTE) \
+#define EDITOR_STATE_INT(FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, int new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -639,19 +639,19 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
      { \
        CRIT_ON_FAIL(edje_edit_state_## FUNC ##_set(edit_object, part_name, 
state_name, state_val, new_val)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
 TODO("delete macro _SAVE after fix issue in the edje_edit")
-#define EDITOR_STATE_INT_SAVE(FUNC, ATTRIBUTE) \
+#define EDITOR_STATE_INT_SAVE(FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, int new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -681,18 +681,18 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
        CRIT_ON_FAIL(edje_edit_state_## FUNC ##_set(edit_object, part_name, 
state_name, state_val, new_val)); \
        CRIT_ON_FAIL(editor_save(edit_object)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_STATE_DOUBLE_SAVE(FUNC, ATTRIBUTE) \
+#define EDITOR_STATE_DOUBLE_SAVE(FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, double new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -722,18 +722,18 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
        CRIT_ON_FAIL(edje_edit_state_## FUNC ##_set(edit_object, part_name, 
state_name, state_val, new_val)); \
        CRIT_ON_FAIL(editor_save(edit_object)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_PROGRAM_DOUBLE(FUNC, REAL_FUNC, ATTRIBUTE) \
+#define EDITOR_PROGRAM_DOUBLE(FUNC, REAL_FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_program_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                            const char *program, double new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(program != NULL); \
    if (change) \
@@ -757,18 +757,18 @@ editor_program_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Boo
      { \
        CRIT_ON_FAIL(edje_edit_program_## REAL_FUNC ##_set(edit_object, 
program, new_val)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-#define EDITOR_PROGRAM_STRING(FUNC, REAL_FUNC, ATTRIBUTE) \
+#define EDITOR_PROGRAM_STRING(FUNC, REAL_FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_program_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                            const char *program, const char *new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(program != NULL); \
    if (change) \
@@ -792,7 +792,7 @@ editor_program_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Boo
      { \
        CRIT_ON_FAIL(edje_edit_program_## REAL_FUNC ##_set(edit_object, 
program, new_val)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
        evas_object_smart_callback_call(ap.win, SIGNAL_EDITOR_PROGRAM_UPDATE, 
(void *)program); \
      } \
    return true; \
diff --git a/src/bin/editor/editor_part.c b/src/bin/editor/editor_part.c
index c3a7eef..50539ae 100644
--- a/src/bin/editor/editor_part.c
+++ b/src/bin/editor/editor_part.c
@@ -29,7 +29,7 @@ editor_part_text_effect_set(Evas_Object *edit_object, Change 
*change, Eina_Bool
                             const char *part_name, Edje_Text_Effect new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PART_TEXT_EFFECT;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_TEXT_EFFECT;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(new_val < EDJE_TEXT_EFFECT_LAST);
@@ -55,7 +55,7 @@ editor_part_text_effect_set(Evas_Object *edit_object, Change 
*change, Eina_Bool
      {
         CRIT_ON_FAIL(edje_edit_part_effect_set(edit_object, part_name, 
(new_val | edje_edit_part_text_shadow_direction_get(edit_object, part_name))));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -65,7 +65,7 @@ editor_part_text_shadow_direction_set(Evas_Object 
*edit_object, Change *change,
                                       const char *part_name, Edje_Text_Effect 
new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PART_TEXT_SHADOW_DIRECTION;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_TEXT_SHADOW_DIRECTION;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert((new_val & EDJE_TEXT_EFFECT_MASK_BASIC) == 0);
@@ -91,7 +91,7 @@ editor_part_text_shadow_direction_set(Evas_Object 
*edit_object, Change *change,
      {
         CRIT_ON_FAIL(edje_edit_part_effect_set(edit_object, part_name, 
(new_val | edje_edit_part_text_effect_get(edit_object, part_name))));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -101,7 +101,7 @@ editor_part_ignore_flags_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
                              const char *part_name, Evas_Event_Flags new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PART_IGNORE_FLAGS;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_IGNORE_FLAGS;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    if (change)
@@ -125,34 +125,34 @@ editor_part_ignore_flags_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
      {
         CRIT_ON_FAIL(edje_edit_part_ignore_flags_set(edit_object, part_name, 
new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
 
-EDITOR_PART_BOOL(mouse_events, ATTRIBUTE_PART_MOUSE_EVENTS)
-EDITOR_PART_BOOL(repeat_events, ATTRIBUTE_PART_REPEAT_EVENTS)
-EDITOR_PART_BOOL(scale, ATTRIBUTE_PART_SCALE)
-EDITOR_PART_BOOL(multiline, ATTRIBUTE_PART_MULTILINE)
-
-EDITOR_PART_INT(drag_count_x, ATTRIBUTE_PART_DRAG_COUNT_X)
-EDITOR_PART_INT(drag_count_y, ATTRIBUTE_PART_DRAG_COUNT_Y)
-EDITOR_PART_INT(drag_x, ATTRIBUTE_PART_DRAG_X)
-EDITOR_PART_INT(drag_y, ATTRIBUTE_PART_DRAG_Y)
-EDITOR_PART_INT(drag_step_x, ATTRIBUTE_PART_DRAG_STEP_X)
-EDITOR_PART_INT(drag_step_y, ATTRIBUTE_PART_DRAG_STEP_Y)
-
-EDITOR_STRING_STRING(part_clip_to, part_clip_to, ATTRIBUTE_PART_CLIP_TO)
-EDITOR_STRING_STRING(part_drag_confine, part_drag_confine, 
ATTRIBUTE_PART_DRAG_CONFINE)
-EDITOR_STRING_STRING(part_drag_threshold, part_drag_threshold, 
ATTRIBUTE_PART_DRAG_THRESHOLD)
-EDITOR_STRING_STRING(part_drag_event, part_drag_event, 
ATTRIBUTE_PART_DRAG_EVENT)
-EDITOR_STRING_STRING(part_group_source, part_source, 
ATTRIBUTE_PART_GROUP_SOURCE)
-EDITOR_STRING_STRING(part_textblock_selection_under, part_source, 
ATTRIBUTE_PART_TEXTBLOCK_SELECTION_UNDER)
-EDITOR_STRING_STRING(part_textblock_selection_over, part_source2, 
ATTRIBUTE_PART_TEXTBLOCK_SELECTION_OVER)
-EDITOR_STRING_STRING(part_textblock_cursor_under, part_source3, 
ATTRIBUTE_PART_TEXTBLOCK_CURSOR_UNDER)
-EDITOR_STRING_STRING(part_textblock_cursor_over, part_source4, 
ATTRIBUTE_PART_TEXTBLOCK_CURSOR_OVER)
-EDITOR_STRING_STRING(part_textblock_anchors_under, part_source5, 
ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_UNDER)
-EDITOR_STRING_STRING(part_textblock_anchors_over, part_source6, 
ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_OVER)
+EDITOR_PART_BOOL(mouse_events, RM_ATTRIBUTE_PART_MOUSE_EVENTS)
+EDITOR_PART_BOOL(repeat_events, RM_ATTRIBUTE_PART_REPEAT_EVENTS)
+EDITOR_PART_BOOL(scale, RM_ATTRIBUTE_PART_SCALE)
+EDITOR_PART_BOOL(multiline, RM_ATTRIBUTE_PART_MULTILINE)
+
+EDITOR_PART_INT(drag_count_x, RM_ATTRIBUTE_PART_DRAG_COUNT_X)
+EDITOR_PART_INT(drag_count_y, RM_ATTRIBUTE_PART_DRAG_COUNT_Y)
+EDITOR_PART_INT(drag_x, RM_ATTRIBUTE_PART_DRAG_X)
+EDITOR_PART_INT(drag_y, RM_ATTRIBUTE_PART_DRAG_Y)
+EDITOR_PART_INT(drag_step_x, RM_ATTRIBUTE_PART_DRAG_STEP_X)
+EDITOR_PART_INT(drag_step_y, RM_ATTRIBUTE_PART_DRAG_STEP_Y)
+
+EDITOR_STRING_STRING(part_clip_to, part_clip_to, RM_ATTRIBUTE_PART_CLIP_TO)
+EDITOR_STRING_STRING(part_drag_confine, part_drag_confine, 
RM_ATTRIBUTE_PART_DRAG_CONFINE)
+EDITOR_STRING_STRING(part_drag_threshold, part_drag_threshold, 
RM_ATTRIBUTE_PART_DRAG_THRESHOLD)
+EDITOR_STRING_STRING(part_drag_event, part_drag_event, 
RM_ATTRIBUTE_PART_DRAG_EVENT)
+EDITOR_STRING_STRING(part_group_source, part_source, 
RM_ATTRIBUTE_PART_GROUP_SOURCE)
+EDITOR_STRING_STRING(part_textblock_selection_under, part_source, 
RM_ATTRIBUTE_PART_TEXTBLOCK_SELECTION_UNDER)
+EDITOR_STRING_STRING(part_textblock_selection_over, part_source2, 
RM_ATTRIBUTE_PART_TEXTBLOCK_SELECTION_OVER)
+EDITOR_STRING_STRING(part_textblock_cursor_under, part_source3, 
RM_ATTRIBUTE_PART_TEXTBLOCK_CURSOR_UNDER)
+EDITOR_STRING_STRING(part_textblock_cursor_over, part_source4, 
RM_ATTRIBUTE_PART_TEXTBLOCK_CURSOR_OVER)
+EDITOR_STRING_STRING(part_textblock_anchors_under, part_source5, 
RM_ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_UNDER)
+EDITOR_STRING_STRING(part_textblock_anchors_over, part_source6, 
RM_ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_OVER)
 
 Eina_Bool
 editor_part_name_set(Evas_Object *edit_object, Change *change, Eina_Bool 
merge, Eina_Bool apply,
@@ -160,7 +160,7 @@ editor_part_name_set(Evas_Object *edit_object, Change 
*change, Eina_Bool merge,
 {
    Diff *diff;
    Rename ren;
-   Attribute attribute = ATTRIBUTE_PART_NAME;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_NAME;
    assert(edit_object != NULL);
    assert(name != NULL);
    assert(new_val != NULL);
@@ -187,7 +187,7 @@ editor_part_name_set(Evas_Object *edit_object, Change 
*change, Eina_Bool merge,
         ren.old_name = name;
         ren.new_name = new_val;
         if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_PART_RENAMED, &ren);
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -197,7 +197,7 @@ editor_part_item_aspect_mode_set(Evas_Object *edit_object, 
Change *change, Eina_
                                  const char *part_name, const char *item_name, 
Edje_Aspect_Control new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PART_ITEM_ASPECT_MODE;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_ITEM_ASPECT_MODE;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(item_name != NULL);
@@ -225,38 +225,38 @@ editor_part_item_aspect_mode_set(Evas_Object 
*edit_object, Change *change, Eina_
         CRIT_ON_FAIL(edje_edit_part_item_aspect_mode_set(edit_object, 
part_name, item_name, new_val));
         CRIT_ON_FAIL(editor_save(edit_object));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
 
-EDITOR_PART_ITEM_DOUBLE(align_x, ATTRIBUTE_PART_ITEM_ALIGN_X);
-EDITOR_PART_ITEM_DOUBLE(align_y, ATTRIBUTE_PART_ITEM_ALIGN_Y);
-EDITOR_PART_ITEM_DOUBLE(weight_x, ATTRIBUTE_PART_ITEM_WEIGHT_X);
-EDITOR_PART_ITEM_DOUBLE(weight_y, ATTRIBUTE_PART_ITEM_WEIGHT_Y);
-
-EDITOR_PART_ITEM_INT(aspect_h, ATTRIBUTE_PART_ITEM_ASPECT_H, false);
-EDITOR_PART_ITEM_INT(aspect_w, ATTRIBUTE_PART_ITEM_ASPECT_W, false);
-EDITOR_PART_ITEM_INT(max_h, ATTRIBUTE_PART_ITEM_MAX_H, false);
-EDITOR_PART_ITEM_INT(max_w, ATTRIBUTE_PART_ITEM_MAX_W, false);
-EDITOR_PART_ITEM_INT(min_h, ATTRIBUTE_PART_ITEM_MIN_H, false);
-EDITOR_PART_ITEM_INT(min_w, ATTRIBUTE_PART_ITEM_MIN_W, false);
-EDITOR_PART_ITEM_INT(prefer_h, ATTRIBUTE_PART_ITEM_PREFER_H, false);
-EDITOR_PART_ITEM_INT(prefer_w, ATTRIBUTE_PART_ITEM_PREFER_W, false);
-EDITOR_PART_ITEM_INT(spread_h, ATTRIBUTE_PART_ITEM_SPREAD_H, true);
-EDITOR_PART_ITEM_INT(spread_w, ATTRIBUTE_PART_ITEM_SPREAD_W, true);
-
-EDITOR_PART_ITEM_USHORT(span_col, ATTRIBUTE_PART_ITEM_SPAN_COL, true);
-EDITOR_PART_ITEM_USHORT(span_row, ATTRIBUTE_PART_ITEM_SPAN_ROW, true);
-EDITOR_PART_ITEM_USHORT(position_col, ATTRIBUTE_PART_ITEM_POSITION_COL, true);
-EDITOR_PART_ITEM_USHORT(position_row, ATTRIBUTE_PART_ITEM_POSITION_ROW, true);
+EDITOR_PART_ITEM_DOUBLE(align_x, RM_ATTRIBUTE_PART_ITEM_ALIGN_X);
+EDITOR_PART_ITEM_DOUBLE(align_y, RM_ATTRIBUTE_PART_ITEM_ALIGN_Y);
+EDITOR_PART_ITEM_DOUBLE(weight_x, RM_ATTRIBUTE_PART_ITEM_WEIGHT_X);
+EDITOR_PART_ITEM_DOUBLE(weight_y, RM_ATTRIBUTE_PART_ITEM_WEIGHT_Y);
+
+EDITOR_PART_ITEM_INT(aspect_h, RM_ATTRIBUTE_PART_ITEM_ASPECT_H, false);
+EDITOR_PART_ITEM_INT(aspect_w, RM_ATTRIBUTE_PART_ITEM_ASPECT_W, false);
+EDITOR_PART_ITEM_INT(max_h, RM_ATTRIBUTE_PART_ITEM_MAX_H, false);
+EDITOR_PART_ITEM_INT(max_w, RM_ATTRIBUTE_PART_ITEM_MAX_W, false);
+EDITOR_PART_ITEM_INT(min_h, RM_ATTRIBUTE_PART_ITEM_MIN_H, false);
+EDITOR_PART_ITEM_INT(min_w, RM_ATTRIBUTE_PART_ITEM_MIN_W, false);
+EDITOR_PART_ITEM_INT(prefer_h, RM_ATTRIBUTE_PART_ITEM_PREFER_H, false);
+EDITOR_PART_ITEM_INT(prefer_w, RM_ATTRIBUTE_PART_ITEM_PREFER_W, false);
+EDITOR_PART_ITEM_INT(spread_h, RM_ATTRIBUTE_PART_ITEM_SPREAD_H, true);
+EDITOR_PART_ITEM_INT(spread_w, RM_ATTRIBUTE_PART_ITEM_SPREAD_W, true);
+
+EDITOR_PART_ITEM_USHORT(span_col, RM_ATTRIBUTE_PART_ITEM_SPAN_COL, true);
+EDITOR_PART_ITEM_USHORT(span_row, RM_ATTRIBUTE_PART_ITEM_SPAN_ROW, true);
+EDITOR_PART_ITEM_USHORT(position_col, RM_ATTRIBUTE_PART_ITEM_POSITION_COL, 
true);
+EDITOR_PART_ITEM_USHORT(position_row, RM_ATTRIBUTE_PART_ITEM_POSITION_ROW, 
true);
 
 Eina_Bool
 editor_part_item_source_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply,
                             const char *part_name, const char *item_name, 
const char *new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PART_ITEM_SOURCE;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_ITEM_SOURCE;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(item_name != NULL);
@@ -285,7 +285,7 @@ editor_part_item_source_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
         CRIT_ON_FAIL(editor_save(edit_object));
         _editor_project_changed();
         CRIT_ON_FAIL(editor_save(edit_object));
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -298,7 +298,7 @@ editor_part_item_padding_left_set(Evas_Object *edit_object, 
Change *change, Eina
 {
    Diff *diff;
    int o3, o4, o5, o6;
-   Attribute attribute = ATTRIBUTE_PART_ITEM_PADDING_LEFT;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_ITEM_PADDING_LEFT;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(item_name != NULL);
@@ -326,7 +326,7 @@ editor_part_item_padding_left_set(Evas_Object *edit_object, 
Change *change, Eina
         CRIT_ON_FAIL(edje_edit_part_item_padding_set(edit_object, part_name, 
item_name, n3, o4, o5, o6));
         CRIT_ON_FAIL(editor_save(edit_object));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -337,7 +337,7 @@ editor_part_item_padding_right_set(Evas_Object 
*edit_object, Change *change, Ein
 {
    Diff *diff;
    int o3, o4, o5, o6;
-   Attribute attribute = ATTRIBUTE_PART_ITEM_PADDING_RIGHT;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_ITEM_PADDING_RIGHT;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(item_name != NULL);
@@ -365,7 +365,7 @@ editor_part_item_padding_right_set(Evas_Object 
*edit_object, Change *change, Ein
         CRIT_ON_FAIL(edje_edit_part_item_padding_set(edit_object, part_name, 
item_name, o3, n4, o5, o6));
         CRIT_ON_FAIL(editor_save(edit_object));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -376,7 +376,7 @@ editor_part_item_padding_top_set(Evas_Object *edit_object, 
Change *change, Eina_
 {
    Diff *diff;
    int o3, o4, o5, o6;
-   Attribute attribute = ATTRIBUTE_PART_ITEM_PADDING_TOP;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_ITEM_PADDING_TOP;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(item_name != NULL);
@@ -404,7 +404,7 @@ editor_part_item_padding_top_set(Evas_Object *edit_object, 
Change *change, Eina_
         CRIT_ON_FAIL(edje_edit_part_item_padding_set(edit_object, part_name, 
item_name, o3, o4, n5, o6));
         CRIT_ON_FAIL(editor_save(edit_object));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -415,7 +415,7 @@ editor_part_item_padding_bottom_set(Evas_Object 
*edit_object, Change *change, Ei
 {
    Diff *diff;
    int o3, o4, o5, o6;
-   Attribute attribute = ATTRIBUTE_PART_ITEM_PADDING_BOTTOM;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_ITEM_PADDING_BOTTOM;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(item_name != NULL);
@@ -443,7 +443,7 @@ editor_part_item_padding_bottom_set(Evas_Object 
*edit_object, Change *change, Ei
         CRIT_ON_FAIL(edje_edit_part_item_padding_set(edit_object, part_name, 
item_name, o3, o4, o5, n6));
         CRIT_ON_FAIL(editor_save(edit_object));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -455,7 +455,7 @@ editor_part_select_mode_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
                             const char *part_name, Edje_Edit_Select_Mode 
new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PART_SELECT_MODE;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_SELECT_MODE;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    if (change)
@@ -479,7 +479,7 @@ editor_part_select_mode_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
      {
         CRIT_ON_FAIL(edje_edit_part_select_mode_set(edit_object, part_name, 
new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -489,7 +489,7 @@ editor_part_entry_mode_set(Evas_Object *edit_object, Change 
*change, Eina_Bool m
                            const char *part_name, Edje_Edit_Entry_Mode new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PART_ENTRY_MODE;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_ENTRY_MODE;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    if (change)
@@ -513,7 +513,7 @@ editor_part_entry_mode_set(Evas_Object *edit_object, Change 
*change, Eina_Bool m
      {
         CRIT_ON_FAIL(edje_edit_part_entry_mode_set(edit_object, part_name, 
new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -523,7 +523,7 @@ editor_part_pointer_mode_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
                            const char *part_name, Evas_Object_Pointer_Mode 
new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PART_POINTER_MODE;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_POINTER_MODE;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    if (change)
@@ -547,7 +547,7 @@ editor_part_pointer_mode_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
      {
         CRIT_ON_FAIL(edje_edit_part_pointer_mode_set(edit_object, part_name, 
new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -557,7 +557,7 @@ editor_part_cursor_mode_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
                             const char *part_name, unsigned char new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PART_CURSOR_MODE;
+   RM_Attribute attribute = RM_ATTRIBUTE_PART_CURSOR_MODE;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    if (change)
@@ -581,7 +581,7 @@ editor_part_cursor_mode_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
      {
         CRIT_ON_FAIL(edje_edit_part_cursor_mode_set(edit_object, part_name, 
new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
diff --git a/src/bin/editor/editor_program.c b/src/bin/editor/editor_program.c
index d69a566..9e9307e 100644
--- a/src/bin/editor/editor_program.c
+++ b/src/bin/editor/editor_program.c
@@ -51,7 +51,7 @@ editor_program_transition_type_set(Evas_Object *edit_object, 
Change *change, Ein
                                    const char *program, Edje_Tween_Mode 
new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_TRANSITION_TYPE;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_TRANSITION_TYPE;
 
    assert(edit_object != NULL);
    assert(program != NULL);
@@ -80,7 +80,7 @@ editor_program_transition_type_set(Evas_Object *edit_object, 
Change *change, Ein
           new_val = new_val | EDJE_TWEEN_MODE_OPT_FROM_CURRENT;
         CRIT_ON_FAIL(edje_edit_program_transition_set(edit_object, program, 
new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -91,7 +91,7 @@ editor_program_transition_from_current_set(Evas_Object 
*edit_object, Change *cha
 {
    Diff *diff;
    Edje_Tween_Mode mode;
-   Attribute attribute = ATTRIBUTE_PROGRAM_TRANSITION_FROM_CURRENT;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_TRANSITION_FROM_CURRENT;
 
    assert(edit_object != NULL);
    assert(program != NULL);
@@ -120,7 +120,7 @@ editor_program_transition_from_current_set(Evas_Object 
*edit_object, Change *cha
           mode = mode | EDJE_TWEEN_MODE_OPT_FROM_CURRENT;
         CRIT_ON_FAIL(edje_edit_program_transition_set(edit_object, program, 
mode));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -130,7 +130,7 @@ editor_program_channel_set(Evas_Object *edit_object, Change 
*change, Eina_Bool m
                            const char *program, Edje_Channel new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_CHANNEL;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_CHANNEL;
    assert(edit_object != NULL);
    assert(program != NULL);
    if (change)
@@ -154,16 +154,16 @@ editor_program_channel_set(Evas_Object *edit_object, 
Change *change, Eina_Bool m
      {
         CRIT_ON_FAIL(edje_edit_program_channel_set(edit_object, program, 
new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
 
-EDITOR_PROGRAM_DOUBLE(tone_duration, tone_duration, 
ATTRIBUTE_PROGRAM_TONE_DURATION);
-EDITOR_PROGRAM_DOUBLE(in_from, in_from, ATTRIBUTE_PROGRAM_IN_FROM);
-EDITOR_PROGRAM_DOUBLE(in_range, in_range, ATTRIBUTE_PROGRAM_IN_RANGE);
-EDITOR_PROGRAM_DOUBLE(transition_time, transition_time, 
ATTRIBUTE_PROGRAM_TRANSITION_TIME);
-EDITOR_PROGRAM_DOUBLE(sample_speed, sample_speed, 
ATTRIBUTE_PROGRAM_SAMPLE_SPEED);
+EDITOR_PROGRAM_DOUBLE(tone_duration, tone_duration, 
RM_ATTRIBUTE_PROGRAM_TONE_DURATION);
+EDITOR_PROGRAM_DOUBLE(in_from, in_from, RM_ATTRIBUTE_PROGRAM_IN_FROM);
+EDITOR_PROGRAM_DOUBLE(in_range, in_range, RM_ATTRIBUTE_PROGRAM_IN_RANGE);
+EDITOR_PROGRAM_DOUBLE(transition_time, transition_time, 
RM_ATTRIBUTE_PROGRAM_TRANSITION_TIME);
+EDITOR_PROGRAM_DOUBLE(sample_speed, sample_speed, 
RM_ATTRIBUTE_PROGRAM_SAMPLE_SPEED);
 
 double
 editor_program_transition_factor_get(Evas_Object *edit_object, const char 
*program)
@@ -190,7 +190,7 @@ editor_program_transition_factor_set(Evas_Object 
*edit_object, Change *change, E
                                      const char *program, double new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_TRANSITION_FACTOR;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_TRANSITION_FACTOR;
    assert(edit_object != NULL);
    assert(program != NULL);
 
@@ -228,7 +228,7 @@ editor_program_transition_factor_set(Evas_Object 
*edit_object, Change *change, E
           }
 
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -251,7 +251,7 @@ editor_program_transition_gradient_set(Evas_Object 
*edit_object, Change *change,
                                        const char *program, double new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_TRANSITION_GRADIENT;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_TRANSITION_GRADIENT;
    assert(edit_object != NULL);
    assert(program != NULL);
 
@@ -278,7 +278,7 @@ editor_program_transition_gradient_set(Evas_Object 
*edit_object, Change *change,
      {
         CRIT_ON_FAIL(edje_edit_program_transition_value1_set(edit_object, 
program, new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -302,7 +302,7 @@ editor_program_transition_decay_set(Evas_Object 
*edit_object, Change *change, Ei
                                     const char *program, double new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_TRANSITION_DECAY;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_TRANSITION_DECAY;
    assert(edit_object != NULL);
    assert(program != NULL);
 
@@ -330,7 +330,7 @@ editor_program_transition_decay_set(Evas_Object 
*edit_object, Change *change, Ei
      {
         CRIT_ON_FAIL(edje_edit_program_transition_value1_set(edit_object, 
program, new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -353,7 +353,7 @@ editor_program_transition_bounces_set(Evas_Object 
*edit_object, Change *change,
                                       const char *program, double new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_TRANSITION_BOUNCES;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_TRANSITION_BOUNCES;
    assert(edit_object != NULL);
    assert(program != NULL);
 
@@ -380,7 +380,7 @@ editor_program_transition_bounces_set(Evas_Object 
*edit_object, Change *change,
      {
         CRIT_ON_FAIL(edje_edit_program_transition_value2_set(edit_object, 
program, new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -403,7 +403,7 @@ editor_program_transition_swings_set(Evas_Object 
*edit_object, Change *change, E
                                      const char *program, double new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_TRANSITION_SWINGS;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_TRANSITION_SWINGS;
    assert(edit_object != NULL);
    assert(program != NULL);
 
@@ -430,12 +430,12 @@ editor_program_transition_swings_set(Evas_Object 
*edit_object, Change *change, E
      {
         CRIT_ON_FAIL(edje_edit_program_transition_value2_set(edit_object, 
program, new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
 
-#define EDITOR_PROGRAM_TRANSITION_BEZIER(VAL, REAL_VAL, ATTRIBUTE) \
+#define EDITOR_PROGRAM_TRANSITION_BEZIER(VAL, REAL_VAL, RM_ATTRIBUTE) \
 double \
 editor_program_transition_bezier_## VAL ##_get(Evas_Object *edit_object, const 
char *program) \
 { \
@@ -454,7 +454,7 @@ editor_program_transition_bezier_## VAL ##_set(Evas_Object 
*edit_object, Change
                                                const char *program, double 
new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(program != NULL); \
  \
@@ -481,39 +481,39 @@ editor_program_transition_bezier_## VAL 
##_set(Evas_Object *edit_object, Change
      { \
        CRIT_ON_FAIL(edje_edit_program_transition_value## 
REAL_VAL##_set(edit_object, program, new_val)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-EDITOR_PROGRAM_TRANSITION_BEZIER(x1, 1, 
ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_X1);
-EDITOR_PROGRAM_TRANSITION_BEZIER(y1, 2, 
ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_Y1);
-EDITOR_PROGRAM_TRANSITION_BEZIER(x2, 3, 
ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_X2);
-EDITOR_PROGRAM_TRANSITION_BEZIER(y2, 4, 
ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_Y2);
+EDITOR_PROGRAM_TRANSITION_BEZIER(x1, 1, 
RM_ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_X1);
+EDITOR_PROGRAM_TRANSITION_BEZIER(y1, 2, 
RM_ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_Y1);
+EDITOR_PROGRAM_TRANSITION_BEZIER(x2, 3, 
RM_ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_X2);
+EDITOR_PROGRAM_TRANSITION_BEZIER(y2, 4, 
RM_ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_Y2);
 
-EDITOR_PROGRAM_STRING(filter_part, filter_part, ATTRIBUTE_PROGRAM_FILTER_PART);
-EDITOR_PROGRAM_STRING(filter_state, filter_state, 
ATTRIBUTE_PROGRAM_FILTER_STATE);
-EDITOR_PROGRAM_STRING(api_name, api_name, ATTRIBUTE_PROGRAM_API_NAME);
-EDITOR_PROGRAM_STRING(api_description, api_description, 
ATTRIBUTE_PROGRAM_API_DESCRIPTION);
-EDITOR_PROGRAM_STRING(sample_name, sample_name, ATTRIBUTE_PROGRAM_SAMPLE_NAME);
-EDITOR_PROGRAM_STRING(tone_name, tone_name, ATTRIBUTE_PROGRAM_TONE_NAME);
-EDITOR_PROGRAM_STRING(signal, signal, ATTRIBUTE_PROGRAM_SIGNAL);
-EDITOR_PROGRAM_STRING(source, source, ATTRIBUTE_PROGRAM_SOURCE);
+EDITOR_PROGRAM_STRING(filter_part, filter_part, 
RM_ATTRIBUTE_PROGRAM_FILTER_PART);
+EDITOR_PROGRAM_STRING(filter_state, filter_state, 
RM_ATTRIBUTE_PROGRAM_FILTER_STATE);
+EDITOR_PROGRAM_STRING(api_name, api_name, RM_ATTRIBUTE_PROGRAM_API_NAME);
+EDITOR_PROGRAM_STRING(api_description, api_description, 
RM_ATTRIBUTE_PROGRAM_API_DESCRIPTION);
+EDITOR_PROGRAM_STRING(sample_name, sample_name, 
RM_ATTRIBUTE_PROGRAM_SAMPLE_NAME);
+EDITOR_PROGRAM_STRING(tone_name, tone_name, RM_ATTRIBUTE_PROGRAM_TONE_NAME);
+EDITOR_PROGRAM_STRING(signal, signal, RM_ATTRIBUTE_PROGRAM_SIGNAL);
+EDITOR_PROGRAM_STRING(source, source, RM_ATTRIBUTE_PROGRAM_SOURCE);
 
-EDITOR_PROGRAM_STRING(state, state, ATTRIBUTE_PROGRAM_STATE);
-EDITOR_PROGRAM_DOUBLE(value, value, ATTRIBUTE_PROGRAM_VALUE);
+EDITOR_PROGRAM_STRING(state, state, RM_ATTRIBUTE_PROGRAM_STATE);
+EDITOR_PROGRAM_DOUBLE(value, value, RM_ATTRIBUTE_PROGRAM_VALUE);
 
-EDITOR_PROGRAM_STRING(emit_source, state2, ATTRIBUTE_PROGRAM_EMIT_SOURCE);
+EDITOR_PROGRAM_STRING(emit_source, state2, RM_ATTRIBUTE_PROGRAM_EMIT_SOURCE);
 
-EDITOR_PROGRAM_DOUBLE(drag_value_x, value, ATTRIBUTE_PROGRAM_DRAG_VALUE_X);
-EDITOR_PROGRAM_DOUBLE(drag_value_y, value2, ATTRIBUTE_PROGRAM_DRAG_VALUE_Y);
+EDITOR_PROGRAM_DOUBLE(drag_value_x, value, RM_ATTRIBUTE_PROGRAM_DRAG_VALUE_X);
+EDITOR_PROGRAM_DOUBLE(drag_value_y, value2, RM_ATTRIBUTE_PROGRAM_DRAG_VALUE_Y);
 
 Eina_Bool
 editor_program_emit_signal_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply,
                                const char *program, const char *new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_EMIT_SIGNAL;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_EMIT_SIGNAL;
    assert(edit_object != NULL);
    assert(program != NULL);
    if (change)
@@ -539,7 +539,7 @@ editor_program_emit_signal_set(Evas_Object *edit_object, 
Change *change, Eina_Bo
        if (!edje_edit_program_emit_source_get(edit_object, program))
          CRIT_ON_FAIL(edje_edit_program_state2_set(edit_object, program, ""));
        _editor_project_changed();
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
        evas_object_smart_callback_call(ap.win, SIGNAL_EDITOR_PROGRAM_UPDATE, 
(void *)program);
      }
    return true;
@@ -551,7 +551,7 @@ editor_program_name_set(Evas_Object *edit_object, Change 
*change, Eina_Bool merg
 {
    Diff *diff;
    Rename ren;
-   Attribute attribute = ATTRIBUTE_PROGRAM_NAME;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_NAME;
    assert(edit_object != NULL);
    assert(name != NULL);
    assert(new_val != NULL);
@@ -578,7 +578,7 @@ editor_program_name_set(Evas_Object *edit_object, Change 
*change, Eina_Bool merg
         ren.old_name = name;
         ren.new_name = new_val;
         if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_PROGRAM_RENAMED, &ren);
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -588,7 +588,7 @@ editor_program_target_add(Evas_Object *edit_object, Change 
*change, Eina_Bool me
                           const char *program_name, Eina_Stringshare *target)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_TARGET;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_TARGET;
    assert(edit_object != NULL);
    assert(program_name != NULL);
    assert(target != NULL);
@@ -613,7 +613,7 @@ editor_program_target_add(Evas_Object *edit_object, Change 
*change, Eina_Bool me
         CRIT_ON_FAIL(edje_edit_program_target_add(edit_object, program_name, 
target));
         _editor_project_changed();
         if (!_editor_signals_blocked)
-        evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -623,7 +623,7 @@ editor_program_target_del(Evas_Object *edit_object, Change 
*change, Eina_Bool me
                           const char *program_name, Eina_Stringshare *target)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_TARGET;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_TARGET;
    assert(edit_object != NULL);
    assert(program_name != NULL);
    if (change)
@@ -647,7 +647,7 @@ editor_program_target_del(Evas_Object *edit_object, Change 
*change, Eina_Bool me
         CRIT_ON_FAIL(edje_edit_program_target_del(edit_object, program_name, 
target));
         _editor_project_changed();
         if (!_editor_signals_blocked)
-        evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -657,7 +657,7 @@ editor_program_after_add(Evas_Object *edit_object, Change 
*change, Eina_Bool mer
                          const char *program_name, Eina_Stringshare *after)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_AFTER;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_AFTER;
    assert(edit_object != NULL);
    assert(program_name != NULL);
    assert(after != NULL);
@@ -682,7 +682,7 @@ editor_program_after_add(Evas_Object *edit_object, Change 
*change, Eina_Bool mer
         CRIT_ON_FAIL(edje_edit_program_after_add(edit_object, program_name, 
after));
         _editor_project_changed();
         if (!_editor_signals_blocked)
-          evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+          evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -692,7 +692,7 @@ editor_program_after_del(Evas_Object *edit_object, Change 
*change, Eina_Bool mer
                          const char *program_name, Eina_Stringshare *after)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_PROGRAM_AFTER;
+   RM_Attribute attribute = RM_ATTRIBUTE_PROGRAM_AFTER;
    assert(edit_object != NULL);
    assert(program_name != NULL);
    if (change)
@@ -716,7 +716,7 @@ editor_program_after_del(Evas_Object *edit_object, Change 
*change, Eina_Bool mer
         CRIT_ON_FAIL(edje_edit_program_after_del(edit_object, program_name, 
after));
         _editor_project_changed();
         if (!_editor_signals_blocked)
-          evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+          evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
diff --git a/src/bin/editor/editor_states.c b/src/bin/editor/editor_states.c
index 95645d7..3090935 100644
--- a/src/bin/editor/editor_states.c
+++ b/src/bin/editor/editor_states.c
@@ -24,34 +24,34 @@
 #include "diff.h"
 
 extern int _editor_signals_blocked;
-EDITOR_STATE_DOUBLE(rel1_relative_x, ATTRIBUTE_STATE_REL1_RELATIVE_X)
-EDITOR_STATE_DOUBLE(rel1_relative_y, ATTRIBUTE_STATE_REL1_RELATIVE_Y)
-EDITOR_STATE_DOUBLE(rel2_relative_x, ATTRIBUTE_STATE_REL2_RELATIVE_X)
-EDITOR_STATE_DOUBLE(rel2_relative_y, ATTRIBUTE_STATE_REL2_RELATIVE_Y)
+EDITOR_STATE_DOUBLE(rel1_relative_x, RM_ATTRIBUTE_STATE_REL1_RELATIVE_X)
+EDITOR_STATE_DOUBLE(rel1_relative_y, RM_ATTRIBUTE_STATE_REL1_RELATIVE_Y)
+EDITOR_STATE_DOUBLE(rel2_relative_x, RM_ATTRIBUTE_STATE_REL2_RELATIVE_X)
+EDITOR_STATE_DOUBLE(rel2_relative_y, RM_ATTRIBUTE_STATE_REL2_RELATIVE_Y)
 
-EDITOR_STATE_INT(rel1_offset_x, ATTRIBUTE_STATE_REL1_OFFSET_X)
-EDITOR_STATE_INT(rel1_offset_y, ATTRIBUTE_STATE_REL1_OFFSET_Y)
-EDITOR_STATE_INT(rel2_offset_x, ATTRIBUTE_STATE_REL2_OFFSET_X)
-EDITOR_STATE_INT(rel2_offset_y, ATTRIBUTE_STATE_REL2_OFFSET_Y)
+EDITOR_STATE_INT(rel1_offset_x, RM_ATTRIBUTE_STATE_REL1_OFFSET_X)
+EDITOR_STATE_INT(rel1_offset_y, RM_ATTRIBUTE_STATE_REL1_OFFSET_Y)
+EDITOR_STATE_INT(rel2_offset_x, RM_ATTRIBUTE_STATE_REL2_OFFSET_X)
+EDITOR_STATE_INT(rel2_offset_y, RM_ATTRIBUTE_STATE_REL2_OFFSET_Y)
 
-EDITOR_STATE_DOUBLE(aspect_min, ATTRIBUTE_STATE_ASPECT_MIN)
-EDITOR_STATE_DOUBLE(aspect_max, ATTRIBUTE_STATE_ASPECT_MAX)
+EDITOR_STATE_DOUBLE(aspect_min, RM_ATTRIBUTE_STATE_ASPECT_MIN)
+EDITOR_STATE_DOUBLE(aspect_max, RM_ATTRIBUTE_STATE_ASPECT_MAX)
 
-EDITOR_STATE_DOUBLE(fill_origin_relative_x, 
ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_X)
-EDITOR_STATE_DOUBLE(fill_origin_relative_y, 
ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_Y)
-EDITOR_STATE_INT(fill_origin_offset_x, ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_X)
-EDITOR_STATE_INT(fill_origin_offset_y, ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_Y)
+EDITOR_STATE_DOUBLE(fill_origin_relative_x, 
RM_ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_X)
+EDITOR_STATE_DOUBLE(fill_origin_relative_y, 
RM_ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_Y)
+EDITOR_STATE_INT(fill_origin_offset_x, RM_ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_X)
+EDITOR_STATE_INT(fill_origin_offset_y, RM_ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_Y)
 
-EDITOR_STATE_DOUBLE(fill_size_relative_x, ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_X)
-EDITOR_STATE_DOUBLE(fill_size_relative_y, ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_Y)
-EDITOR_STATE_INT(fill_size_offset_x, ATTRIBUTE_STATE_FILL_SIZE_OFFSET_X)
-EDITOR_STATE_INT(fill_size_offset_y, ATTRIBUTE_STATE_FILL_SIZE_OFFSET_Y)
+EDITOR_STATE_DOUBLE(fill_size_relative_x, 
RM_ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_X)
+EDITOR_STATE_DOUBLE(fill_size_relative_y, 
RM_ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_Y)
+EDITOR_STATE_INT(fill_size_offset_x, RM_ATTRIBUTE_STATE_FILL_SIZE_OFFSET_X)
+EDITOR_STATE_INT(fill_size_offset_y, RM_ATTRIBUTE_STATE_FILL_SIZE_OFFSET_Y)
 
-EDITOR_STATE_DOUBLE_SAVE(container_align_x, ATTRIBUTE_STATE_CONTAINER_ALIGN_X)
-EDITOR_STATE_DOUBLE_SAVE(container_align_y, ATTRIBUTE_STATE_CONTAINER_ALIGN_Y)
+EDITOR_STATE_DOUBLE_SAVE(container_align_x, 
RM_ATTRIBUTE_STATE_CONTAINER_ALIGN_X)
+EDITOR_STATE_DOUBLE_SAVE(container_align_y, 
RM_ATTRIBUTE_STATE_CONTAINER_ALIGN_Y)
 
-EDITOR_STATE_DOUBLE(minmul_h, ATTRIBUTE_STATE_MINMUL_H)
-EDITOR_STATE_DOUBLE(minmul_w, ATTRIBUTE_STATE_MINMUL_W)
+EDITOR_STATE_DOUBLE(minmul_h, RM_ATTRIBUTE_STATE_MINMUL_H)
+EDITOR_STATE_DOUBLE(minmul_w, RM_ATTRIBUTE_STATE_MINMUL_W)
 
 #define MAX_SET(VAL, VAL_CAPS) \
 Eina_Bool \
@@ -61,7 +61,7 @@ editor_state_max_## VAL ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bo
    int old_value; \
    int min_value; \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE_STATE_MAX_##VAL_CAPS; \
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_MAX_##VAL_CAPS; \
  \
    assert(edit_object != NULL); \
    assert(new_value >= -1); \
@@ -96,7 +96,7 @@ editor_state_max_## VAL ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bo
      { \
         CRIT_ON_FAIL(edje_edit_state_max_## VAL ##_set(edit_object, part_name, 
state_name, state_val, new_value)); \
         _editor_project_changed(); \
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
@@ -112,7 +112,7 @@ editor_state_min_## VAL ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bo
    int old_value; \
    int max_value; \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE_STATE_MIN_##VAL_CAPS; \
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_MIN_##VAL_CAPS; \
  \
    assert(edit_object != NULL); \
    assert(new_value >= 0); \
@@ -147,7 +147,7 @@ editor_state_min_## VAL ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bo
      { \
         CRIT_ON_FAIL(edje_edit_state_min_## VAL ##_set(edit_object, part_name, 
state_name, state_val, new_value)); \
         _editor_project_changed(); \
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
@@ -155,13 +155,13 @@ editor_state_min_## VAL ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bo
 MIN_SET(w, W)
 MIN_SET(h, H)
 
-#define ALIGN_SET(FUNC, ATTRIBUTE) \
+#define ALIGN_SET(FUNC, RM_ATTRIBUTE) \
 Eina_Bool \
 editor_state_## FUNC ##_set(Evas_Object *edit_object, Change *change, 
Eina_Bool merge, Eina_Bool apply, \
                             const char *part_name, const char *state_name, 
double state_val, double new_val) \
 { \
    Diff *diff; \
-   Attribute attribute = ATTRIBUTE; \
+   RM_Attribute attribute = RM_ATTRIBUTE; \
    assert(edit_object != NULL); \
    assert(part_name != NULL); \
    assert(state_name != NULL); \
@@ -190,37 +190,37 @@ editor_state_## FUNC ##_set(Evas_Object *edit_object, 
Change *change, Eina_Bool
      { \
        CRIT_ON_FAIL(edje_edit_state_## FUNC ##_set(edit_object, part_name, 
state_name, state_val, new_val)); \
        _editor_project_changed(); \
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute); \
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute); \
      } \
    return true; \
 }
 
-ALIGN_SET(align_x, ATTRIBUTE_STATE_ALIGN_X)
-ALIGN_SET(align_y, ATTRIBUTE_STATE_ALIGN_Y)
-
-EDITOR_STATE_BOOL(fixed_h, ATTRIBUTE_STATE_FIXED_H)
-EDITOR_STATE_BOOL(fixed_w, ATTRIBUTE_STATE_FIXED_W)
-EDITOR_STATE_BOOL(fill_smooth, ATTRIBUTE_STATE_FILL_SMOOTH)
-EDITOR_STATE_BOOL(visible, ATTRIBUTE_STATE_VISIBLE)
-EDITOR_STATE_BOOL(container_min_h, ATTRIBUTE_STATE_CONTAINER_MIN_H)
-EDITOR_STATE_BOOL(container_min_v, ATTRIBUTE_STATE_CONTAINER_MIN_V)
-
-EDITOR_STATE_STRING_WITH_RESET(rel1_to_x, ATTRIBUTE_STATE_REL1_TO_X, true, 
rel1_relative_x)
-EDITOR_STATE_STRING_WITH_RESET(rel1_to_y, ATTRIBUTE_STATE_REL1_TO_Y, true, 
rel1_relative_y)
-EDITOR_STATE_STRING_WITH_RESET(rel2_to_x, ATTRIBUTE_STATE_REL2_TO_X, true, 
rel2_relative_x)
-EDITOR_STATE_STRING_WITH_RESET(rel2_to_y, ATTRIBUTE_STATE_REL2_TO_Y, true, 
rel2_relative_y)
-EDITOR_STATE_STRING(proxy_source, ATTRIBUTE_STATE_PROXY_SOURCE, true)
-
-EDITOR_STATE_BOOL(map_on, ATTRIBUTE_STATE_MAP_ON)
-EDITOR_STATE_BOOL(map_perspective_on, ATTRIBUTE_STATE_MAP_PERSPECTIVE_ON)
-EDITOR_STATE_STRING(map_perspective, ATTRIBUTE_STATE_MAP_PERSPECTIVE, true)
-EDITOR_STATE_STRING(map_light, ATTRIBUTE_STATE_MAP_LIGHT, true)
-EDITOR_STATE_BOOL(map_smooth, ATTRIBUTE_STATE_MAP_SMOOTH)
-EDITOR_STATE_BOOL(map_alpha, ATTRIBUTE_STATE_MAP_ALPHA)
-EDITOR_STATE_BOOL(map_backface_cull, ATTRIBUTE_STATE_MAP_BACKFACE_CULL)
-EDITOR_STATE_INT(map_perspective_focal, ATTRIBUTE_STATE_MAP_PERSPECTIVE_FOCAL)
-EDITOR_STATE_INT(map_perspective_zplane, 
ATTRIBUTE_STATE_MAP_PERSPECTIVE_ZPLANE)
-EDITOR_STATE_STRING(map_rotation_center, ATTRIBUTE_STATE_MAP_ROTATION_CENTER, 
true)
+ALIGN_SET(align_x, RM_ATTRIBUTE_STATE_ALIGN_X)
+ALIGN_SET(align_y, RM_ATTRIBUTE_STATE_ALIGN_Y)
+
+EDITOR_STATE_BOOL(fixed_h, RM_ATTRIBUTE_STATE_FIXED_H)
+EDITOR_STATE_BOOL(fixed_w, RM_ATTRIBUTE_STATE_FIXED_W)
+EDITOR_STATE_BOOL(fill_smooth, RM_ATTRIBUTE_STATE_FILL_SMOOTH)
+EDITOR_STATE_BOOL(visible, RM_ATTRIBUTE_STATE_VISIBLE)
+EDITOR_STATE_BOOL(container_min_h, RM_ATTRIBUTE_STATE_CONTAINER_MIN_H)
+EDITOR_STATE_BOOL(container_min_v, RM_ATTRIBUTE_STATE_CONTAINER_MIN_V)
+
+EDITOR_STATE_STRING_WITH_RESET(rel1_to_x, RM_ATTRIBUTE_STATE_REL1_TO_X, true, 
rel1_relative_x)
+EDITOR_STATE_STRING_WITH_RESET(rel1_to_y, RM_ATTRIBUTE_STATE_REL1_TO_Y, true, 
rel1_relative_y)
+EDITOR_STATE_STRING_WITH_RESET(rel2_to_x, RM_ATTRIBUTE_STATE_REL2_TO_X, true, 
rel2_relative_x)
+EDITOR_STATE_STRING_WITH_RESET(rel2_to_y, RM_ATTRIBUTE_STATE_REL2_TO_Y, true, 
rel2_relative_y)
+EDITOR_STATE_STRING(proxy_source, RM_ATTRIBUTE_STATE_PROXY_SOURCE, true)
+
+EDITOR_STATE_BOOL(map_on, RM_ATTRIBUTE_STATE_MAP_ON)
+EDITOR_STATE_BOOL(map_perspective_on, RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE_ON)
+EDITOR_STATE_STRING(map_perspective, RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE, true)
+EDITOR_STATE_STRING(map_light, RM_ATTRIBUTE_STATE_MAP_LIGHT, true)
+EDITOR_STATE_BOOL(map_smooth, RM_ATTRIBUTE_STATE_MAP_SMOOTH)
+EDITOR_STATE_BOOL(map_alpha, RM_ATTRIBUTE_STATE_MAP_ALPHA)
+EDITOR_STATE_BOOL(map_backface_cull, RM_ATTRIBUTE_STATE_MAP_BACKFACE_CULL)
+EDITOR_STATE_INT(map_perspective_focal, 
RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE_FOCAL)
+EDITOR_STATE_INT(map_perspective_zplane, 
RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE_ZPLANE)
+EDITOR_STATE_STRING(map_rotation_center, 
RM_ATTRIBUTE_STATE_MAP_ROTATION_CENTER, true)
 
 //map_rotation (3 values)
 Eina_Bool
@@ -229,7 +229,7 @@ editor_state_map_rotation_x_set(Evas_Object *edit_object, 
Change *change, Eina_B
 {
    Diff *diff;
    double o4, o5, o6;
-   Attribute attribute = ATTRIBUTE_STATE_MAP_ROTATION_X;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_MAP_ROTATION_X;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(state_name != NULL);
@@ -258,7 +258,7 @@ editor_state_map_rotation_x_set(Evas_Object *edit_object, 
Change *change, Eina_B
      {
         CRIT_ON_FAIL(edje_edit_state_map_rotation_set(edit_object, part_name, 
state_name, state_val, n4, o5, o6));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -269,7 +269,7 @@ editor_state_map_rotation_y_set(Evas_Object *edit_object, 
Change *change, Eina_B
 {
    Diff *diff;
    double o4, o5, o6;
-   Attribute attribute = ATTRIBUTE_STATE_MAP_ROTATION_Y;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_MAP_ROTATION_Y;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(state_name != NULL);
@@ -298,7 +298,7 @@ editor_state_map_rotation_y_set(Evas_Object *edit_object, 
Change *change, Eina_B
      {
         CRIT_ON_FAIL(edje_edit_state_map_rotation_set(edit_object, part_name, 
state_name, state_val, o4, n5, o6));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -309,7 +309,7 @@ editor_state_map_rotation_z_set(Evas_Object *edit_object, 
Change *change, Eina_B
 {
    Diff *diff;
    double o4, o5, o6;
-   Attribute attribute = ATTRIBUTE_STATE_MAP_ROTATION_Z;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_MAP_ROTATION_Z;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(state_name != NULL);
@@ -338,28 +338,28 @@ editor_state_map_rotation_z_set(Evas_Object *edit_object, 
Change *change, Eina_B
      {
         CRIT_ON_FAIL(edje_edit_state_map_rotation_set(edit_object, part_name, 
state_name, state_val, o4, o5, n6));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
 
-EDITOR_STATE_INT_INT_INT_INT_INT(map_point_color, map_point_color, 
ATTRIBUTE_STATE_MAP_POINT_COLOR, 1)
-EDITOR_STATE_INT_INT_INT_INT_INT(map_point_color, map_point_color, 
ATTRIBUTE_STATE_MAP_POINT_COLOR, 2)
-EDITOR_STATE_INT_INT_INT_INT_INT(map_point_color, map_point_color, 
ATTRIBUTE_STATE_MAP_POINT_COLOR, 3)
-EDITOR_STATE_INT_INT_INT_INT_INT(map_point_color, map_point_color, 
ATTRIBUTE_STATE_MAP_POINT_COLOR, 4)
+EDITOR_STATE_INT_INT_INT_INT_INT(map_point_color, map_point_color, 
RM_ATTRIBUTE_STATE_MAP_POINT_COLOR, 1)
+EDITOR_STATE_INT_INT_INT_INT_INT(map_point_color, map_point_color, 
RM_ATTRIBUTE_STATE_MAP_POINT_COLOR, 2)
+EDITOR_STATE_INT_INT_INT_INT_INT(map_point_color, map_point_color, 
RM_ATTRIBUTE_STATE_MAP_POINT_COLOR, 3)
+EDITOR_STATE_INT_INT_INT_INT_INT(map_point_color, map_point_color, 
RM_ATTRIBUTE_STATE_MAP_POINT_COLOR, 4)
 
 TODO("Fix edje_edit API")
-//EDITOR_STATE_STRING(box_layout, ATTRIBUTE_STATE_BOX_LAYOUT)
-//EDITOR_STATE_STRING(box_alt_layout, ATTRIBUTE_STATE_BOX_ALT_LAYOUT)
+//EDITOR_STATE_STRING(box_layout, RM_ATTRIBUTE_STATE_BOX_LAYOUT)
+//EDITOR_STATE_STRING(box_alt_layout, RM_ATTRIBUTE_STATE_BOX_ALT_LAYOUT)
 
-EDITOR_STATE_STRING(color_class, ATTRIBUTE_STATE_COLOR_CLASS, true)
+EDITOR_STATE_STRING(color_class, RM_ATTRIBUTE_STATE_COLOR_CLASS, true)
 
 TODO("Replace with image stub")
-EDITOR_STATE_STRING_WITH_FALLBACK(image, ATTRIBUTE_STATE_IMAGE, NULL, false)
+EDITOR_STATE_STRING_WITH_FALLBACK(image, RM_ATTRIBUTE_STATE_IMAGE, NULL, false)
 
-EDITOR_STATE_INT_INT_INT_INT(color, color, ATTRIBUTE_STATE_COLOR)
-EDITOR_STATE_INT_INT_INT_INT(outline_color, color2, 
ATTRIBUTE_STATE_OUTLINE_COLOR)
-EDITOR_STATE_INT_INT_INT_INT(shadow_color, color3, 
ATTRIBUTE_STATE_SHADOW_COLOR)
+EDITOR_STATE_INT_INT_INT_INT(color, color, RM_ATTRIBUTE_STATE_COLOR)
+EDITOR_STATE_INT_INT_INT_INT(outline_color, color2, 
RM_ATTRIBUTE_STATE_OUTLINE_COLOR)
+EDITOR_STATE_INT_INT_INT_INT(shadow_color, color3, 
RM_ATTRIBUTE_STATE_SHADOW_COLOR)
 
 /* IMAGE BORDER */
 
@@ -369,7 +369,7 @@ editor_state_image_border_left_set(Evas_Object 
*edit_object, Change *change, Ein
 {
    Diff *diff;
    int o4, o5, o6, o7;
-   Attribute attribute = ATTRIBUTE_STATE_IMAGE_BORDER_LEFT;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_IMAGE_BORDER_LEFT;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(state_name != NULL);
@@ -399,7 +399,7 @@ editor_state_image_border_left_set(Evas_Object 
*edit_object, Change *change, Ein
         CRIT_ON_FAIL(edje_edit_state_image_border_set(edit_object, part_name, 
state_name, state_val, n4, o5, o6, o7));
         CRIT_ON_FAIL(editor_save(edit_object));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -410,7 +410,7 @@ editor_state_image_border_right_set(Evas_Object 
*edit_object, Change *change, Ei
 {
    Diff *diff;
    int o4, o5, o6, o7;
-   Attribute attribute = ATTRIBUTE_STATE_IMAGE_BORDER_RIGHT;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_IMAGE_BORDER_RIGHT;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(state_name != NULL);
@@ -440,7 +440,7 @@ editor_state_image_border_right_set(Evas_Object 
*edit_object, Change *change, Ei
         CRIT_ON_FAIL(edje_edit_state_image_border_set(edit_object, part_name, 
state_name, state_val, o4, n5, o6, o7));
         CRIT_ON_FAIL(editor_save(edit_object));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -451,7 +451,7 @@ editor_state_image_border_top_set(Evas_Object *edit_object, 
Change *change, Eina
 {
    Diff *diff;
    int o4, o5, o6, o7;
-   Attribute attribute = ATTRIBUTE_STATE_IMAGE_BORDER_TOP;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_IMAGE_BORDER_TOP;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(state_name != NULL);
@@ -481,7 +481,7 @@ editor_state_image_border_top_set(Evas_Object *edit_object, 
Change *change, Eina
         CRIT_ON_FAIL(edje_edit_state_image_border_set(edit_object, part_name, 
state_name, state_val, o4, o5, n6, o7));
         CRIT_ON_FAIL(editor_save(edit_object));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -492,7 +492,7 @@ editor_state_image_border_bottom_set(Evas_Object 
*edit_object, Change *change, E
 {
    Diff *diff;
    int o4, o5, o6, o7;
-   Attribute attribute = ATTRIBUTE_STATE_IMAGE_BORDER_BOTTOM;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_IMAGE_BORDER_BOTTOM;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(state_name != NULL);
@@ -522,20 +522,20 @@ editor_state_image_border_bottom_set(Evas_Object 
*edit_object, Change *change, E
         CRIT_ON_FAIL(edje_edit_state_image_border_set(edit_object, part_name, 
state_name, state_val, o4, o5, o6, n7));
         CRIT_ON_FAIL(editor_save(edit_object));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
 
 /**********************/
 
-EDITOR_STATE_UCHAR(image_border_fill, ATTRIBUTE_STATE_IMAGE_BORDER_FILL, true)
-EDITOR_STATE_UCHAR(fill_type, ATTRIBUTE_STATE_FILL_TYPE, false)
-EDITOR_STATE_UCHAR(aspect_pref, ATTRIBUTE_STATE_ASPECT_PREF, false)
-EDITOR_STATE_UCHAR(table_homogeneous, ATTRIBUTE_STATE_TABLE_HOMOGENEOUS, false)
+EDITOR_STATE_UCHAR(image_border_fill, RM_ATTRIBUTE_STATE_IMAGE_BORDER_FILL, 
true)
+EDITOR_STATE_UCHAR(fill_type, RM_ATTRIBUTE_STATE_FILL_TYPE, false)
+EDITOR_STATE_UCHAR(aspect_pref, RM_ATTRIBUTE_STATE_ASPECT_PREF, false)
+EDITOR_STATE_UCHAR(table_homogeneous, RM_ATTRIBUTE_STATE_TABLE_HOMOGENEOUS, 
false)
 
-EDITOR_STATE_INT_SAVE(container_padding_x, ATTRIBUTE_STATE_CONTAINER_PADING_X)
-EDITOR_STATE_INT_SAVE(container_padding_y, ATTRIBUTE_STATE_CONTAINER_PADING_Y)
+EDITOR_STATE_INT_SAVE(container_padding_x, 
RM_ATTRIBUTE_STATE_CONTAINER_PADING_X)
+EDITOR_STATE_INT_SAVE(container_padding_y, 
RM_ATTRIBUTE_STATE_CONTAINER_PADING_Y)
 
 Eina_Bool
 editor_state_tween_add(Evas_Object *edit_object, Change *change, Eina_Bool 
merge, Eina_Bool apply,
@@ -543,7 +543,7 @@ editor_state_tween_add(Evas_Object *edit_object, Change 
*change, Eina_Bool merge
                        Eina_Stringshare *name)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_STATE_IMAGE_TWEEN;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_IMAGE_TWEEN;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(state_name != NULL);
@@ -572,7 +572,7 @@ editor_state_tween_add(Evas_Object *edit_object, Change 
*change, Eina_Bool merge
         CRIT_ON_FAIL(edje_edit_state_tween_add(edit_object, part_name, 
state_name, state_val, name));
         _editor_project_changed();
         if (!_editor_signals_blocked)
-          evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+          evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
@@ -582,7 +582,7 @@ editor_state_tween_del(Evas_Object *edit_object, Change 
*change, Eina_Bool merge
                        Eina_Stringshare *name)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_STATE_IMAGE_TWEEN;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_IMAGE_TWEEN;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(state_name != NULL);
@@ -611,7 +611,7 @@ editor_state_tween_del(Evas_Object *edit_object, Change 
*change, Eina_Bool merge
         CRIT_ON_FAIL(edje_edit_state_tween_del(edit_object, part_name, 
state_name, state_val, name));
         _editor_project_changed();
         if (!_editor_signals_blocked)
-          evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+          evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
diff --git a/src/bin/editor/editor_text.c b/src/bin/editor/editor_text.c
index 837b9c8..5ea80e5 100644
--- a/src/bin/editor/editor_text.c
+++ b/src/bin/editor/editor_text.c
@@ -24,17 +24,17 @@
 #include "change.h"
 
 extern int _editor_signals_blocked;
-EDITOR_STATE_DOUBLE(text_align_x, ATTRIBUTE_STATE_TEXT_ALIGN_X)
-EDITOR_STATE_DOUBLE(text_align_y, ATTRIBUTE_STATE_TEXT_ALIGN_Y)
+EDITOR_STATE_DOUBLE(text_align_x, RM_ATTRIBUTE_STATE_TEXT_ALIGN_X)
+EDITOR_STATE_DOUBLE(text_align_y, RM_ATTRIBUTE_STATE_TEXT_ALIGN_Y)
 
-EDITOR_STATE_DOUBLE(text_elipsis, ATTRIBUTE_STATE_TEXT_ELIPSIS)
+EDITOR_STATE_DOUBLE(text_elipsis, RM_ATTRIBUTE_STATE_TEXT_ELIPSIS)
 
 Eina_Bool
 editor_state_text_size_set(Evas_Object *edit_object, Change *change, Eina_Bool 
merge, Eina_Bool apply,
                            const char *part_name, const char *state_name, 
double state_val, int new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_STATE_TEXT_SIZE;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_TEXT_SIZE;
 
    assert(edit_object != NULL);
    assert(part_name != NULL);
@@ -66,31 +66,31 @@ editor_state_text_size_set(Evas_Object *edit_object, Change 
*change, Eina_Bool m
      {
         CRIT_ON_FAIL(edje_edit_state_text_size_set(edit_object, part_name, 
state_name, state_val, new_val));
         _editor_project_changed();
-        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+        if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
 
-EDITOR_STATE_BOOL(text_fit_x, ATTRIBUTE_STATE_TEXT_FIT_X)
-EDITOR_STATE_BOOL(text_fit_y, ATTRIBUTE_STATE_TEXT_FIT_Y)
-EDITOR_STATE_BOOL(text_max_x, ATTRIBUTE_STATE_TEXT_MAX_X)
-EDITOR_STATE_BOOL(text_max_y, ATTRIBUTE_STATE_TEXT_MAX_Y)
-EDITOR_STATE_BOOL(text_min_x, ATTRIBUTE_STATE_TEXT_MIN_X)
-EDITOR_STATE_BOOL(text_min_y, ATTRIBUTE_STATE_TEXT_MIN_Y)
+EDITOR_STATE_BOOL(text_fit_x, RM_ATTRIBUTE_STATE_TEXT_FIT_X)
+EDITOR_STATE_BOOL(text_fit_y, RM_ATTRIBUTE_STATE_TEXT_FIT_Y)
+EDITOR_STATE_BOOL(text_max_x, RM_ATTRIBUTE_STATE_TEXT_MAX_X)
+EDITOR_STATE_BOOL(text_max_y, RM_ATTRIBUTE_STATE_TEXT_MAX_Y)
+EDITOR_STATE_BOOL(text_min_x, RM_ATTRIBUTE_STATE_TEXT_MIN_X)
+EDITOR_STATE_BOOL(text_min_y, RM_ATTRIBUTE_STATE_TEXT_MIN_Y)
 
-EDITOR_STATE_STRING(text_source, ATTRIBUTE_STATE_TEXT_SOURCE, true)
-EDITOR_STATE_STRING(text_text_source, ATTRIBUTE_STATE_TEXT_TEXT_SOURCE, true)
+EDITOR_STATE_STRING(text_source, RM_ATTRIBUTE_STATE_TEXT_SOURCE, true)
+EDITOR_STATE_STRING(text_text_source, RM_ATTRIBUTE_STATE_TEXT_TEXT_SOURCE, 
true)
 
-EDITOR_STATE_STRING_WITH_FALLBACK(font, ATTRIBUTE_STATE_FONT, NULL, false)
+EDITOR_STATE_STRING_WITH_FALLBACK(font, RM_ATTRIBUTE_STATE_FONT, NULL, false)
 TODO("Add style fallback here")
-EDITOR_STATE_STRING_WITH_FALLBACK(text_style, ATTRIBUTE_STATE_TEXT_STYLE, 
NULL, true)
+EDITOR_STATE_STRING_WITH_FALLBACK(text_style, RM_ATTRIBUTE_STATE_TEXT_STYLE, 
NULL, true)
 
 Eina_Bool
 editor_state_text_set(Evas_Object *edit_object, Change *change, Eina_Bool 
merge, Eina_Bool apply,
                       const char *part_name, const char *state_name, double 
state_val, const char *new_val)
 {
    Diff *diff;
-   Attribute attribute = ATTRIBUTE_STATE_TEXT_STYLE;
+   RM_Attribute attribute = RM_ATTRIBUTE_STATE_TEXT_STYLE;
    assert(edit_object != NULL);
    assert(part_name != NULL);
    assert(state_name != NULL);
@@ -119,7 +119,7 @@ editor_state_text_set(Evas_Object *edit_object, Change 
*change, Eina_Bool merge,
      {
        CRIT_ON_FAIL(edje_edit_state_text_set(edit_object, part_name, 
state_name, state_val, new_val ? new_val : ""));
        _editor_project_changed();
-       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, &attribute);
+       if (!_editor_signals_blocked) evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
      }
    return true;
 }
diff --git a/src/bin/editor/editor_top_level.c 
b/src/bin/editor/editor_top_level.c
index 090043b..48d6cef 100644
--- a/src/bin/editor/editor_top_level.c
+++ b/src/bin/editor/editor_top_level.c
@@ -96,7 +96,7 @@ editor_color_class_description_set(Evas_Object *obj, const 
char *name, const cha
    assert(obj != NULL);
    assert(name != NULL);
 
-   Attribute attribute = ATTRIBUTE_RESOURCES_COLORCLASS_DESCRIPTION;
+   RM_Attribute_Resources attribute = 
RM_ATTRIBUTE_RESOURCES_COLORCLASS_DESCRIPTION;
 
    CRIT_ON_FAIL(edje_edit_color_class_description_set(obj, name, description));
 
@@ -104,7 +104,7 @@ editor_color_class_description_set(Evas_Object *obj, const 
char *name, const cha
      return false; /* i hope it will never happen */
    _editor_project_changed();
    if (!_editor_signals_blocked)
-     evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RESOURCE_ATTRIBUTE_CHANGED, &attribute);
+     evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_RESOURCE_ATTRIBUTE_CHANGED, &attribute);
    return true;
 }
 
@@ -117,7 +117,7 @@ editor_color_class_colors_set(Evas_Object *obj, const char 
*name,
    assert(obj != NULL);
    assert(name != NULL);
 
-   Attribute attribute = ATTRIBUTE_RESOURCES_COLORCLASS_COLORS;
+   RM_Attribute_Resources attribute = RM_ATTRIBUTE_RESOURCES_COLORCLASS_COLORS;
 
    CRIT_ON_FAIL(edje_edit_color_class_colors_set(obj, name,
                                                  r, g, b, a,
@@ -128,7 +128,7 @@ editor_color_class_colors_set(Evas_Object *obj, const char 
*name,
      return false; /* i hope it will never happen */
    _editor_project_changed();
    if (!_editor_signals_blocked)
-     evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RESOURCE_ATTRIBUTE_CHANGED, &attribute);
+     evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_RESOURCE_ATTRIBUTE_CHANGED, &attribute);
    return true;
 }
 
@@ -236,13 +236,13 @@ editor_style_tag_add(Evas_Object *obj, const char *name, 
const char *tag)
    assert(name != NULL);
 
    CRIT_ON_FAIL(edje_edit_style_tag_add(obj, name, tag));
-   Attribute attribute = ATTRIBUTE_RESOURCES_STYLE_TAG_ADDED;
+   RM_Attribute_Resources attribute = RM_ATTRIBUTE_RESOURCES_STYLE_TAG_ADDED;
 
    if (!editor_save(obj))
      return false; /* i hope it will never happen */
    _editor_project_changed();
    if (!_editor_signals_blocked)
-     evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RESOURCE_ATTRIBUTE_CHANGED, &attribute);
+     evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_RESOURCE_ATTRIBUTE_CHANGED, &attribute);
    return true;
 }
 
@@ -253,13 +253,13 @@ editor_style_tag_del(Evas_Object *obj, const char *name, 
const char *tag)
    assert(name != NULL);
 
    CRIT_ON_FAIL(edje_edit_style_tag_del(obj, name, tag));
-   Attribute attribute = ATTRIBUTE_RESOURCES_STYLE_TAG_DELETED;
+   RM_Attribute_Resources attribute = RM_ATTRIBUTE_RESOURCES_STYLE_TAG_DELETED;
 
    if (!editor_save(obj))
      return false; /* i hope it will never happen */
    _editor_project_changed();
    if (!_editor_signals_blocked)
-     evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RESOURCE_ATTRIBUTE_CHANGED, &attribute);
+     evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_RESOURCE_ATTRIBUTE_CHANGED, &attribute);
    return true;
 }
 
@@ -270,12 +270,14 @@ editor_style_tag_value_set(Evas_Object *obj, const char 
*name, const char *tag,
    assert(name != NULL);
 
    CRIT_ON_FAIL(edje_edit_style_tag_value_set(obj, name, tag, value));
-   Attribute attribute = ATTRIBUTE_RESOURCES_STYLE_TAG_DELETED;
+   RM_Attribute_Resources attribute = RM_ATTRIBUTE_RESOURCES_STYLE_TAG_DELETED;
 
    if (!editor_save(obj))
      return false; /* i hope it will never happen */
    _editor_project_changed();
    if (!_editor_signals_blocked)
-     evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RESOURCE_ATTRIBUTE_CHANGED, &attribute);
+     evas_object_smart_callback_call(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, &attribute);
+
+     evas_object_smart_callback_call(ap.win, SIGNAL_EDITOR_ATTRIBUTE_CHANGED, 
&attribute);
    return true;
 }
diff --git a/src/bin/resource_manager/resource_manager2.h 
b/src/bin/resource_manager/resource_manager2.h
index 0676036..2bf1ab3 100644
--- a/src/bin/resource_manager/resource_manager2.h
+++ b/src/bin/resource_manager/resource_manager2.h
@@ -21,6 +21,7 @@
 #define RESOURCE_MANAGER2_H
 
 #include "eflete.h"
+#include "resource_manager_signals.h"
 
 enum _Resource2_Type
 {
diff --git a/src/bin/resource_manager/resource_manager_react.c 
b/src/bin/resource_manager/resource_manager_react.c
index 0ef7630..d277c45 100644
--- a/src/bin/resource_manager/resource_manager_react.c
+++ b/src/bin/resource_manager/resource_manager_react.c
@@ -51,14 +51,15 @@ _property_resource_attribute_changed(void *data __UNUSED__,
                                      Evas_Object *obj __UNUSED__,
                                      void *event_info)
 {
-   Attribute_Resource *attr = event_info;
-   printf("Some resource attribute was changed [%d] \n", (int)*attr);
+   Attribute *attr = event_info;
+   Attribute_Resource editor_resource = (int)*attr;
+   printf("Some resource attribute was changed [%d][%d] \n", (int)*attr, 
editor_resource);
    switch ((int)*attr)
      {
-      case ATTRIBUTE_RESOURCES_COLORCLASS_DESCRIPTION:
-      case ATTRIBUTE_RESOURCES_COLORCLASS_COLORS:
-      case ATTRIBUTE_RESOURCES_STYLE_TAG_ADDED:
-      case ATTRIBUTE_RESOURCES_STYLE_TAG_DELETED:
+      case RM_ATTRIBUTE_RESOURCES_COLORCLASS_DESCRIPTION:
+      case RM_ATTRIBUTE_RESOURCES_COLORCLASS_COLORS:
+      case RM_ATTRIBUTE_RESOURCES_STYLE_TAG_ADDED:
+      case RM_ATTRIBUTE_RESOURCES_STYLE_TAG_DELETED:
       default:
          break;
      }
@@ -89,140 +90,142 @@ _property_attribute_changed(void *data __UNUSED__,
     ***********************************************************************
     ***********************************************************************/
 
-   Attribute *attr = event_info;
-   printf("Some attribute was changed [%d] \n", (int)*attr);
+   RM_Attribute *attr = event_info;
+   Attribute editor_resource = (int)*attr;
+
    switch ((int)*attr)
      {
-      case ATTRIBUTE_GROUP_MIN_W:
-      case ATTRIBUTE_GROUP_MIN_H:
-      case ATTRIBUTE_GROUP_MAX_W:
-      case ATTRIBUTE_GROUP_MAX_H:
-      case ATTRIBUTE_STATE_MIN_W:
-      case ATTRIBUTE_STATE_MIN_H:
-      case ATTRIBUTE_STATE_MAX_W:
-      case ATTRIBUTE_STATE_MAX_H:
-      case ATTRIBUTE_STATE_ALIGN_X:
-      case ATTRIBUTE_STATE_ALIGN_Y:
-      case ATTRIBUTE_STATE_REL1_RELATIVE_X:
-      case ATTRIBUTE_STATE_REL1_RELATIVE_Y:
-      case ATTRIBUTE_STATE_REL2_RELATIVE_X:
-      case ATTRIBUTE_STATE_REL2_RELATIVE_Y:
-      case ATTRIBUTE_STATE_REL1_OFFSET_X:
-      case ATTRIBUTE_STATE_REL1_OFFSET_Y:
-      case ATTRIBUTE_STATE_REL2_OFFSET_X:
-      case ATTRIBUTE_STATE_REL2_OFFSET_Y:
-      case ATTRIBUTE_STATE_ASPECT_MIN:
-      case ATTRIBUTE_STATE_ASPECT_MAX:
-      case ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_X:
-      case ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_Y:
-      case ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_X:
-      case ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_Y:
-      case ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_X:
-      case ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_Y:
-      case ATTRIBUTE_STATE_FILL_SIZE_OFFSET_X:
-      case ATTRIBUTE_STATE_FILL_SIZE_OFFSET_Y:
-      case ATTRIBUTE_STATE_TEXT_ALIGN_X:
-      case ATTRIBUTE_STATE_TEXT_ALIGN_Y:
-      case ATTRIBUTE_STATE_TEXT_ELIPSIS:
-      case ATTRIBUTE_STATE_TEXT_SIZE:
-      case ATTRIBUTE_STATE_TEXT_FIT_X:
-      case ATTRIBUTE_STATE_TEXT_FIT_Y:
-      case ATTRIBUTE_STATE_TEXT_MAX_X:
-      case ATTRIBUTE_STATE_TEXT_MAX_Y:
-      case ATTRIBUTE_STATE_TEXT_MIN_X:
-      case ATTRIBUTE_STATE_TEXT_MIN_Y:
-      case ATTRIBUTE_STATE_FIXED_H:
-      case ATTRIBUTE_STATE_FIXED_W:
-      case ATTRIBUTE_STATE_IMAGE:
-      case ATTRIBUTE_STATE_IMAGE_TWEEN:
-      case ATTRIBUTE_STATE_REL1_TO_X:
-      case ATTRIBUTE_STATE_REL1_TO_Y:
-      case ATTRIBUTE_STATE_REL2_TO_X:
-      case ATTRIBUTE_STATE_REL2_TO_Y:
-      case ATTRIBUTE_STATE_TEXT_SOURCE:
-      case ATTRIBUTE_STATE_TEXT_TEXT_SOURCE:
-      case ATTRIBUTE_STATE_TEXT:
-      case ATTRIBUTE_STATE_FONT:
-      case ATTRIBUTE_STATE_TEXT_STYLE:
-      case ATTRIBUTE_STATE_ASPECT_PREF:
-      case ATTRIBUTE_PART_TEXT_EFFECT:
-      case ATTRIBUTE_PART_TEXT_SHADOW_DIRECTION:
-      case ATTRIBUTE_PART_CLIP_TO:
-      case ATTRIBUTE_PART_DRAG_CONFINE:
-      case ATTRIBUTE_PART_GROUP_SOURCE:
-      case ATTRIBUTE_PART_TEXTBLOCK_SELECTION_UNDER:
-      case ATTRIBUTE_PART_TEXTBLOCK_SELECTION_OVER:
-      case ATTRIBUTE_PART_TEXTBLOCK_CURSOR_UNDER:
-      case ATTRIBUTE_PART_TEXTBLOCK_CURSOR_OVER:
-      case ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_UNDER:
-      case ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_OVER:
-      case ATTRIBUTE_STATE_CONTAINER_ALIGN_X:
-      case ATTRIBUTE_STATE_CONTAINER_ALIGN_Y:
-      case ATTRIBUTE_STATE_CONTAINER_MIN_H:
-      case ATTRIBUTE_STATE_CONTAINER_MIN_V:
-      case ATTRIBUTE_STATE_TABLE_HOMOGENEOUS:
-      case ATTRIBUTE_STATE_CONTAINER_PADING_X:
-      case ATTRIBUTE_STATE_CONTAINER_PADING_Y:
-      case ATTRIBUTE_STATE_MINMUL_H:
-      case ATTRIBUTE_STATE_MINMUL_W:
-      case ATTRIBUTE_PART_MULTILINE:
-      case ATTRIBUTE_PART_ENTRY_MODE:
-      case ATTRIBUTE_STATE_FILL_TYPE:
-      case ATTRIBUTE_STATE_COLOR:
-      case ATTRIBUTE_STATE_OUTLINE_COLOR:
-      case ATTRIBUTE_STATE_SHADOW_COLOR:
-      case ATTRIBUTE_STATE_MAP_ROTATION_CENTER:
-      case ATTRIBUTE_STATE_MAP_ROTATION_X:
-      case ATTRIBUTE_STATE_MAP_ROTATION_Y:
-      case ATTRIBUTE_STATE_MAP_ROTATION_Z:
-      case ATTRIBUTE_STATE_MAP_POINT_COLOR_1:
-      case ATTRIBUTE_STATE_MAP_POINT_COLOR_2:
-      case ATTRIBUTE_STATE_MAP_POINT_COLOR_3:
-      case ATTRIBUTE_STATE_MAP_POINT_COLOR_4:
-      case ATTRIBUTE_STATE_FILL_SMOOTH:
-      case ATTRIBUTE_STATE_VISIBLE:
-      case ATTRIBUTE_STATE_IMAGE_BORDER_TOP:
-      case ATTRIBUTE_STATE_IMAGE_BORDER_BOTTOM:
-      case ATTRIBUTE_STATE_IMAGE_BORDER_LEFT:
-      case ATTRIBUTE_STATE_IMAGE_BORDER_RIGHT:
-      case ATTRIBUTE_STATE_IMAGE_BORDER_FILL:
-      case ATTRIBUTE_STATE_COLOR_CLASS:
-      case ATTRIBUTE_STATE_MAP_ON:
-      case ATTRIBUTE_STATE_MAP_PERSPECTIVE_ON:
-      case ATTRIBUTE_STATE_MAP_PERSPECTIVE:
-      case ATTRIBUTE_STATE_MAP_LIGHT:
-      case ATTRIBUTE_STATE_MAP_SMOOTH:
-      case ATTRIBUTE_STATE_MAP_ALPHA:
-      case ATTRIBUTE_STATE_MAP_BACKFACE_CULL:
-      case ATTRIBUTE_STATE_MAP_PERSPECTIVE_FOCAL:
-      case ATTRIBUTE_STATE_MAP_PERSPECTIVE_ZPLANE:
-      case ATTRIBUTE_PART_ITEM_ASPECT_MODE:
-      case ATTRIBUTE_PART_ITEM_ALIGN_X:
-      case ATTRIBUTE_PART_ITEM_ALIGN_Y:
-      case ATTRIBUTE_PART_ITEM_WEIGHT_X:
-      case ATTRIBUTE_PART_ITEM_WEIGHT_Y:
-      case ATTRIBUTE_PART_ITEM_ASPECT_H:
-      case ATTRIBUTE_PART_ITEM_ASPECT_W:
-      case ATTRIBUTE_PART_ITEM_MAX_H:
-      case ATTRIBUTE_PART_ITEM_MAX_W:
-      case ATTRIBUTE_PART_ITEM_MIN_H:
-      case ATTRIBUTE_PART_ITEM_MIN_W:
-      case ATTRIBUTE_PART_ITEM_PREFER_H:
-      case ATTRIBUTE_PART_ITEM_PREFER_W:
-      case ATTRIBUTE_PART_ITEM_SPREAD_H:
-      case ATTRIBUTE_PART_ITEM_SPREAD_W:
-      case ATTRIBUTE_PART_ITEM_SPAN_COL:
-      case ATTRIBUTE_PART_ITEM_SPAN_ROW:
-      case ATTRIBUTE_PART_ITEM_POSITION_COL:
-      case ATTRIBUTE_PART_ITEM_POSITION_ROW:
-      case ATTRIBUTE_PART_ITEM_SOURCE:
-      case ATTRIBUTE_PART_ITEM_PADDING_RIGHT:
-      case ATTRIBUTE_PART_ITEM_PADDING_LEFT:
-      case ATTRIBUTE_PART_ITEM_PADDING_TOP:
-      case ATTRIBUTE_PART_ITEM_PADDING_BOTTOM:
+      case RM_ATTRIBUTE_GROUP_MIN_W:
+      case RM_ATTRIBUTE_GROUP_MIN_H:
+      case RM_ATTRIBUTE_GROUP_MAX_W:
+      case RM_ATTRIBUTE_GROUP_MAX_H:
+      case RM_ATTRIBUTE_STATE_MIN_W:
+      case RM_ATTRIBUTE_STATE_MIN_H:
+      case RM_ATTRIBUTE_STATE_MAX_W:
+      case RM_ATTRIBUTE_STATE_MAX_H:
+      case RM_ATTRIBUTE_STATE_ALIGN_X:
+      case RM_ATTRIBUTE_STATE_ALIGN_Y:
+      case RM_ATTRIBUTE_STATE_REL1_RELATIVE_X:
+      case RM_ATTRIBUTE_STATE_REL1_RELATIVE_Y:
+      case RM_ATTRIBUTE_STATE_REL2_RELATIVE_X:
+      case RM_ATTRIBUTE_STATE_REL2_RELATIVE_Y:
+      case RM_ATTRIBUTE_STATE_REL1_OFFSET_X:
+      case RM_ATTRIBUTE_STATE_REL1_OFFSET_Y:
+      case RM_ATTRIBUTE_STATE_REL2_OFFSET_X:
+      case RM_ATTRIBUTE_STATE_REL2_OFFSET_Y:
+      case RM_ATTRIBUTE_STATE_ASPECT_MIN:
+      case RM_ATTRIBUTE_STATE_ASPECT_MAX:
+      case RM_ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_X:
+      case RM_ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_Y:
+      case RM_ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_X:
+      case RM_ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_Y:
+      case RM_ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_X:
+      case RM_ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_Y:
+      case RM_ATTRIBUTE_STATE_FILL_SIZE_OFFSET_X:
+      case RM_ATTRIBUTE_STATE_FILL_SIZE_OFFSET_Y:
+      case RM_ATTRIBUTE_STATE_TEXT_ALIGN_X:
+      case RM_ATTRIBUTE_STATE_TEXT_ALIGN_Y:
+      case RM_ATTRIBUTE_STATE_TEXT_ELIPSIS:
+      case RM_ATTRIBUTE_STATE_TEXT_SIZE:
+      case RM_ATTRIBUTE_STATE_TEXT_FIT_X:
+      case RM_ATTRIBUTE_STATE_TEXT_FIT_Y:
+      case RM_ATTRIBUTE_STATE_TEXT_MAX_X:
+      case RM_ATTRIBUTE_STATE_TEXT_MAX_Y:
+      case RM_ATTRIBUTE_STATE_TEXT_MIN_X:
+      case RM_ATTRIBUTE_STATE_TEXT_MIN_Y:
+      case RM_ATTRIBUTE_STATE_FIXED_H:
+      case RM_ATTRIBUTE_STATE_FIXED_W:
+      case RM_ATTRIBUTE_STATE_IMAGE:
+      case RM_ATTRIBUTE_STATE_IMAGE_TWEEN:
+      case RM_ATTRIBUTE_STATE_REL1_TO_X:
+      case RM_ATTRIBUTE_STATE_REL1_TO_Y:
+      case RM_ATTRIBUTE_STATE_REL2_TO_X:
+      case RM_ATTRIBUTE_STATE_REL2_TO_Y:
+      case RM_ATTRIBUTE_STATE_TEXT_SOURCE:
+      case RM_ATTRIBUTE_STATE_TEXT_TEXT_SOURCE:
+      case RM_ATTRIBUTE_STATE_TEXT:
+      case RM_ATTRIBUTE_STATE_FONT:
+      case RM_ATTRIBUTE_STATE_TEXT_STYLE:
+      case RM_ATTRIBUTE_STATE_ASPECT_PREF:
+      case RM_ATTRIBUTE_PART_TEXT_EFFECT:
+      case RM_ATTRIBUTE_PART_TEXT_SHADOW_DIRECTION:
+      case RM_ATTRIBUTE_PART_CLIP_TO:
+      case RM_ATTRIBUTE_PART_DRAG_CONFINE:
+      case RM_ATTRIBUTE_PART_GROUP_SOURCE:
+      case RM_ATTRIBUTE_PART_TEXTBLOCK_SELECTION_UNDER:
+      case RM_ATTRIBUTE_PART_TEXTBLOCK_SELECTION_OVER:
+      case RM_ATTRIBUTE_PART_TEXTBLOCK_CURSOR_UNDER:
+      case RM_ATTRIBUTE_PART_TEXTBLOCK_CURSOR_OVER:
+      case RM_ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_UNDER:
+      case RM_ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_OVER:
+      case RM_ATTRIBUTE_STATE_CONTAINER_ALIGN_X:
+      case RM_ATTRIBUTE_STATE_CONTAINER_ALIGN_Y:
+      case RM_ATTRIBUTE_STATE_CONTAINER_MIN_H:
+      case RM_ATTRIBUTE_STATE_CONTAINER_MIN_V:
+      case RM_ATTRIBUTE_STATE_TABLE_HOMOGENEOUS:
+      case RM_ATTRIBUTE_STATE_CONTAINER_PADING_X:
+      case RM_ATTRIBUTE_STATE_CONTAINER_PADING_Y:
+      case RM_ATTRIBUTE_STATE_MINMUL_H:
+      case RM_ATTRIBUTE_STATE_MINMUL_W:
+      case RM_ATTRIBUTE_PART_MULTILINE:
+      case RM_ATTRIBUTE_PART_ENTRY_MODE:
+      case RM_ATTRIBUTE_STATE_FILL_TYPE:
+      case RM_ATTRIBUTE_STATE_COLOR:
+      case RM_ATTRIBUTE_STATE_OUTLINE_COLOR:
+      case RM_ATTRIBUTE_STATE_SHADOW_COLOR:
+      case RM_ATTRIBUTE_STATE_MAP_ROTATION_CENTER:
+      case RM_ATTRIBUTE_STATE_MAP_ROTATION_X:
+      case RM_ATTRIBUTE_STATE_MAP_ROTATION_Y:
+      case RM_ATTRIBUTE_STATE_MAP_ROTATION_Z:
+      case RM_ATTRIBUTE_STATE_MAP_POINT_COLOR_1:
+      case RM_ATTRIBUTE_STATE_MAP_POINT_COLOR_2:
+      case RM_ATTRIBUTE_STATE_MAP_POINT_COLOR_3:
+      case RM_ATTRIBUTE_STATE_MAP_POINT_COLOR_4:
+      case RM_ATTRIBUTE_STATE_FILL_SMOOTH:
+      case RM_ATTRIBUTE_STATE_VISIBLE:
+      case RM_ATTRIBUTE_STATE_IMAGE_BORDER_TOP:
+      case RM_ATTRIBUTE_STATE_IMAGE_BORDER_BOTTOM:
+      case RM_ATTRIBUTE_STATE_IMAGE_BORDER_LEFT:
+      case RM_ATTRIBUTE_STATE_IMAGE_BORDER_RIGHT:
+      case RM_ATTRIBUTE_STATE_IMAGE_BORDER_FILL:
+      case RM_ATTRIBUTE_STATE_COLOR_CLASS:
+      case RM_ATTRIBUTE_STATE_MAP_ON:
+      case RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE_ON:
+      case RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE:
+      case RM_ATTRIBUTE_STATE_MAP_LIGHT:
+      case RM_ATTRIBUTE_STATE_MAP_SMOOTH:
+      case RM_ATTRIBUTE_STATE_MAP_ALPHA:
+      case RM_ATTRIBUTE_STATE_MAP_BACKFACE_CULL:
+      case RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE_FOCAL:
+      case RM_ATTRIBUTE_STATE_MAP_PERSPECTIVE_ZPLANE:
+      case RM_ATTRIBUTE_PART_ITEM_ASPECT_MODE:
+      case RM_ATTRIBUTE_PART_ITEM_ALIGN_X:
+      case RM_ATTRIBUTE_PART_ITEM_ALIGN_Y:
+      case RM_ATTRIBUTE_PART_ITEM_WEIGHT_X:
+      case RM_ATTRIBUTE_PART_ITEM_WEIGHT_Y:
+      case RM_ATTRIBUTE_PART_ITEM_ASPECT_H:
+      case RM_ATTRIBUTE_PART_ITEM_ASPECT_W:
+      case RM_ATTRIBUTE_PART_ITEM_MAX_H:
+      case RM_ATTRIBUTE_PART_ITEM_MAX_W:
+      case RM_ATTRIBUTE_PART_ITEM_MIN_H:
+      case RM_ATTRIBUTE_PART_ITEM_MIN_W:
+      case RM_ATTRIBUTE_PART_ITEM_PREFER_H:
+      case RM_ATTRIBUTE_PART_ITEM_PREFER_W:
+      case RM_ATTRIBUTE_PART_ITEM_SPREAD_H:
+      case RM_ATTRIBUTE_PART_ITEM_SPREAD_W:
+      case RM_ATTRIBUTE_PART_ITEM_SPAN_COL:
+      case RM_ATTRIBUTE_PART_ITEM_SPAN_ROW:
+      case RM_ATTRIBUTE_PART_ITEM_POSITION_COL:
+      case RM_ATTRIBUTE_PART_ITEM_POSITION_ROW:
+      case RM_ATTRIBUTE_PART_ITEM_SOURCE:
+      case RM_ATTRIBUTE_PART_ITEM_PADDING_RIGHT:
+      case RM_ATTRIBUTE_PART_ITEM_PADDING_LEFT:
+      case RM_ATTRIBUTE_PART_ITEM_PADDING_TOP:
+      case RM_ATTRIBUTE_PART_ITEM_PADDING_BOTTOM:
       default:
          break;
      }
+   evas_object_smart_callback_call(ap.win, SIGNAL_EDITOR_ATTRIBUTE_CHANGED, 
&editor_resource);
 }
 
 static void
@@ -671,8 +674,8 @@ _resource_callbacks_register(Project *project)
    TODO("add afters and targets addition and changes")
    evas_object_smart_callback_add(ap.win, SIGNAL_EDITOR_GROUP_DATA_ADDED, 
_editor_group_data_added_cb, project);
    evas_object_smart_callback_add(ap.win, SIGNAL_EDITOR_GROUP_DATA_DELETED, 
_editor_group_data_deleted_cb, project);
-   evas_object_smart_callback_add(ap.win, SIGNAL_EDITOR_ATTRIBUTE_CHANGED, 
_property_attribute_changed, project);
-   evas_object_smart_callback_add(ap.win, 
SIGNAL_EDITOR_RESOURCE_ATTRIBUTE_CHANGED, _property_resource_attribute_changed, 
project);
+   evas_object_smart_callback_add(ap.win, SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, 
_property_attribute_changed, project);
+   evas_object_smart_callback_add(ap.win, 
SIGNAL_EDITOR_RM_RESOURCE_ATTRIBUTE_CHANGED, 
_property_resource_attribute_changed, project);
    evas_object_smart_callback_add(ap.win, SIGNAL_EDITOR_GROUP_ADDED, 
_editor_group_add_cb, project);
    evas_object_smart_callback_add(ap.win, SIGNAL_EDITOR_GROUP_DELETED, 
_editor_group_del_cb, project);
 }
@@ -707,8 +710,8 @@ _resource_callbacks_unregister(Project *project)
    evas_object_smart_callback_del_full(ap.win, SIGNAL_EDITOR_PROGRAM_DELETED, 
_editor_program_deleted_cb, project);
    evas_object_smart_callback_del_full(ap.win, SIGNAL_EDITOR_GROUP_DATA_ADDED, 
_editor_group_data_added_cb, project);
    evas_object_smart_callback_del_full(ap.win, 
SIGNAL_EDITOR_GROUP_DATA_DELETED, _editor_group_data_deleted_cb, project);
-   evas_object_smart_callback_del_full(ap.win, 
SIGNAL_EDITOR_ATTRIBUTE_CHANGED, _property_attribute_changed, project);
-   evas_object_smart_callback_del_full(ap.win, 
SIGNAL_EDITOR_RESOURCE_ATTRIBUTE_CHANGED, _property_resource_attribute_changed, 
project);
+   evas_object_smart_callback_del_full(ap.win, 
SIGNAL_EDITOR_RM_ATTRIBUTE_CHANGED, _property_attribute_changed, project);
+   evas_object_smart_callback_del_full(ap.win, 
SIGNAL_EDITOR_RM_RESOURCE_ATTRIBUTE_CHANGED, 
_property_resource_attribute_changed, project);
    evas_object_smart_callback_del_full(ap.win, SIGNAL_EDITOR_GROUP_ADDED, 
_editor_group_add_cb, project);
    evas_object_smart_callback_del_full(ap.win, SIGNAL_EDITOR_GROUP_DELETED, 
_editor_group_del_cb, project);
 }
diff --git a/src/bin/resource_manager/resource_manager_signals.h 
b/src/bin/resource_manager/resource_manager_signals.h
new file mode 100644
index 0000000..043381a
--- /dev/null
+++ b/src/bin/resource_manager/resource_manager_signals.h
@@ -0,0 +1,228 @@
+/*
+ * Edje Theme Editor
+ * Copyright (C) 2013-2016 Samsung Electronics.
+ *
+ * This file is part of Edje Theme Editor.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; If not, see www.gnu.org/licenses/lgpl.html.
+ */
+
+#ifndef RESOURCE_MANAGER_SIGNALS_H
+#define RESOURCE_MANAGER_SIGNALS_H
+
+typedef enum {
+   ATTRIBUTE_NONE,
+
+   ATTRIBUTE_GROUP_NAME,
+   ATTRIBUTE_GROUP_MIN_W,
+   ATTRIBUTE_GROUP_MIN_H,
+   ATTRIBUTE_GROUP_MAX_W,
+   ATTRIBUTE_GROUP_MAX_H,
+   ATTRIBUTE_GROUP_DATA_NAME,
+   ATTRIBUTE_GROUP_DATA_VALUE,
+   ATTRIBUTE_STATE_NAME,
+   ATTRIBUTE_STATE_MIN_W,
+   ATTRIBUTE_STATE_MIN_H,
+   ATTRIBUTE_STATE_MAX_W,
+   ATTRIBUTE_STATE_MAX_H,
+   ATTRIBUTE_STATE_ALIGN_X,
+   ATTRIBUTE_STATE_ALIGN_Y,
+   ATTRIBUTE_STATE_REL1_RELATIVE_X,
+   ATTRIBUTE_STATE_REL1_RELATIVE_Y,
+   ATTRIBUTE_STATE_REL2_RELATIVE_X,
+   ATTRIBUTE_STATE_REL2_RELATIVE_Y,
+   ATTRIBUTE_STATE_REL1_OFFSET_X,
+   ATTRIBUTE_STATE_REL1_OFFSET_Y,
+   ATTRIBUTE_STATE_REL2_OFFSET_X,
+   ATTRIBUTE_STATE_REL2_OFFSET_Y,
+   ATTRIBUTE_STATE_ASPECT_MIN,
+   ATTRIBUTE_STATE_ASPECT_MAX,
+   ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_X,
+   ATTRIBUTE_STATE_FILL_ORIGIN_RELATIVE_Y,
+   ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_X,
+   ATTRIBUTE_STATE_FILL_ORIGIN_OFFSET_Y,
+   ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_X,
+   ATTRIBUTE_STATE_FILL_SIZE_RELATIVE_Y,
+   ATTRIBUTE_STATE_FILL_SIZE_OFFSET_X,
+   ATTRIBUTE_STATE_FILL_SIZE_OFFSET_Y,
+   ATTRIBUTE_STATE_TEXT_ALIGN_X,
+   ATTRIBUTE_STATE_TEXT_ALIGN_Y,
+   ATTRIBUTE_STATE_TEXT_ELIPSIS,
+   ATTRIBUTE_STATE_TEXT_ELIPSIS_ENABLE /* virtual attribute */,
+   ATTRIBUTE_STATE_TEXT_SIZE,
+   ATTRIBUTE_STATE_TEXT_FIT_X,
+   ATTRIBUTE_STATE_TEXT_FIT_Y,
+   ATTRIBUTE_STATE_TEXT_MAX_X,
+   ATTRIBUTE_STATE_TEXT_MAX_Y,
+   ATTRIBUTE_STATE_TEXT_MIN_X,
+   ATTRIBUTE_STATE_TEXT_MIN_Y,
+   ATTRIBUTE_STATE_FIXED_H,
+   ATTRIBUTE_STATE_FIXED_W,
+   ATTRIBUTE_STATE_FILL_SMOOTH,
+   ATTRIBUTE_STATE_VISIBLE,
+   ATTRIBUTE_STATE_IMAGE,
+   ATTRIBUTE_STATE_IMAGE_TWEEN,
+   ATTRIBUTE_STATE_COLOR_CLASS,
+   ATTRIBUTE_STATE_REL1_TO_X,
+   ATTRIBUTE_STATE_REL1_TO_Y,
+   ATTRIBUTE_STATE_REL2_TO_X,
+   ATTRIBUTE_STATE_REL2_TO_Y,
+   ATTRIBUTE_STATE_TEXT_SOURCE,
+   ATTRIBUTE_STATE_TEXT_TEXT_SOURCE,
+   ATTRIBUTE_STATE_TEXT,
+   ATTRIBUTE_STATE_FONT,
+   ATTRIBUTE_STATE_TEXT_STYLE,
+   ATTRIBUTE_STATE_COLOR,
+   ATTRIBUTE_STATE_OUTLINE_COLOR,
+   ATTRIBUTE_STATE_SHADOW_COLOR,
+   ATTRIBUTE_STATE_IMAGE_BORDER_TOP,
+   ATTRIBUTE_STATE_IMAGE_BORDER_BOTTOM,
+   ATTRIBUTE_STATE_IMAGE_BORDER_LEFT,
+   ATTRIBUTE_STATE_IMAGE_BORDER_RIGHT,
+   ATTRIBUTE_STATE_IMAGE_BORDER_FILL,
+   ATTRIBUTE_STATE_ASPECT_PREF,
+   ATTRIBUTE_PART_TEXT_EFFECT,
+   ATTRIBUTE_PART_TEXT_SHADOW_DIRECTION,
+   ATTRIBUTE_PART_IGNORE_FLAGS,
+   ATTRIBUTE_PART_MOUSE_EVENTS,
+   ATTRIBUTE_PART_REPEAT_EVENTS,
+   ATTRIBUTE_PART_SCALE,
+   ATTRIBUTE_PART_DRAG_COUNT_X,
+   ATTRIBUTE_PART_DRAG_COUNT_Y,
+   ATTRIBUTE_PART_DRAG_X,
+   ATTRIBUTE_PART_DRAG_Y,
+   ATTRIBUTE_PART_DRAG_STEP_X,
+   ATTRIBUTE_PART_DRAG_STEP_Y,
+   ATTRIBUTE_PART_CLIP_TO,
+   ATTRIBUTE_PART_DRAG_CONFINE,
+   ATTRIBUTE_PART_DRAG_THRESHOLD,
+   ATTRIBUTE_PART_DRAG_EVENT,
+   ATTRIBUTE_PART_NAME,
+   ATTRIBUTE_PART_TYPE,
+   ATTRIBUTE_PART_GROUP_SOURCE,
+   ATTRIBUTE_PART_TEXTBLOCK_SELECTION_UNDER,
+   ATTRIBUTE_PART_TEXTBLOCK_SELECTION_OVER,
+   ATTRIBUTE_PART_TEXTBLOCK_CURSOR_UNDER,
+   ATTRIBUTE_PART_TEXTBLOCK_CURSOR_OVER,
+   ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_UNDER,
+   ATTRIBUTE_PART_TEXTBLOCK_ANCHORS_OVER,
+   ATTRIBUTE_PART_ITEM_ASPECT_MODE,
+   ATTRIBUTE_PART_ITEM_ALIGN_X,
+   ATTRIBUTE_PART_ITEM_ALIGN_Y,
+   ATTRIBUTE_PART_ITEM_WEIGHT_X,
+   ATTRIBUTE_PART_ITEM_WEIGHT_Y,
+   ATTRIBUTE_PART_ITEM_ASPECT_H,
+   ATTRIBUTE_PART_ITEM_ASPECT_W,
+   ATTRIBUTE_PART_ITEM_MAX_H,
+   ATTRIBUTE_PART_ITEM_MAX_W,
+   ATTRIBUTE_PART_ITEM_MIN_H,
+   ATTRIBUTE_PART_ITEM_MIN_W,
+   ATTRIBUTE_PART_ITEM_NAME,
+   ATTRIBUTE_PART_ITEM_PREFER_H,
+   ATTRIBUTE_PART_ITEM_PREFER_W,
+   ATTRIBUTE_PART_ITEM_SPREAD_H,
+   ATTRIBUTE_PART_ITEM_SPREAD_W,
+   ATTRIBUTE_PART_ITEM_SPAN_COL,
+   ATTRIBUTE_PART_ITEM_SPAN_ROW,
+   ATTRIBUTE_PART_ITEM_POSITION_COL,
+   ATTRIBUTE_PART_ITEM_POSITION_ROW,
+   ATTRIBUTE_PART_ITEM_SOURCE,
+   ATTRIBUTE_PART_ITEM_PADDING_TOP,
+   ATTRIBUTE_PART_ITEM_PADDING_BOTTOM,
+   ATTRIBUTE_PART_ITEM_PADDING_LEFT,
+   ATTRIBUTE_PART_ITEM_PADDING_RIGHT,
+   ATTRIBUTE_STATE_CONTAINER_ALIGN_X,
+   ATTRIBUTE_STATE_CONTAINER_ALIGN_Y,
+   ATTRIBUTE_STATE_CONTAINER_MIN_H,
+   ATTRIBUTE_STATE_CONTAINER_MIN_V,
+   ATTRIBUTE_STATE_TABLE_HOMOGENEOUS,
+   ATTRIBUTE_STATE_CONTAINER_PADING_X,
+   ATTRIBUTE_STATE_CONTAINER_PADING_Y,
+   ATTRIBUTE_STATE_MINMUL_H,
+   ATTRIBUTE_STATE_MINMUL_W,
+   ATTRIBUTE_PART_MULTILINE,
+   ATTRIBUTE_STATE_PROXY_SOURCE,
+   ATTRIBUTE_PART_SELECT_MODE,
+   ATTRIBUTE_PART_ENTRY_MODE,
+   ATTRIBUTE_PART_POINTER_MODE,
+   ATTRIBUTE_PART_CURSOR_MODE,
+   ATTRIBUTE_STATE_FILL_TYPE,
+   ATTRIBUTE_STATE_MAP_ON,
+   ATTRIBUTE_STATE_MAP_PERSPECTIVE_ON,
+   ATTRIBUTE_STATE_MAP_PERSPECTIVE,
+   ATTRIBUTE_STATE_MAP_LIGHT,
+   ATTRIBUTE_STATE_MAP_SMOOTH,
+   ATTRIBUTE_STATE_MAP_ALPHA,
+   ATTRIBUTE_STATE_MAP_BACKFACE_CULL,
+   ATTRIBUTE_STATE_MAP_PERSPECTIVE_FOCAL,
+   ATTRIBUTE_STATE_MAP_PERSPECTIVE_ZPLANE,
+   ATTRIBUTE_STATE_MAP_ROTATION_CENTER,
+   ATTRIBUTE_STATE_MAP_ROTATION_X,
+   ATTRIBUTE_STATE_MAP_ROTATION_Y,
+   ATTRIBUTE_STATE_MAP_ROTATION_Z,
+   ATTRIBUTE_STATE_MAP_POINT_COLOR_1,
+   ATTRIBUTE_STATE_MAP_POINT_COLOR_2,
+   ATTRIBUTE_STATE_MAP_POINT_COLOR_3,
+   ATTRIBUTE_STATE_MAP_POINT_COLOR_4,
+   ATTRIBUTE_PROGRAM_TRANSITION_TYPE,
+   ATTRIBUTE_PROGRAM_TRANSITION_FROM_CURRENT,
+   ATTRIBUTE_PROGRAM_ACTION,
+   ATTRIBUTE_PROGRAM_CHANNEL,
+   ATTRIBUTE_PROGRAM_TONE_DURATION,
+   ATTRIBUTE_PROGRAM_IN_FROM,
+   ATTRIBUTE_PROGRAM_IN_RANGE,
+   ATTRIBUTE_PROGRAM_TRANSITION_TIME,
+   ATTRIBUTE_PROGRAM_SAMPLE_SPEED,
+   ATTRIBUTE_PROGRAM_VALUE,
+   ATTRIBUTE_PROGRAM_TRANSITION_FACTOR,
+   ATTRIBUTE_PROGRAM_TRANSITION_GRADIENT,
+   ATTRIBUTE_PROGRAM_TRANSITION_DECAY,
+   ATTRIBUTE_PROGRAM_TRANSITION_BOUNCES,
+   ATTRIBUTE_PROGRAM_TRANSITION_SWINGS,
+   ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_X1,
+   ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_Y1,
+   ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_X2,
+   ATTRIBUTE_PROGRAM_TRANSITION_BEZIER_Y2,
+   ATTRIBUTE_PROGRAM_FILTER_PART,
+   ATTRIBUTE_PROGRAM_FILTER_STATE,
+   ATTRIBUTE_PROGRAM_API_NAME,
+   ATTRIBUTE_PROGRAM_API_DESCRIPTION,
+   ATTRIBUTE_PROGRAM_SAMPLE_NAME,
+   ATTRIBUTE_PROGRAM_TONE_NAME,
+   ATTRIBUTE_PROGRAM_SIGNAL,
+   ATTRIBUTE_PROGRAM_SOURCE,
+   ATTRIBUTE_PROGRAM_STATE,
+   ATTRIBUTE_PROGRAM_EMIT_SIGNAL,
+   ATTRIBUTE_PROGRAM_EMIT_SOURCE,
+   ATTRIBUTE_PROGRAM_DRAG_VALUE_X,
+   ATTRIBUTE_PROGRAM_DRAG_VALUE_Y,
+   ATTRIBUTE_PROGRAM_NAME,
+   ATTRIBUTE_PROGRAM_TARGET,
+   ATTRIBUTE_PROGRAM_AFTER,
+   ATTRIBUTE_PROGRAM_SCRIPT,
+
+   ATTRIBUTE_LAST
+} Attribute;
+
+typedef enum {
+   ATTRIBUTE_RESOURCES_NONE,
+
+   ATTRIBUTE_RESOURCES_COLORCLASS_DESCRIPTION,
+   ATTRIBUTE_RESOURCES_COLORCLASS_COLORS,
+   ATTRIBUTE_RESOURCES_STYLE_TAG_ADDED,
+   ATTRIBUTE_RESOURCES_STYLE_TAG_DELETED,
+
+   ATTRIBUTE_RESOURCES_LAST
+} Attribute_Resource;
+
+#endif /* RESOURCE_MANAGER_SIGNALS_H */
diff --git a/src/bin/ui/main_window.h b/src/bin/ui/main_window.h
index 19cd2d5..b3c7dfc 100644
--- a/src/bin/ui/main_window.h
+++ b/src/bin/ui/main_window.h
@@ -31,6 +31,7 @@
 
 #include "eflete.h"
 #include "widget_macro.h"
+#include "resource_manager2.h"
 
 #ifdef HAVE_AUDIO
 TODO("Check pulse_audio on configure and add COREAUDIO support")

-- 


Reply via email to