static GtkWidget *
banlist_treeview_new (GtkWidget *box)
{
GtkListStore *store;
GtkWidget *view;
GtkTreeSelection *select;
GtkTreeViewColumn *col;
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
view = gtkutil_treeview_new (box, GTK_TREE_MODEL (store), NULL,
MASK_COLUMN, _("Mask"),
FROM_COLUMN, _("From"),
DATE_COLUMN, _("Date"), -1);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), MASK_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_min_width (col, 300);
gtk_tree_view_column_set_sort_column_id (col, MASK_COLUMN);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), FROM_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, FROM_COLUMN);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), DATE_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
gtk_widget_show (view);
return view;
}
static void add_stat_columns(GtkTreeView * treeview, char *title, char **headers, int n)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
int i, j;
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "xalign", 1.0, NULL);
column = gtk_tree_view_column_new_with_attributes(title, renderer, "text", 0, NULL);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_tree_view_append_column(treeview, column);
for (i = 0; i < 2; i++) {
for (j = 0; j < n; j++) {
char *header = g_strdup_printf("%s%s", headers[j], ap[i].szName);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "xalign", 1.0, NULL);
column = gtk_tree_view_column_new_with_attributes(header,
renderer, "text",
1 + j + i * n, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_tree_view_append_column(treeview, column);
g_free(header);
}
}
}
void
treeview2_set_up_season_results(GtkTreeView *treeview)
{
#ifdef DEBUG
printf("treeview2_set_up_season_results\n");
#endif
gint i;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
gchar *titles[6] =
/* Week */
{_("We"),
/* Round */
_("Ro"),
_("Competition"),
_("Opponent"),
"",
_("Result")};
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(treeview),
GTK_SELECTION_NONE);
gtk_tree_view_set_headers_visible(treeview, TRUE);
for(i=0;i<3;i++)
{
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[i]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer,
"text", i);
if(i<2)
{
gtk_tree_view_column_set_alignment(col, 0.5);
g_object_set(renderer, "xalign", 0.5, NULL);
}
}
for(i=3;i<6;i++)
{
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[i]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(col, renderer,
treeview_helper_season_results,
NULL, NULL);
if(i == 4)
{
gtk_tree_view_column_set_alignment(col, 0.5);
g_object_set(renderer, "xalign", 0.5, NULL);
}
}
}
static GtkWidget *
banlist_treeview_new (GtkWidget *box, banlist_info *banl)
{
GtkListStore *store;
GtkWidget *view;
GtkTreeSelection *select;
GtkTreeViewColumn *col;
GtkTreeSortable *sortable;
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
sortable = GTK_TREE_SORTABLE (store);
gtk_tree_sortable_set_sort_func (sortable, DATE_COLUMN, banlist_date_sort, GINT_TO_POINTER (DATE_COLUMN), NULL);
view = gtkutil_treeview_new (box, GTK_TREE_MODEL (store), NULL,
TYPE_COLUMN, _("Type"),
MASK_COLUMN, _("Mask"),
FROM_COLUMN, _("From"),
DATE_COLUMN, _("Date"), -1);
g_signal_connect (G_OBJECT (view), "button-press-event", G_CALLBACK (banlist_button_pressed), NULL);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), MASK_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_min_width (col, 100);
gtk_tree_view_column_set_sort_column_id (col, MASK_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), TYPE_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, TYPE_COLUMN);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), FROM_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, FROM_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), DATE_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, DATE_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_connect (G_OBJECT (select), "changed", G_CALLBACK (banlist_select_changed), banl);
gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
gtk_widget_show (view);
return view;
}
static GtkWidget *
notify_treeview_new (GtkWidget *box)
{
GtkListStore *store;
GtkWidget *view;
GtkTreeViewColumn *col;
int col_id;
store = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_POINTER, /* can't specify colour! */
G_TYPE_POINTER
);
g_return_val_if_fail (store != NULL, NULL);
view = gtkutil_treeview_new (box, GTK_TREE_MODEL (store),
notify_treecell_property_mapper,
USER_COLUMN, _("User"),
STATUS_COLUMN, _("Status"),
SERVER_COLUMN, _("Network"),
SEEN_COLUMN, _("Last Seen"), -1);
for (col_id=0; (col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), col_id));
col_id++)
gtk_tree_view_column_set_alignment (col, 0.5);
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (view))),
"changed", G_CALLBACK (notify_row_cb), view);
gtk_widget_show (view);
return view;
}
static void
panda_clist_build_children (GladeXML *xml, GtkWidget *w, GladeWidgetInfo *info,
const char *longname)
{
GList *tmp;
GtkTreeViewColumn *column;
gint col = 0;
for (tmp = info->children; tmp; tmp = tmp->next) {
GtkWidget *child = glade_xml_build_widget (xml, tmp->data,
longname);
gtk_widget_show(child);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(w), col);
gtk_tree_view_column_set_widget(column, child);
if (GTK_IS_MISC(child)) {
gtk_tree_view_column_set_alignment(column, GTK_MISC(child)->xalign);
gtk_misc_set_padding(GTK_MISC(child),0,0);
}
gtk_tree_view_column_set_clickable(column, FALSE);
gtk_tree_view_column_set_spacing(column,0);
if (!GTK_PANDA_CLIST(w)->show_titles) {
gtk_widget_hide(child);
}
col++;
}
}
static GtkWidget *
plugingui_treeview_new (GtkWidget * box)
{
GtkListStore *store;
GtkWidget *view;
GtkTreeViewColumn *col;
int col_id;
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
view = gtkutil_treeview_new (box, GTK_TREE_MODEL (store), NULL,
NAME_COLUMN, _("Name"),
VERSION_COLUMN, _("Version"),
FILE_COLUMN, _("File"),
DESC_COLUMN, _("Description"), -1);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
for (col_id = 0;
(col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), col_id));
col_id++)
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_widget_show (view);
return view;
}
/****************************************************************
Populate view with buildable item information
*****************************************************************/
static void populate_view(GtkTreeView *view, struct city **ppcity,
GtkTreeViewColumn **pcol)
{
static const char *titles[] =
{ N_("Type"), N_("Name"), N_("Info"), N_("Cost"), N_("Turns") };
static bool titles_done;
guint i;
GtkCellRenderer *rend;
GtkTreeViewColumn *col;
intl_slist(ARRAY_SIZE(titles), titles, &titles_done);
/* Case i == 0 taken out of the loop to workaround gcc-4.2.1 bug
* http://gcc.gnu.org/PR33381
* Some values would 'stick' from i == 0 round. */
i = 0;
rend = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_data_func(view,
i, titles[i], rend, cell_render_func, ppcity, NULL);
col = gtk_tree_view_get_column(view, i);
if (gui_gtk3_show_task_icons) {
if (max_unit_width == -1 || max_unit_height == -1) {
update_max_unit_size();
}
} else {
g_object_set(col, "visible", FALSE, NULL);
}
if (gui_gtk3_show_task_icons) {
g_object_set(rend, "height", max_unit_height, NULL);
}
for (i = 1; i < ARRAY_SIZE(titles); i++) {
gint pos = i-1;
rend = gtk_cell_renderer_text_new();
g_object_set_data(G_OBJECT(rend), "column", GINT_TO_POINTER(pos));
gtk_tree_view_insert_column_with_data_func(view,
i, titles[i], rend, cell_render_func, ppcity, NULL);
col = gtk_tree_view_get_column(view, i);
if (pos >= 2) {
g_object_set(G_OBJECT(rend), "xalign", 1.0, NULL);
gtk_tree_view_column_set_alignment(col, 1.0);
}
if (pos == 3) {
*pcol = col;
}
if (gui_gtk3_show_task_icons) {
g_object_set(rend, "height", max_unit_height, NULL);
}
}
}
static void
create_bidding_widget (window_board_t *win)
{
/*
GtkScrolledWindow *scroll = GTK_SCROLLED_WINDOW
(get_widget ("scrolledwindow2"));
GdkColor bg = { 0, 0.8*65535, 0.0, 0.0 };
gdk_colormap_alloc_color (gdk_colormap_get_system (), &bg, FALSE, TRUE);
gtk_widget_modify_bg (GTK_WIDGET (scroll), GTK_STATE_NORMAL, &bg);
*/
win->bidding = GTK_TREE_VIEW (get_widget ("treeview_bidding"));
//gtk_widget_modify_bg (GTK_WIDGET (bidding), GTK_STATE_NORMAL, &bg);
//gdk_window_set_background (gtk_tree_view_get_bin_window (bidding), &bidding_vuln);
win->bidding_store = gtk_list_store_new (8,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model (win->bidding, GTK_TREE_MODEL (win->bidding_store));
#if GTK_CHECK_VERSION (2,12,0)
g_signal_connect (G_OBJECT (win->bidding), "query-tooltip",
G_CALLBACK (bidding_query_tooltip), win);
#endif
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xalign", 0.5,
"cell-background", "yellow",
"mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE,
NULL);
char *dir[] = {"W", "N", "E", "S"};
int i;
for (i = 0; i < 4; i++) {
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new_with_attributes (_(dir[i]), renderer,
"markup", 2 * i, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_min_width (column, 36);
gtk_tree_view_column_set_alignment (column, 0.5);
//g_signal_connect_swapped (column, "clicked", G_CALLBACK (bidding_clicked), 0);
/*
win->bidding_label[i] = gtk_label_new (dir[i]);
//gtk_label_set_width_chars (win->bidding_label[i], 4);
gtk_label_set_ellipsize (win->bidding_label[i], PANGO_ELLIPSIZE_END);
gtk_tree_view_column_set_widget (column, win->bidding_label[i]);
gtk_widget_show (win->bidding_label[i]);
*/
gtk_tree_view_append_column (win->bidding, column);
win->bidding_column[i] = column;
}
gtk_container_forall (GTK_CONTAINER (win->bidding), (GtkCallback) create_bidding_widget_cb, win);
GdkColormap *cmap = gdk_colormap_get_system ();
gdk_colormap_alloc_color (cmap, &bidding_non_vuln, FALSE, TRUE);
gdk_colormap_alloc_color (cmap, &bidding_vuln, FALSE, TRUE);
}
void
treeview2_set_up_job_exchange(GtkTreeView *treeview)
{
#ifdef DEBUG
printf("treeview2_set_up_job_exchange\n");
#endif
gint i;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
gchar *titles[6] =
{"",
_("Team"),
_("League"),
_("Country"),
_("Av.skill"),
_("Talent %")};
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(treeview),
GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_visible(treeview, TRUE);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[0]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer,
"text", 0);
for(i=1;i<3;i++)
{
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[i]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer,
"text", i);
}
for(i=3;i<6;i++)
{
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[i]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(col, renderer,
treeview_helper_job_exchange,
NULL, NULL);
if(i > 3)
{
gtk_tree_view_column_set_alignment(col, 0.5);
g_object_set(renderer, "xalign", 0.5, NULL);
}
}
}
/**
* add_columns:
* @treeview: the GtkTreeView to add the column to
*
* Adds a column to a GtkTreeView.
*/
static void
add_columns (GtkTreeView * treeview)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *img_att;
GdkPixbuf *pix;
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_(" Index "),
renderer,
"text", COL_INDEX,
NULL);
gtk_tree_view_column_set_alignment (column, (gfloat) 0.5);
gtk_tree_view_append_column (treeview, column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_(" Title "),
renderer,
"text", COL_ID,
NULL);
gtk_tree_view_column_set_alignment (column, (gfloat) 0.5);
gtk_tree_view_append_column (treeview, column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
pix = gdk_pixbuf_new_from_xpm_data (clip_xpm);
img_att = gtk_image_new_from_pixbuf (pix);
gtk_misc_set_alignment (GTK_MISC (img_att), (gfloat) 0.5,
(gfloat) 0.0);
g_object_unref (G_OBJECT (pix));
gtk_tree_view_column_set_widget (column, img_att);
g_object_set (G_OBJECT (renderer), "xalign", (gfloat) 0.5, NULL);
/*needed at least in GTK 2.0.6, anyways doing it seems stupid 2 me*/
gtk_widget_show (img_att);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_add_attribute (column, renderer, "text",
NUM_ATT);
gtk_tree_view_column_set_alignment (column, (gfloat) 0.5);
gtk_tree_view_append_column (treeview, column);
}
void gTree::setColumnAlignment(int ind, int align)
{
GtkTreeViewColumn *col = gt_tree_view_find_column(GTK_TREE_VIEW(widget), ind);
if (!col)
return;
gtk_tree_view_column_set_alignment(col, gt_from_alignment(align));
}
static GtkTreeModel *
ping_create_model (GtkTreeView * widget)
{
GtkCellRenderer *renderer;
static GtkTreeViewColumn *column;
GtkTreeModel *model;
renderer = gtk_cell_renderer_text_new ();
/* Number of bytes received in a ping reply */
column =
gtk_tree_view_column_new_with_attributes
(_("Bytes"), renderer, "text", 0, NULL);
gtk_tree_view_append_column (widget, column);
renderer = gtk_cell_renderer_text_new ();
/* IP address that reply a ping */
column =
gtk_tree_view_column_new_with_attributes
(_("Source"), renderer, "text", 1, NULL);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (widget, column);
renderer = gtk_cell_renderer_text_new ();
/* Number of sequence of a ICMP request (ping) */
column =
gtk_tree_view_column_new_with_attributes
(_("Seq"), renderer, "text", 2, NULL);
g_object_set (G_OBJECT (renderer), "xalign", 1.0, NULL);
gtk_tree_view_append_column (widget, column);
renderer = gtk_cell_renderer_text_new ();
/* Time elapsed between a packets was sent and
when was received its reply */
column =
gtk_tree_view_column_new_with_attributes
(_("Time"), renderer, "text", 3, NULL);
g_object_set (G_OBJECT (renderer), "xalign", 1.0, NULL);
gtk_tree_view_append_column (widget, column);
renderer = gtk_cell_renderer_text_new ();
/* Unit of time elapsed (commonly will be ms) */
column =
gtk_tree_view_column_new_with_attributes
(_("Units"), renderer, "text", 4, NULL);
gtk_tree_view_append_column (widget, column);
model = GTK_TREE_MODEL (gtk_list_store_new
(5,
G_TYPE_INT,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_STRING, G_TYPE_STRING));
return model;
}
static GtkTreeViewColumn *new_column(int type, int width, const char *title, ...){
GtkTreeViewColumn *col;
GtkCellRenderer *render=NULL;
col=gtk_tree_view_column_new();
switch(type){
case 0:
render=gtk_cell_renderer_text_new();
#if GTK_MAJOR_VERSION>=3 || GTK_MINOR_VERSION >= 18
gtk_cell_renderer_set_padding(render, 1, 1);
gtk_cell_renderer_set_alignment(render, 1, 0.5);
#endif
break;
case 1:
render=gtk_cell_renderer_progress_new();
break;
case 2:
render=gtk_cell_renderer_pixbuf_new();
break;
default:
error("Invalid\n");
}
gtk_tree_view_column_set_title(col, title);
gtk_tree_view_column_set_spacing(col, 2);
gtk_tree_view_column_set_alignment(col, 1);
gtk_tree_view_column_set_resizable(col, TRUE);
//gtk_tree_view_column_set_clickable(col, TRUE);
//gtk_tree_view_column_set_expand(col,FALSE);
if(width>0){//Adjustable columns
//Do not set min_width if set resizable.
//gtk_tree_view_column_set_min_width(col, width);
gtk_tree_view_column_set_expand(col,TRUE);
//resizable is not good if expand
gtk_tree_view_column_set_resizable(col, FALSE);
if(type==0){
g_object_set(G_OBJECT(render),"ellipsize",PANGO_ELLIPSIZE_START,NULL);
}
}else if(width<0){/*max width*/
gtk_tree_view_column_set_min_width(col,-width/10);
gtk_tree_view_column_set_max_width(col,-width);
}
gtk_tree_view_column_pack_start(col,render,TRUE);
va_list ap;
va_start(ap, title);
const char *att=NULL;
while((att=va_arg(ap, const char *))){
gtk_tree_view_column_add_attribute(col, render, att, va_arg(ap,int));
}
va_end(ap);
return col;
}
void create_column(void *view, int type,
char *title, int width)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
debug("create_column()");
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(title, renderer,
"text", type,
NULL);
gtk_tree_view_column_set_title(column, title);
gtk_tree_view_column_set_visible(column, TRUE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_min_width(column, width);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_column_set_clickable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_order(column, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
}
static void apply_window_insert_check_column(GtkWidget *list_view)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_toggle_new();
g_object_set(renderer,
"radio", FALSE,
"activatable", TRUE,
NULL);
column = gtk_tree_view_column_new_with_attributes
("",
renderer,
"active", TAG_SELECTED,
"inconsistent", TAG_SELECTED_INCONSISTENT,
NULL);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_insert_column(GTK_TREE_VIEW(list_view), column, 0);
g_signal_connect(G_OBJECT(renderer), "toggled",
G_CALLBACK(tag_apply_selected_toggled),
list_view);
}
static GtkTreeView* ug_selector_view_new (const gchar* title, gboolean active_toggled)
{
GtkTreeView* view;
GtkCellRenderer* renderer;
GtkTreeViewColumn* column;
view = (GtkTreeView*) gtk_tree_view_new ();
// gtk_tree_view_set_fixed_height_mode (view, TRUE);
// UgSelectorItem.mark
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "M");
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func (column, renderer,
col_set_toggle, NULL, NULL);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_column_set_min_width (column, 15);
// gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column (view, column);
if (active_toggled) {
g_signal_connect (renderer, "toggled",
G_CALLBACK (on_cell_toggled), view);
}
// UgSelectorItem.uri
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, title);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func (column, renderer,
col_set_uri, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
// gtk_tree_view_column_set_expand (column, TRUE);
// gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column (view, column);
gtk_widget_show (GTK_WIDGET (view));
return view;
}
static GtkTreeModel *
scan_create_model (GtkTreeView *widget)
{
GtkCellRenderer *renderer;
static GtkTreeViewColumn *column;
GtkTreeModel *model;
renderer = gtk_cell_renderer_text_new ();
/* Number of bytes received in a ping reply */
column =
gtk_tree_view_column_new_with_attributes
(_("Port"), renderer, "text", 0, NULL);
g_object_set (G_OBJECT (renderer), "xalign", 1.0, NULL);
gtk_tree_view_append_column (widget, column);
renderer = gtk_cell_renderer_text_new ();
/* IP address that reply a ping */
column =
gtk_tree_view_column_new_with_attributes
(_("State"), renderer, "text", 1, NULL);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (widget, column);
renderer = gtk_cell_renderer_text_new ();
/* Number of sequence of a ICMP request (ping) */
column =
gtk_tree_view_column_new_with_attributes
(_("Service"), renderer, "text", 2, NULL);
gtk_tree_view_append_column (widget, column);
model = GTK_TREE_MODEL (gtk_list_store_new
(3,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING));
return model;
}
bool
sc_toggle_index(girara_session_t* session, girara_argument_t* UNUSED(argument),
girara_event_t* UNUSED(event), unsigned int UNUSED(t))
{
g_return_val_if_fail(session != NULL, false);
g_return_val_if_fail(session->global.data != NULL, false);
zathura_t* zathura = session->global.data;
if (zathura->document == NULL) {
return false;
}
girara_tree_node_t* document_index = NULL;
GtkWidget* treeview = NULL;
GtkTreeModel* model = NULL;
GtkCellRenderer* renderer = NULL;
GtkCellRenderer* renderer2 = NULL;
if (zathura->ui.index == NULL) {
/* create new index widget */
zathura->ui.index = gtk_scrolled_window_new(NULL, NULL);
if (zathura->ui.index == NULL) {
goto error_ret;
}
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(zathura->ui.index),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* create index */
document_index = zathura_document_index_generate(zathura->document, NULL);
if (document_index == NULL) {
girara_notify(session, GIRARA_WARNING, _("This document does not contain any index"));
goto error_free;
}
model = GTK_TREE_MODEL(gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER));
if (model == NULL) {
goto error_free;
}
treeview = gtk_tree_view_new_with_model(model);
if (treeview == NULL) {
goto error_free;
}
gtk_style_context_add_class(gtk_widget_get_style_context(treeview),
"indexmode");
g_object_unref(model);
renderer = gtk_cell_renderer_text_new();
if (renderer == NULL) {
goto error_free;
}
renderer2 = gtk_cell_renderer_text_new();
if (renderer2 == NULL) {
goto error_free;
}
document_index_build(model, NULL, document_index);
girara_node_free(document_index);
/* setup widget */
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 0, "Title", renderer, "markup", 0, NULL);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 1, "Target", renderer2, "text", 1, NULL);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_object_set(G_OBJECT(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 0)), "expand", TRUE, NULL);
gtk_tree_view_column_set_alignment(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 1), 1.0f);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(treeview), gtk_tree_path_new_first(), NULL, FALSE);
g_signal_connect(G_OBJECT(treeview), "row-activated", G_CALLBACK(cb_index_row_activated), zathura);
gtk_container_add(GTK_CONTAINER(zathura->ui.index), treeview);
gtk_widget_show(treeview);
}
if (gtk_widget_get_visible(GTK_WIDGET(zathura->ui.index))) {
girara_set_view(session, zathura->ui.page_widget);
gtk_widget_hide(GTK_WIDGET(zathura->ui.index));
girara_mode_set(zathura->ui.session, zathura->modes.normal);
/* refresh view */
refresh_view(zathura);
} else {
/* save current position to the jumplist */
zathura_jumplist_add(zathura);
girara_set_view(session, zathura->ui.index);
gtk_widget_show(GTK_WIDGET(zathura->ui.index));
girara_mode_set(zathura->ui.session, zathura->modes.index);
}
return false;
error_free:
if (zathura->ui.index != NULL) {
g_object_ref_sink(zathura->ui.index);
zathura->ui.index = NULL;
}
if (document_index != NULL) {
girara_node_free(document_index);
}
error_ret:
return false;
}
void plugin_init(GeanyData *data)
{
conf = g_build_path(G_DIR_SEPARATOR_S, geany_data->app->configdir, "plugins", "quick-find.conf", NULL);
config = g_key_file_new();
g_key_file_load_from_file(config, conf, G_KEY_FILE_NONE, NULL);
executable = utils_get_setting_string(config, "main", "executable", DEFAULT_EXECUTABLE);
trim_file = g_regex_new(g_strconcat("^.*", G_DIR_SEPARATOR_S, NULL), G_REGEX_OPTIMIZE | G_REGEX_CASELESS, 0, NULL);
trim_regex = g_regex_new("\n$", G_REGEX_OPTIMIZE | G_REGEX_CASELESS, 0, NULL);
label = gtk_label_new(_("Find"));
panel = gtk_vbox_new(FALSE, 6);
scrollable_table = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollable_table), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(panel), scrollable_table, TRUE, TRUE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(geany->main_widgets->sidebar_notebook), panel, label);
entry = gtk_entry_new();
gtk_entry_set_icon_from_stock(GTK_ENTRY(entry), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_FIND);
g_signal_connect(entry, "activate", G_CALLBACK(on_activate), NULL);
GtkWidget *button_box = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(button_box), entry, TRUE, TRUE, 0);
GtkWidget *button = gtk_button_new_with_label(_("Find"));
g_signal_connect(button, "clicked", G_CALLBACK(on_click), NULL);
gtk_box_pack_end(GTK_BOX(button_box), button, FALSE, TRUE, 0);
check_case = gtk_check_button_new_with_label(_("Case Sensitive"));
ui_widget_set_tooltip_text(check_case, _("Perform a case-sensitive search."));
gtk_box_pack_end(GTK_BOX(panel), check_case, FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(panel), button_box, FALSE, TRUE, 0);
gtk_container_set_focus_child(GTK_CONTAINER(panel), entry);
GtkTreeViewColumn *number_column, *line_column, *file_column, *text_column;
GtkCellRenderer *render;
list = gtk_tree_store_new(4, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list));
render = gtk_cell_renderer_text_new();
number_column = gtk_tree_view_column_new_with_attributes("#", render, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), number_column);
gtk_tree_view_column_set_alignment(number_column, 1.0);
gtk_cell_renderer_set_alignment(render, 1.0, 0.0);
gtk_tree_view_column_add_attribute(number_column, render, "text", 0);
render = gtk_cell_renderer_text_new();
line_column = gtk_tree_view_column_new_with_attributes("Line", render, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), line_column);
gtk_tree_view_column_set_alignment(line_column, 1.0);
gtk_cell_renderer_set_alignment(render, 1.0, 0.0);
gtk_tree_view_column_add_attribute(line_column, render, "text", 1);
render = gtk_cell_renderer_text_new();
file_column = gtk_tree_view_column_new_with_attributes("File", render, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), file_column);
gtk_tree_view_column_add_attribute(file_column, render, "text", 2);
gtk_tree_view_column_set_cell_data_func(file_column, render, (GtkTreeCellDataFunc)cell_data, NULL, NULL);
render = gtk_cell_renderer_text_new();
text_column = gtk_tree_view_column_new_with_attributes("Text", render, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), text_column);
gtk_tree_view_column_add_attribute(text_column, render, "text", 3);
g_object_unref(GTK_TREE_MODEL(list));
GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
g_signal_connect(select, "changed", G_CALLBACK(selected_row), NULL);
gtk_container_add(GTK_CONTAINER(scrollable_table), tree);
gtk_widget_show(label);
gtk_widget_show_all(panel);
g_signal_connect(geany->main_widgets->window, "key-release-event", G_CALLBACK(panel_focus_tab), NULL);
GeanyKeyGroup *key_group;
key_group = plugin_set_key_group(geany_plugin, "quick_find_keyboard_shortcut", KB_GROUP, NULL);
keybindings_set_item(key_group, KB_QUICK_FIND, entry_focus, 0, 0, "quick_find", _("Quick Find..."), NULL);
}
static void editor_list_window_create(void)
{
GtkWidget *win_vbox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *scrolled;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkTreeModel *store;
GtkTreeSortable *sortable;
EditorListWindow *ewl;
editor_list_window = ewl = g_new0(EditorListWindow, 1);
ewl->window = window_new(GTK_WINDOW_TOPLEVEL, "editors", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Editors"));
gtk_window_set_type_hint(GTK_WINDOW(ewl->window), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT(ewl->window), "delete_event",
G_CALLBACK(editor_list_window_delete), NULL);
gtk_window_set_default_size(GTK_WINDOW(ewl->window), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT);
gtk_window_set_resizable(GTK_WINDOW(ewl->window), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(ewl->window), PREF_PAD_BORDER);
win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
gtk_container_add(GTK_CONTAINER(ewl->window), win_vbox);
gtk_widget_show(win_vbox);
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
button = pref_button_new(NULL, GTK_STOCK_NEW, NULL, FALSE,
G_CALLBACK(editor_list_window_new_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_EDIT, NULL, FALSE,
G_CALLBACK(editor_list_window_edit_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive(button, FALSE);
gtk_widget_show(button);
ewl->edit_button = button;
button = pref_button_new(NULL, GTK_STOCK_DELETE, NULL, FALSE,
G_CALLBACK(editor_list_window_delete_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive(button, FALSE);
gtk_widget_show(button);
ewl->delete_button = button;
button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE,
G_CALLBACK(editor_list_window_close_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(win_vbox), scrolled, TRUE, TRUE, 5);
gtk_widget_show(scrolled);
ewl->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(desktop_file_list));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
g_signal_connect(selection, "changed", G_CALLBACK(editor_list_window_selection_changed_cb), ewl);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ewl->view), FALSE);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_NAME);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Hidden"));
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_HIDDEN);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_HIDDEN);
gtk_tree_view_column_set_alignment(column, 0.5);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Desktop file"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_KEY);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_KEY);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Path"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_PATH);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_PATH);
/* set up sorting */
store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
sortable = GTK_TREE_SORTABLE(store);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_KEY, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_KEY), NULL);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_HIDDEN, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_HIDDEN), NULL);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_NAME, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_NAME), NULL);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_PATH, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_PATH), NULL);
/* set initial sort order */
//gtk_tree_sortable_set_sort_column_id(sortable, DESKTOP_FILE_COLUMN_KEY, GTK_SORT_ASCENDING);
gtk_container_add(GTK_CONTAINER(scrolled), ewl->view);
gtk_widget_show(ewl->view);
gtk_widget_show(ewl->window);
}
void Operator_manage(GtkWidget * UNUSED(widget), GtkWindow * parent) {
GtkWidget * dialog;
GtkWidget *hbox;
GtkWidget * bbox;
GtkWidget * sw;
GtkTreeModel * model;
GtkWidget *treeview;
GtkWidget * button;
GtkCellRenderer * renderer;
GtkTreeViewColumn *column;
/** Creation de la fenêtre principale */
dialog = gtk_dialog_new_with_buttons("Gestion des opérateurs", parent, GTK_DIALOG_MODAL
| GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
gtk_container_set_border_width(GTK_CONTAINER (dialog), 5);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
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_box_pack_start(GTK_BOX (hbox), sw, TRUE, TRUE, 0);
model = gtk_tree_model_sort_new_with_model(Operator_loadModel());
/* create tree view */
treeview = gtk_tree_view_new_with_model(model);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW (treeview), 0);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Opérateur");
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_min_width(column, 300);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_cell_renderer_set_alignment(renderer, 0, 0.5);
gtk_tree_view_append_column(GTK_TREE_VIEW (treeview), column);
gtk_widget_set_size_request(sw, 350, 400);
gtk_widget_show(treeview);
g_object_unref(model);
gtk_container_add(GTK_CONTAINER (sw), treeview);
bbox = gtk_vbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_set_spacing(GTK_BOX (bbox), 5);
gtk_box_pack_start(GTK_BOX (hbox), bbox, TRUE, TRUE, 0);
gtk_widget_show(bbox);
button = gtk_button_new_with_label("Ajouter");
g_signal_connect (button, "clicked", G_CALLBACK (Operator_add), treeview);
gtk_container_add(GTK_CONTAINER (bbox), button);
gtk_widget_show(button);
button = gtk_button_new_with_label("Supprimer");
g_signal_connect (button, "clicked", G_CALLBACK (Operator_delete), treeview);
gtk_container_add(GTK_CONTAINER (bbox), button);
gtk_widget_show(button);
button = gtk_button_new_with_label("Modifier");
g_signal_connect (button, "clicked", G_CALLBACK (Operator_modify), treeview);
gtk_container_add(GTK_CONTAINER (bbox), button);
gtk_widget_show_all(hbox);
gtk_dialog_run(GTK_DIALOG (dialog));
gtk_widget_destroy(dialog);
}
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
treeview2_set_up_bets(GtkTreeView *treeview)
{
#ifdef DEBUG
printf("treeview2_set_up_bets\n");
#endif
gint i;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
gchar *titles[6] =
{_("Team1"),
/* Team 1 wins (betting window). */
_("Win1"),
_("Draw"),
/* Team 2 wins (betting window). */
_("Win2"),
_("Team2"),
/* How much the user wagers; how much he won or lost. */
_("Wager/\nWin/Loss")};
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(treeview),
GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_visible(treeview, TRUE);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[0]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer,
"markup", 0);
gtk_tree_view_column_set_alignment(col, 1.0);
g_object_set(renderer, "xalign", 1.0, NULL);
for(i=1;i<4;i++)
{
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[i]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(col, renderer,
treeview_helper_bet_odds,
NULL, NULL);
}
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[4]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer,
"text", 4);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[5]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer,
"markup", 5);
gtk_tree_view_column_set_alignment(col, 0.5);
g_object_set(renderer, "xalign", 0.5, NULL);
}
/**
* callback called by the button to launch the automatic association
* between transactions and reconcile
*
* \param button
* \param assistant
*
* \return FALSE
* */
static gboolean gsb_assistant_reconcile_config_lauch_manu_asso ( GtkWidget *button,
GtkWidget *assistant )
{
GList *tmp_list;
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
GList *path_list;
gint account_number = -1;
GtkWidget *dialog;
GtkWidget *label;
GtkWidget *scrolled_window;
GtkWidget *dialog_tree_view;
GtkListStore *dialog_store;
gint return_value;
gint i;
enum dialog_column {
DIALOG_NAME = 0,
DIALOG_INIT_DATE,
DIALOG_FINAL_DATE,
DIALOG_RECONCILE_NUMBER,
DIALOG_NB_COL
};
gint selected_reconcile_number;
gint transaction_number;
/* get the selection */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview_transactions_to_link));
/* get the selected transactions */
path_list = gtk_tree_selection_get_selected_rows ( GTK_TREE_SELECTION (selection),
&model );
if (!path_list)
return FALSE;
/* ok, we have a selection, before continuing,
* we check that all the transactions are on the same account */
tmp_list = path_list;
while (tmp_list)
{
GtkTreePath *path;
path = tmp_list -> data;
if (gtk_tree_model_get_iter ( GTK_TREE_MODEL (model),
&iter,
path ))
{
gtk_tree_model_get ( GTK_TREE_MODEL (model),
&iter,
TRANSACTION_NUMBER, &transaction_number,
-1 );
if (account_number == -1)
account_number = gsb_data_transaction_get_account_number (transaction_number);
else
{
if (gsb_data_transaction_get_account_number (transaction_number) != account_number)
{
dialogue_error (_("All the selected transactions have to belong to the same account !"));
/* erase the path_list */
g_list_foreach (path_list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (path_list);
return FALSE;
}
}
}
tmp_list = tmp_list -> next;
}
if (account_number == -1)
{
/* erase the path_list */
g_list_foreach (path_list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (path_list);
return FALSE;
}
/* ok, all the transactions belong to the same account, we can
* show a dialog to select the reconcile */
dialog = gtk_dialog_new_with_buttons ( _("Selection of a reconciliation"),
GTK_WINDOW ( assistant ),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
"gtk-cancel", GTK_RESPONSE_CANCEL,
"gtk-ok", GTK_RESPONSE_OK,
NULL );
gtk_window_set_default_size ( GTK_WINDOW ( dialog ), 770, 412 );
gtk_window_set_position ( GTK_WINDOW ( dialog ), GTK_WIN_POS_CENTER_ON_PARENT );
gtk_window_set_resizable ( GTK_WINDOW ( dialog ), TRUE );
gtk_container_set_border_width ( GTK_CONTAINER ( dialog ), 12 );
label = gtk_label_new ( _("Select the reconciliation to associate to the selected transactions: ") );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0.0, 0.0 );
gtk_box_pack_start ( GTK_BOX ( dialog_get_content_area ( dialog ) ),
label,
FALSE, FALSE,
10 );
/* make the list */
scrolled_window = gtk_scrolled_window_new (FALSE, FALSE);
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC );
gtk_box_pack_start ( GTK_BOX ( dialog_get_content_area ( dialog ) ),
scrolled_window,
TRUE, TRUE,
0 );
dialog_store = gtk_list_store_new ( DIALOG_NB_COL,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT );
dialog_tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog_store));
g_object_unref (G_OBJECT(dialog_store));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dialog_tree_view), TRUE);
gtk_container_add ( GTK_CONTAINER (scrolled_window),
dialog_tree_view );
/* set the columns */
for (i=DIALOG_NAME ; i<DIALOG_RECONCILE_NUMBER ; i++)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
gchar *titles[] = {
_("Reconciliation reference"), _("Initial date"), _("Final date")
};
gfloat alignment[] = {
COLUMN_LEFT, COLUMN_CENTER, COLUMN_CENTER
};
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_start ( column, cell, TRUE );
gtk_tree_view_column_set_title ( column, titles[i] );
gtk_tree_view_column_set_attributes (column, cell,
"text", i,
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(dialog_tree_view), column);
}
/* fill the tree view */
tmp_list = gsb_data_reconcile_get_reconcile_list ();
while (tmp_list)
{
gint reconcile_number;
reconcile_number = gsb_data_reconcile_get_no_reconcile (tmp_list -> data);
if (gsb_data_reconcile_get_account (reconcile_number) == account_number)
{
gchar *init_date_str;
gchar *final_date_str;
init_date_str = gsb_format_gdate (gsb_data_reconcile_get_init_date (reconcile_number));
final_date_str = gsb_format_gdate (gsb_data_reconcile_get_final_date (reconcile_number));
gtk_list_store_append ( GTK_LIST_STORE (dialog_store),
&iter );
gtk_list_store_set ( GTK_LIST_STORE (dialog_store),
&iter,
DIALOG_NAME, gsb_data_reconcile_get_name (reconcile_number),
DIALOG_INIT_DATE, init_date_str,
DIALOG_FINAL_DATE, final_date_str,
DIALOG_RECONCILE_NUMBER, reconcile_number,
-1 );
g_free (init_date_str);
g_free (final_date_str);
}
tmp_list = tmp_list -> next;
}
gtk_widget_show_all (dialog);
/* launch the dialog */
return_value = gtk_dialog_run (GTK_DIALOG (dialog));
if (return_value != GTK_RESPONSE_OK)
{
gtk_widget_destroy (dialog);
return FALSE;
}
/* we get the selected reconcile */
if (!gtk_tree_selection_get_selected ( gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog_tree_view)),
NULL,
&iter ))
{
dialogue_warning (_("No selection found, the transactions are not modified."));
gtk_widget_destroy (dialog);
return FALSE;
}
gtk_tree_model_get ( GTK_TREE_MODEL (dialog_store),
&iter,
DIALOG_RECONCILE_NUMBER, &selected_reconcile_number,
-1 );
/* ok we have the reconcile number, we can destroy the dialog */
gtk_widget_destroy (dialog);
/* and now, fill the selected transactions with that reconcile number */
tmp_list = g_list_last (path_list);
while (tmp_list)
{
GtkTreePath *path;
path = tmp_list -> data;
if (gtk_tree_model_get_iter ( GTK_TREE_MODEL (model),
&iter,
path ))
{
gtk_tree_model_get ( GTK_TREE_MODEL (model),
&iter,
TRANSACTION_NUMBER, &transaction_number,
-1 );
gtk_list_store_remove ( GTK_LIST_STORE (model),
&iter );
gsb_data_transaction_set_reconcile_number ( transaction_number,
selected_reconcile_number );
transactions_to_link--;
}
tmp_list = tmp_list -> prev;
}
/* erase the path_list */
g_list_foreach (path_list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (path_list);
/* now there is 2 way :
* either transactions_to_link is 0, we go directly to the succes page
* either it's not null, and the user should create more reconciles */
if (transactions_to_link)
{
gchar *string;
/* update the labels */
string = g_strdup_printf (_("Still %d transactions to link with a reconciliation."),
transactions_to_link);
gtk_label_set_text ( GTK_LABEL (label_transactions_to_link_1),
string);
gtk_label_set_text ( GTK_LABEL (label_transactions_to_link_3),
string);
g_free (string);
gtk_widget_grab_focus (treeview_transactions_to_link);
}
else
{
/* go to the success page */
gsb_assistant_set_next ( assistant,
RECONCILE_ASSISTANT_MANUALLY_ASSOCIATE,
RECONCILE_ASSISTANT_SUCCESS );
gsb_assistant_next_page (assistant);
}
return FALSE;
}
struct layerWidget * initialize_layer_widget(struct xmi_layer **my_layer) {
#if DEBUG == 1
fprintf(stdout,"Entering initialize_layer_widget\n");
#endif
struct layerWidget *rv;
GtkWidget *window;
GtkWidget *mainVBox;
GtkWidget *HBox;
GtkWidget *VBox;
GtkWidget *addButton;
GtkWidget *editButton;
GtkWidget *removeButton;
GtkWidget *normalizeButton;
GtkWidget *okButton;
GtkWidget *cancelButton;
GtkWidget *label;
GtkWidget *sumEntry;
GtkWidget *densityEntry;
GtkWidget *thicknessEntry;
GtkWidget *separator;
GtkListStore *store;
GtkWidget *tree;
GtkTreeSelection *select;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *scrolledWindow;
struct xmi_layer *compound;
struct compoundWidget *cw;
struct add_data *ad;
rv = (struct layerWidget *) malloc(sizeof(struct layerWidget));
ad = (struct add_data *) malloc(sizeof(struct add_data));
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Modify layer");
gtk_window_set_default_size(GTK_WINDOW(window),200,200);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window),TRUE);
g_signal_connect(G_OBJECT(window), "show",G_CALLBACK(window_show_cb), (gpointer) rv);
g_signal_connect(G_OBJECT(window), "delete-event",G_CALLBACK(delete_layer_widget), NULL);
//initialize compound
cw = initialize_compound_widget(rv, GTK_WINDOW(window));
mainVBox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(mainVBox),5);
gtk_container_add(GTK_CONTAINER(window), mainVBox);
//connect window with widget show and hide signals!!!
//construct store
store = gtk_list_store_new(N_COLUMNS_LAYER, G_TYPE_STRING, G_TYPE_DOUBLE);
//construct tree
HBox = gtk_hbox_new(FALSE,5);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new();
my_gtk_cell_renderer_set_alignment(renderer, 0.5, 0.5);
column = gtk_tree_view_column_new_with_attributes("Element", renderer,"text",SYMBOL_COLUMN,NULL);
gtk_tree_view_column_set_resizable(column,TRUE);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
my_gtk_cell_renderer_set_alignment(renderer, 0.5, 0.5);
column = gtk_tree_view_column_new_with_attributes("Weight fraction (%)", renderer,"text",WEIGHT_COLUMN,NULL);
gtk_tree_view_column_set_resizable(column,TRUE);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
//gtk_widget_size_request(scrolledWindow,&size);
gtk_widget_set_size_request(scrolledWindow, 220,150);
gtk_container_add(GTK_CONTAINER(scrolledWindow), tree);
gtk_box_pack_start(GTK_BOX(HBox),scrolledWindow, FALSE, FALSE,3 );
//selections
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select,GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK(element_selection_changed_cb),
(gpointer) rv
);
//add/edit/remove
VBox = gtk_vbox_new(FALSE,5);
addButton = gtk_button_new_from_stock(GTK_STOCK_ADD);
editButton = gtk_button_new_from_stock(GTK_STOCK_EDIT);
removeButton = gtk_button_new_from_stock(GTK_STOCK_REMOVE);
gtk_widget_set_sensitive(addButton, TRUE);
gtk_widget_set_sensitive(editButton, FALSE);
gtk_widget_set_sensitive(removeButton, FALSE);
gtk_box_pack_start(GTK_BOX(VBox), addButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(VBox), editButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(VBox), removeButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(HBox),VBox, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
g_signal_connect(G_OBJECT(addButton),"clicked", G_CALLBACK(add_button_clicked_cb), (gpointer) ad );
g_signal_connect(G_OBJECT(editButton),"clicked", G_CALLBACK(edit_button_clicked_cb), (gpointer) ad );
g_signal_connect(G_OBJECT(removeButton),"clicked", G_CALLBACK(remove_button_clicked_cb), (gpointer) ad );
g_signal_connect(G_OBJECT(tree),"row-activated", G_CALLBACK(element_row_activated_cb), (gpointer) ad);
//Sum and normalize
HBox = gtk_hbox_new(FALSE,2);
label = gtk_label_new("Weights sum (%)");
sumEntry = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(sumEntry),FALSE);
normalizeButton = gtk_button_new_with_label("Normalize");
gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(HBox), sumEntry, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(HBox), normalizeButton, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
g_signal_connect(G_OBJECT(normalizeButton), "clicked", G_CALLBACK(normalize_button_clicked_cb), (gpointer) ad);
//separator
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(mainVBox), separator, FALSE, FALSE, 3);
//Density and thickness
HBox = gtk_hbox_new(FALSE,2);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label),"Density (g/cm<sup>3</sup>)");
densityEntry = gtk_entry_new();
rv->densityG =g_signal_connect(G_OBJECT(densityEntry),"changed",G_CALLBACK(density_thickness_changed_cb), (gpointer) rv);
gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
gtk_box_pack_end(GTK_BOX(HBox), densityEntry, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
HBox = gtk_hbox_new(FALSE,2);
label = gtk_label_new("Thickness (cm)");
thicknessEntry = gtk_entry_new();
rv->thicknessG = g_signal_connect(G_OBJECT(thicknessEntry),"changed",G_CALLBACK(density_thickness_changed_cb), (gpointer) rv);
gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
gtk_box_pack_end(GTK_BOX(HBox), thicknessEntry, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
//separator
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(mainVBox), separator, FALSE, FALSE, 3);
//ok, cancel...
okButton = gtk_button_new_from_stock(GTK_STOCK_OK);
cancelButton = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect(G_OBJECT(cancelButton),"clicked", G_CALLBACK(ok_cancel_button_clicked_cb), (gpointer) rv);
g_signal_connect(G_OBJECT(okButton),"clicked", G_CALLBACK(ok_cancel_button_clicked_cb), (gpointer) rv);
HBox = gtk_hbox_new(TRUE,2);
gtk_box_pack_start(GTK_BOX(HBox), okButton, TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(HBox), cancelButton, TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
//end of drawing widgets
#if DEBUG == 1
fprintf(stdout,"window pointer upon creation: %p\n",window);
#endif
rv->window = window;
rv->store = store;
rv->my_layer = my_layer;
rv->sumEntry = sumEntry;
rv->densityEntry = densityEntry;
rv->thicknessEntry = thicknessEntry;
rv->editButton = editButton;
rv->removeButton = removeButton;
rv->cancelButton = cancelButton;
rv->okButton = okButton;
ad->store = store;
ad->layer = my_layer;
ad->cw = cw;
ad->sumEntry = sumEntry;
ad->select = select;
ad->tree = tree;
return rv;
}
static void xmi_msim_gui_layer_dialog_init(XmiMsimGuiLayerDialog *dialog) {
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
gtk_dialog_add_buttons(GTK_DIALOG(dialog), "_Ok", GTK_RESPONSE_ACCEPT, "_Cancel", GTK_RESPONSE_REJECT, NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
gtk_window_set_default_size(GTK_WINDOW(dialog), 200, 200);
GtkWidget *contentArea = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget *mainVBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_box_set_homogeneous(GTK_BOX(mainVBox), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(mainVBox),5);
gtk_container_add(GTK_CONTAINER(contentArea), mainVBox);
GtkListStore *store = gtk_list_store_new(N_COLUMNS_LAYER, G_TYPE_STRING, G_TYPE_DOUBLE, G_TYPE_INT);
//construct tree
GtkWidget *HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
GtkWidget *compositionTreeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_cell_renderer_set_alignment(renderer, 0.5, 0.5);
GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes("Element", renderer, "text", SYMBOL_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_append_column(GTK_TREE_VIEW(compositionTreeView), column);
renderer = gtk_cell_renderer_text_new();
gtk_cell_renderer_set_alignment(renderer, 0.5, 0.5);
column = gtk_tree_view_column_new_with_attributes("Weight fraction (%)", renderer, "text", WEIGHT_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_append_column(GTK_TREE_VIEW(compositionTreeView), column);
GtkWidget *scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(scrolledWindow, 220, 150);
gtk_container_add(GTK_CONTAINER(scrolledWindow), compositionTreeView);
GtkWidget *frame = gtk_frame_new(NULL);
gtk_container_add(GTK_CONTAINER(frame), scrolledWindow);
gtk_box_pack_start(GTK_BOX(HBox), frame, FALSE, FALSE, 3);
//selections
GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(compositionTreeView));
gtk_tree_selection_set_mode(select, GTK_SELECTION_MULTIPLE);
g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(element_selection_changed), (gpointer) dialog);
//add/edit/remove
GtkWidget *VBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_box_set_homogeneous(GTK_BOX(VBox), FALSE);
GtkWidget *addButton = gtk_button_new_with_mnemonic("_Add");
GtkWidget *editButton = gtk_button_new_with_mnemonic("_Edit");
GtkWidget *removeButton = gtk_button_new_with_mnemonic("_Remove");
GtkWidget *predefButton = gtk_button_new_with_label("Load from catalog");
GtkWidget *addToCatalogButton = gtk_button_new_with_label("Add to catalog");
gtk_widget_set_sensitive(addButton, TRUE);
gtk_widget_set_sensitive(editButton, FALSE);
gtk_widget_set_sensitive(removeButton, FALSE);
gtk_widget_set_sensitive(predefButton, TRUE);
gtk_widget_set_sensitive(addToCatalogButton, FALSE);
gtk_box_pack_start(GTK_BOX(VBox), addButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(VBox), editButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(VBox), removeButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(VBox), predefButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(VBox), addToCatalogButton, TRUE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(HBox),VBox, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
g_signal_connect(G_OBJECT(addButton), "clicked", G_CALLBACK(add_button_clicked), (gpointer) dialog);
g_signal_connect(G_OBJECT(editButton), "clicked", G_CALLBACK(edit_button_clicked), (gpointer) dialog);
g_signal_connect(G_OBJECT(removeButton), "clicked", G_CALLBACK(remove_button_clicked), (gpointer) dialog);
g_signal_connect(G_OBJECT(predefButton), "clicked", G_CALLBACK(predef_button_clicked), (gpointer) dialog);
g_signal_connect(G_OBJECT(addToCatalogButton), "clicked", G_CALLBACK(add_to_catalog_button_clicked), (gpointer) dialog);
g_signal_connect(G_OBJECT(compositionTreeView), "row-activated", G_CALLBACK(element_row_activated), (gpointer) dialog);
//Sum and normalize
HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
GtkWidget *label = gtk_label_new("Weights sum (%)");
GtkWidget *sumLabel = gtk_label_new("");
gtk_label_set_justify(GTK_LABEL(sumLabel), GTK_JUSTIFY_CENTER);
GtkWidget *normalizeButton = gtk_button_new_with_label("Normalize");
gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(HBox), sumLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(HBox), normalizeButton, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
g_signal_connect(G_OBJECT(normalizeButton), "clicked", G_CALLBACK(normalize_button_clicked), (gpointer) dialog);
//separator
GtkWidget *separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(mainVBox), separator, FALSE, FALSE, 3);
//Density and thickness
HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label),"Density (g/cm<sup>3</sup>)");
GtkWidget *densityEntry = gtk_entry_new();
gtk_widget_set_name(densityEntry, "color_entry");
gtk_entry_set_activates_default(GTK_ENTRY(densityEntry), TRUE);
gulong density_changed = g_signal_connect(G_OBJECT(densityEntry), "changed", G_CALLBACK(density_thickness_changed), (gpointer) dialog);
gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
gtk_box_pack_end(GTK_BOX(HBox), densityEntry, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
label = gtk_label_new("Thickness (cm)");
GtkWidget *thicknessEntry = gtk_entry_new();
gtk_widget_set_name(thicknessEntry, "color_entry");
gtk_entry_set_activates_default(GTK_ENTRY(thicknessEntry), TRUE);
gulong thickness_changed = g_signal_connect(G_OBJECT(thicknessEntry), "changed", G_CALLBACK(density_thickness_changed), (gpointer) dialog);
gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
gtk_box_pack_end(GTK_BOX(HBox), thicknessEntry, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
dialog->addButton = addButton;
dialog->editButton = editButton;
dialog->removeButton = removeButton;
dialog->predefButton = predefButton;
dialog->addToCatalogButton = addToCatalogButton;
dialog->normalizeButton = normalizeButton;
dialog->sumLabel = sumLabel;
dialog->densityEntry = densityEntry;
dialog->thicknessEntry = thicknessEntry;
dialog->compositionTreeView = compositionTreeView;
dialog->density_changed = density_changed;
dialog->thickness_changed = thickness_changed;
g_signal_connect(G_OBJECT(compositionTreeView), "key-press-event", G_CALLBACK(backspace_key_clicked), (gpointer) dialog);
gtk_widget_show_all(contentArea);
}
/**
* This function initializes the Event Viewer functionnality through the
* GTK API.
*/
DiskPerformanceData *disk_performance_data(LttvPluginTab *ptab)
{
LttTime end;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
DiskPerformanceData* disk_data = g_new(DiskPerformanceData,1) ;
g_info("enter disk_performance_data \n");
Tab *tab = ptab->tab;
disk_data->tab = tab;
disk_data->ptab = ptab;
disk_data->time_window = lttvwindow_get_time_window(tab);
disk_data->disk_array = g_array_new(FALSE, FALSE, sizeof(lttv_total_block ));
lttvwindow_register_time_window_notify(tab,
disk_update_time_window,
disk_data);
disk_data->scroll_win = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (disk_data->scroll_win);
gtk_scrolled_window_set_policy(
GTK_SCROLLED_WINDOW(disk_data->scroll_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* Create a model for storing the data list */
disk_data->store_m = gtk_list_store_new (
N_COLUMNS, /* Total number of columns */
G_TYPE_STRING, /* Diskname */
G_TYPE_INT64, /* Bytes read */
G_TYPE_INT64, /* Bytes read/sec */
G_TYPE_INT,
G_TYPE_INT64, /* bytes written */
G_TYPE_INT64, /* bytes written/sec */
G_TYPE_INT
);
disk_data->tree_v = gtk_tree_view_new_with_model (GTK_TREE_MODEL (disk_data->store_m));
g_object_unref (G_OBJECT (disk_data->store_m));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("DiskName",
renderer,
"text", DISKNAME_COLUMN,
NULL);
gtk_tree_view_column_set_alignment (column, 0.0);
gtk_tree_view_column_set_fixed_width (column, 45);
gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("BytesRead",
renderer,
"text", BYTES_RD_COLUMN,
NULL);
gtk_tree_view_column_set_alignment (column, 0.0);
gtk_tree_view_column_set_fixed_width (column, 220);
gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("BytesRead/sec",
renderer,
"text", BYTES_RD_SEC_COLUMN,
NULL);
gtk_tree_view_column_set_alignment (column, 1.0);
gtk_tree_view_column_set_fixed_width (column, 220);
gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("NumReadOperations",
renderer,
"text",NUM_RD_COLUMN,
NULL);
gtk_tree_view_column_set_alignment (column, 1.0);
gtk_tree_view_column_set_fixed_width (column, 220);
gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("BytesWritten",
renderer,
"text", BYTES_WR_COLUMN,
NULL);
gtk_tree_view_column_set_alignment (column, 0.0);
gtk_tree_view_column_set_fixed_width (column, 145);
gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("BytesWritten/sec",
renderer,
"text", BYTES_WR_SEC_COLUMN,
NULL);
gtk_tree_view_column_set_alignment (column, 1.0);
gtk_tree_view_column_set_fixed_width (column, 220);
gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("NumWriteOperations",
renderer,
"text",NUM_WR_COLUMN,
NULL);
gtk_tree_view_column_set_alignment (column, 0.0);
gtk_tree_view_column_set_fixed_width (column, 145);
gtk_tree_view_append_column (GTK_TREE_VIEW (disk_data->tree_v), column);
disk_data->select_c = gtk_tree_view_get_selection (GTK_TREE_VIEW (disk_data->tree_v));
gtk_tree_selection_set_mode (disk_data->select_c, GTK_SELECTION_SINGLE);
gtk_container_add (GTK_CONTAINER (disk_data->scroll_win), disk_data->tree_v);
disk_data->hbox_v = gtk_hbox_new(0, 0);
gtk_box_pack_start(GTK_BOX(disk_data->hbox_v), disk_data->scroll_win, TRUE, TRUE, 0);
gtk_widget_show(disk_data->hbox_v);
gtk_widget_show(disk_data->tree_v);
g_disk_data_list = g_slist_append(g_disk_data_list, disk_data);
g_object_set_data_full(G_OBJECT(disk_data->hbox_v),
"disk_data",
disk_data,
(GDestroyNotify)gui_disperformance_free);
request_event(disk_data);
return disk_data;
}
/**
* create the page to manually associate the transactions to the reconciles
* show a complete list of orphans transactions, and for each of them, we propose
* to link them to a reconcile
*
* \param assistant
*
* \return a GtkWidget, the page to the assistant
* */
static GtkWidget *gsb_assistant_reconcile_config_page_manually_associate ( GtkWidget *assistant )
{
GtkWidget *page;
GtkWidget *label;
GtkWidget *separator;
GtkWidget *scrolled_window;
gint i;
GtkWidget *button;
GtkWidget *hbox;
GtkListStore *store;
gchar *titles[] = {
_("Date"), _("Payee"), _("Amount"), _("Account")
};
gfloat alignment[] = {
COLUMN_CENTER, COLUMN_LEFT, COLUMN_CENTER, COLUMN_CENTER
};
page = gtk_box_new ( GTK_ORIENTATION_VERTICAL, 0 );
gtk_container_set_border_width ( GTK_CONTAINER(page), 12 );
/* the number of transactions to link */
label_transactions_to_link_3 = gtk_label_new (NULL);
gtk_box_pack_start ( GTK_BOX (page),
label_transactions_to_link_3,
FALSE, FALSE, 0 );
separator = gtk_separator_new ( GTK_ORIENTATION_HORIZONTAL );
gtk_box_pack_start ( GTK_BOX (page),
separator,
FALSE, FALSE, 0 );
/* now we can show the list of orphans transactions */
label = gtk_label_new (_("Select the transaction(s) you want to associate with a reconciliation: "));
gtk_misc_set_alignment ( GTK_MISC ( label ), 0.0, 0.0 );
gtk_box_pack_start ( GTK_BOX (page),
label,
FALSE, FALSE, 10 );
scrolled_window = gtk_scrolled_window_new (FALSE, FALSE);
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC );
gtk_box_pack_start ( GTK_BOX (page),
scrolled_window,
TRUE, TRUE, 0 );
gtk_widget_show (scrolled_window);
/* set up the tree view */
store = gtk_list_store_new ( TRANSACTION_NB_COL,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT );
treeview_transactions_to_link = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
g_object_unref (G_OBJECT(store));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview_transactions_to_link), TRUE);
gtk_tree_selection_set_mode ( gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview_transactions_to_link)),
GTK_SELECTION_MULTIPLE );
gtk_container_add ( GTK_CONTAINER (scrolled_window),
treeview_transactions_to_link );
gtk_widget_show (treeview_transactions_to_link);
/* set the columns */
for (i=TRANSACTION_DATE ; i<TRANSACTION_NUMBER ; i++)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
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_start ( column, cell, TRUE );
gtk_tree_view_column_set_title ( column, titles[i] );
gtk_tree_view_column_set_attributes (column, cell,
"text", i,
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(treeview_transactions_to_link), column);
}
/* set the button to associate */
hbox = gtk_box_new ( GTK_ORIENTATION_HORIZONTAL, 0 );
gtk_box_set_homogeneous ( GTK_BOX ( hbox ), TRUE );
gtk_box_pack_start ( GTK_BOX (page),
hbox,
FALSE, FALSE,
10 );
button = gtk_button_new_with_label ( _("Link the selection to a reconciliation..."));
g_signal_connect ( G_OBJECT (button),
"clicked",
G_CALLBACK (gsb_assistant_reconcile_config_lauch_manu_asso),
assistant );
gtk_box_pack_start ( GTK_BOX (hbox),
button,
TRUE, TRUE,
0 );
gtk_widget_show_all (page);
return page;
}
/** Create QTH list widgets. */
static GtkWidget *create_qth_list()
{
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
qthlist = gtk_tree_view_new();
model = create_and_fill_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(qthlist), model);
g_object_unref(model);
/* name column */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer,
"text",
QTH_LIST_COL_NAME, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_insert_column(GTK_TREE_VIEW(qthlist), column, -1);
/* location column */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Location"), renderer,
"text", QTH_LIST_COL_LOC,
NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_insert_column(GTK_TREE_VIEW(qthlist), column, -1);
/* lat column */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Lat"), renderer,
"text", QTH_LIST_COL_LAT,
NULL);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_column_set_cell_data_func(column,
renderer,
float_cell_data_function,
GUINT_TO_POINTER(QTH_LIST_COL_LAT),
NULL);
gtk_tree_view_insert_column(GTK_TREE_VIEW(qthlist), column, -1);
/* lon column */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Lon"), renderer,
"text", QTH_LIST_COL_LON,
NULL);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_column_set_cell_data_func(column,
renderer,
float_cell_data_function,
GUINT_TO_POINTER(QTH_LIST_COL_LON),
NULL);
gtk_tree_view_insert_column(GTK_TREE_VIEW(qthlist), column, -1);
/* alt column */
renderer = gtk_cell_renderer_text_new();
if (sat_cfg_get_bool(SAT_CFG_BOOL_USE_IMPERIAL))
{
column = gtk_tree_view_column_new_with_attributes(_("Alt\n(ft)"),
renderer,
"text",
QTH_LIST_COL_ALT,
NULL);
}
else
{
column =
gtk_tree_view_column_new_with_attributes(_("Alt\n(m)"), renderer,
"text", QTH_LIST_COL_ALT,
NULL);
}
gtk_tree_view_insert_column(GTK_TREE_VIEW(qthlist), column, -1);
gtk_tree_view_column_set_alignment(column, 0.5);
/* locator */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("QRA"), renderer,
"text", QTH_LIST_COL_QRA,
NULL);
gtk_tree_view_insert_column(GTK_TREE_VIEW(qthlist), column, -1);
gtk_tree_view_column_set_alignment(column, 0.5);
/* weather station */
/* renderer = gtk_cell_renderer_text_new (); */
/* column = gtk_tree_view_column_new_with_attributes (_("WX"), renderer, */
/* "text", QTH_LIST_COL_WX, */
/* NULL); */
/* gtk_tree_view_insert_column (GTK_TREE_VIEW (qthlist), column, -1); */
/* gtk_tree_view_column_set_alignment (column, 0.5); */
/* default */
renderer = gtk_cell_renderer_toggle_new();
handler_id = g_signal_connect(renderer, "toggled",
G_CALLBACK(default_toggled), model);
column = gtk_tree_view_column_new_with_attributes(_("Default"), renderer,
"active",
QTH_LIST_COL_DEF, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(qthlist), column);
gtk_tree_view_column_set_alignment(column, 0.5);
g_signal_connect(qthlist, "row-activated", G_CALLBACK(row_activated_cb),
NULL);
#ifdef HAS_LIBGPS
/* GPSD enabled */
/*server */
renderer = gtk_cell_renderer_text_new();
column =
gtk_tree_view_column_new_with_attributes(_("GPSD\nServer"), renderer,
"text",
QTH_LIST_COL_GPSD_SERVER,
NULL);
gtk_tree_view_insert_column(GTK_TREE_VIEW(qthlist), column, -1);
gtk_tree_view_column_set_alignment(column, 0.5);
/*port */
renderer = gtk_cell_renderer_text_new();
column =
gtk_tree_view_column_new_with_attributes(_("GPSD\nPort"), renderer,
"text",
QTH_LIST_COL_GPSD_PORT, NULL);
gtk_tree_view_insert_column(GTK_TREE_VIEW(qthlist), column, -1);
gtk_tree_view_column_set_alignment(column, 0.5);
/*type */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("QTH\nType"), renderer,
"text",
QTH_LIST_COL_TYPE, NULL);
gtk_tree_view_insert_column(GTK_TREE_VIEW(qthlist), column, -1);
gtk_tree_view_column_set_alignment(column, 0.5);
#endif
return qthlist;
}
