/**
* uploads_get_dialog:
*
* Returns the a #GtkWindow representing the Uploads window. If it
* has not already been created, it creates it. The Uploads window is
* set to be hidden instead of destroyed when closed, to avoid having
* to recreate it and re-parse the UI file, etc.
**/
static GtkWindow *
uploads_get_dialog (XviewerPostasaPlugin *plugin)
{
GtkBuilder *builder;
GError *error = NULL;
GtkButton *cancel_button;
GtkButton *cancel_all_button;
if (plugin->priv->uploads_window == NULL) {
builder = gtk_builder_new ();
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
gtk_builder_add_from_resource (builder, GTKBUILDER_UPLOAD_FILE,
&error);
if (error != NULL) {
g_warning ("Couldn't load Postasa uploads UI file:%d:%s", error->code, error->message);
g_error_free (error);
return NULL;
}
/* note: do not unref gtk_builder_get_object() returns */
plugin->priv->uploads_window = GTK_WINDOW (gtk_builder_get_object (builder, "uploads_window"));
plugin->priv->uploads_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "uploads_view"));
plugin->priv->uploads_store = GTK_LIST_STORE (gtk_builder_get_object (builder, "uploads_store"));
cancel_button = GTK_BUTTON (gtk_builder_get_object (builder, "cancel_button"));
cancel_all_button = GTK_BUTTON (gtk_builder_get_object (builder, "cancel_all_button"));
/* TODO: can't set expand = TRUE when packing cells into columns via glade-3/GtkBuilder apparently?
bgo #602152 So for now, we take them, clear them out, and remap them. Ugh. Better solutions welcome. */
GtkTreeViewColumn *file_col = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (builder, "file_col"));
GtkCellRenderer *thumbnail_cell = GTK_CELL_RENDERER (gtk_builder_get_object (builder, "thumbnail_cell"));
GtkCellRenderer *filepath_cell = GTK_CELL_RENDERER (gtk_builder_get_object (builder, "filepath_cell"));
gtk_tree_view_column_clear (file_col);
gtk_tree_view_column_pack_start (file_col, thumbnail_cell, FALSE);
gtk_tree_view_column_pack_end (file_col, filepath_cell, TRUE);
gtk_tree_view_column_add_attribute (file_col, thumbnail_cell, "pixbuf", 0);
gtk_tree_view_column_add_attribute (file_col, filepath_cell, "text", 1);
GtkTreeViewColumn *progress_col = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (builder, "progress_col"));
GtkCellRenderer *progress_cell = GTK_CELL_RENDERER (gtk_builder_get_object (builder, "progress_cell"));
gtk_tree_view_column_clear (progress_col);
gtk_tree_view_column_pack_end (progress_col, progress_cell, TRUE);
gtk_tree_view_column_add_attribute (progress_col, progress_cell, "pulse", 3);
gtk_tree_view_column_add_attribute (progress_col, progress_cell, "text", 5);
g_object_unref (builder);
g_signal_connect (G_OBJECT (cancel_button), "clicked", G_CALLBACK (uploads_cancel_cb), plugin);
g_signal_connect (G_OBJECT (cancel_all_button), "clicked", G_CALLBACK (uploads_cancel_all_cb), plugin);
g_signal_connect (G_OBJECT (plugin->priv->uploads_window), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), plugin);
}
return plugin->priv->uploads_window;
}
void
setup_treeview (GtkWidget *treeview,
GtkTreeModel *model,
char *headers[],
int render_index)
{
GtkTreeSelection *selection;
int i;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
g_assert (selection != NULL);
for (i = 0; headers[i] != NULL; i++) {
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_end (column, renderer, FALSE);
gtk_tree_view_column_set_title (column, headers[i]);
gtk_tree_view_column_add_attribute (column,
renderer,
"text", i + render_index);
gtk_tree_view_column_set_sizing(column,
GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_insert_column (GTK_TREE_VIEW (treeview),
column,
-1);
}
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview),
model);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
}
static void
cg_combo_flags_cell_layout_pack_end (GtkCellLayout *layout,
GtkCellRenderer *cell,
gboolean expand)
{
CgComboFlags *combo;
CgComboFlagsPrivate *priv;
CgComboFlagsCellInfo *info;
combo = CG_COMBO_FLAGS (layout);
priv = CG_COMBO_FLAGS_PRIVATE (combo);
g_object_ref (cell);
g_object_ref_sink (cell);
info = g_new0 (CgComboFlagsCellInfo, 1);
info->cell = cell;
info->expand = expand;
info->pack = GTK_PACK_END;
priv->cells = g_slist_append (priv->cells, info);
if (priv->column != NULL)
gtk_tree_view_column_pack_end (priv->column, cell, expand);
}
static VALUE
tvc_pack_end(VALUE self, VALUE cell, VALUE expand)
{
G_CHILD_ADD(self, cell);
gtk_tree_view_column_pack_end(_SELF(self), RVAL2CELLRENDERER(cell), RVAL2CBOOL(expand));
return self;
}
SidebarIndexPage::SidebarIndexPage(Control* control) : AbstractSidebarPage(
control)
{
XOJ_INIT_TYPE(SidebarIndexPage);
this->searchTimeout = 0;
this->hasContents = false;
this->treeViewBookmarks = gtk_tree_view_new();
g_object_ref(this->treeViewBookmarks);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(treeViewBookmarks), true);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeViewBookmarks),
DOCUMENT_LINKS_COLUMN_NAME);
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeViewBookmarks),
(GtkTreeViewSearchEqualFunc) treeSearchFunction, this, NULL);
this->scrollBookmarks = gtk_scrolled_window_new(NULL, NULL);
g_object_ref(this->scrollBookmarks);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollBookmarks),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollBookmarks),
GTK_SHADOW_IN);
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
treeViewBookmarks));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeViewBookmarks), FALSE);
gtk_container_add(GTK_CONTAINER(scrollBookmarks), treeViewBookmarks);
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeViewBookmarks), column);
GtkCellRenderer* renderer = (GtkCellRenderer*) g_object_new(
GTK_TYPE_CELL_RENDERER_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, TRUE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer,
"markup", DOCUMENT_LINKS_COLUMN_NAME, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer,
"text", DOCUMENT_LINKS_COLUMN_PAGE_NUMBER, NULL);
g_object_set(G_OBJECT(renderer), "style", PANGO_STYLE_ITALIC, NULL);
g_signal_connect(treeViewBookmarks, "cursor-changed",
G_CALLBACK(treeBookmarkSelected), this);
gtk_widget_show(this->treeViewBookmarks);
registerListener(control);
}
void
create_user_privileges_table (void)
{
GtkWidget *list;
GtkTreeModel *model, *filter_model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeIter iter;
list = gst_dialog_get_widget (tool->main_dialog, "user_privileges");
model = GTK_TREE_MODEL (gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_OBJECT));
filter_model = gtk_tree_model_filter_new (model, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (list), filter_model);
g_object_unref (filter_model);
g_object_unref (model);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), COL_DESCRIPTION, GTK_SORT_ASCENDING);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter_model),
privileges_table_visible_func,
NULL, NULL);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column,
renderer,
"active", COL_MEMBER,
NULL);
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (on_user_privilege_toggled), filter_model);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_end (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column,
renderer,
"text", COL_DESCRIPTION,
NULL);
gtk_tree_view_column_set_sort_column_id (column, 1);
gtk_tree_view_insert_column (GTK_TREE_VIEW (list), column, 0);
}
void cgraphics_treeview_widget_create( widget_t *widget )
{
GtkTreeSelection *select;
GtkTreeViewColumn *tvc;
GtkCellRenderer *irenderer, *trenderer;
GtkTreeModel *model;
widget->native = gtk_scrolled_window_new( NULL, NULL );
gtk_scrolled_window_set_policy( widget->native, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
gtk_scrolled_window_set_shadow_type( widget->native, GTK_SHADOW_IN );
widget->container = gtk_tree_view_new( );
gtk_container_add( widget->native, widget->container );
gtk_widget_show( GTK_WIDGET( widget->container ) );
cgraphics_widget_create( widget );
gtk_tree_view_set_headers_visible( widget->container, FALSE );
select = gtk_tree_view_get_selection( GTK_TREE_VIEW(widget->container) );
gtk_tree_selection_set_mode( select, GTK_SELECTION_SINGLE );
g_signal_connect( G_OBJECT(select), "changed", G_CALLBACK(cgraphics_treeview_selected_handler), widget );
g_signal_connect( G_OBJECT(widget->container), "button-press-event", G_CALLBACK(cgraphics_treeview_rightclick_handler), widget );
model = (GtkTreeModel *)gtk_tree_store_new( 3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER );
gtk_tree_view_set_model( GTK_TREE_VIEW(widget->container), model );
g_object_unref( model );
irenderer = gtk_cell_renderer_pixbuf_new( );
trenderer = gtk_cell_renderer_text_new( );
tvc = gtk_tree_view_column_new( );
gtk_tree_view_column_set_title( tvc, "Column" );
gtk_tree_view_column_pack_start( tvc, irenderer, FALSE );
gtk_tree_view_column_pack_end( tvc, trenderer, TRUE );
gtk_tree_view_column_add_attribute( tvc, irenderer, "pixbuf", 0 );
gtk_tree_view_column_add_attribute( tvc, trenderer, "text", 1 );
gtk_tree_view_append_column( GTK_TREE_VIEW(widget->container), tvc );
}
GtkWidget *
call_history_view_gtk_new (boost::shared_ptr<History::Book> book,
G_GNUC_UNUSED boost::shared_ptr<Ekiga::CallCore> call_core,
G_GNUC_UNUSED boost::shared_ptr<Ekiga::ContactCore> contact_core)
{
CallHistoryViewGtk* self = NULL;
GtkListStore *store = NULL;
GtkTreeViewColumn *column = NULL;
GtkCellRenderer *renderer = NULL;
GtkTreeSelection *selection = NULL;
g_return_val_if_fail (book, (GtkWidget*)NULL);
self = (CallHistoryViewGtk*)g_object_new (CALL_HISTORY_VIEW_GTK_TYPE, NULL);
self->priv = new _CallHistoryViewGtkPrivate (book);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (self),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* build the store then the tree */
store = gtk_list_store_new (COLUMN_NUMBER,
G_TYPE_POINTER,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
self->priv->tree = (GtkTreeView*)gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self->priv->tree), FALSE);
gtk_tree_view_set_grid_lines (self->priv->tree, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->priv->tree));
g_object_unref (store);
/* one column should be enough for everyone */
column = gtk_tree_view_column_new ();
/* show icon */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer,
"icon-name", COLUMN_ERROR_PIXBUF);
g_object_set (renderer, "xalign", 0.0, "yalign", 0.5, "xpad", 6, "stock-size", 1, NULL);
/* show name and text */
renderer = gm_cell_renderer_bitext_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer,
"primary-text", COLUMN_NAME);
gtk_tree_view_column_add_attribute (column, renderer,
"secondary-text", COLUMN_INFO);
gtk_tree_view_append_column (self->priv->tree, column);
/* show icon */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_end (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer,
"icon-name", COLUMN_PIXBUF);
g_object_set (renderer, "xalign", 1.0, "yalign", 0.5, "xpad", 6, "stock-size", 2, NULL);
/* react to user clicks */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->tree));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed",
G_CALLBACK (on_selection_changed), self);
g_signal_connect (self->priv->tree, "event-after",
G_CALLBACK (on_clicked), self);
g_signal_connect (GTK_WIDGET (self), "map",
G_CALLBACK (on_map_cb), self);
/* connect to the signals */
self->priv->conns.add (book->contact_added.connect (boost::bind (&on_book_contact_added, _1, self)));
self->priv->conns.add (book->cleared.connect (boost::bind (&on_book_cleared, self)));
/* initial populate */
self->priv->book->visit_contacts (boost::bind (&on_visit_contacts, _1, GTK_LIST_STORE (store)));
/* register book actions */
self->priv->menu = Ekiga::GActorMenuPtr (new Ekiga::GActorMenu (*book));
return GTK_WIDGET (self);
}
/**
* create the config widget for the reconcile
* to modify/delete a reconcile
*
* \param
*
* \return a GtkWidget containing the config widget
*/
GtkWidget *gsb_reconcile_config_create ( void )
{
GtkWidget *scrolled_window;
GtkWidget *vbox_pref;
GtkWidget *paddinggrid;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeStore *reconcile_model;
GtkTreeSelection *reconcile_selection;
GtkWidget *label;
gint i;
gfloat alignment[] = {
COLUMN_LEFT, COLUMN_CENTER, COLUMN_CENTER,
COLUMN_RIGHT, COLUMN_RIGHT
};
gchar *titles[] = {
_("Account"), _("Init date"), _("Final date"),
_("Init balance"), _("Final balance")
};
GtkWidget *table_selection;
GtkWidget *button;
gint width_entry = 80;
GrisbiWinEtat *w_etat;
w_etat = (GrisbiWinEtat *) grisbi_win_get_w_etat ();
vbox_pref = new_vbox_with_title_and_icon ( _("Reconciliation"),
"gsb-reconciliation-32.png" );
gsb_automem_radiobutton3_new_with_title ( vbox_pref,
_("Select the end date of reconciliation: "),
_("Start Date + one month"),
_("Today's date"),
NULL,
&w_etat->reconcile_end_date,
G_CALLBACK ( gsb_reconcile_config_end_date_changed ),
NULL,
GTK_ORIENTATION_HORIZONTAL );
paddinggrid = utils_prefs_paddinggrid_new_with_title (vbox_pref, _("List of reconciliations"));
gtk_widget_set_vexpand (paddinggrid, TRUE);
/* set the list */
scrolled_window = utils_prefs_scrolled_window_new ( NULL, GTK_SHADOW_IN, SW_COEFF_UTIL_PG, 200);
gtk_grid_attach (GTK_GRID (paddinggrid), scrolled_window, 0, 0, 3, 3);
/* need to create first the table to set it in the arg of the changed signal of selection */
table_selection = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (table_selection), 6);
gtk_grid_set_column_spacing (GTK_GRID (table_selection), 6);
/* create the model */
reconcile_model = gtk_tree_store_new ( NUM_RECONCILIATION_COLUMNS,
G_TYPE_STRING, /* Name account or reconciliation */
G_TYPE_STRING, /* init date */
G_TYPE_STRING, /* final date */
G_TYPE_STRING, /* init balance */
G_TYPE_STRING, /* final balance */
G_TYPE_INT, /* Account number */
G_TYPE_INT, /* Bold or regular text */
G_TYPE_INT, /* reconciliation number */
GDK_TYPE_RGBA);
reconcile_treeview = gtk_tree_view_new_with_model ( GTK_TREE_MODEL (reconcile_model) );
gtk_widget_set_name (reconcile_treeview, "tree_view");
g_object_unref (G_OBJECT(reconcile_model));
gtk_tree_selection_set_mode ( gtk_tree_view_get_selection (GTK_TREE_VIEW (reconcile_treeview)),
GTK_SELECTION_SINGLE );
gtk_container_add ( GTK_CONTAINER (scrolled_window), reconcile_treeview );
reconcile_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (reconcile_treeview));
g_signal_connect (reconcile_selection,
"changed",
G_CALLBACK (gsb_reconcile_config_select),
table_selection);
/* Name */
for (i=RECONCILIATION_NAME_COLUMN ; i<RECONCILIATION_ACCOUNT_COLUMN ; i++)
{
cell = gtk_cell_renderer_text_new ();
g_object_set ( G_OBJECT (cell),
"xalign", alignment[i],
NULL );
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_sizing ( column,
GTK_TREE_VIEW_COLUMN_AUTOSIZE );
gtk_tree_view_column_set_alignment ( column,
alignment[i] );
gtk_tree_view_column_pack_end ( column, cell, TRUE );
gtk_tree_view_column_set_title ( column, titles[i] );
gtk_tree_view_column_set_attributes (column, cell,
"text", i,
"weight", RECONCILIATION_WEIGHT_COLUMN,
"cell-background-rgba", RECONCILIATION_BACKGROUND_COLOR,
NULL);
gtk_tree_view_column_set_expand ( column, TRUE );
gtk_tree_view_column_set_resizable ( column,
TRUE );
gtk_tree_view_append_column ( GTK_TREE_VIEW(reconcile_treeview), column);
}
/* Various remaining settings */
gsb_reconcile_config_fill();
/* Set the reconcile_sort */
button = gsb_automem_checkbutton_new (_("Sort by descending date the reconciliations"),
&w_etat->reconcile_sort,
G_CALLBACK (gsb_reconcile_config_sort_reconcile),
NULL);
gtk_widget_set_margin_top (button, MARGIN_TOP);
gtk_grid_attach (GTK_GRID (paddinggrid), button, 0, 3, 1, 1);
button = gtk_button_new_with_label (_("Collapse row"));
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (G_OBJECT (button),
"clicked",
G_CALLBACK (gsb_reconcile_button_collapse_row_clicked),
reconcile_selection);
gtk_grid_attach (GTK_GRID (paddinggrid), button, 1, 3, 1, 1);
/* set signal here because data is button */
g_signal_connect (reconcile_treeview,
"row-expanded",
G_CALLBACK (gsb_reconcile_treeview_row_expanded),
button);
g_signal_connect (reconcile_treeview,
"row-collapsed",
G_CALLBACK (gsb_reconcile_treeview_row_collapsed),
button);
/* set the modifying part under the list */
paddinggrid = utils_prefs_paddinggrid_new_with_title (vbox_pref,_("Selected reconcile") );
/* for that we make a table 2x3 but with the names 4x3,
* the table has been set before to accept as arg on the changed selection */
gtk_grid_attach (GTK_GRID (paddinggrid), table_selection, 0, 0, 1, 1);
/* set the name */
label = gtk_label_new ( _("Reconciliation reference: ") );
utils_labels_set_alignment ( GTK_LABEL (label), 0, 0.5);
gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
gtk_grid_attach (GTK_GRID (table_selection), label, 0, 0, 1, 1);
reconcile_name_entry = gsb_autofunc_entry_new ( NULL,
G_CALLBACK (gsb_reconcile_config_update_line), reconcile_treeview,
G_CALLBACK (gsb_data_reconcile_set_name), 0 );
gtk_widget_set_size_request ( reconcile_name_entry, width_entry, -1 );
gtk_grid_attach (GTK_GRID (table_selection), reconcile_name_entry, 1, 0, 1, 1);
/* set the initial date */
label = gtk_label_new ( _("Initial date: ") );
utils_labels_set_alignment ( GTK_LABEL (label), 0, 0.5);
gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
gtk_grid_attach (GTK_GRID (table_selection), label, 0, 1, 1, 1);
reconcile_init_date_entry = gsb_autofunc_date_new ( NULL,
G_CALLBACK (gsb_reconcile_config_update_line), reconcile_treeview,
G_CALLBACK (gsb_data_reconcile_set_init_date), 0 );
gtk_widget_set_size_request ( reconcile_init_date_entry, width_entry, -1 );
gtk_grid_attach (GTK_GRID (table_selection), reconcile_init_date_entry, 1, 1, 1, 1);
/* set the final date */
label = gtk_label_new ( _("Final date: ") );
utils_labels_set_alignment ( GTK_LABEL (label), 0, 0.5);
gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
gtk_grid_attach (GTK_GRID (table_selection), label, 0, 2, 1, 1);
reconcile_final_date_entry = gsb_autofunc_date_new ( NULL,
G_CALLBACK (gsb_reconcile_config_update_line), reconcile_treeview,
G_CALLBACK (gsb_data_reconcile_set_final_date), 0 );
gtk_widget_set_size_request ( reconcile_final_date_entry, width_entry, -1 );
gtk_grid_attach (GTK_GRID (table_selection), reconcile_final_date_entry, 1, 2, 1, 1);
/* set the delete button */
delete_reconcile_button = gtk_button_new_with_label (_("Delete the reconcile"));
gtk_button_set_relief ( GTK_BUTTON (delete_reconcile_button), GTK_RELIEF_NORMAL);
g_signal_connect ( G_OBJECT (delete_reconcile_button), "clicked",
G_CALLBACK (gsb_reconcile_config_delete),
reconcile_treeview );
gtk_grid_attach (GTK_GRID (table_selection), delete_reconcile_button, 2, 0, 2, 1);
/* set the initial balance */
label = gtk_label_new ( _("Initial balance: ") );
utils_labels_set_alignment ( GTK_LABEL (label), 0, 0.5);
gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
gtk_grid_attach (GTK_GRID (table_selection), label, 2, 1, 1, 1);
reconcile_init_balance_entry = gsb_autofunc_real_new ( null_real,
G_CALLBACK (gsb_reconcile_config_update_line), reconcile_treeview,
G_CALLBACK (gsb_data_reconcile_set_init_balance), 0 );
gtk_widget_set_size_request ( reconcile_init_balance_entry, width_entry, -1 );
gtk_grid_attach (GTK_GRID (table_selection), reconcile_init_balance_entry, 3, 1, 1, 1);
/* set the final balance */
label = gtk_label_new ( _("Final balance: ") );
utils_labels_set_alignment ( GTK_LABEL (label), 0, 0.5);
gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
gtk_grid_attach (GTK_GRID (table_selection), label, 2, 2, 1, 1);
reconcile_final_balance_entry = gsb_autofunc_real_new ( null_real,
G_CALLBACK (gsb_reconcile_config_update_line), reconcile_treeview,
G_CALLBACK (gsb_data_reconcile_set_final_balance), 0 );
gtk_widget_set_size_request ( reconcile_final_balance_entry, width_entry, -1 );
gtk_grid_attach (GTK_GRID (table_selection), reconcile_final_balance_entry, 3, 2, 1, 1);
/* at the beginning, the table is unsensitive */
gtk_widget_set_sensitive ( table_selection, FALSE );
/* set the button to find non-associated transactions */
button = gtk_button_new_with_label (
_("Find all marked transactions not associated with a reconciliation"));
gtk_button_set_relief ( GTK_BUTTON (button), GTK_RELIEF_NORMAL );
utils_widget_set_padding (button, 0, MARGIN_TOP);
g_signal_connect ( G_OBJECT (button),
"clicked",
G_CALLBACK (gsb_reconcile_config_find_alone_transactions),
NULL );
gtk_grid_attach (GTK_GRID (paddinggrid), button, 0, 1, 1, 1);
gtk_widget_show_all (vbox_pref);
utils_set_tree_store_background_color (reconcile_treeview, RECONCILIATION_BACKGROUND_COLOR);
if ( !gsb_data_account_get_accounts_amount () )
{
gtk_widget_set_sensitive ( vbox_pref, FALSE );
}
return vbox_pref;
}
static GtkWidget *create_right(void)
{
GtkWidget *mainbox;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scrolled;
GtkWidget *tree;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
mainbox = gtk_vbox_new(FALSE, 24);
gtk_container_set_border_width(GTK_CONTAINER(mainbox), 8);
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(mainbox), vbox, TRUE, TRUE, 0);
label = create_label("Networks");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(vbox), scrolled);
tree = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
gtk_container_add(GTK_CONTAINER(scrolled), tree);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), 0,
NULL, gtk_cell_renderer_pixbuf_new(),
status_to_icon, NULL, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(tree), 0);
gtk_tree_view_column_set_min_width(column, 24);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer,
"text", CONNMAN_COLUMN_NAME);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_end(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
security_to_icon, NULL, NULL);
tree_networks = tree;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(select_callback), NULL);
return mainbox;
}
PrefabSelector::PrefabSelector () :
_widget(gtk_vbox_new(FALSE, 2)), _store(gtk_tree_store_new(PREFAB_STORE_SIZE, G_TYPE_STRING, G_TYPE_STRING,
GDK_TYPE_PIXBUF, G_TYPE_STRING)),
_fileFiltered(gtk_tree_model_filter_new(GTK_TREE_MODEL(_store), NULL)), _fileSorted(
GTK_TREE_MODEL(gtk_tree_model_sort_new_with_model(_fileFiltered))), _view(
GTK_TREE_VIEW(gtk_tree_view_new_with_model(_fileSorted)))
{
std::string fullpath = GlobalRegistry().get(RKEY_APP_PATH) + "prefabs/";
_selectedSelectionStrategy = PREFAB_SELECT_EXTEND;
GtkWidget* scr = gtk_scrolled_window_new(0, 0);
gtk_box_pack_start(GTK_BOX(_widget), scr, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scr), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scr), GTK_SHADOW_IN);
{
gtk_tree_view_set_enable_search(_view, TRUE);
gtk_tree_view_set_search_column(_view, PREFAB_SHORTNAME);
gtk_tree_view_set_headers_visible(_view, TRUE);
gtk_tree_view_set_headers_clickable(_view, TRUE);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_grid_lines(_view, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL);
#endif
g_signal_connect(G_OBJECT(_view), "button_press_event", G_CALLBACK(callbackButtonPress), this);
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Prefab"));
gtk_tree_view_column_set_expand(column, FALSE);
gtk_tree_view_column_set_sort_indicator(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, PREFAB_SHORTNAME);
gtk_tree_view_append_column(_view, column);
GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_renderer_set_fixed_size(imageRenderer, 128, -1);
gtk_tree_view_column_pack_start(column, imageRenderer, false);
gtk_tree_view_column_add_attribute(column, imageRenderer, "pixbuf", PREFAB_IMAGE);
GtkCellRenderer* nameRenderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(column, nameRenderer, false);
gtk_tree_view_column_add_attribute(column, nameRenderer, "markup", PREFAB_DESCRIPTION);
}
gtk_container_add(GTK_CONTAINER(scr), GTK_WIDGET(_view));
g_object_unref(G_OBJECT(_store));
}
GtkWidget* hboxFooter = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(_widget), hboxFooter, FALSE, TRUE, 0);
{
// options
GtkWidget* vboxOptions = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxOptions, FALSE, TRUE, 0);
GtkRadioButton* radioExtendSelection =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(NULL, _("Extend current selection")));
gtk_widget_ref(GTK_WIDGET(radioExtendSelection));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioExtendSelection), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioExtendSelection), "handler", gint_to_pointer(
g_signal_connect(radioExtendSelection,
"toggled", G_CALLBACK(callbackSelectionOptionToggleExtend), this)));
GtkRadioButton
* radioUnselect =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioExtendSelection, _("Deselect before insert")));
gtk_widget_ref(GTK_WIDGET(radioUnselect));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioUnselect), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioUnselect), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioUnselect),
"toggled", G_CALLBACK(callbackSelectionOptionToggleUnselect), this)));
GtkRadioButton
* radioReplace =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioUnselect, _("Replace current selection")));
gtk_widget_ref(GTK_WIDGET(radioReplace));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioReplace), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioReplace), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioReplace),
"toggled", G_CALLBACK(callbackSelectionOptionToggleReplace), this)));
}
{
//search entry, connect to file filter
GtkWidget* vboxSearch = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxSearch, FALSE, TRUE, 3);
GtkWidget *searchEntry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vboxSearch), searchEntry, FALSE, TRUE, 3);
gtk_widget_show(searchEntry);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(_fileFiltered),
(GtkTreeModelFilterVisibleFunc) callbackFilterFiles, this, NULL);
g_signal_connect(G_OBJECT(searchEntry), "changed", G_CALLBACK(callbackRefilter), NULL);
_filterEntry = GTK_ENTRY(searchEntry);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_search_entry(_view, _filterEntry);
#endif
}
/* fill prefab store with data */
Directory_forEach(fullpath, LoadPrefabDirectoryFunctor(fullpath, "", NULL, _store));
Directory_forEach(fullpath, MatchFileExtension<LoadPrefabFileFunctor> ("map", LoadPrefabFileFunctor("", NULL, _store)));
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(_fileFiltered));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(_fileSorted), PREFAB_SHORTNAME, GTK_SORT_ASCENDING);
}
GtkWidget *
CChoosebook::create_tree()
{
GtkWidget *sw;
GtkTreeStore *model;
GtkTreeIter iter;
gchar *filename;
model = gtk_tree_store_new (3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING);
filename = g_build_filename(g_pReciteWord->userpath, "hardbooks", NULL);
gtk_tree_store_append (model, &iter, NULL);
gtk_tree_store_set (model, &iter, 0,Skin->choosebook.dir.p[0],1, _("hardbooks"),2,filename, -1);
create_tree_model(filename,model, &iter);
g_free(filename);
filename = g_build_filename(g_pReciteWord->userpath, "books", NULL);
gtk_tree_store_append (model, &iter, NULL);
gtk_tree_store_set (model, &iter, 0,Skin->choosebook.dir.p[0],1, _("my books"),2,filename, -1);
create_tree_model(filename,model, &iter);
g_free(filename);
gtk_tree_store_append (model, &iter, NULL);
filename = g_build_filename(reciteword_data_dir, "books", NULL);
gtk_tree_store_set (model, &iter,
0,Skin->choosebook.dir.p[0],1, _("books"),2, filename,
-1);
create_tree_model(filename,model, &iter);
g_free(filename);
tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
g_object_unref (model);
/*GtkTreeViewColumn *column;
GtkCellRenderer *cell_renderer;
column = gtk_tree_view_column_new ();
cell_renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column,
cell_renderer,
FALSE);
cell_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column,
cell_renderer,
TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
column);*/
GtkCellRenderer *renderer_image;
GtkCellRenderer *renderer_text;
GtkTreeViewColumn *column;
renderer_image = gtk_cell_renderer_pixbuf_new();
renderer_text = gtk_cell_renderer_text_new ();
//g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column,_("Directories"));
gtk_tree_view_column_pack_start(column,renderer_image,FALSE);
gtk_tree_view_column_add_attribute(column,
renderer_image,
"pixbuf",0);
gtk_tree_view_column_pack_end(column,renderer_text,TRUE);
gtk_tree_view_column_add_attribute(column,
renderer_text,
"text",1);
gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view),column,-1);
/* col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Folder",
renderer, "text",
0,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1);*/
//gtk_tree_view_column_set_visible(GTK_TREE_VIEW_COLUMN (column), FALSE);
gtk_tree_view_column_set_clickable (column, TRUE);
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
gtk_tree_view_expand_all(GTK_TREE_VIEW(tree_view));
//gtk_tree_selection_set_select_function(selection,tree_selection_func,this,NULL);
g_signal_connect (G_OBJECT (selection),
"changed",
G_CALLBACK (on_choosebook_tree_selection_changed),
this);
/*g_signal_connect (G_OBJECT (tree_view),
"button_press_event",
G_CALLBACK (on_choosebook_tree_button_press),
this);*/
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request(sw,Skin->choosebook.book_tree.w,Skin->choosebook.book_tree.h);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw), tree_view);
gtk_widget_show(tree_view);
return sw;
}
/**
* Creates the "Payment methods" tab. It uses a nice GtkTreeView.
*
* \param
*
* \returns A newly allocated vbox
*/
GtkWidget *gsb_payment_method_config_create ( void )
{
GtkWidget *vbox_pref, *hbox, *scrolled_window, *paddingbox;
GtkWidget *vbox, *table, *menu, *item, *label;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkWidget *bouton_ajouter_type;
GtkTreeStore *payment_method_model;
gint width_entry = 80;
/* Now we have a model, create view */
vbox_pref = new_vbox_with_title_and_icon ( _("Payment methods"),
"payment.png" );
/* Known payment methods */
paddingbox = new_paddingbox_with_title (vbox_pref, TRUE,
_("Known payment methods"));
hbox = gtk_hbox_new ( FALSE, 6 );
gtk_box_pack_start ( GTK_BOX ( paddingbox ), hbox,
TRUE, TRUE, 0 );
/* Create tree */
scrolled_window = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW ( scrolled_window ),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC );
gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW ( scrolled_window ),
GTK_SHADOW_IN);
gtk_box_pack_start ( GTK_BOX ( hbox ), scrolled_window,
TRUE, TRUE, 0 );
/* Create tree view */
payment_method_model = gtk_tree_store_new (NUM_PAYMENT_METHODS_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_INT,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_INT,
G_TYPE_INT );
payment_method_treeview = gtk_tree_view_new_with_model ( GTK_TREE_MODEL (payment_method_model) );
g_object_unref (G_OBJECT(payment_method_model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (payment_method_treeview), TRUE);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (payment_method_treeview)),
"changed",
G_CALLBACK (gsb_payment_method_config_select),
payment_method_treeview);
/* Account */
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ( );
gtk_tree_view_column_pack_end ( column, cell, TRUE );
gtk_tree_view_column_set_title ( column, _("Account") );
gtk_tree_view_column_set_attributes (column, cell,
"text", PAYMENT_METHODS_NAME_COLUMN,
NULL);
gtk_tree_view_append_column ( GTK_TREE_VIEW(payment_method_treeview), column);
/* Defaults */
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (gsb_payment_method_config_toggled), payment_method_treeview);
gtk_cell_renderer_toggle_set_radio ( GTK_CELL_RENDERER_TOGGLE(cell), TRUE );
g_object_set (cell, "xalign", 0.5, NULL);
column = gtk_tree_view_column_new ( );
gtk_tree_view_column_set_alignment ( column, 0.5 );
gtk_tree_view_column_pack_end ( column, cell, TRUE );
gtk_tree_view_column_set_title ( column, _("Default") );
gtk_tree_view_column_set_attributes (column, cell,
"active", PAYMENT_METHODS_DEFAULT_COLUMN,
"activatable", PAYMENT_METHODS_ACTIVABLE_COLUMN,
"visible", PAYMENT_METHODS_VISIBLE_COLUMN,
NULL);
gtk_tree_view_append_column ( GTK_TREE_VIEW(payment_method_treeview), column);
/* Numbering */
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ( );
gtk_tree_view_column_pack_end ( column, cell, TRUE );
gtk_tree_view_column_set_title ( column, _("Numbering") );
gtk_tree_view_column_set_attributes (column, cell,
"text", PAYMENT_METHODS_NUMBERING_COLUMN,
NULL);
gtk_tree_view_append_column ( GTK_TREE_VIEW(payment_method_treeview), column);
/* expand all rows after the treeview widget has been realized */
g_signal_connect (payment_method_treeview, "realize",
G_CALLBACK (gtk_tree_view_expand_all), NULL);
gtk_container_add ( GTK_CONTAINER ( scrolled_window ),
payment_method_treeview );
gsb_payment_method_config_fill_list (GTK_TREE_MODEL (payment_method_model));
/* Create "Add" & "Remove" buttons */
vbox = gtk_vbox_new ( FALSE, 6 );
gtk_box_pack_start ( GTK_BOX ( hbox ), vbox,
FALSE, FALSE, 0 );
/* "Add payment method" button */
bouton_ajouter_type = gtk_button_new_from_stock (GTK_STOCK_ADD);
gtk_button_set_relief ( GTK_BUTTON ( bouton_ajouter_type ),
GTK_RELIEF_NONE );
g_signal_connect ( G_OBJECT ( bouton_ajouter_type ),
"clicked",
G_CALLBACK (gsb_payment_method_config_add),
payment_method_treeview );
gtk_box_pack_start ( GTK_BOX ( vbox ), bouton_ajouter_type,
TRUE, FALSE, 5 );
/* "Remove payment method" button */
payment_remove_button = gtk_button_new_from_stock (GTK_STOCK_REMOVE);
gtk_button_set_relief ( GTK_BUTTON ( payment_remove_button ),
GTK_RELIEF_NONE );
gtk_widget_set_sensitive ( payment_remove_button, FALSE );
g_signal_connect ( G_OBJECT ( payment_remove_button ),
"clicked",
G_CALLBACK (gsb_payment_method_config_remove),
payment_method_treeview );
gtk_box_pack_start ( GTK_BOX ( vbox ), payment_remove_button,
TRUE, FALSE, 5 );
/* Payment method details */
details_paddingbox = new_paddingbox_with_title (vbox_pref, FALSE,
_("Payment method details"));
gtk_widget_set_sensitive ( details_paddingbox, FALSE );
/* Payment method name */
table = gtk_table_new ( 3, 3, FALSE );
gtk_table_set_col_spacings ( GTK_TABLE ( table ), 6 );
gtk_table_set_row_spacings ( GTK_TABLE ( table ), 6 );
gtk_box_pack_start ( GTK_BOX ( details_paddingbox ), table,
TRUE, TRUE, 6 );
label = gtk_label_new ( _("Name: ") );
gtk_misc_set_alignment (GTK_MISC (label), 0, 1);
gtk_label_set_justify ( GTK_LABEL(label), GTK_JUSTIFY_RIGHT );
gtk_table_attach ( GTK_TABLE ( table ),
label, 0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, 0,
0, 0 );
payment_name_entry = gsb_autofunc_entry_new ( NULL,
G_CALLBACK (gsb_payment_method_config_name_changed),
payment_method_treeview,
G_CALLBACK (gsb_data_payment_set_name), 0 );
gtk_widget_set_size_request ( payment_name_entry, width_entry, -1 );
gtk_table_attach ( GTK_TABLE ( table ),
payment_name_entry, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, 0,
0, 0 );
/* button show entry, automatic numbering button will be shown only if entry is showed */
button_show_entry = gsb_autofunc_checkbutton_new ( _("Need entry field"),
FALSE,
G_CALLBACK (gsb_payment_method_config_show_entry_changed), payment_method_treeview,
G_CALLBACK (gsb_data_payment_set_show_entry), 0 );
gtk_table_attach ( GTK_TABLE ( table ),
button_show_entry, 2, 3, 0, 1,
GTK_SHRINK | GTK_FILL, 0,
0, 0 );
/* Automatic numbering */
label = gtk_label_new ( _("Automatic numbering: ") );
gtk_misc_set_alignment (GTK_MISC (label), 0, 1);
gtk_label_set_justify ( GTK_LABEL(label), GTK_JUSTIFY_RIGHT );
gtk_table_attach ( GTK_TABLE ( table ),
label, 0, 1, 1, 2,
GTK_SHRINK | GTK_FILL, 0,
0, 0 );
payment_last_number_entry = gsb_autofunc_spin_new ( 0,
G_CALLBACK (gsb_payment_method_config_auto_entry_changed),
payment_method_treeview,
G_CALLBACK (gsb_data_payment_set_last_number_from_int),
0 );
gtk_widget_set_size_request ( payment_last_number_entry, width_entry, -1 );
gtk_table_attach ( GTK_TABLE ( table ),
payment_last_number_entry, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, 0,
0, 0 );
/* button automatic numbering, activate it sensitive the automatic numbering entry */
button_auto_numbering = gsb_autofunc_checkbutton_new ( _("Activate"),
FALSE,
G_CALLBACK (gsb_payment_method_config_auto_button_changed), payment_method_treeview,
G_CALLBACK (gsb_data_payment_set_automatic_numbering), 0 );
gtk_table_attach ( GTK_TABLE ( table ),
button_auto_numbering, 2, 3, 1, 2,
GTK_SHRINK | GTK_FILL, 0,
0, 0 );
/* Payment method method_ptr */
label = gtk_label_new ( _("Type: ") );
gtk_misc_set_alignment (GTK_MISC (label), 0, 1);
gtk_label_set_justify ( GTK_LABEL(label), GTK_JUSTIFY_RIGHT );
gtk_table_attach ( GTK_TABLE ( table ),
label, 0, 1, 2, 3,
GTK_SHRINK | GTK_FILL, 0,
0, 0 );
/* Create menu */
payment_sign_button = gtk_option_menu_new ();
menu = gtk_menu_new();
/* Neutral method_ptr */
item = gtk_menu_item_new_with_label ( _("Neutral") );
g_signal_connect ( G_OBJECT ( item ),
"activate",
G_CALLBACK ( gsb_payment_method_config_sign_changed ),
GINT_TO_POINTER (GSB_PAYMENT_NEUTRAL));
gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), item );
/* Debit method_ptr */
item = gtk_menu_item_new_with_label ( _("Debit") );
g_signal_connect ( G_OBJECT ( item ),
"activate",
G_CALLBACK ( gsb_payment_method_config_sign_changed ),
GINT_TO_POINTER (GSB_PAYMENT_DEBIT));
gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), item );
/* Credit method_ptr */
item = gtk_menu_item_new_with_label ( _("Credit") );
g_signal_connect ( G_OBJECT ( item ),
"activate",
G_CALLBACK ( gsb_payment_method_config_sign_changed ),
GINT_TO_POINTER (GSB_PAYMENT_CREDIT));
gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), item );
/* Set menu */
gtk_option_menu_set_menu ( GTK_OPTION_MENU ( payment_sign_button ), menu );
gtk_table_attach ( GTK_TABLE ( table ),
payment_sign_button, 1, 3, 2, 3,
GTK_EXPAND | GTK_FILL, 0,
0, 0 );
/** Do not set this tab sensitive is no account file is opened. */
if ( !gsb_data_account_get_accounts_amount () )
{
gtk_widget_set_sensitive ( vbox_pref, FALSE );
}
return ( vbox_pref );
}
/**
* create the config widget for the reconcile
* to choose the order of the method of payment to sort the list
* while reconciling
*
* \param
*
* \return a GtkWidget containing the config widget
*/
GtkWidget *gsb_reconcile_sort_config_create ( void )
{
GtkWidget *hbox, *scrolled_window;
GtkWidget *vbox_pref, *paddingbox;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkWidget *vbox_fleches_tri;
GtkTreeStore *reconcile_model;
GtkTreeSelection *reconcile_selection;
vbox_pref = new_vbox_with_title_and_icon ( _("Sort for reconciliation"),
"reconciliationlg.png" );
paddingbox = new_paddingbox_with_title ( vbox_pref, TRUE,
_("Reconciliation: sort transactions") );
/* la partie du milieu est une hbox avec les types */
hbox = gtk_hbox_new ( FALSE, 5 );
gtk_box_pack_start ( GTK_BOX ( paddingbox ), hbox,
TRUE, TRUE, 0 );
/* mise en place de la liste qui contient les types classés */
scrolled_window = gtk_scrolled_window_new ( NULL, NULL );
gtk_box_pack_start ( GTK_BOX ( hbox ), scrolled_window,
TRUE, TRUE, 0);
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW ( scrolled_window ),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
reconcile_model = gtk_tree_store_new ( NUM_RECONCILIATION_SORT_COLUMNS,
G_TYPE_STRING, /* Name */
G_TYPE_BOOLEAN, /* Visible */
G_TYPE_BOOLEAN, /* Sort by method of payment */
G_TYPE_BOOLEAN, /* Split neutrals */
G_TYPE_INT, /* Account number */
G_TYPE_INT, /* payment number */
G_TYPE_BOOLEAN ); /* sensitive line */
reconcile_treeview = gtk_tree_view_new_with_model ( GTK_TREE_MODEL (reconcile_model) );
g_object_unref (G_OBJECT(reconcile_model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (reconcile_treeview), TRUE);
gtk_tree_selection_set_mode ( gtk_tree_view_get_selection (GTK_TREE_VIEW (reconcile_treeview)),
GTK_SELECTION_SINGLE );
reconcile_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (reconcile_treeview));
g_signal_connect (reconcile_selection, "changed",
G_CALLBACK (gsb_reconcile_sort_config_select), reconcile_model);
/* Name */
cell = gtk_cell_renderer_text_new ( );
column = gtk_tree_view_column_new ( );
gtk_tree_view_column_pack_end ( column, cell, TRUE );
gtk_tree_view_column_set_title ( column, _("Payment method") );
gtk_tree_view_column_set_attributes (column, cell,
"text", RECONCILIATION_SORT_NAME_COLUMN,
"sensitive", RECONCILIATION_SORT_SENSITIVE_COLUMN,
NULL);
gtk_tree_view_column_set_expand ( column, TRUE );
gtk_tree_view_append_column ( GTK_TREE_VIEW(reconcile_treeview), column);
/* Sort by date */
cell = gtk_cell_renderer_toggle_new ();
gtk_cell_renderer_toggle_set_radio ( GTK_CELL_RENDERER_TOGGLE(cell), FALSE );
g_signal_connect (cell, "toggled",
G_CALLBACK (gsb_reconcile_sort_config_payment_toggled), reconcile_treeview);
g_object_set (cell, "xalign", 0.5, NULL);
column = gtk_tree_view_column_new ( );
gtk_tree_view_column_set_alignment ( column, 0.5 );
gtk_tree_view_column_pack_end ( column, cell, TRUE );
gtk_tree_view_column_set_title ( column, _("Sort by payment method") );
gtk_tree_view_column_set_attributes (column, cell,
"active", RECONCILIATION_SORT_SORT_COLUMN,
"activatable", RECONCILIATION_SORT_VISIBLE_COLUMN,
"visible", RECONCILIATION_SORT_VISIBLE_COLUMN,
NULL);
gtk_tree_view_column_set_expand ( column, TRUE );
gtk_tree_view_append_column ( GTK_TREE_VIEW(reconcile_treeview), column);
/* Split neutral payment methods */
cell = gtk_cell_renderer_toggle_new ();
gtk_cell_renderer_toggle_set_radio ( GTK_CELL_RENDERER_TOGGLE(cell), FALSE );
g_signal_connect (cell, "toggled",
G_CALLBACK (gsb_reconcile_sort_config_neutral_toggled), reconcile_treeview);
g_object_set (cell, "xalign", 0.5, NULL);
column = gtk_tree_view_column_new ( );
gtk_tree_view_column_set_alignment ( column, 0.5 );
gtk_tree_view_column_pack_end ( column, cell, TRUE );
gtk_tree_view_column_set_title ( column, _("Split neutral payment methods") );
gtk_tree_view_column_set_attributes (column, cell,
"active", RECONCILIATION_SORT_SPLIT_NEUTRAL_COLUMN,
"activatable", RECONCILIATION_SORT_VISIBLE_COLUMN,
"visible", RECONCILIATION_SORT_VISIBLE_COLUMN,
NULL);
gtk_tree_view_column_set_expand ( column, TRUE );
gtk_tree_view_append_column ( GTK_TREE_VIEW(reconcile_treeview), column);
/* Various remaining settings */
gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW ( scrolled_window ),
GTK_SHADOW_IN);
gtk_container_add ( GTK_CONTAINER ( scrolled_window ), reconcile_treeview );
gsb_reconcile_sort_config_fill();
/* set the arrows under the list */
vbox_fleches_tri = gtk_hbox_new ( TRUE, 10 );
gtk_box_pack_start ( GTK_BOX (paddingbox), vbox_fleches_tri,
FALSE, FALSE, 0);
button_move_up = gtk_button_new_from_stock (GTK_STOCK_GO_UP);
gtk_button_set_relief ( GTK_BUTTON ( button_move_up ), GTK_RELIEF_NONE );
g_signal_connect ( G_OBJECT ( button_move_up ), "clicked",
G_CALLBACK (gsb_reconcile_sort_config_move_up), reconcile_treeview );
gtk_box_pack_start ( GTK_BOX (vbox_fleches_tri),
button_move_up,
FALSE, FALSE, 0 );
gtk_widget_set_sensitive ( button_move_up, FALSE );
button_move_down = gtk_button_new_from_stock (GTK_STOCK_GO_DOWN);
gtk_button_set_relief ( GTK_BUTTON ( button_move_down ), GTK_RELIEF_NONE );
g_signal_connect ( G_OBJECT ( button_move_down ), "clicked",
G_CALLBACK (gsb_reconcile_sort_config_move_down), reconcile_treeview);
gtk_box_pack_start ( GTK_BOX (vbox_fleches_tri),
button_move_down,
FALSE, FALSE, 0 );
gtk_widget_set_sensitive ( button_move_down, FALSE );
if ( !gsb_data_account_get_accounts_amount () )
{
gtk_widget_set_sensitive ( vbox_pref, FALSE );
}
return vbox_pref;
}
FeedListView *
feed_list_view_create (GtkTreeView *treeview)
{
GtkCellRenderer *titleRenderer, *countRenderer;
GtkCellRenderer *iconRenderer;
GtkTreeViewColumn *column, *column2;
GtkTreeSelection *select;
debug_enter ("feed_list_view_create");
/* Set up store */
g_assert (NULL == flv);
flv = FEED_LIST_VIEW (g_object_new (FEED_LIST_VIEW_TYPE, NULL));
flv->treeview = treeview;
flv->feedstore = gtk_tree_store_new (FS_LEN,
G_TYPE_STRING,
G_TYPE_ICON,
G_TYPE_POINTER,
G_TYPE_UINT,
G_TYPE_STRING);
gtk_tree_view_set_model (GTK_TREE_VIEW (flv->treeview), GTK_TREE_MODEL (flv->feedstore));
/* Prepare filter */
flv->filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (flv->feedstore), NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (flv->filter),
feed_list_view_filter_visible_function,
NULL,
NULL);
g_signal_connect (G_OBJECT (flv->feedstore), "row-changed",
G_CALLBACK (feed_list_view_row_changed_cb), flv);
/* we render the icon/state, the feed title and the unread count */
iconRenderer = gtk_cell_renderer_pixbuf_new ();
titleRenderer = gtk_cell_renderer_text_new ();
countRenderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (countRenderer, 1.0, 0);
column = gtk_tree_view_column_new ();
column2 = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, iconRenderer, FALSE);
gtk_tree_view_column_pack_start (column, titleRenderer, TRUE);
gtk_tree_view_column_pack_end (column2, countRenderer, FALSE);
gtk_tree_view_column_add_attribute (column, iconRenderer, "gicon", FS_ICON);
gtk_tree_view_column_add_attribute (column, titleRenderer, "markup", FS_LABEL);
gtk_tree_view_column_add_attribute (column2, countRenderer, "markup", FS_COUNT);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
gtk_tree_view_column_set_sizing (column2, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
gtk_tree_view_append_column (flv->treeview, column);
gtk_tree_view_append_column (flv->treeview, column2);
g_object_set (titleRenderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_signal_connect (G_OBJECT (flv->treeview), "row-activated", G_CALLBACK (feed_list_view_row_activated_cb), flv);
g_signal_connect (G_OBJECT (flv->treeview), "key-press-event", G_CALLBACK (feed_list_view_key_press_cb), flv);
select = gtk_tree_view_get_selection (flv->treeview);
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (select), "changed",
G_CALLBACK (feed_list_view_selection_changed_cb),
flv);
conf_get_bool_value (REDUCED_FEEDLIST, &flv->feedlist_reduced_unread);
if (flv->feedlist_reduced_unread)
feed_list_view_reduce_mode_changed (); /* before menu setup for reduced mode check box to be correct */
ui_dnd_setup_feedlist (flv->feedstore);
liferea_shell_update_feed_menu (TRUE, FALSE, FALSE);
liferea_shell_update_allitems_actions (FALSE, FALSE);
debug_exit ("feed_list_view_create");
return flv;
}
/*
* create variables tree view widget
* arguments:
* on_render_name - custom name column renderer function
* on_expression_changed - callback to call on expression changed
*/
GtkWidget* vtree_create(watch_render_name on_render_name, watch_expression_changed on_expression_changed)
{
/* create tree view */
GtkCellRenderer *renderer;
GtkCellRenderer *icon_renderer;
GtkTreeViewColumn *column;
GtkTreeStore* store = gtk_tree_store_new (
W_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
GtkWidget* tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
g_object_unref(store);
/* set tree view parameters */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_level_indentation(GTK_TREE_VIEW(tree), 10);
/* connect signals */
if (NULL != on_key_pressed)
{
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_key_pressed), NULL);
}
/* create columns */
/* Name */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_end(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer, "text", W_NAME, NULL);
icon_renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set(icon_renderer, "follow-state", TRUE, NULL);
gtk_tree_view_column_pack_end(column, icon_renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, icon_renderer, render_icon, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
if (on_render_name)
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_name, NULL, NULL);
if (on_expression_changed)
{
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (on_expression_changed), NULL);
}
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Value */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Value"), renderer, "text", W_VALUE, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, render_value, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Type */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Type"), renderer, "text", W_TYPE, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Last invisible column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", W_LAST_VISIBLE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Internal (unvisible column) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Internal", renderer, "text", W_INTERNAL, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Path expression (unvisible column) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Expression", renderer, "text", W_EXPRESSION, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* STUB (unvisible column) */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Need Update", renderer, "active", W_STUB, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_visible(column, FALSE);
/* Changed (unvisible column) */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Changed", renderer, "active", W_CHANGED, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_visible(column, FALSE);
return tree;
}
static void
goa_panel_init (GoaPanel *panel)
{
GtkWidget *button;
GtkWidget *w;
GError *error;
GtkStyleContext *context;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeIter iter;
panel->builder = gtk_builder_new ();
error = NULL;
if (gtk_builder_add_from_file (panel->builder,
CINNAMONCC_UI_DIR "/online-accounts.ui",
&error) == 0)
{
goa_warning ("Error loading UI file: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
goto out;
}
panel->toolbar = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-toolbar"));
panel->toolbar_add_button = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-toolbutton-add"));
g_signal_connect (panel->toolbar_add_button,
"clicked",
G_CALLBACK (on_toolbar_add_button_clicked),
panel);
panel->toolbar_remove_button = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-toolbutton-remove"));
g_signal_connect (panel->toolbar_remove_button,
"clicked",
G_CALLBACK (on_toolbar_remove_button_clicked),
panel);
context = gtk_widget_get_style_context (GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-scrolledwindow")));
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM);
context = gtk_widget_get_style_context (panel->toolbar);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
panel->accounts_treeview = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-treeview"));
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->accounts_treeview)),
"changed",
G_CALLBACK (on_tree_view_selection_changed),
panel);
button = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-button-add"));
g_signal_connect (button,
"clicked",
G_CALLBACK (on_add_button_clicked),
panel);
panel->accounts_vbox = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-vbox"));
/* TODO: probably want to avoid _sync() ... */
error = NULL;
panel->client = goa_client_new_sync (NULL /* GCancellable */, &error);
if (panel->client == NULL)
{
goa_warning ("Error getting a GoaClient: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
w = GTK_WIDGET (gtk_builder_get_object (panel->builder, "goa-top-widget"));
gtk_widget_set_sensitive (w, FALSE);
g_error_free (error);
goto out;
}
g_signal_connect (panel->client,
"account-changed",
G_CALLBACK (on_account_changed),
panel);
panel->accounts_model = goa_panel_accounts_model_new (panel->client);
gtk_tree_view_set_model (GTK_TREE_VIEW (panel->accounts_treeview), GTK_TREE_MODEL (panel->accounts_model));
g_signal_connect (panel->accounts_model, "row-deleted", G_CALLBACK (on_model_row_deleted), panel);
g_signal_connect (panel->accounts_model, "row-inserted", G_CALLBACK (on_model_row_inserted), panel);
column = gtk_tree_view_column_new ();
gtk_tree_view_append_column (GTK_TREE_VIEW (panel->accounts_treeview), column);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
g_object_set (G_OBJECT (renderer),
"stock-size", GTK_ICON_SIZE_DIALOG,
NULL);
gtk_tree_view_column_set_attributes (column,
renderer,
"gicon", GOA_PANEL_ACCOUNTS_MODEL_COLUMN_ICON,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
g_object_set (G_OBJECT (renderer),
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
"width-chars", 30,
NULL);
gtk_tree_view_column_set_attributes (column,
renderer,
"markup", GOA_PANEL_ACCOUNTS_MODEL_COLUMN_MARKUP,
NULL);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_end (column, renderer, FALSE);
g_object_set (G_OBJECT (renderer),
"icon-name", "dialog-error-symbolic",
NULL);
gtk_tree_view_column_set_attributes (column,
renderer,
"visible", GOA_PANEL_ACCOUNTS_MODEL_COLUMN_ATTENTION_NEEDED,
NULL);
/* Select the first row, if any */
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (panel->accounts_model),
&iter))
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->accounts_treeview)),
&iter);
out:
w = GTK_WIDGET (gtk_builder_get_object (panel->builder, "goa-top-widget"));
gtk_widget_reparent (w, GTK_WIDGET (panel));
gtk_widget_show_all (w);
}
static void
gedit_documents_panel_init (GeditDocumentsPanel *panel)
{
GtkWidget *sw;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeSelection *selection;
GIcon *icon;
gedit_debug (DEBUG_PANEL);
panel->priv = GEDIT_DOCUMENTS_PANEL_GET_PRIVATE (panel);
panel->priv->adding_tab = FALSE;
panel->priv->is_reodering = FALSE;
gtk_orientable_set_orientation (GTK_ORIENTABLE (panel),
GTK_ORIENTATION_VERTICAL);
/* Create the scrolled window */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (sw);
gtk_box_pack_start (GTK_BOX (panel), sw, TRUE, TRUE, 0);
/* Create the empty model */
panel->priv->model = GTK_TREE_MODEL (gtk_tree_store_new (N_COLUMNS,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_OBJECT,
G_TYPE_OBJECT));
/* Create the treeview */
panel->priv->treeview = gtk_tree_view_new_with_model (panel->priv->model);
g_object_unref (G_OBJECT (panel->priv->model));
gtk_container_add (GTK_CONTAINER (sw), panel->priv->treeview);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (panel->priv->treeview), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (panel->priv->treeview), FALSE); /* TODO */
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (panel->priv->treeview), FALSE);
gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (panel->priv->treeview), 18);
/* Disable search because each time the selection is changed, the
active tab is changed which focuses the view, and thus would remove
the search entry, rendering it useless */
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (panel->priv->treeview), FALSE);
/* Disable focus so it doesn't steal focus each time from the view */
gtk_widget_set_can_focus (panel->priv->treeview, FALSE);
gtk_widget_set_has_tooltip (panel->priv->treeview, TRUE);
gtk_widget_show (panel->priv->treeview);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Documents"));
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_add_attribute (column, cell, "pixbuf", PIXBUF_COLUMN);
gtk_tree_view_column_set_cell_data_func (column, cell,
(GtkTreeCellDataFunc)pixbuf_data_func,
panel, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell, "markup", NAME_COLUMN);
gtk_tree_view_append_column (GTK_TREE_VIEW (panel->priv->treeview),
column);
cell = gedit_cell_renderer_button_new ();
icon = g_themed_icon_new_with_default_fallbacks ("window-close-symbolic");
g_object_set (cell, "gicon", icon, NULL);
g_object_unref (icon);
gtk_tree_view_column_pack_end (column, cell, FALSE);
g_signal_connect (cell,
"clicked",
G_CALLBACK (close_button_clicked),
panel);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->priv->treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
panel->priv->selection_changed_handler_id = g_signal_connect (selection,
"changed",
G_CALLBACK (treeview_selection_changed),
panel);
g_signal_connect (panel->priv->treeview,
"button-press-event",
G_CALLBACK (panel_button_press_event),
panel);
g_signal_connect (panel->priv->treeview,
"query-tooltip",
G_CALLBACK (treeview_query_tooltip),
panel);
/*
g_signal_connect (panel->priv->model,
"row-inserted",
G_CALLBACK (treeview_row_inserted),
panel);*/
}
static void
contact_list_view_setup (EmpathyContactListView *view)
{
EmpathyContactListViewPriv *priv;
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
gint i;
priv = GET_PRIV (view);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (view),
empathy_contact_list_store_search_equal_func,
NULL, NULL);
g_signal_connect (priv->store, "row-has-child-toggled",
G_CALLBACK (contact_list_view_row_has_child_toggled_cb),
view);
gtk_tree_view_set_model (GTK_TREE_VIEW (view),
GTK_TREE_MODEL (priv->store));
/* Setup view */
g_object_set (view,
"headers-visible", FALSE,
"reorderable", TRUE,
"show-expanders", FALSE,
NULL);
col = gtk_tree_view_column_new ();
/* State */
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (
col, cell,
(GtkTreeCellDataFunc) contact_list_view_pixbuf_cell_data_func,
view, NULL);
g_object_set (cell,
"xpad", 5,
"ypad", 1,
"visible", FALSE,
NULL);
/* Name */
cell = empathy_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, cell, TRUE);
gtk_tree_view_column_set_cell_data_func (
col, cell,
(GtkTreeCellDataFunc) contact_list_view_text_cell_data_func,
view, NULL);
gtk_tree_view_column_add_attribute (col, cell,
"name", EMPATHY_CONTACT_LIST_STORE_COL_NAME);
gtk_tree_view_column_add_attribute (col, cell,
"status", EMPATHY_CONTACT_LIST_STORE_COL_STATUS);
gtk_tree_view_column_add_attribute (col, cell,
"is_group", EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP);
/* Voip Capability Icon */
cell = empathy_cell_renderer_activatable_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (
col, cell,
(GtkTreeCellDataFunc) contact_list_view_voip_cell_data_func,
view, NULL);
g_object_set (cell,
"visible", FALSE,
NULL);
g_signal_connect (cell, "path-activated",
G_CALLBACK (contact_list_view_voip_activated_cb),
view);
/* Avatar */
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (
col, cell,
(GtkTreeCellDataFunc) contact_list_view_avatar_cell_data_func,
view, NULL);
g_object_set (cell,
"xpad", 0,
"ypad", 0,
"visible", FALSE,
"width", 32,
"height", 32,
NULL);
/* Expander */
cell = empathy_cell_renderer_expander_new ();
gtk_tree_view_column_pack_end (col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (
col, cell,
(GtkTreeCellDataFunc) contact_list_view_expander_cell_data_func,
view, NULL);
/* Actually add the column now we have added all cell renderers */
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
/* Drag & Drop. */
for (i = 0; i < G_N_ELEMENTS (drag_types_dest); ++i) {
drag_atoms_dest[i] = gdk_atom_intern (drag_types_dest[i].target,
FALSE);
}
for (i = 0; i < G_N_ELEMENTS (drag_types_source); ++i) {
drag_atoms_source[i] = gdk_atom_intern (drag_types_source[i].target,
FALSE);
}
}
static void
gb_book_links_construct (GbBookLinks *self)
{
GbBookLinksPrivate *priv;
GtkWidget *swindow;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
priv = self->priv;
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow),
GTK_SHADOW_IN);
/* Create tree view */
priv->tree_view = gtk_tree_view_new ();
gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW (priv->tree_view), TRUE);
g_signal_connect_swapped (priv->tree_view, "row-activated",
G_CALLBACK (schedule_emit_link_activated), self);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (priv->tree_view), FALSE);
gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (priv->tree_view), 20);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view), FALSE);
gtk_container_add (GTK_CONTAINER (swindow), priv->tree_view);
gtk_box_pack_start (GTK_BOX (self), swindow, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (self));
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), column);
renderer = (GtkCellRenderer *)
g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
"ellipsize", PANGO_ELLIPSIZE_END,
"weight", PANGO_WEIGHT_BOLD,
"xpad", 10,
NULL);
gtk_tree_view_column_pack_start (GTK_TREE_VIEW_COLUMN (column), renderer, TRUE);
gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer,
"markup", BOOK_LINKS_COLUMN_MARKUP,
NULL);
renderer = gd_styled_text_renderer_new ();
gd_styled_text_renderer_add_class (GD_STYLED_TEXT_RENDERER (renderer), "dim-label");
g_object_set (renderer,
"max-width-chars", 12,
"scale", PANGO_SCALE_SMALL,
"xalign", 1.0,
"xpad", 10,
NULL);
gtk_tree_view_column_pack_end (GTK_TREE_VIEW_COLUMN (column), renderer, FALSE);
/*
gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer,
"text", BOOK_LINKS_COLUMN_LABEL,
NULL);
*/
priv->model = (GtkTreeModel *)gtk_list_store_new (BOOK_LINKS_COLUMN_N,
G_TYPE_STRING,
G_TYPE_STRING);
}
/*
* init breaks tree view and return it if succesfull
* arguments:
* cb - callback to call on treeview double click
*/
gboolean bptree_init(move_to_line_cb cb)
{
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* save double click callback */
on_break_clicked = cb;
/* crete hash table for file nodes */
files = g_hash_table_new_full(
g_str_hash,
g_str_equal,
(GDestroyNotify)g_free,
(GDestroyNotify)gtk_tree_row_reference_free
);
/* create tree view */
store = gtk_tree_store_new (
N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_BOOLEAN,
G_TYPE_STRING);
model = GTK_TREE_MODEL(store);
tree = gtk_tree_view_new_with_model (model);
g_object_unref(store);
/* set tree view properties */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), 1);
gtk_widget_set_has_tooltip(GTK_WIDGET(tree), TRUE);
/* multiple selection */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
/* connect signals */
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_key_pressed), NULL);
g_signal_connect(G_OBJECT(tree), "row-activated", G_CALLBACK (on_row_double_click), NULL);
g_signal_connect(G_OBJECT(tree), "query-tooltip", G_CALLBACK (on_query_tooltip), NULL);
/* creating columns */
/* icon, file */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new();
gtk_tree_view_column_pack_end(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_filename, NULL, NULL);
/* enable for file */
renderer = cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT(renderer), "toggled", G_CALLBACK(on_enable_for_file), NULL);
gtk_tree_view_column_pack_end(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "active", ENABLED, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_enable_for_file, NULL, NULL);
/* enable breakpoint */
renderer = cell_renderer_break_icon_new ();
g_signal_connect (G_OBJECT(renderer), "clicked", G_CALLBACK(on_enable_break), NULL);
g_object_set(renderer, "pixbuf_enabled", (gpointer)break_pixbuf, NULL);
g_object_set(renderer, "pixbuf_disabled", (gpointer)break_disabled_pixbuf, NULL);
g_object_set(renderer, "pixbuf_conditional", (gpointer)break_condition_pixbuf, NULL);
g_object_set(renderer, "pixbuf_file", (gpointer)break_pixbuf, NULL);
gtk_tree_view_column_pack_end(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "enabled", ENABLED, "condition", CONDITION, "hitscount", HITSCOUNT, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_enable_break, NULL, NULL);
gtk_tree_view_column_set_title(column, _("Location"));
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* condition */
condition_renderer = gtk_cell_renderer_text_new ();
g_object_set (condition_renderer, "editable", TRUE, NULL);
g_object_set (condition_renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_signal_connect (G_OBJECT (condition_renderer), "edited", G_CALLBACK (on_condition_changed), NULL);
column = gtk_tree_view_column_new_with_attributes (_("Condition"), condition_renderer, "text", CONDITION, NULL);
gtk_tree_view_column_set_cell_data_func(column, condition_renderer, on_render, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* hits count */
hcount_renderer = gtk_cell_renderer_spin_new ();
g_object_set (hcount_renderer,
"adjustment", gtk_adjustment_new (0.0, 0.0, 100000.0, 1.0, 2.0, 2.0),
"digits", 0, NULL);
g_signal_connect (G_OBJECT (hcount_renderer), "edited", G_CALLBACK (on_hitscount_changed), NULL);
column = gtk_tree_view_column_new_with_attributes (_("Hit count"), hcount_renderer, "text", HITSCOUNT, NULL);
gtk_tree_view_column_set_cell_data_func(column, hcount_renderer, on_render, (gpointer)TRUE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* line */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Line"), renderer, "text", LINE, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Last invisible column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", LAST_VISIBLE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
tab_breaks = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (tab_breaks);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tab_breaks), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (tab_breaks), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (tab_breaks), tree);
return TRUE;
}
static GtkWidget *
create_treeview (BluetoothChooser *self)
{
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
GtkWidget *scrolled, *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/* Create the scrolled window */
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_OUT);
/* Create the tree view */
tree = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(tree), TRUE);
g_object_set (tree, "show-expanders", FALSE, NULL);
g_signal_connect (G_OBJECT (tree), "row-activated",
G_CALLBACK (row_activated_cb), self);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Device"));
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN(column), TRUE);
/* The type icon */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_set_spacing (column, 4);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"icon-name", BLUETOOTH_COLUMN_ICON, NULL);
/* The device name */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
alias_to_label, NULL, NULL);
/* The connected icon */
priv->connected_cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, priv->connected_cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, priv->connected_cell,
connected_to_icon, NULL, NULL);
g_object_set (G_OBJECT (priv->connected_cell), "visible", priv->show_connected, NULL);
/* The bonded icon */
priv->bonded_cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_end (column, priv->bonded_cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, priv->bonded_cell,
bonded_to_icon, NULL, NULL);
g_object_set (G_OBJECT (priv->bonded_cell), "visible", priv->show_paired, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column);
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW(tree), -1,
_("Type"), gtk_cell_renderer_text_new(),
type_to_text, NULL, NULL);
priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode (priv->selection, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT(priv->selection), "changed",
G_CALLBACK(select_browse_device_callback), self);
/* Set the model, and filter */
priv->model = bluetooth_client_get_device_model (priv->client);
if (priv->model) {
priv->filter = gtk_tree_model_filter_new (priv->model, NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->filter),
filter_func, self, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW(tree), priv->filter);
g_signal_connect (priv->filter, "row-changed",
G_CALLBACK (device_model_row_changed), self);
g_object_unref (priv->filter);
} else {
gtk_widget_set_sensitive (GTK_WIDGET (tree), FALSE);
set_search_label (self, FALSE);
}
gtk_container_add (GTK_CONTAINER(scrolled), tree);
priv->treeview = tree;
return scrolled;
}
