//! pembuatan view
GtkWidget *tableCreate (void){
table = struct_new(table_);
databaseCreate();
GtkTreeModel *model;
table->view = gtk_tree_view_new();
//header
GtkTreeViewColumn *col = tableCreateHeader(table->view);
/* connect a cell data function */
model = create_and_fill_model("");
gtk_tree_view_set_model(GTK_TREE_VIEW(table->view), model);
g_object_unref(model); /* destroy model automatically with view */
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(table->view)),GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_clickable (table->view,TRUE);
gtk_tree_view_set_rules_hint (table->view,TRUE);
gtk_tree_view_set_grid_lines(table->view, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL );
g_object_set( table->view ,"hover-selection" , TRUE,NULL);
g_signal_connect(table->view, "button-press-event", (GCallback) table_onButtonPressed, NULL);
return table->view;
}
/**
* stf_preview_new
* @data_container: a container in which to put a treeview.
*
* returns : a new renderdata struct
**/
RenderData_t*
stf_preview_new (GtkWidget *data_container,
GODateConventions const *date_conv)
{
RenderData_t* renderdata;
GnumericLazyList *ll;
g_return_val_if_fail (data_container != NULL, NULL);
renderdata = g_new (RenderData_t, 1);
renderdata->data_container = data_container;
renderdata->startrow = 1;
renderdata->colformats = g_ptr_array_new ();
renderdata->ignore_formats = FALSE;
renderdata->lines_chunk = NULL;
renderdata->lines = NULL;
renderdata->date_conv = date_conv;
ll = gnumeric_lazy_list_new (render_get_value, renderdata, 0, 1, G_TYPE_STRING);
renderdata->tree_view =
GTK_TREE_VIEW (gtk_tree_view_new_with_model (GTK_TREE_MODEL (ll)));
gtk_tree_view_set_grid_lines (renderdata->tree_view,
GTK_TREE_VIEW_GRID_LINES_VERTICAL);
g_object_ref (renderdata->tree_view);
g_object_unref (ll);
renderdata->colcount = 0;
{
GtkWidget *w = GTK_WIDGET (renderdata->tree_view);
int width, height, vertical_separator;
PangoLayout *layout =
gtk_widget_create_pango_layout (w, "Mg19");
gtk_widget_style_get (w,
"vertical_separator", &vertical_separator,
NULL);
pango_layout_get_pixel_size (layout, &width, &height);
/*
* Make room for about 80 characters and about 7 lines of data.
* (The +2 allows room for the headers and the h-scrollbar.
*/
gtk_widget_set_size_request (renderdata->data_container,
width * 20, /* About 80 chars. */
(height + vertical_separator) * (7 + 2));
g_object_unref (layout);
}
gtk_container_add (GTK_CONTAINER (renderdata->data_container),
GTK_WIDGET (renderdata->tree_view));
gtk_widget_show_all (GTK_WIDGET (renderdata->tree_view));
return renderdata;
}
static GtkWidget *
create_tree_view(int n, n_list_store *list, int tree)
{
GType *tarray;
GtkTreeModel *lstore;
GtkWidget *tview;
GtkTreeViewColumn *col;
GtkTreeSelection *sel;
int i;
if (n < 1 || list == NULL)
return NULL;
tarray = g_malloc(sizeof(*tarray) * n);
if (tarray == NULL)
return NULL;
for (i = 0; i < n; i++) {
if (list[i].type == G_TYPE_DOUBLE || list[i].type == G_TYPE_ENUM || list[i].type == G_TYPE_PARAM) {
tarray[i] = G_TYPE_STRING;
} else {
tarray[i] = list[i].type;
}
list[i].edited_id = 0;
}
if (tree) {
lstore = GTK_TREE_MODEL(gtk_tree_store_newv(n, tarray));
} else {
lstore = GTK_TREE_MODEL(gtk_list_store_newv(n, tarray));
}
g_free(tarray);
tview = gtk_tree_view_new_with_model(lstore);
#if ! GTK_CHECK_VERSION(3, 14, 0)
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tview), TRUE);
#endif
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tview), TRUE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tview), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tview));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
for (i = 0; i < n; i++) {
if (list[i].visible) {
col = create_column(list, i);
gtk_tree_view_column_set_visible(col, list[i].visible);
gtk_tree_view_append_column(GTK_TREE_VIEW(tview), col);
}
}
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), n > 1);
return tview;
}
static void
mug_msg_list_view_init (MugMsgListView * obj)
{
MugMsgListViewPrivate *priv;
GtkTreeView *tview;
priv = MUG_MSG_LIST_VIEW_GET_PRIVATE (obj);
priv->_xpath = priv->_query = NULL;
priv->_store = gtk_list_store_new (MUG_N_COLS, G_TYPE_STRING, /* date */
G_TYPE_STRING, /* folder */
G_TYPE_STRING, /* flagstr */
G_TYPE_STRING, /* from */
G_TYPE_STRING, /* to */
G_TYPE_STRING, /* subject */
G_TYPE_STRING, /* path */
G_TYPE_UINT, /* prio */
G_TYPE_UINT, /* flags */
G_TYPE_INT); /* timeval */
tview = GTK_TREE_VIEW (obj);
gtk_tree_view_set_model (tview, GTK_TREE_MODEL (priv->_store));
gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (obj), TRUE);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (obj),
GTK_TREE_VIEW_GRID_LINES_VERTICAL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (obj), TRUE);
append_col (tview, "Date", MUG_COL_DATESTR, MUG_COL_TIME, 80);
append_col (tview, "Folder", MUG_COL_MAILDIR, -1, 60);
append_col (tview, "F", MUG_COL_FLAGSSTR, -1, 25);
append_col (tview, "From", MUG_COL_FROM, -1, 0);
append_col (tview, "To", MUG_COL_TO, -1, 0);
append_col (tview, "Subject", MUG_COL_SUBJECT, -1, 0);
g_signal_connect (G_OBJECT (obj), "cursor-changed",
G_CALLBACK (on_cursor_changed), obj);
}
static void plugin_manager_create(void)
{
GtkWidget *window;
GtkWidget *vbox;
#ifdef USE_UPDATE_CHECK_PLUGIN
GtkWidget *update_check_btn;
#endif
GtkWidget *close_btn;
GtkWidget *confirm_area;
GtkWidget *scrolledwin;
GtkWidget *treeview;
GtkListStore *store;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), _("Plug-in manager"));
gtk_widget_set_size_request(window, 600, 400);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtkut_stock_button_set_create(&confirm_area,
#ifdef USE_UPDATE_CHECK_PLUGIN
&update_check_btn, _("Check for _update"),
&close_btn, GTK_STOCK_CLOSE,
NULL, NULL);
gtkut_box_set_reverse_order(GTK_BOX(confirm_area), TRUE);
#else
&close_btn, GTK_STOCK_CLOSE,
NULL, NULL,
NULL, NULL);
#endif
gtk_widget_show(confirm_area);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(close_btn);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(plugin_manager_deleted), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(key_pressed), NULL);
#ifdef USE_UPDATE_CHECK_PLUGIN
g_signal_connect(G_OBJECT(update_check_btn), "clicked",
G_CALLBACK(plugin_manager_update_check), NULL);
#endif
g_signal_connect(G_OBJECT(close_btn), "clicked",
G_CALLBACK(plugin_manager_deleted), NULL);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwin);
gtk_widget_set_size_request(scrolledwin, -1, -1);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
store = gtk_list_store_new(N_COLS, G_TYPE_STRING);
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COL_INFO);
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(treeview),
GTK_TREE_VIEW_GRID_LINES_HORIZONTAL);
#endif
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes
(_("Plug-in information"), renderer, "text", COL_INFO, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_widget_show(treeview);
gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);
gtk_widget_show_all(window);
pm_window.window = window;
pm_window.close_btn = close_btn;
pm_window.treeview = treeview;
pm_window.store = store;
pm_window.selection = selection;
}
GtkWidget *create_list_upcoming(void)
{
GtkListStore *store;
GtkWidget *view;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
DB( g_print ("\n[list_upcoming] create\n") );
/* create list store */
store = gtk_list_store_new(
NUM_LST_DSPUPC,
G_TYPE_POINTER,
G_TYPE_BOOLEAN, /* payee */
G_TYPE_STRING, /* memo */
G_TYPE_DOUBLE, /* expense */
G_TYPE_DOUBLE, /* income */
G_TYPE_POINTER, /* account */
G_TYPE_BOOLEAN, /* next on */
G_TYPE_INT, /* remaining */
G_TYPE_INT /* nb late */
);
//treeview
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (view), PREFS->grid_lines);
//gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview),
// COLUMN_DESCRIPTION);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_SINGLE);
/* column : Late */
column = gtk_tree_view_column_new();
//TRANSLATORS: title of list column to inform the scheduled transaction is Late
gtk_tree_view_column_set_title(column, _("Late"));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, sched_lateicon_cell_data_function, NULL, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, sched_latetext_cell_data_function, NULL, NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPUPC_NB_LATE);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column : Remaining */
/*column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("In"));
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remaining_cell_data_function, NULL, NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPUPC_REMAINING);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
*/
/* column: Next on */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Next date"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, date_cell_data_function, NULL, NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPUPC_DATE);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: Payee */
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Payee"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, payee_cell_data_function, NULL, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
//gtk_tree_view_column_add_attribute(column, renderer, "text", 1);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST/2);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
gtk_tree_view_column_set_fixed_width(column, PREFS->pnl_upc_col_pay_width);
/* column: Memo */
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Memo"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, memo_cell_data_function, NULL, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
//gtk_tree_view_column_add_attribute(column, renderer, "text", 2);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST/2);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
gtk_tree_view_column_set_fixed_width(column, PREFS->pnl_upc_col_mem_width);
/* column: Amount */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Expense"));
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, amount_cell_data_function, GINT_TO_POINTER(-1), NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: Amount */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Income"));
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, amount_cell_data_function, GINT_TO_POINTER(1), NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: Account */
renderer = gtk_cell_renderer_text_new ();
/*g_object_set(renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);*/
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Account"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, account_cell_data_function, NULL, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPOPE_DATE);
gtk_tree_view_column_set_alignment (column, 0.5);
//gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: empty */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), list_account_selectionfunc, NULL, NULL);
/* set initial sort order */
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), LST_DSPUPC_REMAINING, GTK_SORT_ASCENDING);
g_signal_connect (view, "destroy", G_CALLBACK (list_upcoming_destroy), NULL);
return(view);
}
void project_main_dialog_init_list(GtkWidget *treeview)
{
GtkCellRenderer *renderer;
GtkListStore *store;
// Tree view configuration
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(treeview), GTK_TREE_VIEW_GRID_LINES_BOTH);
// Render
renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new_with_attributes("Project", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_column_set_sort_column_id(column, PROJECT_MAIN_DIALOG_LIST_COLUMN_PROJECT_ID);
gtk_tree_view_column_set_resizable(column, TRUE);
column = gtk_tree_view_column_new_with_attributes("Issues", renderer, "text", 1, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_column_set_sort_column_id(column, PROJECT_MAIN_DIALOG_LIST_COLUMN_ISSUES_COUNT_ID);
gtk_tree_view_column_set_resizable(column, TRUE);
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", 2, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_column_set_sort_column_id(column, PROJECT_MAIN_DIALOG_LIST_COLUMN_STATUS_ID);
gtk_tree_view_column_set_resizable(column, TRUE);
// List model
store = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(store));
g_object_unref(store);
// Setup the selection handler
GtkTreeSelection *select;
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
// Sort columns
GtkTreeSortable *sortable = GTK_TREE_SORTABLE(store);
gtk_tree_sortable_set_sort_func(sortable,
PROJECT_MAIN_DIALOG_LIST_COLUMN_PROJECT_ID,
project_main_dialog_list_sort_callback,
GINT_TO_POINTER(PROJECT_MAIN_DIALOG_LIST_COLUMN_PROJECT_ID),
NULL);
gtk_tree_sortable_set_sort_func(sortable,
PROJECT_MAIN_DIALOG_LIST_COLUMN_ISSUES_COUNT_ID,
project_main_dialog_list_sort_callback,
GINT_TO_POINTER(PROJECT_MAIN_DIALOG_LIST_COLUMN_ISSUES_COUNT_ID),
NULL);
gtk_tree_sortable_set_sort_func(sortable,
PROJECT_MAIN_DIALOG_LIST_COLUMN_STATUS_ID,
project_main_dialog_list_sort_callback,
GINT_TO_POINTER(PROJECT_MAIN_DIALOG_LIST_COLUMN_STATUS_ID),
NULL);
// List callbacks
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(project_main_dialog_on_list_row_activated),
NULL);
}
/*
* 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 */
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_INT,
G_TYPE_INT);
GtkWidget* tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(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_grid_lines (GTK_TREE_VIEW(tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
g_object_set(tree, "rules-hint", TRUE, NULL);
/* connect signals */
g_signal_connect(G_OBJECT(tree), "row-collapsed", G_CALLBACK (on_row_collapsed), NULL);
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_key_pressed), NULL);
/* create columns */
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gchar *header;
int char_width = get_char_width(tree);
/* Name */
header = _("Name");
renderer = gtk_cell_renderer_text_new ();
column = create_column(header, renderer, FALSE,
get_header_string_width(header, MW_NAME, char_width),
"text", W_NAME);
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 */
header = _("Value");
renderer = gtk_cell_renderer_text_new ();
column = create_column(header, renderer, TRUE,
get_header_string_width(header, MW_VALUE, char_width),
"text", W_VALUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, render_value, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Type */
header = _("Type");
renderer = gtk_cell_renderer_text_new ();
column = create_column(header, renderer, FALSE,
get_header_string_width(header, MW_TYPE, char_width),
"text", W_TYPE);
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 GtkWidget *
gnc_stock_split_assistant_create (StockSplitInfo *info)
{
GtkBuilder *builder;
GtkWidget *window;
builder = gtk_builder_new();
gnc_builder_add_from_file (builder , "assistant-stock-split.glade", "stock_split_assistant");
window = GTK_WIDGET(gtk_builder_get_object (builder, "stock_split_assistant"));
info->window = window;
// Set the style context for this assistant so it can be easily manipulated with css
gnc_widget_set_style_context (GTK_WIDGET(window), "GncAssistStockSplit");
/* Enable buttons on first, second, fourth and last page. */
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "intro_page_label")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "stock_account_page")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "stock_cash_page")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "finish_page_label")),
TRUE);
/* Account page Widgets */
{
GtkTreeView *view;
GtkListStore *store;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
info->account_view = GTK_WIDGET(gtk_builder_get_object(builder, "account_view"));
view = GTK_TREE_VIEW(info->account_view);
// Set grid lines option to preference
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(view), gnc_tree_view_get_grid_lines_pref ());
store = gtk_list_store_new(NUM_SPLIT_COLS, G_TYPE_POINTER, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(view, GTK_TREE_MODEL(store));
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Account"), renderer,
"text", SPLIT_COL_FULLNAME,
NULL);
gtk_tree_view_append_column(view, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Symbol"), renderer,
"text", SPLIT_COL_MNEMONIC,
NULL);
gtk_tree_view_append_column(view, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Shares"), renderer,
"text", SPLIT_COL_SHARES,
NULL);
gtk_tree_view_append_column(view, column);
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed",
G_CALLBACK (selection_changed_cb), info);
}
/* Details Page Widgets */
{
GtkWidget *table;
GtkWidget *amount;
GtkWidget *date;
GtkWidget *label;
table = GTK_WIDGET(gtk_builder_get_object(builder, "stock_details_table"));
info->description_entry = GTK_WIDGET(gtk_builder_get_object(builder, "description_entry"));
date = gnc_date_edit_new (gnc_time (NULL), FALSE, FALSE);
gtk_grid_attach (GTK_GRID(table), date, 1, 0, 1, 1);
gtk_widget_show (date);
info->date_edit = date;
label = GTK_WIDGET(gtk_builder_get_object(builder, "date_label"));
gnc_date_make_mnemonic_target (GNC_DATE_EDIT(date), label);
amount = gnc_amount_edit_new ();
g_signal_connect (amount, "changed",
G_CALLBACK (gnc_stock_split_details_valid_cb), info);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (amount), TRUE);
gtk_grid_attach (GTK_GRID(table), amount, 1, 1, 1, 1);
gtk_widget_show (amount);
info->distribution_edit = amount;
label = GTK_WIDGET(gtk_builder_get_object(builder, "distribution_label"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), amount);
amount = gnc_amount_edit_new ();
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (amount),
gnc_default_price_print_info ());
g_signal_connect (amount, "changed",
G_CALLBACK (gnc_stock_split_details_valid_cb), info);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (amount), TRUE);
gtk_grid_attach (GTK_GRID(table), amount, 1, 5, 1, 1);
gtk_widget_show (amount);
info->price_edit = amount;
label = GTK_WIDGET(gtk_builder_get_object(builder, "price_label"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), amount);
info->price_currency_edit = gnc_currency_edit_new();
gnc_currency_edit_set_currency (GNC_CURRENCY_EDIT(info->price_currency_edit), gnc_default_currency());
gtk_widget_show (info->price_currency_edit);
gtk_grid_attach (GTK_GRID(table), info->price_currency_edit, 1, 6, 1, 1);
}
/* Cash page Widgets */
{
GtkWidget *box;
GtkWidget *tree;
GtkWidget *amount;
GtkWidget *label;
GtkWidget *scroll;
GtkTreeSelection *selection;
box = GTK_WIDGET(gtk_builder_get_object(builder, "cash_box"));
amount = gnc_amount_edit_new ();
g_signal_connect (amount, "changed",
G_CALLBACK (gnc_stock_split_cash_valid_cb), info);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (amount), TRUE);
gtk_box_pack_start (GTK_BOX (box), amount, TRUE, TRUE, 0);
info->cash_edit = amount;
label = GTK_WIDGET(gtk_builder_get_object(builder, "cash_label"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), amount);
info->memo_entry = GTK_WIDGET(gtk_builder_get_object(builder, "memo_entry"));
/* income tree */
tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
info->income_tree = tree;
gnc_tree_view_account_set_filter (GNC_TREE_VIEW_ACCOUNT (tree),
gnc_stock_split_assistant_view_filter_income,
NULL, /* user data */
NULL /* destroy callback */);
gtk_widget_show (tree);
gtk_tree_view_expand_all (GTK_TREE_VIEW(tree));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_unselect_all (selection);
g_signal_connect (selection, "changed",
G_CALLBACK (gnc_stock_split_cash_valid_cb), info);
label = GTK_WIDGET(gtk_builder_get_object(builder, "income_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL(label), tree);
scroll = GTK_WIDGET(gtk_builder_get_object(builder, "income_scroll"));
gtk_container_add (GTK_CONTAINER (scroll), tree);
/* asset tree */
tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
info->asset_tree = tree;
gnc_tree_view_account_set_filter (GNC_TREE_VIEW_ACCOUNT (tree),
gnc_stock_split_assistant_view_filter_asset,
NULL /* user data */,
NULL /* destroy callback */);
gtk_widget_show (tree);
label = GTK_WIDGET(gtk_builder_get_object(builder, "asset_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL(label), tree);
scroll = GTK_WIDGET(gtk_builder_get_object(builder, "asset_scroll"));
gtk_container_add (GTK_CONTAINER (scroll), tree);
gtk_tree_view_expand_all (GTK_TREE_VIEW(tree));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_unselect_all (selection);
g_signal_connect (selection, "changed",
G_CALLBACK (gnc_stock_split_cash_valid_cb), info);
}
g_signal_connect (G_OBJECT(window), "destroy",
G_CALLBACK (gnc_stock_split_assistant_window_destroy_cb), info);
gtk_builder_connect_signals(builder, info);
g_object_unref(G_OBJECT(builder));
return window;
}
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);
}
static GtkWidget *
glade_eprop_model_data_create_input (GladeEditorProperty * eprop)
{
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GtkWidget *vbox, *hbox, *button, *swin, *label;
gchar *string;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
/* hbox with add/remove row buttons on the right... */
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
string = g_strdup_printf ("<b>%s</b>", _("Add and remove rows:"));
label = gtk_label_new (string);
g_free (string);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (button),
gtk_image_new_from_icon_name ("list-add-symbolic",
GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (glade_eprop_model_data_add_clicked),
eprop_data);
button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (button),
gtk_image_new_from_icon_name ("list-remove-symbolic",
GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (glade_eprop_model_data_delete_clicked),
eprop_data);
/* Pack treeview/swindow on the left... */
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), swin, TRUE, TRUE, 0);
eprop_data->view = (GtkTreeView *) gtk_tree_view_new ();
g_signal_connect (eprop_data->view, "key-press-event",
G_CALLBACK (eprop_treeview_key_press), eprop);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (eprop_data->view),
GTK_TREE_VIEW_GRID_LINES_BOTH);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (eprop_data->view), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (eprop_data->view), TRUE);
gtk_container_add (GTK_CONTAINER (swin), GTK_WIDGET (eprop_data->view));
g_object_set (G_OBJECT (vbox), "height-request", 300, NULL);
gtk_widget_show_all (vbox);
return vbox;
}
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);
}
void
update_user_entry(GList *top,GtkWidget *view,gboolean is_forced) {
GtkTreeIter toplevel;
GtkListStore *liststore = NULL;
GtkWidget *usersEntry = NULL;
GtkTreeViewColumn *col = NULL;
userdb_t *current_user = NULL;
int i = 0;
int users_count = 0;
int prio = 0;
guint state = 0;
int id = 0;
gchar *nick_name_ref = NULL;
gchar num_str[32];
if ( (!top) || (!view) )
return;
state=hostinfo_refer_header_state();
release_user_entry(GTK_TREE_VIEW(view));
liststore = gtk_list_store_new(MAX_VIEW_ID,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
for(i=0;(current_user=g_list_nth_data(top,i));++i) {
g_assert(current_user);
nick_name_ref = current_user->nickname;
if ( (current_user->nickname == NULL) || ( current_user->nickname[0] == '\0' ) ) {
if ( (current_user->user != NULL) && (current_user->user[0] != '\0') )
nick_name_ref = current_user->user;
else
nick_name_ref = _("Unknown");
}
dbg_out("Update\n");
dbg_out("NickName: %s\n", current_user->nickname);
dbg_out("Group: %s\n",current_user->group);
dbg_out("User: %s\n",current_user->user);
dbg_out("Host: %s\n",current_user->host);
dbg_out("IP Addr: %s\n",current_user->ipaddr);
dbg_out("Priority: %d\n",current_user->prio);
prio=current_user->prio;
memset(num_str,0,32);
if (prio>0)
snprintf(num_str,31,"%d",prio);
else
snprintf(num_str,31,"-");
num_str[31]='\0';
if ( (prio>=0) || (is_forced) ){
/* Append a top level row and leave it empty */
gtk_list_store_append(liststore, &toplevel);
gtk_list_store_set(liststore, &toplevel,
USER_VIEW_NICKNAME_ID, nick_name_ref,
USER_VIEW_GROUP_ID,current_user->group,
USER_VIEW_HOST_ID,current_user->host,
USER_VIEW_IPADDR_ID,current_user->ipaddr,
USER_VIEW_LOGON_ID,current_user->user,
USER_VIEW_PRIO_ID,num_str,
-1);
}
++users_count;
fflush(stdout);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(liststore));
g_object_unref(liststore); /* destroy model automatically with view */
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
GTK_SELECTION_MULTIPLE );
/*
* ユーザ数更新
*/
usersEntry=lookup_widget(GTK_WIDGET(view),"messageWinUsersEntry");
g_assert(usersEntry);
snprintf(num_str,31,"%d",users_count);
gtk_entry_set_text(GTK_ENTRY(usersEntry), num_str);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW(view),TRUE);
if (GTK_WIDGET_REALIZED(view)) {
#if GTK_CHECK_VERSION(2,10,6)
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(view),TRUE);
if (state & HEADER_VISUAL_GRID_ID)
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(view),GTK_TREE_VIEW_GRID_LINES_BOTH);
#endif
}
#endif
return;
}
/*!
\brief Creates the lookuptables configurator window (MS1 FW's only)
\param widget is unused
\param data is unused
\returns TRUE on success
*/
G_MODULE_EXPORT gboolean lookuptables_configurator(GtkWidget *widget, gpointer data)
{
static gboolean ltc_created = FALSE;
static GtkWidget * lookuptables_config_window = NULL;
GtkListStore *store = NULL;
GtkTreeStore *combostore = NULL;
GtkTreeIter iter;
GtkTreeIter per_iter;
GtkTreeIter sys_iter;
GtkCellRenderer *renderer = NULL;
GtkTreeViewColumn *column = NULL;
GtkWidget * vbox = NULL;
GtkWidget * tree = NULL;
GtkWidget * frame = NULL;
GtkWidget * label = NULL;
ListElement *element = NULL;
ConfigFile *cfgfile = NULL;
GArray *classes = NULL;
GList *p_list = NULL;
GList *s_list = NULL;
gchar * tmpbuf = NULL;
gchar ** vector = NULL;
gchar ** tmpvector = NULL;
Firmware_Details *firmware = NULL;
ENTER();
firmware = (Firmware_Details *)DATA_GET(global_data,"firmware");
if ((ltc_created) && (ltc_visible))
{
EXIT();
return TRUE;
}
if ((ltc_created) && (!ltc_visible))
{
gtk_widget_show_all(lookuptables_config_window);
EXIT();
return TRUE;
}
else /* i.e. NOT created, build it */
{
lookuptables_config_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(lookuptables_config_window),_("MegaTunix LookupTables"));
gtk_window_set_default_size(GTK_WINDOW(lookuptables_config_window),300,200);
vbox = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(lookuptables_config_window),vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox),5);
g_signal_connect(G_OBJECT(lookuptables_config_window),"delete_event", G_CALLBACK(lookuptables_configurator_hide),NULL);
ltc_created = TRUE;
ltc_visible = TRUE;
frame = gtk_frame_new("MegaTunix LookupTables");
gtk_box_pack_start (GTK_BOX(vbox),frame,TRUE,TRUE,5);
vbox = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(frame),vbox);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label),_(" Click on the <i>LookupTable Filename</i> and press <b><u> Enter </u></b> to change "));
gtk_box_pack_start(GTK_BOX(vbox),label,TRUE,TRUE,5);
store = gtk_list_store_new(N_COLS, /* total cols */
G_TYPE_STRING, /* int name */
G_TYPE_STRING, /* filename combo*/
G_TYPE_BOOLEAN,/* View/Edit */
G_TYPE_BOOLEAN); /* change */
combostore = gtk_tree_store_new(1,G_TYPE_STRING);/* lookuptable filename */
gtk_tree_store_append(combostore,&per_iter,NULL);
gtk_tree_store_append(combostore,&sys_iter,NULL);
gtk_tree_store_set(combostore,&per_iter,
0,"Personal", -1);
gtk_tree_store_set(combostore,&sys_iter,
0,"System", -1);
vector = get_files((const gchar *)DATA_GET(global_data,"project_name"),LOOKUPTABLES_DATA_DIR,"inc",&classes);
for (guint i=0;i<g_strv_length(vector);i++)
{
tmpvector = g_strsplit(vector[i],PSEP,-1);
if (g_array_index(classes,FileClass,i) == PERSONAL)
{
element = (ListElement *)g_new0(ListElement, 1);
element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]);
p_list = g_list_append(p_list,element);
}
if (g_array_index(classes,FileClass,i) == SYSTEM)
{
element = (ListElement *)g_new0(ListElement, 1);
element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]);
s_list = g_list_append(s_list,element);
}
g_strfreev(tmpvector);
}
g_strfreev(vector);
g_array_free(classes,TRUE);
p_list = g_list_sort(p_list,list_sort);
s_list = g_list_sort(s_list,list_sort);
for (guint i=0;i<g_list_length(p_list);i++)
{
gtk_tree_store_append(combostore,&iter,&per_iter);
element = (ListElement *)g_list_nth_data(p_list,i);
gtk_tree_store_set(combostore,&iter,
0,element->name,
-1);
}
for (guint i=0;i<g_list_length(s_list);i++)
{
gtk_tree_store_append(combostore,&iter,&sys_iter);
element = (ListElement *)g_list_nth_data(s_list,i);
gtk_tree_store_set(combostore,&iter,
0,element->name,
-1);
}
g_list_foreach(p_list,free_element,NULL);
g_list_foreach(s_list,free_element,NULL);
g_list_free(p_list);
g_list_free(s_list);
cfgfile = cfg_open_file(firmware->profile_filename);
if (!cfgfile)
{
EXIT();
return FALSE;
}
cfg_read_string(cfgfile,"lookuptables","tables",&tmpbuf);
vector = g_strsplit(tmpbuf,",",-1);
g_free(tmpbuf);
for (guint i=0;i<g_strv_length(vector);i++)
{
cfg_read_string(cfgfile,"lookuptables",vector[i],&tmpbuf);
gtk_list_store_append(store,&iter);
gtk_list_store_set(store,&iter,
INTERNAL_NAME_COL,vector[i],
FILENAME_COL,tmpbuf,
VIEW_EDIT_COL,FALSE,
-1);
g_free(tmpbuf);
}
g_strfreev(vector);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree),TRUE);
gtk_box_pack_start(GTK_BOX(vbox),tree,TRUE,TRUE,0);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Internal Table Name",renderer,"text",INTERNAL_NAME_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
renderer = gtk_cell_renderer_combo_new();
g_object_set(G_OBJECT(renderer),"has-entry",FALSE,"editable",TRUE,"model",combostore,"text-column",0,"style",PANGO_STYLE_ITALIC,NULL);
g_signal_connect(G_OBJECT(renderer),"changed", G_CALLBACK(lookuptable_changed),store);
// g_signal_connect(G_OBJECT(renderer),"editing-started", G_CALLBACK(editing_started),store);
column = gtk_tree_view_column_new_with_attributes("LookupTable Filename",renderer,"text",FILENAME_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
/* renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes("View/Edit",renderer,"active",VIEW_EDIT_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
*/
gtk_window_set_transient_for(GTK_WINDOW(lookuptables_config_window),GTK_WINDOW(lookup_widget("main_window")));
gtk_widget_show_all (lookuptables_config_window);
gtk_tree_view_columns_autosize( GTK_TREE_VIEW(tree));
gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree),GTK_TREE_VIEW_GRID_LINES_BOTH);
// g_signal_connect(G_OBJECT(tree),"row-activated", G_CALLBACK(row_activated),NULL);
}
EXIT();
return TRUE;
}
/*
* create target page
*/
void tpage_init()
{
page = gtk_hbox_new(FALSE, 0);
GtkWidget *lbox = gtk_vbox_new(FALSE, SPACING);
GtkWidget *mbox = gtk_vbox_new(FALSE, SPACING);
GtkWidget *rbox = gtk_vbox_new(FALSE, SPACING);
GtkWidget* separator = gtk_vseparator_new();
/* right box with Load/Save buttons */
gtk_container_set_border_width(GTK_CONTAINER(rbox), SPACING);
loadbtn = gtk_button_new_from_stock(GTK_STOCK_OPEN);
g_signal_connect(G_OBJECT(loadbtn), "clicked", G_CALLBACK (on_load_config), (gpointer)TRUE);
savebtn = gtk_button_new_from_stock(GTK_STOCK_SAVE);
g_signal_connect(G_OBJECT(savebtn), "clicked", G_CALLBACK (on_save_config), NULL);
clearbtn = gtk_button_new_from_stock(GTK_STOCK_CLEAR);
g_signal_connect(G_OBJECT(clearbtn), "clicked", G_CALLBACK (on_clear), NULL);
gtk_box_pack_start(GTK_BOX(rbox), loadbtn, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rbox), savebtn, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rbox), clearbtn, FALSE, TRUE, 0);
GtkWidget *hombox = gtk_hbox_new(TRUE, 0);
/* left box */
gtk_container_set_border_width(GTK_CONTAINER(lbox), SPACING);
/* Target frame */
GtkWidget *frame = gtk_frame_new(_("Target"));
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
/* filename hbox */
GtkWidget *hbox = gtk_hbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
targetname = gtk_entry_new ();
button_browse = gtk_button_new_with_label(_("Browse"));
g_signal_connect(G_OBJECT(button_browse), "clicked", G_CALLBACK (on_target_browse_clicked), NULL);
gtk_box_pack_start(GTK_BOX(hbox), targetname, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button_browse, FALSE, TRUE, 0);
/* pack in the vertical box */
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* debugger type hbox */
hbox = gtk_hbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
GtkWidget *label = gtk_label_new(_("Debugger:"));
cmb_debugger = gtk_combo_box_new_text();
GList *modules = debug_get_modules();
GList *iter = modules;
while (iter)
{
gtk_combo_box_append_text(GTK_COMBO_BOX(cmb_debugger), (gchar*)iter->data);
iter = iter->next;
}
g_list_free(modules);
gtk_combo_box_set_active(GTK_COMBO_BOX(cmb_debugger), 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), cmb_debugger, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
gtk_box_pack_start(GTK_BOX(lbox), frame, FALSE, FALSE, 0);
/* Arguments frame */
frame = gtk_frame_new(_("Arguments"));
hbox = gtk_vbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
textview = gtk_text_view_new ();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR);
gtk_box_pack_start(GTK_BOX(hbox), textview, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), hbox);
gtk_box_pack_start(GTK_BOX(lbox), frame, TRUE, TRUE, 0);
/* Environment */
gtk_container_set_border_width(GTK_CONTAINER(mbox), SPACING);
frame = gtk_frame_new(_("Environment variables"));
hbox = gtk_hbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
store = gtk_list_store_new (
N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING);
model = GTK_TREE_MODEL(store);
envtree = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(envtree), TRUE);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(envtree), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
g_object_set(envtree, "rules-hint", TRUE, NULL);
g_signal_connect(G_OBJECT(envtree), "key-press-event", G_CALLBACK (on_envtree_keypressed), NULL);
gchar *header;
int char_width = get_char_width(envtree);
header = _("Name");
renderer_name = gtk_cell_renderer_text_new ();
g_object_set (renderer_name, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer_name), "edited", G_CALLBACK (on_name_changed), NULL);
column_name = create_column(header, renderer_name, FALSE,
get_header_string_width(header, MW_NAME, char_width),
"text", NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_name);
header = _("Value");
renderer_value = gtk_cell_renderer_text_new ();
column_value = create_column(header, renderer_value, TRUE,
get_header_string_width(header, MW_VALUE, char_width),
"text", VALUE);
g_signal_connect (G_OBJECT (renderer_value), "edited", G_CALLBACK (on_value_changed), NULL);
g_signal_connect (G_OBJECT (renderer_value), "editing-started", G_CALLBACK (on_value_editing_started), NULL);
g_signal_connect (G_OBJECT (renderer_value), "editing-canceled", G_CALLBACK (on_value_editing_cancelled), NULL);
gtk_tree_view_column_set_cell_data_func(column_value, renderer_value, on_render_value, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_value);
/* add empty row */
add_empty_row();
/* set multiple selection */
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(envtree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_box_pack_start(GTK_BOX(hbox), envtree, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), hbox);
gtk_box_pack_start(GTK_BOX(mbox), frame, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hombox), lbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hombox), mbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(page), hombox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(page), separator, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(page), rbox, FALSE, TRUE, 0);
/* update Load/Save config button */
tpage_on_document_activate(document_get_current());
}
static GtkWidget *create_tree(void)
{
GtkWidget *tree;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
tree = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tree),
GTK_TREE_VIEW_GRID_LINES_NONE);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_spacing(column, 6);
gtk_tree_view_column_set_min_width(column, 250);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
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", CONNMAN_COLUMN_ICON);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
service_to_text, NULL, NULL);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
security_to_icon, NULL, NULL);
renderer = gtk_cell_renderer_progress_new();
gtk_cell_renderer_set_fixed_size(renderer, 100, -1);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
strength_to_value, NULL, NULL);
model = connman_client_get_model(client);
gtk_tree_view_set_model(GTK_TREE_VIEW(tree), model);
g_object_unref(model);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(tree),
CONNMAN_COLUMN_NAME);
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), tree);
g_signal_connect(G_OBJECT(tree), "button-press-event",
G_CALLBACK(button_pressed), NULL);
g_signal_connect(G_OBJECT(tree), "popup-menu",
G_CALLBACK(popup_callback), NULL);
g_signal_connect(G_OBJECT(tree), "drag-drop",
G_CALLBACK(drag_drop), NULL);
g_signal_connect(G_OBJECT(tree), "drag-data-get",
G_CALLBACK(drag_data_get), selection);
g_signal_connect(G_OBJECT(tree), "drag-data-received",
G_CALLBACK(drag_data_received), model);
return tree;
}
