void expandRow(GtkTreeView* treeview,GtkTreeIter* iter,GtkTreePath* path,gpointer user_data)
{
GtkTreeModel* model;
bool gotchild;
GtkTreeIter childiter;
char* folder;
GtkTreeIter* cleariter;
GtkTreeIter childchild;
model=gtk_tree_view_get_model(treeview);
gotchild=gtk_tree_model_iter_children(model,&childiter,iter);
gtk_tree_model_get(model,iter,COLUMN_PATHNAME,&folder,-1);
cleariter=gtk_tree_iter_copy(&childiter);
gtk_tree_model_iter_next(model,cleariter);
if(gtk_tree_store_iter_is_valid((GtkTreeStore*)store,cleariter))
while(gtk_tree_store_remove((GtkTreeStore*)store,cleariter));
cleariter=gtk_tree_iter_copy(&childiter);
gtk_tree_model_iter_children(model,&childchild,cleariter);
if(gtk_tree_store_iter_is_valid((GtkTreeStore*)store,&childchild))
gtk_tree_store_remove((GtkTreeStore*)store,&childchild);
while(gotchild)
{
if(addContents(treeview,&childiter,(char*)folder))
gotchild=gtk_tree_model_iter_next(model,&childiter);
else
gotchild=false;
}
flag=true;
}
static gboolean
find_iter_for_book (AddressBookWindow *self,
Ekiga::BookPtr book,
GtkTreeIter *iter)
{
Ekiga::Book *book_iter = NULL;
GtkTreeModel *store = NULL;
store = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->tree_view));
if (gtk_tree_model_get_iter_first (store, iter)) {
while (gtk_tree_store_iter_is_valid (GTK_TREE_STORE (store), iter)) {
gtk_tree_model_get (store, iter,
COLUMN_BOOK_POINTER, &book_iter,
-1);
if (book.get () == book_iter) {
break;
}
if (!gtk_tree_model_iter_next (store, iter))
return FALSE;
}
return gtk_tree_store_iter_is_valid (GTK_TREE_STORE (store), iter);
}
return FALSE;
}
/* clear extra buttons to N/A and if model then set those as white */
extern void post_setup_popup_grid_list(popup_info_t *popup_win)
{
/* refresh the pointer */
if (popup_win->model
&& gtk_tree_store_iter_is_valid(GTK_TREE_STORE(popup_win->model),
&popup_win->iter)) {
gtk_tree_model_get(popup_win->model, &popup_win->iter,
popup_win->node_inx_id,
&popup_win->node_inx, -1);
} else {
popup_win->node_inx = NULL;
}
if (popup_win->node_inx) {
int j=0;
while (popup_win->node_inx[j] >= 0) {
change_grid_color(
popup_win->grid_button_list,
popup_win->node_inx[j],
popup_win->node_inx[j+1], MAKE_WHITE, true, 0);
j += 2;
}
}
change_grid_color(popup_win->grid_button_list, -1, -1,
MAKE_BLACK, true, NODE_STATE_IDLE);
}
static void
on_tv_cur_changed (GtkTreeView *treeview, gpointer data)
{
GtkTreeIter iter;
gchar *parsename = NULL;
gtk_tree_selection_get_selected (gtk_tree_view_get_selection (treeview), NULL, &iter);
if (gtk_tree_store_iter_is_valid (baobab.model, &iter)) {
gtk_tree_model_get (GTK_TREE_MODEL (baobab.model), &iter,
COL_H_PARSENAME, &parsename, -1);
}
}
static void cm_tree_drag_data_get_cb(GtkWidget *widget, GdkDragContext *drag_context,
GtkSelectionData *data, guint info, guint ltime,
CookieManagerPage *cmp)
{
GtkTreeIter iter, iter_store;
GtkTreeSelection *selection;
GtkTreeModel *model;
GList *rows;
CookieManagerPagePrivate *priv = cmp->priv;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview));
rows = gtk_tree_selection_get_selected_rows(selection, &model);
if (cm_list_length(rows) != 1)
{
cm_free_selection_list(rows, (GFunc) gtk_tree_path_free);
return;
}
/* get iter */
gtk_tree_model_get_iter(model, &iter, (GtkTreePath*) (g_list_nth_data(rows, 0)));
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(model), &iter_store, &iter);
if (gtk_tree_store_iter_is_valid(priv->store, &iter_store))
{
SoupCookie *cookie;
gchar *name;
const gchar *text;
gtk_tree_model_get(model, &iter,
COOKIE_MANAGER_COL_NAME, &name,
COOKIE_MANAGER_COL_COOKIE, &cookie,
-1);
if (name != NULL)
{
GtkTreeIter parent;
/* get the name of the parent item which should be a domain item */
if (cookie != NULL && gtk_tree_model_iter_parent(model, &parent, &iter))
{
g_free(name);
gtk_tree_model_get(model, &parent, COOKIE_MANAGER_COL_NAME, &name, -1);
}
text = cm_skip_leading_dot(name);
gtk_selection_data_set_text(data, text, -1);
}
g_free(name);
}
}
int
clip_GTK_TREESTOREITERISVALID(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
C_object *citer = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKCOBJ(citer, GTK_IS_TREE_ITER(citer->object));
gtk_tree_store_iter_is_valid(GTK_TREE_STORE(cstree->object), GTK_TREE_ITER(citer->object));
return 0;
err:
return 1;
}
static void
update_days_and_lines_for_log (LogviewLoglist *loglist,
GtkTreeIter *log, GSList *days)
{
gboolean res;
GtkTreeIter iter, dummy;
GSList *l;
int i;
char date[200];
Day *day;
/* if we have some days, we can't remove all the items immediately, otherwise,
* if the row is expanded, it will be collapsed because there are no items,
* so we create a dummy entry, remove all the others and then remove the
* dummy one.
*/
res = gtk_tree_model_iter_children (GTK_TREE_MODEL (loglist->priv->model),
&iter, log);
if (res) {
gtk_tree_store_insert_before (loglist->priv->model, &dummy, log, &iter);
gtk_tree_store_set (loglist->priv->model, &dummy,
LOG_NAME, "", -1);
do {
gtk_tree_store_remove (loglist->priv->model, &iter);
} while (gtk_tree_store_iter_is_valid (loglist->priv->model, &iter));
}
for (i = 1, l = days; l; l = l->next) {
/* now insert all the days */
day = l->data;
g_date_strftime (date, 200, "%A, %e %b", day->date);
gtk_tree_store_insert (GTK_TREE_STORE (loglist->priv->model),
&iter, log, i);
gtk_tree_store_set (GTK_TREE_STORE (loglist->priv->model),
&iter, LOG_NAME, date, LOG_DAY, day, -1);
i++;
}
if (res) {
gtk_tree_store_remove (loglist->priv->model, &dummy);
}
}
void gtkui_cheats_remove(GtkWidget *widget, gpointer userdata) {
// Remove a cheat from the list
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
// Get the selected item
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_get_selected(selection, &model, &iter);
// Remove the cheat
if (gtk_tree_store_iter_is_valid(treestore, &iter)) {
gtk_tree_store_remove(treestore, &iter);
}
//Re-initialize the cheats
Cheats cheats(emulator);
cheats.ClearCodes();
gtk_tree_model_foreach(GTK_TREE_MODEL(model), gtkui_cheats_scan_list, NULL);
}
void
vol_store_voladj(GtkTreeStore * store, GtkTreeIter * iter, float voladj) {
if (!gtk_tree_store_iter_is_valid(store, iter)) {
return;
}
if (store == music_store) { /* music store */
track_data_t * data;
gtk_tree_model_get(GTK_TREE_MODEL(music_store), iter, MS_COL_DATA, &data, -1);
data->volume = voladj;
music_store_mark_changed(iter);
} else { /* playlist */
playlist_data_t * data;
char str[32];
voladj2str(voladj, str);
gtk_tree_model_get(GTK_TREE_MODEL(store), iter, PL_COL_DATA, &data, -1);
data->voladj = voladj;
gtk_tree_store_set(store, iter, PL_COL_VADJ, str, -1);
}
}
static void
multi_notebook_tab_switched (GeditMultiNotebook *mnb,
GeditNotebook *old_notebook,
GeditTab *old_tab,
GeditNotebook *new_notebook,
GeditTab *new_tab,
GeditDocumentsPanel *panel)
{
gedit_debug (DEBUG_PANEL);
if (!panel->priv->setting_active_notebook &&
!_gedit_window_is_removing_tabs (panel->priv->window))
{
GtkTreeIter iter;
if (get_iter_from_tab (panel, new_notebook, new_tab, &iter) &&
gtk_tree_store_iter_is_valid (GTK_TREE_STORE (panel->priv->model), &iter))
{
select_iter (panel, &iter);
}
}
}
static VALUE
rg_iter_is_valid_p(VALUE self, VALUE iter)
{
return (NIL_P(iter)) ? Qfalse :
CBOOL2RVAL(gtk_tree_store_iter_is_valid(_SELF(self), RVAL2GTKTREEITER(iter)));
}
static gboolean
get_iter_from_tab (GeditDocumentsPanel *panel,
GeditNotebook *notebook,
GeditTab *tab,
GtkTreeIter *tab_iter)
{
GtkTreeIter parent;
gboolean success;
gboolean search_notebook;
/* Note: we cannot use the functions of the MultiNotebook
* because in cases where the notebook or tab has been
* removed already we will fail to get an iter.
*/
gedit_debug (DEBUG_PANEL);
g_assert (notebook != NULL);
/* tab may be NULL if just the notebook is specified */
g_assert (tab_iter != NULL);
search_notebook = (gedit_multi_notebook_get_n_notebooks (panel->priv->mnb) > 1);
if (!gtk_tree_model_get_iter_first (panel->priv->model, &parent))
return FALSE;
success = FALSE;
do
{
GtkTreeIter iter;
if (search_notebook)
{
GeditNotebook *current_notebook;
gtk_tree_model_get (panel->priv->model,
&parent,
NOTEBOOK_COLUMN, ¤t_notebook,
-1);
if (current_notebook != NULL)
{
gboolean is_cur;
is_cur = (current_notebook == notebook);
g_object_unref (current_notebook);
if (is_cur)
{
/* notebook found */
search_notebook = FALSE;
gtk_tree_model_iter_children (panel->priv->model, &iter, &parent);
}
}
}
else
{
iter = parent;
}
if (!search_notebook)
{
if (tab == NULL)
{
success = TRUE;
break;
}
g_assert (gtk_tree_store_iter_is_valid (GTK_TREE_STORE (panel->priv->model),
&iter));
do
{
GeditTab *current_tab;
gtk_tree_model_get (panel->priv->model,
&iter,
TAB_COLUMN, ¤t_tab,
-1);
if (current_tab != NULL)
{
gboolean is_cur;
is_cur = (current_tab == tab);
g_object_unref (current_tab);
if (is_cur)
{
*tab_iter = iter;
success = TRUE;
/* break 2; */
goto out;
}
}
} while (gtk_tree_model_iter_next (panel->priv->model, &iter));
/* We already found the notebook and the tab was not found */
g_assert (!success);
}
} while (gtk_tree_model_iter_next (panel->priv->model, &parent));
out:
return success;
}
static void cm_tree_selection_changed_cb(GtkTreeSelection *selection, CookieManagerPage *cmp)
{
GList *rows;
GtkTreeIter iter, iter_store;
GtkTreeModel *model;
gchar *text, *name;
gboolean valid = TRUE;
gboolean delete_possible = TRUE;
guint rows_len;
SoupCookie *cookie;
CookieManagerPagePrivate *priv = cmp->priv;
rows = gtk_tree_selection_get_selected_rows(selection, &model);
rows_len = cm_list_length(rows);
if (rows_len == 0)
{
valid = FALSE;
delete_possible = FALSE;
}
else if (rows_len == 1)
{
/* get iter */
gtk_tree_model_get_iter(model, &iter, (GtkTreePath*) (g_list_nth_data(rows, 0)));
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model),
&iter_store, &iter);
}
else
valid = FALSE;
if (valid && gtk_tree_store_iter_is_valid(priv->store, &iter_store))
{
gtk_tree_model_get(model, &iter, COOKIE_MANAGER_COL_COOKIE, &cookie, -1);
if (cookie != NULL)
{
text = cm_get_cookie_description_text(cookie);
gtk_label_set_markup(GTK_LABEL(priv->desc_label), text);
g_free(text);
}
else
{
gtk_tree_model_get(model, &iter, COOKIE_MANAGER_COL_NAME, &name, -1);
if (name != NULL)
{
gint cookie_count = gtk_tree_model_iter_n_children(model, &iter);
text = cm_get_domain_description_text(name, cookie_count);
gtk_label_set_markup(GTK_LABEL(priv->desc_label), text);
g_free(text);
g_free(name);
}
}
}
/* This is a bit hack'ish but we add some empty lines to get a minimum height of the
* label at the bottom without any font size calculation. */
if (! valid)
gtk_label_set_text(GTK_LABEL(priv->desc_label), CM_EMPTY_LABEL_TEXT);
cm_set_button_sensitiveness(cmp, delete_possible);
cm_free_selection_list(rows, (GFunc) gtk_tree_path_free);
}
gboolean write_menu_conf( xmlTextWriterPtr writer,
GtkTreeStore *menu_tree, GtkTreeIter *iterator )
{
gboolean return_value = FALSE;
gboolean include_open = FALSE;
gchar *name = NULL;
gchar *desktop_id = NULL;
gboolean default_category;
/* Make sure we have a valid iterator */
if (!gtk_tree_store_iter_is_valid( menu_tree, iterator) ) {
g_warning( "write_menu_conf: invalid iterator." );
return FALSE;
}
/* Loop through the model */
do {
gtk_tree_model_get( GTK_TREE_MODEL( menu_tree ), iterator,
TREE_MODEL_NAME,
&name,
TREE_MODEL_DESKTOP_ID,
&desktop_id,
TREE_MODEL_DEFAULT,
&default_category,
-1 );
if ( !desktop_id || strlen( desktop_id ) == 0 ) {
/* </Include> */
if ( include_open == TRUE ) {
if ( xmlTextWriterEndElement( writer ) < 0 ) {
g_warning( "write_menu_conf: "
"failed to end Include element." );
goto cleanup_and_exit;
} else {
#ifdef DEBUG
g_debug( "write_menu_conf: </Include>" );
#endif
}
include_open = FALSE;
}
/* <Menu> */
if ( xmlTextWriterStartElement( writer,
BAD_CAST "Menu" ) < 0 ) {
g_warning( "write_menu_conf: "
"failed to start Menu element." );
goto cleanup_and_exit;
} else {
#ifdef DEBUG
g_debug( "write_menu_conf: <Menu>" );
#endif
}
/* <Name> ... </Name> */
if ( xmlTextWriterWriteElement( writer, (const xmlChar *) "Name", (const xmlChar *) name ) < 0 ) {
g_warning( "write_menu_conf: "
"failed to write Name element." );
goto cleanup_and_exit;
} else {
g_debug( "write_menu_conf: <Name>%s</Name>", name );
}
if (default_category)
{
g_debug ("%s is default", name);
xmlTextWriterWriteElement( writer, (const xmlChar *) "All", (const xmlChar *)"" );
}
GtkTreeIter child_iterator;
/* Has children.. */
if ( gtk_tree_model_iter_children( GTK_TREE_MODEL( menu_tree ),
&child_iterator, iterator ) ) {
/* Recurse */
if ( !write_menu_conf( writer, menu_tree,
&child_iterator ) ) {
g_warning( "write_menu_conf: failed to recurse." );
goto cleanup_and_exit;
}
}
/* </Menu> */
if ( xmlTextWriterEndElement( writer ) < 0 ) {
g_warning ( "write_menu_conf: "
"failed to end Menu element." );
goto cleanup_and_exit;
} else {
g_debug( "write_menu_conf: </Menu>" );
}
} else if ( desktop_id && strcmp( desktop_id,
SEPARATOR_STRING ) == 0 ) {
/* </Include> */
if ( include_open == TRUE ) {
if ( xmlTextWriterEndElement( writer ) < 0 ) {
g_warning( "write_menu_conf: "
"failed to end Include element." );
goto cleanup_and_exit;
} else {
g_debug( "write_menu_conf: </Include>" );
}
include_open = FALSE;
}
/* <Separator/> */
/* This returns -1 for some reason. But this seems to work
* and without this it doesn't work. Oh well.. */
xmlTextWriterWriteElement( writer, (const xmlChar *) "Separator", NULL );
xmlTextWriterEndElement( writer );
g_debug( "write_menu_conf: <Separator/>" );
} else if ( desktop_id && strlen ( desktop_id ) > 0 ) {
/* <Include> */
if ( include_open == FALSE ) {
if ( xmlTextWriterStartElement( writer,
BAD_CAST "Include") < 0 ) {
g_warning( "write_menu_conf: "
"failed to start Include element." );
goto cleanup_and_exit;
} else {
g_debug( "write_menu_conf: <Include>" );
}
include_open = TRUE;
}
/* <Filename> ... </Filename> */
if ( xmlTextWriterWriteElement( writer,
(const xmlChar *) "Filename", (const xmlChar *) desktop_id ) < 0 ) {
g_warning( "write_menu_conf: "
"failed to write Filename element." );
goto cleanup_and_exit;
} else {
g_debug( "write_menu_conf: "
"<Filename>%s</Filename>", desktop_id );
}
} else {
g_warning( "write_menu_conf: 'what happen?'"
" - 'somebody set us up the bomb!'" );
goto cleanup_and_exit;
}
if ( name ) {
g_free( name );
name = NULL;
}
if ( desktop_id ) {
g_free( desktop_id );
desktop_id = NULL;
}
} while ( gtk_tree_model_iter_next( GTK_TREE_MODEL( menu_tree ), iterator ) );
/* </Include> */
if ( include_open == TRUE ) {
if ( xmlTextWriterEndElement( writer ) < 0 ) {
g_warning( "write_menu_conf: "
"failed to end Include element." );
goto cleanup_and_exit;
} else {
g_debug( "write_menu_conf: </Include>" );
}
include_open = FALSE;
}
/* Great! Everything went fine! */
return_value = TRUE;
cleanup_and_exit:
if ( name ) {
g_free( name );
}
if ( desktop_id ) {
g_free( desktop_id );
}
return return_value;
}
static void read_menu_conf(const char *filename, GtkTreeStore *menu_tree,
xmlDocPtr doc, xmlNodePtr root_element, GtkTreeIter *iterator,
GList *desktop_files)
{
gboolean first_level = FALSE;
static GdkPixbuf *folder_icon = NULL;
static GdkPixbuf *folder_thumb_icon = NULL;
static GdkPixbuf *folder_open_icon = NULL;
static GdkPixbuf *folder_closed_icon = NULL;
static GdkPixbuf *emblem_expander_open = NULL;
static GdkPixbuf *emblem_expander_closed = NULL;
static GtkTreeIter extras_iter;
GList *l;
/* Get emblems */
if ( !emblem_expander_open ) {
emblem_expander_open = get_icon( EMBLEM_EXPANDER_OPEN, ICON_SIZE );
}
if ( !emblem_expander_closed ) {
emblem_expander_closed = get_icon( EMBLEM_EXPANDER_CLOSED, ICON_SIZE );
}
/* Get the folder icons */
if ( !folder_icon ) {
folder_icon = get_icon(ICON_FOLDER, ICON_SIZE);
folder_thumb_icon = get_icon_with_fallback(ICON_FOLDER,
ICON_THUMB_SIZE,
folder_icon);
}
if ( !folder_open_icon ) {
folder_open_icon = add_emblem_to_icon(
folder_icon, emblem_expander_open );
}
if ( !folder_closed_icon ) {
folder_closed_icon = add_emblem_to_icon(
folder_icon, emblem_expander_closed );
}
if (doc == NULL) {
doc = xmlReadFile(filename, NULL, 0);
if (doc == NULL) {
g_warning( "read_menu_conf: unable to read '%s'", filename );
goto check_unallocated;
}
first_level = TRUE;
}
if (root_element == NULL) {
root_element = xmlDocGetRootElement(doc);
if (root_element == NULL) {
#ifdef DEBUG
g_debug( "read_menu_conf: failed to get root element." );
#endif
xmlFreeDoc(doc);
goto check_unallocated;
}
}
if (xmlStrcmp(root_element->name, (const xmlChar *) "Menu") != 0) {
/* Not a menu */
#ifdef DEBUG
g_debug( "read_menu_conf: not a menu.");
#endif
xmlFreeDoc(doc);
goto check_unallocated;
}
xmlNodePtr current_element = NULL;
xmlChar *key;
GtkTreeIter child_iterator;
desktop_entry_t *item;
/* Loop through the elements and add to parent */
for (current_element = root_element->xmlChildrenNode;
current_element != NULL;
current_element = current_element->next) {
if (strcmp((const char *) current_element->name, "Menu") == 0) {
/* Submenu */
gtk_tree_store_append(menu_tree, &child_iterator, iterator);
read_menu_conf(filename,
menu_tree,
doc,
current_element,
&child_iterator,
desktop_files);
} else if (strcmp((const char *) current_element->name, "Name") == 0) {
key = xmlNodeListGetString(doc,
current_element->xmlChildrenNode,
1);
if (iterator &&
gtk_tree_store_iter_is_valid (menu_tree, iterator))
gtk_tree_store_set(menu_tree, iterator,
TREE_MODEL_NAME,
key,
TREE_MODEL_LOCALIZED_NAME,
dgettext (GETTEXT_PACKAGE,
(gchar *)key),
TREE_MODEL_ICON,
folder_icon,
TREE_MODEL_THUMB_ICON,
folder_thumb_icon,
TREE_MODEL_EMBLEM_EXPANDER_OPEN,
folder_open_icon,
TREE_MODEL_EMBLEM_EXPANDER_CLOSED,
folder_closed_icon,
TREE_MODEL_EXEC,
"",
TREE_MODEL_SERVICE,
"",
TREE_MODEL_DESKTOP_ID,
"",
TREE_MODEL_COMMENT,
"",
TREE_MODEL_DEFAULT,
FALSE,
-1);
xmlFree(key);
} else if (strcmp((char *)current_element->name, "All") == 0) {
extras_iter = *iterator;
gtk_tree_store_set (menu_tree, iterator,
TREE_MODEL_DEFAULT,
TRUE,
-1);
} else if (strcmp((const char *) current_element->name, "MergeFile") == 0) {
/* FIXME: skip this for now */
continue;
key = xmlNodeListGetString(doc,
current_element->xmlChildrenNode, 1);
/* Relative path. prepend current dir */
if (g_str_has_prefix((const char *) key, "/") == FALSE) {
key = (xmlChar *) g_build_path(G_DIR_SEPARATOR_S,
g_path_get_dirname(filename), key, NULL);
}
/* Recursion */
read_menu_conf((const char *) key, menu_tree, NULL, NULL, iterator, desktop_files);
xmlFree(key);
} else if (strcmp((const char *) current_element->name, "Include") == 0) {
xmlNodePtr child_element = NULL;
for (child_element = current_element->xmlChildrenNode;
child_element != NULL;
child_element = child_element->next) {
if (strcmp((const char *) child_element->name, "Filename") == 0) {
/* Get the children */
key = xmlNodeListGetString(doc,
child_element->xmlChildrenNode,
1);
if ( !key || strlen((const char *) key) == 0) {
xmlFree( key );
continue;
}
/* Get the contents */
item = get_desktop_item(desktop_files, (const char *) key);
if ( !item ) {
xmlFree( key );
continue;
}
add_desktop_entry(item, menu_tree, iterator);
xmlFree(key);
}
else if (strcmp((char *)child_element->name, "And") == 0) {
xmlNodePtr cat_element = NULL;
GSList *items, *i;
for (cat_element = child_element->xmlChildrenNode;
cat_element != NULL;
cat_element = cat_element->next) {
if (strcmp((char *)cat_element->name, "Category") != 0)
continue;
if (!cat_element->xmlChildrenNode)
continue;
key = xmlNodeListGetString(doc,
cat_element->xmlChildrenNode,
1);
items = get_desktop_entries_from_category (desktop_files,
(gchar*)key);
for (i = items ; i ; i = g_slist_next(i))
{
add_desktop_entry((desktop_entry_t *)i->data,
menu_tree,
iterator);
}
xmlFree(key);
}
}
}
} else if (strcmp((const char *) current_element->name, "Separator") == 0) {
GtkTreeIter child_iter;
gtk_tree_store_append(menu_tree,
&child_iter, iterator);
gtk_tree_store_set(menu_tree,
&child_iter,
TREE_MODEL_NAME,
SEPARATOR_STRING,
TREE_MODEL_ICON,
NULL,
TREE_MODEL_EMBLEM_EXPANDER_OPEN,
NULL,
TREE_MODEL_EMBLEM_EXPANDER_CLOSED,
NULL,
TREE_MODEL_THUMB_ICON,
NULL,
TREE_MODEL_EXEC,
SEPARATOR_STRING,
TREE_MODEL_SERVICE,
SEPARATOR_STRING,
TREE_MODEL_DESKTOP_ID,
SEPARATOR_STRING,
TREE_MODEL_COMMENT,
SEPARATOR_STRING,
TREE_MODEL_DEFAULT,
FALSE,
-1);
}
}
check_unallocated:
if ( first_level )
{
/* The doc handle was created in this call */
xmlFreeDoc(doc);
l = desktop_files;
while ( l ) {
desktop_entry_t *item;
item = l->data;
if ( item->allocated == FALSE ) {
/* Create the extras menu if it does not exist */
if ( !gtk_tree_store_iter_is_valid(menu_tree, &extras_iter ) ) {
gtk_tree_store_append( menu_tree,
&extras_iter,
NULL );
gtk_tree_store_set(menu_tree,
&extras_iter,
TREE_MODEL_NAME,
EXTRAS_MENU_STRING,
TREE_MODEL_LOCALIZED_NAME,
dgettext (GETTEXT_PACKAGE,
EXTRAS_MENU_STRING),
TREE_MODEL_ICON,
folder_icon,
TREE_MODEL_THUMB_ICON,
folder_thumb_icon,
TREE_MODEL_EMBLEM_EXPANDER_OPEN,
folder_open_icon,
TREE_MODEL_EMBLEM_EXPANDER_CLOSED,
folder_closed_icon,
TREE_MODEL_EXEC,
"",
TREE_MODEL_SERVICE,
"",
TREE_MODEL_DESKTOP_ID,
"",
TREE_MODEL_DEFAULT,
TRUE,
-1 );
}
add_desktop_entry( item, menu_tree, &extras_iter );
}
l = l->next;
}
/* We don't need our reference to the folder icon pixbuf anymore */
if ( folder_icon ) {
g_object_unref( G_OBJECT( folder_icon ) );
folder_icon = NULL;
}
if ( folder_thumb_icon ) {
g_object_unref( G_OBJECT( folder_thumb_icon ) );
folder_thumb_icon = NULL;
}
if ( folder_open_icon ) {
g_object_unref( G_OBJECT( folder_open_icon ) );
folder_open_icon = NULL;
}
if ( folder_closed_icon ) {
g_object_unref( G_OBJECT( folder_closed_icon ) );
folder_closed_icon = NULL;
}
}
return;
}
