static void bar_pane_keywords_edit_ok_cb(GenericDialog *gd, gpointer data)
{
ConfDialogData *cdd = data;
PaneKeywordsData *pkd = cdd->pkd;
GtkTreeModel *model;
GtkTreeModel *keyword_tree;
GtkTreeIter kw_iter;
gboolean have_dest = FALSE;
GList *keywords;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
if (cdd->click_tpath)
{
GtkTreeIter iter;
if (gtk_tree_model_get_iter(model, &iter, cdd->click_tpath))
{
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
have_dest = TRUE;
}
}
if (cdd->edit_existing && !have_dest) return;
keywords = keyword_list_pull(cdd->edit_widget);
if (cdd->edit_existing)
{
if (keywords && keywords->data && /* there should be one keyword */
!keyword_exists(keyword_tree, NULL, &kw_iter, keywords->data, TRUE, NULL))
{
keyword_set(GTK_TREE_STORE(keyword_tree), &kw_iter, keywords->data, cdd->is_keyword);
}
}
else
{
GList *work = keywords;
gboolean append_to = FALSE;
while (work)
{
GtkTreeIter add;
if (keyword_exists(keyword_tree, NULL, (have_dest || append_to) ? &kw_iter : NULL, work->data, FALSE, NULL))
{
work = work->next;
continue;
}
if (have_dest)
{
gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, &kw_iter);
}
else if (append_to)
{
gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, NULL, &kw_iter);
}
else
{
gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, NULL);
append_to = TRUE;
kw_iter = add;
}
keyword_set(GTK_TREE_STORE(keyword_tree), &add, work->data, cdd->is_keyword);
work = work->next;
}
}
string_list_free(keywords);
}
static void bar_pane_keywords_dnd_receive(GtkWidget *tree_view, GdkDragContext *context,
gint x, gint y,
GtkSelectionData *selection_data, guint info,
guint time, gpointer data)
{
PaneKeywordsData *pkd = data;
GtkTreePath *tpath = NULL;
GtkTreeViewDropPosition pos;
GtkTreeModel *model;
GtkTreeModel *keyword_tree;
gboolean src_valid = FALSE;
GList *new_keywords = NULL;
GList *work;
/* iterators for keyword_tree */
GtkTreeIter src_kw_iter;
GtkTreeIter dest_kw_iter;
GtkTreeIter new_kw_iter;
g_signal_stop_emission_by_name(tree_view, "drag_data_received");
model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), NULL, pos);
switch (info)
{
case TARGET_APP_KEYWORD_PATH:
{
GList *path = *(gpointer *)gtk_selection_data_get_data(selection_data);
src_valid = keyword_tree_get_iter(keyword_tree, &src_kw_iter, path);
string_list_free(path);
break;
}
default:
new_keywords = string_to_keywords_list((gchar *)gtk_selection_data_get_data(selection_data));
break;
}
if (tpath)
{
GtkTreeIter dest_iter;
gtk_tree_model_get_iter(model, &dest_iter, tpath);
gtk_tree_path_free(tpath);
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &dest_kw_iter, &dest_iter);
if (src_valid && gtk_tree_store_is_ancestor(GTK_TREE_STORE(keyword_tree), &src_kw_iter, &dest_kw_iter))
{
/* can't move to it's own child */
return;
}
if (src_valid && keyword_compare(keyword_tree, &src_kw_iter, &dest_kw_iter) == 0)
{
/* can't move to itself */
return;
}
if ((pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE || pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER) &&
!gtk_tree_model_iter_has_child(keyword_tree, &dest_kw_iter))
{
/* the node has no children, all keywords can be added */
gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &dest_kw_iter);
}
else
{
if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, &dest_kw_iter))
{
/* the keyword can't be moved if the same name already exist */
return;
}
if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, &dest_kw_iter, &new_keywords))
{
/* the keywords can't be added if the same name already exist */
return;
}
switch (pos)
{
case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
case GTK_TREE_VIEW_DROP_BEFORE:
gtk_tree_store_insert_before(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL, &dest_kw_iter);
break;
case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
case GTK_TREE_VIEW_DROP_AFTER:
gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL, &dest_kw_iter);
break;
}
}
}
else
{
if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, NULL))
{
/* the keyword can't be moved if the same name already exist */
return;
}
if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, NULL, &new_keywords))
{
/* the keywords can't be added if the same name already exist */
return;
}
gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL);
}
if (src_valid)
{
keyword_move_recursive(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &src_kw_iter);
}
work = new_keywords;
while (work)
{
gchar *keyword = work->data;
keyword_set(GTK_TREE_STORE(keyword_tree), &new_kw_iter, keyword, TRUE);
work = work->next;
if (work)
{
GtkTreeIter add;
gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, NULL, &new_kw_iter);
new_kw_iter = add;
}
}
string_list_free(new_keywords);
bar_keyword_tree_sync(pkd);
}
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);
}
static void cm_delete_item(CookieManagerPage *cmp)
{
GtkTreeIter iter, iter_store, child;
GtkTreeModel *model;
GtkTreePath *path, *last_path;
GtkTreeSelection *selection;
GList *rows, *row;
GList *refs = NULL;
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) == 0)
return;
last_path = gtk_tree_path_copy(g_list_nth_data(rows, 0));
/* as paths will change during delete, first create GtkTreeRowReferences for
* all selected rows */
row = rows;
do
{
refs = g_list_append(refs, gtk_tree_row_reference_new(model, (GtkTreePath*) (row->data)));
} while ((row = row->next) != NULL);
row = refs;
do
{
/* get iter */
path = gtk_tree_row_reference_get_path((GtkTreeRowReference*) row->data);
if (path == NULL)
continue;
gtk_tree_model_get_iter(model, &iter, path);
if (gtk_tree_model_iter_has_child(model, &iter))
{
while (gtk_tree_model_iter_children(model, &child, &iter))
{
cm_delete_cookie(cmp, model, &child);
cm_store_remove(cmp, &child);
/* we retrieve again the iter at path because it got invalid by the delete operation */
gtk_tree_model_get_iter(model, &iter, path);
}
/* remove/hide the parent */
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(priv->filter),
&iter_store, &iter);
if (gtk_tree_model_iter_has_child(GTK_TREE_MODEL(priv->store), &iter_store))
gtk_tree_store_set(priv->store, &iter_store, COOKIE_MANAGER_COL_VISIBLE, FALSE, -1);
else
cm_store_remove(cmp, &iter);
}
else
{
GtkTreePath *path_store, *path_model;
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(priv->filter),
&iter_store, &iter);
path_store = gtk_tree_model_get_path(GTK_TREE_MODEL(priv->store), &iter_store);
path_model = gtk_tree_model_get_path(model, &iter);
cm_delete_cookie(cmp, model, &iter);
gtk_tree_store_remove(priv->store, &iter_store);
/* check whether the parent still has children, otherwise delete it */
if (gtk_tree_path_up(path_store))
{
gtk_tree_model_get_iter(GTK_TREE_MODEL(priv->store), &iter_store, path_store);
if (! gtk_tree_model_iter_has_child(GTK_TREE_MODEL(priv->store), &iter_store))
/* remove the empty parent */
gtk_tree_store_remove(priv->store, &iter_store);
}
/* now for the filter model */
if (gtk_tree_path_up(path_model))
{
gtk_tree_model_get_iter(model, &iter, path_model);
if (! gtk_tree_model_iter_has_child(model, &iter))
{
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(priv->filter), &iter_store, &iter);
/* hide the empty parent */
gtk_tree_store_set(priv->store, &iter_store, COOKIE_MANAGER_COL_VISIBLE, FALSE, -1);
}
}
gtk_tree_path_free(path_store);
gtk_tree_path_free(path_model);
}
gtk_tree_path_free(path);
} while ((row = row->next) != NULL);
cm_free_selection_list(rows, (GFunc) gtk_tree_path_free);
cm_free_selection_list(refs, (GFunc) gtk_tree_row_reference_free);
cm_select_path(cmp, model, last_path);
gtk_tree_path_free(last_path);
}
static void
panel_addto_selection_changed (GtkTreeSelection *selection,
PanelAddtoDialog *dialog)
{
GtkTreeModel *filter_model;
GtkTreeModel *child_model;
GtkTreeIter iter;
GtkTreeIter filter_iter;
PanelAddtoItemInfo *data;
char *iid;
if (!gtk_tree_selection_get_selected (selection,
&filter_model,
&filter_iter)) {
gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button),
FALSE);
return;
}
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (filter_model),
&iter, &filter_iter);
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter_model));
gtk_tree_model_get (child_model, &iter, COLUMN_DATA, &data, -1);
if (!data) {
gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button),
FALSE);
return;
}
gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), TRUE);
if (data->type == PANEL_ADDTO_LAUNCHER_MENU) {
gtk_button_set_label (GTK_BUTTON (dialog->add_button),
GTK_STOCK_GO_FORWARD);
} else {
gtk_button_set_label (GTK_BUTTON (dialog->add_button),
GTK_STOCK_ADD);
}
gtk_button_set_use_stock (GTK_BUTTON (dialog->add_button),
TRUE);
/* only allow dragging applets if we can add applets */
if (panel_profile_id_lists_are_writable ()) {
switch (data->type) {
case PANEL_ADDTO_LAUNCHER:
panel_addto_setup_launcher_drag (GTK_TREE_VIEW (dialog->tree_view),
data->launcher_path);
break;
case PANEL_ADDTO_APPLET:
panel_addto_setup_applet_drag (GTK_TREE_VIEW (dialog->tree_view),
data->iid);
break;
case PANEL_ADDTO_LAUNCHER_MENU:
gtk_tree_view_unset_rows_drag_source (GTK_TREE_VIEW (dialog->tree_view));
break;
case PANEL_ADDTO_MENU:
/* build the iid for menus other than the main menu */
if (data->iid == NULL) {
iid = g_strdup_printf ("MENU:%s/%s",
data->menu_filename,
data->menu_path);
} else {
iid = g_strdup (data->iid);
}
panel_addto_setup_internal_applet_drag (GTK_TREE_VIEW (dialog->tree_view),
iid);
g_free (iid);
break;
default:
panel_addto_setup_internal_applet_drag (GTK_TREE_VIEW (dialog->tree_view),
data->iid);
break;
}
}
}
static void
program_list_selection_changed (GtkTreeSelection *selection,
PanelRunDialog *dialog)
{
GtkTreeModel *filter_model;
GtkTreeModel *child_model;
GtkTreeIter iter;
GtkTreeIter filter_iter;
char *temp;
char *path, *stripped;
gboolean terminal;
GKeyFile *key_file;
GtkWidget *entry;
if (!gtk_tree_selection_get_selected (selection, &filter_model,
&filter_iter))
return;
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (filter_model),
&iter, &filter_iter);
path = NULL;
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter_model));
gtk_tree_model_get (child_model, &iter,
COLUMN_PATH, &path,
-1);
if (!path)
return;
key_file = g_key_file_new ();
if (!g_key_file_load_from_file (key_file, path,
G_KEY_FILE_NONE, NULL)) {
g_key_file_free (key_file);
g_free (path);
return;
}
dialog->use_program_list = TRUE;
if (dialog->desktop_path)
g_free (dialog->desktop_path);
dialog->desktop_path = g_strdup (path);
if (dialog->item_name)
g_free (dialog->item_name);
dialog->item_name = NULL;
/* Order is important here. We have to set the text first so that the
* drag source is enabled, otherwise the drag icon can't be set by
* panel_run_dialog_set_icon.
*/
entry = gtk_bin_get_child (GTK_BIN (dialog->combobox));
temp = panel_key_file_get_string (key_file, "Exec");
if (temp) {
stripped = remove_parameters (temp);
gtk_entry_set_text (GTK_ENTRY (entry), stripped);
g_free (stripped);
} else {
temp = panel_key_file_get_string (key_file, "URL");
gtk_entry_set_text (GTK_ENTRY (entry), sure_string (temp));
}
g_free (temp);
temp = panel_key_file_get_locale_string (key_file, "Icon");
GIcon *icon = panel_gicon_from_icon_name (temp);
panel_run_dialog_set_icon (dialog, icon, FALSE);
g_object_unref (icon);
g_free (temp);
temp = panel_key_file_get_locale_string (key_file, "Comment");
//FIXME: if sure_string () == "", we should display "Will run..." as in entry_changed()
gtk_label_set_text (GTK_LABEL (dialog->program_label),
sure_string (temp));
g_free (temp);
terminal = panel_key_file_get_boolean (key_file, "Terminal", FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->terminal_checkbox),
terminal);
g_key_file_free (key_file);
g_free (path);
}
