void
image_tweenlist_populate(void)
{
Eina_List *tweens, *l;
Etk_Tree_Col *col;
if (!etk_string_length_get(Cur.state)) return;
if (!etk_string_length_get(Cur.part)) return;
col = etk_tree_nth_col_get(ETK_TREE(UI_ImageTweenList), 0);
etk_tree_clear(ETK_TREE(UI_ImageTweenList));
tweens = l = edje_edit_state_tweens_list_get(edje_o, Cur.part->string, Cur.state->string);
while (l)
{
//printf("RET: %s (id: %d)\n", l->data, edje_edit_image_id_get(edje_o, l->data));
//snprintf(buf, sizeof(buf), "images/%d", edje_edit_image_id_get(edje_o, l->data)); TODO: find a way to append image directly from the edje file.
etk_tree_row_append(ETK_TREE(UI_ImageTweenList), NULL,
col, NULL, NULL, l->data,
NULL);
l = l->next;
}
edje_edit_string_list_free(tweens);
}
static void
_tree_fill (Etk_Pdf *pdf, Etk_Tree *tree, Etk_Tree_Col *col, Etk_Tree_Row *row, Ecore_List *items)
{
Etk_Tree_Row *prow;
Epdf_Index_Item *item;
if (!items)
return;
ecore_list_first_goto (items);
while ((item = ecore_list_next (items))) {
char *buf;
Ecore_List *c;
int *num;
buf = strdup (epdf_index_item_title_get (item));
prow = etk_tree_row_append (tree, row, col, buf, NULL);
num = (int *)malloc (sizeof (int));
*num = epdf_index_item_page_get (etk_pdf_pdf_document_get (pdf), item);
etk_tree_row_data_set_full (prow, num, free);
free (buf);
c = epdf_index_item_children_get (item);
if (c) {
_tree_fill (pdf, tree, col, prow, c);
}
}
}
void
on_add_dialog_response(Etk_Dialog *dialog, int response_id, void *data)
{
const char *artist;
const char *album;
char *key;
Etk_Tree_Row *row;
if (response_id == ETK_RESPONSE_OK)
{
artist = etk_entry_text_get(ETK_ENTRY(entry_add_artist));
album = etk_entry_text_get(ETK_ENTRY(entry_add_album));
if (artist && strcmp(artist, "")
&& album && strcmp(album, ""))
{
asprintf(&key, "/%s/%s", artist, album);
row = etk_tree_row_append(ETK_TREE(tree), NULL,
etk_tree_nth_col_get(ETK_TREE(tree), 0),
key, NULL);
}
}
etk_entry_text_set(ETK_ENTRY(entry_add_artist), "");
etk_entry_text_set(ETK_ENTRY(entry_add_album), "");
etk_widget_hide_all(ETK_WIDGET(dialog));
}
void etk_file_cache_dialog_refresh(Etk_Widget* tree)
{
Etk_Tree_Col* col1;
Etk_Tree_Col* col2;
char* key;
char buffer[PATH_MAX];
Ecore_List* keys;
etk_tree_clear(ETK_TREE(tree));
/*Populate the tree*/
col1 = etk_tree_nth_col_get(ETK_TREE(tree), 0);
col2 = etk_tree_nth_col_get(ETK_TREE(tree), 1);
etk_tree_freeze(ETK_TREE(tree));
keys = entropy_core_file_cache_keys_retrieve();
while ( (key = ecore_list_first_remove(keys))) {
entropy_file_listener* listen = entropy_core_file_cache_retrieve(key);
if (listen) {
snprintf(buffer, PATH_MAX, "%s/%s", listen->file->path, listen->file->filename);
etk_tree_row_append(ETK_TREE(tree), NULL,
col1, listen->count,
col2, buffer,
NULL);
}
}
ecore_list_destroy(keys);
etk_tree_thaw(ETK_TREE(tree));
}
static void
process_message(gpointer _message, gpointer _data)
{
GValueArray *message = (GValueArray *) _message;
struct MessageListViewData *data = (struct MessageListViewData *) _data;
GHashTable *details =
g_value_get_boxed(g_value_array_get_nth(message, 4));
long timestamp =
g_value_get_long(g_hash_table_lookup(details, "timestamp_int"));
char datestr[32];
strftime(datestr, 31, "%e.%m.%Y, %H:%M", localtime(×tamp));
GHashTable *parameters = g_hash_table_new(NULL, NULL);
g_hash_table_insert(parameters, strdup("number"),
strdup(phonegui_contact_cache_lookup((char *)
g_value_get_string
(g_value_array_get_nth
(message,
2)))));
char *content =
strdup(g_value_get_string(g_value_array_get_nth(message, 3)));
string_replace_newline(content);
g_hash_table_insert(parameters, strdup("content"), content);
g_hash_table_insert(parameters, strdup("date"), strdup(datestr));
Etk_Tree_Row *row =
etk_tree_row_append(ETK_TREE(data->tree), NULL, data->col1,
parameters, NULL);
etk_tree_row_data_set(row, g_value_array_copy(message));
}
void
data_window_populate(void)
{
Eina_List *l, *datas;
Etk_Tree_Col *col1, *col2;
// FIXME type of data ?
char *data;
col1 = etk_tree_nth_col_get(ETK_TREE(UI_DataList), 0);
col2 = etk_tree_nth_col_get(ETK_TREE(UI_DataList), 1);
etk_tree_freeze(ETK_TREE(UI_DataList));
etk_tree_clear(ETK_TREE(UI_DataList));
datas = edje_edit_data_list_get(edje_o);
EINA_LIST_FOREACH(datas, l , data)
{
const char *val;
val = edje_edit_data_value_get(edje_o, data);
etk_tree_row_append(ETK_TREE(UI_DataList), NULL,
col1, data,
col2, val,
NULL);
edje_edit_string_free(val);
}
edje_edit_string_list_free(datas);
etk_tree_thaw(ETK_TREE(UI_DataList));
etk_widget_disabled_set(UI_DataApplyButton, ETK_TRUE);
etk_entry_text_set(ETK_ENTRY(UI_DataNameEntry), "");
etk_entry_text_set(ETK_ENTRY(UI_DataValueEntry), "");
}
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;
}/*}}}*/
static void
frame_recipient_process_recipient(gpointer _properties, gpointer _data)
{
GHashTable *properties = (GHashTable *) _properties;
struct MessageNewViewData *data = (struct MessageNewViewData *) _data;
Etk_Tree_Row *row =
etk_tree_row_append(ETK_TREE(data->tree_recipients), NULL,
data->col1_recipients, properties, NULL);
etk_tree_row_data_set(row, properties);
}
void bootpanel_add_interface(char* interface, boot_panel* pnl)
{
int checked;
EXALT_ASSERT_RETURN_VOID(interface!=NULL);
EXALT_ASSERT_RETURN_VOID(pnl!=NULL);
checked = exalt_dbus_bootprocess_iface_is(exalt_conn, interface);
etk_tree_row_append(ETK_TREE(pnl->eth_list), NULL,
pnl->eth_col0,checked,interface ,
NULL);
}
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;
}
void
fill_tree_with_db(Etk_Tree *tree)
{
int num, i;
char **entries;
char *cover_path;
Etk_Tree_Col *col;
Etk_Tree_Row *row;
Eet_File *ef;
char *cover_db_path;
asprintf(&cover_db_path, "%s/.e/apps/emphasis/cover.eet", getenv("HOME"));
ef = eet_open(cover_db_path, EET_FILE_MODE_READ);
if (!ef)
{
fprintf(stderr, "Can't open %s\n", cover_db_path);
free(cover_db_path);
exit(-1);
}
col = etk_tree_col_new(tree, "/artist/album", 0, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(tree);
etk_tree_freeze(tree);
entries = eet_list(ef, "*", &num);
for (i=0; i<num; i++)
{
cover_path = eet_read(ef, entries[i], NULL);
row = etk_tree_row_append(tree, NULL, col, entries[i], NULL);
if (strcmp("not found", cover_path))
{
etk_tree_row_data_set(row, cover_path);
}
else
{
etk_tree_row_data_set(row, NULL);
}
}
eet_close(ef);
free(cover_db_path);
etk_tree_col_sort_set(etk_tree_nth_col_get(tree, 0), tree_sort, NULL);
etk_tree_thaw(tree);
}
/* 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;
}
void layout_etk_simple_add_header(entropy_gui_component_instance* instance, Entropy_Config_Structure* structure_obj)
{
void *(*structure_plugin_init) (entropy_core * core,
entropy_gui_component_instance *,
void* parent_visual,
void *data);
entropy_plugin *structure;
entropy_generic_file* file;
Etk_Tree_Row* row;
Etk_Tree_Col* col;
entropy_layout_gui* gui = instance->data;
char* icon_string = NULL;
Ecore_List* layouts;
_layout_etk_row_structure_plugin* struct_ref = NULL;
col = etk_tree_nth_col_get(ETK_TREE(gui->tree), 0);
/*Parse the file from the URI*/
file = entropy_core_parse_uri (structure_obj->uri);
printf("Object for %s/%s is %p....\n", file->path, file->filename, file);
/*This will be moved to a central function. TODO*/
if (!strcmp(file->uri_base, "file"))
icon_string = PACKAGE_DATA_DIR "/icons/local-system.png";
else if (!strcmp(file->uri_base, "smb"))
icon_string = PACKAGE_DATA_DIR "/icons/samba-system.png";
else if (!strcmp(file->uri_base,"sftp"))
icon_string = PACKAGE_DATA_DIR "/icons/sftp-system.png";
else if (!strcmp(file->uri_base,"vfolder"))
icon_string = PACKAGE_DATA_DIR "/icons/vfolder-system.png";
etk_tree_freeze(ETK_TREE(gui->tree));
row = etk_tree_row_append(ETK_TREE(gui->tree), NULL, col,
icon_string, NULL, structure_obj->name, NULL);
etk_tree_thaw(ETK_TREE(gui->tree));
structure = entropy_plugins_type_get_first(ENTROPY_PLUGIN_GUI_COMPONENT,ENTROPY_PLUGIN_GUI_COMPONENT_STRUCTURE_VIEW);
structure_plugin_init =
dlsym (structure->dl_ref, "entropy_plugin_gui_instance_new");
/*We shouldn't really assume it's a folder - but it bootstraps us for
* now- FIXME*/
strcpy(file->mime_type, "file/folder");
file->filetype = FILE_FOLDER;
if (!strlen (file->mime_type)) {
entropy_mime_file_identify (file);
}
instance = (*structure_plugin_init)(instance->core, instance, row,file);
instance->plugin = structure;
/*Add to tracker*/
ecore_hash_set(_etk_layout_row_reference, row, structure_obj);
printf ("LOADED: %s/%s\n", file->path, file->filename);
/*Add to layout/plugin tracker - this is to destroy if the user removes a location*/
if (! (layouts = ecore_hash_get(_etk_layout_structure_plugin_reference, structure_obj))) {
layouts = ecore_list_new();
ecore_hash_set(_etk_layout_structure_plugin_reference, structure_obj, layouts);
}
struct_ref = entropy_malloc(sizeof(_layout_etk_row_structure_plugin));
struct_ref->row = row;
struct_ref->structure_plugin = structure;
ecore_list_append(layouts, struct_ref);
}
int
main (int argc, char *argv[])
{
Etk_Widget *window;
Etk_Widget *hpaned, *vpaned;
Etk_Widget *tree;
Etk_Widget *list;
Etk_Widget *pdf;
Etk_Tree_Col *col;
Etk_Tree_Row *row;
Ecore_List *index;
Epdf_Document *document;
int page_count;
int i;
if (argc == 1) {
printf ("Usage: %s pdf_file\n", argv[0]);
return -1;
}
etk_init (argc, argv);
/* We open the pdf file */
pdf = etk_pdf_new ();
etk_pdf_file_set (ETK_PDF (pdf), argv[1]);
document = ETK_PDF (pdf)->pdf_document;
if (!document) {
printf ("The file %s can't be opened\n", argv[1]);
etk_shutdown ();
return -1;
}
window = etk_window_new ();
etk_window_title_set (ETK_WINDOW (window), "Etk Pdf Test Application");
etk_signal_connect ("delete-event", ETK_OBJECT (window),
ETK_CALLBACK(_quit_cb), NULL);
hpaned = etk_hpaned_new();
etk_container_add (ETK_CONTAINER (window), hpaned);
etk_widget_show (hpaned);
vpaned = etk_vpaned_new();
etk_paned_child1_set (ETK_PANED (hpaned), vpaned, 0);
etk_widget_show (vpaned);
index = etk_pdf_pdf_index_get (ETK_PDF (pdf));
if (index) {
Etk_Tree_Col *col;
tree = etk_tree_new ();
etk_tree_mode_set (ETK_TREE (tree), ETK_TREE_MODE_TREE);
etk_tree_multiple_select_set (ETK_TREE (tree), ETK_FALSE);
/* column */
col = etk_tree_col_new (ETK_TREE (tree), "Index", 130, 0.0);
etk_tree_col_model_add (col, etk_tree_model_text_new());
etk_tree_build (ETK_TREE (tree));
/* rows */
_tree_fill (ETK_PDF (pdf), ETK_TREE (tree), col, NULL, index);
epdf_index_delete (index);
/* change page */
etk_signal_connect ("row-clicked", ETK_OBJECT (tree),
ETK_CALLBACK(_change_page_cb), pdf);
/* we attach and show */
etk_paned_child1_set (ETK_PANED (vpaned), tree, 0);
etk_widget_show (tree);
}
list = etk_tree_new ();
etk_tree_headers_visible_set (ETK_TREE (list), ETK_FALSE);
etk_tree_mode_set (ETK_TREE (list), ETK_TREE_MODE_LIST);
etk_tree_multiple_select_set (ETK_TREE (list), ETK_FALSE);
/* column */
col = etk_tree_col_new (ETK_TREE (list), "", 60, 0.0);
etk_tree_col_model_add (col, etk_tree_model_int_new());
etk_tree_build (ETK_TREE (list));
/* rows */
page_count = epdf_document_page_count_get (ETK_PDF (pdf)->pdf_document);
for (i = 0; i < page_count; i++) {
int *num;
row = etk_tree_row_append (ETK_TREE (list), NULL, col, i + 1, NULL);
num = (int *)malloc (sizeof (int));
*num = i;
etk_tree_row_data_set_full (row, num, free);
}
/* change page */
etk_signal_connect ("row-clicked", ETK_OBJECT (list),
ETK_CALLBACK(_change_page_cb), pdf);
/* we attach and show */
etk_paned_child2_set (ETK_PANED (vpaned), list, 0);
etk_widget_show (list);
etk_pdf_scale_set (ETK_PDF (pdf), 0.5, 0.5);
etk_paned_child2_set (ETK_PANED (hpaned), pdf, 1);
etk_widget_show (pdf);
etk_widget_show (window);
etk_main ();
etk_shutdown ();
return 0;
}
/* Creates the window for the tree test */
void etk_test_tree_window_create(void *data)
{
static Etk_Widget *win = NULL;
Etk_Widget *vbox;
Etk_Widget *hbox;
Etk_Widget *tree;
Etk_Widget *button;
Etk_Tree_Col *col1, *col2, *col3, *col4, *col5, *col6;
Etk_Tree_Row *row;
Etk_Widget *statusbar;
Etk_Color c_warn;
char row_name[128];
const char *stock_key;
int i, j;
if (win)
{
etk_widget_show(ETK_WIDGET(win));
return;
}
/* Create the window and the vbox where the widgets will be packed into */
win = etk_window_new();
etk_window_title_set(ETK_WINDOW(win), "Etk Tree Test");
etk_window_resize(ETK_WINDOW(win), 640, 500);
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, 0);
etk_container_add(ETK_CONTAINER(win), vbox);
/* Create the tree widget */
tree = etk_tree_new();
etk_tree_mode_set(ETK_TREE(tree), ETK_TREE_MODE_TREE);
etk_scrolled_view_extra_vmargin_set(etk_tree_scrolled_view_get(ETK_TREE(tree)), 250);
etk_scrolled_view_drag_bouncy_set(etk_tree_scrolled_view_get(ETK_TREE(tree)), ETK_BOUNCY_STOPTOOBJECT);
etk_scrolled_view_dragable_set(etk_tree_scrolled_view_get(ETK_TREE(tree)), ETK_TRUE);
etk_tree_multiple_select_set(ETK_TREE(tree), ETK_TRUE);
etk_widget_padding_set(tree, 5, 5, 5, 5);
etk_box_append(ETK_BOX(vbox), tree, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 0);
/* We first create the columns of the tree, and then we "build" the tree with etk_tree_build() */
col1 = etk_tree_col_new(ETK_TREE(tree), "Column 1", 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());
col2 = etk_tree_col_new(ETK_TREE(tree), "Column 2", 60, 1.0);
etk_tree_col_model_add(col2, etk_tree_model_double_new());
col3 = etk_tree_col_new(ETK_TREE(tree), "Column 3", 80, 0.75);
etk_tree_col_model_add(col3, etk_tree_model_int_new());
col4 = etk_tree_col_new(ETK_TREE(tree), "Column 4", 60, 0.0);
etk_tree_col_model_add(col4, etk_tree_model_image_new());
col5 = etk_tree_col_new(ETK_TREE(tree), "Column 5", 60, 0.5);
etk_tree_col_model_add(col5, etk_tree_model_checkbox_new());
col6 = etk_tree_col_new(ETK_TREE(tree), "Column 6", 60, 0.0);
etk_tree_col_model_add(col6, etk_tree_model_progress_bar_new());
etk_tree_build(ETK_TREE(tree));
/* Then we add the rows to the tree. etk_tree_freeze/thaw() is used to improve
* the speed when you insert a lot of rows. It is not really important if you
* insert only some thousands of rows (here, we insert 3000 rows) */
etk_tree_freeze(ETK_TREE(tree));
etk_theme_color_get(NULL, ETK_COLOR_WARNING_FG, &c_warn.r, &c_warn.g, &c_warn.b, &c_warn.a);
for (i = 0; i < 1000; i++)
{
sprintf(row_name, "Row %d", (i * 3) + 1);
stock_key = etk_stock_key_get(ETK_STOCK_PLACES_USER_HOME, ETK_STOCK_SMALL);
row = etk_tree_row_append(ETK_TREE(tree), NULL,
col1, etk_theme_icon_path_get(), stock_key, row_name,
col2, 0.57,
col3, rand(),
col4, PACKAGE_DATA_DIR "/images/1star.png", NULL,
col5, ETK_FALSE,
col6, 0.57, "57 %",
NULL);
for (j = 0; j < 3; j++)
{
Etk_Tree_Row *current;
sprintf(row_name, "Row %d", (i * 3) + 2);
stock_key = etk_stock_key_get(ETK_STOCK_PLACES_FOLDER, ETK_STOCK_SMALL);
current = etk_tree_row_append(ETK_TREE(tree), row,
col1, etk_theme_icon_path_get(), stock_key, row_name,
col2, 20.0,
col3, rand(),
col4, PACKAGE_DATA_DIR "/images/2stars.png", NULL,
col5, ETK_TRUE,
col6, 0.20, "20 %",
NULL);
if (j == 2) row = current;
}
sprintf(row_name, "<font color=#%.2X%.2X%.2X%.2X>Row %d</font>",
c_warn.r, c_warn.g, c_warn.b, c_warn.a, (i * 3) + 3);
stock_key = etk_stock_key_get(ETK_STOCK_TEXT_X_GENERIC, ETK_STOCK_SMALL);
etk_tree_row_append(ETK_TREE(tree), row,
col1, etk_theme_icon_path_get(), stock_key, row_name,
col2, 300.0,
col3, 257,
col4, PACKAGE_DATA_DIR "/images/3stars.png", NULL,
col5, ETK_TRUE,
NULL);
}
etk_tree_thaw(ETK_TREE(tree));
etk_tree_col_sort_set(col3, _etk_test_tree_compare_cb, NULL);
hbox = etk_hbox_new(ETK_TRUE, 0);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_FILL, 0);
button = etk_button_new_with_label("Sort the tree");
etk_box_append(ETK_BOX(hbox), button, ETK_BOX_START, ETK_BOX_EXPAND, 0);
etk_signal_connect_by_code(ETK_BUTTON_CLICKED_SIGNAL, ETK_OBJECT(button),
ETK_CALLBACK(_etk_test_tree_sort_button_cb), col3);
button = etk_button_new_with_label("Insert a sorted row");
etk_box_append(ETK_BOX(hbox), button, ETK_BOX_START, ETK_BOX_EXPAND, 0);
etk_signal_connect_by_code(ETK_BUTTON_CLICKED_SIGNAL, ETK_OBJECT(button),
ETK_CALLBACK(_etk_test_tree_insert_sorted_button_cb), ETK_TREE(tree));
button = etk_button_new_with_label("Select all");
etk_box_append(ETK_BOX(hbox), button, ETK_BOX_START, ETK_BOX_EXPAND, 0);
etk_signal_connect_by_code(ETK_BUTTON_CLICKED_SIGNAL, ETK_OBJECT(button),
ETK_CALLBACK(_etk_test_tree_select_all_cb), ETK_TREE(tree));
button = etk_button_new_with_label("Unselect all");
etk_box_append(ETK_BOX(hbox), button, ETK_BOX_START, ETK_BOX_EXPAND, 0);
etk_signal_connect_by_code(ETK_BUTTON_CLICKED_SIGNAL, ETK_OBJECT(button),
ETK_CALLBACK(_etk_test_tree_unselect_all_cb), ETK_TREE(tree));
/* Finally we create the statusbar used to display the events on the tree */
statusbar = etk_statusbar_new();
etk_box_append(ETK_BOX(vbox), statusbar, ETK_BOX_START, ETK_BOX_FILL, 0);
etk_signal_connect_by_code(ETK_WIDGET_KEY_DOWN_SIGNAL, ETK_OBJECT(tree),
ETK_CALLBACK(_etk_test_tree_key_down_cb), NULL);
etk_signal_connect_by_code(ETK_TREE_ROW_CLICKED_SIGNAL, ETK_OBJECT(tree),
ETK_CALLBACK(_etk_test_tree_row_clicked_cb), statusbar);
etk_signal_connect_by_code(ETK_TREE_COL_CELL_VALUE_CHANGED_SIGNAL, ETK_OBJECT(col5),
ETK_CALLBACK(_etk_test_tree_checkbox_toggled_cb), statusbar);
etk_widget_show_all(win);
}
void mainWindow_eth_cb(exalt_ethernet* eth, int action, void* user_data)
{/*{{{*/
char wireless_img[] = PACKAGE_DATA_DIR ICONS_WIRELESS_ACTIVATE;
char wireless_img_not_activate[] = PACKAGE_DATA_DIR ICONS_WIRELESS_NOT_ACTIVATE;
char eth_img[] = PACKAGE_DATA_DIR ICONS_ETHERNET_ACTIVATE;
char eth_img_not_activate[] = PACKAGE_DATA_DIR ICONS_ETHERNET_NOT_ACTIVATE;
main_window* win = (main_window*) user_data;
if(action == EXALT_ETH_CB_NEW)
{
char* img;
if(exalt_eth_is_wireless(eth))
{
if(exalt_eth_is_activate(eth) && exalt_wireless_raddiobutton_ison(exalt_eth_get_wireless(eth)))
img = wireless_img;
else
img = wireless_img_not_activate;
}
else if(exalt_eth_is_activate(eth))
img = eth_img;
else
img = eth_img_not_activate;
etk_tree_row_append(ETK_TREE(win->eth_list), NULL,
win->eth_col0,img,NULL,exalt_eth_get_name(eth) ,
NULL);
}
else if(action == EXALT_ETH_CB_REMOVE)
{
Etk_Tree_Row* row;
row = mainWindow_findrow(win, eth);
if(row)
etk_tree_row_delete(row);
}
else if(action == EXALT_ETH_CB_ACTIVATE || EXALT_ETH_CB_DEACTIVATE || EXALT_ETH_CB_WIRELESS_RADIO_ON || EXALT_ETH_CB_WIRELESS_RADIO_OFF)
{
Etk_Tree_Row *row;
row = mainWindow_findrow(win, eth);
if(row)
{
if(exalt_eth_is_wireless(eth))
{
short radio;
radio = exalt_wireless_raddiobutton_ison(exalt_eth_get_wireless(eth));
if(radio && exalt_eth_is_activate(eth))
etk_tree_row_fields_set(row, 0, win->eth_col0,wireless_img,NULL,exalt_eth_get_name(eth), NULL);
else
etk_tree_row_fields_set(row, 0, win->eth_col0,wireless_img_not_activate,NULL,exalt_eth_get_name(eth), NULL);
}
else
if(exalt_eth_is_activate(eth))
etk_tree_row_fields_set(row, 0, win->eth_col0,eth_img,NULL,exalt_eth_get_name(eth), NULL);
else
etk_tree_row_fields_set(row, 0, win->eth_col0,eth_img_not_activate,NULL,exalt_eth_get_name(eth), NULL);
}
//update the panel
eth_panel* pnl = win->eth_panel;
if(pnl->eth == eth)
ethpanel_set_eth(pnl,eth);
//update the wireless panel
wireless_panel* wpnl = win->wireless_panel;
if(wpnl->eth == eth)
wirelesspanel_set_eth(wpnl,eth);
}
}/*}}}*/
