/* Creates the window for the mdi test */
void etk_test_mdi_window_window_create(void *data)
{
static Etk_Widget *win = NULL;
Etk_Widget *mdi_area;
Etk_Widget *mdi_window;
Etk_Widget *down_image;
Etk_Widget *next_image;
Etk_Widget *prev_image;
Etk_Widget *up_image;
Etk_Widget *table;
if (win)
{
etk_widget_show_all(ETK_WIDGET(win));
return;
}
win = etk_window_new();
etk_window_resize(ETK_WINDOW(win), 300, 300);
etk_window_title_set(ETK_WINDOW(win), "Etk Mdi Window Test");
etk_container_border_width_set(ETK_CONTAINER(win), 5);
etk_signal_connect_by_code(ETK_WINDOW_DELETE_EVENT_SIGNAL, ETK_OBJECT(win), ETK_CALLBACK(etk_window_hide_on_delete), NULL);
down_image = etk_image_new_from_stock(ETK_STOCK_GO_DOWN, ETK_STOCK_BIG);
next_image = etk_image_new_from_stock(ETK_STOCK_GO_NEXT, ETK_STOCK_BIG);
prev_image = etk_image_new_from_stock(ETK_STOCK_GO_PREVIOUS, ETK_STOCK_BIG);
up_image = etk_image_new_from_stock(ETK_STOCK_GO_UP, ETK_STOCK_BIG);
table = etk_table_new(3, 3, ETK_TABLE_NOT_HOMOGENEOUS);
etk_container_add(ETK_CONTAINER(win), table);
etk_table_attach(ETK_TABLE(table), down_image, 0, 2, 0, 0, ETK_TABLE_NONE, 0, 0);
etk_table_attach(ETK_TABLE(table), next_image, 0, 0, 1, 1, ETK_TABLE_NONE, 0, 0);
etk_table_attach(ETK_TABLE(table), prev_image, 2, 2, 1, 1, ETK_TABLE_NONE, 0, 0);
etk_table_attach(ETK_TABLE(table), up_image, 0, 2, 2, 2, ETK_TABLE_NONE, 0, 0);
mdi_area = etk_mdi_area_new();
etk_table_attach_default(ETK_TABLE(table), mdi_area, 1, 1, 1, 1);
mdi_window = etk_mdi_window_new();
etk_mdi_window_title_set(ETK_MDI_WINDOW(mdi_window), "Mdi Window 1");
etk_widget_size_request_set(ETK_WIDGET(mdi_window), 100, 100);
etk_container_add(ETK_CONTAINER(mdi_area), mdi_window);
mdi_window = etk_mdi_window_new();
etk_mdi_window_title_set(ETK_MDI_WINDOW(mdi_window), "Mdi Window 2");
etk_mdi_window_move(ETK_MDI_WINDOW(mdi_window), 100, 100);
etk_widget_size_request_set(ETK_WIDGET(mdi_window), 100, 100);
etk_container_add(ETK_CONTAINER(mdi_area), mdi_window);
etk_widget_show_all(win);
}
void
_ex_tab_select(Ex_Tab *tab)
{
//chdir(tab->dir);
D(("_ex_tab_select: changed dir to %s\n", tab->dir));
D(("_ex_tab_select: selecting tab num %d\n", e->cur_tab->num));
if (tab->comment.visible)
etk_notebook_page_child_set(ETK_NOTEBOOK(e->notebook), tab->num,
tab->comment.vbox);
else if (tab->fit_window)
etk_notebook_page_child_set(ETK_NOTEBOOK(e->notebook), tab->num,
tab->alignment);
etk_table_attach(ETK_TABLE(e->table), tab->dtree,
0, 3, 3, 3,
ETK_TABLE_VEXPAND | ETK_TABLE_FILL, 0, 0);
etk_widget_show(tab->dtree);
etk_paned_child2_set(ETK_PANED(e->vpaned), tab->itree, ETK_TRUE);
etk_widget_show(tab->itree);
etk_widget_show(tab->image);
etk_widget_show(tab->alignment);
etk_widget_show(tab->scrolled_view);
etk_widget_show_all(e->win);
}
/* Removes the child from the table */
static void _etk_table_child_remove(Etk_Container *container, Etk_Widget *widget)
{
Etk_Table *table;
Etk_Table_Cell *cell;
if (!(table = ETK_TABLE(container)) || !widget)
return;
if (!(cell = etk_object_data_get(ETK_OBJECT(widget), "_Etk_Table::Cell")))
return;
etk_table_cell_clear(table, cell->left_attach, cell->top_attach);
}
/* Gets the list of the children */
static Eina_List *_etk_table_children_get(Etk_Container *container)
{
Etk_Table *table;
Etk_Table_Cell *cell;
Eina_List *children, *l;
if (!(table = ETK_TABLE(container)))
return NULL;
children = NULL;
for (l = table->cells_list; l; l = l->next)
{
cell = l->data;
children = eina_list_append(children, cell->child);
}
return children;
}
/* Gets the value of the property whose id is "property_id" */
static void _etk_table_property_get(Etk_Object *object, int property_id, Etk_Property_Value *value)
{
Etk_Table *table;
if (!(table = ETK_TABLE(object)) || !value)
return;
switch (property_id)
{
case ETK_TABLE_NUM_COLS_PROPERTY:
etk_property_value_int_set(value, table->num_cols);
break;
case ETK_TABLE_NUM_ROWS_PROPERTY:
etk_property_value_int_set(value, table->num_rows);
break;
case ETK_TABLE_HOMOGENEOUS_PROPERTY:
etk_property_value_int_set(value, table->homogeneous);
break;
default:
break;
}
}
/*** Implementation ***/
Etk_Widget*
image_frame_create(void)
{
Etk_Widget *label;
Etk_Widget *table;
Etk_Tree_Col *col1;
//table
table = etk_table_new(6, 5, ETK_TABLE_NOT_HOMOGENEOUS);
//AddImageButton
UI_ImageAddButton = etk_button_new_from_stock(ETK_STOCK_IMAGE_X_GENERIC);
etk_object_properties_set(ETK_OBJECT(UI_ImageAddButton), "label", "Choose Image", NULL);
etk_table_attach_default(ETK_TABLE(table), UI_ImageAddButton, 0, 2, 0, 0);
//ImageName
UI_ImageNameLabel = etk_label_new("none");
etk_object_properties_set(ETK_OBJECT(UI_ImageNameLabel), "xalign", 0.5, NULL);
etk_table_attach_default(ETK_TABLE(table), UI_ImageNameLabel, 3, 5, 0, 0);
//ImageTweenVBox
UI_ImageTweenVBox = etk_vbox_new(ETK_TRUE, 0);
etk_table_attach_default(ETK_TABLE(table), UI_ImageTweenVBox, 0, 1, 1, 1);
//AddTweenButton
UI_AddTweenButton = etk_button_new_from_stock(ETK_STOCK_LIST_ADD);
etk_button_style_set(ETK_BUTTON(UI_AddTweenButton), ETK_BUTTON_ICON);
etk_signal_connect("clicked", ETK_OBJECT(UI_AddTweenButton),
ETK_CALLBACK(_window_all_button_click_cb), (void*)IMAGE_TWEEN_ADD);
etk_box_append(ETK_BOX(UI_ImageTweenVBox), UI_AddTweenButton,
ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//DeleteTweenButton
UI_DeleteTweenButton = etk_button_new_from_stock(ETK_STOCK_LIST_REMOVE);
etk_button_style_set(ETK_BUTTON(UI_DeleteTweenButton), ETK_BUTTON_ICON);
etk_signal_connect("clicked", ETK_OBJECT(UI_DeleteTweenButton),
ETK_CALLBACK(_window_all_button_click_cb), (void*)IMAGE_TWEEN_DELETE);
etk_box_append(ETK_BOX(UI_ImageTweenVBox), UI_DeleteTweenButton,
ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//MoveUpTweenButton
UI_MoveUpTweenButton = etk_button_new_from_stock(ETK_STOCK_GO_UP);
etk_button_style_set(ETK_BUTTON(UI_MoveUpTweenButton), ETK_BUTTON_ICON);
etk_signal_connect("clicked", ETK_OBJECT(UI_MoveUpTweenButton),
ETK_CALLBACK(_window_all_button_click_cb), (void*)IMAGE_TWEEN_UP);
etk_box_append(ETK_BOX(UI_ImageTweenVBox), UI_MoveUpTweenButton,
ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//MoveDownTweenButton
UI_MoveDownTweenButton = etk_button_new_from_stock(ETK_STOCK_GO_DOWN);
etk_button_style_set(ETK_BUTTON(UI_MoveDownTweenButton), ETK_BUTTON_ICON);
etk_signal_connect("clicked", ETK_OBJECT(UI_MoveDownTweenButton),
ETK_CALLBACK(_window_all_button_click_cb), (void*)IMAGE_TWEEN_DOWN);
etk_box_append(ETK_BOX(UI_ImageTweenVBox), UI_MoveDownTweenButton,
ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//ImageTweenList
UI_ImageTweenList = etk_tree_new();
etk_tree_mode_set(ETK_TREE(UI_ImageTweenList), ETK_TREE_MODE_LIST);
etk_tree_headers_visible_set(ETK_TREE(UI_ImageTweenList), FALSE);
// etk_tree_multiple_select_set(ETK_TREE(UI_ImageTweenList), ETK_TRUE);
col1 = etk_tree_col_new(ETK_TREE(UI_ImageTweenList), "Tween", 130, 0.0);
etk_tree_col_model_add(col1, etk_tree_model_image_new());
etk_tree_col_model_add(col1, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(UI_ImageTweenList));
etk_table_attach_default(ETK_TABLE(table),UI_ImageTweenList, 2, 5, 1, 1);
label = etk_label_new("Alpha");
etk_table_attach_default(ETK_TABLE(table),label, 0, 0, 2, 2);
//ImageAlphaSlider
UI_ImageAlphaSlider = etk_hslider_new(0, 255, 15, 1,20);
etk_slider_label_set(ETK_SLIDER(UI_ImageAlphaSlider), "%.0f");
etk_table_attach_default(ETK_TABLE(table),UI_ImageAlphaSlider, 1, 5, 2, 2);
label = etk_label_new("Left");
etk_object_properties_set(ETK_OBJECT(label), "xalign",0.5,NULL);
etk_table_attach_default(ETK_TABLE(table),label, 1, 1, 3, 3);
label = etk_label_new("Right");
etk_object_properties_set(ETK_OBJECT(label), "xalign",0.5,NULL);
etk_table_attach_default(ETK_TABLE(table),label, 2, 2, 3, 3);
label = etk_label_new("Top");
etk_object_properties_set(ETK_OBJECT(label), "xalign",0.5,NULL);
etk_table_attach_default(ETK_TABLE(table),label, 3, 3, 3, 3);
label = etk_label_new("Bottom");
etk_object_properties_set(ETK_OBJECT(label), "xalign",0.5,NULL);
etk_table_attach_default(ETK_TABLE(table),label, 4, 4, 3, 3);
label = etk_label_new("Border");
//etk_object_properties_set(ETK_OBJECT(label), "xalign", 0.5, NULL);
etk_table_attach_default(ETK_TABLE(table),label, 0, 0, 4, 4);
//UI_BorderLeftSpinner
UI_BorderLeftSpinner = etk_spinner_new(0, 500, 0, 1, 10);
etk_widget_size_request_set(UI_BorderLeftSpinner,45, 20);
etk_table_attach_default(ETK_TABLE(table),UI_BorderLeftSpinner, 1, 1, 4, 4);
//UI_BorderRightSpinner
UI_BorderRightSpinner = etk_spinner_new(0, 500, 0, 1, 10);
etk_widget_size_request_set(UI_BorderRightSpinner,45, 20);
etk_table_attach_default(ETK_TABLE(table),UI_BorderRightSpinner, 2, 2, 4, 4);
//UI_BorderTopSpinner
UI_BorderTopSpinner = etk_spinner_new(0, 500, 0, 1, 10);
etk_widget_size_request_set(UI_BorderTopSpinner,45, 20);
etk_table_attach_default(ETK_TABLE(table),UI_BorderTopSpinner, 3, 3, 4, 4);
//UI_BorderBottomSpinner
UI_BorderBottomSpinner = etk_spinner_new(0, 500, 0, 1, 10);
etk_widget_size_request_set(UI_BorderBottomSpinner,45, 20);
etk_table_attach_default(ETK_TABLE(table),UI_BorderBottomSpinner, 4, 4, 4, 4);
//UI_BorderMiddleCheck
UI_BorderMiddleCheck = etk_check_button_new_with_label("Mid");
etk_table_attach_default(ETK_TABLE(table),UI_BorderMiddleCheck, 5, 5, 4, 4);
etk_signal_connect("row-selected", ETK_OBJECT(UI_ImageTweenList),
ETK_CALLBACK(_image_TweenList_row_selected_cb), NULL);
etk_signal_connect("clicked", ETK_OBJECT(UI_ImageAddButton),
ETK_CALLBACK(_window_all_button_click_cb), (void*)IMAGE_BROWSER_SHOW);
etk_signal_connect("value-changed", ETK_OBJECT(UI_ImageAlphaSlider),
ETK_CALLBACK(_image_AlphaSlider_value_changed_cb), NULL);
etk_signal_connect("value-changed", ETK_OBJECT(UI_BorderLeftSpinner),
ETK_CALLBACK(_image_border_spinners_value_changed_cb),
(void *)BORDER_LEFT);
etk_signal_connect("value-changed", ETK_OBJECT(UI_BorderRightSpinner),
ETK_CALLBACK(_image_border_spinners_value_changed_cb),
(void *)BORDER_RIGHT);
etk_signal_connect("value-changed", ETK_OBJECT(UI_BorderTopSpinner),
ETK_CALLBACK(_image_border_spinners_value_changed_cb),
(void *)BORDER_TOP);
etk_signal_connect("value-changed", ETK_OBJECT(UI_BorderBottomSpinner),
ETK_CALLBACK(_image_border_spinners_value_changed_cb),
(void *)BORDER_BOTTOM);
etk_signal_connect("toggled", ETK_OBJECT(UI_BorderMiddleCheck),
ETK_CALLBACK(_image_BorderMiddleCheck_toggled_cb), NULL);
return table;
}
/*** Implementation ***/
Etk_Widget*
gradient_frame_create(void)
{
Etk_Widget *table;
Etk_Widget *label;
Etk_Combobox_Item *item;
//table
table = etk_table_new(2, 5, ETK_TABLE_NOT_HOMOGENEOUS);
//UI_GradientTypeComboBox
label = etk_label_new("<b>Type</b>");
etk_table_attach(ETK_TABLE(table), label, 0, 0, 0, 0, ETK_TABLE_NONE, 0, 0);
UI_GradientTypeComboBox = etk_combobox_new();
etk_combobox_items_height_set(ETK_COMBOBOX(UI_GradientTypeComboBox), 24);
etk_combobox_column_add(ETK_COMBOBOX(UI_GradientTypeComboBox),
ETK_COMBOBOX_IMAGE, 27, ETK_COMBOBOX_NONE, 0.0);
etk_combobox_column_add(ETK_COMBOBOX(UI_GradientTypeComboBox),
ETK_COMBOBOX_LABEL, 75, ETK_COMBOBOX_EXPAND_FILL, 0.0);
etk_combobox_build(ETK_COMBOBOX(UI_GradientTypeComboBox));
etk_table_attach_default(ETK_TABLE(table), UI_GradientTypeComboBox, 1, 1, 0, 0);
item = etk_combobox_item_append(ETK_COMBOBOX(UI_GradientTypeComboBox),
etk_image_new_from_edje(EdjeFile,"GRAD_LINEAR.PNG"), "linear");
item = etk_combobox_item_append(ETK_COMBOBOX(UI_GradientTypeComboBox),
etk_image_new_from_edje(EdjeFile,"GRAD_RADIAL.PNG"), "radial");
item = etk_combobox_item_append(ETK_COMBOBOX(UI_GradientTypeComboBox),
etk_image_new_from_edje(EdjeFile,"GRAD_RECTANGULAR.PNG"), "rectangular");
item = etk_combobox_item_append(ETK_COMBOBOX(UI_GradientTypeComboBox),
etk_image_new_from_edje(EdjeFile,"GRAD_ANGULAR.PNG"), "angular");
item = etk_combobox_item_append(ETK_COMBOBOX(UI_GradientTypeComboBox),
etk_image_new_from_edje(EdjeFile,"GRAD_SINUSOIDAL.PNG"), "sinusoidal");
//UI_GradientSpectraComboBox
label = etk_label_new("<b>Spectra</b>");
etk_table_attach(ETK_TABLE(table), label, 0, 0, 1, 1, ETK_TABLE_NONE, 0, 0);
UI_GradientSpectraComboBox = etk_combobox_new();
etk_combobox_column_add(ETK_COMBOBOX(UI_GradientSpectraComboBox),
ETK_COMBOBOX_OTHER, 45, ETK_COMBOBOX_NONE, 0.5);
etk_combobox_column_add(ETK_COMBOBOX(UI_GradientSpectraComboBox),
ETK_COMBOBOX_LABEL, 100, ETK_COMBOBOX_EXPAND_FILL, 0.0);
etk_combobox_build(ETK_COMBOBOX(UI_GradientSpectraComboBox));
etk_table_attach_default(ETK_TABLE(table), UI_GradientSpectraComboBox, 1, 1, 1, 1);
//GradientAlphaSlider
label = etk_label_new("<b>Alpha</b>");
etk_table_attach(ETK_TABLE(table), label, 0, 0, 2, 2, ETK_TABLE_NONE, 0, 0);
UI_GradientAlphaSlider = etk_hslider_new(0, 255, 15, 1,20);
etk_slider_label_set(ETK_SLIDER(UI_GradientAlphaSlider), "%.0f");
etk_table_attach_default(ETK_TABLE(table), UI_GradientAlphaSlider, 1, 1, 2, 2);
//GradientAngleSlider
label = etk_label_new("<b>Angle</b>");
etk_table_attach(ETK_TABLE(table), label, 0, 0, 3, 3, ETK_TABLE_NONE, 0, 0);
UI_GradientAngleSlider = etk_hslider_new(0, 360, 15, 1,20);
etk_slider_label_set(ETK_SLIDER(UI_GradientAngleSlider), "%.0f");
etk_table_attach_default(ETK_TABLE(table), UI_GradientAngleSlider, 1, 1, 3, 3);
//~ //hbox (first handler)
//~ hbox = etk_hbox_new(ETK_FALSE, 0);
//~ etk_table_attach_default(ETK_TABLE(table), hbox, 0, 2, 3, 3);
//~ label = etk_label_new("<b>Start X </b>");
//~ etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//~ //UI_GradientRel1XSpinner
//~ UI_GradientRel1XSpinner = etk_spinner_new(-100.0, 100.0, 0.0, 0.01, 0.1);
//~ etk_spinner_digits_set(ETK_SPINNER(UI_GradientRel1XSpinner), 2);
//~ etk_widget_size_request_set(UI_GradientRel1XSpinner, 45, 20);
//~ etk_box_append(ETK_BOX(hbox), UI_GradientRel1XSpinner,
//~ ETK_BOX_START, ETK_BOX_NONE, 0);
//~ label = etk_label_new("+");
//~ etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
//~ //UI_GradientRel1XOffsetSpinner
//~ UI_GradientRel1XOffsetSpinner = etk_spinner_new(-2000, 2000, 0, 1, 10);
//~ etk_widget_size_request_set(UI_GradientRel1XOffsetSpinner, 45, 20);
//~ etk_box_append(ETK_BOX(hbox), UI_GradientRel1XOffsetSpinner,
//~ ETK_BOX_START, ETK_BOX_NONE, 0);
//~ label = etk_label_new("<b> Y </b>");
//~ etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//~ //UI_GradientRel1YSpinner
//~ UI_GradientRel1YSpinner = etk_spinner_new(-100.0, 100.0, 0.0, 0.01, 0.1);
//~ etk_spinner_digits_set(ETK_SPINNER(UI_GradientRel1YSpinner), 2);
//~ etk_widget_size_request_set(UI_GradientRel1YSpinner, 45, 20);
//~ etk_box_append(ETK_BOX(hbox), UI_GradientRel1YSpinner,
//~ ETK_BOX_START, ETK_BOX_NONE, 0);
//~ label = etk_label_new("+");
//~ etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
//~ //UI_GradientRel1YOffsetSpinner
//~ UI_GradientRel1YOffsetSpinner = etk_spinner_new(-2000, 2000, 0, 1, 10);
//~ etk_widget_size_request_set(UI_GradientRel1YOffsetSpinner, 45, 20);
//~ etk_box_append(ETK_BOX(hbox), UI_GradientRel1YOffsetSpinner,
//~ ETK_BOX_START, ETK_BOX_NONE, 0);
//hbox (second handler)
//~ hbox = etk_hbox_new(ETK_FALSE, 0);
//~ etk_table_attach_default(ETK_TABLE(table), hbox, 0, 2, 4, 4);
//~ label = etk_label_new("<b>End X </b>");
//~ etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//~ //UI_GradientRel2XSpinner
//~ UI_GradientRel2XSpinner = etk_spinner_new(-100.0, 100.0, 0.0, 0.01, 0.1);
//~ etk_spinner_digits_set(ETK_SPINNER(UI_GradientRel2XSpinner), 2);
//~ etk_widget_size_request_set(UI_GradientRel2XSpinner, 45, 20);
//~ etk_box_append(ETK_BOX(hbox), UI_GradientRel2XSpinner,
//~ ETK_BOX_START, ETK_BOX_NONE, 0);
//~ label = etk_label_new("+");
//~ etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
//~ //UI_GradientRel2XOffsetSpinner
//~ UI_GradientRel2XOffsetSpinner = etk_spinner_new(-2000, 2000, 0, 1, 10);
//~ etk_widget_size_request_set(UI_GradientRel2XOffsetSpinner, 45, 20);
//~ etk_box_append(ETK_BOX(hbox), UI_GradientRel2XOffsetSpinner,
//~ ETK_BOX_START, ETK_BOX_NONE, 0);
//~ label = etk_label_new("<b> Y </b>");
//~ etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//~ //UI_GradientRel2YSpinner
//~ UI_GradientRel2YSpinner = etk_spinner_new(-100.0, 100.0, 0.0, 0.01, 0.1);
//~ etk_spinner_digits_set(ETK_SPINNER(UI_GradientRel2YSpinner), 2);
//~ etk_widget_size_request_set(UI_GradientRel2YSpinner, 45, 20);
//~ etk_box_append(ETK_BOX(hbox), UI_GradientRel2YSpinner,
//~ ETK_BOX_START, ETK_BOX_NONE, 0);
//~ label = etk_label_new("+");
//~ etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
//~ //UI_GradientRel2YOffsetSpinner
//~ UI_GradientRel2YOffsetSpinner = etk_spinner_new(-2000, 2000, 0, 1, 10);
//~ etk_widget_size_request_set(UI_GradientRel2YOffsetSpinner, 45, 20);
//~ etk_box_append(ETK_BOX(hbox), UI_GradientRel2YOffsetSpinner,
//~ ETK_BOX_START, ETK_BOX_NONE, 0);
etk_signal_connect("item-activated", ETK_OBJECT(UI_GradientTypeComboBox),
ETK_CALLBACK(_gradient_type_combo_activated_cb), NULL);
etk_signal_connect("item-activated", ETK_OBJECT(UI_GradientSpectraComboBox),
ETK_CALLBACK(_gradient_spectra_combo_activated_cb), NULL);
etk_signal_connect("value-changed", ETK_OBJECT(UI_GradientAlphaSlider),
ETK_CALLBACK(_image_AlphaSlider_value_changed_cb), NULL);
etk_signal_connect("value-changed", ETK_OBJECT(UI_GradientAngleSlider),
ETK_CALLBACK(_gradient_AngleSlider_value_changed_cb), NULL);
//~ etk_signal_connect("value-changed", ETK_OBJECT(UI_GradientRel1XSpinner),
//~ ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
//~ (void *)REL1X_SPINNER);
//~ etk_signal_connect("value-changed", ETK_OBJECT(UI_GradientRel1YSpinner),
//~ ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
//~ (void *)REL1Y_SPINNER);
//~ etk_signal_connect("value-changed", ETK_OBJECT(UI_GradientRel2XSpinner),
//~ ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
//~ (void *)REL2X_SPINNER);
//~ etk_signal_connect("value-changed", ETK_OBJECT(UI_GradientRel2YSpinner),
//~ ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
//~ (void *)REL2Y_SPINNER);
//~ etk_signal_connect("value-changed", ETK_OBJECT(UI_GradientRel1XOffsetSpinner),
//~ ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
//~ (void *)REL1XO_SPINNER);
//~ etk_signal_connect("value-changed", ETK_OBJECT(UI_GradientRel1YOffsetSpinner),
//~ ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
//~ (void *)REL1YO_SPINNER);
//~ etk_signal_connect("value-changed", ETK_OBJECT(UI_GradientRel2XOffsetSpinner),
//~ ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
//~ (void *)REL2XO_SPINNER);
//~ etk_signal_connect("value-changed", ETK_OBJECT(UI_GradientRel2YOffsetSpinner),
//~ ETK_CALLBACK(_gradient_RelSpinners_value_changed_cb),
//~ (void *)REL2YO_SPINNER);
return table;
}
static void _ex_tab_tree_drag_begin_cb(Etk_Object *object, void *data)
{
Ex_Tab *tab;
Etk_Tree *tree;
Etk_Tree_Row *row;
Etk_Widget *drag;
Etk_Widget *image;
Eina_List *rows;
char *icol1_string;
char *icol2_string;
char *drag_data;
const char **types;
unsigned int num_types;
tab = data;
tree = ETK_TREE(object);
/* TODO: reimplement dnd when it is reimplemented in Etk
drag = (ETK_WIDGET(tree))->drag; */
drag = NULL;
rows = etk_tree_selected_rows_get(tree);
types = calloc(1, sizeof(char*));
num_types = 1;
types[0] = strdup("text/uri-list");
if (eina_list_count(rows) > 1)
{
Eina_List *ll;
Etk_Widget *table;
int i = 0, l = 0, r = 0, t = 0, b = 0, row_num;
if (eina_list_count(rows) >= EX_DND_COL_NUM)
row_num = eina_list_count(rows) / EX_DND_COL_NUM;
else
row_num = 1;
table = etk_table_new(EX_DND_COL_NUM, row_num + 1, ETK_TABLE_HOMOGENEOUS);
drag_data = calloc(PATH_MAX * eina_list_count(rows), sizeof(char));
EINA_LIST_FOREACH(rows, ll, row)
{
char tmp[PATH_MAX];
etk_tree_row_fields_get(row, etk_tree_nth_col_get(tree, 0), &icol1_string, &icol2_string, etk_tree_nth_col_get(tree, 1),NULL);
snprintf(tmp, PATH_MAX * sizeof(char), "file://%s%s\r\n", tab->dir, icol2_string);
strncat(drag_data, tmp, PATH_MAX * eina_list_count(rows));
if (i <= EX_DND_MAX_NUM * EX_DND_MAX_NUM)
{
image = etk_image_new_from_file(icol1_string, NULL);
etk_image_keep_aspect_set(ETK_IMAGE(image), ETK_TRUE);
etk_widget_size_request_set(image, 48, 48);
etk_table_attach(ETK_TABLE(table), image, l, r, t, b, ETK_TABLE_NONE, 3, 3);
++l; ++r;
if (l == EX_DND_COL_NUM)
{
l = r = 0;
++t; ++b;
}
}
++i;
}
void evolve_gui_placeholder_replace(Evolve_Widget *parent, Evolve_Widget *child, Etk_Widget *placeholder)
{
if (!parent || !parent->type || !child || !child->type || !placeholder)
return;
if (!strcmp(parent->type, "hbox") || !strcmp(parent->type, "vbox"))
{
int pos;
Etk_Box_Group group;
char *group_str;
char pos_str[5];
Evolve_Widget_Property *prop;
etk_box_child_position_get(ETK_BOX(parent->widget), placeholder,
&group, &pos);
group_str = evolve_widget_packing_property_to_str_convert("box", "group", group);
prop = calloc(1, sizeof(Evolve_Widget_Property));
prop->name = strdup("group");
prop->value = group_str;
prop->type = EVOLVE_WIDGET_PROP_INT;
eina_hash_add(child->packing_props, "group", prop);
prop = calloc(1, sizeof(Evolve_Widget_Property));
snprintf(pos_str, sizeof(pos_str), "%d", pos);
prop->name = strdup("position");
prop->value = strdup(pos_str);
prop->type = EVOLVE_WIDGET_PROP_INT;
eina_hash_add(child->packing_props, "position", prop);
}
else if (!strcmp(parent->type, "toolbar"))
{
/* [TODO] [3] We are accessing the toolbar's internals, better way? */
int pos;
char pos_str[5];
Evolve_Widget_Property *prop;
etk_box_child_position_get(ETK_BOX(ETK_TOOLBAR(parent->widget)->box),
placeholder,
NULL, &pos);
prop = calloc(1, sizeof(Evolve_Widget_Property));
snprintf(pos_str, sizeof(pos_str), "%d", pos);
prop->name = strdup("position");
prop->value = strdup(pos_str);
prop->type = EVOLVE_WIDGET_PROP_INT;
eina_hash_add(child->packing_props, "position", prop);
}
else if (!strcmp(parent->type, "table"))
{
int la, ra, ta, ba;
char la_str[5], ra_str[5], ta_str[5], ba_str[5];
Evolve_Widget_Property *prop;
etk_table_child_position_get(ETK_TABLE(parent->widget),
placeholder,
&la, &ra, &ta, &ba);
prop = calloc(1, sizeof(Evolve_Widget_Property));
snprintf(la_str, sizeof(la_str), "%d", la);
prop->name = strdup("left_attach");
prop->value = strdup(la_str);
prop->type = EVOLVE_WIDGET_PROP_INT;
eina_hash_add(child->packing_props, "left_attach", prop);
prop = calloc(1, sizeof(Evolve_Widget_Property));
snprintf(ra_str, sizeof(ra_str), "%d", ra);
prop->name = strdup("right_attach");
prop->value = strdup(ra_str);
prop->type = EVOLVE_WIDGET_PROP_INT;
eina_hash_add(child->packing_props, "right_attach", prop);
prop = calloc(1, sizeof(Evolve_Widget_Property));
snprintf(ta_str, sizeof(ta_str), "%d", ta);
prop->name = strdup("top_attach");
prop->value = strdup(ta_str);
prop->type = EVOLVE_WIDGET_PROP_INT;
eina_hash_add(child->packing_props, "top_attach", prop);
prop = calloc(1, sizeof(Evolve_Widget_Property));
snprintf(ba_str, sizeof(ba_str), "%d", ba);
prop->name = strdup("bottom_attach");
prop->value = strdup(ba_str);
prop->type = EVOLVE_WIDGET_PROP_INT;
eina_hash_add(child->packing_props, "bottom_attach", prop);
}
else if (!strcmp(parent->type, "notebook"))
{
int pos;
char pos_str[5];
const char *label;
Evolve_Widget_Property *prop;
pos = etk_notebook_page_index_get(ETK_NOTEBOOK(parent->widget), placeholder);
label = etk_notebook_page_tab_label_get(ETK_NOTEBOOK(parent->widget), pos);
prop = calloc(1, sizeof(Evolve_Widget_Property));
snprintf(pos_str, sizeof(pos_str), "%d", pos);
prop->name = strdup("position");
prop->value = strdup(pos_str);
prop->type = EVOLVE_WIDGET_PROP_INT;
eina_hash_add(child->packing_props, "position", prop);
if (label)
{
prop = calloc(1, sizeof(Evolve_Widget_Property));
prop->name = strdup("tab_label");
prop->value = strdup(label);
prop->type = EVOLVE_WIDGET_PROP_STR;
eina_hash_add(child->packing_props, "tab_label", prop);
}
}
etk_container_remove(placeholder);
}
void evolve_gui_general_table_populate(Evolve_Widget *widget)
{
Etk_Widget *label;
Etk_Widget *entry;
Etk_Type *type;
Eina_List *l, *list = NULL;
char *str;
int i = 2;
if (!widget || !widget->type || !(type = evolve_widget_type_to_etk(widget->type)))
return;
etk_type_property_list(type, &list);
etk_table_resize(ETK_TABLE(_evolve_gui_gen_table), 0, 0);
etk_table_resize(ETK_TABLE(_evolve_gui_gen_table), 2, eina_list_count(list) + 2);
label = etk_label_new("Class:");
entry = etk_entry_new();
etk_entry_text_set(ETK_ENTRY(entry), type->name);
etk_widget_disabled_set(entry, ETK_TRUE);
etk_table_attach_default(ETK_TABLE(_evolve_gui_gen_table), label,
0, 0, 0, 0);
etk_table_attach_default(ETK_TABLE(_evolve_gui_gen_table), entry,
1, 1, 0, 0);
label = etk_label_new("Name:");
entry = etk_entry_new();
etk_entry_text_set(ETK_ENTRY(entry), widget->name);
etk_table_attach_default(ETK_TABLE(_evolve_gui_gen_table), label,
0, 0, 1, 1);
etk_table_attach_default(ETK_TABLE(_evolve_gui_gen_table), entry,
1, 1, 1, 1);
for (l = list; l; l = l->next)
{
Evolve_Property *prop;
Evolve_Property *eprop;
Evolve_Property *p;
Etk_String *value;
Etk_Widget *vwidget;
if (!(prop = l->data))
continue;
str = evolve_util_string_humanize(prop->name);
label = etk_label_new(str);
free(str);
eprop = evolve_widget_property_get(widget, prop->name);
if (eprop && eprop->default_value)
p = eprop;
else
p = prop;
switch(prop->type)
{
case EVOLVE_PROPERTY_INT:
value = etk_string_new_printf("%d", evolve_property_value_int_get(p->default_value));
vwidget = etk_spinner_new(0, 9999, evolve_property_value_int_get(p->default_value), 1, 10);
etk_object_data_set_full(ETK_OBJECT(vwidget), "prop", p, NULL);
etk_object_data_set_full(ETK_OBJECT(vwidget), "widget", widget, NULL);
etk_signal_connect("value-changed", ETK_OBJECT(vwidget),
ETK_CALLBACK(evolve_gui_property_spinner_value_changed_cb),
NULL);
break;
case EVOLVE_PROPERTY_BOOL:
value = etk_string_new_printf("%d", evolve_property_value_bool_get(p->default_value));
vwidget = etk_combobox_new_default();
{
Etk_Combobox_Item *item;
item = etk_combobox_item_append(ETK_COMBOBOX(vwidget), "True");
if (evolve_property_value_bool_get(p->default_value))
etk_combobox_active_item_set(ETK_COMBOBOX(vwidget), item);
item = etk_combobox_item_append(ETK_COMBOBOX(vwidget), "False");
if (!evolve_property_value_bool_get(p->default_value))
etk_combobox_active_item_set(ETK_COMBOBOX(vwidget), item);
}
break;
case EVOLVE_PROPERTY_CHAR:
value = etk_string_new_printf("%c", evolve_property_value_char_get(p->default_value));
vwidget = etk_entry_new();
etk_entry_text_set(ETK_ENTRY(vwidget), etk_string_get(value));
etk_object_data_set_full(ETK_OBJECT(vwidget), "prop", p, NULL);
etk_signal_connect("text-changed", ETK_OBJECT(vwidget),
ETK_CALLBACK(evolve_gui_property_entry_text_changed_cb),
widget);
break;
case EVOLVE_PROPERTY_FLOAT:
value = etk_string_new_printf("%f", evolve_property_value_float_get(p->default_value));
vwidget = etk_spinner_new(0.0, 9999.0, evolve_property_value_float_get(p->default_value), 0.1, 1.0);
etk_spinner_digits_set(ETK_SPINNER(vwidget), 1);
etk_object_data_set_full(ETK_OBJECT(vwidget), "prop", p, NULL);
etk_object_data_set_full(ETK_OBJECT(vwidget), "widget", widget, NULL);
etk_signal_connect("value-changed", ETK_OBJECT(vwidget),
ETK_CALLBACK(evolve_gui_property_spinner_value_changed_cb),
NULL);
break;
case EVOLVE_PROPERTY_DOUBLE:
value = etk_string_new_printf("%g", evolve_property_value_double_get(p->default_value));
vwidget = etk_spinner_new(0.0, 9999.0, evolve_property_value_double_get(p->default_value), 0.1, 1.0);
etk_spinner_digits_set(ETK_SPINNER(vwidget), 1);
etk_object_data_set_full(ETK_OBJECT(vwidget), "prop", p, NULL);
etk_object_data_set_full(ETK_OBJECT(vwidget), "widget", widget, NULL);
etk_signal_connect("value-changed", ETK_OBJECT(vwidget),
ETK_CALLBACK(evolve_gui_property_spinner_value_changed_cb),
NULL);
break;
case EVOLVE_PROPERTY_SHORT:
value = etk_string_new_printf("%d", evolve_property_value_short_get(p->default_value));
vwidget = etk_spinner_new(0, 9999, evolve_property_value_short_get(p->default_value), 1, 10);
etk_object_data_set_full(ETK_OBJECT(vwidget), "prop", p, NULL);
etk_object_data_set_full(ETK_OBJECT(vwidget), "widget", widget, NULL);
etk_signal_connect("value-changed", ETK_OBJECT(vwidget),
ETK_CALLBACK(evolve_gui_property_spinner_value_changed_cb),
NULL);
break;
case EVOLVE_PROPERTY_LONG:
value = etk_string_new_printf("%li", evolve_property_value_long_get(p->default_value));
vwidget = etk_spinner_new(0, 9999, evolve_property_value_long_get(p->default_value), 1, 10);
etk_object_data_set_full(ETK_OBJECT(vwidget), "prop", p, NULL);
etk_object_data_set_full(ETK_OBJECT(vwidget), "widget", widget, NULL);
etk_signal_connect("value-changed", ETK_OBJECT(vwidget),
ETK_CALLBACK(evolve_gui_property_spinner_value_changed_cb),
NULL);
break;
case EVOLVE_PROPERTY_POINTER:
value = etk_string_new_printf("cant cast PROPERTY_POINTER");
vwidget = etk_entry_new();
etk_entry_text_set(ETK_ENTRY(vwidget), etk_string_get(value));
etk_widget_disabled_set(vwidget, ETK_TRUE);
break;
case EVOLVE_PROPERTY_STRING:
value = etk_string_new_printf("%s", evolve_property_value_string_get(p->default_value));
vwidget = etk_entry_new();
etk_entry_text_set(ETK_ENTRY(vwidget), etk_string_get(value));
etk_entry_text_set(ETK_ENTRY(vwidget), etk_string_get(value));
etk_object_data_set_full(ETK_OBJECT(vwidget), "prop", p, NULL);
etk_signal_connect("text-changed", ETK_OBJECT(vwidget),
ETK_CALLBACK(evolve_gui_property_entry_text_changed_cb),
widget);
break;
default:
value = etk_string_new_printf("cant determine value");
vwidget = etk_entry_new();
etk_entry_text_set(ETK_ENTRY(vwidget), etk_string_get(value));
break;
}
if (p == prop)
{
int type;
type = prop->type;
evolve_widget_property_set(widget, prop->name, etk_string_get(value), type);
eprop = evolve_widget_property_get(widget, prop->name);
}
etk_object_destroy(ETK_OBJECT(value));
etk_table_attach_default(ETK_TABLE(_evolve_gui_gen_table), label,
0, 0, i, i);
etk_table_attach_default(ETK_TABLE(_evolve_gui_gen_table), vwidget,
1, 1, i, i);
++i;
}
etk_widget_show_all(_evolve_gui_gen_table);
}
/* Adds a child to the table */
static void _etk_table_child_add(Etk_Container *container, Etk_Widget *widget)
{
etk_table_attach_default(ETK_TABLE(container), widget, 0, 0, 0, 0);
}
/* Resizes the table to the size allocation */
static void _etk_table_size_allocate(Etk_Widget *widget, Etk_Geometry geometry)
{
Etk_Table *table;
Etk_Container *container;
Etk_Widget *child;
Etk_Table_Cell *cell;
Etk_Size requested_inner_size;
Etk_Size allocated_inner_size;
Etk_Geometry child_geometry;
float offset, size;
Eina_List *l;
int i;
if (!(table = ETK_TABLE(widget)) || !table->cells)
return;
container = ETK_CONTAINER(table);
_etk_table_size_request(widget, &requested_inner_size);
requested_inner_size.w -= 2 * container->border_width;
requested_inner_size.h -= 2 * container->border_width;
allocated_inner_size.w = geometry.w - 2 * container->border_width;
allocated_inner_size.h = geometry.h - 2 * container->border_width;
/* We calculate the size of the cols */
offset = 0;
if (requested_inner_size.w >= allocated_inner_size.w)
{
float ratio;
ratio = (float)allocated_inner_size.w / requested_inner_size.w;
for (i = 0; i < table->num_cols; i++)
{
size = table->cols[i].requested_size * ratio;
table->cols[i].size = size;
table->cols[i].offset = offset;
offset += size;
}
}
else
{
int num_cols_to_expand = 0;
int free_space;
for (i = 0; i < table->num_cols; i++)
{
if (table->cols[i].expand)
num_cols_to_expand++;
}
free_space = allocated_inner_size.w - requested_inner_size.w;
for (i = 0; i < table->num_cols; i++)
{
if (table->cols[i].expand)
size = table->cols[i].requested_size + ((float)free_space / num_cols_to_expand);
else
size = table->cols[i].requested_size;
table->cols[i].size = size;
table->cols[i].offset = offset;
offset += size;
}
}
/* We calculate the size of the rows */
offset = 0;
if (requested_inner_size.h >= allocated_inner_size.h)
{
float ratio;
ratio = (float)allocated_inner_size.h / requested_inner_size.h;
for (i = 0; i < table->num_rows; i++)
{
size = table->rows[i].requested_size * ratio;
table->rows[i].size = size;
table->rows[i].offset = offset;
offset += size;
}
}
else
{
int num_rows_to_expand = 0;
int free_space;
for (i = 0; i < table->num_rows; i++)
{
if (table->rows[i].expand)
num_rows_to_expand++;
}
free_space = allocated_inner_size.h - requested_inner_size.h;
for (i = 0; i < table->num_rows; i++)
{
if (table->rows[i].expand)
size = table->rows[i].requested_size + ((float)free_space / num_rows_to_expand);
else
size = table->rows[i].requested_size;
table->rows[i].size = size;
table->rows[i].offset = offset;
offset += size;
}
}
/* We allocate the size for the children */
for (l = table->cells_list; l; l = l->next)
{
cell = l->data;
child = cell->child;
child_geometry.x = geometry.x + table->cols[cell->left_attach].offset + cell->x_padding;
child_geometry.y = geometry.y + table->rows[cell->top_attach].offset + cell->y_padding;
child_geometry.w = table->cols[cell->right_attach].offset - table->cols[cell->left_attach].offset +
table->cols[cell->right_attach].size - 2 * cell->x_padding;
child_geometry.h = table->rows[cell->bottom_attach].offset - table->rows[cell->top_attach].offset +
table->rows[cell->bottom_attach].size - 2 * cell->y_padding;
etk_container_child_space_fill(child, &child_geometry, cell->fill_policy & ETK_TABLE_HFILL,
cell->fill_policy & ETK_TABLE_VFILL, 0.5, 0.5);
etk_widget_size_allocate(child, child_geometry);
}
}
/* Calculates the ideal size of the table */
static void _etk_table_size_request(Etk_Widget *widget, Etk_Size *size_requisition)
{
Etk_Table *table;
Etk_Widget *child;
Etk_Table_Cell *cell;
Etk_Size child_size;
Etk_Bool hexpand = ETK_FALSE, vexpand = ETK_FALSE;
Eina_List *l;
int i;
if (!(table = ETK_TABLE(widget)) || !size_requisition)
return;
if (!table->cells)
{
size_requisition->w = 0;
size_requisition->h = 0;
}
else
{
/*********************************************
* Phase 1: We calculate the width of the cols of the table
*********************************************/
/* Horizontally-homogeneous table */
if (table->homogeneous & ETK_TABLE_HHOMOGENEOUS)
{
int max_col_width = CELL_MIN_SIZE;
int cell_size;
/* We calculate the maximum size of a cell */
for (l = table->cells_list; l; l = l->next)
{
cell = l->data;
child = cell->child;
etk_widget_size_request(child, &child_size);
cell_size = (2 * cell->x_padding + child_size.w) / (cell->right_attach - cell->left_attach + 1);
if (max_col_width < cell_size)
max_col_width = cell_size;
hexpand |= (cell->fill_policy & ETK_TABLE_HEXPAND);
}
for (i = 0; i < table->num_cols; i++)
{
table->cols[i].requested_size = max_col_width;
table->cols[i].expand = !!hexpand;
}
size_requisition->w = table->num_cols * max_col_width;
}
/* Non horizontally-homogeneous table */
else
{
for (i = 0; i < table->num_cols; i++)
{
table->cols[i].requested_size = CELL_MIN_SIZE;
table->cols[i].expand = ETK_FALSE;
}
/* We first treat the children that span only one column */
for (l = table->cells_list; l; l = l->next)
{
cell = l->data;
child = cell->child;
if (cell->left_attach == cell->right_attach)
{
etk_widget_size_request(child, &child_size);
if (table->cols[cell->left_attach].requested_size < child_size.w + 2 * cell->x_padding)
table->cols[cell->left_attach].requested_size = child_size.w + 2 * cell->x_padding;
table->cols[cell->left_attach].expand |= ((cell->fill_policy & ETK_TABLE_HEXPAND) != 0);
hexpand |= (cell->fill_policy & ETK_TABLE_HEXPAND);
}
}
/* Then, we treat the children that span several columns */
for (l = table->cells_list; l; l = l->next)
{
int cells_size;
int num_expandable_cells;
int free_space;
float delta;
cell = l->data;
child = cell->child;
if (cell->left_attach < cell->right_attach)
{
cells_size = 0;
num_expandable_cells = 0;
etk_widget_size_request(child, &child_size);
for (i = cell->left_attach; i <= cell->right_attach; i++)
{
cells_size += table->cols[i].requested_size;
if (!hexpand && (cell->fill_policy & ETK_TABLE_HEXPAND))
table->cols[i].expand = ETK_TRUE;
if (table->cols[i].expand)
num_expandable_cells++;
}
free_space = child_size.w - cells_size;
if (free_space > 0)
{
if (num_expandable_cells <= 0)
{
delta = (float)free_space / (cell->right_attach - cell->left_attach + 1);
for (i = cell->left_attach; i <= cell->right_attach; i++)
table->cols[i].requested_size += (int)(delta * (i + 1)) - (int)(delta * i);
}
else
{
delta = (float)free_space / num_expandable_cells;
for (i = cell->left_attach; i <= cell->right_attach; i++)
{
if (table->cols[i].expand)
table->cols[i].requested_size += (int)(delta * (i + 1)) - (int)(delta * i);
}
}
}
}
}
size_requisition->w = 0;
for (i = 0; i < table->num_cols; i++)
size_requisition->w += table->cols[i].requested_size;
}
/*********************************************
* Phase 2: We calculate the height of the rows of the table
*********************************************/
/* Vertically-homogeneous table */
if (table->homogeneous & ETK_TABLE_VHOMOGENEOUS)
{
int max_row_height = CELL_MIN_SIZE;
int cell_size;
/* We calculate the maximum size of a cell */
for (l = table->cells_list; l; l = l->next)
{
cell = l->data;
child = cell->child;
etk_widget_size_request(child, &child_size);
cell_size = (2 * cell->y_padding + child_size.h) / (cell->bottom_attach - cell->top_attach + 1);
if (max_row_height < cell_size)
max_row_height = cell_size;
vexpand |= (cell->fill_policy & ETK_TABLE_VEXPAND);
}
for (i = 0; i < table->num_rows; i++)
{
table->rows[i].requested_size = max_row_height;
table->rows[i].expand = !!vexpand;
}
size_requisition->h = table->num_rows * max_row_height;
}
/* Non vertically-homogeneous table */
else
{
for (i = 0; i < table->num_rows; i++)
{
table->rows[i].requested_size = CELL_MIN_SIZE;
table->rows[i].expand = ETK_FALSE;
}
/* We first treat the children that span only one row */
for (l = table->cells_list; l; l = l->next)
{
cell = l->data;
child = cell->child;
if (cell->top_attach == cell->bottom_attach)
{
etk_widget_size_request(child, &child_size);
if (table->rows[cell->top_attach].requested_size < child_size.h + 2 * cell->y_padding)
table->rows[cell->top_attach].requested_size = child_size.h + 2 * cell->y_padding;
table->rows[cell->top_attach].expand |= ((cell->fill_policy & ETK_TABLE_VEXPAND) != 0);
vexpand |= (cell->fill_policy & ETK_TABLE_VEXPAND);
}
}
/* Then, we treat the children that span several rows */
for (l = table->cells_list; l; l = l->next)
{
int cells_size;
int num_expandable_cells;
int free_space;
float delta;
cell = l->data;
child = cell->child;
if (cell->top_attach < cell->bottom_attach)
{
cells_size = 0;
num_expandable_cells = 0;
etk_widget_size_request(child, &child_size);
for (i = cell->top_attach; i <= cell->bottom_attach; i++)
{
cells_size += table->rows[i].requested_size;
if (!vexpand && (cell->fill_policy & ETK_TABLE_VEXPAND))
table->rows[i].expand = ETK_TRUE;
if (table->rows[i].expand)
num_expandable_cells++;
}
free_space = child_size.h - cells_size;
if (free_space > 0)
{
if (num_expandable_cells <= 0)
{
delta = (float)free_space / (cell->bottom_attach - cell->top_attach + 1);
for (i = cell->top_attach; i <= cell->bottom_attach; i++)
table->rows[i].requested_size += (int)(delta * (i + 1)) - (int)(delta * i);
}
else
{
delta = (float)free_space / num_expandable_cells;
for (i = cell->top_attach; i <= cell->bottom_attach; i++)
{
if (table->rows[i].expand)
table->rows[i].requested_size += (int)(delta * (i + 1)) - (int)(delta * i);
}
}
}
}
}
size_requisition->h = 0;
for (i = 0; i < table->num_rows; i++)
size_requisition->h += table->rows[i].requested_size;
}
}
size_requisition->w += 2 * ETK_CONTAINER(table)->border_width;
size_requisition->h += 2 * ETK_CONTAINER(table)->border_width;
}