/* Removes the child from the box */
static void _etk_box_child_remove(Etk_Container *container, Etk_Widget *widget)
{
Etk_Box *box;
Etk_Box_Cell *cell;
if (!(box = ETK_BOX(container)) || !widget)
return;
if ((cell = _etk_box_cell_get(widget)))
{
if (cell->prev)
cell->prev->next = cell->next;
if (cell->next)
cell->next->prev = cell->prev;
if (cell == box->first_cell[cell->group])
box->first_cell[cell->group] = cell->next;
if (cell == box->last_cell[cell->group])
box->last_cell[cell->group] = cell->prev;
box->cells_count[cell->group]--;
ETK_WIDGET(box)->focus_order = eina_list_remove_list(ETK_WIDGET(box)->focus_order, cell->focus_node);
etk_object_data_set(ETK_OBJECT(widget), "_Etk_Box::Cell", NULL);
free(cell);
etk_widget_size_recalc_queue(ETK_WIDGET(box));
etk_signal_emit(ETK_CONTAINER_CHILD_REMOVED_SIGNAL, ETK_OBJECT(box), widget);
}
}
void entropy_etk_delete_dialog_new(entropy_gui_component_instance* instance, Ecore_List* files)
{
char buf[PATH_MAX];
Etk_Widget* window = etk_window_new();
Etk_Widget* vbox= etk_vbox_new(ETK_TRUE,5);
Etk_Widget* hbox = etk_hbox_new(ETK_TRUE,5);
Etk_Widget* button;
Etk_Widget* label;
if (ecore_list_count(files) == 1) {
ecore_list_first_goto(files);
entropy_generic_file* file = ((entropy_generic_file*)ecore_list_current(files));
snprintf(buf, PATH_MAX, "Are you sure you want to delete '%s/%s'? ", file->path,
file->filename);
} else {
snprintf(buf, PATH_MAX, "Are you sure you want to delete these %d files'? ", ecore_list_count(files));
}
etk_window_title_set(ETK_WINDOW(window), buf);
etk_container_add(ETK_CONTAINER(window), vbox);
label = etk_label_new(buf);
etk_box_append(ETK_BOX(vbox), label, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 5);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 5);
button = etk_button_new_with_label("Yes");
etk_container_add(ETK_CONTAINER(hbox), button);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_entropy_delete_dialog_cb),
(int*)ENTROPY_USER_INTERACTION_RESPONSE_YES );
etk_object_data_set(ETK_OBJECT(button), "window", window);
etk_widget_show(button);
button = etk_button_new();
etk_button_label_set(ETK_BUTTON(button), "No");
etk_container_add(ETK_CONTAINER(hbox), button);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_entropy_delete_dialog_cb),
(int*)ENTROPY_USER_INTERACTION_RESPONSE_NO );
etk_object_data_set(ETK_OBJECT(button), "window", window);
etk_widget_show(button);
etk_object_data_set(ETK_OBJECT(window), "files", files);
etk_object_data_set(ETK_OBJECT(window), "instance", instance);
etk_widget_show_all(window);
}
/**
* @brief Attachs a widget to the table
* @param table a table
* @param child the widget to attach
* @param left_attach the column where the left side of the child will be attached (starting from 0)
* @param right_attach the column where the right side of the child will be attached (starting from 0)
* @param top_attach the row where the top side of the child will be attached (starting from 0)
* @param bottom_attach the row where the bottom side of the child will be attached (starting from 0)
* @param fill_policy The fill policy of the child
* @param x_padding the amount of free space on the left and on the right sides of the child widget
* @param y_padding the amount of free space on the top and on the bottom sides of the child widget
*/
void etk_table_attach(Etk_Table *table, Etk_Widget *child, int left_attach, int right_attach, int top_attach, int bottom_attach, Etk_Table_Fill_Policy fill_policy, int x_padding, int y_padding)
{
Etk_Table_Cell *cell;
int i, j;
if (!table || !table->cells || !child)
return;
left_attach = ETK_CLAMP(left_attach, 0, table->num_cols - 1);
right_attach = ETK_CLAMP(right_attach, left_attach, table->num_cols - 1);
top_attach = ETK_CLAMP(top_attach, 0, table->num_rows - 1);
bottom_attach = ETK_CLAMP(bottom_attach, top_attach, table->num_rows - 1);
cell = malloc(sizeof(Etk_Table_Cell));
cell->left_attach = left_attach;
cell->right_attach = right_attach;
cell->top_attach = top_attach;
cell->bottom_attach = bottom_attach;
cell->x_padding = x_padding;
cell->y_padding = y_padding;
cell->fill_policy = fill_policy;
cell->child = child;
for (i = left_attach; i <= right_attach; i++)
{
for (j = top_attach; j <= bottom_attach; j++)
{
etk_table_cell_clear(table, i, j);
table->cells[CELL_INDEX(table, i, j)] = cell;
}
}
table->cells_list = eina_list_append(table->cells_list, cell);
cell->node = eina_list_last(table->cells_list);
etk_object_data_set(ETK_OBJECT(child), "_Etk_Table::Cell", cell);
etk_widget_parent_set(child, ETK_WIDGET(table));
etk_signal_emit(ETK_CONTAINER_CHILD_ADDED_SIGNAL, ETK_OBJECT(table), child);
}
/**
* @brief Clears the cell ( @a col, @a row ): it removes from the table the widget that is in this cell
* @param table a table
* @param col the column in which the widget to remove is (starting from 0)
* @param row the row in which the widget to remove is (starting from 0)
*/
void etk_table_cell_clear(Etk_Table *table, int col, int row)
{
Etk_Table_Cell *cell;
Etk_Widget *child;
int i, j;
if (!table || !table->cells || col < 0 || col > table->num_cols - 1 || row < 0 || row > table->num_rows - 1)
return;
if (!(cell = table->cells[CELL_INDEX(table, col, row)]) || !(child = cell->child))
return;
for (i = cell->left_attach; i <= cell->right_attach; i++)
{
for (j = cell->top_attach; j <= cell->bottom_attach; j++)
table->cells[CELL_INDEX(table, i, j)] = NULL;
}
table->cells_list = eina_list_remove_list(table->cells_list, cell->node);
free(cell);
etk_object_data_set(ETK_OBJECT(child), "_Etk_Table::Cell", NULL);
etk_widget_parent_set(child, NULL);
etk_signal_emit(ETK_CONTAINER_CHILD_REMOVED_SIGNAL, ETK_OBJECT(table), child);
}
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;
}
void entropy_etk_user_interaction_dialog_new(entropy_file_operation* interact)
{
char buf[PATH_MAX];
Etk_Widget* window = etk_window_new();
Etk_Widget* vbox= etk_vbox_new(ETK_TRUE,5);
Etk_Widget* hbox = etk_hbox_new(ETK_TRUE,5);
Etk_Widget* button;
Etk_Widget* label;
snprintf(buf, PATH_MAX, "Confirm overwrite for '%s'? ", interact->file);
etk_window_title_set(ETK_WINDOW(window), buf);
etk_container_add(ETK_CONTAINER(window), vbox);
label = etk_label_new(buf);
etk_box_append(ETK_BOX(vbox), label, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 5);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 5);
button = etk_button_new_with_label("Yes");
etk_container_add(ETK_CONTAINER(hbox), button);
etk_object_data_set(ETK_OBJECT(button), "window", window);
etk_object_data_set(ETK_OBJECT(button), "operation", (long*)interact->id);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_entropy_user_interaction_dialog_cb),
(int*)ENTROPY_USER_INTERACTION_RESPONSE_YES );
etk_widget_show(button);
button = etk_button_new_with_label("Yes to all");
etk_container_add(ETK_CONTAINER(hbox), button);
etk_object_data_set(ETK_OBJECT(button), "window", window);
etk_object_data_set(ETK_OBJECT(button), "operation", (long*)interact->id);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_entropy_user_interaction_dialog_cb),
(int*)ENTROPY_USER_INTERACTION_RESPONSE_YES_TO_ALL );
etk_widget_show(button);
button = etk_button_new();
etk_button_label_set(ETK_BUTTON(button), "No");
etk_container_add(ETK_CONTAINER(hbox), button);
etk_object_data_set(ETK_OBJECT(button), "window", window);
etk_object_data_set(ETK_OBJECT(button), "operation", (long*)interact->id);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_entropy_user_interaction_dialog_cb),
(int*)ENTROPY_USER_INTERACTION_RESPONSE_NO );
etk_widget_show(button);
button = etk_button_new_with_label("No to all");
etk_container_add(ETK_CONTAINER(hbox), button);
etk_object_data_set(ETK_OBJECT(button), "window", window);
etk_object_data_set(ETK_OBJECT(button), "operation", (long*)interact->id);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_entropy_user_interaction_dialog_cb),
(int*)ENTROPY_USER_INTERACTION_RESPONSE_NO_TO_ALL );
etk_widget_show(button);
button = etk_button_new();
etk_button_label_set(ETK_BUTTON(button), "Abort");
etk_container_add(ETK_CONTAINER(hbox), button);
etk_object_data_set(ETK_OBJECT(button), "window", window);
etk_object_data_set(ETK_OBJECT(button), "operation", (long*)interact->id);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_entropy_user_interaction_dialog_cb),
(int*)ENTROPY_USER_INTERACTION_RESPONSE_ABORT );
etk_widget_show(button);
etk_widget_show_all(window);
etk_widget_show(vbox);
etk_widget_show(hbox);
}
/* Adds a new widget to the box, after the cell "after" */
static void _etk_box_insert_after_cell(Etk_Box *box, Etk_Widget *child, Etk_Box_Group group, Etk_Box_Cell *after, Etk_Box_Fill_Policy fill_policy, int padding)
{
Etk_Box_Cell *cell;
Etk_Widget *box_widget;
if (!(box_widget = ETK_WIDGET(box)) || !child)
return;
if (after && after->group != group)
{
ETK_WARNING("The child to pack and the widget after which the child should be packed "
"do not belong to the same child-group");
return;
}
cell = malloc(sizeof(Etk_Box_Cell));
cell->prev = NULL;
cell->next = NULL;
cell->child = child;
cell->focus_node = NULL;
cell->group = group;
cell->fill_policy = fill_policy;
cell->padding = padding;
if (after)
{
cell->prev = after;
cell->next = after->next;
if (after->next)
after->next->prev = cell;
else
box->last_cell[group] = cell;
after->next = cell;
box_widget->focus_order = eina_list_append_relative_list(box_widget->focus_order, child, after->focus_node);
cell->focus_node = eina_list_next(after->focus_node);
}
else
{
cell->next = box->first_cell[group];
if (box->first_cell[group])
box->first_cell[group]->prev = cell;
else
box->last_cell[group] = cell;
box->first_cell[group] = cell;
if (group == ETK_BOX_START || !box->last_cell[ETK_BOX_START])
{
box_widget->focus_order = eina_list_prepend(box_widget->focus_order, child);
cell->focus_node = box_widget->focus_order;
}
else
{
box_widget->focus_order = eina_list_append_relative_list(box_widget->focus_order,
child, box->last_cell[ETK_BOX_START]->focus_node);
cell->focus_node = eina_list_next(box->last_cell[ETK_BOX_START]->focus_node);
}
}
box->cells_count[group]++;
etk_widget_parent_set(child, ETK_WIDGET(box));
etk_object_data_set(ETK_OBJECT(child), "_Etk_Box::Cell", cell);
etk_signal_emit(ETK_CONTAINER_CHILD_ADDED_SIGNAL, ETK_OBJECT(box), child);
}
/* TODO : documentation */
void
emphasis_init_player(Emphasis_Player_Gui *player)
{
Enhance *en;
en = enhance_new();
player->en = en;
if(!en)
{
fprintf(stderr, "Enhance new failed");
exit(1);
}
player->state = EMPHASIS_SMALL; /* TODO : state toggle full */
_emphasis_enhance_callbacks(player);
enhance_file_load(en, "Emphasis", PACKAGE_DATA_DIR EMPHASIS_GLADE);
/* TODO : check widget? */
EN_VAR_GET(en, player, window);
etk_widget_hide(player->small.window);
etk_widget_hide(player->full.window);
EN_VAR_GET(en, player, root);
player->small.ctr.root = enhance_var_get(en, "small_root_ctrl");
player->small.cov.root = enhance_var_get(en, "small_root_cover");
_emphasis_init_player_small(player);
EN_VAR_GET(en, player, cover);
EN_VAR_GET(en, player, stop);
EN_VAR_GET(en, player, prev);
EN_VAR_GET(en, player, play);
EN_VAR_GET(en, player, next);
EN_VAR_GET(en, player, info);
EN_VAR_GET(en, player, progress);
//EN_VAR_GET(en, player, time);
player->full.time = enhance_var_get(en, "full_time");
EN_VAR_GET(en, player, sound_slider);
EN_VAR_GET(en, player, sound_low);
EN_VAR_GET(en, player, sound_high);
EN_VAR_GET(en, player, random);
EN_VAR_GET(en, player, repeat);
EN_VAR_GET(en, player, full);
player->small.media = enhance_var_get(en, "small_media");
player->media.window = enhance_var_get(en, "media_window");
player->media.root = enhance_var_get(en, "media_root");
player->media.notebook = enhance_var_get(en, "media_notebook");
player->media.paned = enhance_var_get(en, "media_paned");
player->media.pls = enhance_var_get(en, "media_pls");
player->media.artist = enhance_var_get(en, "media_artist");
player->media.album = enhance_var_get(en, "media_album");
player->media.track = enhance_var_get(en, "media_track");
player->media.search_root = enhance_var_get(en, "search_page_root");
player->media.search_combo = enhance_var_get(en, "search_page_combo");
player->media.search_tree = enhance_var_get(en, "search_page_tree");
player->media.pls_list = enhance_var_get(en, "media_pls_list");
player->media.pls_content = enhance_var_get(en, "media_pls_content");
player->media.pls_entry_save = enhance_var_get(en, "media_pls_entry_save");
/* Mediabox buttons init */
player->media.toolbar = enhance_var_get(en, "media_toolbar");
player->media.button_lib = enhance_var_get(en, "media_button_lib");
player->media.button_search = enhance_var_get(en, "media_button_search");
player->media.button_playlists = enhance_var_get(en, "media_button_pls");
player->media.button_stats = enhance_var_get(en, "media_button_stats");
/* enhance completion : col def */
etk_tree_multiple_select_set(ETK_TREE(player->media.artist), ETK_TRUE);
etk_tree_multiple_select_set(ETK_TREE(player->media.album) , ETK_TRUE);
etk_tree_multiple_select_set(ETK_TREE(player->media.track) , ETK_TRUE);
etk_tree_multiple_select_set(ETK_TREE(player->media.pls) , ETK_TRUE);
Etk_Tree_Col *col;
col = etk_tree_col_new(ETK_TREE(player->media.artist), "Artist", 60, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(player->media.artist));
col = etk_tree_col_new(ETK_TREE(player->media.album), "Album", 60, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(player->media.album));
col = etk_tree_col_new(ETK_TREE(player->media.track), "Track", 60, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(player->media.track));
/* pls */
col = etk_tree_col_new(ETK_TREE(player->media.pls), "Title", 140, 0.0);
etk_tree_col_model_add(col, etk_tree_model_image_new());
etk_tree_col_model_add(col, etk_tree_model_text_new());
col = etk_tree_col_new(ETK_TREE(player->media.pls), "Time", 30, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
col = etk_tree_col_new(ETK_TREE(player->media.pls), "Artist", 120, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
col = etk_tree_col_new(ETK_TREE(player->media.pls), "Album", 120, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(player->media.pls));
/* search page */
etk_tree_multiple_select_set(ETK_TREE(player->media.search_tree), ETK_TRUE);
col = etk_tree_col_new(ETK_TREE(player->media.search_tree), "Artist", 120, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
col = etk_tree_col_new(ETK_TREE(player->media.search_tree), "Album", 100, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
col = etk_tree_col_new(ETK_TREE(player->media.search_tree), "Title", 200, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
col = etk_tree_col_new(ETK_TREE(player->media.search_tree), "Filename", 200, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(player->media.search_tree));
/* playlists page */
col = etk_tree_col_new(ETK_TREE(player->media.pls_list), "Playlists", 120, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(player->media.pls_list));
col = etk_tree_col_new(ETK_TREE(player->media.pls_content), "Preview", 120, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(ETK_TREE(player->media.pls_content));
/**/
etk_object_data_set(ETK_OBJECT(player->media.artist), "title", "Artist");
etk_object_data_set(ETK_OBJECT(player->media.album) , "title", "Album" );
etk_object_data_set(ETK_OBJECT(player->media.track) , "title", "Track" );
etk_object_data_set(ETK_OBJECT(player->media.artist),
"Emphasis_Type",
(void*)EMPHASIS_ARTIST);
etk_object_data_set(ETK_OBJECT(player->media.album),
"Emphasis_Type",
(void*)EMPHASIS_ALBUM);
etk_object_data_set(ETK_OBJECT(player->media.track),
"Emphasis_Type",
(void*)EMPHASIS_TRACK);
/* enhance completion : dnd */
etk_widget_dnd_source_set(ETK_WIDGET(player->media.artist), ETK_TRUE);
etk_widget_dnd_source_set(ETK_WIDGET(player->media.album) , ETK_TRUE);
etk_widget_dnd_source_set(ETK_WIDGET(player->media.track) , ETK_TRUE);
etk_widget_dnd_dest_set(ETK_WIDGET(player->media.pls), ETK_TRUE);
etk_signal_connect("row-clicked", ETK_OBJECT(player->media.artist),
ETK_CALLBACK(cb_tree_mlib_clicked),
player);
etk_signal_connect("row-clicked", ETK_OBJECT(player->media.album ),
ETK_CALLBACK(cb_tree_mlib_clicked),
player);
etk_signal_connect("row-clicked", ETK_OBJECT(player->media.track ),
ETK_CALLBACK(cb_tree_mlib_clicked),
player);
etk_signal_connect("row-clicked", ETK_OBJECT(player->media.pls ),
ETK_CALLBACK(cb_tree_pls_clicked),
NULL);
/* Media pls init */
etk_object_data_set(ETK_OBJECT(player->media.pls_content),
"Emphasis_Type",
(void*)EMPHASIS_TRACK);
/* enhance complection : images */
emphasis_player_cover_set(player, NULL);
emphasis_player_vol_image_set(player, 0, PACKAGE_DATA_DIR EMPHASIS_SOUNDL);
emphasis_player_vol_image_set(player, 1, PACKAGE_DATA_DIR EMPHASIS_SOUNDR);
player->small.cover_size_w = player->small.cover->requested_size.w;
player->small.cover_size_h = player->small.cover->requested_size.h;
player->full.cover_size_w = player->full.cover->requested_size.w;
player->full.cover_size_h = player->full.cover->requested_size.h;
/* TEMP configuration, need to add this to enhance */
etk_window_wmclass_set(ETK_WINDOW(player->full.window),
"emphasis full", "Emphasis");
etk_window_wmclass_set(ETK_WINDOW(player->small.window),
"emphasis small", "Emphasis");
etk_window_wmclass_set(ETK_WINDOW(player->media.window),
"emphasis mlib", "Emphasis");
etk_container_border_width_set(ETK_CONTAINER(player->full.window), 5);
}
