From 9d85805b13151206df7f285109f71ba272e445a9 Mon Sep 17 00:00:00 2001 From: davemds Date: Sun, 14 Apr 2013 13:08:15 +0200 Subject: [PATCH] Python-EFL: Implemented EdjeEdit API, with full unit tests. Some stuff is not working on the C side, the unit test is full of FIXME and TODO. The biggest problem is the PartState that do not work at all, I will give a short look at this, but I'm not so much intrested atm...If you want/need to help please let me know. --- TODO | 4 +- efl/edje/efl.edje_edit.pyx | 495 +++++++++++++++ efl/edje/efl.edje_edit_group.pxi | 56 ++ efl/edje/efl.edje_edit_part.pxi | 331 ++++++++++ efl/edje/efl.edje_edit_part_state.pxi | 851 ++++++++++++++++++++++++++ efl/edje/efl.edje_edit_program.pxi | 260 ++++++++ include/efl.edje_edit.pxd | 321 ++++++++++ setup.py | 9 + tests/edje/test_04_edit.py | 477 +++++++++++++++ tests/edje/theme.edc | 104 +++- tests/edje/theme.edj | Bin 12963 -> 15994 bytes 11 files changed, 2905 insertions(+), 3 deletions(-) create mode 100644 efl/edje/efl.edje_edit.pyx create mode 100644 efl/edje/efl.edje_edit_group.pxi create mode 100644 efl/edje/efl.edje_edit_part.pxi create mode 100644 efl/edje/efl.edje_edit_part_state.pxi create mode 100644 efl/edje/efl.edje_edit_program.pxi create mode 100644 include/efl.edje_edit.pxd create mode 100644 tests/edje/test_04_edit.py diff --git a/TODO b/TODO index 3ce725d..2d80e31 100644 --- a/TODO +++ b/TODO @@ -3,6 +3,7 @@ BUGS ==== * Evas: smart object doesn't work +* EdjeEdit: PartState API does not work * Docs: GenlistWidget is documented instead of Genlist (all the scrollable are affected) @@ -22,7 +23,6 @@ TODO * ecore.FileMonitor * alert on signal and subprocess module usage (was in python-ecore/ecore/__init__.py) * evas.SmartObject -* edje.Edit * edje: complete the unit tests * elm.Web need a test * elm.GestureLayer need a test @@ -39,6 +39,7 @@ TODO * Tests for evas.Textgrid * update links and text on: http://www.freedesktop.org/wiki/Software/DBusBindings + IMAGES ====== @@ -67,6 +68,7 @@ CHANGES FROM 1.7 to 1.8 * added efl container package * ecore.file.Download => efl.ecore.FileDownload +* edje.edit.EdjeEdit => efl.edje_edit.EdjeEdit * Emotion(module_filename="xxx") => Emotion(module_name="xxx") * elementary.need_e_dbus => elementary.need_edbus * elm.domain_translatable_text_part_set => elm.domain_translatable_part_text_set diff --git a/efl/edje/efl.edje_edit.pyx b/efl/edje/efl.edje_edit.pyx new file mode 100644 index 0000000..224f12a --- /dev/null +++ b/efl/edje/efl.edje_edit.pyx @@ -0,0 +1,495 @@ +# Copyright (C) 2007-2013 various contributors (see AUTHORS) +# +# This file is part of Python-EFL. +# +# Python-EFL 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; either +# version 2.1 of the License, or (at your option) any later version. +# +# Python-EFL 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 Python-EFL. If not, see . + +from efl.eo cimport _touni, _ctouni, convert_eina_list_strings_to_python_list +from efl.edje cimport Edje_Part_Type +from efl.edje import EDJE_PART_TYPE_EXTERNAL + + +# Edje_Edit_Image_Comp +EDJE_EDIT_IMAGE_COMP_RAW = 0 +EDJE_EDIT_IMAGE_COMP_USER = 1 +EDJE_EDIT_IMAGE_COMP_COMP = 2 +EDJE_EDIT_IMAGE_COMP_LOSSY = 3 + + +cdef class EdjeEdit(Edje): + + def __init__(self, Canvas canvas not None, **kargs): + self._set_obj(edje_edit_object_add(canvas.obj)) + self._set_common_params(**kargs) + + # General + def compiler_get(self): + cdef const_char *s = edje_edit_compiler_get(self.obj) + r = _ctouni(s) + if s != NULL: + edje_edit_string_free(s) + return r + + def save(self): + return bool(edje_edit_save(self.obj)) + + def save_all(self): + return bool(edje_edit_save_all(self.obj)) + + def print_internal_status(self): + edje_edit_print_internal_status(self.obj) + + # Group + property current_group: + def __get__(self): + return Group(self) + + def group_add(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_group_add(self.obj, + name if name is not None else NULL)) + + def group_del(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_group_del(self.obj, + name if name is not None else NULL)) + + def group_exist(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_group_exist(self.obj, + name if name is not None else NULL)) + + # Data + property data: + def __get__(self): + cdef: + Eina_List *lst + list ret + lst = edje_edit_data_list_get(self.obj) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def data_get(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + cdef const_char *val = edje_edit_data_value_get(self.obj, + name if name is not None else NULL) + r = _ctouni(val) + edje_edit_string_free(val) + return r + + def data_set(self, name, value): + if isinstance(name, unicode): name = name.encode("UTF-8") + if isinstance(value, unicode): value = value.encode("UTF-8") + + return bool(edje_edit_data_value_set(self.obj, + name if name is not None else NULL, + value if value is not None else NULL)) + + def data_add(self, name, value): + if isinstance(name, unicode): name = name.encode("UTF-8") + if isinstance(value, unicode): value = value.encode("UTF-8") + return bool(edje_edit_data_add(self.obj, + name if name is not None else NULL, + value if value is not None else NULL)) + + def data_rename(self, old, new): + if isinstance(old, unicode): old = old.encode("UTF-8") + if isinstance(new, unicode): new = new.encode("UTF-8") + return bool(edje_edit_data_name_set(self.obj, + old if old is not None else NULL, + new if new is not None else NULL)) + + def data_del(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_data_del(self.obj, + name if name is not None else NULL)) + + # Group Data + property group_data: + def __get__(self): + cdef: + Eina_List *lst + list ret + lst = edje_edit_group_data_list_get(self.obj) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def group_data_get(self, name): + cdef const_char *val + if isinstance(name, unicode): name = name.encode("UTF-8") + val = edje_edit_group_data_value_get(self.obj, + name if name is not None else NULL) + r = _ctouni(val) + edje_edit_string_free(val) + return r + + def group_data_set(self, name, value): + if isinstance(name, unicode): name = name.encode("UTF-8") + if isinstance(value, unicode): value = value.encode("UTF-8") + return bool(edje_edit_group_data_value_set(self.obj, + name if name is not None else NULL, + value if value is not None else NULL)) + + def group_data_add(self, name, value): + if isinstance(name, unicode): name = name.encode("UTF-8") + if isinstance(value, unicode): value = value.encode("UTF-8") + return bool(edje_edit_group_data_add(self.obj, + name if name is not None else NULL, + value if value is not None else NULL)) + + def group_data_rename(self, old, new): + if isinstance(old, unicode): old = old.encode("UTF-8") + if isinstance(new, unicode): new = new.encode("UTF-8") + return bool(edje_edit_group_data_name_set(self.obj, + old if old is not None else NULL, + new if new is not None else NULL)) + + def group_data_del(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_group_data_del(self.obj, + name if name is not None else NULL)) + + # Text Style + property text_styles: + def __get__(self): + cdef Eina_List *lst + lst = edje_edit_styles_list_get(self.obj) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def text_style_get(self, name): + return Text_Style(self, name) + + def text_style_add(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_style_add(self.obj, + name if name is not None else NULL)) + + def text_style_del(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + edje_edit_style_del(self.obj, + name if name is not None else NULL) + return True + + # Color Classes + property color_classes: + def __get__(self): + cdef Eina_List *lst + lst = edje_edit_color_classes_list_get(self.obj) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def color_class_get(self, name): + return Color_Class(self, name) + + def color_class_add(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_color_class_add(self.obj, + name if name is not None else NULL)) + + def color_class_del(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_color_class_del(self.obj, + name if name is not None else NULL)) + + # Externals + property externals: + def __get__(self): + cdef Eina_List *lst + lst = edje_edit_externals_list_get(self.obj) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def external_add(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_external_add(self.obj, + name if name is not None else NULL)) + + def external_del(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_external_del(self.obj, + name if name is not None else NULL)) + + # Fonts + property fonts: + def __get__(self): + cdef Eina_List *lst + lst = edje_edit_fonts_list_get(self.obj) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def font_add(self, font, alias=None): + if isinstance(font, unicode): font = font.encode("UTF-8") + if isinstance(alias, unicode): alias = alias.encode("UTF-8") + return bool(edje_edit_font_add(self.obj, + font if font is not None else NULL, + alias if alias is not None else NULL)) + + def font_del(self, alias): + if isinstance(alias, unicode): alias = alias.encode("UTF-8") + return bool(edje_edit_font_del(self.obj, + alias if alias is not None else NULL)) + + # Parts + property parts: + def __get__(self): + cdef Eina_List *lst + lst = edje_edit_parts_list_get(self.obj) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def part_get(self, name): + if self.part_exist(name): + return Part(self, name) + return None + + def part_add(self, name, int type, char *source=""): + if isinstance(name, unicode): name = name.encode("UTF-8") + if type != EDJE_PART_TYPE_EXTERNAL: + return bool(edje_edit_part_add(self.obj, + name if name is not None else NULL, + type)) + else: + return bool(edje_edit_part_external_add(self.obj, name, source)) + + def part_del(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_part_del(self.obj, + name if name is not None else NULL)) + + def part_exist(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_part_exist(self.obj, + name if name is not None else NULL)) + + # Images + property images: + def __get__(self): + cdef Eina_List *lst + lst = edje_edit_images_list_get(self.obj) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def image_id_get(self, image): + if isinstance(image, unicode): image = image.encode("UTF-8") + return edje_edit_image_id_get(self.obj, + image if image is not None else NULL) + + def image_add(self, path): + if isinstance(path, unicode): path = path.encode("UTF-8") + return bool(edje_edit_image_add(self.obj, + path if path is not None else NULL)) + + def image_del(self, image): + if isinstance(image, unicode): image = image.encode("UTF-8") + return bool(edje_edit_image_del(self.obj, + image if image is not None else NULL)) + + # Programs + property programs: + def __get__(self): + cdef Eina_List *lst + lst = edje_edit_programs_list_get(self.obj) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def program_get(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + if self.program_exist(name): + return Program(self, name) + return None + + def program_add(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_program_add(self.obj, + name if name is not None else NULL)) + + def program_del(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_program_del(self.obj, + name if name is not None else NULL)) + + def program_exist(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_program_exist(self.obj, + name if name is not None else NULL)) + """ + property error: + def __get__(self): + last_error = c_evas.eina_error_get() + if last_error: + return c_evas.eina_error_msg_get(last_error) + + return None + """ + + # Scripts + property script: + def __get__(self): + cdef char *code + code = edje_edit_script_get(self.obj) + ret = _touni(code) + free(code) + return ret + + def __set__(self, code): + if isinstance(code, unicode): code = code.encode("UTF-8") + edje_edit_script_set(self.obj, + code if code is not None else NULL) + + def __del__(self): + edje_edit_script_set(self.obj, NULL) + + def script_compile(self): + return bool(edje_edit_script_compile(self.obj)) + + property script_errors: + def __get__(self): + cdef const_Eina_List *lst + cdef Edje_Edit_Script_Error *se + ret = [] + lst = edje_edit_script_error_list_get(self.obj) + while lst: + se = lst.data + if se.program_name != NULL: + pr = se.program_name + else: + pr = '' + err = (pr, _ctouni(se.error_str)) + ret.append(err) + lst = lst.next + return ret + + +cdef class Text_Style(object): + cdef EdjeEdit edje + cdef object name + + def __init__(self, EdjeEdit e, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + self.edje = e + self.name = name + + property tags: + def __get__(self): + cdef Eina_List *lst + lst = edje_edit_style_tags_list_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def tag_get(self, name): + return Text_Style_Tag(self, name) + + def tag_add(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_style_tag_add(self.edje.obj, self.name, + name if name is not None else NULL)) + + def tag_del(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + edje_edit_style_tag_del(self.edje.obj, self.name, + name if name is not None else NULL) + return True + + +cdef class Text_Style_Tag(object): + cdef Text_Style text_style + cdef object name + + def __init__(self, Text_Style text_style, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + self.text_style = text_style + self.name = name + + property value: + def __get__(self): + cdef const_char *val + val = edje_edit_style_tag_value_get(self.text_style.edje.obj, + self.text_style.name, + self.name if self.name is not None else NULL) + ret = _ctouni(val) + edje_edit_string_free(val) + return ret + def __set__(self, value): + if isinstance(value, unicode): value = value.encode("UTF-8") + edje_edit_style_tag_value_set(self.text_style.edje.obj, + self.text_style.name, self.name, + value if value is not None else NULL) + + def rename(self, newname): + if isinstance(newname, unicode): newname = newname.encode("UTF-8") + edje_edit_style_tag_name_set(self.text_style.edje.obj, + self.text_style.name, + self.name if self.name is not None else NULL, + newname if newname is not None else NULL) + self.name = newname if newname is not None else NULL + return True + + +cdef class Color_Class(object): + cdef EdjeEdit edje + cdef object name + + def __init__(self, EdjeEdit e, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + self.edje = e + self.name = name + + property name: + def __get__(self): + return self.name.decode('UTF-8', 'strict') + + def __set__(self, newname): + self.rename(newname) + + def rename(self, newname): + cdef Eina_Bool ret + if isinstance(newname, unicode): newname = newname.encode("UTF-8") + ret = edje_edit_color_class_name_set(self.edje.obj, + self.name if self.name is not None else NULL, + newname if newname is not None else NULL) + if ret == 0: + return False + self.name = newname + return True + + def colors_get(self): + cdef int r, g, b, a, r2, g2, b2, a2, r3, g3, b3, a3 + edje_edit_color_class_colors_get(self.edje.obj, self.name, + &r, &g, &b, &a, &r2, &g2, &b2, &a2, &r3, &g3, &b3, &a3) + return ((r, g, b, a), (r2, g2, b2, a2), (r3, g3, b3, a3)) + + def colors_set(self, int r, int g, int b, int a, + int r2, int g2, int b2, int a2, + int r3, int g3, int b3, int a3): + edje_edit_color_class_colors_set(self.edje.obj, self.name, + r, g, b, a, r2, g2, b2, a2, r3, g3, b3, a3) + + +include "efl.edje_edit_group.pxi" +include "efl.edje_edit_part.pxi" +include "efl.edje_edit_part_state.pxi" +include "efl.edje_edit_program.pxi" + diff --git a/efl/edje/efl.edje_edit_group.pxi b/efl/edje/efl.edje_edit_group.pxi new file mode 100644 index 0000000..60eb4b0 --- /dev/null +++ b/efl/edje/efl.edje_edit_group.pxi @@ -0,0 +1,56 @@ +# Copyright (C) 2007-2013 various contributors (see AUTHORS) +# +# This file is part of Python-EFL. +# +# Python-EFL 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; either +# version 2.1 of the License, or (at your option) any later version. +# +# Python-EFL 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 Python-EFL. If not, see . + + +cdef class Group(object): + cdef EdjeEdit edje + + def __init__(self, EdjeEdit e): + self.edje = e + + def delete(self): + return False + + property w_min: # TODO rename to min_w !! + def __get__(self): + return edje_edit_group_min_w_get(self.edje.obj) + def __set__(self, value): + edje_edit_group_min_w_set(self.edje.obj, value) + + property w_max: # TODO rename to max_w !! + def __get__(self): + return edje_edit_group_max_w_get(self.edje.obj) + def __set__(self, value): + edje_edit_group_max_w_set(self.edje.obj, value) + + property h_min: # TODO rename to min_h !! + def __get__(self): + return edje_edit_group_min_h_get(self.edje.obj) + def __set__(self, value): + edje_edit_group_min_h_set(self.edje.obj, value) + + property h_max: # TODO rename to max_h !! + def __get__(self): + return edje_edit_group_max_h_get(self.edje.obj) + def __set__(self, value): + edje_edit_group_max_h_set(self.edje.obj, value) + + def rename(self, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + return bool(edje_edit_group_name_set(self.edje.obj, + name if name is not None else NULL)) + diff --git a/efl/edje/efl.edje_edit_part.pxi b/efl/edje/efl.edje_edit_part.pxi new file mode 100644 index 0000000..8332cfb --- /dev/null +++ b/efl/edje/efl.edje_edit_part.pxi @@ -0,0 +1,331 @@ +# Copyright (C) 2007-2013 various contributors (see AUTHORS) +# +# This file is part of Python-EFL. +# +# Python-EFL 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; either +# version 2.1 of the License, or (at your option) any later version. +# +# Python-EFL 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 Python-EFL. If not, see . + + +cdef class Part(object): + cdef EdjeEdit edje + cdef object name + + def __init__(self, EdjeEdit e, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + self.edje = e + self.name = name + + property name: + def __get__(self): + return self.name.decode('UTF-8', 'strict') + def __set__(self, name): + self.rename(name) + + def rename(self, newname): + cdef Eina_Bool ret + if isinstance(newname, unicode): newname = newname.encode("UTF-8") + ret = edje_edit_part_name_set(self.edje.obj, + self.name if self.name is not None else NULL, + newname if newname is not None else NULL) + if ret == 0: + return False + self.name = newname + return True + + def above_get(self): + cdef: + const_char *part + object ret + part = edje_edit_part_above_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _ctouni(part) + edje_edit_string_free(part) + return ret + + def below_get(self): + cdef: + const_char *part + object ret + part = edje_edit_part_below_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _ctouni(part) + edje_edit_string_free(part) + return ret + + def restack_below(self): + return bool(edje_edit_part_restack_below(self.edje.obj, + self.name if self.name is not None else NULL)) + + def restack_above(self): + return bool(edje_edit_part_restack_above(self.edje.obj, + self.name if self.name is not None else NULL)) + + property type: + def __get__(self): + return edje_edit_part_type_get(self.edje.obj, + self.name if self.name is not None else NULL) + + + property states: + def __get__(self): + cdef Eina_List *lst + lst = edje_edit_part_states_list_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def state_get(self, sname, double value=0.0): + if self.state_exist(sname, value): + return State(self, sname, value) + + def state_add(self, sname, double value=0.0): + if isinstance(sname, unicode): sname = sname.encode("UTF-8") + return bool(edje_edit_state_add(self.edje.obj, + self.name if self.name is not None else NULL, + sname if sname is not None else NULL, + value)) + + def state_del(self, sname, double value=0.0): + if isinstance(sname, unicode): sname = sname.encode("UTF-8") + return bool(edje_edit_state_del(self.edje.obj, + self.name if self.name is not None else NULL, + sname if sname is not None else NULL, + value)) + + def state_exist(self, sname, double value=0.0): + if isinstance(sname, unicode): sname = sname.encode("UTF-8") + return bool(edje_edit_state_exist(self.edje.obj, + self.name if self.name is not None else NULL, + sname if sname is not None else NULL, + value)) + + def state_copy(self, sfrom, double vfrom, sto, double vto): + if isinstance(sfrom, unicode): sfrom = sfrom.encode("UTF-8") + if isinstance(sto, unicode): sto = sto.encode("UTF-8") + return bool(edje_edit_state_copy(self.edje.obj, + self.name if self.name is not None else NULL, + sfrom if sfrom is not None else NULL, vfrom, + sto if sto is not None else NULL, vto)) + + def state_selected_get(self): + cdef const_char *sel + cdef double val + sel = edje_edit_part_selected_state_get(self.edje.obj, + self.name if self.name is not None else NULL, &val) + if sel == NULL: return None + r = _ctouni(sel) + v = val + edje_edit_string_free(sel) + return (r, v) + + def state_selected_set(self, state, double value=0.0): + if isinstance(state, unicode): state = state.encode("UTF-8") + edje_edit_part_selected_state_set(self.edje.obj, + self.name if self.name is not None else NULL, + state if state is not None else NULL, + value) + + property clip_to: + def __get__(self): + cdef const_char *clipper + clipper = edje_edit_part_clip_to_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _ctouni(clipper) + edje_edit_string_free(clipper) + return ret + + def __set__(self, clipper): + if isinstance(clipper, unicode): clipper = clipper.encode("UTF-8") + edje_edit_part_clip_to_set(self.edje.obj, + self.name if self.name is not None else NULL, + clipper if clipper is not None else NULL) + + def __del__(self): + edje_edit_part_clip_to_set(self.edje.obj, + self.name if self.name is not None else NULL, + NULL) + + property source: + def __get__(self): + cdef const_char *source + source = edje_edit_part_source_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _ctouni(source) + edje_edit_string_free(source) + return ret + + def __set__(self, source): + if isinstance(source, unicode): source = source.encode("UTF-8") + edje_edit_part_source_set(self.edje.obj, + self.name if self.name is not None else NULL, + source if source is not None else NULL) + + def __del__(self): + edje_edit_part_source_set(self.edje.obj, + self.name if self.name is not None else NULL, + NULL) + + property mouse_events: + def __get__(self): + return bool(edje_edit_part_mouse_events_get(self.edje.obj, + self.name if self.name is not None else NULL)) + + def __set__(self, me): + edje_edit_part_mouse_events_set(self.edje.obj, + self.name if self.name is not None else NULL, + 1 if me else 0) + + property repeat_events: + def __get__(self): + return bool(edje_edit_part_repeat_events_get(self.edje.obj, + self.name if self.name is not None else NULL)) + + def __set__(self, re): + edje_edit_part_repeat_events_set(self.edje.obj, + self.name if self.name is not None else NULL, + 1 if re else 0) + + property effect: + def __get__(self): + return edje_edit_part_effect_get(self.edje.obj, + self.name if self.name is not None else NULL) + + def __set__(self, effect): + edje_edit_part_effect_set(self.edje.obj, + self.name if self.name is not None else NULL, + effect) + + property ignore_flags: + def __get__(self): + return edje_edit_part_ignore_flags_get(self.edje.obj, + self.name if self.name is not None else NULL) + + def __set__(self, flags): + edje_edit_part_ignore_flags_set(self.edje.obj, + self.name if self.name is not None else NULL, + flags) + + property scale: + def __get__(self): + return bool(edje_edit_part_scale_get(self.edje.obj, + self.name if self.name is not None else NULL)) + + def __set__(self, scale): + edje_edit_part_scale_set(self.edje.obj, + self.name if self.name is not None else NULL, + 1 if scale else 0) + + property drag: + def __get__(self): + cdef int x, y + x = edje_edit_part_drag_x_get(self.edje.obj, + self.name if self.name is not None else NULL) + y = edje_edit_part_drag_y_get(self.edje.obj, + self.name if self.name is not None else NULL) + return (x, y) + + def __set__(self, val): + x, y = val + edje_edit_part_drag_x_set(self.edje.obj, + self.name if self.name is not None else NULL, x) + edje_edit_part_drag_y_set(self.edje.obj, + self.name if self.name is not None else NULL, y) + + property drag_step: + def __get__(self): + cdef int x, y + x = edje_edit_part_drag_step_x_get(self.edje.obj, + self.name if self.name is not None else NULL) + y = edje_edit_part_drag_step_y_get(self.edje.obj, + self.name if self.name is not None else NULL) + return (x, y) + + def __set__(self, val): + x, y = val + edje_edit_part_drag_step_x_set(self.edje.obj, + self.name if self.name is not None else NULL, x) + edje_edit_part_drag_step_y_set(self.edje.obj, + self.name if self.name is not None else NULL, y) + + property drag_count: + def __get__(self): + cdef int x, y + x = edje_edit_part_drag_count_x_get(self.edje.obj, + self.name if self.name is not None else NULL) + y = edje_edit_part_drag_count_y_get(self.edje.obj, + self.name if self.name is not None else NULL) + return (x, y) + + def __set__(self, val): + x, y = val + edje_edit_part_drag_count_x_set(self.edje.obj, + self.name if self.name is not None else NULL, x) + edje_edit_part_drag_count_y_set(self.edje.obj, + self.name if self.name is not None else NULL, y) + + property drag_confine: + def __get__(self): + cdef const_char *confine + confine = edje_edit_part_drag_confine_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _ctouni(confine) + edje_edit_string_free(confine) + return ret + + def __set__(self, confine): + if isinstance(confine, unicode): confine = confine.encode("UTF-8") + edje_edit_part_drag_confine_set(self.edje.obj, + self.name if self.name is not None else NULL, + confine if confine is not None else NULL) + + property drag_event: + def __get__(self): + cdef const_char *event + event = edje_edit_part_drag_event_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _ctouni(event) + edje_edit_string_free(event) + return ret + + def __set__(self, event): + if isinstance(event, unicode): event = event.encode("UTF-8") + edje_edit_part_drag_event_set(self.edje.obj, + self.name if self.name is not None else NULL, + event if event is not None else NULL) + + property api: + def __get__(self): + cdef: + const_char *name + const_char *description + name = edje_edit_part_api_name_get(self.edje.obj, + self.name if self.name is not None else NULL) + description = edje_edit_part_api_description_get(self.edje.obj, + self.name if self.name is not None else NULL) + n, d = _ctouni(name), _ctouni(description) + edje_edit_string_free(name) + edje_edit_string_free(description) + return (n, d) + + def __set__(self, value): + cdef object name, desc + name, desc = value + if isinstance(name, unicode): name = name.encode("UTF-8") + if isinstance(desc, unicode): desc = desc.encode("UTF-8") + edje_edit_part_api_name_set(self.edje.obj, + self.name if self.name is not None else NULL, + name if name is not None else NULL) + edje_edit_part_api_description_set(self.edje.obj, + self.name if self.name is not None else NULL, + desc if desc is not None else NULL) diff --git a/efl/edje/efl.edje_edit_part_state.pxi b/efl/edje/efl.edje_edit_part_state.pxi new file mode 100644 index 0000000..8c4b69d --- /dev/null +++ b/efl/edje/efl.edje_edit_part_state.pxi @@ -0,0 +1,851 @@ +# Copyright (C) 2007-2013 various contributors (see AUTHORS) +# +# This file is part of Python-EFL. +# +# Python-EFL 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; either +# version 2.1 of the License, or (at your option) any later version. +# +# Python-EFL 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 Python-EFL. If not, see . + + +cdef class State: + cdef EdjeEdit edje + cdef object part + cdef object name + cdef object part_obj + cdef object value + + def __init__(self, Part part, name, double value=0.0): + if isinstance(name, unicode): name = name.encode("UTF-8") + self.part_obj = part + self.edje = part.edje + self.part = part.name + self.name = name + self.value = value + + property name: + def __get__(self): + return self.name + + property value: + def __get__(self): + return self.value + + def part_get(self): + return self.part_obj + + def name_set(self, new_name, new_value=None): + if new_value == None: + new_value = self.value + return bool(edje_edit_state_name_set(self.edje.obj, self.part, + self.name, self.value, new_name, + new_value)) + """ + def copy_from(self, from_state, from_value=0.0): + return bool(edje_edit_state_copy(self.edje.obj, self.part, + from_state, from_value, self.name, + self.value)) + """ + def rel1_to_get(self): + cdef const_char *tx, *ty + tx = edje_edit_state_rel1_to_x_get(self.edje.obj, self.part, self.name, + self.value) + ty = edje_edit_state_rel1_to_y_get(self.edje.obj, self.part, self.name, + self.value) + if tx != NULL: + x = tx + edje_edit_string_free(tx) + else: + x = None + + if ty != NULL: + y = ty + edje_edit_string_free(ty) + else: + y = None + + return (x, y) + """ + def rel1_to_set(self, x, y): + if x: + edje_edit_state_rel1_to_x_set(self.edje.obj, self.part, self.name, + self.value, x) + else: + edje_edit_state_rel1_to_x_set(self.edje.obj, self.part, self.name, + self.value, NULL) + if y: + edje_edit_state_rel1_to_y_set(self.edje.obj, self.part, self.name, + self.value, y) + else: + edje_edit_state_rel1_to_y_set(self.edje.obj, self.part, self.name, + self.value, NULL) + # remove when fixed in edje_edit + edje_edit_part_selected_state_set(self.edje.obj, self.part, self.name, + self.value) + + property rel1_to: + def __get__(self): + return self.rel1_to_get() + def __set__(self, rel1_to): + self.rel1_to_set(*rel1_to) + + def rel1_to_x_set(self, x): + if x: + edje_edit_state_rel1_to_x_set(self.edje.obj, self.part, self.name, + self.value, x) + else: + edje_edit_state_rel1_to_x_set(self.edje.obj, self.part, self.name, + self.value, NULL) + # remove when fixed in edje_edit + edje_edit_part_selected_state_set(self.edje.obj, self.part, self.name, + self.value) + + def rel1_to_y_set(self, y): + if y: + edje_edit_state_rel1_to_y_set(self.edje.obj, self.part, self.name, + self.value, y) + else: + edje_edit_state_rel1_to_y_set(self.edje.obj, self.part, self.name, + self.value, NULL) + # remove when fixed in edje_edit + edje_edit_part_selected_state_set(self.edje.obj, self.part, self.name, + self.value) + + def rel1_relative_get(self): + cdef double x, y + x = edje_edit_state_rel1_relative_x_get(self.edje.obj, self.part, + self.name, self.value) + y = edje_edit_state_rel1_relative_y_get(self.edje.obj, self.part, + self.name, self.value) + return (x, y) + + def rel1_relative_set(self, double x, double y): + edje_edit_state_rel1_relative_x_set(self.edje.obj, self.part, self.name, + self.value, x) + edje_edit_state_rel1_relative_y_set(self.edje.obj, self.part, self.name, + self.value, y) + + property rel1_relative: + def __get__(self): + return self.rel1_relative_get() + def __set__(self, value): + self.rel1_relative_set(*value) + + def rel1_relative_x_set(self, double x): + edje_edit_state_rel1_relative_x_set(self.edje.obj, self.part, self.name, + self.value, x) + + def rel1_relative_y_set(self, double y): + edje_edit_state_rel1_relative_y_set(self.edje.obj, self.part, self.name, + self.value, y) + + def rel1_offset_get(self): + cdef int x, y + x = edje_edit_state_rel1_offset_x_get(self.edje.obj, self.part, + self.name, self.value) + y = edje_edit_state_rel1_offset_y_get(self.edje.obj, self.part, + self.name, self.value) + return (x, y) + + def rel1_offset_set(self, int x, int y): + edje_edit_state_rel1_offset_x_set(self.edje.obj, self.part, self.name, + self.value, x) + edje_edit_state_rel1_offset_y_set(self.edje.obj, self.part, self.name, + self.value, y) + + property rel1_offset: + def __get__(self): + return self.rel1_offset_get() + def __set__(self, value): + self.rel1_offset_set(*value) + + def rel1_offset_x_set(self, int x): + edje_edit_state_rel1_offset_x_set(self.edje.obj, self.part, self.name, + self.value, x) + + def rel1_offset_y_set(self, int y): + edje_edit_state_rel1_offset_y_set(self.edje.obj, self.part, self.name, + self.value, y) + + def rel2_to_get(self): + cdef const_char_ptr tx, ty + tx = edje_edit_state_rel2_to_x_get(self.edje.obj, self.part, self.name, + self.value) + ty = edje_edit_state_rel2_to_y_get(self.edje.obj, self.part, self.name, + self.value) + if tx != NULL: + x = tx + edje_edit_string_free(tx) + else: + x = None + + if ty != NULL: + y = ty + edje_edit_string_free(ty) + else: + y = None + + return (x, y) + + def rel2_to_set(self, x, y): + if x: + edje_edit_state_rel2_to_x_set(self.edje.obj, self.part, self.name, + self.value, x) + else: + edje_edit_state_rel2_to_x_set(self.edje.obj, self.part, self.name, + self.value, NULL) + if y: + edje_edit_state_rel2_to_y_set(self.edje.obj, self.part, self.name, + self.value, y) + else: + edje_edit_state_rel2_to_y_set(self.edje.obj, self.part, self.name, + self.value, NULL) + # remove when fixed in edje_edit + edje_edit_part_selected_state_set(self.edje.obj, self.part, self.name, + self.value) + + property rel2_to: + def __get__(self): + return self.rel2_to_get() + def __set__(self, rel2_to): + self.rel2_to_set(*rel2_to) + + def rel2_to_x_set(self, x): + if x: + edje_edit_state_rel2_to_x_set(self.edje.obj, self.part, self.name, + self.value, x) + else: + edje_edit_state_rel2_to_x_set(self.edje.obj, self.part, self.name, + self.value, NULL) + # remove when fixed in edje_edit + edje_edit_part_selected_state_set(self.edje.obj, self.part, self.name, + self.value) + def rel2_to_y_set(self, y): + if y: + edje_edit_state_rel2_to_y_set(self.edje.obj, self.part, self.name, + self.value, y) + else: + edje_edit_state_rel2_to_y_set(self.edje.obj, self.part, self.name, + self.value, NULL) + # remove when fixed in edje_edit + edje_edit_part_selected_state_set(self.edje.obj, self.part, self.name, + self.value) + + def rel2_relative_get(self): + cdef double x, y + x = edje_edit_state_rel2_relative_x_get(self.edje.obj, self.part, + self.name, self.value) + y = edje_edit_state_rel2_relative_y_get(self.edje.obj, self.part, + self.name, self.value) + return (x, y) + + def rel2_relative_set(self, double x, double y): + edje_edit_state_rel2_relative_x_set(self.edje.obj, self.part, self.name, + self.value, x) + edje_edit_state_rel2_relative_y_set(self.edje.obj, self.part, self.name, + self.value, y) + + property rel2_relative: + def __get__(self): + return self.rel2_relative_get() + def __set__(self, value): + self.rel2_relative_set(*value) + + def rel2_relative_x_set(self, double x): + edje_edit_state_rel2_relative_x_set(self.edje.obj, self.part, self.name, + self.value, x) + def rel2_relative_y_set(self, double y): + edje_edit_state_rel2_relative_y_set(self.edje.obj, self.part, self.name, + self.value, y) + + def rel2_offset_get(self): + cdef int x, y + x = edje_edit_state_rel2_offset_x_get(self.edje.obj, self.part, + self.name, self.value) + y = edje_edit_state_rel2_offset_y_get(self.edje.obj, self.part, + self.name, self.value) + return (x, y) + + def rel2_offset_set(self, int x, int y): + edje_edit_state_rel2_offset_x_set(self.edje.obj, self.part, self.name, + self.value, x) + edje_edit_state_rel2_offset_y_set(self.edje.obj, self.part, self.name, + self.value, y) + + property rel2_offset: + def __get__(self): + return self.rel2_offset_get() + def __set__(self, value): + self.rel2_offset_set(*value) + + def rel2_offset_x_set(self, int x): + edje_edit_state_rel2_offset_x_set(self.edje.obj, self.part, self.name, + self.value, x) + def rel2_offset_y_set(self, int y): + edje_edit_state_rel2_offset_y_set(self.edje.obj, self.part, self.name, + self.value, y) + + def color_get(self): + cdef int r, g, b, a + edje_edit_state_color_get(self.edje.obj, self.part, self.name, + self.value, &r, &g, &b, &a) + return (r, g, b, a) + + def color_set(self, int r, int g, int b, int a): + edje_edit_state_color_set(self.edje.obj, self.part, self.name, + self.value, r, g, b, a) + + property color: + def __get__(self): + return self.color_get() + def __set__(self, color): + self.color_set(*color) + + def color2_get(self): + cdef int r, g, b, a + edje_edit_state_color2_get(self.edje.obj, self.part, self.name, + self.value, &r, &g, &b, &a) + return (r, g, b, a) + + def color2_set(self, int r, int g, int b, int a): + edje_edit_state_color2_set(self.edje.obj, self.part, self.name, + self.value, r, g, b, a) + + property color2: + def __get__(self): + return self.color2_get() + def __set__(self, color): + self.color2_set(*color) + + def color3_get(self): + cdef int r, g, b, a + edje_edit_state_color3_get(self.edje.obj, self.part, self.name, + self.value, &r, &g, &b, &a) + return (r, g, b, a) + + def color3_set(self, int r, int g, int b, int a): + edje_edit_state_color3_set(self.edje.obj, self.part, self.name, + self.value, r, g, b, a) + + property color3: + def __get__(self): + return self.color3_get() + def __set__(self, color): + self.color3_set(*color) + + def align_get(self): + cdef double x, y + x = edje_edit_state_align_x_get(self.edje.obj, self.part, self.name, + self.value) + y = edje_edit_state_align_y_get(self.edje.obj, self.part, self.name, + self.value) + return (x, y) + + def align_set(self, double x, double y): + edje_edit_state_align_x_set(self.edje.obj, self.part, self.name, + self.value, x) + edje_edit_state_align_y_set(self.edje.obj, self.part, self.name, + self.value, y) + + property align: + def __get__(self): + return self.align_get() + def __set__(self, align): + self.align_set(*align) + + def min_get(self): + cdef int w, h + w = edje_edit_state_min_w_get(self.edje.obj, self.part, self.name, + self.value) + h = edje_edit_state_min_h_get(self.edje.obj, self.part, self.name, + self.value) + return (w, h) + + def min_set(self, int w, int h): + edje_edit_state_min_w_set(self.edje.obj, self.part, self.name, + self.value, w) + edje_edit_state_min_h_set(self.edje.obj, self.part, self.name, + self.value, h) + + property min: + def __get__(self): + return self.min_get() + def __set__(self, min): + self.min_set(*min) + + def max_get(self): + cdef int w, h + w = edje_edit_state_max_w_get(self.edje.obj, self.part, self.name, + self.value) + h = edje_edit_state_max_h_get(self.edje.obj, self.part, self.name, + self.value) + return (w, h) + + def max_set(self, int w, int h): + edje_edit_state_max_w_set(self.edje.obj, self.part, self.name, + self.value, w) + edje_edit_state_max_h_set(self.edje.obj, self.part, self.name, + self.value, h) + + property max: + def __get__(self): + return self.max_get() + def __set__(self, max): + self.max_set(*max) + + def aspect_min_get(self): + return edje_edit_state_aspect_min_get(self.edje.obj, self.part, + self.name, self.value) + + def aspect_min_set(self, double a): + edje_edit_state_aspect_min_set(self.edje.obj, self.part, self.name, + self.value, a) + + def aspect_max_get(self): + return edje_edit_state_aspect_max_get(self.edje.obj, self.part, + self.name, self.value) + + def aspect_max_set(self, double a): + edje_edit_state_aspect_max_set(self.edje.obj, self.part, self.name, + self.value, a) + + def aspect_pref_get(self): + return edje_edit_state_aspect_pref_get(self.edje.obj, self.part, + self.name, self.value) + + def aspect_pref_set(self, char a): + edje_edit_state_aspect_pref_set(self.edje.obj, self.part, self.name, + self.value, a) + + def fill_origin_relative_get(self): + cdef double x, y + x = edje_edit_state_fill_origin_relative_x_get(self.edje.obj, self.part, + self.name, self.value) + y = edje_edit_state_fill_origin_relative_y_get(self.edje.obj, self.part, + self.name, self.value) + return (x, y) + + def fill_origin_relative_set(self, double x, double y): + edje_edit_state_fill_origin_relative_x_set(self.edje.obj, self.part, + self.name, self.value, x) + edje_edit_state_fill_origin_relative_y_set(self.edje.obj, self.part, + self.name, self.value, y) + + def fill_origin_offset_get(self): + cdef int x, y + x = edje_edit_state_fill_origin_offset_x_get(self.edje.obj, self.part, + self.name, self.value) + y = edje_edit_state_fill_origin_offset_y_get(self.edje.obj, self.part, + self.name, self.value) + return (x, y) + + def fill_origin_offset_set(self, x, y): + edje_edit_state_fill_origin_offset_x_set(self.edje.obj, self.part, + self.name, self.value, x) + edje_edit_state_fill_origin_offset_y_set(self.edje.obj, self.part, + self.name, self.value, y) + + def fill_size_relative_get(self): + cdef double x, y + x = edje_edit_state_fill_size_relative_x_get(self.edje.obj, self.part, + self.name, self.value) + y = edje_edit_state_fill_size_relative_y_get(self.edje.obj, self.part, + self.name, self.value) + return (x, y) + + def fill_size_relative_set(self, double x, double y): + edje_edit_state_fill_size_relative_x_set(self.edje.obj, self.part, + self.name, self.value, x) + edje_edit_state_fill_size_relative_y_set(self.edje.obj, self.part, + self.name, self.value, y) + + def fill_size_offset_get(self): + cdef int x, y + x = edje_edit_state_fill_size_offset_x_get(self.edje.obj, self.part, + self.name, self.value) + y = edje_edit_state_fill_size_offset_y_get(self.edje.obj, self.part, + self.name, self.value) + return (x, y) + + def fill_size_offset_set(self, x, y): + edje_edit_state_fill_size_offset_x_set(self.edje.obj, self.part, + self.name, self.value, x) + edje_edit_state_fill_size_offset_y_set(self.edje.obj, self.part, + self.name, self.value, y) + + property visible: + def __get__(self): + return bool(edje_edit_state_visible_get(self.edje.obj, self.part, + self.name, self.value)) + def __set__(self, v): + if v: + edje_edit_state_visible_set(self.edje.obj, self.part, self.name, + self.value, 1) + else: + edje_edit_state_visible_set(self.edje.obj, self.part, self.name, self.value, 0) + + def color_class_get(self): + cdef const_char_ptr cc + cc = edje_edit_state_color_class_get(self.edje.obj, self.part, + self.name, self.value) + if cc == NULL: + return None + rcc = cc + edje_edit_string_free(cc) + return rcc + + def color_class_set(self, cc): + if not cc: + edje_edit_state_color_class_set(self.edje.obj, self.part, + self.name, self.value, NULL) + else: + edje_edit_state_color_class_set(self.edje.obj, self.part, + self.name, self.value, cc) + + def external_params_get(self): + cdef evas.c_evas.const_Eina_List *lst + ret = [] + lst = edje_edit_state_external_params_list_get(self.edje.obj, self.part, + self.name, self.value) + while lst: + p = c_edje._ExternalParam_from_ptr(lst.data) + if p is not None: + ret.append(p) + lst = lst.next + return ret + + def external_param_get(self, param): + cdef c_edje.Edje_External_Param_Type type + cdef void *value + cdef const_char_ptr s + + if not edje_edit_state_external_param_get(self.edje.obj, self.part, + self.name, self.value, param, + &type, &value): + return None + if type == edje.c_edje.EDJE_EXTERNAL_PARAM_TYPE_BOOL: + b = (value)[0] + return (type, bool(b)) + elif type == edje.c_edje.EDJE_EXTERNAL_PARAM_TYPE_INT: + i = (value)[0] + return (type, i) + elif type == edje.c_edje.EDJE_EXTERNAL_PARAM_TYPE_DOUBLE: + d = (value)[0] + return (type, d) + elif type == edje.c_edje.EDJE_EXTERNAL_PARAM_TYPE_STRING: + s = value + if s == NULL: + return (type, None) + else: + return (type, s) + elif type == edje.c_edje.EDJE_EXTERNAL_PARAM_TYPE_CHOICE: + s = value + if s == NULL: + return (type, None) + else: + return (type, s) + return None + + def external_param_set(self, param, value): + cdef const_char_ptr expected + + if isinstance(value, bool): + return self.external_param_bool_set(param, value) + elif isinstance(value, (long, int)): + return self.external_param_int_set(param, value) + elif isinstance(value, float): + return self.external_param_double_set(param, value) + elif isinstance(value, str): + t = edje_object_part_external_param_type_get( + self.edje.obj, self.part, param) + if t == edje.c_edje.EDJE_EXTERNAL_PARAM_TYPE_STRING: + return self.external_param_string_set(param, value) + elif t == edje.c_edje.EDJE_EXTERNAL_PARAM_TYPE_CHOICE: + return self.external_param_choice_set(param, value) + + t = edje_object_part_external_param_type_get( + self.edje.obj, self.part, param) + if t >= edje.c_edje.EDJE_EXTERNAL_PARAM_TYPE_MAX: + raise TypeError("no external parameter %s" % (param,)) + else: + expected = edje_external_param_type_str(t) + raise TypeError( + "invalid external parameter %s of (%s), expected %s" % + (param, type(value).__name__, expected)) + + def external_param_int_get(self, param): + cdef int value + + if not edje_edit_state_external_param_int_get(self.edje.obj, self.part, + self.name, self.value, + param, &value): + return None + return value + + def external_param_bool_get(self, param): + cdef evas.c_evas.Eina_Bool value + + if not edje_edit_state_external_param_bool_get( + self.edje.obj, self.part, self.name, self.value, param, &value): + return None + return bool(value) + + def external_param_double_get(self, param): + cdef double value + + if not edje_edit_state_external_param_double_get(self.edje.obj, self.part, + self.name, self.value, + param, &value): + return None + return value + + def external_param_string_get(self, param): + cdef const_char_ptr value + + if not edje_edit_state_external_param_string_get( + self.edje.obj, self.part, self.name, self.value, param, &value): + return None + if value != NULL: + return value + + def external_param_choice_get(self, param): + cdef const_char_ptr value + + if not edje_edit_state_external_param_choice_get( + self.edje.obj, self.part, self.name, self.value, param, &value): + return None + if value != NULL: + return value + + def external_param_int_set(self, param, value): + return bool(edje_edit_state_external_param_int_set(self.edje.obj, + self.part, self.name, + self.value, param, + value)) + + def external_param_bool_set(self, param, value): + return bool(edje_edit_state_external_param_bool_set( + self.edje.obj, self.part, self.name, self.value, param, value)) + + def external_param_double_set(self, param, value): + return bool(edje_edit_state_external_param_double_set(self.edje.obj, + self.part, self.name, + self.value,param, + value)) + + def external_param_string_set(self, param, value): + return bool(edje_edit_state_external_param_string_set(self.edje.obj, + self.part, self.name, + self.value, param, + value)) + + def external_param_choice_set(self, param, value): + return bool(edje_edit_state_external_param_choice_set( + self.edje.obj, self.part, self.name, self.value, param, value)) + + def text_get(self): + cdef const_char_ptr t + t = edje_edit_state_text_get(self.edje.obj, self.part, self.name, + self.value) + if t == NULL: + return None + r = t + edje_edit_string_free(t) + return r + + def text_set(self, t): + edje_edit_state_text_set(self.edje.obj, self.part, self.name, + self.value, t) + + property text: + def __get__(self): + return self.text_get() + def __set__(self, text): + self.text_set(text) + + def font_get(self): + cdef const_char_ptr f + f = edje_edit_state_font_get(self.edje.obj, self.part, self.name, + self.value) + if f == NULL: + return None + r = f + edje_edit_string_free(f) + return r + + def font_set(self, char *f): + edje_edit_state_font_set(self.edje.obj, self.part, self.name, + self.value, f) + + property font: + def __get__(self): + return self.font_get() + def __set__(self, font): + self.font_set(font) + + def text_size_get(self): + return edje_edit_state_text_size_get(self.edje.obj, self.part, + self.name, self.value) + + def text_size_set(self, int s): + edje_edit_state_text_size_set(self.edje.obj, self.part, self.name, + self.value, s) + + property text_size: + def __get__(self): + return self.text_size_get() + def __set__(self, value): + self.text_size_set(value) + + def text_align_get(self): + cdef double x, y + x = edje_edit_state_text_align_x_get(self.edje.obj, self.part, + self.name, self.value) + y = edje_edit_state_text_align_y_get(self.edje.obj, self.part, + self.name, self.value) + return (x, y) + + def text_align_set(self, double x, double y): + edje_edit_state_text_align_x_set(self.edje.obj, self.part, self.name, + self.value, x) + edje_edit_state_text_align_y_set(self.edje.obj, self.part, self.name, + self.value, y) + + property text_align: + def __get__(self): + return self.text_align_get() + def __set__(self, align): + self.text_align_set(*align) + + def text_elipsis_get(self): + return edje_edit_state_text_elipsis_get(self.edje.obj, self.part, + self.name, self.value) + + def text_elipsis_set(self, double e): + edje_edit_state_text_elipsis_set(self.edje.obj, self.part, self.name, + self.value, e) + + property text_elipsis: + def __get__(self): + return self.text_elipsis_get() + def __set__(self, value): + self.text_elipsis_set(value) + + def text_fit_get(self): + x = bool(edje_edit_state_text_fit_x_get(self.edje.obj, self.part, + self.name, self.value)) + y = bool(edje_edit_state_text_fit_y_get(self.edje.obj, self.part, + self.name, self.value)) + return (x, y) + + def text_fit_set(self, x, y): + if x: + edje_edit_state_text_fit_x_set(self.edje.obj, self.part, self.name, + self.value, 1) + else: + edje_edit_state_text_fit_x_set(self.edje.obj, self.part, self.name, + self.value, 0) + if y: + edje_edit_state_text_fit_y_set(self.edje.obj, self.part, self.name, + self.value, 1) + else: + edje_edit_state_text_fit_y_set(self.edje.obj, self.part, self.name, + self.value, 0) + + property text_fit: + def __get__(self): + return self.text_fit_get() + def __set__(self, value): + self.text_fit_set(*value) + + def image_get(self): + cdef const_char_ptr img + img = edje_edit_state_image_get(self.edje.obj, self.part, self.name, + self.value) + if img == NULL: + return None + r = img + edje_edit_string_free(img) + return r + + def image_set(self, char *image): + if not image: + return + + edje_edit_state_image_set(self.edje.obj, self.part, self.name, + self.value, image) + + property image: + def __get__(self): + return self.image_get() + def __set__(self, image): + self.image_set(image) + + def image_border_get(self): + cdef int l, r, t, b + edje_edit_state_image_border_get(self.edje.obj, self.part, self.name, + self.value, &l, &r, &t, &b) + return (l, r, t, b) + + def image_border_set(self, int l, int r, int t, int b): + edje_edit_state_image_border_set(self.edje.obj, self.part, self.name, + self.value, l, r, t, b) + + property image_border: + def __get__(self): + return self.image_border_get() + def __set__(self, value): + self.image_border_set(*value) + + def image_border_fill_get(self): + cdef unsigned char r + r = edje_edit_state_image_border_fill_get(self.edje.obj, self.part, + self.name, self.value) + if r == 0: + return False + return True + + def image_border_fill_set(self, fill): + if fill: + edje_edit_state_image_border_fill_set(self.edje.obj, self.part, + self.name, self.value, 1) + else: + edje_edit_state_image_border_fill_set(self.edje.obj, self.part, + self.name, self.value, 0) + + property image_border_fill: + def __get__(self): + return self.image_border_fill_get() + def __set__(self, value): + self.image_border_fill_set(value) + + property tweens: + def __get__(self): + "@rtype: list of str" + cdef evas.c_evas.Eina_List *lst, *itr + ret = [] + lst = edje_edit_state_tweens_list_get(self.edje.obj, self.part, + self.name, self.value) + itr = lst + while itr: + ret.append(itr.data) + itr = itr.next + edje_edit_string_list_free(lst) + return ret + + def tween_add(self, char *img): + return bool(edje_edit_state_tween_add(self.edje.obj, self.part, + self.name, self.value, img)) + + def tween_del(self, char *img): + return bool(edje_edit_state_tween_del(self.edje.obj, self.part, + self.name, self.value, img)) + """ diff --git a/efl/edje/efl.edje_edit_program.pxi b/efl/edje/efl.edje_edit_program.pxi new file mode 100644 index 0000000..acca7e4 --- /dev/null +++ b/efl/edje/efl.edje_edit_program.pxi @@ -0,0 +1,260 @@ +# Copyright (C) 2007-2013 various contributors (see AUTHORS) +# +# This file is part of Python-EFL. +# +# Python-EFL 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; either +# version 2.1 of the License, or (at your option) any later version. +# +# Python-EFL 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 Python-EFL. If not, see . + + +cdef class Program(object): + cdef EdjeEdit edje + cdef object name + + def __init__(self, EdjeEdit e, name): + if isinstance(name, unicode): name = name.encode("UTF-8") + self.edje = e + self.name = name + + property name: + def __get__(self): + return self.name.decode('UTF-8', 'strict') + + def __set__(self, newname): + self.rename(newname) + + def rename(self, newname): + cdef Eina_Bool ret + if isinstance(newname, unicode): newname = newname.encode("UTF-8") + ret = edje_edit_program_name_set(self.edje.obj, + self.name if self.name is not None else NULL, + newname if newname is not None else NULL) + if ret == 0: + return False + self.name = newname + return True + + def edje_get(self): + return self.edje + + def run(self): + return bool(edje_edit_program_run(self.edje.obj, + self.name if self.name is not None else NULL)) + + # XXX TODO: add (or better convert) all this to properties + # like is done in Part() + def source_get(self): + cdef const_char *s + s = edje_edit_program_source_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _ctouni(s) + edje_edit_string_free(s) + return ret + + def source_set(self, source): + if isinstance(source, unicode): source = source.encode("UTF-8") + return bool(edje_edit_program_source_set(self.edje.obj, + self.name if self.name is not None else NULL, + source if source is not None else NULL)) + + def signal_get(self): + cdef const_char *s + s = edje_edit_program_signal_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _ctouni(s) + edje_edit_string_free(s) + return ret + + def signal_set(self, signal): + if isinstance(signal, unicode): signal = signal.encode("UTF-8") + return bool(edje_edit_program_signal_set(self.edje.obj, + self.name if self.name is not None else NULL, + signal if signal is not None else NULL)) + + def in_from_get(self): + return edje_edit_program_in_from_get(self.edje.obj, + self.name if self.name is not None else NULL) + + def in_from_set(self, double f): + return bool(edje_edit_program_in_from_set(self.edje.obj, + self.name if self.name is not None else NULL, f)) + + def in_range_get(self): + return edje_edit_program_in_range_get(self.edje.obj, + self.name if self.name is not None else NULL) + + def in_range_set(self, double r): + return bool(edje_edit_program_in_range_set(self.edje.obj, + self.name if self.name is not None else NULL, r)) + + def action_get(self): + return edje_edit_program_action_get(self.edje.obj, + self.name if self.name is not None else NULL) + + def action_set(self, action): + if isinstance(action, unicode): action = action.encode("UTF-8") + return bool(edje_edit_program_action_set(self.edje.obj, + self.name if self.name is not None else NULL, + action)) + + def targets_get(self): + cdef Eina_List *lst + lst = edje_edit_program_targets_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def target_add(self, target): + if isinstance(target, unicode): target = target.encode("UTF-8") + return bool(edje_edit_program_target_add(self.edje.obj, + self.name if self.name is not None else NULL, + target if target is not None else NULL)) + + def target_del(self, target): + if isinstance(target, unicode): target = target.encode("UTF-8") + return bool(edje_edit_program_target_del(self.edje.obj, + self.name if self.name is not None else NULL, + target if target is not None else NULL)) + + def targets_clear(self): + return bool(edje_edit_program_targets_clear(self.edje.obj, + self.name if self.name is not None else NULL)) + + def afters_get(self): + cdef Eina_List *lst + lst = edje_edit_program_afters_get(self.edje.obj, self.name) + ret = convert_eina_list_strings_to_python_list(lst) + edje_edit_string_list_free(lst) + return ret + + def after_add(self, after): + if isinstance(after, unicode): after = after.encode("UTF-8") + return bool(edje_edit_program_after_add(self.edje.obj, + self.name if self.name is not None else NULL, + after if after is not None else NULL)) + + def after_del(self, after): + if isinstance(after, unicode): after = after.encode("UTF-8") + return bool(edje_edit_program_after_del(self.edje.obj, + self.name if self.name is not None else NULL, + after if after is not None else NULL)) + + def afters_clear(self): + return bool(edje_edit_program_afters_clear(self.edje.obj, + self.name if self.name is not None else NULL)) + + def state_get(self): + cdef const_char *s + s = edje_edit_program_state_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _ctouni(s) + edje_edit_string_free(s) + return ret + + def state_set(self, state): + if isinstance(state, unicode): state = state.encode("UTF-8") + return bool(edje_edit_program_state_set(self.edje.obj, + self.name if self.name is not None else NULL, + state if state is not None else NULL)) + + def value_get(self): + return edje_edit_program_value_get(self.edje.obj, + self.name if self.name is not None else NULL) + + def value_set(self, double v): + return bool(edje_edit_program_value_set(self.edje.obj, + self.name if self.name is not None else NULL, v)) + + def state2_get(self): + cdef const_char *s + s = edje_edit_program_state2_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _ctouni(s) + edje_edit_string_free(s) + return ret + + def state2_set(self, state): + if isinstance(state, unicode): state = state.encode("UTF-8") + return bool(edje_edit_program_state2_set(self.edje.obj, + self.name if self.name is not None else NULL, + state if state is not None else NULL)) + + def value2_get(self): + return edje_edit_program_value2_get(self.edje.obj, + self.name if self.name is not None else NULL) + + def value2_set(self, double v): + return bool(edje_edit_program_value2_set(self.edje.obj, + self.name if self.name is not None else NULL, v)) + + def transition_get(self): + return edje_edit_program_transition_get(self.edje.obj, + self.name if self.name is not None else NULL) + + def transition_set(self, t): + return bool(edje_edit_program_transition_set(self.edje.obj, + self.name if self.name is not None else NULL, t)) + + def transition_time_get(self): + return edje_edit_program_transition_time_get(self.edje.obj, + self.name if self.name is not None else NULL) + + def transition_time_set(self, double t): + return bool(edje_edit_program_transition_time_set(self.edje.obj, + self.name if self.name is not None else NULL, t)) + + property api: + def __get__(self): + cdef: + const_char *name + const_char *desc + name = edje_edit_program_api_name_get(self.edje.obj, + self.name if self.name is not None else NULL) + desc = edje_edit_program_api_description_get(self.edje.obj, + self.name if self.name is not None else NULL) + n, d = _ctouni(name), _ctouni(desc) + edje_edit_string_free(name) + edje_edit_string_free(desc) + return (n, d) + + def __set__(self, value): + cdef object name, desc + name, desc = value + if isinstance(name, unicode): name = name.encode("UTF-8") + if isinstance(desc, unicode): desc = desc.encode("UTF-8") + edje_edit_program_api_name_set(self.edje.obj, + self.name if self.name is not None else NULL, + name if name is not None else NULL) + edje_edit_program_api_description_set(self.edje.obj, + self.name if self.name is not None else NULL, + desc if desc is not None else NULL) + + property script: + def __get__(self): + cdef char *code + code = edje_edit_script_program_get(self.edje.obj, + self.name if self.name is not None else NULL) + ret = _touni(code) + free(code) + return ret + + def __set__(self, code): + if isinstance(code, unicode): code = code.encode("UTF-8") + edje_edit_script_program_set(self.edje.obj, + self.name if self.name is not None else NULL, + code if code is not None else NULL) + + def __del__(self): + edje_edit_script_program_set(self.edje.obj, + self.name if self.name is not None else NULL, NULL) + diff --git a/include/efl.edje_edit.pxd b/include/efl.edje_edit.pxd new file mode 100644 index 0000000..4d741a0 --- /dev/null +++ b/include/efl.edje_edit.pxd @@ -0,0 +1,321 @@ +# Copyright (C) 2007-2013 various contributors (see AUTHORS) +# +# This file is part of Python-EFL. +# +# Python-EFL 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; either +# version 2.1 of the License, or (at your option) any later version. +# +# Python-EFL 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 Python-EFL. If not, see . + +from efl cimport * +from efl.evas cimport Canvas, Evas_Event_Flags +from efl.evas cimport Evas_Object, Evas +from efl.edje cimport Edje, Edje_Part_Type, Edje_Text_Effect, Edje_Tween_Mode, \ + Edje_Action_Type + + +cdef extern from "Edje_Edit.h": + #################################################################### + # Enumerations + # + ctypedef enum Edje_Edit_Image_Comp: + pass + + #################################################################### + # Structures + # + ctypedef struct Edje_Edit_Script_Error: + const_char *program_name + int line + const_char *error_str + + #################################################################### + # Engine + # + + # general + Evas_Object *edje_edit_object_add(Evas *e) + void edje_edit_string_free(const_char *str) + void edje_edit_string_list_free(Eina_List *lst) + + const_char *edje_edit_compiler_get(Evas_Object *obj) + Eina_Bool edje_edit_save(Evas_Object *obj) + Eina_Bool edje_edit_save_all(Evas_Object *obj) + void edje_edit_print_internal_status(Evas_Object *obj) + + # group + Eina_Bool edje_edit_group_add(Evas_Object *obj, char *name) + Eina_Bool edje_edit_group_del(Evas_Object *obj, char *group_name) + Eina_Bool edje_edit_group_exist(Evas_Object *obj, char *group) + Eina_Bool edje_edit_group_name_set(Evas_Object *obj, char *new_name) + int edje_edit_group_min_w_get(Evas_Object *obj) + void edje_edit_group_min_w_set(Evas_Object *obj, int w) + int edje_edit_group_min_h_get(Evas_Object *obj) + void edje_edit_group_min_h_set(Evas_Object *obj, int h) + int edje_edit_group_max_w_get(Evas_Object *obj) + void edje_edit_group_max_w_set(Evas_Object *obj, int w) + int edje_edit_group_max_h_get(Evas_Object *obj) + void edje_edit_group_max_h_set(Evas_Object *obj, int h) + + # data + Eina_List *edje_edit_data_list_get(Evas_Object *obj) + Eina_Bool edje_edit_data_add(Evas_Object *obj, const_char *itemname, const_char *value) + Eina_Bool edje_edit_data_del(Evas_Object *obj, const_char *itemname) + const_char *edje_edit_data_value_get(Evas_Object * obj, const_char *itemname) + Eina_Bool edje_edit_data_value_set(Evas_Object * obj, const_char *itemname, const_char *value) + Eina_Bool edje_edit_data_name_set(Evas_Object *obj, const_char *itemname, const_char *newname) + + Eina_List *edje_edit_group_data_list_get(Evas_Object *obj) + Eina_Bool edje_edit_group_data_add(Evas_Object *obj, const_char *itemname, const_char *value) + Eina_Bool edje_edit_group_data_del(Evas_Object *obj, const_char *itemname) + const_char *edje_edit_group_data_value_get(Evas_Object *obj, const_char *itemname) + Eina_Bool edje_edit_group_data_value_set(Evas_Object *obj, const_char *itemname, const_char *value) + Eina_Bool edje_edit_group_data_name_set(Evas_Object *obj, const_char *itemname, const_char *newname) + + # text styles + Eina_List *edje_edit_styles_list_get(Evas_Object *obj) + Eina_Bool edje_edit_style_add(Evas_Object *obj, const_char *style) + void edje_edit_style_del(Evas_Object *obj, const_char *style) + Eina_List *edje_edit_style_tags_list_get(Evas_Object *obj, const_char *style) + const_char *edje_edit_style_tag_value_get(Evas_Object *obj, const_char *style, const_char *tag) + void edje_edit_style_tag_value_set(Evas_Object *obj, const_char *style, const_char *tag, const_char *new_value) + void edje_edit_style_tag_name_set(Evas_Object *obj, const_char *style, const_char *tag, const_char *new_name) + Eina_Bool edje_edit_style_tag_add(Evas_Object *obj, const_char *style, const_char *tag_name) + void edje_edit_style_tag_del(Evas_Object *obj, const_char *style, const_char *tag) + + # fonts + Eina_List *edje_edit_fonts_list_get(Evas_Object *obj) + Eina_Bool edje_edit_font_add(Evas_Object *obj, const_char *path, const_char *alias) + Eina_Bool edje_edit_font_del(Evas_Object *obj, const_char *alias) + + # color classes + Eina_List *edje_edit_color_classes_list_get(Evas_Object *obj) + Eina_Bool edje_edit_color_class_add(Evas_Object *obj, const_char *name) + Eina_Bool edje_edit_color_class_del(Evas_Object *obj, const_char *name) + Eina_Bool edje_edit_color_class_colors_get(Evas_Object *obj, const_char *class_name, int *r, int *g, int *b, int *a, int *r2, int *g2, int *b2, int *a2, int *r3, int *g3, int *b3, int *a3) + Eina_Bool edje_edit_color_class_colors_set(Evas_Object *obj, const_char *class_name, int r, int g, int b, int a, int r2, int g2, int b2, int a2, int r3, int g3, int b3, int a3) + Eina_Bool edje_edit_color_class_name_set(Evas_Object *obj, const_char *name, const_char *newname) + + # externals + Eina_List *edje_edit_externals_list_get(Evas_Object *obj) + Eina_Bool edje_edit_external_add(Evas_Object *obj, const_char *name) + Eina_Bool edje_edit_external_del(Evas_Object *obj, const_char *name) + + # images + Eina_List *edje_edit_images_list_get(Evas_Object *obj) + Eina_Bool edje_edit_image_add(Evas_Object *obj, const_char *path) + Eina_Bool edje_edit_image_del(Evas_Object *obj, const_char *name) + Eina_Bool edje_edit_image_data_add(Evas_Object *obj, const_char *name, int id) + const_char *edje_edit_state_image_get(Evas_Object *obj, const_char *part, const_char *state, double value) + void edje_edit_state_image_set(Evas_Object *obj, const_char *part, const_char *state, double value, const_char *image) + int edje_edit_image_id_get(Evas_Object *obj, const_char *image_name) + Edje_Edit_Image_Comp edje_edit_image_compression_type_get(Evas_Object *obj, const_char *image) + int edje_edit_image_compression_rate_get(Evas_Object *obj, const_char *image) + void edje_edit_state_image_border_get(Evas_Object *obj, const_char *part, const_char *state, double value, int *l, int *r, int *t, int *b) + void edje_edit_state_image_border_set(Evas_Object *obj, const_char *part, const_char *state, double value, int l, int r, int t, int b) + unsigned char edje_edit_state_image_border_fill_get(Evas_Object *obj, const_char *part, const_char *state, double value) + void edje_edit_state_image_border_fill_set(Evas_Object *obj, const_char *part, const_char *state, double value, unsigned char fill) + Eina_List *edje_edit_state_tweens_list_get(Evas_Object *obj, const_char *part, const_char *state, double value) + Eina_Bool edje_edit_state_tween_add(Evas_Object *obj, const_char *part, const_char *state, double value, const_char *tween) + Eina_Bool edje_edit_state_tween_del(Evas_Object *obj, const_char *part, const_char *state, double value, const_char *tween) + + # part + Eina_List *edje_edit_parts_list_get(Evas_Object *obj) + Eina_Bool edje_edit_part_add(Evas_Object *obj, const_char *name, Edje_Part_Type type) + Eina_Bool edje_edit_part_external_add(Evas_Object *obj, const_char *name, const_char *source) + Eina_Bool edje_edit_part_del(Evas_Object *obj, const_char *part) + Eina_Bool edje_edit_part_exist(Evas_Object *obj, const_char *part) + const_char *edje_edit_part_above_get(Evas_Object *obj, const_char *part) + const_char *edje_edit_part_below_get(Evas_Object *obj, const_char *part) + Eina_Bool edje_edit_part_restack_below(Evas_Object *obj, const_char *part) + Eina_Bool edje_edit_part_restack_above(Evas_Object *obj, const_char *part) + Eina_Bool edje_edit_part_name_set(Evas_Object *obj, const_char *part, const_char *new_name) + Edje_Part_Type edje_edit_part_type_get(Evas_Object *obj, const_char *part) + const_char *edje_edit_part_clip_to_get(Evas_Object *obj, const_char *part) + Eina_Bool edje_edit_part_clip_to_set(Evas_Object *obj, const_char *part, const_char *clip_to) + const_char *edje_edit_part_source_get(Evas_Object *obj, const_char *part) + Eina_Bool edje_edit_part_source_set(Evas_Object *obj, const_char *part, const_char *source) + Edje_Text_Effect edje_edit_part_effect_get(Evas_Object *obj, const_char *part) + void edje_edit_part_effect_set(Evas_Object *obj, const_char *part, Edje_Text_Effect effect) + const_char *edje_edit_part_selected_state_get(Evas_Object *obj, const_char *part, double *value) + Eina_Bool edje_edit_part_selected_state_set(Evas_Object *obj, const_char *part, const_char *state, double value) + Eina_Bool edje_edit_part_mouse_events_get(Evas_Object *obj, const_char *part) + void edje_edit_part_mouse_events_set(Evas_Object *obj, const_char *part, Eina_Bool mouse_events) + Eina_Bool edje_edit_part_repeat_events_get(Evas_Object *obj, const_char *part) + void edje_edit_part_repeat_events_set(Evas_Object *obj, const_char *part, Eina_Bool repeat_events) + Evas_Event_Flags edje_edit_part_ignore_flags_get(Evas_Object *obj, const_char *part) + void edje_edit_part_ignore_flags_set(Evas_Object *obj, const_char *part, Evas_Event_Flags ignore_flags) + void edje_edit_part_scale_set(Evas_Object *obj, const_char *part, Eina_Bool scale) + Eina_Bool edje_edit_part_scale_get(Evas_Object *obju, const_char *part) + int edje_edit_part_drag_x_get(Evas_Object *obj, const_char *part) + void edje_edit_part_drag_x_set(Evas_Object *obj, const_char *part, int drag) + int edje_edit_part_drag_y_get(Evas_Object *obj, const_char *part) + void edje_edit_part_drag_y_set(Evas_Object *obj, const_char *part, int drag) + int edje_edit_part_drag_step_x_get(Evas_Object *obj, const_char *part) + void edje_edit_part_drag_step_x_set(Evas_Object *obj, const_char *part, int step) + int edje_edit_part_drag_step_y_get(Evas_Object *obj, const_char *part) + void edje_edit_part_drag_step_y_set(Evas_Object *obj, const_char *part, int step) + int edje_edit_part_drag_count_x_get(Evas_Object *obj, const_char *part) + void edje_edit_part_drag_count_x_set(Evas_Object *obj, const_char *part, int count) + int edje_edit_part_drag_count_y_get(Evas_Object *obj, const_char *part) + void edje_edit_part_drag_count_y_set(Evas_Object *obj, const_char *part, int count) + const_char *edje_edit_part_drag_confine_get(Evas_Object *obj, const_char *part) + void edje_edit_part_drag_confine_set(Evas_Object *obj, const_char *part, const_char *confine) + const_char *edje_edit_part_drag_event_get(Evas_Object *obj, const_char *part) + void edje_edit_part_drag_event_set(Evas_Object *obj, const_char *part, const_char *event) + const_char *edje_edit_part_api_name_get(Evas_Object *obj, const_char *part) + const_char *edje_edit_part_api_description_get(Evas_Object *obj, const_char *part) + Eina_Bool edje_edit_part_api_name_set(Evas_Object *obj, const_char *part, const_char *name) + Eina_Bool edje_edit_part_api_description_set(Evas_Object *obj, const_char *part, const_char *description) + const_char *edje_edit_program_api_name_get(Evas_Object *obj, const_char *part) + const_char *edje_edit_program_api_description_get(Evas_Object *obj, const_char *part) + Eina_Bool edje_edit_program_api_name_set(Evas_Object *obj, const_char *part, const_char *name) + Eina_Bool edje_edit_program_api_description_set(Evas_Object *obj, const_char *part, const_char *description) + + # State + Eina_List *edje_edit_part_states_list_get(Evas_Object *obj, char *part) + int edje_edit_state_name_set(Evas_Object *obj, char *part, char *state, double value, char *new_name, double new_value) + Eina_Bool edje_edit_state_add(Evas_Object *obj, char *part, char *name, double value) + Eina_Bool edje_edit_state_del(Evas_Object *obj, char *part, char *state, double value) + Eina_Bool edje_edit_state_exist(Evas_Object *obj, char *part, char *state, double value) + Eina_Bool edje_edit_state_copy(Evas_Object *obj, char *part, char *sfrom, double vfrom, char *sto, double vto) + double edje_edit_state_rel1_relative_x_get(Evas_Object *obj, char *part, char *state, double value) + double edje_edit_state_rel1_relative_y_get(Evas_Object *obj, char *part, char *state, double value) + double edje_edit_state_rel2_relative_x_get(Evas_Object *obj, char *part, char *state, double value) + double edje_edit_state_rel2_relative_y_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_rel1_relative_x_set(Evas_Object *obj, char *part, char *state, double value, double x) + void edje_edit_state_rel1_relative_y_set(Evas_Object *obj, char *part, char *state, double value, double y) + void edje_edit_state_rel2_relative_x_set(Evas_Object *obj, char *part, char *state, double value, double x) + void edje_edit_state_rel2_relative_y_set(Evas_Object *obj, char *part, char *state, double value, double y) + int edje_edit_state_rel1_offset_x_get(Evas_Object *obj, char *part, char *state, double value) + int edje_edit_state_rel1_offset_y_get(Evas_Object *obj, char *part, char *state, double value) + int edje_edit_state_rel2_offset_x_get(Evas_Object *obj, char *part, char *state, double value) + int edje_edit_state_rel2_offset_y_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_rel1_offset_x_set(Evas_Object *obj, char *part, char *state, double value, double x) + void edje_edit_state_rel1_offset_y_set(Evas_Object *obj, char *part, char *state, double value, double y) + void edje_edit_state_rel2_offset_x_set(Evas_Object *obj, char *part, char *state, double value, double x) + void edje_edit_state_rel2_offset_y_set(Evas_Object *obj, char *part, char *state, double value, double y) + char *edje_edit_state_rel1_to_x_get(Evas_Object *obj, char *part, char *state, double value) + char *edje_edit_state_rel1_to_y_get(Evas_Object *obj, char *part, char *state, double value) + char *edje_edit_state_rel2_to_x_get(Evas_Object *obj, char *part, char *state, double value) + char *edje_edit_state_rel2_to_y_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_rel1_to_x_set(Evas_Object *obj, char *part, char *state, double value, char *rel_to) + void edje_edit_state_rel1_to_y_set(Evas_Object *obj, char *part, char *state, double value, char *rel_to) + void edje_edit_state_rel2_to_x_set(Evas_Object *obj, char *part, char *state, double value, char *rel_to) + void edje_edit_state_rel2_to_y_set(Evas_Object *obj, char *part, char *state, double value, char *rel_to) + void edje_edit_state_color_get(Evas_Object *obj, char *part, char *state, double value, int *r, int *g, int *b, int *a) + void edje_edit_state_color2_get(Evas_Object *obj, char *part, char *state, double value, int *r, int *g, int *b, int *a) + void edje_edit_state_color3_get(Evas_Object *obj, char *part, char *state, double value, int *r, int *g, int *b, int *a) + void edje_edit_state_color_set(Evas_Object *obj, char *part, char *state, double value, int r, int g, int b, int a) + void edje_edit_state_color2_set(Evas_Object *obj, char *part, char *state, double value, int r, int g, int b, int a) + void edje_edit_state_color3_set(Evas_Object *obj, char *part, char *state, double value, int r, int g, int b, int a) + double edje_edit_state_align_x_get(Evas_Object *obj, char *part, char *state, double value) + double edje_edit_state_align_y_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_align_x_set(Evas_Object *obj, char *part, char *state, double value, double align) + void edje_edit_state_align_y_set(Evas_Object *obj, char *part, char *state, double value, double align) + int edje_edit_state_min_w_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_min_w_set(Evas_Object *obj, char *part, char *state, double value, int min_w) + int edje_edit_state_min_h_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_min_h_set(Evas_Object *obj, char *part, char *state, double value, int min_h) + int edje_edit_state_max_w_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_max_w_set(Evas_Object *obj, char *part, char *state, double value, int max_w) + int edje_edit_state_max_h_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_max_h_set(Evas_Object *obj, char *part, char *state, double value, int max_h) + double edje_edit_state_aspect_min_get(Evas_Object *obj, char *part, char *state, double value) + double edje_edit_state_aspect_max_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_aspect_min_set(Evas_Object *obj, char *part, char *state, double value, double aspect) + void edje_edit_state_aspect_max_set(Evas_Object *obj, char *part, char *state, double value, double aspect) + unsigned char edje_edit_state_aspect_pref_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_aspect_pref_set(Evas_Object *obj, char *part, char *state, double value, unsigned char pref) + double edje_edit_state_fill_origin_relative_x_get(Evas_Object *obj, char *part, char *state, double value) + double edje_edit_state_fill_origin_relative_y_get(Evas_Object *obj, char *part, char *state, double value) + int edje_edit_state_fill_origin_offset_x_get(Evas_Object *obj, char *part, char *state, double value) + int edje_edit_state_fill_origin_offset_y_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_fill_origin_relative_x_set(Evas_Object *obj, char *part, char *state, double value, double x) + void edje_edit_state_fill_origin_relative_y_set(Evas_Object *obj, char *part, char *state, double value, double x) + void edje_edit_state_fill_origin_offset_x_set(Evas_Object *obj, char *part, char *state, double value, double x) + void edje_edit_state_fill_origin_offset_y_set(Evas_Object *obj, char *part, char *state, double value, double y) + double edje_edit_state_fill_size_relative_x_get(Evas_Object *obj, char *part, char *state, double value) + double edje_edit_state_fill_size_relative_y_get(Evas_Object *obj, char *part, char *state, double value) + int edje_edit_state_fill_size_offset_x_get(Evas_Object *obj, char *part, char *state, double value) + int edje_edit_state_fill_size_offset_y_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_fill_size_relative_x_set(Evas_Object *obj, char *part, char *state, double value, double x) + void edje_edit_state_fill_size_relative_y_set(Evas_Object *obj, char *part, char *state, double value, double x) + void edje_edit_state_fill_size_offset_x_set(Evas_Object *obj, char *part, char *state, double value, double x) + void edje_edit_state_fill_size_offset_y_set(Evas_Object *obj, char *part, char *state, double value, double y) + Eina_Bool edje_edit_state_visible_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_visible_set(Evas_Object *obj, char *part, char *state, double value, Eina_Bool visible) + char *edje_edit_state_color_class_get(Evas_Object *obj, char *part, char *state, double value) + void edje_edit_state_color_class_set(Evas_Object *obj, char *part, char *state, double value, char *color_class) + +# Eina_List * edje_edit_state_external_params_list_get(Evas_Object *obj, char *part, char *state, double value) +# Eina_Bool edje_edit_state_external_param_get(Evas_Object *obj, char *part, char *state, double value, char *param, edje.c_edje.Edje_External_Param_Type *type, void **val) +# Eina_Bool edje_edit_state_external_param_int_get(Evas_Object *obj, char *part, char *state, double value, char *param, int *val) +# Eina_Bool edje_edit_state_external_param_bool_get(Evas_Object *obj, char *part, char *state, double value, char *param, Eina_Bool *val) +# Eina_Bool edje_edit_state_external_param_double_get(Evas_Object *obj, char *part, char *state, double value, char *param, double *val) +# Eina_Bool edje_edit_state_external_param_string_get(Evas_Object *obj, char *part, char *state, double value, char *param, char **val) +# Eina_Bool edje_edit_state_external_param_choice_get(Evas_Object *obj, char *part, char *state, double value, char *param, char **val) +# edje.c_edje.Edje_External_Param_Type edje_object_part_external_param_type_get(Evas_Object *obj, char *part, char *param) +# char *edje_external_param_type_str(edje.c_edje.Edje_External_Param_Type type) +# Eina_Bool edje_edit_state_external_param_set(Evas_Object *obj, char *part, char *state, double value, char *param, edje.c_edje.Edje_External_Param_Type type, ...) +# Eina_Bool edje_edit_state_external_param_int_set(Evas_Object *obj, char *part, char *state, double value, char *param, int val) +# Eina_Bool edje_edit_state_external_param_bool_set(Evas_Object *obj, char *part, char *state, double value, char *param, Eina_Bool val) +# Eina_Bool edje_edit_state_external_param_double_set(Evas_Object *obj, char *part, char *state, double value, char *param, double val) +# Eina_Bool edje_edit_state_external_param_string_set(Evas_Object *obj, char *part, char *state, double value, char *param, char *val) +# Eina_Bool edje_edit_state_external_param_choice_set(Evas_Object *obj, char *part, char *state, double value, char *param, char *val) + + + # programs + Eina_List *edje_edit_programs_list_get(Evas_Object *obj) + Eina_Bool edje_edit_program_add(Evas_Object *obj, const_char *name) + Eina_Bool edje_edit_program_del(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_exist(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_run(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_name_set(Evas_Object *obj, const_char *prog, const_char *new_name) + const_char *edje_edit_program_source_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_source_set(Evas_Object *obj, const_char *prog, const_char *source) + const_char *edje_edit_program_signal_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_signal_set(Evas_Object *obj, const_char *prog, const_char *signal) + double edje_edit_program_in_from_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_in_from_set(Evas_Object *obj, const_char *prog, double seconds) + double edje_edit_program_in_range_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_in_range_set(Evas_Object *obj, const_char *prog, double seconds) + Edje_Action_Type edje_edit_program_action_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_action_set(Evas_Object *obj, const_char *prog, Edje_Action_Type action) + Eina_List *edje_edit_program_targets_get(Evas_Object *, const_char *prog) + Eina_Bool edje_edit_program_target_add(Evas_Object *obj, const_char *prog, const_char *target) + Eina_Bool edje_edit_program_target_del(Evas_Object *obj, const_char *prog, const_char *target) + Eina_Bool edje_edit_program_targets_clear(Evas_Object *obj, const_char *prog) + Eina_List *edje_edit_program_afters_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_after_add(Evas_Object *obj, const_char *prog, const_char *after) + Eina_Bool edje_edit_program_after_del(Evas_Object *obj, const_char *prog, const_char *after) + Eina_Bool edje_edit_program_afters_clear(Evas_Object *obj, const_char *prog) + const_char *edje_edit_program_state_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_state_set(Evas_Object *obj, const_char *prog, const_char *state) + double edje_edit_program_value_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_value_set(Evas_Object *obj, const_char *prog, double value) + const_char *edje_edit_program_state2_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_state2_set(Evas_Object *obj, const_char *prog, const_char *state2) + double edje_edit_program_value2_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_value2_set(Evas_Object *obj, const_char *prog, double value) + Edje_Tween_Mode edje_edit_program_transition_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_transition_set(Evas_Object *obj, const_char *prog, Edje_Tween_Mode transition) + double edje_edit_program_transition_time_get(Evas_Object *obj, const_char *prog) + Eina_Bool edje_edit_program_transition_time_set(Evas_Object *obj, const_char *prog, double seconds) + + # scripts + char* edje_edit_script_get(Evas_Object *obj) + void edje_edit_script_set(Evas_Object *obj, const_char *code) + char* edje_edit_script_program_get(Evas_Object *obj, const_char *prog) + void edje_edit_script_program_set(Evas_Object *obj, const_char *prog, const_char *code) + Eina_Bool edje_edit_script_compile(Evas_Object *obj) + const_Eina_List *edje_edit_script_error_list_get(Evas_Object *obj) + diff --git a/setup.py b/setup.py index 38f5fd9..a2688fd 100755 --- a/setup.py +++ b/setup.py @@ -65,6 +65,7 @@ else: # subprocess.call("rm -rfv efl/evas/*.c", shell=True) # subprocess.call("rm -rfv efl/ecore/*.c", shell=True) # subprocess.call("rm -rfv efl/edje/*.c", shell=True) + # subprocess.call("rm -rfv efl/edje/edit/*.c", shell=True) # subprocess.call("rm -rfv efl/emotion/*.c", shell=True) # subprocess.call("rm -rfv efl/elementary/*.c", shell=True) # subprocess.call("rm -rfv efl/dbus_mainloop/dbus_mainloop.c", shell=True) @@ -102,6 +103,14 @@ else: extra_compile_args = edje_cflags, extra_link_args = edje_libs + eina_libs + evas_libs) modules.append(edje_ext) + + # Edje_Edit + edje_edit_ext = Extension("efl.edje_edit", ["efl/edje/efl.edje_edit.pyx"], + define_macros = [('EDJE_EDIT_IS_UNSTABLE_AND_I_KNOW_ABOUT_IT', None)], + include_dirs = ['include/'], + extra_compile_args = edje_cflags, + extra_link_args = edje_libs + eina_libs + evas_libs) + modules.append(edje_edit_ext) # Emotion emotion_cflags, emotion_libs = pkg_config('Emotion', 'emotion', "1.7.99") diff --git a/tests/edje/test_04_edit.py b/tests/edje/test_04_edit.py new file mode 100644 index 0000000..67ba20e --- /dev/null +++ b/tests/edje/test_04_edit.py @@ -0,0 +1,477 @@ +#!/usr/bin/env python + +from efl import evas +from efl import ecore +from efl import edje +from efl.edje import EDJE_PART_TYPE_RECTANGLE +from efl.edje_edit import EdjeEdit, Text_Style, Text_Style_Tag, Color_Class, \ + Part, Program +import os, unittest + + +theme_file = os.path.join(os.path.dirname(__file__), "theme.edj") + + +class TestEdjeEditBase(unittest.TestCase): + def setUp(self): + self.canvas = evas.Canvas(method="buffer", + size=(400, 500), + viewport=(0, 0, 400, 500)) + self.canvas.engine_info_set(self.canvas.engine_info_get()) + + def tearDown(self): + self.canvas.delete() + + + def testConstructor(self): + o = EdjeEdit(self.canvas, file=theme_file, group="main") + self.assertIsInstance(o, EdjeEdit) + o.delete() + self.assertTrue(o.is_deleted()) + + +class TestEdjeEditGeneral(unittest.TestCase): + def setUp(self): + self.canvas = evas.Canvas(method="buffer", + size=(400, 500), + viewport=(0, 0, 400, 500)) + self.canvas.engine_info_set(self.canvas.engine_info_get()) + self.o = EdjeEdit(self.canvas, file=theme_file, group="main") + + def tearDown(self): + self.o.delete() + self.canvas.delete() + + def testGeneral(self): + self.assertEqual(self.o.compiler_get(), "edje_cc") + self.assertEqual(self.o.file_get(), (theme_file, "main")) + # o.print_internal_status() # FIXME this crash badly + + def testGroup(self): + g = self.o.current_group + + self.assertEqual((g.w_min, g.w_max), (200, 400)) + self.assertEqual((g.h_min, g.h_max), (200, 400)) + + g.w_min = g.h_min = 201 + g.w_max = g.h_max = 401 + + self.assertEqual((g.w_min, g.w_max), (201, 401)) + self.assertEqual((g.h_min, g.h_max), (201, 401)) + + # TODO test g.rename + + def testGroupAdd(self): + self.assertFalse(self.o.group_exist("test_new_group")) + self.o.group_add("test_new_group") + self.assertTrue(self.o.group_exist("test_new_group")) + + @unittest.skip("crash badly") # TODO FIXME + def testGroupDel(self): + self.o.group_add("test_new_group2") + self.o.group_del("test_new_group2") + self.assertFalse(o.group_exist("test_new_group2")) + + def testData(self): + self.assertIn("key1", self.o.data) + self.assertIn("key2", self.o.data) + + self.assertEqual(self.o.data_get("key1"), "value1") + self.assertEqual(self.o.data_get("key2"), "value2") + + self.o.data_set("key1", "new_value1") + self.o.data_set("key2", "new_value2") + self.assertEqual(self.o.data_get("key1"), "new_value1") + self.assertEqual(self.o.data_get("key2"), "new_value2") + + self.o.data_add("key5", "value5") + self.assertEqual(self.o.data_get("key5"), "value5") + + self.o.data_rename("key5", "key55") + self.assertEqual(self.o.data_get("key55"), "value5") + + # self.o.data_del("key44") # FIXME this crash badly + # self.assertNotIn("key44", self.o.data) + + def testGroupData(self): + self.assertIn("key3", self.o.group_data) + self.assertIn("key4", self.o.group_data) + + self.assertEqual(self.o.group_data_get("key3"), "value3") + self.assertEqual(self.o.group_data_get("key4"), "value4") + + self.o.group_data_set("key3", "new_value3") + self.o.group_data_set("key4", "new_value4") + self.assertEqual(self.o.group_data_get("key3"), "new_value3") + self.assertEqual(self.o.group_data_get("key4"), "new_value4") + + self.o.group_data_add("key6", "value6") + self.assertEqual(self.o.group_data_get("key6"), "value6") + + self.o.group_data_del("key6") + self.assertNotIn("key6", self.o.group_data) + + def testTextStyles(self): + self.assertIn("style1", self.o.text_styles) + self.assertIn("style2", self.o.text_styles) + self.assertNotIn("styleNOTEXISTS", self.o.text_styles) + + style = self.o.text_style_get("style1") + self.assertIsInstance(style, Text_Style) + self.assertIn("DEFAULT", style.tags) + self.assertIn("br", style.tags) + self.assertIn("tab", style.tags) + self.assertNotIn("b", style.tags) + + tag = style.tag_get("DEFAULT") + self.assertIsInstance(tag, Text_Style_Tag) + + # TODO more test for tags add/del + + def testColorClasses(self): + self.assertIn("colorclass1", self.o.color_classes) + self.assertIn("colorclass2", self.o.color_classes) + self.assertNotIn("colorclassNOTEXISTS", self.o.color_classes) + + cc1 = self.o.color_class_get("colorclass1") + cc2 = self.o.color_class_get("colorclass2") + self.assertIsInstance(cc1, Color_Class) + self.assertIsInstance(cc2, Color_Class) + + self.assertEqual(cc1.name, "colorclass1") + self.assertEqual(cc2.name, "colorclass2") + + cc1.name = "colorclass1_new" + self.assertEqual(cc1.name, "colorclass1_new") + + self.assertEqual(cc1.colors_get(), ((1,2,3,4),(5,6,7,8),(9,10,11,12))) + self.assertEqual(cc2.colors_get(), ((13,14,15,16),(17,18,19,20),(21,22,23,24))) + + cc1.colors_set(50,51,52,53, 54,55,56,57, 58,59,60,61) + cc2.colors_set(70,71,72,73, 74,75,76,77, 78,79,80,81) + self.assertEqual(cc1.colors_get(), ((50,51,52,53),(54,55,56,57),(58,59,60,61))) + self.assertEqual(cc2.colors_get(), ((70,71,72,73),(74,75,76,77),(78,79,80,81))) + + self.o.color_class_add("colorclass3") + self.assertIn("colorclass3", self.o.color_classes) + cc3 = self.o.color_class_get("colorclass3") + self.assertIsInstance(cc3, Color_Class) + + cc3.colors_set(85,86,87,88, 89,90,91,92, 93,94,95,96) + self.assertEqual(cc3.colors_get(), ((85,86,87,88),(89,90,91,92),(93,94,95,96))) + + self.o.color_class_del("colorclass3") + self.assertNotIn("colorclass3", self.o.color_classes) + + @unittest.skip("need to fix external_del to not leave a NULL element") # TODO FIXME + def testExternal(self): + self.assertEqual(self.o.externals, ['elm']) + self.o.external_add('emotion') + self.assertEqual(self.o.externals, ['elm', 'emotion']) + self.o.external_del('emotion') + self.assertEqual(self.o.externals, ['elm']) + + # TODO test for images, image_id_get, image_del + + def testScript(self): + self.assertEqual(len(self.o.script), 104) + # TODO test setting .script, compile and .script_errors + + +class TestEdjeEditParts(unittest.TestCase): + def setUp(self): + self.canvas = evas.Canvas(method="buffer", + size=(400, 500), + viewport=(0, 0, 400, 500)) + self.canvas.engine_info_set(self.canvas.engine_info_get()) + self.o = EdjeEdit(self.canvas, file=theme_file, group="main") + + def tearDown(self): + self.o.delete() + self.canvas.delete() + + def testPart(self): + self.assertEqual(len(self.o.parts), 42) + self.assertTrue(self.o.part_exist("bg")) + self.assertTrue(self.o.part_exist("rect")) + self.assertFalse(self.o.part_exist("NOTEXIST")) + + p = self.o.part_get("rect") + self.assertIsInstance(p, Part) + self.assertEqual(p.type, EDJE_PART_TYPE_RECTANGLE) + + def testPartRename(self): + p = self.o.part_get("rect") + self.assertEqual(p.name, "rect") + p.name = "rect_new_name" + self.assertEqual(p.name, "rect_new_name") + p.rename("rect") + self.assertEqual(p.name, "rect") + + def testPartAdd(self): + self.o.part_add("new_part", EDJE_PART_TYPE_RECTANGLE) + self.assertTrue(self.o.part_exist("new_part")) + self.assertEqual(len(self.o.parts), 43) + + p = self.o.part_get("new_part") + self.assertIsInstance(p, Part) + + @unittest.skip("part_del() crash") # TODO FIXME + def testPartDel(self): + self.assertTrue(self.o.part_exist("rect")) + self.o.part_del("rect") + self.assertFalse(self.o.part_exist("rect")) + + @unittest.skip("cause segfault") # TODO FIXME + def testPartStacking(self): + # print(self.o.parts) + p = self.o.part_get("rect") + self.assertEqual(p.below_get(), "bg") + self.assertEqual(p.above_get(), "label") + + p.restack_below() + p.restack_above() + self.assertEqual(p.below_get(), "bg") + self.assertEqual(p.above_get(), "label") + + @unittest.skip("cause segfault") # TODO FIXME + def testPartClip(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.clip_to, "test_clip") + p.clip_to = "bg" + self.assertEqual(p.clip_to, "bg") + + def testPartSource(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.source, None) + + def testPartMouseEvents(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.mouse_events, False) + p.mouse_events = True + self.assertEqual(p.mouse_events, True) + + def testPartRepeatEvents(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.repeat_events, False) + p.repeat_events = True + self.assertEqual(p.repeat_events, True) + + def testPartEffect(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.effect, 18) + p.effect = 2 + self.assertEqual(p.effect, 2) + + def testPartIgnoreFlags(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.ignore_flags, 1) + p.ignore_flags = 0 + self.assertEqual(p.ignore_flags, 0) + + def testPartScale(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.scale, True) + p.scale = False + self.assertEqual(p.scale, False) + + def testPartDrag(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.drag, (1,1)) + p.drag = (0,0) + self.assertEqual(p.drag, (0,0)) + + def testPartDragStep(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.drag_step, (6,7)) + p.drag_step = (16,17) + self.assertEqual(p.drag_step, (16,17)) + + def testPartDragCount(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.drag_count, (8,9)) + p.drag_count = (18,19) + self.assertEqual(p.drag_count, (18,19)) + + def testPartDragConfine(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.drag_confine, "label") + p.drag_confine = "bg" + self.assertEqual(p.drag_confine, "bg") + + def testPartDragEvent(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.drag_event, "edit_test_drag_event") + p.drag_event = "edit_test_drag_event" + self.assertEqual(p.drag_event, "edit_test_drag_event") + + def testPartApi(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.api, ("api_name", "api_description")) + p.api = ("new_api_name", "new_api_desc") + self.assertEqual(p.api, ("new_api_name", "new_api_desc")) + + +class TestEdjeEditPrograms(unittest.TestCase): + def setUp(self): + self.canvas = evas.Canvas(method="buffer", + size=(400, 500), + viewport=(0, 0, 400, 500)) + self.canvas.engine_info_set(self.canvas.engine_info_get()) + self.o = EdjeEdit(self.canvas, file=theme_file, group="main") + + def tearDown(self): + self.o.delete() + self.canvas.delete() + + def testProgram(self): + o = self.o + self.assertIn("prog1", o.programs) + self.assertIn("prog2", o.programs) + self.assertIn("prog3", o.programs) + self.assertNotIn("progNOTIN", o.programs) + + pr1 = o.program_get("prog1") + self.assertIsInstance(pr1, Program) + self.assertEqual(pr1.edje_get(), self.o) + + o.program_add("prog5") + pr5 = o.program_get("prog5") + self.assertIsInstance(pr5, Program) + self.assertTrue(o.program_exist("prog5")) + + pr5.name = "prog10" + self.assertTrue(o.program_exist("prog10")) + self.assertFalse(o.program_exist("prog5")) + + pr5.rename("prog5") + o.program_del("prog5") + self.assertFalse(o.program_exist("prog5")) + self.assertNotIn("prog5", o.programs) + + # TODO test Program.run() + + def testProgramSource(self): + p = self.o.program_get("prog1") + self.assertEqual(p.source_get(), "edit_test") + p.source_set("edit_*") + self.assertEqual(p.source_get(), "edit_*") + + def testProgramSignal(self): + p = self.o.program_get("prog1") + self.assertEqual(p.signal_get(), "mouse,down,1") + p.signal_set("mouse,down,2") + self.assertEqual(p.signal_get(), "mouse,down,2") + + def testProgramIn(self): + p = self.o.program_get("prog1") + self.assertEqual(p.in_from_get(), 1.1) + self.assertEqual(p.in_range_get(), 2.2) + p.in_from_set(3.3) + p.in_range_set(4.4) + self.assertEqual(p.in_from_get(), 3.3) + self.assertEqual(p.in_range_get(), 4.4) + + def testProgramAction(self): + p = self.o.program_get("prog1") + self.assertEqual(p.action_get(), 1) + p.action_set(2) + self.assertEqual(p.action_get(), 2) + # restore the original to not mess stuff + p.action_set(1) + + def testProgramTargets(self): + p = self.o.program_get("prog1") + self.assertEqual(p.targets_get(), ["edit_test", "test_clip"]) + p.target_del("test_clip") + self.assertEqual(p.targets_get(), ["edit_test"]) + p.target_add("test_clip") + self.assertEqual(p.targets_get(), ["edit_test", "test_clip"]) + p.targets_clear() + self.assertEqual(p.targets_get(), []) + + @unittest.skip("Program.after_add() does not work") + def testProgramAfters(self): + p = self.o.program_get("prog1") + self.assertEqual(p.afters_get(), ["prog2", "prog3"]) + p.after_del("prog2") + self.assertEqual(p.afters_get(), ["prog3"]) + p.after_add("prog4") + self.assertEqual(p.afters_get(), ["prog3", "prog4"]) + p.afters_clear() + self.assertEqual(p.afters_get(), []) + + def testProgramState(self): + p = self.o.program_get("prog1") + self.assertEqual(p.state_get(), "state2") + self.assertEqual(p.value_get(), 0.1) + p.state_set("state1") + p.value_set(0.0) + self.assertEqual(p.state_get(), "state1") + self.assertEqual(p.value_get(), 0.0) + + def testProgramApi(self): + p = self.o.program_get("prog1") + self.assertEqual(p.api, ("p_api_name", "p_api_desc")) + p.api = ("new_name", "new_desc") + self.assertEqual(p.api, ("new_name", "new_desc")) + + @unittest.skip("Program.script does not work") + def testProgramScript(self): + p = self.o.program_get("emit_back_message") + print(p.script) + + +class TestEdjeEditPartStates(unittest.TestCase): + def setUp(self): + self.canvas = evas.Canvas(method="buffer", + size=(400, 500), + viewport=(0, 0, 400, 500)) + self.canvas.engine_info_set(self.canvas.engine_info_get()) + self.o = EdjeEdit(self.canvas, file=theme_file, group="main") + + def tearDown(self): + self.o.delete() + self.canvas.delete() + + def testPartStates(self): + p = self.o.part_get("edit_test") + self.assertEqual(p.states, ["default 0.00","state1 0.00","state2 0.00","state2 0.10"]) + + # state_add() + p.state_add("state9", 0.1) + self.assertEqual(p.states, ["default 0.00","state1 0.00","state2 0.00","state2 0.10","state9 0.10"]) + + # state_selected TODO FIXME state_selected_set does not work + # self.assertEqual(p.state_selected_get(), ("default", 0.0)) + # p.state_selected_set("state2", 0.1) + # self.assertEqual(p.state_selected_get(), ("state2", 0.1)) + + # state del() TODO FIXME state_del does not work + # p.state_del("state9", 0.1) + # self.assertEqual(p.states, ["default 0.00","state1 0.00","state2 0.00","state2 0.10"]) + + # TODO test state_copy + + @unittest.skip("state_exist does not work") # TODO FIXME + def testPartStateExist(self): + p = self.o.part_get("edit_test") + self.assertFalse(p.state_exist("stateNOTEXISTS", 0.1)) + self.assertTrue(p.state_exist("state1", 0.0)) + self.assertTrue(p.state_exist("state2", 0.1)) + + @unittest.skip("PartState does not work") # TODO FIXME + def testPartStateProps(self): + p = self.o.part_get("edit_test") + s = p.state_get("state1", 0.0) + print(s) + print(s.rel1_to_get()) + + + + +if __name__ == '__main__': + unittest.main(verbosity=2) + edje.shutdown() + ecore.shutdown() + evas.shutdown() diff --git a/tests/edje/theme.edc b/tests/edje/theme.edc index 1210f57..c24d92a 100644 --- a/tests/edje/theme.edc +++ b/tests/edje/theme.edc @@ -8,6 +8,38 @@ data { item: "key2" "value2"; } +styles { + style { + name: "style1"; + base: "font=Sans font_size=13 color=#fff wrap=word"; + tag: "br" "\n"; + tag: "tab" "\t"; + } + style { + name: "style2"; + base: "font=Sans font_size=9 color=#ccc"; + tag: "br" "\n"; + tag: "tab" "\t"; + tag: "b" "+ font=Sans:style=Bold"; + } +} + +color_classes { + color_class { + name: "colorclass1"; + color: 1 2 3 4; + color2: 5 6 7 8; + color3: 9 10 11 12; + } + color_class { + name: "colorclass2"; + color: 13 14 15 16; + color2: 17 18 19 20; + color3: 21 22 23 24; + } +} + + collections { group { name: "main"; @@ -19,6 +51,12 @@ collections { item: "key4" "value4"; } + script { + public my_func(val) { + set_text(PART:"label", "asd"); + } + } + parts { part { name: "bg"; type: RECT; @@ -70,6 +108,52 @@ collections { } } } + //// Used to test edje edit + part { name: "test_clip"; + type: RECT; + mouse_events: 0; + description { + state: "default" 0.0; + } + } + part { name: "edit_test"; + type: RECT; + mouse_events: 0; + repeat_events: 0; + scale: 1; + effect: OUTLINE BOTTOM; + ignore_flags: ON_HOLD; + clip_to: "test_clip"; + api: "api_name" "api_description"; + description { + state: "default" 0.0; + } + description { + state: "state1" 0.0; + } + description { + state: "state2" 0.0; + } + description { + state: "state2" 0.1; + } + dragable { + confine: "label"; + events: "edit_test_drag_event"; + x: 1 6 8; + y: 1 7 9; + } + } + part { name: "edit_test_drag_event"; + type: RECT; + description { + state: "default" 0.0; + } + dragable { + x: 1 0 0; + y: 1 0 0; + } + } //// Externals (hiddens, only used for the unittests) part { name: "ext_elm_actionslider"; type: EXTERNAL; @@ -447,13 +531,29 @@ collections { } } programs { - program { - name: "emit_back_message"; + program { name: "emit_back_message"; signal: "emit,message"; script { send_message(MSG_INT, 1, 1); } } + program { name: "prog1"; + source: "edit_test"; + signal: "mouse,down,1"; + in: 1.1 2.2; + action: STATE_SET "state2" 0.1; + target: "edit_test"; + target: "test_clip"; + after: "prog2"; + after: "prog3"; + api: "p_api_name" "p_api_desc"; + } + program { name: "prog2"; + } + program { name: "prog3"; + } + program { name: "prog4"; + } } } } diff --git a/tests/edje/theme.edj b/tests/edje/theme.edj index 87eb49247f956be8005ea699784c5563638203fa..d77072ba758843dbfa36e56db95059de59e6cf90 100644 GIT binary patch literal 15994 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