void PluginManageDlg::drag_data_received_cb(GtkWidget *widget, GdkDragContext *ctx, guint x, guint y, GtkSelectionData *sd, guint info, guint t, PluginManageDlg *oPluginManageDlg)
{
if (gtk_selection_data_get_target(sd) == gdk_atom_intern("STARDICT_PLUGINMANAGE", FALSE) && gtk_selection_data_get_data(sd)) {
GtkTreePath *path = NULL;
GtkTreeViewDropPosition position;
GtkTreeIter drag_iter;
memcpy(&drag_iter, gtk_selection_data_get_data(sd), sizeof(drag_iter));
if (gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y, &path, &position)) {
GtkTreeIter iter;
GtkTreeModel *model = GTK_TREE_MODEL(oPluginManageDlg->plugin_tree_model);
gtk_tree_model_get_iter(model, &iter, path);
if (gtk_tree_model_iter_has_child(model, &iter)) {
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
if (gtk_tree_model_iter_has_child(model, &drag_iter)) {
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
GtkTreeIter parent_iter;
if (!gtk_tree_model_iter_parent(model, &parent_iter, &iter)) {
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
GtkTreeIter drag_parent_iter;
if (!gtk_tree_model_iter_parent(model, &drag_parent_iter, &drag_iter)) {
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
char *iter_str, *drag_iter_str;
iter_str = gtk_tree_model_get_string_from_iter(model, &parent_iter);
drag_iter_str = gtk_tree_model_get_string_from_iter(model, &drag_parent_iter);
if (strcmp(iter_str, drag_iter_str) != 0) {
g_free(iter_str);
g_free(drag_iter_str);
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
g_free(iter_str);
g_free(drag_iter_str);
switch (position) {
case GTK_TREE_VIEW_DROP_AFTER:
case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
gtk_tree_store_move_after(GTK_TREE_STORE(model), &drag_iter, &iter);
break;
case GTK_TREE_VIEW_DROP_BEFORE:
case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
gtk_tree_store_move_before(GTK_TREE_STORE(model), &drag_iter, &iter);
break;
default: {
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
}
oPluginManageDlg->write_order_list();
oPluginManageDlg->order_changed_ = true;
gtk_drag_finish (ctx, TRUE, FALSE, t);
}
}
}
gchar *nsgtk_history_parent_get(gchar *domain)
{
GtkTreeIter iter;
gchar *path;
/* Adds an extra entry in the list to act as the root domain
* (which will keep track of things like visits to all sites
* in the domain), This does not work as a tree because the
* children cannot be displayed if the root is hidden
* (which would conflict with the site view) */
path = g_hash_table_lookup(history->domain_hash, domain);
if (path == NULL){
gtk_list_store_append(history->domain_list, &iter);
gtk_list_store_set(history->domain_list, &iter,
DOM_DOMAIN, domain,
DOM_LASTVISIT, messages_get("gtkUnknownHost"),
DOM_TOTALVISITS, 0,
-1);
path = gtk_tree_model_get_string_from_iter(
GTK_TREE_MODEL(history->domain_list), &iter);
g_hash_table_insert(history->domain_hash, domain,
path);
}
return path;
}
void
on_interpreter_cell_changed(GtkCellRendererCombo *combo, char *path_string, GtkTreeIter *new_iter, ChimaraGlk *glk)
{
unsigned int format, interpreter;
format = (unsigned int)strtol(path_string, NULL, 10);
GtkTreeModel *combo_model;
g_object_get(combo, "model", &combo_model, NULL);
char *combo_string = gtk_tree_model_get_string_from_iter(combo_model, new_iter);
interpreter = (unsigned int)strtol(combo_string, NULL, 10);
g_free(combo_string);
chimara_if_set_preferred_interpreter(CHIMARA_IF(glk), format, interpreter);
/* Display the new setting in the list */
GtkTreeIter iter;
GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
gtk_tree_model_get_iter(GTK_TREE_MODEL(preferred_list), &iter, path);
gtk_tree_path_free(path);
gtk_list_store_set(preferred_list, &iter,
1, interpreter_to_display_string(interpreter),
-1);
/* Save the new settings in the preferences file */
extern GSettings *prefs_settings;
GVariantBuilder *builder = g_variant_builder_new( G_VARIANT_TYPE("a{ss}") );
unsigned int count;
for(count = 0; count < CHIMARA_IF_NUM_FORMATS; count++) {
g_variant_builder_add(builder, "{ss}",
format_to_string(count),
interpreter_to_string(chimara_if_get_preferred_interpreter(CHIMARA_IF(glk), count)));
}
g_settings_set(prefs_settings, "preferred-interpreters", "a{ss}", builder);
g_variant_builder_unref(builder);
}
static gchar *
find_string_in_model (GtkTreeModel *model, const gchar *value, gint column)
{
GtkTreeIter iter;
gboolean valid;
gchar *path = NULL, *test;
if (!value)
return NULL;
for (valid = gtk_tree_model_get_iter_first (model, &iter); valid;
valid = gtk_tree_model_iter_next (model, &iter))
{
gtk_tree_model_get (model, &iter, column, &test, -1);
if (test)
{
gint cmp = strcmp (test, value);
g_free (test);
if (!cmp)
{
path = gtk_tree_model_get_string_from_iter (model, &iter);
break;
}
}
}
return path;
}
static void cancelDownloadCallback(GtkWidget *button, BrowserDownloadDialog *dialog)
{
GtkTreeModel * model;
GtkTreeIter iter;
WebKitDownload *wkDownload;
if (gtk_tree_selection_get_selected(GTK_TREE_SELECTION(dialog->select), &model, &iter))
{
gtk_tree_model_get (GTK_TREE_MODEL(dialog->model), &iter, 7, &wkDownload, -1);
if(wkDownload)
{
webkit_download_cancel(WEBKIT_DOWNLOAD(wkDownload));
gtk_list_store_remove(dialog->model, &iter);
return;
}
char *treeviewIndex = g_strdup_printf("%s", gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(dialog->model), &iter));
if(treeviewIndex)
{
size_t listIndex = atoi(treeviewIndex);
DeleteList(dialog->download,listIndex);
}
g_printerr("store_remove\n");
gtk_list_store_remove(dialog->model, &iter);
}
}
static void
impl_get_item_attributes (GMenuModel *menu_model, int item_index, GHashTable **attrs)
{
RBDisplayPageMenu *menu = RB_DISPLAY_PAGE_MENU (menu_model);
RBDisplayPage *page;
GtkTreeIter iter;
*attrs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
page = get_page_at_index (menu, item_index, &iter);
if (page != NULL) {
char *name;
char *path;
GVariant *v;
g_object_get (page, "name", &name, NULL);
rb_debug ("page at %d is %s", item_index, name);
g_hash_table_insert (*attrs, g_strdup ("label"), g_variant_new_string (name));
g_free (name);
g_hash_table_insert (*attrs, g_strdup ("action"), g_variant_new_string (menu->priv->action));
path = gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL (menu->priv->model), &iter);
/* this is a bit awkward.. */
v = g_variant_new_string (path);
g_hash_table_insert (*attrs, g_strdup ("target"), g_variant_ref_sink (v));
g_free (path);
} else {
rb_debug ("no page at %d", item_index);
}
}
static void display_calendar_for_selected_row(struct commodity_register *commodity_register) {
if (gtk_tree_selection_count_selected_rows(COMMODITY_REGISTER_CORE.selection) == 1) {
GtkTreeIter iter;
GtkTreeModel *model;
if (gtk_tree_selection_get_selected(COMMODITY_REGISTER_CORE.selection, &model, &iter)) {
gchar *current_timestamp = get_string_column_via_iter(model, &iter, STORE_TIMESTAMP), *new_date;
gchar current_date[DATE_SIZE];
strncpy(current_date, current_timestamp, DATE_SIZE-1);
current_date[DATE_SIZE-1] = NULL_CHARACTER;
new_date = display_calendar(current_date, GTK_WIDGET(COMMODITY_REGISTER_CORE.window));
/* Did we get a date back? */
if (new_date != NULL) {
gchar *path_string = gtk_tree_model_get_string_from_iter(model, &iter);
gchar *new_time_stamp = g_strdup_printf("%s 00:00:00", new_date);
timestamp_edited(GTK_CELL_RENDERER_TEXT(commodity_register->timestamp_renderer), path_string, new_time_stamp, commodity_register);
g_free(path_string);
g_free(new_date);
g_free(new_time_stamp);
}
} else {
fprintf(stderr, "mouse_button_pressed: gtk_tree_selection_get_selected failed\n");
exit(EXIT_FAILURE);
}
} else
display_message_dialog("Improper selection", GTK_MESSAGE_WARNING, COMMODITY_REGISTER_CORE.window);
}
static void fill_combo_box (GtkIconTheme *theme, GtkComboBox *combo_box, GList *app_list)
{
GList *entry;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
if (theme == NULL) {
theme = gtk_icon_theme_get_default ();
}
gtk_combo_box_set_row_separator_func (combo_box, is_separator,
GINT_TO_POINTER (g_list_length (app_list)), NULL);
model = GTK_TREE_MODEL (gtk_list_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING));
gtk_combo_box_set_model (combo_box, model);
renderer = gtk_cell_renderer_pixbuf_new ();
/* not all cells have a pixbuf, this prevents the combo box to shrink */
gtk_cell_renderer_set_fixed_size (renderer, -1, 22);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
"pixbuf", PIXBUF_COL,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
"text", TEXT_COL,
NULL);
for (entry = app_list; entry != NULL; entry = g_list_next (entry)) {
MateDAItem *item;
item = (MateDAItem *) entry->data;
pixbuf = gtk_icon_theme_load_icon (theme, item->icon_name, 22, 0, NULL);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
PIXBUF_COL, pixbuf,
TEXT_COL, item->name,
-1);
item->icon_path = gtk_tree_model_get_string_from_iter (model, &iter);
if (pixbuf)
g_object_unref (pixbuf);
}
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, -1);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
PIXBUF_COL, NULL,
TEXT_COL, _("Custom"),
-1);
}
/**
* Move account in list depending on direction and selected account
*/
static void
account_move(gboolean move_up, gpointer data)
{
// Get view, model and selection of account
GtkTreeView *tree_view = GTK_TREE_VIEW(data);
GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
GtkTreeSelection *selection = gtk_tree_view_get_selection(tree_view);
// Find selected iteration and create a copy
GtkTreeIter iter;
gtk_tree_selection_get_selected(selection, &model, &iter);
GtkTreeIter *iter_copy;
iter_copy = gtk_tree_iter_copy(&iter);
// Find path of iteration
gchar *path = gtk_tree_model_get_string_from_iter(model, &iter);
// The first real account in the list can't move up because of the IP2IP account
// It can still move down though
if (g_strcmp0(path, "1") == 0 && move_up)
return;
GtkTreePath *tree_path = gtk_tree_path_new_from_string(path);
gint *indices = gtk_tree_path_get_indices(tree_path);
const gint pos = indices[0] - 1; /* black magic : gtk tree order is not account queue order */
// Depending on button direction get new path
if (move_up)
gtk_tree_path_prev(tree_path);
else
gtk_tree_path_next(tree_path);
gtk_tree_model_get_iter(model, &iter, tree_path);
// Swap iterations if valid
if (gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter))
gtk_list_store_swap(GTK_LIST_STORE(model), &iter, iter_copy);
// Scroll to new position
gtk_tree_view_scroll_to_cell(tree_view, tree_path, NULL, FALSE, 0, 0);
// Free resources
gtk_tree_path_free(tree_path);
gtk_tree_iter_free(iter_copy);
g_free(path);
// Perpetuate changes in account queue
if (move_up)
account_list_move_up(pos);
else
account_list_move_down(pos);
// Set the order in the configuration file
gchar *ordered_account_list = account_list_get_ordered_list();
dbus_set_accounts_order(ordered_account_list);
g_free(ordered_account_list);
}
const char* cardtree_append(cardtree_t* ct,
const char* path, gboolean leaf,
const char* node, const char* id, int length, const char* comment)
{
GtkTreeIter parent;
GtkTreeIter child;
char length_string[12];
if (path!=NULL && cardtree_is_empty(ct))
return NULL;
if (node==NULL)
return NULL;
if (path!=NULL)
{
if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(ct->_store),&parent,path)==FALSE)
return NULL;
gtk_tree_store_append (ct->_store, &child, &parent);
}
else
{
gtk_tree_store_append (ct->_store, &child, NULL);
}
cardtree_clear_tmpstr(ct);
ct->_tmpstr = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(ct->_store),&child);
/* FIXME : check if parent is not leaf */
gtk_tree_store_set (ct->_store, &child,
C_LEAF, leaf,
C_NODE, node,
-1);
if (length>=0)
{
sprintf(length_string,"%i",length);
gtk_tree_store_set (ct->_store, &child,
C_LENGTH, length_string,
-1);
}
if (id && !leaf)
gtk_tree_store_set (ct->_store, &child,
C_ID, id,
-1);
if (comment)
gtk_tree_store_set (ct->_store, &child,
C_COMMENT, comment,
-1);
cardtree_create_markup(ct,&child);
return ct->_tmpstr;
}
static void
codec_moved_cb (GtkWidget *widget,
gpointer data)
{
CodecsBox *self = NULL;
GtkTreeIter iter;
GtkTreeIter *iter2 = NULL;
GtkTreeModel *model = NULL;
GtkTreeSelection *selection = NULL;
GtkTreePath *tree_path = NULL;
std::list<std::string> list;
gchar *path_str = NULL;
self = CODECS_BOX (data);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->codecs_list));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->codecs_list));
if (!gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection),
NULL, &iter))
return;
/* Update the tree view */
iter2 = gtk_tree_iter_copy (&iter);
path_str = gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL (model),
&iter);
tree_path = gtk_tree_path_new_from_string (path_str);
if (!g_strcmp0 ((gchar *) g_object_get_data (G_OBJECT (widget), "operation"),
"up"))
gtk_tree_path_prev (tree_path);
else
gtk_tree_path_next (tree_path);
gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, tree_path);
if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter)
&& gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter2))
gtk_list_store_swap (GTK_LIST_STORE (model), &iter, iter2);
/* Scroll to the new position */
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self->priv->codecs_list),
tree_path, NULL, FALSE, 0, 0);
gtk_tree_path_free (tree_path);
gtk_tree_iter_free (iter2);
g_free (path_str);
/* Update the key */
list = codecs_box_to_list (self);
if (self->priv->type == Ekiga::Call::Audio)
self->priv->audio_settings->set_string_list ("media-list", list);
else if (self->priv->type == Ekiga::Call::Video)
self->priv->video_settings->set_string_list ("media-list", list);
}
static VALUE
rg_to_str(VALUE self)
{
GtkTreeIter* iter = _SELF(self);
GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
gchar* s = gtk_tree_model_get_string_from_iter (model, iter);
VALUE result = CSTR2RVAL(s);
g_free(s);
return result;
}
void nsgtk_history_domain_set_visible (GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, gboolean has_sites)
{
gchar *string = gtk_tree_model_get_string_from_iter(model, iter);
if (!g_str_equal(string, "0")) /* "All" */
gtk_list_store_set(GTK_LIST_STORE(model), iter,
DOM_HAS_SITES, has_sites, -1);
g_free(string);
}
static void ListView_change(GtkTreeView* treeView, ListView* self) {
GtkTreeIter iter;
if(!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(treeView), 0, &iter)) return; //should not be possible
char* path = gtk_tree_model_get_string_from_iter(gtk_tree_view_get_model(treeView), &iter);
unsigned selection = decimal(path);
g_free(path);
if(!self->state.selected || self->state.selection != selection) {
self->state.selected = true;
self->state.selection = selection;
if(self->onChange) self->onChange();
}
}
static void
trackersettings_clist_selected (GtkTreeSelection *sel,
TrackerSettings *ts)
{
GtkTreeModel *mdl;
GtkTreeIter iter;
gchar *str;
gint row;
if(gtk_tree_selection_get_selected(sel, &mdl, &iter)) {
row = atoi(str = gtk_tree_model_get_string_from_iter(mdl, &iter));
g_free(str);
ts->clist_selected_row = row;
}
}
gboolean ListSelectionChange(GtkTreeView *treeview, gpointer data)
{ // the selected channel has (probably) changed
GtkTreeSelection *ts;
GtkTreeModel *tm;
GtkTreeIter it;
ts=gtk_tree_view_get_selection(GTK_TREE_VIEW(GetWidget("channels")));
if (gtk_tree_selection_get_selected(ts,&tm,&it)) {
char *rows=gtk_tree_model_get_string_from_iter(tm,&it);
chan=atoi(rows);
g_free(rows);
} else
chan=-1;
UpdateButtons();
return TRUE;
}
static void
treeview_gsettings_changed_callback (GSettings *settings, gchar *key, GtkTreeView *list)
{
GtkTreeModel *store;
gchar *curr_value;
gchar *path;
/* find value in model */
curr_value = g_settings_get_string (settings, key);
store = gtk_tree_view_get_model (list);
path = find_string_in_model (store, curr_value, COL_NAME);
/* Add a temporary item if we can't find a match
* TODO: delete this item if it is no longer selected?
*/
if (!path)
{
GtkListStore *list_store;
GtkTreeIter iter, sort_iter;
ThemeConvData *conv;
list_store = GTK_LIST_STORE (gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (store)));
conv = g_object_get_data (G_OBJECT(list), THEME_DATA);
gtk_list_store_insert_with_values (list_store, &iter, 0,
COL_LABEL, curr_value,
COL_NAME, curr_value,
COL_THUMBNAIL, conv->thumbnail,
-1);
/* convert the tree store iter for use with the sort model */
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (store),
&sort_iter, &iter);
path = gtk_tree_model_get_string_from_iter (store, &sort_iter);
create_thumbnail (curr_value, conv->thumbnail, conv->data);
}
/* select the new gsettings theme in treeview */
GtkTreeSelection *selection = gtk_tree_view_get_selection (list);
GtkTreePath *treepath = gtk_tree_path_new_from_string (path);
gtk_tree_selection_select_path (selection, treepath);
gtk_tree_view_scroll_to_cell (list, treepath, NULL, FALSE, 0, 0);
gtk_tree_path_free (treepath);
}
const char* cardtree_find_ext(cardtree_t* ct, GtkTreeIter* iter,
const char* t_node, const char *t_id)
{
gboolean leaf;
gchar* node;
gchar* id;
GtkTreeIter child;
int match;
const char * retval;
do {
/* check item */
gtk_tree_model_get(GTK_TREE_MODEL(ct->_store),iter,
C_LEAF,&leaf,
C_NODE,&node,
C_ID,&id,
-1);
if ((t_node==NULL || (node && strcmp(t_node,node)==0)) &&
(t_id==NULL || (id && strcmp(t_id,id)==0)))
match = 1;
else
match = 0;
if (node) g_free(node);
if (id) g_free(id);
if (match)
{
cardtree_clear_tmpstr(ct);
ct->_tmpstr = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(ct->_store),iter);
return ct->_tmpstr;
}
/* check children */
if (gtk_tree_model_iter_children(GTK_TREE_MODEL(ct->_store),&child,iter)!=FALSE)
{
retval = cardtree_find_ext(ct,&child,t_node,t_id);
if (retval) return retval;
}
} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(ct->_store),iter)!=FALSE);
return NULL;
}
static void user_install_treeview_select_row(GtkTreeSelection *selection, gpointer data)
{
GtkTreeIter iter;
GtkTreeModel *model;
gchar* pathString;
gint row = -1;
GtkNotebook *notebook;
notebook = (GtkNotebook*)data;
if (!gtk_tree_selection_get_selected (selection, &model, &iter)) return;
pathString =gtk_tree_model_get_string_from_iter(model, &iter);
if(strstr(pathString,":"))
{
gchar* t = strstr(pathString,":")+1;
row = 1 + atoi(t);
}
else row = 0;
if(row>=0) gtk_notebook_set_current_page(notebook, row);
}
void icon_view_item_select(GtkIconView *icon_view, GtkTreePath *path, gpointer userdata)
{
GtkTreeModel *model;
GtkNotebook *notebook;
GtkTreeIter iter;
notebook = GTK_NOTEBOOK(userdata);
model = gtk_icon_view_get_model(icon_view);
gtk_tree_model_get_iter(model, &iter, path);
char *string;
string = gtk_tree_model_get_string_from_iter(model, &iter);
printf("current select string is %s\n", string);
int n = atoi(string);
if(n == 0)
{
gtk_notebook_set_current_page(notebook, n+1);
}
if(n == 1)
{
gtk_notebook_set_current_page(notebook, n+1);
}
}
static void
adblock_ui_edit_cb (GtkButton *button,
AdblockUI *dialog)
{
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *selection;
selection = dialog->priv->selection;
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
char* path = gtk_tree_model_get_string_from_iter (model, &iter);
GtkTreePath* tree_path = gtk_tree_path_new_from_string (path);
GtkTreeView *treeview = dialog->priv->treeview;
GtkTreeViewColumn *column = gtk_tree_view_get_column (treeview,
COL_FILTER_URI);
gtk_tree_view_set_cursor (treeview, tree_path, column, TRUE);
gtk_tree_path_free (tree_path);
g_free (path);
}
}
int internal_cardtree_from_xml_file(cardtree_t *ct, GtkTreeIter *parent, FILE* F)
{
/* quick and dirty, absolutely no checking ! */
GtkTreeIter child;
a_string_t *atr;
a_string_t *elt;
int retval = XML_ERROR;
char *debug_msg;
int in_element;
elt = a_strnew(NULL);
atr = a_strnew(NULL);
while (!ferror(F))
{
in_element = TOK_TEXT;
if (get_next_xml_token(F,elt,&in_element)!=XML_OK) goto clean_up;
if (in_element==TOK_END)
{
retval = XML_OK;
goto clean_up;
}
else if (a_strequal(elt,"<node"))
{
gtk_tree_store_append (ct->_store, &child, parent);
gtk_tree_store_set (ct->_store, &child,
C_LEAF, 0,
-1);
for (;;)
{
if (get_next_xml_token(F,elt,&in_element)!=XML_OK) goto clean_up;
if (in_element != TOK_ATTRIBUTE) break;
if (assert_next_xml_token(F,atr,&in_element,"=")!=XML_OK) goto clean_up;
if (get_next_xml_token(F,atr,&in_element)!=XML_OK) goto clean_up;
if (in_element != TOK_STRING) goto clean_up;
if (a_strequal(elt,"name"))
{
gtk_tree_store_set (ct->_store, &child,
C_NODE, a_strval(atr),
-1);
}
else if (a_strequal(elt,"id"))
{
gtk_tree_store_set (ct->_store, &child,
C_ID, a_strval(atr),
-1);
}
else if (a_strequal(elt,"length"))
{
gtk_tree_store_set (ct->_store, &child,
C_LENGTH, a_strval(atr),
-1);
}
else if (a_strequal(elt,"comment"))
{
gtk_tree_store_set (ct->_store, &child,
C_COMMENT, a_strval(atr),
-1);
}
else
{
log_printf(LOG_ERROR,"Unexpected XML attribute '%s'",a_strval(elt));
retval = XML_ERROR;
goto clean_up;
}
}
cardtree_create_markup(ct,&child);
if (!a_strequal(elt,"/>"))
{
if (!a_strequal(elt,">"))
{
log_printf(LOG_ERROR,"Expected '>' or '/>'");
goto clean_up;
}
retval = internal_cardtree_from_xml_file(ct,&child,F);
if (retval!=XML_OK) goto clean_up;
/*if (assert_next_xml_token(F,elt,&in_element,"</node>")!=XML_OK) goto clean_up;*/
}
}
else if (a_strequal(elt,"<data"))
{
gtk_tree_store_append (ct->_store, &child, parent);
gtk_tree_store_set (ct->_store, &child,
C_LEAF, 1,
-1);
if (get_next_xml_token(F,elt,&in_element)!=XML_OK) goto clean_up;
if (a_strequal(elt,"/>")) continue;
if (!a_strequal(elt,">"))
{
log_printf(LOG_ERROR,"Expected '>' or '/>'");
goto clean_up;
}
if (get_next_xml_token(F,elt,&in_element)!=XML_OK) goto clean_up;
if (in_element!=TOK_TEXT)
{
log_printf(LOG_ERROR,"Expected text inside <data>...</data>, got %s instead.",
a_strval(elt));
goto clean_up;
}
gtk_tree_store_set (ct->_store, &child,
C_NODE, a_strval(elt),
-1);
cardtree_create_markup(ct,&child);
if (assert_next_xml_token(F,elt,&in_element,"</>")!=XML_OK) goto clean_up;
}
else if (a_strequal(elt,"<cardtree"))
{
if (parent!=NULL)
{
log_printf(LOG_ERROR,"XML ERROR - cardtree must be root element");
goto clean_up;
}
if (get_next_xml_token(F,elt,&in_element)!=XML_OK) goto clean_up;
if (a_strequal(elt,"/>"))
{
retval = XML_OK;
goto clean_up;
}
if (!a_strequal(elt,">"))
{
log_printf(LOG_ERROR,"Expected '>' or '/>'");
goto clean_up;
}
retval = internal_cardtree_from_xml_file(ct,NULL,F);
if (retval!=XML_OK) goto clean_up;
/*retval = assert_next_xml_token(F,elt,&in_element,"</cardtree>");*/
goto clean_up;
}
else if (in_element==TOK_INSTRUCTION)
{
/* NOP */
}
else
{
log_printf(LOG_ERROR,"Syntax error : %s",a_strval(elt));
retval = XML_ERROR;
goto clean_up;
}
}
log_printf(LOG_ERROR,"Unexpected end-of-file or error in XML");
retval = XML_ERROR;
clean_up:
if (retval==XML_ERROR)
{
if (parent)
{
debug_msg = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(ct->_store),parent);
log_printf(LOG_ERROR,"Error in path '%s'",debug_msg);
g_free(debug_msg);
}
else
log_printf(LOG_ERROR,"Error in root");
}
a_strfree(atr);
a_strfree(elt);
return retval;
}
gint
drag_received (GtkWidget* widget, GdkDragContext* drag_context, gint x, gint y, GtkSelectionData* data, guint info, guint time, gpointer user_data)
{
// this receives drops for the whole window.
if(!data || data->length < 0){ perr("no data!\n"); return -1; }
dbg(1, "%s", data->data);
if(g_str_has_prefix((char*)data->data, "colour:")){
char* colour_string = (char*)data->data + 7;
unsigned colour_index = atoi(colour_string) ? atoi(colour_string) - 1 : 0;
// which row are we on?
GtkTreePath* path;
GtkTreeIter iter;
gint tx, treeview_top;
gdk_window_get_position(app->libraryview->widget->window, &tx, &treeview_top);
dbg(2, "treeview_top=%i", y);
#ifdef HAVE_GTK_2_12
gint bx, by;
gtk_tree_view_convert_widget_to_bin_window_coords(GTK_TREE_VIEW(app->libraryview->widget), x, y - treeview_top, &bx, &by);
dbg(2, "coords: %dx%d => %dx%d", x, y, bx, by);
#else
gint by = y - treeview_top - 20;
#endif
#ifdef USE_GDL
GdkWindow* top_window = gdk_window_get_toplevel(gtk_widget_get_toplevel(app->libraryview->widget)->window);
GdkWindow* window = app->libraryview->widget->window;
while((window = gdk_window_get_parent(window)) != top_window){
gint x0, y0;
gdk_window_get_position(window, &x0, &y0);
by -= y0;
}
#endif
if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(app->libraryview->widget), x, by, &path, NULL, NULL, NULL)){
gtk_tree_model_get_iter(GTK_TREE_MODEL(samplecat.store), &iter, path);
gchar* path_str = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(samplecat.store), &iter);
dbg(2, "path=%s y=%i final_y=%i", path_str, y, y - treeview_top);
listview_item_set_colour(path, colour_index);
gtk_tree_path_free(path);
}
else dbg(0, "path not found.");
return FALSE;
}
if(info == GPOINTER_TO_INT(GDK_SELECTION_TYPE_STRING)) printf(" type=string.\n");
if(info == GPOINTER_TO_INT(TARGET_URI_LIST)){
dbg(1, "type=uri_list. len=%i", data->length);
GList* list = uri_list_to_glist((char*)data->data);
if(g_list_length(list) < 1) pwarn("drag drop: uri list parsing found no uri's.\n");
int i = 0;
ScanResults result = {0,};
GList* l = list;
#ifdef __APPLE__
gdk_threads_enter();
#endif
for(;l;l=l->next){
char* u = l->data;
gchar* method_string;
vfs_get_method_string(u, &method_string);
dbg(2, "%i: %s method=%s", i, u, method_string);
if(!strcmp(method_string, "file")){
//we could probably better use g_filename_from_uri() here
//http://10.0.0.151/man/glib-2.0/glib-Character-Set-Conversion.html#g-filename-from-uri
//-or perhaps get_local_path() from rox/src/support.c
char* uri_unescaped = vfs_unescape_string(u + strlen(method_string) + 1, NULL);
char* uri = (strstr(uri_unescaped, "///") == uri_unescaped) ? uri_unescaped + 2 : uri_unescaped;
if(do_progress(0,0)) break;
if(is_dir(uri)) application_add_dir(uri, &result);
else application_add_file(uri, &result);
g_free(uri_unescaped);
}
else pwarn("drag drop: unknown format: '%s'. Ignoring.\n", u);
i++;
}
hide_progress();
#ifdef __APPLE__
gdk_threads_leave();
#endif
statusbar_print(1, "import complete. %i files added", result.n_added);
uri_list_free(list);
}
return FALSE;
}
list_item_t *list_search_text(list_t *list, char *text, int from_start, int info_only, int case_sensitive)
{
list_item_t *cur = NULL;
gboolean good = FALSE;
GtkTreeIter iter;
char text_buf[strlen(text)+1];
int column0;
int found;
//fprintf(stderr, "-- SEARCH text='%s' info=%d\n", text, info_only);
/* Find where the search should start from */
if ( list->search_path != NULL ) {
/* Get path of previous successful search */
gtk_tree_model_get_iter(GTK_TREE_MODEL(list->store), &iter, list->search_path);
/* Remove search result highlighting */
gtk_list_store_set(list->store, &iter,
LIST_LINENO_BACKGROUND, NULL,
-1);
list_search_clear(list);
/* Get next row. If end reached, wrap to first row */
good = gtk_tree_model_iter_next(GTK_TREE_MODEL(list->store), &iter);
if ( ! good )
from_start = 1;
}
else {
from_start = 1;
}
if ( from_start ) {
good = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(list->store), &iter);
}
/* Return now if no valid start row found */
if ( ! good )
return NULL;
/* Make all chars capitals if search is not case sensitive */
if ( ! case_sensitive ) {
strcpy(text_buf, text);
text = strupper(text_buf);
}
/* Search for text in Log list */
column0 = info_only ? LIST_INFO : LIST_DATE;
found = 0;
while ( good && (!found) ) {
int column;
char *str;
str = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(list->store), &iter);
g_free(str);
for (column = column0; (column <= LIST_INFO) && (!found); column++) {
gtk_tree_model_get(GTK_TREE_MODEL(list->store), &iter,
column, &str,
-1);
if ( strstr2(str, text, case_sensitive) != NULL )
found = 1;
}
if ( ! found )
good = gtk_tree_model_iter_next(GTK_TREE_MODEL(list->store), &iter);
}
if ( found ) {
gtk_list_store_set(list->store, &iter,
LIST_LINENO_BACKGROUND, "black",
-1);
if ( ! row_is_visible(list->tree, &iter) )
scroll_to_row(list->tree, &iter);
list->search_path = gtk_tree_model_get_path(GTK_TREE_MODEL(list->store), &iter);
}
return cur;
}
void nsgtk_history_update_info(GtkTreeSelection *treesel, gboolean domain)
{
GtkTreeIter iter;
GtkTreeModel *model;
gboolean has_selection;
has_selection = gtk_tree_selection_get_selected(treesel, &model, &iter);
if (has_selection && domain) {
gchar *b;
gint i;
char buf[20];
gboolean all = g_str_equal(gtk_tree_model_get_string_from_iter(
model, &iter), "0");
/* Address */
gtk_tree_model_get(model, &iter, DOM_DOMAIN, &b, -1);
gtk_label_set_text(GTK_LABEL(glade_xml_get_widget(gladeFile,
"labelHistoryAddress")),
all ? "-" : b);
g_free(b);
/* Last Visit */
gtk_tree_model_get(model, &iter, DOM_LASTVISIT, &i, -1);
gtk_label_set_text(GTK_LABEL(glade_xml_get_widget(gladeFile,
"labelHistoryLastVisit")),
nsgtk_history_date_parse(i));
/* Total Visits */
gtk_tree_model_get(model, &iter, DOM_TOTALVISITS, &i, -1);
snprintf(buf, 20, "%d", i);
gtk_label_set_text(GTK_LABEL(glade_xml_get_widget(gladeFile,
"labelHistoryVisits")),
buf);
} else if (has_selection){
GdkPixbuf *thumb;
gchar *b;
gint i;
char buf[20];
/* Address */
gtk_tree_model_get(model, &iter, SITE_ADDRESS, &b, -1);
gtk_label_set_text(GTK_LABEL(glade_xml_get_widget(gladeFile,
"labelHistoryAddress")), b);
g_free(b);
/* Last Visit */
gtk_tree_model_get(model, &iter, SITE_LASTVISIT, &i, -1);
gtk_label_set_text(GTK_LABEL(glade_xml_get_widget(gladeFile,
"labelHistoryLastVisit")),
nsgtk_history_date_parse(i));
/* Total Visits */
gtk_tree_model_get(model, &iter, SITE_TOTALVISITS, &i, -1);
snprintf(buf, 20, "%d", i);
gtk_label_set_text(GTK_LABEL(glade_xml_get_widget(gladeFile,
"labelHistoryVisits")), buf);
gtk_tree_model_get(model, &iter, SITE_THUMBNAIL, &thumb, -1);
gtk_image_set_from_pixbuf(GTK_IMAGE(
glade_xml_get_widget(gladeFile,
"imageThumbnail")), thumb);
g_object_set(G_OBJECT(glade_xml_get_widget(
gladeFile, "imageFrame")),
"visible", (bool)thumb, NULL);
}
}
