static int release_user_entry(GtkTreeView *view) { GtkTreePath *path; GtkTreeIter iter; GtkTreeModel *model; model = gtk_tree_view_get_model(view); if (!model) return -EINVAL; path=gtk_tree_path_new_first (); g_assert(path); if (gtk_tree_model_get_iter(model,&iter,path)) { while(gtk_list_store_remove(GTK_LIST_STORE(model), &iter)) dbg_out("Remove OK\n"); } gtk_tree_path_free (path); return 0; }
static void dialog_pref_select_page (PrefState *state, gchar const *page) { page_search_t pst = {NULL, NULL}; if (page == NULL) page = "Tools"; pst.page = _(page); gtk_tree_model_foreach (GTK_TREE_MODEL (state->store), (GtkTreeModelForeachFunc) dialog_pref_select_page_search, &pst); if (pst.path == NULL) pst.path = gtk_tree_path_new_first (); if (pst.path != NULL) { gtk_tree_view_set_cursor (state->view, pst.path, NULL, FALSE); gtk_tree_view_expand_row (state->view, pst.path, TRUE); gtk_tree_path_free (pst.path); } }
static gboolean individual_view_drag_motion_cb (GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time_) { EmpathyIndividualView *view = EMPATHY_INDIVIDUAL_VIEW (widget); GdkAtom target; target = gtk_drag_dest_find_target (GTK_WIDGET (view), context, NULL); if (target == gdk_atom_intern_static_string ("text/x-persona-id")) { GtkTreePath *path; /* FIXME: It doesn't make sense for us to highlight a specific row or * position to drop a Persona in, so just highlight the entire widget. * Since I can't find a way to do this, just highlight the first possible * position in the tree. */ gdk_drag_status (context, gdk_drag_context_get_suggested_action (context), time_); path = gtk_tree_path_new_first (); gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (view), path, GTK_TREE_VIEW_DROP_BEFORE); gtk_tree_path_free (path); return TRUE; } /* Unknown or unhandled drag target */ gdk_drag_status (context, GDK_ACTION_DEFAULT, time_); gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (view), NULL, 0); return FALSE; }
static GtkTreePath * _dtm_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkTreePath *result; int index = 0; if (!NODE_DIAGRAM(iter) && !NODE_LAYER(iter) && !NODE_OBJECT(iter)) { /* the root path */ return gtk_tree_path_new_first (); } result = gtk_tree_path_new (); if (NODE_DIAGRAM(iter)) { GList *list = dia_open_diagrams(); gtk_tree_path_append_index (result, g_list_index (list, NODE_DIAGRAM(iter))); } if (NODE_LAYER(iter)) { g_return_val_if_fail (NODE_DIAGRAM(iter) == layer_get_parent_diagram (NODE_LAYER(iter)), NULL); index = data_layer_get_index (NODE_DIAGRAM(iter), NODE_LAYER(iter)); if (index >= 0) gtk_tree_path_append_index (result, index); } if (index >= 0 && NODE_OBJECT(iter)) { g_return_val_if_fail (NODE_LAYER(iter) == dia_object_get_parent_layer (NODE_OBJECT(iter)), NULL); index = layer_object_get_index (NODE_LAYER(iter), NODE_OBJECT(iter)); if (index >= 0) gtk_tree_path_append_index (result, index); } if (index < 0) { gtk_tree_path_free (result); return NULL; } return result; }
void FormAccount_UpDown(FormAccount* fa, unsigned int updown) { GtkTreePath* path; GtkTreeModel* model; GtkTreeIter iter; gtk_tree_view_get_cursor(GTK_TREE_VIEW(fa->ListViewAccount), &path, NULL); if (path == NULL) { path = gtk_tree_path_new_first(); } else { switch (updown) { case 2: gtk_tree_path_next(path); model = gtk_tree_view_get_model(GTK_TREE_VIEW(fa->ListViewAccount)); if (gtk_tree_model_get_iter(model, &iter, path) == FALSE) { gtk_tree_path_prev(path); } break; case 1: gtk_tree_path_prev(path); break; } } gtk_tree_view_set_cursor_on_cell(GTK_TREE_VIEW(fa->ListViewAccount), path, NULL, NULL, FALSE); gtk_tree_path_free(path); }
static GtkTreePath *get_next_bus (GtkTreeModel *tm, GtkTreePath *tpSelBus) { int row_type ; int icRootChildren = -1 ; GtkTreePath *tp = NULL ; int idxChild = 0 ; GtkTreeIter itr ; if (1 != gtk_tree_path_get_depth (tpSelBus)) return NULL ; icRootChildren = gtk_tree_model_iter_n_children (tm, NULL) ; tp = gtk_tree_path_new_first () ; while (gtk_tree_path_compare (tp, tpSelBus) <= 0 && idxChild < icRootChildren) if (gtk_tree_model_get_iter (tm, &itr, tp)) { gtk_tree_path_next (tp) ; idxChild++ ; } else break ; while (idxChild < icRootChildren) { if (gtk_tree_model_get_iter (tm, &itr, tp)) { gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_TYPE, &row_type, -1) ; if (ROW_TYPE_BUS & row_type) return tp ; } if (++idxChild < icRootChildren) gtk_tree_path_next (tp) ; } gtk_tree_path_free (tp) ; return NULL ; }
gint tsk_get_tasks_num (guint32 julian, gboolean check_only, gboolean show_done, gint hidden_category, GUI *appGUI) { GtkTreeModel *model = NULL; GtkTreePath *path; GtkTreeIter iter; guint32 tsk_julian; gchar *buf; gint tasks = 0; gint done; model = GTK_TREE_MODEL (appGUI->tsk->tasks_list_store); g_return_val_if_fail (model != NULL, 0); path = gtk_tree_path_new_first (); while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) { gtk_tree_model_get (model, &iter, TA_COLUMN_DUE_DATE_JULIAN, &tsk_julian, TA_COLUMN_CATEGORY, &buf, TA_COLUMN_DONE, &done, -1); if (tsk_julian == julian && (show_done || !done) && tsk_get_category_state (buf, hidden_category, appGUI)) { tasks++; } g_free (buf); if (check_only && tasks) break; gtk_tree_path_next (path); } gtk_tree_path_free (path); return tasks; }
static GtkTreePath * dspy_introspection_model_get_path (GtkTreeModel *model, GtkTreeIter *iter) { DspyIntrospectionModel *self = (DspyIntrospectionModel *)model; GtkTreePath *path; DspyNode *node; LOG_DEBUG (G_STRFUNC); g_assert (DSPY_IS_INTROSPECTION_MODEL (self)); g_assert (iter != NULL); node = iter->user_data; g_assert (node != NULL); g_assert (node->any.parent != NULL); path = gtk_tree_path_new_first (); g_assert (gtk_tree_path_get_depth (path) == 1); for (; node->any.parent != NULL; node = node->any.parent) { gint pos = 0; for (const GList *list = &node->any.link; list->prev; list = list->prev) pos++; gtk_tree_path_prepend_index (path, pos); } gtk_tree_path_up (path); return g_steal_pointer (&path); }
static void panel_addto_search_entry_changed (GtkWidget *entry, PanelAddtoDialog *dialog) { GtkTreeModel *model; char *new_text; GtkTreeIter iter; GtkTreePath *path; new_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->search_entry))); g_strchomp (new_text); if (dialog->search_text && g_utf8_collate (new_text, dialog->search_text) == 0) { g_free (new_text); return; } if (dialog->search_text) g_free (dialog->search_text); dialog->search_text = new_text; model = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tree_view)); gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model)); path = gtk_tree_path_new_first (); if (gtk_tree_model_get_iter (model, &iter, path)) { GtkTreeSelection *selection; gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->tree_view), path, NULL, FALSE, 0, 0); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view)); gtk_tree_selection_select_path (selection, path); } gtk_tree_path_free (path); }
/*! * Event-handler for editing the suggestion. */ void AP_UnixDialog_Spell::onSuggestionChanged () { UT_DEBUGMSG (("ROB: AP_UnixDialog_Spell::onSuggestionChanged()\n")); const gchar * modtext = gtk_entry_get_text(GTK_ENTRY(m_eChange)); UT_ASSERT(modtext); GtkTreeIter iter; GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (m_lvSuggestions)); GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvSuggestions)); GtkTreePath *first = gtk_tree_path_new_first (); if (gtk_tree_model_get_iter (model, &iter, first)) { gtk_tree_path_free (first); do { gchar *label = NULL; gtk_tree_model_get (model, &iter, COLUMN_SUGGESTION, &label, -1); if (g_ascii_strncasecmp (modtext, label, strlen (modtext)) == 0) { GtkTreePath *path = gtk_tree_model_get_path (model, &iter); g_signal_handler_block(G_OBJECT(selection), m_listHandlerID); gtk_tree_selection_select_path (selection, path); g_signal_handler_unblock(G_OBJECT(selection), m_listHandlerID); gtk_tree_path_free (path); return; } } while (gtk_tree_model_iter_next (model, &iter)); } else { gtk_tree_path_free (first); gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvSuggestions))); } }
void plugins_show_window(PluginType plugin_type) { gchar *heading; GtkTreeViewColumn *column; switch(plugin_type) { case PLUGIN_TYPE_IMPORT : heading=g_strdup((gchar *)_("Import Plugins")); plugins_liststore=plugins_import_liststore; break; case PLUGIN_TYPE_EXPORT : heading=g_strdup((gchar *)_("Export Plugins")); plugins_liststore=plugins_export_liststore; break; case PLUGIN_TYPE_DOWNLOAD : heading=g_strdup((gchar *)_("Download Plugins")); plugins_liststore=plugins_download_liststore; break; case PLUGIN_TYPE_GENERAL : heading=g_strdup((gchar *)_("General Plugins")); plugins_liststore=plugins_general_liststore; break; } plugins_window=GTK_WIDGET(create_plugins_window()); column=gtk_tree_view_column_new_with_attributes(heading,gtk_cell_renderer_text_new(),"text",PLUGIN_COL_DESCRIPTION,NULL); g_free(heading); widget_plugins_list=GTK_WIDGET(lookup_widget(GTK_WIDGET(plugins_window),"pluginslist")); gtk_tree_view_append_column(GTK_TREE_VIEW(widget_plugins_list),column); gtk_tree_view_column_set_sort_column_id(column, PLUGIN_COL_DESCRIPTION); gtk_tree_view_set_model(GTK_TREE_VIEW(widget_plugins_list),GTK_TREE_MODEL(plugins_liststore)); gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget_plugins_list),gtk_tree_path_new_first(),NULL,FALSE); gtk_window_set_transient_for(GTK_WINDOW(plugins_window),GTK_WINDOW(main_window)); gtk_widget_show(plugins_window); if(!gtk_tree_model_iter_n_children(GTK_TREE_MODEL(plugins_liststore),NULL)) gtk_widget_set_sensitive(GTK_WIDGET(lookup_widget(GTK_WIDGET(plugins_window),"plugins_ok_btn")),FALSE); }
static void wp_remove_wallpaper (GtkWidget *widget, AppearanceData *data) { MateWPItem *item; GtkTreeIter iter; GtkTreePath *path; item = get_selected_item (data, &iter); if (item) { item->deleted = TRUE; if (gtk_list_store_remove (GTK_LIST_STORE (data->wp_model), &iter)) path = gtk_tree_model_get_path (data->wp_model, &iter); else path = gtk_tree_path_new_first (); gtk_icon_view_select_path (data->wp_view, path); gtk_icon_view_set_cursor (data->wp_view, path, NULL, FALSE); gtk_tree_path_free (path); } }
/** * autoar_gtk_chooser_advanced_new: * @default_format: an #AutoarFormat * @default_filter: an #AutoarFilter * * Create a #GtkGrid with two lists. One list shows all available formats, * and the other list shows all available filters. * * Returns: (transfer full): a new #GtkGrid widget **/ GtkWidget* autoar_gtk_chooser_advanced_new (AutoarFormat default_format, AutoarFilter default_filter) { GtkWidget *advanced_widget; GtkGrid *advanced; GtkTreeModel *format_model; GtkWidget *format_widget; GtkTreeView *format; GtkTreeSelection *format_selection; GtkCellRenderer *format_renderer; GtkTreePath *format_path; GtkTreeModel *filter_model; GtkWidget *filter_widget; GtkTreeView *filter; GtkTreeSelection *filter_selection; GtkCellRenderer *filter_renderer; GtkTreePath *filter_path; GtkWidget *description_widget; GtkLabel *description; advanced_widget = gtk_grid_new (); advanced = GTK_GRID (advanced_widget); gtk_grid_set_row_spacing (advanced, 5); gtk_grid_set_column_spacing (advanced, 5); gtk_grid_set_column_homogeneous (advanced, TRUE); format_model = advanced_format_store (); format_widget = gtk_tree_view_new_with_model (format_model); format = GTK_TREE_VIEW (format_widget); format_selection = gtk_tree_view_get_selection (format); format_renderer = gtk_cell_renderer_text_new (); gtk_tree_selection_set_mode (format_selection, GTK_SELECTION_SINGLE); gtk_tree_view_insert_column_with_attributes (format, -1, _("Format"), format_renderer, "text", ADVANCED_FORMAT_COL_DESCRIPTION, NULL); if (autoar_format_is_valid (default_format)) { GtkTreeIter iter; gboolean valid; format_path = NULL; for (valid = gtk_tree_model_get_iter_first (format_model, &iter); valid; valid = gtk_tree_model_iter_next (format_model, &iter)) { int get_format; gtk_tree_model_get (format_model, &iter, ADVANCED_FORMAT_COL_FORMAT, &get_format, -1); if (default_format == get_format) { format_path = gtk_tree_model_get_path (format_model, &iter); break; } } if (format_path == NULL) format_path = gtk_tree_path_new_first (); } else { format_path = gtk_tree_path_new_first (); } gtk_tree_view_set_cursor (format, format_path, NULL, FALSE); gtk_tree_path_free (format_path); gtk_grid_attach (advanced, format_widget, 0, 0, 1, 1); g_object_unref (format_model); filter_model = advanced_filter_store (); filter_widget = gtk_tree_view_new_with_model (filter_model); filter = GTK_TREE_VIEW (filter_widget); filter_selection = gtk_tree_view_get_selection (filter); filter_renderer = gtk_cell_renderer_text_new (); gtk_tree_selection_set_mode (filter_selection, GTK_SELECTION_SINGLE); gtk_tree_view_insert_column_with_attributes (filter, -1, _("Filter"), filter_renderer, "text", ADVANCED_FILTER_COL_DESCRIPTION, NULL); if (autoar_filter_is_valid (default_filter)) { GtkTreeIter iter; gboolean valid; filter_path = NULL; for (valid = gtk_tree_model_get_iter_first (filter_model, &iter); valid; valid = gtk_tree_model_iter_next (filter_model, &iter)) { int get_filter; gtk_tree_model_get (filter_model, &iter, ADVANCED_FILTER_COL_FILTER, &get_filter, -1); if (default_filter == get_filter) { filter_path = gtk_tree_model_get_path (filter_model, &iter); break; } } if (filter_path == NULL) filter_path = gtk_tree_path_new_first (); } else { filter_path = gtk_tree_path_new_first (); } gtk_tree_view_set_cursor (filter, filter_path, NULL, FALSE); gtk_tree_path_free (filter_path); gtk_grid_attach (advanced, filter_widget, 1, 0, 1, 1); g_object_unref (filter_model); description_widget = gtk_label_new (NULL); description = GTK_LABEL (description_widget); gtk_label_set_justify (description, GTK_JUSTIFY_CENTER); gtk_grid_attach (advanced, description_widget, 0, 1, 2, 1); g_signal_connect (format_widget, "cursor-changed", G_CALLBACK (advanced_update_description_cb), advanced); g_signal_connect (filter_widget, "cursor-changed", G_CALLBACK (advanced_update_description_cb), advanced); /* Run the callback now to set the initial text on the label */ advanced_update_description_cb (NULL, advanced_widget); return advanced_widget; }
bool sc_navigate_index(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); g_return_val_if_fail(zathura->document != NULL, false); if(zathura->ui.index == NULL) { return false; } GtkTreeView *tree_view = gtk_container_get_children(GTK_CONTAINER(zathura->ui.index))->data; GtkTreePath *path; gtk_tree_view_get_cursor(tree_view, &path, NULL); if (path == NULL) { return false; } GtkTreeModel *model = gtk_tree_view_get_model(tree_view); GtkTreeIter iter; GtkTreeIter child_iter; gboolean is_valid_path = TRUE; switch(argument->n) { case TOP: /* go to the first node */ gtk_tree_path_free(path); path = gtk_tree_path_new_first(); break; case BOTTOM: /* go to the last visiible node */ gtk_tree_path_free(path); path = gtk_tree_path_new_from_indices(gtk_tree_model_iter_n_children(model, NULL) - 1, -1); gtk_tree_model_get_iter(model, &iter, path); while (gtk_tree_model_iter_has_child(model, &iter) == TRUE && gtk_tree_view_row_expanded(tree_view, path) == TRUE) { gtk_tree_path_append_index(path, gtk_tree_model_iter_n_children(model, &iter) - 1); } break; case UP: if (gtk_tree_path_prev(path) == FALSE) { /* For some reason gtk_tree_path_up returns TRUE although we're not * moving anywhere. */ is_valid_path = gtk_tree_path_up(path) && (gtk_tree_path_get_depth(path) > 0); } else { /* row above */ while (gtk_tree_view_row_expanded(tree_view, path)) { gtk_tree_model_get_iter(model, &iter, path); /* select last child */ gtk_tree_model_iter_nth_child(model, &child_iter, &iter, gtk_tree_model_iter_n_children(model, &iter)-1); gtk_tree_path_free(path); path = gtk_tree_model_get_path(model, &child_iter); } } break; case COLLAPSE: if (gtk_tree_view_collapse_row(tree_view, path) == FALSE && gtk_tree_path_get_depth(path) > 1) { gtk_tree_path_up(path); gtk_tree_view_collapse_row(tree_view, path); } break; case DOWN: if (gtk_tree_view_row_expanded(tree_view, path) == TRUE) { gtk_tree_path_down(path); } else { do { gtk_tree_model_get_iter(model, &iter, path); if (gtk_tree_model_iter_next(model, &iter)) { gtk_tree_path_free(path); path = gtk_tree_model_get_path(model, &iter); break; } } while((is_valid_path = (gtk_tree_path_get_depth(path) > 1)) && gtk_tree_path_up(path)); } break; case EXPAND: if (gtk_tree_view_expand_row(tree_view, path, FALSE)) { gtk_tree_path_down(path); } break; case EXPAND_ALL: gtk_tree_view_expand_all(tree_view); break; case COLLAPSE_ALL: gtk_tree_view_collapse_all(tree_view); gtk_tree_path_free(path); path = gtk_tree_path_new_first(); gtk_tree_view_set_cursor(tree_view, path, NULL, FALSE); break; case TOGGLE: gtk_tree_model_get_iter(model, &iter, path); if (gtk_tree_model_iter_has_child(model, &iter) == TRUE) { if (gtk_tree_view_row_expanded(tree_view, path) == TRUE) { gtk_tree_view_collapse_row(tree_view, path); } else { gtk_tree_view_expand_row(tree_view, path, FALSE); } break; } case SELECT: cb_index_row_activated(tree_view, path, NULL, zathura); gtk_tree_path_free(path); return false; } if (is_valid_path == TRUE) { gtk_tree_view_set_cursor(tree_view, path, NULL, FALSE); } gtk_tree_path_free(path); return false; }
bool sc_toggle_index(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; if (zathura->document == NULL) { return false; } girara_tree_node_t* document_index = NULL; GtkWidget* treeview = NULL; GtkTreeModel* model = NULL; GtkCellRenderer* renderer = NULL; GtkCellRenderer* renderer2 = NULL; if (zathura->ui.index == NULL) { /* create new index widget */ zathura->ui.index = gtk_scrolled_window_new(NULL, NULL); if (zathura->ui.index == NULL) { goto error_ret; } gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(zathura->ui.index), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* create index */ document_index = zathura_document_index_generate(zathura->document, NULL); if (document_index == NULL) { girara_notify(session, GIRARA_WARNING, _("This document does not contain any index")); goto error_free; } model = GTK_TREE_MODEL(gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER)); if (model == NULL) { goto error_free; } treeview = gtk_tree_view_new_with_model(model); if (treeview == NULL) { goto error_free; } gtk_style_context_add_class(gtk_widget_get_style_context(treeview), "indexmode"); g_object_unref(model); renderer = gtk_cell_renderer_text_new(); if (renderer == NULL) { goto error_free; } renderer2 = gtk_cell_renderer_text_new(); if (renderer2 == NULL) { goto error_free; } document_index_build(model, NULL, document_index); girara_node_free(document_index); /* setup widget */ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 0, "Title", renderer, "markup", 0, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 1, "Target", renderer2, "text", 1, NULL); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_object_set(G_OBJECT(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 0)), "expand", TRUE, NULL); gtk_tree_view_column_set_alignment(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 1), 1.0f); gtk_tree_view_set_cursor(GTK_TREE_VIEW(treeview), gtk_tree_path_new_first(), NULL, FALSE); g_signal_connect(G_OBJECT(treeview), "row-activated", G_CALLBACK(cb_index_row_activated), zathura); gtk_container_add(GTK_CONTAINER(zathura->ui.index), treeview); gtk_widget_show(treeview); } if (gtk_widget_get_visible(GTK_WIDGET(zathura->ui.index))) { girara_set_view(session, zathura->ui.page_widget); gtk_widget_hide(GTK_WIDGET(zathura->ui.index)); girara_mode_set(zathura->ui.session, zathura->modes.normal); /* refresh view */ refresh_view(zathura); } else { /* save current position to the jumplist */ zathura_jumplist_add(zathura); girara_set_view(session, zathura->ui.index); gtk_widget_show(GTK_WIDGET(zathura->ui.index)); girara_mode_set(zathura->ui.session, zathura->modes.index); } return false; error_free: if (zathura->ui.index != NULL) { g_object_ref_sink(zathura->ui.index); zathura->ui.index = NULL; } if (document_index != NULL) { girara_node_free(document_index); } error_ret: return false; }
/* Create a new dir tree view */ GtkWidget* ptk_dir_tree_view_new( PtkFileBrowser* browser, gboolean show_hidden ) { GtkTreeView * dir_tree_view; GtkTreeViewColumn* col; GtkCellRenderer* renderer; GtkTreeModel* model; GtkTreeSelection* tree_sel; GtkTreePath* tree_path; GtkTreeModel* filter; dir_tree_view = GTK_TREE_VIEW( gtk_tree_view_new () ); gtk_tree_view_set_headers_visible( dir_tree_view, FALSE ); #if GTK_CHECK_VERSION(2, 10, 0) gtk_tree_view_set_enable_tree_lines(dir_tree_view, TRUE); #endif /* FIXME: Temporarily disable drag & drop since it doesn't work right now. gtk_tree_view_enable_model_drag_dest ( dir_tree_view, drag_targets, sizeof( drag_targets ) / sizeof( GtkTargetEntry ), GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK ); gtk_tree_view_enable_model_drag_source ( dir_tree_view, ( GDK_CONTROL_MASK | GDK_BUTTON1_MASK | GDK_BUTTON3_MASK ), drag_targets, sizeof( drag_targets ) / sizeof( GtkTargetEntry ), GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK ); */ col = gtk_tree_view_column_new (); renderer = ( GtkCellRenderer* ) ptk_file_icon_renderer_new(); gtk_tree_view_column_pack_start( col, renderer, FALSE ); gtk_tree_view_column_set_attributes( col, renderer, "pixbuf", COL_DIR_TREE_ICON, "info", COL_DIR_TREE_INFO, NULL ); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start( col, renderer, TRUE ); gtk_tree_view_column_set_attributes( col, renderer, "text", COL_DIR_TREE_DISP_NAME, NULL ); gtk_tree_view_append_column ( dir_tree_view, col ); tree_sel = gtk_tree_view_get_selection( dir_tree_view ); gtk_tree_selection_set_select_function( tree_sel, sel_func, NULL, NULL ); if ( G_UNLIKELY( !dir_tree_view_data ) ) dir_tree_view_data = g_quark_from_static_string( "show_hidden" ); g_object_set_qdata( G_OBJECT( dir_tree_view ), dir_tree_view_data, ( gpointer ) show_hidden ); model = get_dir_tree_model(); filter = gtk_tree_model_filter_new( model, NULL ); g_object_unref( G_OBJECT( model ) ); gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( filter ), filter_func, dir_tree_view, NULL ); gtk_tree_view_set_model( dir_tree_view, filter ); g_object_unref( G_OBJECT( filter ) ); g_signal_connect ( dir_tree_view, "row-expanded", G_CALLBACK ( on_dir_tree_view_row_expanded ), model ); g_signal_connect_data ( dir_tree_view, "row-collapsed", G_CALLBACK ( on_dir_tree_view_row_collapsed ), model, NULL, G_CONNECT_AFTER ); g_signal_connect ( dir_tree_view, "button-press-event", G_CALLBACK ( on_dir_tree_view_button_press ), browser ); g_signal_connect ( dir_tree_view, "key-press-event", G_CALLBACK ( on_dir_tree_view_key_press ), NULL ); tree_path = gtk_tree_path_new_first(); gtk_tree_view_expand_row( dir_tree_view, tree_path, FALSE ); gtk_tree_path_free( tree_path ); g_signal_connect( dir_tree_view, "destroy", G_CALLBACK(on_destroy), NULL ); return GTK_WIDGET( dir_tree_view ); }
/** Create widget for select question in single question form. * * This will also register the corresponding setter function. * * @param fe cdebconf frontend * @param question handled question * @param question_box the container for question widgets * @param model model for the possible choices * @return the created widget, NULL if something went wrong * @see focus_path() */ static int create_select_list(struct frontend * fe, struct question * question, GtkWidget * question_box, GtkTreeModel * model) { GtkTreePath * path = NULL; GtkWidget * view; GtkWidget * scroll; GtkWidget * frame; /* check NULL! */ view = gtk_tree_view_new_with_model(model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE /* no headers */); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(view), TRUE /* enable typeahead */); gtk_tree_view_set_search_column(GTK_TREE_VIEW(view), CHOICE_MODEL_TRANSLATED_VALUE); gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_BROWSE); if (!IS_SPECIAL_QUESTION(question)) { hide_expanders(GTK_TREE_VIEW(view)); } insert_choice_column(fe, GTK_TREE_VIEW(view)); g_signal_connect_swapped(G_OBJECT(view), "row-activated", G_CALLBACK(cdebconf_gtk_set_answer_ok), fe); if (should_expand_all(question->tag)) { gtk_tree_view_expand_all(GTK_TREE_VIEW(view)); } path = cdebconf_gtk_choice_model_get_first_selected(model); /* Select first row if there is no other default */ if (NULL == path) { path = gtk_tree_path_new_first(); } else { /* Only expand path when there was a previous selection. */ gtk_tree_view_expand_to_path(GTK_TREE_VIEW(view), path); } gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), path, NULL /* don't focus a particular column */, FALSE /* don't start editing */); /* We need to focus the row *after* the widget realization, see #340007. */ g_signal_connect_after(view, "expose-event", G_CALLBACK(focus_path), path); /* path will be free'd in focus_path() */ scroll = gtk_scrolled_window_new(NULL /* create horizontal adjustement */, NULL /* create vertical adjustement */); gtk_container_add(GTK_CONTAINER(scroll), view); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); frame = gtk_frame_new(NULL); gtk_container_add(GTK_CONTAINER(frame), scroll); cdebconf_gtk_add_common_layout(fe, question, question_box, frame); gtk_widget_grab_focus(view); cdebconf_gtk_register_setter(fe, SETTER_FUNCTION(set_value_from_select), question, view); return DC_OK; }
// part_browser_create // // Creates a new part browser. This is only called once per schematic window. GtkWidget * part_browser_create (SchematicView *schematic_view) { Browser *br; GtkBuilder *gui; GError *perror = NULL; char *msg; GtkWidget *w, *view; GtkCellRenderer *cell_text; GtkTreeViewColumn *cell_column; static GtkTargetEntry dnd_types[] = { { "x-application/oregano-part", 0, DRAG_PART_INFO } }; static int dnd_num_types = sizeof (dnd_types) / sizeof (dnd_types[0]); GtkTreePath *path; if ((gui = gtk_builder_new ()) == NULL) { oregano_error (_("Could not create part browser")); return NULL; } else gtk_builder_set_translation_domain (gui, NULL); br = g_new0 (Browser, 1); br->preview = NULL; br->schematic_view = schematic_view; br->hidden = FALSE; schematic_view_set_browser (schematic_view, br); if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/part-browser.ui", &perror) <= 0) { msg = perror->message; oregano_error_with_title (_("Could not create part browser"), msg); g_error_free (perror); return NULL; } view = GTK_WIDGET (gtk_builder_get_object (gui, "viewport1")); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (view), 115); w = goo_canvas_new (); gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (w)); br->canvas = w; g_signal_connect (w, "realize", (GCallback) preview_realized, br); //gtk_widget_set_size_request (w, PREVIEW_WIDTH, // PREVIEW_HEIGHT + PREVIEW_TEXT_HEIGHT); goo_canvas_set_bounds (GOO_CANVAS (w), 0, 0, PREVIEW_WIDTH, (PREVIEW_HEIGHT + PREVIEW_TEXT_HEIGHT)); br->description = GOO_CANVAS_TEXT (goo_canvas_text_new ( goo_canvas_get_root_item (GOO_CANVAS (br->canvas)), "", 0.0, PREVIEW_HEIGHT - 9.0, 100.0, GOO_CANVAS_ANCHOR_NORTH_WEST, "font", "sans 9", NULL)); // Set up dnd. g_signal_connect (G_OBJECT (br->canvas), "drag_data_get", G_CALLBACK (drag_data_get), br); gtk_drag_source_set (br->canvas, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK, dnd_types, dnd_num_types, GDK_ACTION_MOVE); br->filter_entry = GTK_ENTRY (gtk_builder_get_object (gui, "part_search")); g_signal_connect (G_OBJECT (br->filter_entry), "changed", G_CALLBACK (part_search_change), br); g_signal_connect (G_OBJECT (br->filter_entry), "activate", G_CALLBACK (part_search_activate), br); // Buttons. w = GTK_WIDGET (gtk_builder_get_object (gui, "place_button")); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (place_cmd), br); // Update the libraries option menu br->library = g_list_nth_data (oregano.libraries, 0); part_browser_setup_libs (br, gui); // Parts list. w = GTK_WIDGET (gtk_builder_get_object (gui, "parts_list")); br->list = w; // Create the List Model for TreeView, this is a Real model br->real_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); cell_text = gtk_cell_renderer_text_new (); cell_column = gtk_tree_view_column_new_with_attributes ( "", cell_text, "text", 0, NULL); // Create the sort model for the items, this sort the real model br->sort_model = gtk_tree_model_sort_new_with_model ( GTK_TREE_MODEL (br->real_model)); gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (br->sort_model), 0, GTK_SORT_ASCENDING); // Create the filter sorted model. This filter items based on user // request for fast item search br->filter_model = gtk_tree_model_filter_new (br->sort_model, NULL); gtk_tree_model_filter_set_visible_func ( GTK_TREE_MODEL_FILTER (br->filter_model), part_list_filter_func, br, NULL); // If we have TreeFilter use it, if not, just use sorting model only if (br->filter_model) gtk_tree_view_set_model (GTK_TREE_VIEW (w), br->filter_model); else gtk_tree_view_set_model (GTK_TREE_VIEW (w), br->sort_model); gtk_tree_view_append_column (GTK_TREE_VIEW (w), cell_column); update_list (br); // Set up TreeView dnd. g_signal_connect (G_OBJECT (w), "drag_data_get", G_CALLBACK (drag_data_get), br); gtk_drag_source_set (w, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK, dnd_types, dnd_num_types, GDK_ACTION_MOVE); g_signal_connect (G_OBJECT (w), "cursor_changed", G_CALLBACK (select_row), br); g_signal_connect (G_OBJECT (w), "row_activated", G_CALLBACK (part_selected), br); br->viewport = GTK_WIDGET (gtk_builder_get_object (gui, "part_browser_vbox")); path = gtk_tree_path_new_first (); gtk_tree_view_set_cursor (GTK_TREE_VIEW (w), path, NULL, FALSE); gtk_tree_path_free (path); gtk_widget_unparent (br->viewport); return br->viewport; }
static void change_root_to( ASFileBrowserRootSelFrame *data, ASFileBrowserRoot root ) { char *new_root = NULL ; int i ; GtkTreeModel *old_model ; if( root != root_Other ) { /* disable other text controls */ } switch( root ) { case root_PrivateAfterStep : new_root = mystrdup(Session->ashome ); break ; case root_SharedAfterStep : new_root = mystrdup(Session->asshare ); break ; case root_Home : new_root = mystrdup(getenv("HOME")); break ; case root_UsrShare : new_root = mystrdup("/usr/share"); break ; case root_UsrLocalShare : new_root = mystrdup("/usr/local/share"); break ; case root_Root : #ifdef __CYGWIN__ new_root = mystrdup("/cygdrive"); #else new_root = mystrdup("/"); #endif break ; case root_Other : break ; } if( root != root_Root ) data->last_nonroot_root = root ; old_model = asgtk_dir_tree_get_model( ASGTK_DIR_TREE(data->target_dirlist) ); for( i = 0 ; i < root_StandardRoots ; ++i ) if( data->root_models[i] == old_model ) { if( data->root_paths[i] ) gtk_tree_path_free( data->root_paths[i] ); data->root_paths[i] = asgtk_dir_tree_get_curr_path( ASGTK_DIR_TREE(data->target_dirlist) ); break; } g_object_unref( old_model ); if( root < root_StandardRoots ) { GtkTreeModel *new_model ; asgtk_dir_tree_set_root( ASGTK_DIR_TREE(data->target_dirlist), new_root, data->root_models[root] ); new_model = asgtk_dir_tree_get_model( ASGTK_DIR_TREE(data->target_dirlist) ); if( data->root_models[root] != new_model ) { if( data->root_models[root] ) g_object_unref( data->root_models[root] ); data->root_models[root] = new_model ; }else g_object_unref( new_model ); if( data->root_paths[root] == NULL ) data->root_paths[root] = gtk_tree_path_new_first (); asgtk_dir_tree_restore_curr_path( ASGTK_DIR_TREE(data->target_dirlist), data->root_paths[root] ); }else asgtk_dir_tree_set_root( ASGTK_DIR_TREE(data->target_dirlist), new_root, NULL ); if( new_root ) free( new_root ); }
void xml_tree_model_add_file ( xmlTreeModel *model, gchar *filename) { g_return_if_fail (XML_IS_TREE_MODEL(model)); g_return_if_fail (filename != NULL); GtkTreeIter iter; xsltStylesheetPtr xsldoc; xmlDocPtr xmldoc = NULL; xmlNodePtr cur; model->parser = xmlCreateURLParserCtxt (filename, XML_PARSE_RECOVER);// | //XML_PARSE_DTDVALID); g_return_if_fail(model->parser != NULL); int record_info = 1; xmlSetFeature(model->parser, "gather line info", &record_info); xmlParseDocument(model->parser); glong bytes = xmlByteConsumed(model->parser); model->valid = (model->parser->valid == 0) ? FALSE : TRUE; xmldoc = model->parser->myDoc; g_return_if_fail (xmldoc != NULL); model->offset = get_offset(xmldoc, filename); gint i; xmlParserNodeInfoPtr node; for(i = 0; i < model->parser->node_seq.length; ++i) { node = &model->parser->node_seq.buffer[i]; model->nodeinfo = g_list_append(model->nodeinfo, node); } model->nodeinfo = g_list_sort(model->nodeinfo, compare_node_func); cur = xmlDocGetRootElement(xmldoc); if ((IS_XSLT_ELEM(cur)) && ((IS_XSLT_NAME(cur, "stylesheet")) || (IS_XSLT_NAME(cur, "transform")))) { xsldoc = xsltParseStylesheetDoc(xmldoc); } else { xsldoc = NULL; } if(model->xsldoc != NULL) { xsltFreeStylesheet(model->xsldoc); model->xmldoc = NULL; } if(model->xmldoc) xmlFreeDoc(model->xmldoc); model->xmldoc = xmldoc; model->xsldoc = xsldoc; model->filename = filename; model->stamp = g_random_int(); /* Random int to check whether an iter belongs to our model */ gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter); gtk_tree_model_row_changed(GTK_TREE_MODEL(model),gtk_tree_path_new_first(), &iter); g_signal_emit(model, xml_tree_model_signals[XML_TREE_MODEL_CHANGED],0,NULL); //xmlFreeParserCtxt(model->parser); }
static void _update_info_resv(List info_list, GtkTreeView *tree_view) { GtkTreeModel *model = gtk_tree_view_get_model(tree_view); static GtkTreeModel *last_model = NULL; reserve_info_t *resv_ptr = NULL; char *name = NULL; ListIterator itr = NULL; sview_resv_info_t *sview_resv_info = NULL; set_for_update(model, SORTID_UPDATED); itr = list_iterator_create(info_list); while ((sview_resv_info = (sview_resv_info_t*) list_next(itr))) { resv_ptr = sview_resv_info->resv_ptr; /* This means the tree_store changed (added new column or something). */ if (last_model != model) sview_resv_info->iter_set = false; if (sview_resv_info->iter_set) { gtk_tree_model_get(model, &sview_resv_info->iter_ptr, SORTID_NAME, &name, -1); if (strcmp(name, resv_ptr->name)) { /* Bad pointer */ sview_resv_info->iter_set = false; //g_print("bad resv iter pointer\n"); } g_free(name); } if (sview_resv_info->iter_set) { _update_resv_record(sview_resv_info, GTK_TREE_STORE(model)); } else { GtkTreePath *path = gtk_tree_path_new_first(); /* get the iter, or find out the list is empty * goto add */ if (gtk_tree_model_get_iter( model, &sview_resv_info->iter_ptr, path)) { do { /* search for the jobid and check to see if it is in the list */ gtk_tree_model_get( model, &sview_resv_info->iter_ptr, SORTID_NAME, &name, -1); if (!strcmp(name, resv_ptr->name)) { /* update with new info */ g_free(name); _update_resv_record( sview_resv_info, GTK_TREE_STORE(model)); sview_resv_info->iter_set = 1; break; } g_free(name); } while (gtk_tree_model_iter_next( model, &sview_resv_info->iter_ptr)); } if (!sview_resv_info->iter_set) { _append_resv_record(sview_resv_info, GTK_TREE_STORE(model)); sview_resv_info->iter_set = true; } gtk_tree_path_free(path); } } list_iterator_destroy(itr); /* remove all old reservations */ remove_old(model, SORTID_UPDATED); last_model = model; }
static void _update_info_block(List block_list, GtkTreeView *tree_view) { ListIterator itr; sview_block_info_t *block_ptr = NULL; GtkTreePath *path = gtk_tree_path_new_first(); GtkTreeModel *model = gtk_tree_view_get_model(tree_view); GtkTreeIter iter; char *name = NULL; char *host = NULL; int line = 0; if (!block_list) { g_print("No block_list given"); return; } /* get the iter, or find out the list is empty goto add */ if (gtk_tree_model_get_iter(model, &iter, path)) { /* make sure all the partitions are still here */ while (1) { gtk_tree_store_set(GTK_TREE_STORE(model), &iter, SORTID_UPDATED, 0, -1); if (!gtk_tree_model_iter_next(model, &iter)) { break; } } } /* Report the BG Blocks */ itr = list_iterator_create(block_list); while ((block_ptr = (sview_block_info_t*) list_next(itr))) { if (block_ptr->cnode_cnt == 0) block_ptr->cnode_cnt = block_ptr->size; if (!block_ptr->slurm_part_name) block_ptr->slurm_part_name = xstrdup("no part"); /* get the iter, or find out the list is empty goto add */ if (!gtk_tree_model_get_iter(model, &iter, path)) { goto adding; } line = 0; while (1) { /* search for the jobid and check to see if it is in the list */ gtk_tree_model_get(model, &iter, SORTID_BLOCK, &name, -1); if (!strcmp(name, block_ptr->bg_block_name)) { /* update with new info */ g_free(name); _update_block_record(block_ptr, GTK_TREE_STORE(model), &iter); goto found; } g_free(name); line++; if (!gtk_tree_model_iter_next(model, &iter)) { break; } } adding: _append_block_record(block_ptr, GTK_TREE_STORE(model), &iter, line); found: ; } list_iterator_destroy(itr); if (host) free(host); gtk_tree_path_free(path); /* remove all old blocks */ remove_old(model, SORTID_UPDATED); }
static void DialogToBusLayout (bus_layout_D *dialog, BUS_LAYOUT *bus_layout) { GtkTreeModel *tm = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tview)) ; int Nix ; int icTopLevel = gtk_tree_model_iter_n_children (tm, NULL), icCells = -1 ; GtkTreePath *tp = NULL, *tpCells = NULL ; GtkTreeIter itr ; int Nix1, idxCell = -1 ; int row_type ; EXP_ARRAY *cell_list = NULL ; BUS *bus ; // destroy all buses before adding the new ones for (Nix = bus_layout->buses->icUsed - 1 ; Nix > -1 ; Nix--) { exp_array_free (exp_array_index_1d (bus_layout->buses, BUS, Nix).cell_indices) ; g_free (exp_array_index_1d (bus_layout->buses, BUS, Nix).pszName) ; } exp_array_remove_vals (bus_layout->buses, 1, 0, bus_layout->buses->icUsed) ; // Since we've destroyed all buses, no cells are members of any bus any longer for (Nix = 0 ; Nix < bus_layout->inputs->icUsed ; Nix++) exp_array_index_1d (bus_layout->inputs, BUS_LAYOUT_CELL, Nix).bIsInBus = FALSE ; for (Nix = 0 ; Nix < bus_layout->outputs->icUsed ; Nix++) exp_array_index_1d (bus_layout->outputs, BUS_LAYOUT_CELL, Nix).bIsInBus = FALSE ; if (icTopLevel > 0) { tp = gtk_tree_path_new_first () ; for (Nix = 0 ; Nix < icTopLevel ; Nix++, gtk_tree_path_next (tp)) { if (gtk_tree_model_get_iter (tm, &itr, tp)) { gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_TYPE, &row_type, -1) ; if (ROW_TYPE_BUS & row_type) { exp_array_1d_insert_vals (bus_layout->buses, NULL, 1, -1) ; bus = &(exp_array_index_1d (bus_layout->buses, BUS, bus_layout->buses->icUsed - 1)) ; gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_NAME, &(bus->pszName), -1) ; if (ROW_TYPE_INPUT & row_type) { bus->bus_function = QCAD_CELL_INPUT ; cell_list = bus_layout->inputs ; } else { bus->bus_function = QCAD_CELL_OUTPUT ; cell_list = bus_layout->outputs ; } bus->cell_indices = exp_array_new (sizeof (int), 1) ; if ((icCells = gtk_tree_model_iter_n_children (tm, &itr)) > 0) { gtk_tree_path_down (tpCells = gtk_tree_path_copy (tp)) ; for (Nix1 = 0 ; Nix1 < icCells ; Nix1++, gtk_tree_path_next (tpCells)) if (gtk_tree_model_get_iter (tm, &itr, tpCells)) { gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_INDEX, &idxCell, -1) ; exp_array_1d_insert_vals (bus->cell_indices, &idxCell, 1, -1) ; // Flag this cell in the master cell list as a member of some bus exp_array_index_1d (cell_list, BUS_LAYOUT_CELL, idxCell).bIsInBus = TRUE ; } gtk_tree_path_free (tpCells) ; } } } } gtk_tree_path_free (tp) ; } }
gint export_contacts_to_file(gchar *filename, gboolean header, GUI *appGUI) { GtkTreePath *sort_path, *filter_path, *path; gint i, j, a, b, c, e, n, m, max_field, exported; gchar *text; GtkTreeIter iter; FILE *filehandle; guint32 date; gchar tmpbuf[BUFFER_SIZE]; gchar tmp_buffer_1[BUFFER_SIZE], tmp_buffer_2[BUFFER_SIZE]; exported = 0; if (utl_gui_check_overwrite_file (filename, appGUI->cnt->export_window, appGUI) != 0) { return -1; } for(max_field = CONTACTS_NUM_COLUMNS-1; max_field >= 0; --max_field) { if(config.export_fields[max_field] == '+') break; } if (max_field == -1) { max_field = CONTACTS_NUM_COLUMNS-1; } filehandle = g_fopen (filename, "w"); if(filehandle) { if (config.export_format == EXPORT_TO_XHTML) { fprintf(filehandle, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"); fprintf(filehandle, "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"); fprintf(filehandle, "<head>\n"); fprintf(filehandle, "\t<title>Contact List</title>\n"); fprintf(filehandle, "\t<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\" />\n"); fprintf(filehandle, "\t<meta name=\"generator\" content=\"OSMO - http://clay.ll.pl/osmo\" />\n"); fprintf(filehandle, "\t<style type=\"text/css\">\n"); fprintf(filehandle, "\t\tbody { color:black; background-color:white; }\n"); fprintf(filehandle, "\t\ta { color:#0000ff; }\n"); fprintf(filehandle, "\t\ta:visited { color:#000055; }\n"); fprintf(filehandle, "\t\ttable { border-collapse:collapse; }\n"); fprintf(filehandle, "\t\ttr.header { background-color:#c0c0c0; }\n"); fprintf(filehandle, "\t\ttr.evenrow { background-color:#f0f0f0; }\n"); fprintf(filehandle, "\t\ttr.oddrow { background-color:#fafafa; }\n"); fprintf(filehandle, "\t\tth, td { border:1px solid #555555; padding:3px; }\n"); fprintf(filehandle, "\t</style>\n"); fprintf(filehandle, "</head>\n\n"); fprintf(filehandle, "<body>\n\n"); fprintf(filehandle, "<h1>Contact List</h1>\n\n"); fprintf(filehandle, "<table>\n"); fprintf(filehandle, "<tr class=\"header\">\n"); for(i=0; i < CONTACTS_NUM_COLUMNS; i++) { if(config.export_fields[i] == '+') { fprintf(filehandle, "\t<th>"); if (appGUI->cnt->contact_fields_tags_name[i*2] != NULL) { for(a=b=0; a < strlen(appGUI->cnt->contact_fields_tags_name[i*2]); a++) { if(appGUI->cnt->contact_fields_tags_name[i*2][a] == ' ') { tmpbuf[b] = '\0'; strcat(tmpbuf, " "); b += 6; } else { tmpbuf[b++] = appGUI->cnt->contact_fields_tags_name[i*2][a]; } } tmpbuf[b] = '\0'; fprintf(filehandle, "%s", tmpbuf); } fprintf(filehandle, "</th>\n"); } } fprintf(filehandle, "</tr>\n\n"); } j = 0; sort_path = gtk_tree_path_new_first (); while (gtk_tree_model_get_iter (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, sort_path) == TRUE) { if (sort_path != NULL) { filter_path = gtk_tree_model_sort_convert_path_to_child_path (GTK_TREE_MODEL_SORT(appGUI->cnt->contacts_sort), sort_path); if (filter_path != NULL) { path = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER(appGUI->cnt->contacts_filter), filter_path); if (path != NULL) { gtk_tree_model_get_iter (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, path); if (config.export_format == EXPORT_TO_XHTML) { if(j & 1) { fprintf(filehandle, "<tr class=\"evenrow\">\n"); } else { fprintf(filehandle, "<tr class=\"oddrow\">\n"); } } else if (config.export_format == EXPORT_TO_CSV && header == TRUE && j == 0) { for(i=n=0; i < CONTACTS_NUM_COLUMNS; i++) { if (i != COLUMN_PHOTO && i != COLUMN_ID && config.export_fields[i] == '+') { n++; } } for(i=m=0; i < CONTACTS_NUM_COLUMNS; i++) { if (i != COLUMN_PHOTO && i != COLUMN_ID && config.export_fields[i] == '+') { fprintf(filehandle, "%s", appGUI->cnt->contact_fields_tags_name[i*2]); if (m != n-1) { fprintf(filehandle, ","); } m++; } } fprintf(filehandle, "\n"); } for(i=0; i < CONTACTS_NUM_COLUMNS; i++) { if(config.export_fields[i] == '+') { if (i == COLUMN_BIRTH_DAY_DATE || i == COLUMN_NAME_DAY_DATE) { gtk_tree_model_get (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, i, &date, -1); if (date == 0) { text = NULL; } else { if (i == COLUMN_BIRTH_DAY_DATE) { text = g_strdup((const gchar *)julian_to_str(date, DATE_FULL, config.override_locale_settings)); } else { text = g_strdup((const gchar *)julian_to_str(date, DATE_NAME_DAY, config.override_locale_settings)); } } } else { gtk_tree_model_get (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, i, &text, -1); } if (config.export_format == EXPORT_TO_XHTML) { fprintf(filehandle, "\t<td>"); if (text != NULL) { for(a=b=0; a < strlen(text); a++) { if(text[a] == ' ') { tmpbuf[b] = '\0'; strcat(tmpbuf, " "); b += 6; } else { tmpbuf[b++] = text[a]; } } tmpbuf[b] = '\0'; switch (i) { case COLUMN_EMAIL_1: case COLUMN_EMAIL_2: case COLUMN_EMAIL_3: case COLUMN_EMAIL_4: fprintf(filehandle, "<a href=\"mailto:%s\">%s</a>", tmpbuf, tmpbuf); break; case COLUMN_WWW_1: case COLUMN_WWW_2: case COLUMN_WWW_3: case COLUMN_WWW_4: case COLUMN_BLOG: fprintf(filehandle, "<a href=\"%s\">%s</a>", tmpbuf, tmpbuf); break; default: fprintf(filehandle, "%s", tmpbuf); } g_free(text); } fprintf(filehandle, "</td>\n"); } else { /* CSV */ if (text != NULL) { /* 1 */ for(a = b = e = 0; a < strlen(text); a++) { if(text[a]=='"') { b = 1; } if(text[a]=='\n') { e = 1; /* found new line */ } } c = a = 0; if (b) { tmp_buffer_1[c++] = '"'; } do { if(text[a]=='"') { tmp_buffer_1[c++] = '"'; } tmp_buffer_1[c++] = text[a]; a++; } while (text[a]!='\0'); if(b) { tmp_buffer_1[c++] = '"'; } tmp_buffer_1[c] = '\0'; /* 2 */ for(a = b = 0; a < strlen(tmp_buffer_1); a++) { if(tmp_buffer_1[a]==',') { b = 1; } } c = a = 0; if (b) { tmp_buffer_2[c++] = '"'; } do { tmp_buffer_2[c++] = tmp_buffer_1[a]; a++; } while (tmp_buffer_1[a]!='\0'); if (b) { tmp_buffer_2[c++] = '"'; } tmp_buffer_2[c] = '\0'; if (e) { fprintf(filehandle, "\"%s\"", tmp_buffer_2); } else { fprintf(filehandle, "%s", tmp_buffer_2); } g_free(text); } if (i != max_field) { fprintf(filehandle, ","); } } } } if (config.export_format == EXPORT_TO_XHTML) { fprintf(filehandle, "</tr>\n\n"); } else { /* CSV */ fprintf(filehandle, "\n"); } j++; exported++; gtk_tree_path_free(path); } gtk_tree_path_free(filter_path); } } gtk_tree_path_next (sort_path); } if (config.export_format == EXPORT_TO_XHTML) { fprintf(filehandle, "</table>\n"); fprintf(filehandle, "</body>\n"); fprintf(filehandle, "</html>\n"); } fclose(filehandle); } else { utl_gui_create_dialog(GTK_MESSAGE_ERROR, _("Cannot create file."), GTK_WINDOW(appGUI->cnt->export_window)); return -1; } return exported; }
void AP_UnixDialog_Spell::_updateWindow (void) { GtkTextBuffer * buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(m_txWrong)); GtkTextIter iter2; // Empty buffer gtk_text_buffer_set_text(buffer, "", -1); const UT_UCSChar *p; UT_sint32 iLength; // insert start of sentence p = m_pWordIterator->getPreWord(iLength); if (0 < iLength) { gchar * preword = (gchar*) _convertToMB(p, iLength); gtk_text_buffer_set_text(buffer, preword, -1); FREEP(preword); } // insert misspelled word (in highlight color) p = m_pWordIterator->getCurrentWord(iLength); gchar * word = (gchar*) _convertToMB(p, iLength); GtkTextTag * txt_tag = gtk_text_buffer_create_tag(buffer, NULL, "foreground-gdk", &m_highlight, NULL); gtk_text_buffer_get_end_iter(buffer, &iter2); gtk_text_buffer_insert_with_tags(buffer, &iter2, word, -1, txt_tag, NULL); // word is freed at the end of the method... // insert end of sentence p = m_pWordIterator->getPostWord(iLength); if (0 < iLength) { gchar * postword = (gchar*) _convertToMB(p, iLength); gtk_text_buffer_get_end_iter(buffer, &iter2); gtk_text_buffer_insert(buffer, &iter2, postword, -1); FREEP(postword); } else { // Insert space to make gtk_text_buffer understand that it // really should highlight the selected word. This is a // workaround for bug 5459. It really should be fixed in GTK. gtk_text_buffer_get_end_iter(buffer, &iter2); gtk_text_buffer_insert(buffer, &iter2, " ", -1); } // TODO: set scroll position so misspelled word is centered GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (m_lvSuggestions)); // Detach model for faster updates g_object_ref (G_OBJECT (model)); gtk_tree_view_set_model (GTK_TREE_VIEW (m_lvSuggestions), NULL); gtk_list_store_clear (GTK_LIST_STORE (model)); GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvSuggestions)); UT_DEBUGMSG (("ROB: AP_UnixDialog_Spell::_updateWindow() itemcount=%d\n", m_Suggestions->getItemCount ())); if (m_Suggestions->getItemCount () == 0) { GtkTreeIter iter; gtk_tree_selection_set_mode (selection, GTK_SELECTION_NONE); const XAP_StringSet * pSS = m_pApp->getStringSet(); UT_UTF8String s; pSS->getValueUTF8(AP_STRING_ID_DLG_Spell_NoSuggestions,s); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_SUGGESTION, s.utf8_str (), COLUMN_NUMBER, -1, -1); g_signal_handler_block(G_OBJECT(m_eChange), m_replaceHandlerID); gtk_entry_set_text(GTK_ENTRY(m_eChange), word); g_signal_handler_unblock(G_OBJECT(m_eChange), m_replaceHandlerID); } else { GtkTreeIter iter; gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); gchar * suggest = NULL; for (UT_sint32 i = 0; i < m_Suggestions->getItemCount(); i++) { suggest = (gchar*) _convertToMB((UT_UCSChar*)m_Suggestions->getNthItem(i)); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_SUGGESTION, suggest, COLUMN_NUMBER, i, -1); } // put the first suggestion in the entry suggest = (gchar*) _convertToMB((UT_UCSChar*)m_Suggestions->getNthItem(0)); g_signal_handler_block(G_OBJECT(m_eChange), m_replaceHandlerID); gtk_entry_set_text(GTK_ENTRY(m_eChange), suggest); g_signal_handler_unblock(G_OBJECT(m_eChange), m_replaceHandlerID); } gtk_tree_view_set_model (GTK_TREE_VIEW (m_lvSuggestions), model); g_object_unref (G_OBJECT (model)); // select first if (m_Suggestions->getItemCount () > 0) { GtkTreePath *path = gtk_tree_path_new_first (); gtk_tree_selection_select_path (selection, path); gtk_tree_path_free (path); } FREEP (word); }
static void combobox_changed (GtkComboBox *combobox, PanelRunDialog *dialog) { char *text; char *start; char *msg; text = g_strdup (panel_run_dialog_get_combo_text (dialog)); start = text; while (*start != '\0' && g_ascii_isspace (*start)) start++; /* update item name to use for dnd */ if (!dialog->use_program_list) { if (dialog->desktop_path) { g_free (dialog->desktop_path); dialog->desktop_path = NULL; } if (dialog->item_name) { g_free (dialog->item_name); dialog->item_name = NULL; } } /* desensitize run button if no text entered */ if (!start || !start [0]) { g_free (text); gtk_widget_set_sensitive (dialog->run_button, FALSE); gtk_drag_source_unset (dialog->run_dialog); if (panel_profile_get_enable_program_list ()) gtk_label_set_text (GTK_LABEL (dialog->program_label), _("Select an application to view its description.")); panel_run_dialog_set_default_icon (dialog, FALSE); if (dialog->find_command_idle_id) { g_source_remove (dialog->find_command_idle_id); dialog->find_command_idle_id = 0; } if (panel_profile_get_enable_program_list ()) { GtkTreeIter iter; GtkTreePath *path; gtk_tree_model_foreach (GTK_TREE_MODEL (dialog->program_list_store), panel_run_dialog_make_all_list_visible, NULL); path = gtk_tree_path_new_first (); if (gtk_tree_model_get_iter (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->program_list)), &iter, path)) gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->program_list), path, NULL, FALSE, 0, 0); gtk_tree_path_free (path); } return; } gtk_widget_set_sensitive (dialog->run_button, TRUE); gtk_drag_source_set (dialog->run_dialog, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY); gtk_drag_source_add_uri_targets (dialog->run_dialog); if (panel_profile_get_enable_program_list () && !dialog->use_program_list) { msg = g_strdup_printf (_("Will run command: '%s'"), start); gtk_label_set_text (GTK_LABEL (dialog->program_label), msg); g_free (msg); } /* look up icon for the command */ if (panel_profile_get_enable_program_list () && !dialog->use_program_list && !dialog->find_command_idle_id) dialog->find_command_idle_id = g_idle_add_full (G_PRIORITY_LOW, (GSourceFunc) panel_run_dialog_find_command_idle, dialog, NULL); g_free (text); }
/** * Function called first when try to print the list * initialize the variables and calculate the number of pages * * \param operation GtkPrintOperation * \param context GtkPrintContext * \param null * * \return FALSE * */ gboolean print_tree_view_list_begin ( GtkPrintOperation *operation, GtkPrintContext *context, gpointer data ) { GtkTreeView *tree_view = ( GtkTreeView * ) data; gint size_line; gdouble lines_per_page_double; gint nbre_pages; devel_debug (NULL); /* we need to calculate the number of pages */ cr = gtk_print_context_get_cairo_context ( context ); /* get the size of the title */ if ( title_string && strlen ( title_string ) ) size_title = print_tree_view_list_get_title_size ( ); else size_title = 0; /* get the size of a row */ size_row = pango_font_description_get_size ( gsb_data_print_config_get_font_transactions () ) / PANGO_SCALE; size_line = size_row + gsb_data_print_config_get_draw_lines ( ); /* get the size of the titles of columns */ if ( gsb_data_print_config_get_draw_columns_name () ) { nbre_lines_col_title = print_tree_view_list_get_columns_title_nbre_lines ( tree_view ); size_columns_title = print_tree_view_list_get_columns_title_size ( nbre_lines_col_title ); } else size_columns_title = 0; /* the heigh of a page decrease size_columns_title */ page_height = gtk_print_context_get_height ( context ); /* get total lines to print */ total_lines_to_print = 0; total_lines_to_print = print_tree_view_list_set_rows_to_print ( tree_view ); /* how much transactions we can show in a page : */ lines_per_page_double = page_height / size_line; /* on enlève les lignes des titres des colonnes */ lines_per_page_double -= nbre_lines_col_title; if ( !size_title ) /* no title */ { nbre_pages = ceil ( total_lines_to_print / lines_per_page_double ); lines_in_first_page = floor ( lines_per_page_double ); } else { gint first_page_height; first_page_height = page_height - size_title; lines_in_first_page = floor ( first_page_height / size_line ) - nbre_lines_col_title; nbre_pages = 1 + ceil ( ( total_lines_to_print - lines_in_first_page ) / lines_per_page_double ); } /* set the number of page */ gtk_print_operation_set_n_pages ( GTK_PRINT_OPERATION ( operation ), nbre_pages ); /* save the nb of rows per page */ lines_per_page = floor ( lines_per_page_double ); /* calculate the size and position of the columns */ page_width = gtk_print_context_get_width ( context ); print_tree_view_list_calculate_columns_width ( tree_view, page_width ); if ( tree_path_to_print ) gtk_tree_path_free ( tree_path_to_print ); tree_path_to_print = gtk_tree_path_new_first ( ); total_lines_printed = 0; current_row_to_print = 0; return FALSE; }
static gboolean panel_run_dialog_find_command_idle (PanelRunDialog *dialog) { GtkTreeIter iter; GtkTreeModel *model; GtkTreePath *path; char *text; GIcon *found_icon; char *found_name; gboolean fuzzy; model = GTK_TREE_MODEL (dialog->program_list_store); path = gtk_tree_path_new_first (); if (!path || !gtk_tree_model_get_iter (model, &iter, path)) { if (path) gtk_tree_path_free (path); panel_run_dialog_set_icon (dialog, NULL, FALSE); dialog->find_command_idle_id = 0; return FALSE; } text = g_strdup (panel_run_dialog_get_combo_text (dialog)); found_icon = NULL; found_name = NULL; fuzzy = FALSE; do { char *exec = NULL; GIcon *icon = NULL; char *name = NULL; char *comment = NULL; gtk_tree_model_get (model, &iter, COLUMN_EXEC, &exec, COLUMN_GICON, &icon, COLUMN_NAME, &name, COLUMN_COMMENT, &comment, -1); if (!fuzzy && exec && icon && fuzzy_command_match (text, exec, &fuzzy)) { g_clear_object (&found_icon); g_free (found_name); found_icon = g_object_ref (icon); found_name = g_strdup (name); gtk_list_store_set (dialog->program_list_store, &iter, COLUMN_VISIBLE, TRUE, -1); } else if (panel_g_utf8_strstrcase (exec, text) != NULL || panel_g_utf8_strstrcase (name, text) != NULL || panel_g_utf8_strstrcase (comment, text) != NULL) { gtk_list_store_set (dialog->program_list_store, &iter, COLUMN_VISIBLE, TRUE, -1); } else { gtk_list_store_set (dialog->program_list_store, &iter, COLUMN_VISIBLE, FALSE, -1); } g_free (exec); g_object_unref (icon); g_free (name); g_free (comment); } while (gtk_tree_model_iter_next (model, &iter)); if (gtk_tree_model_get_iter (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->program_list)), &iter, path)) gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->program_list), path, NULL, FALSE, 0, 0); gtk_tree_path_free (path); panel_run_dialog_set_icon (dialog, found_icon, FALSE); //FIXME update dialog->program_label g_clear_object (&found_icon); g_free (text); g_free (dialog->item_name); dialog->item_name = found_name; dialog->find_command_idle_id = 0; return FALSE; }
void so__dlg_preferences_construct_cb (GtkWidget *dialog, GthBrowser *browser, GtkBuilder *dialog_builder) { BrowserData *data; GtkWidget *notebook; GtkWidget *page; GtkListStore *model; GArray *pixbuf_saver_types; int i; GtkTreeSelection *treeselection; GtkTreePath *path; GtkWidget *label; data = g_new0 (BrowserData, 1); data->builder = _gtk_builder_new_from_file ("save-options-preferences.ui", "pixbuf_savers"); notebook = _gtk_builder_get_widget (dialog_builder, "notebook"); page = _gtk_builder_get_widget (data->builder, "preferences_page"); gtk_widget_show (page); model = (GtkListStore *) gtk_builder_get_object (data->builder, "file_type_liststore"); pixbuf_saver_types = gth_main_get_type_set ("pixbuf-saver"); for (i = 0; (pixbuf_saver_types != NULL) && (i < pixbuf_saver_types->len); i++) { GthPixbufSaver *pixbuf_saver; GtkTreeIter iter; GtkWidget *options; pixbuf_saver = g_object_new (g_array_index (pixbuf_saver_types, GType, i), NULL); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, FILE_TYPE_COLUMN_N, i, FILE_TYPE_COLUMN_OBJ, pixbuf_saver, FILE_TYPE_COLUMN_DISPLAY_NAME, gth_pixbuf_saver_get_display_name (pixbuf_saver), -1); options = gth_pixbuf_saver_get_control (pixbuf_saver); gtk_widget_show (options); gtk_notebook_append_page (GTK_NOTEBOOK (_gtk_builder_get_widget (data->builder, "options_notebook")), options, NULL); data->pixbuf_saver = g_list_prepend (data->pixbuf_saver, pixbuf_saver); } treeselection = gtk_tree_view_get_selection (GTK_TREE_VIEW (_gtk_builder_get_widget (data->builder, "file_type_treeview"))); gtk_tree_selection_set_mode (treeselection, GTK_SELECTION_BROWSE); g_signal_connect (treeselection, "changed", G_CALLBACK (treeselection_changed_cb), dialog); label = gtk_label_new (_("Saving")); gtk_widget_show (label); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); g_object_set_data_full (G_OBJECT (dialog), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free); path = gtk_tree_path_new_first (); gtk_tree_selection_select_path (treeselection, path); gtk_tree_path_free (path); }
void cal_print_get_events (gchar *buffer, guint32 julian, GUI *appGUI) { GtkTreePath *path; GtkTreeIter iter; GtkTreeModel *model; GSList *lnode; struct note *a; gint i; gchar *wbuf1, *wbuf2; gchar buf1[BUFFER_SIZE], buf2[BUFFER_SIZE]; GDate *date, *sdate; gint age, syear; guint32 tsk_julian; gint time; gint max_event_length; GRegex *reg; buffer[0] = '\0'; max_event_length = (config.cal_print_event_length + 2 > BUFFER_SIZE) ? BUFFER_SIZE : config.cal_print_event_length + 2; #ifdef TASKS_ENABLED /* tasks */ if (config.cal_print_tasks) { model = GTK_TREE_MODEL (appGUI->tsk->tasks_list_store); g_return_if_fail (model != NULL); path = gtk_tree_path_new_first (); while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) { gtk_tree_model_get (model, &iter, TA_COLUMN_DUE_DATE_JULIAN, &tsk_julian, TA_COLUMN_CATEGORY, &wbuf1, -1); if (tsk_julian == julian && tasks_category_get_state (wbuf1, STATE_CALENDAR, appGUI) == TRUE) { gtk_tree_model_get (model, &iter, TA_COLUMN_DUE_TIME, &time, TA_COLUMN_SUMMARY, &wbuf2, -1); if (time >= 0) { g_snprintf (buf1, max_event_length, "\n[%02d:%02d] %s", time / 3600, time / 60 % 60, wbuf2); } else { g_snprintf (buf1, max_event_length, "\n%s", wbuf2); } g_strlcat (buffer, buf1, BUFFER_SIZE); g_free (wbuf2); } g_free (wbuf1); gtk_tree_path_next (path); } gtk_tree_path_free (path); } #endif /* TASKS_ENABLED */ #ifdef CONTACTS_ENABLED /* birthdays */ if (config.cal_print_birthdays) { model = GTK_TREE_MODEL (appGUI->cnt->contacts_list_store); g_return_if_fail (model != NULL); date = g_date_new (); g_return_if_fail (date != NULL); sdate = g_date_new_julian (julian); g_return_if_fail (sdate != NULL); syear = g_date_get_year (sdate); path = gtk_tree_path_new_first (); while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) { gtk_tree_model_get (model, &iter, COLUMN_BIRTH_DAY_DATE, &tsk_julian, -1); if (g_date_valid_julian (tsk_julian)) { g_date_set_julian (date, tsk_julian); age = syear - g_date_get_year (date); if (age >= 0) { if (g_date_valid_dmy (g_date_get_day (date), g_date_get_month (date), syear) == FALSE) { g_date_subtract_days (date, 1); } g_date_set_year (date, syear); if (g_date_compare (date, sdate) == 0) { gtk_tree_model_get (model, &iter, COLUMN_FIRST_NAME, &wbuf1, COLUMN_LAST_NAME, &wbuf2, -1); utl_name_strcat (wbuf1, wbuf2, buf2); g_snprintf (buf1, max_event_length, "\n%s (%d)", buf2, age); g_strlcat (buffer, buf1, BUFFER_SIZE); } } } gtk_tree_path_next (path); } gtk_tree_path_free (path); g_date_free (sdate); g_date_free (date); } /* name days */ if (config.cal_print_namedays) { model = GTK_TREE_MODEL (appGUI->cnt->contacts_list_store); g_return_if_fail (model != NULL); date = NULL; date = g_date_new (); g_return_if_fail (date != NULL); sdate = NULL; sdate = g_date_new_julian (julian); g_return_if_fail (sdate != NULL); syear = g_date_get_year (sdate); path = gtk_tree_path_new_first (); while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) { gtk_tree_model_get (model, &iter, COLUMN_NAME_DAY_DATE, &tsk_julian, -1); if (g_date_valid_julian (tsk_julian)) { g_date_set_julian (date, tsk_julian); if (g_date_valid_dmy (g_date_get_day (date), g_date_get_month (date), syear) == TRUE) { g_date_set_year (date, syear); if (g_date_compare (date, sdate) == 0) { gtk_tree_model_get (model, &iter, COLUMN_FIRST_NAME, &wbuf1, COLUMN_LAST_NAME, &wbuf2, -1); utl_name_strcat (wbuf1, wbuf2, buf1); g_snprintf (buf2, max_event_length, "\n%s (%s)", buf1, _("Name day")); g_strlcat (buffer, buf2, BUFFER_SIZE); } } } gtk_tree_path_next (path); } gtk_tree_path_free (path); g_date_free (sdate); g_date_free (date); } #endif /* CONTACTS_ENABLED */ /* day note */ if (config.cal_print_day_notes) { if (appGUI->cal->notes_list != NULL) { wbuf1 = NULL; reg = g_regex_new ("\n", 0, 0, NULL); for (i = 0, lnode = appGUI->cal->notes_list; lnode != NULL; lnode = lnode->next, i++) { a = g_slist_nth_data (appGUI->cal->notes_list, i); if (a->date == julian) { wbuf1 = g_regex_replace_literal (reg, a->note, -1, 0, " ", 0, NULL); break; } } g_regex_unref (reg); } if (wbuf1 != NULL) { g_strstrip (wbuf1); g_snprintf (buf1, max_event_length, "\n%s", wbuf1); g_strlcat (buffer, buf1, BUFFER_SIZE); g_free (wbuf1); } } #ifdef HAVE_LIBICAL /* ical */ if (config.cal_print_ical) { } #endif /* HAVE_LIBICAL */ g_strstrip (buffer); }