/* TODO : documentation */
void
emphasis_player_cover_size_update(Emphasis_Player_Gui *player)
{
etk_widget_size_request_set(player->small.cover,
player->small.cover_size_w,
player->small.cover_size_h);
etk_widget_size_request_set(player->full.cover,
player->full.cover_size_w,
player->full.cover_size_h);
}
/* 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_current_zoom_one_to_one(Exhibit *e)
{
if (e->cur_tab->fit_window)
{
if (e->cur_tab->comment.visible)
{
etk_notebook_page_child_set(ETK_NOTEBOOK(e->notebook), e->cur_tab->num, e->cur_tab->comment.vbox);
etk_container_remove(e->cur_tab->alignment);
etk_container_remove(e->cur_tab->comment.frame);
etk_box_append(ETK_BOX(e->cur_tab->comment.vbox), e->cur_tab->scrolled_view, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
etk_box_append(ETK_BOX(e->cur_tab->comment.vbox), e->cur_tab->comment.frame, ETK_BOX_START, ETK_BOX_NONE, 3);
}
else
etk_notebook_page_child_set(ETK_NOTEBOOK(e->notebook), e->cur_tab->num, e->cur_tab->scrolled_view);
etk_widget_size_request_set(e->cur_tab->alignment, -1, -1);
etk_scrolled_view_add_with_viewport(ETK_SCROLLED_VIEW(e->cur_tab->scrolled_view), e->cur_tab->alignment);
e->cur_tab->fit_window = ETK_FALSE;
}
e->zoom = 0;
e->brightness = 128;
e->contrast = 0;
_ex_image_zoom(ETK_IMAGE(e->cur_tab->image), e->zoom);
_ex_main_statusbar_zoom_update(e);
}
boot_panel* bootpanel_create(main_window *win)
{
boot_panel* pnl;
Etk_Widget *scroll,*vbox, *hbox,*text,*frame;
pnl = malloc(sizeof(boot_panel));
pnl->win = win;
vbox = etk_vbox_new(ETK_FALSE, 5);
hbox = etk_hbox_new(ETK_FALSE, 5);
pnl->frame = hbox;
etk_box_append(ETK_BOX(hbox), vbox, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
scroll = etk_scrolled_view_new ();
etk_box_append(ETK_BOX(vbox), scroll, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
etk_widget_show(scroll);
pnl->eth_list = etk_tree_new();
pnl->eth_col0 = etk_tree_col_new(ETK_TREE(pnl->eth_list), _("Interfaces"), 80, 0.0);
etk_tree_col_model_add(pnl->eth_col0, etk_tree_model_checkbox_new());
etk_tree_col_model_add(pnl->eth_col0, etk_tree_model_text_new());
etk_signal_connect_by_code(ETK_TREE_COL_CELL_VALUE_CHANGED_SIGNAL,
ETK_OBJECT(pnl->eth_col0),
ETK_CALLBACK(bootpanel_ethlist_checkbox_change_cb), pnl);
etk_tree_mode_set(ETK_TREE(pnl->eth_list), ETK_TREE_MODE_LIST);
etk_tree_build(ETK_TREE(pnl->eth_list));
etk_container_add(ETK_CONTAINER(scroll), pnl->eth_list);
text = etk_text_view_new();
etk_widget_size_request_set(text, -1, 150);
etk_object_properties_set(ETK_OBJECT(text), "focusable", ETK_FALSE, NULL);
etk_textblock_text_set(ETK_TEXT_VIEW(text)->textblock,
_("<p align=\"center\"><style effect=glow color1=#fa14 color2=#fe87><b>Help!</b></style>"
"\n<p>When your computer boot, exalt starts and configure yours networks interfaces in the background. If you use the DHCP, your interface will get a IP address after a while.</p>"
"\n<p>You can have a problem if you use a daemon as nfs-client. If the daemon need a network connection when it starts and your interface has no IP address, the daemon will not work. To avoid this problem Exalt can configure your interface in the foreground. If you select the interface in the list, Exalt will wait until your interface gets a IP address.</p>"
"\n<p>If the interface doesn't get a IP address before the timeout, your computer will continue the boot process.</p>"
),
ETK_TRUE);
etk_box_append(ETK_BOX(hbox), text, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
frame=etk_frame_new(_("Timeout"));
etk_box_append(ETK_BOX(vbox), frame, ETK_BOX_START, ETK_BOX_FILL, 0);
hbox = etk_hbox_new(ETK_FALSE, 5);
etk_container_add(ETK_CONTAINER(frame), hbox);
pnl->slider = etk_hslider_new(1,60,30,1,5);
etk_box_append(ETK_BOX(hbox), pnl->slider, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
etk_slider_label_set(ETK_SLIDER(pnl->slider), "%.0f");
etk_signal_connect_by_code(ETK_RANGE_VALUE_CHANGED_SIGNAL, ETK_OBJECT(pnl->slider), ETK_CALLBACK(bootpanel_slider_value_changed_cb), pnl);
etk_slider_update_policy_set(ETK_SLIDER(pnl->slider), ETK_SLIDER_DELAYED);
bootpanel_update_timeout(pnl);
return pnl;
}
void etk_file_cache_dialog_create()
{
Etk_Widget* window = NULL;
Etk_Widget* tree = NULL;
Etk_Tree_Col* tree_col;
Etk_Widget* button;
Etk_Widget* vbox;
if (_etk_file_cache_dialog_running)
return;
_etk_file_cache_dialog_running = 1;
window = etk_window_new();
etk_window_title_set(ETK_WINDOW(window), "File Cache");
etk_window_wmclass_set(ETK_WINDOW(window), "entropyfilecache", "entropyfilecache");
etk_widget_size_request_set(ETK_WIDGET(window), 450, 500);
vbox = etk_vbox_new(ETK_FALSE,0);
etk_container_add(ETK_CONTAINER(window), vbox);
tree = etk_tree_new();
etk_box_append(ETK_BOX(vbox), tree, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
etk_tree_mode_set(ETK_TREE(tree), ETK_TREE_MODE_LIST);
tree_col = etk_tree_col_new(ETK_TREE(tree), _("Listeners"), 125,0.0);
etk_tree_col_model_add(tree_col, etk_tree_model_text_new());
// Not yet implemented in Tree2
//etk_tree_col_sort_func_set(tree_col, _entropy_etk_file_cache_dialog_listener_compare_cb, NULL);
tree_col = etk_tree_col_new(ETK_TREE(tree), _("Filename"), 150, 0.0);
etk_tree_col_model_add(tree_col, etk_tree_model_text_new());
etk_tree_col_expand_set(tree_col, ETK_TRUE);
etk_tree_build(ETK_TREE(tree));
etk_file_cache_dialog_refresh(tree);
button = etk_button_new_with_label("Refresh");
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(_etk_file_cache_dialog_refresh_cb), tree);
etk_box_append(ETK_BOX(vbox), button, ETK_BOX_END, ETK_BOX_NONE, 0);
etk_signal_connect ("delete_event", ETK_OBJECT (window),
ETK_CALLBACK (_etk_file_cache_debug_dialog_delete_cb), window);
etk_widget_show_all(window);
}
/*** Implementation ***/
Etk_Widget*
tree_create(void)
{
//UI_GroupsComboBox
UI_GroupsComboBox = etk_combobox_entry_new_default();
etk_combobox_entry_items_height_set(ETK_COMBOBOX_ENTRY(UI_GroupsComboBox), 18);
etk_combobox_entry_autosearch_set(ETK_COMBOBOX_ENTRY(UI_GroupsComboBox), GROUP_COMBO_AUTOSEARCH_COL, strcasestr);
etk_signal_connect("active-item-changed", ETK_OBJECT(UI_GroupsComboBox),
ETK_CALLBACK(_tree_combobox_active_item_changed_cb), NULL);
//UI_PartsTree
Etk_Tree_Col *col;
UI_PartsTree = etk_tree_new();
etk_widget_padding_set(UI_PartsTree,2,2,2,2);
etk_tree_mode_set(ETK_TREE(UI_PartsTree), ETK_TREE_MODE_TREE);
etk_tree_headers_visible_set(ETK_TREE(UI_PartsTree), ETK_FALSE);
etk_widget_size_request_set(UI_PartsTree, 260, 300);
//Main column
col = etk_tree_col_new(ETK_TREE(UI_PartsTree), "File contents",100,0);
etk_tree_col_model_add(col,etk_tree_model_image_new());
etk_tree_col_model_add(col,etk_tree_model_text_new());
etk_tree_col_resizable_set(col, ETK_FALSE);
etk_tree_col_expand_set(col,ETK_TRUE);
//Visibility column
col = etk_tree_col_new(ETK_TREE(UI_PartsTree), "vis", 10,0);
etk_tree_col_visible_set(col, DEBUG_MODE);
etk_tree_col_model_add(col,etk_tree_model_checkbox_new());
etk_tree_col_resizable_set(col, ETK_FALSE);
etk_tree_col_expand_set(col,ETK_FALSE);
//RowType column
col = etk_tree_col_new(ETK_TREE(UI_PartsTree), "type",10, 0);
etk_tree_col_model_add(col,etk_tree_model_int_new());
etk_tree_col_visible_set(col, DEBUG_MODE);
etk_tree_col_resizable_set(col, ETK_FALSE);
etk_tree_col_expand_set(col,ETK_FALSE);
//Parent part row
col = etk_tree_col_new(ETK_TREE(UI_PartsTree), "parent",100, 0);
etk_tree_col_model_add(col,etk_tree_model_text_new());
etk_tree_col_visible_set(col, DEBUG_MODE);
etk_tree_col_resizable_set(col, ETK_FALSE);
etk_tree_col_expand_set(col,ETK_FALSE);
etk_tree_build(ETK_TREE(UI_PartsTree));
etk_signal_connect("row-selected", ETK_OBJECT(UI_PartsTree),
ETK_CALLBACK(_tree_row_selected_cb), NULL);
etk_signal_connect("row-clicked", ETK_OBJECT(UI_PartsTree),
ETK_CALLBACK(_tree_click_cb), NULL);
//vbox
Etk_Widget *vbox;
vbox = etk_vbox_new(ETK_FALSE, 0);
etk_box_append(ETK_BOX(vbox), UI_GroupsComboBox, ETK_BOX_START, ETK_BOX_NONE, 0);
etk_box_append(ETK_BOX(vbox), UI_PartsTree, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
return vbox;
}
main_window* mainwindow_create()
{/*{{{*/
Etk_Widget *hbox,*scroll;
main_window* win;
win=(main_window*)malloc((unsigned int)sizeof(main_window));
win->win = etk_window_new();
etk_window_title_set(ETK_WINDOW(win->win), _("Exalt: network manager"));
etk_window_wmclass_set(ETK_WINDOW(win->win),"Exalt_network_manager","Exalt_network_manager");
etk_window_resize(ETK_WINDOW(win->win), 623,268);
etk_signal_connect("delete-event", ETK_OBJECT(win->win), ETK_CALLBACK( mainWindow_close), win);
hbox = etk_hbox_new(ETK_FALSE, 5);
etk_container_add(ETK_CONTAINER(win->win), hbox);
scroll = etk_scrolled_view_new ();
etk_box_append(ETK_BOX(hbox), scroll, ETK_BOX_START, ETK_BOX_FILL, 0);
etk_widget_show(scroll);
win->eth_list = etk_tree_new();
etk_widget_size_request_set(win->eth_list, 120, 50);
win->eth_col0 = etk_tree_col_new(ETK_TREE(win->eth_list), _("Interfaces"), 80, 0.0);
etk_tree_col_model_add(win->eth_col0, etk_tree_model_image_new());
etk_tree_col_model_add(win->eth_col0, etk_tree_model_text_new());
etk_tree_rows_height_set(ETK_TREE(win->eth_list),40);
etk_tree_mode_set(ETK_TREE(win->eth_list), ETK_TREE_MODE_LIST);
etk_tree_build(ETK_TREE(win->eth_list));
etk_container_add(ETK_CONTAINER(scroll), win->eth_list);
etk_signal_connect("row-clicked", ETK_OBJECT(win->eth_list),ETK_CALLBACK(mainWindow_ethList_row_clicked_cb), win);
//add the general panel in the list
etk_tree_row_append(ETK_TREE(win->eth_list), NULL,
win->eth_col0,PACKAGE_DATA_DIR ICONS_NETWORK_CONFIG,NULL,_("General") , NULL);
//attach the add callback function to exalt
exalt_eth_set_cb(mainWindow_eth_cb, win);
etk_widget_show_all(win->win);
win->eth_panel = ethpanel_create(win);
etk_box_append(ETK_BOX(hbox),win->eth_panel->frame , ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
win->wireless_panel = wirelesspanel_create(win);
etk_box_append(ETK_BOX(hbox),win->wireless_panel->frame , ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
win->general_panel = generalpanel_create();
etk_box_append(ETK_BOX(hbox),win->general_panel->frame , ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//launch the timer to update the network state
//win->eth_state_timer = ecore_timer_add(MAINWINDOW_ETH_STATE_TIME_MAX ,mainWindow_eth_state_timer,win);
return win;
}/*}}}*/
void
_ex_tab_current_fit_to_window(Exhibit *e)
{
etk_widget_size_request_set(e->cur_tab->alignment, 10, 10);
if (e->cur_tab->comment.visible)
{
etk_notebook_page_child_set(ETK_NOTEBOOK(e->notebook), e->cur_tab->num, e->cur_tab->comment.vbox);
etk_container_remove(e->cur_tab->scrolled_view);
etk_container_remove(e->cur_tab->comment.frame);
etk_box_append(ETK_BOX(e->cur_tab->comment.vbox), e->cur_tab->alignment, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
etk_box_append(ETK_BOX(e->cur_tab->comment.vbox), e->cur_tab->comment.frame, ETK_BOX_START, ETK_BOX_NONE, 3);
}
else
etk_notebook_page_child_set(ETK_NOTEBOOK(e->notebook), e->cur_tab->num, e->cur_tab->alignment);
etk_widget_size_request_set(e->cur_tab->image, -1, -1);
e->cur_tab->fit_window = ETK_TRUE;
_ex_main_statusbar_zoom_update(e);
}
static Etk_Widget *_etk_prefs_other_tab_create()
{
Eina_List *engines;
Eina_List *l;
char *engine;
Etk_Widget *engine_list;
Etk_Widget *frame;
Etk_Widget *vbox;
Etk_Tree_Col *col1;
Etk_Tree_Row *row;
/* main vbox */
vbox = etk_vbox_new(ETK_FALSE, 0);
/* tree to hold the engines list */
engine_list = etk_tree_new();
etk_widget_size_request_set(engine_list, 180, 240);
etk_tree_mode_set(ETK_TREE(engine_list), ETK_TREE_MODE_LIST);
etk_tree_multiple_select_set(ETK_TREE(engine_list), ETK_FALSE);
etk_tree_rows_height_set(ETK_TREE(engine_list), 45);
etk_tree_headers_visible_set(ETK_TREE(engine_list), ETK_FALSE);
etk_signal_connect("row-selected", ETK_OBJECT(engine_list), ETK_CALLBACK(_etk_prefs_engine_row_selected_cb), NULL);
col1 = etk_tree_col_new(ETK_TREE(engine_list), "Engines", 150, 0.0);
etk_tree_col_model_add(col1, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(engine_list));
/* scan for engines and add them to the list */
engines = etk_engine_list_get();
for(l = engines; l; l = l->next)
{
const char *engine_current = etk_config_engine_get();
engine = l->data;
row = etk_tree_row_append(ETK_TREE(engine_list), NULL, col1, engine, NULL);
if (engine_current)
if (!strcmp(engine, engine_current))
etk_tree_row_select(row);
}
/* pack tree */
etk_box_append(ETK_BOX(vbox), engine_list, ETK_BOX_START, ETK_BOX_NONE, 0);
etk_container_border_width_set(ETK_CONTAINER(vbox), 5);
frame = etk_frame_new(_("Engines"));
etk_container_add(ETK_CONTAINER(frame), vbox);
return frame;
}
Entrance_Widget
ew_image_new(int w, int h)
{
Entrance_Widget ew = ew_new();
if(ew)
{
ew->owner = etk_image_new();
ew->box = NULL;
etk_widget_size_request_set(ETK_WIDGET(ew->owner), w, h);
}
return ew;
}
ELAPI void *
el_about(void)
{
Etk_Widget *win, *vbox, *hbox;
Etk_Widget *button, *label;
Etk_Widget *about;
Etk_Textblock *msg;
Etk_Textblock_Iter *iter;
char buf[4096];
win = etk_dialog_new();
etk_window_title_set(ETK_WINDOW(win), "About "PACKAGE_NAME);
etk_window_wmclass_set(ETK_WINDOW(win), PACKAGE"_About", PACKAGE_NAME"_About");
etk_container_border_width_set(ETK_CONTAINER(win), 3);
etk_signal_connect("delete_event", ETK_OBJECT(win), ETK_CALLBACK(_close_cb), NULL);
vbox = etk_vbox_new(ETK_FALSE, 0);
etk_container_add(ETK_CONTAINER(win), vbox);
label = etk_label_new("<h1>"PACKAGE_NAME"</h1>");
etk_label_alignment_set(ETK_LABEL(label), 0.5, 0.5);
etk_box_append(ETK_BOX(vbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
snprintf(buf, sizeof(buf),
"<b>%s is an Etk-based IRC client in development</b>\n\n"
"Christopher 'devilhorns' Michael\n\n%s\n",
PACKAGE_NAME, PACKAGE_BUGREPORT);
about = etk_text_view_new();
etk_widget_size_request_set(about, 250, 150);
etk_box_append(ETK_BOX(vbox), about, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
msg = etk_text_view_textblock_get(ETK_TEXT_VIEW(about));
etk_textblock_object_cursor_visible_set(ETK_TEXT_VIEW(about)->textblock_object, ETK_FALSE);
iter = etk_textblock_iter_new(msg);
etk_textblock_iter_forward_end(iter);
etk_textblock_insert_markup(msg, iter, buf, -1);
etk_box_append(ETK_BOX(vbox), etk_hseparator_new(), ETK_BOX_END, ETK_BOX_FILL, 5);
hbox = etk_hbox_new(ETK_FALSE, 3);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_END, ETK_BOX_NONE, 0);
button = etk_button_new_from_stock(ETK_STOCK_DIALOG_CLOSE);
etk_signal_connect_swapped("clicked", ETK_OBJECT(button), ETK_CALLBACK(_close_cb), win);
etk_box_append(ETK_BOX(hbox), button, ETK_BOX_END, ETK_BOX_NONE, 0);
return win;
}
void etk_directory_add_dialog_create(entropy_generic_file* parent)
{
Etk_Widget* vbox;
Etk_Widget* hbox;
Etk_Widget* label;
Etk_Widget* button;
etk_directory_add_dialog* dialog = calloc(1, sizeof(etk_directory_add_dialog));
dialog->parent = parent;
dialog->window = etk_window_new();
etk_window_title_set(ETK_WINDOW(dialog->window), "Create Directory..");
etk_window_wmclass_set(ETK_WINDOW(dialog->window), "dirdialog", "dirdialog");
etk_widget_size_request_set(ETK_WIDGET(dialog->window), 250, 80);
vbox =etk_vbox_new(ETK_FALSE,0);
etk_container_add(ETK_CONTAINER(dialog->window), vbox);
hbox = etk_hbox_new(ETK_FALSE,0);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_NONE, 0);
label = etk_label_new("Directory Name");
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
dialog->entry = etk_entry_new();
etk_box_append(ETK_BOX(hbox), dialog->entry, ETK_BOX_START, ETK_BOX_NONE, 0);
hbox = etk_hbox_new(ETK_FALSE,0);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_NONE, 0);
button = etk_button_new_with_label("Create");
etk_box_append(ETK_BOX(hbox), button, ETK_BOX_START, ETK_BOX_NONE, 0);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_directory_add_dialog_create_cb), dialog);
button = etk_button_new_with_label("Cancel");
etk_box_append(ETK_BOX(hbox), button, ETK_BOX_START, ETK_BOX_NONE, 0);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_directory_add_dialog_cancel_cb), dialog);
etk_widget_show_all(dialog->window);
}
/* Creates the window for the canvas test */
void etk_test_canvas_window_create(void *data)
{
Etk_Widget *vbox;
Etk_Widget *button;
int i;
if (win)
{
etk_widget_show_all(ETK_WIDGET(win));
return;
}
win = etk_window_new();
etk_window_title_set(ETK_WINDOW(win), "Etk Canvas 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);
vbox = etk_vbox_new(ETK_FALSE, 5);
etk_container_add(ETK_CONTAINER(win), vbox);
canvas = etk_canvas_new();
etk_widget_size_request_set(canvas, 500, 350);
etk_box_append(ETK_BOX(vbox), canvas, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
button = etk_button_new_from_stock(ETK_STOCK_LIST_ADD);
etk_button_label_set(ETK_BUTTON(button), "Add object");
etk_signal_connect_swapped_by_code(ETK_BUTTON_CLICKED_SIGNAL, ETK_OBJECT(button), ETK_CALLBACK(_etk_test_canvas_object_add), canvas);
etk_box_append(ETK_BOX(vbox), button, ETK_BOX_START, ETK_BOX_NONE, 0);
/* add some progess bars to the canvas */
for (i = 0; i < 3; i++)
{
_etk_test_canvas_progress_bars_create(50 + 50 * i, 50 + 50 * i);
}
etk_widget_show_all(win);
}
/* theme page */
static Etk_Widget *_etk_prefs_theme_tab_create()
{
Eina_List *themes;
Eina_List *l;
char *theme;
Etk_Widget *preview;
Etk_Widget *theme_list;
Etk_Widget *preview_hbox;
Etk_Widget *frame;
Etk_Widget *vbox;
Etk_Tree_Col *col1;
Etk_Tree_Row *row;
/* main vbox */
vbox = etk_vbox_new(ETK_FALSE, 0);
/* hbox to hold tree and preview */
preview_hbox = etk_hbox_new(ETK_FALSE, 5);
etk_box_append(ETK_BOX(vbox), preview_hbox, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
/* the preview */
preview = etk_frame_new(_("Preview"));
/* tree to hold the theme list */
theme_list = etk_tree_new();
etk_widget_size_request_set(theme_list, 180, 240);
etk_tree_mode_set(ETK_TREE(theme_list), ETK_TREE_MODE_LIST);
etk_tree_multiple_select_set(ETK_TREE(theme_list), ETK_FALSE);
etk_tree_rows_height_set(ETK_TREE(theme_list), 45);
etk_tree_headers_visible_set(ETK_TREE(theme_list), ETK_FALSE);
etk_signal_connect("row-selected", ETK_OBJECT(theme_list), ETK_CALLBACK(_etk_prefs_theme_row_selected_cb), preview);
col1 = etk_tree_col_new(ETK_TREE(theme_list), "Themes", 150, 0.0);
etk_tree_col_model_add(col1, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(theme_list));
/* scan for themes and add them to the list */
themes = etk_theme_widget_available_themes_get();
for(l = themes; l; l = l->next)
{
const char *widget_theme = etk_config_widget_theme_get();
theme = l->data;
row = etk_tree_row_append(ETK_TREE(theme_list), NULL, col1, theme, NULL);
if (widget_theme)
if (!strcmp(theme, widget_theme))
etk_tree_row_select(row);
}
/* pack tree + preview widget */
etk_box_append(ETK_BOX(preview_hbox), theme_list, ETK_BOX_START, ETK_BOX_NONE, 0);
etk_box_append(ETK_BOX(preview_hbox), preview, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
etk_container_border_width_set(ETK_CONTAINER(vbox), 5);
/* add frame */
frame = etk_frame_new(_("Themes"));
etk_container_add(ETK_CONTAINER(frame), vbox);
return frame;
}
entropy_gui_component_instance *
entropy_plugin_layout_create (entropy_core * core)
{
Etk_Widget *window;
entropy_layout_gui *gui;
entropy_gui_component_instance *layout;
void *(*local_plugin_init) (entropy_core * core,
entropy_gui_component_instance *,
void *data);
entropy_plugin *local;
entropy_plugin *meta;
entropy_plugin *hover;
entropy_plugin *trackback;
entropy_gui_component_instance* meta_instance;
entropy_gui_component_instance* hover_instance;
Etk_Tree_Col* col;
Etk_Widget* vbox;
Etk_Widget* menubar;
Etk_Widget* menu_item;
Etk_Widget* menu;
Eina_List* structures;
Entropy_Config_Structure* structure;
int local_viewer_selected = 0;
/*Entropy related init */
layout = (entropy_gui_component_instance*)entropy_gui_component_instance_layout_new(); /*Create a component instance */
gui = entropy_malloc (sizeof (entropy_layout_gui));
layout->data = gui;
layout->core = core;
gui->progress_hash = ecore_hash_new(ecore_direct_hash, ecore_direct_compare);
gui->properties_request_hash = ecore_hash_new(ecore_direct_hash, ecore_direct_compare);
/*Global init for all layouts*/
if (!_etk_layout_global_init) {
/*Request metadata groups from evfs*/
entropy_plugin_filesystem_metadata_groups_get(layout);
_etk_layout_row_reference = ecore_hash_new(ecore_direct_hash, ecore_direct_compare);
_etk_layout_structure_plugin_reference = ecore_hash_new(ecore_direct_hash, ecore_direct_compare);
_etk_layout_global_init = 1;
}
/*Register this layout container with the core, so our children can get events */
entropy_core_layout_register (core, layout);
/*Register this instance (the layout itself), to receive events that can be safely handled
* by the layout (and reduce the clutter in the child plugins)
* i.e. PROGRESS events, Stat for properties, Overwrite yes/no/etc events, etc*/
/*Handle progress events*/
entropy_core_component_event_register (layout,
entropy_core_gui_event_get
(ENTROPY_GUI_EVENT_FILE_PROGRESS));
/*We want to know if the backend needs feedback */
entropy_core_component_event_register (layout,
entropy_core_gui_event_get
(ENTROPY_GUI_EVENT_USER_INTERACTION_YES_NO_ABORT));
/*We want to know if a stat is an 'extended stat' - e.g. a properties dialog etc */
entropy_core_component_event_register (layout,
entropy_core_gui_event_get
(ENTROPY_GUI_EVENT_EXTENDED_STAT));
entropy_core_component_event_register (layout,
entropy_core_gui_event_get
(ENTROPY_GUI_EVENT_FILE_STAT));
entropy_core_component_event_register (layout,
entropy_core_gui_event_get
(ENTROPY_GUI_EVENT_FILE_STAT_AVAILABLE));
entropy_core_component_event_register (layout,
entropy_core_gui_event_get
(ENTROPY_GUI_EVENT_METADATA_GROUPS));
entropy_core_component_event_register (layout,
entropy_core_gui_event_get
(ENTROPY_GUI_EVENT_PASTE_REQUEST));
entropy_core_component_event_register (layout,
entropy_core_gui_event_get
(ENTROPY_GUI_EVENT_AUTH_REQUEST));
entropy_core_component_event_register (layout,
entropy_core_gui_event_get
(ENTROPY_GUI_EVENT_META_ALL_REQUEST));
/*Etk related init */
window = etk_window_new ();
layout->gui_object = window;
etk_signal_connect("key-down", ETK_OBJECT(window), ETK_CALLBACK(_entropy_etk_layout_key_down_cb), layout);
gui->paned = etk_hpaned_new();
etk_signal_connect ("delete-event", ETK_OBJECT (window),
ETK_CALLBACK (_etk_window_deleted_cb), layout);
etk_window_title_set(ETK_WINDOW(window), "Entropy");
etk_window_wmclass_set(ETK_WINDOW(window), "entropy", "Entropy");
vbox = etk_vbox_new(ETK_FALSE,0);
etk_container_add(ETK_CONTAINER(window), vbox);
/*Tree init*/
gui->tree = etk_tree_new();
gui->tree_shell = etk_vbox_new(ETK_FALSE,0);
etk_box_append(ETK_BOX(gui->tree_shell), gui->tree, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
etk_paned_child1_set(ETK_PANED(gui->paned), gui->tree_shell, ETK_FALSE);
etk_tree_mode_set(ETK_TREE(gui->tree), ETK_TREE_MODE_TREE);
col = etk_tree_col_new(ETK_TREE(gui->tree), _("Folders"), 60,0.0);
etk_tree_col_model_add(col, etk_tree_model_image_new());
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_col_expand_set(col, ETK_TRUE);
etk_tree_build(ETK_TREE(gui->tree));
etk_widget_size_request_set(ETK_WIDGET(gui->tree), ENTROPY_ETK_WINDOW_PANE_DEFAULT_X, 50);
/*Register to receive events related to the treeview config*/
entropy_config_misc_callback_register("general.treeviewer", _entropy_layout_etk_simple_config_cb, gui);
/*If we're configured not to show tree on start, don't show*/
if (!entropy_config_misc_is_set("general.treeviewer")) {
entropy_etk_layout_tree_show(gui,0);
} else {
etk_paned_position_set(ETK_PANED(gui->paned), ENTROPY_ETK_WINDOW_PANE_DEFAULT_X);
}
/*LocalShell Init*/
gui->localshell = etk_vbox_new(ETK_TRUE,0);
etk_paned_child2_set(ETK_PANED(gui->paned), gui->localshell, ETK_TRUE);
/*Trackback container init*/
gui->trackback_shell = etk_vbox_new(ETK_TRUE,0);
/*Popup init*/
gui->popup = etk_menu_new();
etk_signal_connect("row-clicked", ETK_OBJECT( gui->tree ),
ETK_CALLBACK(_etk_layout_row_clicked), layout);
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Delete this location"),
ETK_STOCK_DOCUMENT_OPEN, ETK_MENU_SHELL(gui->popup),NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(_etk_layout_location_delete_confirm_cb), layout);
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Add a new location"),
ETK_STOCK_DOCUMENT_OPEN, ETK_MENU_SHELL(gui->popup),NULL);
for (structures = entropy_config_standard_structures_parse (layout, NULL); structures; ) {
structure = structures->data;
layout_etk_simple_add_header (layout,structure);
structures = structures->next;
}
/*Initialise the list view*/
local = entropy_plugin_gui_get_by_name_toolkit(ENTROPY_TOOLKIT_ETK, "listviewer");
if (local) {
local_plugin_init =
dlsym (local->dl_ref, "entropy_plugin_gui_instance_new");
gui->list_viewer = (*local_plugin_init)(core, layout,NULL);
gui->list_viewer->plugin = local;
if (entropy_config_misc_is_set("general.listviewer")) {
gui->list_viewer->active=1;
local_viewer_selected = 1;
etk_widget_show(gui->list_viewer->gui_object);
etk_box_append(ETK_BOX(gui->localshell), gui->list_viewer->gui_object, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
} else {
gui->list_viewer->active=0;
etk_widget_show(gui->list_viewer->gui_object);
}
}
/*Initialise the icon viewer*/
/*Initialise the list view*/
local = entropy_plugin_gui_get_by_name_toolkit(ENTROPY_TOOLKIT_ETK, "iconviewer");
if (local) {
local_plugin_init =
dlsym (local->dl_ref, "entropy_plugin_gui_instance_new");
gui->iconbox_viewer = (*local_plugin_init)(core, layout,NULL);
gui->iconbox_viewer->plugin = local;
if (entropy_config_misc_is_set("general.iconviewer")) {
gui->iconbox_viewer->active=1;
local_viewer_selected = 1;
etk_widget_show(gui->iconbox_viewer->gui_object);
etk_box_append(ETK_BOX(gui->localshell), gui->iconbox_viewer->gui_object, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
} else {
gui->iconbox_viewer->active=0;
etk_widget_show(gui->iconbox_viewer->gui_object);
}
}
/*Initialise the metadata plugin*/
meta = entropy_plugins_type_get_first(ENTROPY_PLUGIN_GUI_COMPONENT, ENTROPY_PLUGIN_GUI_COMPONENT_INFO_PROVIDER);
if (meta) {
local_plugin_init =
dlsym(meta->dl_ref, "entropy_plugin_gui_instance_new");
meta_instance = (*local_plugin_init)(core,layout,NULL);
meta_instance->plugin = meta;
}
/*Initialise the hover viewer*/
hover = entropy_plugins_type_get_first(ENTROPY_PLUGIN_GUI_COMPONENT, ENTROPY_PLUGIN_GUI_COMPONENT_HOVER_PROVIDER);
if (hover) {
local_plugin_init =
dlsym(hover->dl_ref, "entropy_plugin_gui_instance_new");
hover_instance = (*local_plugin_init)(core,layout,NULL);
hover_instance->plugin = hover;
}
/*Initialise the trackback*/
trackback = entropy_plugin_gui_get_by_name_toolkit(ENTROPY_TOOLKIT_ETK, "trackback");
if (trackback) {
local_plugin_init =
dlsym (trackback->dl_ref, "entropy_plugin_gui_instance_new");
gui->trackback = (*local_plugin_init)(core, layout,NULL);
gui->trackback->plugin = trackback;
gui->trackback->active=1;
if (entropy_config_misc_is_set("general.trackback")) {
etk_box_append(ETK_BOX(gui->trackback_shell), gui->trackback->gui_object, ETK_BOX_START, ETK_BOX_NONE, 0);
}
entropy_config_misc_callback_register("general.trackback", _entropy_layout_etk_simple_config_cb, gui);
}
/*Menu setup*/
menubar = etk_menu_bar_new();
/*File menu*/
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("File"), ETK_STOCK_NO_STOCK, ETK_MENU_SHELL(menubar), NULL);
menu = etk_menu_new();
etk_menu_item_submenu_set(ETK_MENU_ITEM(menu_item), ETK_MENU(menu));
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Exit"), ETK_STOCK_SYSTEM_SHUTDOWN, ETK_MENU_SHELL(menu), NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(etk_layout_simple_exit_cb), layout);
/*Edit menu*/
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Edit"), ETK_STOCK_NO_STOCK, ETK_MENU_SHELL(menubar), NULL);
menu = etk_menu_new();
etk_menu_item_submenu_set(ETK_MENU_ITEM(menu_item), ETK_MENU(menu));
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Cut"), ETK_STOCK_EDIT_CUT, ETK_MENU_SHELL(menu), NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(_entropy_layout_etk_cut_cb), layout);
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Copy"), ETK_STOCK_EDIT_COPY, ETK_MENU_SHELL(menu), NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(_entropy_layout_etk_copy_cb), layout);
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Paste"), ETK_STOCK_EDIT_PASTE, ETK_MENU_SHELL(menu), NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(_entropy_layout_etk_paste_cb), layout);
/*Tools menu*/
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Tools"), ETK_STOCK_NO_STOCK, ETK_MENU_SHELL(menubar), NULL);
menu = etk_menu_new();
etk_menu_item_submenu_set(ETK_MENU_ITEM(menu_item), ETK_MENU(menu));
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Add Location"), ETK_STOCK_ADDRESS_BOOK_NEW, ETK_MENU_SHELL(menu), NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(_location_add_cb), layout);
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("eFolder Wizard.."), ETK_STOCK_ADDRESS_BOOK_NEW, ETK_MENU_SHELL(menu), NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(_entropy_etk_efolder_dialog_show_cb), layout);
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Program Associations.."),
ETK_STOCK_EMBLEM_SYMBOLIC_LINK, ETK_MENU_SHELL(menu), NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(etk_mime_dialog_cb), layout);
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Options.."),
ETK_STOCK_EMBLEM_SYMBOLIC_LINK, ETK_MENU_SHELL(menu), NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(entropy_etk_options_dialog_cb), layout);
/*View menu*/
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("View"), ETK_STOCK_NO_STOCK, ETK_MENU_SHELL(menubar), NULL);
menu = etk_menu_new();
etk_menu_item_submenu_set(ETK_MENU_ITEM(menu_item), ETK_MENU(menu));
gui->tree_view_menu = _entropy_etk_menu_check_item_new(_("Tree View"), ETK_MENU_SHELL(menu));
if (entropy_config_misc_is_set("general.treeviewer")) {
etk_menu_item_check_active_set(ETK_MENU_ITEM_CHECK(gui->tree_view_menu),ETK_TRUE );
}
etk_signal_connect("activated", ETK_OBJECT(gui->tree_view_menu), ETK_CALLBACK(entropy_etk_layout_tree_cb), layout);
menu_item = _entropy_etk_menu_check_item_new(_("Trackback view"), ETK_MENU_SHELL(menu));
if (entropy_config_misc_is_set("general.trackback")) {
etk_menu_item_check_active_set(ETK_MENU_ITEM_CHECK(menu_item), ETK_TRUE);
}
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(entropy_etk_layout_trackback_cb), layout);
_entropy_etk_menu_item_new(ETK_MENU_ITEM_SEPARATOR, NULL,
ETK_STOCK_NO_STOCK, ETK_MENU_SHELL(menu), NULL);
menu_item = _entropy_etk_radio_item_new(_("List View (Alt-l)"), NULL, ETK_MENU_SHELL(menu));
etk_object_data_set(ETK_OBJECT(menu_item), "VISUAL", gui->list_viewer);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(etk_local_viewer_cb), layout);
if (entropy_config_misc_is_set("general.listviewer")) {
etk_menu_item_check_active_set(ETK_MENU_ITEM_CHECK(menu_item), ETK_TRUE);
}
menu_item = _entropy_etk_radio_item_new(_("Icon View (Alt-i)"), ETK_MENU_ITEM_RADIO(menu_item), ETK_MENU_SHELL(menu));
etk_object_data_set(ETK_OBJECT(menu_item), "VISUAL", gui->iconbox_viewer);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(etk_local_viewer_cb), layout);
if (entropy_config_misc_is_set("general.iconviewer")) {
etk_menu_item_check_active_set(ETK_MENU_ITEM_CHECK(menu_item), ETK_TRUE);
}
/*Debug menu*/
/*menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Debug"), ETK_STOCK_NO_STOCK, ETK_MENU_SHELL(menubar), NULL);
menu = etk_menu_new();
etk_menu_item_submenu_set(ETK_MENU_ITEM(menu_item), ETK_MENU(menu));
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("File Cache"), ETK_STOCK_PLACES_FOLDER_SAVED_SEARCH, ETK_MENU_SHELL(menu), NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(etk_file_cache_dialog_cb), layout);*/
/*Help menu*/
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("Help"), ETK_STOCK_NO_STOCK, ETK_MENU_SHELL(menubar), NULL);
menu = etk_menu_new();
etk_menu_item_submenu_set(ETK_MENU_ITEM(menu_item), ETK_MENU(menu));
menu_item = _entropy_etk_menu_item_new(ETK_MENU_ITEM_NORMAL, _("About.."), ETK_STOCK_HELP_BROWSER, ETK_MENU_SHELL(menu), NULL);
etk_signal_connect("activated", ETK_OBJECT(menu_item), ETK_CALLBACK(entropy_etk_about_dialog_cb), layout);
etk_box_append(ETK_BOX(vbox), menubar, ETK_BOX_START, ETK_BOX_NONE, 0);
etk_box_append(ETK_BOX(vbox), gui->trackback_shell, ETK_BOX_START, ETK_BOX_NONE, 0);
etk_box_append(ETK_BOX(vbox), gui->paned, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
/*---------------------------*/
gui->statusbar_box = etk_hbox_new(ETK_TRUE, 0);
etk_box_append(ETK_BOX(vbox), gui->statusbar_box, ETK_BOX_START, ETK_BOX_NONE, 0);
gui->statusbars[0] = etk_statusbar_new();
etk_statusbar_has_resize_grip_set(ETK_STATUSBAR(gui->statusbars[0]), ETK_FALSE);
etk_box_append(ETK_BOX(gui->statusbar_box), gui->statusbars[0], ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
gui->statusbars[1] = etk_statusbar_new();
etk_statusbar_has_resize_grip_set(ETK_STATUSBAR(gui->statusbars[1]), ETK_FALSE);
etk_box_append(ETK_BOX(gui->statusbar_box), gui->statusbars[1], ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
gui->statusbars[2] = etk_statusbar_new();
etk_statusbar_has_resize_grip_set(ETK_STATUSBAR(gui->statusbars[2]), ETK_TRUE);
etk_box_append(ETK_BOX(gui->statusbar_box), gui->statusbars[2], ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
etk_widget_show_all (window);
/*Increment the window counter*/
_etk_layout_window_count++;
etk_window_resize(ETK_WINDOW(window), ENTROPY_ETK_WINDOW_WIDTH, ENTROPY_ETK_WINDOW_HEIGHT);
return layout;
}
/* TODO : documentation */
void
emphasis_player_cover_size_set(Emphasis_Player_Gui *player, int w, int h)
{
etk_widget_size_request_set(player->small.cover, w, h);
etk_widget_size_request_set(player->full.cover , w, h);
}
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;
}
/*** Implementation ***/
Etk_Widget*
data_window_create(void)
{
Etk_Widget *hbox, *vbox, *hbox2, *vbox2, *vbox3;
Etk_Tree_Col *col;
Etk_Widget *button;
Etk_Widget *frame;
Etk_Widget *label;
//DataWin
UI_DataWin = etk_window_new();
etk_window_title_set(ETK_WINDOW(UI_DataWin), "Data Browser");
etk_window_resize(ETK_WINDOW(UI_DataWin), 400, 370);
etk_signal_connect("delete-event", ETK_OBJECT(UI_DataWin),
ETK_CALLBACK(etk_window_hide_on_delete), NULL);
etk_container_border_width_set(ETK_CONTAINER(UI_DataWin), 5);
vbox = etk_vbox_new(ETK_FALSE, 5);
etk_container_add(ETK_CONTAINER(UI_DataWin), vbox);
//Description label
label = etk_label_new("Data stored inside the edje file that can be accessed by the application.");
etk_object_properties_set(ETK_OBJECT(label), "xalign", 0.5, NULL);
etk_box_append(ETK_BOX(vbox), label, ETK_BOX_START, ETK_BOX_NONE, 7);
hbox = etk_hbox_new(ETK_TRUE, 5);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
vbox2 = etk_vbox_new(ETK_FALSE, 0);
etk_box_append(ETK_BOX(hbox), vbox2, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//UI_DataList
UI_DataList = etk_tree_new();
etk_tree_mode_set(ETK_TREE(UI_DataList), ETK_TREE_MODE_LIST);
etk_widget_size_request_set(UI_DataList, 225, 200);
etk_tree_headers_visible_set(ETK_TREE(UI_DataList), ETK_TRUE);
etk_tree_column_separators_visible_set(ETK_TREE(UI_DataList), ETK_TRUE);
etk_tree_alternating_row_colors_set(ETK_TREE(UI_DataList), ETK_TRUE);
col = etk_tree_col_new(ETK_TREE(UI_DataList), "Name", 100, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
col = etk_tree_col_new(ETK_TREE(UI_DataList), "Value", 120, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(UI_DataList));
etk_box_append(ETK_BOX(vbox2), UI_DataList, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
etk_signal_connect("row-selected", ETK_OBJECT(UI_DataList),
ETK_CALLBACK(_data_list_row_selected_cb), NULL);
hbox2 = etk_hbox_new(ETK_TRUE, 0);
etk_box_append(ETK_BOX(vbox2), hbox2, ETK_BOX_START, ETK_BOX_NONE, 0);
//AddDataButton
button = etk_button_new_from_stock(ETK_STOCK_LIST_ADD);
etk_button_style_set(ETK_BUTTON(button), ETK_BUTTON_ICON);
etk_signal_connect("clicked", ETK_OBJECT(button),
ETK_CALLBACK(_data_add_button_click_cb), NULL);
etk_box_append(ETK_BOX(hbox2), button, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//DelDataButton
button = etk_button_new_from_stock(ETK_STOCK_LIST_REMOVE);
etk_button_style_set(ETK_BUTTON(button), ETK_BUTTON_ICON);
etk_signal_connect("clicked", ETK_OBJECT(button),
ETK_CALLBACK(_data_del_button_click_cb), NULL);
etk_box_append(ETK_BOX(hbox2), button, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
vbox2 = etk_vbox_new(ETK_FALSE, 0);
etk_box_append(ETK_BOX(hbox), vbox2, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//Data Editor
frame = etk_frame_new("Data Editor");
etk_box_append(ETK_BOX(vbox2), frame, ETK_BOX_START, ETK_BOX_FILL, 0);
vbox3 = etk_vbox_new(ETK_FALSE, 0);
etk_container_add(ETK_CONTAINER(frame), vbox3);
//Name Entry
label = etk_label_new("<b>Name</b>");
etk_box_append(ETK_BOX(vbox3), label, ETK_BOX_START, ETK_BOX_NONE, 0);
UI_DataNameEntry = etk_entry_new();
//etk_widget_disabled_set(UI_DataNameEntry, ETK_TRUE);
etk_box_append(ETK_BOX(vbox3), UI_DataNameEntry,
ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//Value Entry
label = etk_label_new("<b>Value</b>");
etk_box_append(ETK_BOX(vbox3), label, ETK_BOX_START, ETK_BOX_NONE, 0);
UI_DataValueEntry = etk_entry_new();
etk_box_append(ETK_BOX(vbox3), UI_DataValueEntry,
ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//Apply button
UI_DataApplyButton =etk_button_new_from_stock(ETK_STOCK_DIALOG_APPLY);
etk_signal_connect("clicked", ETK_OBJECT(UI_DataApplyButton),
ETK_CALLBACK(_data_apply_button_click_cb), NULL);
etk_box_append(ETK_BOX(vbox3), UI_DataApplyButton,
ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
return UI_DataWin;
}
/* theme preview widget */
static Etk_Widget *_etk_prefs_theme_preview_get(const char *theme)
{
char file[PATH_MAX];
static Etk_Widget *box = NULL;
Etk_Widget *widget;
Etk_Widget *vbox;
Etk_Widget *frame;
snprintf(file, sizeof(file), PACKAGE_DATA_DIR"/themes/%s.edj", theme);
if (!ecore_file_exists(file))
{
char *home;
home = getenv("HOME");
if (!home)
return NULL;
snprintf(file, sizeof(file), "%s/.e/etk/themes/%s.edj", home, theme);
if (!ecore_file_exists(file))
return NULL;
}
free(_etk_prefs_widget_theme);
_etk_prefs_widget_theme = strdup(theme);
if (box)
{
etk_widget_theme_file_set(box, file);
return box;
}
box = etk_vbox_new(ETK_FALSE, 0);
etk_widget_theme_file_set(box, file);
frame = etk_frame_new(_("Buttons"));
etk_box_append(ETK_BOX(box), frame, ETK_BOX_START, ETK_BOX_NONE, 0);
vbox = etk_vbox_new(ETK_FALSE, 0);
etk_container_add(ETK_CONTAINER(frame), vbox);
widget = etk_button_new_with_label(_("Regular Button"));
etk_box_append(ETK_BOX(vbox), widget, ETK_BOX_START, ETK_BOX_NONE, 0);
widget = etk_check_button_new_with_label(_("Check Button"));
etk_box_append(ETK_BOX(vbox), widget, ETK_BOX_START, ETK_BOX_NONE, 0);
widget = etk_radio_button_new_with_label(_("Radio Button"), NULL);
etk_box_append(ETK_BOX(vbox), widget, ETK_BOX_START, ETK_BOX_NONE, 0);
frame = etk_frame_new(_("Text"));
etk_box_append(ETK_BOX(box), frame, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
vbox = etk_vbox_new(ETK_FALSE, 0);
etk_container_add(ETK_CONTAINER(frame), vbox);
widget = etk_entry_new();
etk_entry_text_set(ETK_ENTRY(widget), _("Sample text..."));
etk_box_append(ETK_BOX(vbox), widget, ETK_BOX_START, ETK_BOX_NONE, 0);
widget = etk_text_view_new();
etk_textblock_text_set(etk_text_view_textblock_get(ETK_TEXT_VIEW(widget)),
_("Multi-line text widget!\nHow about that! (="),
ETK_TRUE);
etk_widget_size_request_set(widget, 320, 50);
etk_box_append(ETK_BOX(vbox), widget, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
return box;
}
/*** Implementation ***/
Etk_Widget*
state_frame_create(void)
{
Etk_Widget *vbox;
Etk_Widget *hbox;
Etk_Widget *label;
Etk_Combobox_Item *ComboItem;
//vbox
vbox = etk_vbox_new(ETK_FALSE, 0);
// etk_container_add(ETK_CONTAINER(UI_DescriptionFrame), vbox);
//hbox
hbox = etk_hbox_new(ETK_FALSE, 0);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
label = etk_label_new("<b>Name</b>");
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//StateEntry
UI_StateEntry = etk_entry_new();
UI_StateEntryImage = etk_image_new_from_stock(ETK_STOCK_DIALOG_OK,
ETK_STOCK_SMALL);
etk_entry_image_set(ETK_ENTRY(UI_StateEntry), ETK_ENTRY_IMAGE_SECONDARY,
ETK_IMAGE(UI_StateEntryImage));
etk_box_append(ETK_BOX(hbox), UI_StateEntry, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//UI_StateIndexSpinner
//~ UI_StateIndexSpinner = etk_spinner_new(0.0, 1.0, 0.0, 0.1, 1.0);
//~ etk_spinner_digits_set(ETK_SPINNER(UI_StateIndexSpinner), 1);
//~ etk_widget_size_request_set(UI_StateIndexSpinner,45, 20);
//~ etk_box_append(ETK_BOX(hbox),UI_StateIndexSpinner, ETK_BOX_START, ETK_BOX_NONE, 0);
//hbox
hbox = etk_hbox_new(ETK_FALSE, 0);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
label = etk_label_new("<b>Aspect</b>");
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
label = etk_label_new("min:");
etk_object_properties_set(ETK_OBJECT(label), "xalign", 1.0, NULL);
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
//UI_AspectMinSpinner
UI_AspectMinSpinner = etk_spinner_new(0.0, 100.0, 0.0, 0.1, 1.0);
etk_spinner_digits_set(ETK_SPINNER(UI_AspectMinSpinner), 1);
etk_widget_size_request_set(UI_AspectMinSpinner,45, 20);
etk_box_append(ETK_BOX(hbox), UI_AspectMinSpinner, ETK_BOX_START, ETK_BOX_NONE, 0);
label = etk_label_new("max:");
etk_object_properties_set(ETK_OBJECT(label), "xalign", 1.0, NULL);
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
//UI_AspectMaxSpinner
UI_AspectMaxSpinner = etk_spinner_new(0.0, 100.0, 0.0, 0.1, 1.0);
etk_spinner_digits_set(ETK_SPINNER(UI_AspectMaxSpinner), 1);
etk_widget_size_request_set(UI_AspectMaxSpinner, 45, 20);
etk_box_append(ETK_BOX(hbox), UI_AspectMaxSpinner, ETK_BOX_START, ETK_BOX_NONE, 0);
//UI_AspectCombo
UI_AspectComboBox = etk_combobox_new();
etk_combobox_column_add(ETK_COMBOBOX(UI_AspectComboBox), ETK_COMBOBOX_LABEL, 30, ETK_COMBOBOX_NONE, 0.0);
etk_combobox_build(ETK_COMBOBOX(UI_AspectComboBox));
etk_box_append(ETK_BOX(hbox), UI_AspectComboBox, ETK_BOX_START, ETK_BOX_NONE, 0);
ComboItem = etk_combobox_item_append(ETK_COMBOBOX(UI_AspectComboBox), "None");
etk_combobox_item_data_set(ComboItem, (void*)EDJE_ASPECT_PREFER_NONE);
ComboItem = etk_combobox_item_append(ETK_COMBOBOX(UI_AspectComboBox), "Vertical");
etk_combobox_item_data_set(ComboItem, (void*)EDJE_ASPECT_PREFER_VERTICAL);
ComboItem = etk_combobox_item_append(ETK_COMBOBOX(UI_AspectComboBox), "Horizontal");
etk_combobox_item_data_set(ComboItem, (void*)EDJE_ASPECT_PREFER_HORIZONTAL);
ComboItem = etk_combobox_item_append(ETK_COMBOBOX(UI_AspectComboBox), "Both");
etk_combobox_item_data_set(ComboItem, (void*)EDJE_ASPECT_PREFER_BOTH);
//hbox
hbox = etk_hbox_new(ETK_FALSE, 0);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_NONE, 0);
label = etk_label_new("<b>Size</b> min");
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
//UI_StateMinWSpinner
UI_StateMinWSpinner = etk_spinner_new(0, 2000, 0, 1, 10);
etk_widget_size_request_set(UI_StateMinWSpinner, 45, 20);
etk_box_append(ETK_BOX(hbox), UI_StateMinWSpinner, ETK_BOX_START, ETK_BOX_NONE, 0);
label = etk_label_new("x");
etk_object_properties_set(ETK_OBJECT(label), "xalign", 0.5, NULL);
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
//UI_StateMinHSpinner
UI_StateMinHSpinner = etk_spinner_new(0, 2000, 0, 1, 10);
etk_widget_size_request_set(UI_StateMinHSpinner, 45, 20);
etk_box_append(ETK_BOX(hbox), UI_StateMinHSpinner, ETK_BOX_START, ETK_BOX_NONE, 0);
label = etk_label_new("max");
etk_object_properties_set(ETK_OBJECT(label), "xalign", 1.0, NULL);
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
//UI_StateMaxWSpinner
UI_StateMaxWSpinner = etk_spinner_new(0, 2000, 0, 1, 10);
etk_widget_size_request_set(UI_StateMaxWSpinner, 45, 20);
etk_box_append(ETK_BOX(hbox), UI_StateMaxWSpinner, ETK_BOX_START, ETK_BOX_NONE, 0);
label = etk_label_new("x");
etk_object_properties_set(ETK_OBJECT(label), "xalign", 0.5, NULL);
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
//UI_StateMaxHspinner
UI_StateMaxHSpinner = etk_spinner_new(0, 2000, 0, 1, 10);
etk_widget_size_request_set(UI_StateMaxHSpinner, 45, 20);
etk_box_append(ETK_BOX(hbox), UI_StateMaxHSpinner, ETK_BOX_START, ETK_BOX_NONE, 0);
//hbox
hbox = etk_hbox_new(ETK_FALSE, 0);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_NONE, 0);
//UI_StateAlignHSpinner
label = etk_label_new("<b>Align</b> H");
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
UI_StateAlignHSpinner = etk_spinner_new(0, 1, 0, 0.01, 0.1);
etk_spinner_digits_set(ETK_SPINNER(UI_StateAlignHSpinner), 2);
etk_widget_size_request_set(UI_StateAlignHSpinner, 45, 20);
etk_box_append(ETK_BOX(hbox), UI_StateAlignHSpinner, ETK_BOX_START, ETK_BOX_NONE, 0);
//UI_StateAlignVSpinner
label = etk_label_new("V");
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
UI_StateAlignVSpinner = etk_spinner_new(0, 1, 0, 0.01, 0.1);
etk_spinner_digits_set(ETK_SPINNER(UI_StateAlignVSpinner), 2);
etk_widget_size_request_set(UI_StateAlignVSpinner, 45, 20);
etk_box_append(ETK_BOX(hbox), UI_StateAlignVSpinner, ETK_BOX_START, ETK_BOX_NONE, 0);
//UI_StateVisibleCheck
UI_StateVisibleCheck = etk_check_button_new_with_label("Visible");
etk_widget_padding_set(UI_StateVisibleCheck, 20, 0, 0, 0);
etk_box_append(ETK_BOX(hbox), UI_StateVisibleCheck, ETK_BOX_START, ETK_BOX_NONE, 0);
//hbox
hbox = etk_hbox_new(ETK_FALSE, 0);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_NONE, 0);
//UI_StateCCEntry
label = etk_label_new("Color Class");
etk_box_append(ETK_BOX(hbox), label, ETK_BOX_START, ETK_BOX_NONE, 0);
UI_StateCCEntry = etk_entry_new();
etk_box_append(ETK_BOX(hbox), UI_StateCCEntry, ETK_BOX_START, ETK_BOX_NONE, 0);
etk_signal_connect("key-down", ETK_OBJECT(UI_StateEntry),
ETK_CALLBACK(_state_Entry_key_down_cb), NULL);
etk_signal_connect("mouse-click", ETK_OBJECT(UI_StateEntryImage),
ETK_CALLBACK(_state_EntryImage_clicked_cb), NULL);
etk_signal_connect("text-changed", ETK_OBJECT(UI_StateEntry),
ETK_CALLBACK(_group_NamesEntry_text_changed_cb), NULL);
etk_signal_connect("value-changed", ETK_OBJECT(UI_AspectMinSpinner),
ETK_CALLBACK(_state_AspectSpinner_value_changed_cb), NULL);
etk_signal_connect("value-changed", ETK_OBJECT(UI_AspectMaxSpinner),
ETK_CALLBACK(_state_AspectSpinner_value_changed_cb), NULL);
etk_signal_connect("active-item-changed", ETK_OBJECT(UI_AspectComboBox),
ETK_CALLBACK(_state_AspectComboBox_changed_cb), NULL);
etk_signal_connect("value-changed", ETK_OBJECT(UI_StateMinWSpinner),
ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
etk_signal_connect("value-changed", ETK_OBJECT(UI_StateMinHSpinner),
ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
etk_signal_connect("value-changed", ETK_OBJECT(UI_StateMaxWSpinner),
ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
etk_signal_connect("value-changed", ETK_OBJECT(UI_StateMaxHSpinner),
ETK_CALLBACK(_state_MinMaxSpinner_value_changed_cb), NULL);
etk_signal_connect("value-changed", ETK_OBJECT(UI_StateAlignVSpinner),
ETK_CALLBACK(_text_FontAlignSpinner_value_changed_cb),
(void*)STATE_ALIGNV_SPINNER);
etk_signal_connect("value-changed", ETK_OBJECT(UI_StateAlignHSpinner),
ETK_CALLBACK(_text_FontAlignSpinner_value_changed_cb),
(void*)STATE_ALIGNH_SPINNER);
etk_signal_connect("toggled", ETK_OBJECT(UI_StateVisibleCheck),
ETK_CALLBACK(_state_VisibleCheck_toggled_cb), NULL);
etk_signal_connect("text-changed", ETK_OBJECT(UI_StateCCEntry),
ETK_CALLBACK(_state_CCEntry_text_changed_cb), NULL);
return vbox;
}
/*** 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;
}
Ex_Tab *
_ex_tab_new(Exhibit *e, char *dir)
{
Ex_Tab *tab;
Etk_Tree_Model *imodel;
char *file;
file = NULL;
tab = calloc(1, sizeof(Ex_Tab));
//tab->num = eina_list_count(e->tabs);
tab->dirs = NULL;
if (!dir) {
D(("NO DIR\n"));
exit(-1);
}
D(("Creating new tab with %s\n", dir));
if (e->options->default_view == EX_IMAGE_FIT_TO_WINDOW)
{
tab->fit_window = ETK_TRUE;
D(("Setting EX_IMAGE_FIT_TO_WINDOW\n"));
}
else
tab->fit_window = ETK_FALSE;
tab->comment.visible = ETK_FALSE;
tab->image_loaded = ETK_FALSE;
tab->dtree = etk_tree_new();
etk_widget_size_request_set(tab->dtree, 180, 120);
etk_signal_connect("row-clicked", ETK_OBJECT(tab->dtree), ETK_CALLBACK(_ex_tab_dtree_item_clicked_cb), e);
tab->dcol = etk_tree_col_new(ETK_TREE(tab->dtree), "Directories", 10, 0.0);
etk_tree_col_model_add(tab->dcol, etk_tree_model_image_new());
etk_tree_col_model_add(tab->dcol, etk_tree_model_text_new());
etk_tree_headers_visible_set(ETK_TREE(tab->dtree), 0);
etk_scrolled_view_policy_set(etk_tree_scrolled_view_get(ETK_TREE(tab->dtree)), ETK_POLICY_AUTO, ETK_POLICY_SHOW);
etk_tree_build(ETK_TREE(tab->dtree));
tab->itree = etk_tree_new();
etk_scrolled_view_dragable_set(ETK_SCROLLED_VIEW(etk_tree_scrolled_view_get(ETK_TREE(tab->itree))), ETK_TRUE);
etk_scrolled_view_drag_bouncy_set(ETK_SCROLLED_VIEW(etk_tree_scrolled_view_get(ETK_TREE(tab->itree))), ETK_FALSE);
etk_scrolled_view_drag_damping_set(ETK_SCROLLED_VIEW(etk_tree_scrolled_view_get(ETK_TREE(tab->itree))), 300);
etk_widget_dnd_source_set(ETK_WIDGET(tab->itree), ETK_TRUE);
// etk_signal_connect("drag_begin", ETK_OBJECT(tab->itree), ETK_CALLBACK(_ex_tab_tree_drag_begin_cb), tab);
etk_widget_size_request_set(tab->itree, 180, 220);
etk_tree_multiple_select_set(ETK_TREE(tab->itree), ETK_TRUE);
etk_signal_connect("row-selected", ETK_OBJECT(tab->itree), ETK_CALLBACK(_ex_tab_itree_item_clicked_cb), e);
etk_signal_connect("key-down", ETK_OBJECT(tab->itree), ETK_CALLBACK(_ex_tab_itree_key_down_cb), e);
imodel = etk_tree_model_wobbly_new();
tab->imodel = imodel;
//etk_tree_model_image_width_set(imodel, 80, 0.0);
tab->icol = etk_tree_col_new(ETK_TREE(tab->itree), "Files", 10, 0.0);
etk_tree_col_model_add(tab->icol, imodel);
etk_tree_col_model_add(tab->icol, etk_tree_model_text_new());
etk_tree_headers_visible_set(ETK_TREE(tab->itree), 0);
etk_tree_rows_height_set(ETK_TREE(tab->itree), 60);
etk_scrolled_view_policy_set(etk_tree_scrolled_view_get(ETK_TREE(tab->itree)), ETK_POLICY_AUTO, ETK_POLICY_SHOW);
etk_tree_build(ETK_TREE(tab->itree));
tab->dir = _ex_path_normalize(ecore_file_realpath(dir));
tab->alignment = etk_alignment_new(0.5, 0.5, 1.0, 1.0);
tab->image = etk_image_new();
etk_widget_theme_file_set(tab->image, PACKAGE_DATA_DIR"/gui.edj");
etk_widget_theme_group_set(tab->image, "image_bg");
etk_signal_connect("mouse-down", ETK_OBJECT(tab->image), ETK_CALLBACK(_ex_image_mouse_down), e);
etk_signal_connect("mouse-up", ETK_OBJECT(tab->image), ETK_CALLBACK(_ex_image_mouse_up), e);
etk_signal_connect("mouse-move", ETK_OBJECT(tab->image), ETK_CALLBACK(_ex_image_mouse_move), e);
etk_signal_connect("mouse-wheel", ETK_OBJECT(tab->image), ETK_CALLBACK(_ex_image_mouse_wheel), e);
etk_image_keep_aspect_set(ETK_IMAGE(tab->image), ETK_TRUE);
etk_container_add(ETK_CONTAINER(tab->alignment), tab->image);
tab->scrolled_view = etk_scrolled_view_new();
etk_scrolled_view_policy_set(ETK_SCROLLED_VIEW(tab->scrolled_view), ETK_POLICY_HIDE, ETK_POLICY_HIDE);
etk_scrolled_view_dragable_set(ETK_SCROLLED_VIEW(tab->scrolled_view), ETK_TRUE);
etk_scrolled_view_drag_bouncy_set((ETK_SCROLLED_VIEW(tab->scrolled_view)), ETK_FALSE);
etk_scrolled_view_add_with_viewport(ETK_SCROLLED_VIEW(tab->scrolled_view), tab->alignment);
etk_widget_has_event_object_set(tab->scrolled_view, ETK_TRUE);
etk_signal_connect("mouse-wheel", ETK_OBJECT(tab->scrolled_view), ETK_CALLBACK(_ex_image_mouse_wheel), e);
return tab;
}
