Beispiel #1
0
std::string ImageStateEdit::getImage ()
{
  const char *cimage = edje_edit_state_image_get (mEdit->obj (), mPart.c_str (), mState.c_str (), mValue);  
  string image (cimage);
  edje_edit_string_free(cimage);
  return image;
}
void
data_window_populate(void)
{
   Eina_List *l, *datas;
   Etk_Tree_Col *col1, *col2;
   // FIXME type of data ?
   char *data;

   col1 = etk_tree_nth_col_get(ETK_TREE(UI_DataList), 0);
   col2 = etk_tree_nth_col_get(ETK_TREE(UI_DataList), 1);

   etk_tree_freeze(ETK_TREE(UI_DataList));
   etk_tree_clear(ETK_TREE(UI_DataList));

   datas = edje_edit_data_list_get(edje_o);
   EINA_LIST_FOREACH(datas, l , data)
   {
      const char *val;

      val = edje_edit_data_value_get(edje_o, data);
      etk_tree_row_append(ETK_TREE(UI_DataList), NULL,
                    col1, data,
                    col2, val,
                    NULL);
      edje_edit_string_free(val);
   }
   edje_edit_string_list_free(datas);

   etk_tree_thaw(ETK_TREE(UI_DataList));
   
   etk_widget_disabled_set(UI_DataApplyButton, ETK_TRUE);
   etk_entry_text_set(ETK_ENTRY(UI_DataNameEntry), "");
   etk_entry_text_set(ETK_ENTRY(UI_DataValueEntry), "");
}
static Eina_Bool
_parts_parse(Evas_Object *ed)
{
   Eina_List *parts, *l;
   const char *name, *description;
   char *apiname;
   Edje_Part_Type type;
   Eina_Bool ret = EINA_TRUE;

   parts = edje_edit_parts_list_get(ed);
   EINA_LIST_FOREACH(parts, l, name)
     {
	if (!(apiname = _part_api_name_get(ed, name)))
	  {
	     DBG("filter out part '%s': not API.", name);
	     continue;
	  }

	type = edje_edit_part_type_get(ed, name);
	if ((type != EDJE_PART_TYPE_SWALLOW) &&
	    (type != EDJE_PART_TYPE_TEXT)    &&
	    (type != EDJE_PART_TYPE_BOX)     &&
	    (type != EDJE_PART_TYPE_TABLE))
	  {
	     free(apiname);
	     continue;
	  }

	description = edje_edit_part_api_description_get(ed, name);
	if (!_part_write(apiname, name, description, type))
	  {
	     ret = EINA_FALSE;
	     edje_edit_string_free(description);
	     free(apiname);
	     break;
	  }

	edje_edit_string_free(description);
	free(apiname);
     }

   edje_edit_string_list_free(parts);
   return ret;
}
static char *
_program_api_name_get(Evas_Object *ed, const char *program)
{
   const char *orig;
   char *fix;

   orig = edje_edit_program_api_name_get(ed, program);
   fix = _api_name_fix(orig);
   edje_edit_string_free(orig);

   return fix;
}
void
image_frame_update(void)
{
   //Etk_Combobox_Item *item = NULL;
   const char *im;

   //Stop signal propagation
   etk_signal_block("value-changed",ETK_OBJECT(UI_BorderLeftSpinner),
                    ETK_CALLBACK(_image_border_spinners_value_changed_cb),
                    (void*)BORDER_LEFT);
   etk_signal_block("value-changed",ETK_OBJECT(UI_BorderRightSpinner),
                    ETK_CALLBACK(_image_border_spinners_value_changed_cb),
                    (void*)BORDER_RIGHT);
   etk_signal_block("value-changed",ETK_OBJECT(UI_BorderTopSpinner),
                    ETK_CALLBACK(_image_border_spinners_value_changed_cb),
                    (void*)BORDER_TOP);
   etk_signal_block("value-changed",ETK_OBJECT(UI_BorderBottomSpinner),
                    ETK_CALLBACK(_image_border_spinners_value_changed_cb),
                    (void*)BORDER_BOTTOM);
   etk_signal_block("value-changed",ETK_OBJECT(UI_ImageAlphaSlider),
                    ETK_CALLBACK(_image_AlphaSlider_value_changed_cb), NULL);
   etk_signal_block("icon-selected", ETK_OBJECT(UI_ImageBrowserIconbox),
                    ETK_CALLBACK(_image_browser_iconbox_selected_cb), NULL);
   etk_signal_block("toggled", ETK_OBJECT(UI_BorderMiddleCheck),
                    ETK_CALLBACK(_image_BorderMiddleCheck_toggled_cb), NULL);

   if (!etk_string_length_get(Cur.state)) return;
   if (!etk_string_length_get(Cur.part)) return;

   image_tweenlist_populate();
   etk_widget_disabled_set(UI_DeleteTweenButton, TRUE);
   etk_widget_disabled_set(UI_MoveDownTweenButton, TRUE);
   etk_widget_disabled_set(UI_MoveUpTweenButton, TRUE);

   /* Update Image Browser */
   image_browser_update();

   //Set the images label for normal image
   im = edje_edit_state_image_get(edje_o, Cur.part->string, Cur.state->string);
   if (im)
   {
      etk_label_set(ETK_LABEL(UI_ImageNameLabel), im);
      edje_edit_string_free(im);
   }
   else
   {
      etk_label_set(ETK_LABEL(UI_ImageNameLabel), "none");
   }

   //Set alpha and borders
   int alpha, t, l, r, b;
   edje_edit_state_color_get(edje_o, Cur.part->string, Cur.state->string,
                             NULL, NULL, NULL, &alpha);
   edje_edit_state_image_border_get(edje_o, Cur.part->string, Cur.state->string,
                                    &l, &r, &t, &b);
   etk_range_value_set(ETK_RANGE(UI_ImageAlphaSlider), alpha);
   etk_range_value_set(ETK_RANGE(UI_BorderLeftSpinner), l);
   etk_range_value_set(ETK_RANGE(UI_BorderRightSpinner), r);
   etk_range_value_set(ETK_RANGE(UI_BorderTopSpinner), t);
   etk_range_value_set(ETK_RANGE(UI_BorderBottomSpinner), b);
   etk_toggle_button_active_set(ETK_TOGGLE_BUTTON(UI_BorderMiddleCheck),
         edje_edit_state_image_border_fill_get(edje_o, Cur.part->string,
                                                      Cur.state->string));

   //ReEnable Signal Propagation
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_BorderLeftSpinner),
                      _image_border_spinners_value_changed_cb,
                      (void*)BORDER_LEFT);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_BorderRightSpinner),
                      _image_border_spinners_value_changed_cb,
                      (void*)BORDER_RIGHT);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_BorderTopSpinner),
                      _image_border_spinners_value_changed_cb,
                      (void*)BORDER_TOP);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_BorderBottomSpinner),
                      _image_border_spinners_value_changed_cb,
                      (void*)BORDER_BOTTOM);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_ImageAlphaSlider),
                      _image_AlphaSlider_value_changed_cb, NULL);
   etk_signal_unblock("icon-selected", ETK_OBJECT(UI_ImageBrowserIconbox),
                      ETK_CALLBACK(_image_browser_iconbox_selected_cb), NULL);
   etk_signal_unblock("toggled", ETK_OBJECT(UI_BorderMiddleCheck),
                      ETK_CALLBACK(_image_BorderMiddleCheck_toggled_cb), NULL);
}
void
gradient_frame_update(void)
{
   const char *type;
   char *p;
   int i;
   int alpha;
   Etk_Combobox_Item *item;

   //Disable signal propagation
   etk_signal_block("item-activated", ETK_OBJECT(UI_GradientTypeComboBox),
                     ETK_CALLBACK(_gradient_type_combo_activated_cb), NULL);
   etk_signal_block("item-activated", ETK_OBJECT(UI_GradientSpectraComboBox),
                     ETK_CALLBACK(_gradient_spectra_combo_activated_cb), NULL);

   etk_signal_block("value-changed", ETK_OBJECT(UI_GradientAlphaSlider),
                    ETK_CALLBACK(_image_AlphaSlider_value_changed_cb), NULL);
   etk_signal_block("value-changed", ETK_OBJECT(UI_GradientAngleSlider),
                  ETK_CALLBACK(_gradient_AngleSlider_value_changed_cb), NULL);

   etk_signal_block("value-changed", ETK_OBJECT(UI_GradientRel1XSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL1X_SPINNER);
   etk_signal_block("value-changed", ETK_OBJECT(UI_GradientRel1YSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL1Y_SPINNER);
   etk_signal_block("value-changed", ETK_OBJECT(UI_GradientRel2XSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL2X_SPINNER);
   etk_signal_block("value-changed", ETK_OBJECT(UI_GradientRel2YSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL2Y_SPINNER);

   etk_signal_block("value-changed", ETK_OBJECT(UI_GradientRel1XOffsetSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL1XO_SPINNER);
   etk_signal_block("value-changed", ETK_OBJECT(UI_GradientRel1YOffsetSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL1YO_SPINNER);
   etk_signal_block("value-changed", ETK_OBJECT(UI_GradientRel2XOffsetSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL2XO_SPINNER);
   etk_signal_block("value-changed", ETK_OBJECT(UI_GradientRel2YOffsetSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL2YO_SPINNER);

   //Set Gradient Type Combo
   type = edje_edit_state_gradient_type_get(edje_o, Cur.part->string, Cur.state->string);
   if (type)
   {
      i=0;
      while ((item = etk_combobox_nth_item_get(ETK_COMBOBOX(UI_GradientTypeComboBox), i)))
      {
         p = etk_combobox_item_field_get(item, 1);
         if (strcmp(p, type) == 0)
            etk_combobox_active_item_set(ETK_COMBOBOX(UI_GradientTypeComboBox), item);
         i++;
      }
      edje_edit_string_free(type);
   }
   else
      etk_combobox_active_item_set(ETK_COMBOBOX(UI_GradientTypeComboBox),
            etk_combobox_nth_item_get(ETK_COMBOBOX(UI_GradientTypeComboBox), 0));

   //Set Gradient Spectra Combo
   type = edje_edit_state_gradient_spectra_get(edje_o, Cur.part->string, Cur.state->string);
   if (type)
   {
      i=0;
      while ((item = etk_combobox_nth_item_get(ETK_COMBOBOX(UI_GradientSpectraComboBox), i)))
      {
         p = etk_combobox_item_field_get(item, 1);
         if (strcmp(p, type) == 0)
         {
            etk_combobox_active_item_set(ETK_COMBOBOX(UI_GradientSpectraComboBox), item);
            break;
         }
         i++;
      }
      edje_edit_string_free(type);
   }
   else
      etk_combobox_active_item_set(ETK_COMBOBOX(UI_GradientSpectraComboBox),
            etk_combobox_nth_item_get(ETK_COMBOBOX(UI_GradientSpectraComboBox), 0));

   //Set alpha slider
   edje_edit_state_color_get(edje_o, Cur.part->string, Cur.state->string,
                             NULL, NULL, NULL, &alpha);
   etk_range_value_set(ETK_RANGE(UI_GradientAlphaSlider), alpha);
   //Set Angle slider
   etk_range_value_set(ETK_RANGE(UI_GradientAngleSlider),
                       edje_edit_state_gradient_angle_get(edje_o,
                           Cur.part->string, Cur.state->string));
   
   //Update Rels spinners
   etk_range_value_set(ETK_RANGE(UI_GradientRel1XSpinner),
      edje_edit_state_gradient_rel1_relative_x_get(edje_o, Cur.part->string,
                                                   Cur.state->string));
   etk_range_value_set(ETK_RANGE(UI_GradientRel1YSpinner),
      edje_edit_state_gradient_rel1_relative_y_get(edje_o, Cur.part->string,
                                                   Cur.state->string));
   etk_range_value_set(ETK_RANGE(UI_GradientRel1XOffsetSpinner),
      edje_edit_state_gradient_rel1_offset_x_get(edje_o, Cur.part->string,
                                                 Cur.state->string));
   etk_range_value_set(ETK_RANGE(UI_GradientRel1YOffsetSpinner),
      edje_edit_state_gradient_rel1_offset_y_get(edje_o, Cur.part->string,
                                                 Cur.state->string));
   etk_range_value_set(ETK_RANGE(UI_GradientRel2XSpinner),
      edje_edit_state_gradient_rel2_relative_x_get(edje_o, Cur.part->string,
                                                   Cur.state->string));
   etk_range_value_set(ETK_RANGE(UI_GradientRel2YSpinner),
      edje_edit_state_gradient_rel2_relative_y_get(edje_o, Cur.part->string,
                                                   Cur.state->string));
   etk_range_value_set(ETK_RANGE(UI_GradientRel2XOffsetSpinner),
      edje_edit_state_gradient_rel2_offset_x_get(edje_o, Cur.part->string,
                                                 Cur.state->string));
   etk_range_value_set(ETK_RANGE(UI_GradientRel2YOffsetSpinner),
      edje_edit_state_gradient_rel2_offset_y_get(edje_o, Cur.part->string,
                                                 Cur.state->string));

   //Reenable signal propagation
   etk_signal_unblock("item-activated", ETK_OBJECT(UI_GradientTypeComboBox),
                     ETK_CALLBACK(_gradient_type_combo_activated_cb), NULL);
   etk_signal_unblock("item-activated", ETK_OBJECT(UI_GradientSpectraComboBox),
                     ETK_CALLBACK(_gradient_spectra_combo_activated_cb), NULL);

   etk_signal_unblock("value-changed", ETK_OBJECT(UI_GradientAlphaSlider),
                    ETK_CALLBACK(_image_AlphaSlider_value_changed_cb), NULL);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_GradientAngleSlider),
                  ETK_CALLBACK(_gradient_AngleSlider_value_changed_cb), NULL);

   etk_signal_unblock("value-changed", ETK_OBJECT(UI_GradientRel1XSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL1X_SPINNER);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_GradientRel1YSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL1Y_SPINNER);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_GradientRel2XSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL2X_SPINNER);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_GradientRel2YSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL2Y_SPINNER);

   etk_signal_unblock("value-changed", ETK_OBJECT(UI_GradientRel1XOffsetSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL1XO_SPINNER);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_GradientRel1YOffsetSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL1YO_SPINNER);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_GradientRel2XOffsetSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL2XO_SPINNER);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_GradientRel2YOffsetSpinner),
                    ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
                    (void *)REL2YO_SPINNER);
}
static Eina_Bool
_programs_parse(Evas_Object *ed)
{
   Eina_Bool ret = EINA_TRUE;
   Eina_List *programs, *l;
   const char *name, *source = NULL, *sig = NULL, *description;
   char *apiname;
   Edje_Action_Type type;

   programs = edje_edit_programs_list_get(ed);
   EINA_LIST_FOREACH(programs, l, name)
     {
	if (!(apiname = _program_api_name_get(ed, name)))
	  {
	     DBG("filter out program '%s': not API.", name);
	     continue;
	  }

	description = edje_edit_program_api_description_get(ed, name);
	type = edje_edit_program_action_get(ed, name);
	if (type == EDJE_ACTION_TYPE_SIGNAL_EMIT)
	  {
	     const char *str, *str2;
	     str = edje_edit_program_state_get(ed, name);
	     str2 = edje_edit_program_state2_get(ed, name);

	     if (!_program_add_write(apiname, str2, str, description))
	       {
		  ret = EINA_FALSE;
		  edje_edit_string_free(str);
		  edje_edit_string_free(str2);
		  break;
	       }

	     edje_edit_string_free(str);
	     edje_edit_string_free(str2);
	  }

	sig = edje_edit_program_signal_get(ed, name);
	if (!sig) sig = eina_stringshare_add("");

	source = edje_edit_program_source_get(ed, name);
	if (!source) source = eina_stringshare_add("");

	if (strlen (sig))
	  {
	     if (!_program_emit_write(apiname, source, sig, description))
	       {
		  ret = EINA_FALSE;
		  break;
	       }
	  }

	edje_edit_string_free(description);
	edje_edit_string_free(sig);
	edje_edit_string_free(source);
	free(apiname);
     }

   edje_edit_string_list_free(programs);
   if (!ret)
     {
	edje_edit_string_free(description);
	edje_edit_string_free(sig);
	edje_edit_string_free(source);
	free(apiname);
     }

   return ret;
}
void
state_frame_update(void)
{
   const char* cc;
   
   //Stop signal propagation
   etk_signal_block("text-changed", ETK_OBJECT(UI_StateEntry),
                    _group_NamesEntry_text_changed_cb, NULL);
   etk_signal_block("value-changed", ETK_OBJECT(UI_AspectMinSpinner),
                    ETK_CALLBACK(_state_AspectSpinner_value_changed_cb), NULL);
   etk_signal_block("value-changed", ETK_OBJECT(UI_AspectMaxSpinner),
                    ETK_CALLBACK(_state_AspectSpinner_value_changed_cb), NULL);
   etk_signal_block("active-item-changed", ETK_OBJECT(UI_AspectComboBox),
                    ETK_CALLBACK(_state_AspectComboBox_changed_cb), NULL);
   etk_signal_block("value-changed", ETK_OBJECT(UI_StateMinWSpinner),
                    ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
   etk_signal_block("value-changed", ETK_OBJECT(UI_StateMinHSpinner),
                    ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
   etk_signal_block("value-changed", ETK_OBJECT(UI_StateMaxWSpinner),
                    ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
   etk_signal_block("value-changed", ETK_OBJECT(UI_StateMaxHSpinner),
                    ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
   etk_signal_block("value-changed", ETK_OBJECT(UI_StateAlignVSpinner),
                    ETK_CALLBACK(_text_FontAlignSpinner_value_changed_cb),
                    (void*)STATE_ALIGNV_SPINNER);
   etk_signal_block("value-changed", ETK_OBJECT(UI_StateAlignHSpinner),
                    ETK_CALLBACK(_text_FontAlignSpinner_value_changed_cb),
                    (void*)STATE_ALIGNH_SPINNER);
   etk_signal_block("toggled", ETK_OBJECT(UI_StateVisibleCheck),
                    ETK_CALLBACK(_state_VisibleCheck_toggled_cb), NULL);
   etk_signal_block("text-changed", ETK_OBJECT(UI_StateCCEntry),
                    ETK_CALLBACK(_state_CCEntry_text_changed_cb), NULL);

   if (etk_string_length_get(Cur.state))
   {
      //Set description name & index
      etk_entry_text_set(ETK_ENTRY(UI_StateEntry),Cur.state->string);
      etk_widget_hide(ETK_WIDGET(UI_StateEntryImage));
      if (!strcmp(Cur.state->string, "default 0.00"))
         etk_widget_disabled_set(ETK_WIDGET(UI_StateEntry), ETK_TRUE);
      else
         etk_widget_disabled_set(ETK_WIDGET(UI_StateEntry), ETK_FALSE);

      //Set aspect min & max
      etk_range_value_set(ETK_RANGE(UI_AspectMinSpinner),
         edje_edit_state_aspect_min_get(edje_o, Cur.part->string, Cur.state->string));
      etk_range_value_set(ETK_RANGE(UI_AspectMaxSpinner),
         edje_edit_state_aspect_max_get(edje_o, Cur.part->string, Cur.state->string));

      //Set aspect pref Combo
      etk_combobox_active_item_set(ETK_COMBOBOX(UI_AspectComboBox),
         etk_combobox_nth_item_get(ETK_COMBOBOX(UI_AspectComboBox), 
            edje_edit_state_aspect_pref_get(edje_o, Cur.part->string, Cur.state->string)));

      //Set min e max size
      etk_range_value_set(ETK_RANGE(UI_StateMinWSpinner),
         edje_edit_state_min_w_get(edje_o, Cur.part->string, Cur.state->string));
      etk_range_value_set(ETK_RANGE(UI_StateMinHSpinner),
         edje_edit_state_min_h_get(edje_o, Cur.part->string, Cur.state->string));
      etk_range_value_set(ETK_RANGE(UI_StateMaxWSpinner),
         edje_edit_state_max_w_get(edje_o, Cur.part->string, Cur.state->string));
      etk_range_value_set(ETK_RANGE(UI_StateMaxHSpinner),
         edje_edit_state_max_h_get(edje_o, Cur.part->string, Cur.state->string));

      //Set description align & valign
      etk_range_value_set(ETK_RANGE(UI_StateAlignHSpinner),
         edje_edit_state_align_x_get(edje_o, Cur.part->string, Cur.state->string));
      etk_range_value_set(ETK_RANGE(UI_StateAlignVSpinner),
         edje_edit_state_align_y_get(edje_o, Cur.part->string, Cur.state->string));

      //Set visible checkbox
      etk_toggle_button_active_set(ETK_TOGGLE_BUTTON(UI_StateVisibleCheck),
         edje_edit_state_visible_get(edje_o, Cur.part->string, Cur.state->string));
      
      //Set Color Class Entry
      cc = edje_edit_state_color_class_get(edje_o, Cur.part->string, Cur.state->string);
      etk_entry_text_set(ETK_ENTRY(UI_StateCCEntry), cc);
      edje_edit_string_free(cc);
   }

   //ReEnable Signal Propagation
   etk_signal_unblock("text-changed", ETK_OBJECT(UI_StateEntry),
                      _group_NamesEntry_text_changed_cb, NULL);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_AspectMinSpinner),
                      ETK_CALLBACK(_state_AspectSpinner_value_changed_cb), NULL);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_AspectMaxSpinner),
                      ETK_CALLBACK(_state_AspectSpinner_value_changed_cb), NULL);
   etk_signal_unblock("active-item-changed", ETK_OBJECT(UI_AspectComboBox),
                      ETK_CALLBACK(_state_AspectComboBox_changed_cb), NULL);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_StateMinWSpinner),
                      ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_StateMinHSpinner),
                      ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_StateMaxWSpinner),
                      ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_StateMaxHSpinner),
                      ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_StateAlignVSpinner),
                      ETK_CALLBACK(_text_FontAlignSpinner_value_changed_cb),
                      (void*)STATE_ALIGNV_SPINNER);
   etk_signal_unblock("value-changed", ETK_OBJECT(UI_StateAlignHSpinner),
                      ETK_CALLBACK(_text_FontAlignSpinner_value_changed_cb),
                      (void*)STATE_ALIGNH_SPINNER);
   etk_signal_unblock("toggled", ETK_OBJECT(UI_StateVisibleCheck),
                      ETK_CALLBACK(_state_VisibleCheck_toggled_cb), NULL);
   etk_signal_unblock("text-changed", ETK_OBJECT(UI_StateCCEntry),
                      ETK_CALLBACK(_state_CCEntry_text_changed_cb), NULL);

}