static GtkTreeModel *create_col_model(GtkTreeView *treeview)
{
GtkListStore *store;
GtkTreeViewColumn *col;
GtkTreeIter iter;
const gchar *title;
int i;
store = gtk_list_store_new(1, G_TYPE_STRING);
i = 0;
col = gtk_tree_view_get_column(treeview, i++);
while (col) {
title = gtk_tree_view_column_get_title(col);
if (!title)
break;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
0, title,
-1);
col = gtk_tree_view_get_column(treeview, i++);
}
return GTK_TREE_MODEL(store);
}
void tree_view_column_set_default_width (GtkTreeView *view,
GtkTreeViewColumn *column,
const gchar *sizing_text)
{
PangoLayout* layout;
int default_width, title_width;
const gchar *column_title;
/* Default size is the larger of the column title and the sizing text */
column_title = gtk_tree_view_column_get_title (column);
layout = gtk_widget_create_pango_layout (GTK_WIDGET(view), column_title);
pango_layout_get_pixel_size(layout, &title_width, NULL);
g_object_unref(layout);
layout = gtk_widget_create_pango_layout (GTK_WIDGET(view), sizing_text);
pango_layout_get_pixel_size(layout, &default_width, NULL);
g_object_unref(layout);
default_width = MAX(default_width, title_width);
if (default_width)
{
default_width += 10; /* add some padding */
g_object_set(G_OBJECT(column),
"sizing", GTK_TREE_VIEW_COLUMN_FIXED,
"fixed-width", default_width,
NULL);
}
}
static gint print_tree_view_list_get_columns_title_nbre_lines ( GtkTreeView *tree_view )
{
GList *list_tmp;
gint nbre_lines = 0;
list_tmp = gtk_tree_view_get_columns ( tree_view );
while ( list_tmp )
{
GtkTreeViewColumn *col;
const gchar *text;
gint nbre_motifs = 0;
col = ( GtkTreeViewColumn * ) list_tmp -> data;
/* get the text */
text = gtk_tree_view_column_get_title ( col );
if ( text == NULL || strlen ( text ) == 0 )
{
list_tmp = list_tmp -> next;
continue;
}
if ( g_utf8_strchr ( text, -1, '\n' ) )
{
nbre_motifs = utils_str_get_nbre_motifs ( text, "\n" );
if ( nbre_motifs > nbre_lines )
nbre_lines = nbre_motifs;
}
list_tmp = list_tmp -> next;
}
nbre_lines++;
return nbre_lines;
}
char* gTree::columnName(int ind)
{
GtkTreeViewColumn *col=gt_tree_view_find_column(GTK_TREE_VIEW(widget),ind);
if (!col) return NULL;
return (char *)gtk_tree_view_column_get_title(col);
}
static void
column_dialog_label_cell_data_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer user_data)
{
GtkTreeViewColumn *column;
gchar *str, *label;
gtk_tree_model_get (tree_model, iter,
0, &column,
-1);
/* A small hack here, we strstrip since the gantt view has a \n in the
* title.
*/
str = g_strdup (gtk_tree_view_column_get_title (column));
label = g_strstrip (str);
g_object_set (cell,
"text", label,
NULL);
g_free (str);
}
static gboolean view_release_event(GtkWidget *view, GdkEventButton *event, gpointer user_data){
if(event->button!=1) return FALSE;
GtkTreePath *path=NULL;
GtkTreeViewColumn *column=NULL;
if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(view),
(gint)event->x,
(gint)event->y,
&path, &column, NULL, NULL)){
const gchar *title=gtk_tree_view_column_get_title(column);
if(!strcmp(title," ")){
GtkTreeIter iter;
gint ihost=GPOINTER_TO_INT(user_data);
GtkTreeModel *model=GTK_TREE_MODEL(lists[ihost]);
gtk_tree_model_get_iter(model, &iter, path);
GValue value=G_VALUE_INIT;
gtk_tree_model_get_value(model, &iter, COL_PID, &value);
int pid=strtol(g_value_get_string(&value), NULL, 10);
g_value_unset(&value);
PROC_T *p=proc_get(ihost, pid);
if(p){
if(p->status.info<10){
kill_job(p);
}else{
scheduler_cmd(ihost, pid, CMD_REMOVE);
}
}
}
}
return TRUE;
}
static void
egg_column_model_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
gint column,
GValue *value)
{
GtkTreeViewColumn *view_column;
g_return_if_fail (EGG_IS_COLUMN_MODEL (tree_model));
g_return_if_fail (column < N_COLUMNS);
g_return_if_fail (column >= 0);
g_return_if_fail (iter->stamp == EGG_COLUMN_MODEL (tree_model)->stamp);
view_column = GTK_TREE_VIEW_COLUMN (((GList *)iter->user_data)->data);
switch (column)
{
case COLUMN_VISIBLE:
g_value_init (value, G_TYPE_BOOLEAN);
g_value_set_boolean (value, gtk_tree_view_column_get_visible (view_column));
break;
case COLUMN_NAME:
g_value_init (value, G_TYPE_STRING);
g_value_set_string (value, gtk_tree_view_column_get_title (view_column));
break;
case COLUMN_OBJECT:
g_value_init (value, GTK_TYPE_TREE_VIEW_COLUMN);
g_value_set_object (value, view_column);
break;
default:
g_assert_not_reached ();
break;
}
}
static void
col_clicked_cb (GtkTreeViewColumn *col, gpointer data)
{
GtkWindow *win;
win = GTK_WINDOW (create_prop_editor (G_OBJECT (col), GTK_TYPE_TREE_VIEW_COLUMN));
gtk_window_set_title (win, gtk_tree_view_column_get_title (col));
}
//! click on header
static gboolean tableClickHeader(GtkTreeViewColumn *widget , gpointer user_data){
table->tittle = gtk_tree_view_column_get_title(widget);
//! mencari header yang di click
int x;
for(x=0;x<count(headerTable);x++){
gint id ;
id = g_strcmp0(table->tittle , headerTable [x]);
if(id == 0)
break;
}
databaseSortChange(x);
tableRefresh("");
// soundPlay("file:/home/zizou-desktop/Aman/music/Computer_Magic-Microsift-1901299923.wav" , 1);
// soundPlay("Computer_Magic-Microsift-1901299923.wav" , 1);
return FALSE;
}
static int hview_which_tree_store(GtkTreeViewColumn *column)
{
gchar *title = NULL;
int res;
title = gtk_tree_view_column_get_title(column);
if (strcmp(title, HVIEW_DOMAIN_COLUMN_TITLE) == 0) {
res = HVIEW_TREE_STORE_IS_DOMAINS;
} else if (strcmp(title, HVIEW_RESOURCE_COLUMN_TITLE) == 0) {
res = HVIEW_TREE_STORE_IS_RESOURCES;
} else {
res = HVIEW_TREE_STORE_IS_UNKNOWN;
}
return res;
}
/* This used to get the column as an argument binded when the signal was
* created, but it seems GTK now destroys and recreates them in some
* circumstances. So bind the column description instead and search for the
* column by its title.
*/
static gboolean
col_onButtonPressed(GtkButton * button,
GdkEventButton * event, trg_column_description *desc)
{
if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
GtkTreeView *gtv = GTK_TREE_VIEW(gtk_widget_get_parent(GTK_WIDGET(button)));
GList *cols = gtk_tree_view_get_columns(gtv);
GList *li;
for (li = cols; li; li = g_list_next(li)) {
GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN(li->data);
if (!g_strcmp0(desc->header, gtk_tree_view_column_get_title(col))) {
view_popup_menu(button, event, col);
break;
}
}
g_list_free(cols);
return TRUE;
}
return FALSE;
}
static void
view_column_model_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
gint column,
GValue *value)
{
ViewColumnModel *view_model = (ViewColumnModel *)tree_model;
g_return_if_fail (column < 2);
g_return_if_fail (view_model->stamp == iter->stamp);
g_return_if_fail (iter->user_data != NULL);
if (column == 0)
{
g_value_init (value, G_TYPE_STRING);
g_value_set_string (value, gtk_tree_view_column_get_title (GTK_TREE_VIEW_COLUMN (((GList *)iter->user_data)->data)));
}
else
{
g_value_init (value, GTK_TYPE_TREE_VIEW_COLUMN);
g_value_set_object (value, ((GList *)iter->user_data)->data);
}
}
static void gsb_csv_export_tree_view_list_export_title_line ( FILE *csv_file, GtkTreeView *tree_view )
{
GList *list;
GList *list_tmp;
list = gtk_tree_view_get_columns ( tree_view );
list_tmp = list;
while ( list_tmp )
{
GtkTreeViewColumn *col;
const gchar *text;
col = ( GtkTreeViewColumn * ) list_tmp -> data;
/* get the text */
text = gtk_tree_view_column_get_title ( col );
CSV_STR_FIELD( csv_file, text );
list_tmp = list_tmp -> next;
}
CSV_END_RECORD( csv_file );
}
native_handle _chisel_native_tablecolumn_get_title( native_handle ntablecolumn ) {
const gchar *title = gtk_tree_view_column_get_title( GTK_TREE_VIEW_COLUMN(ntablecolumn) );
return _chisel_native_string_create_with_utf8_bytes( (char*)title, strlen(title) );
}
static void
populate_dialog (PpPPDSelectionDialog *dialog)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeView *manufacturers_treeview;
GtkTreeView *models_treeview;
GtkWidget *widget;
GtkWidget *header;
manufacturers_treeview = (GtkTreeView*)
gtk_builder_get_object (dialog->builder, "ppd-selection-manufacturers-treeview");
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_padding (renderer, 10, 0);
/* Translators: Name of column showing printer manufacturers */
column = gtk_tree_view_column_new_with_attributes (_("Manufacturer"), renderer,
"text", PPD_MANUFACTURERS_DISPLAY_NAMES_COLUMN, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
header = gtk_label_new (gtk_tree_view_column_get_title (column));
gtk_widget_set_margin_start (header, 10);
gtk_tree_view_column_set_widget (column, header);
gtk_widget_show (header);
gtk_tree_view_append_column (manufacturers_treeview, column);
models_treeview = (GtkTreeView*)
gtk_builder_get_object (dialog->builder, "ppd-selection-models-treeview");
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_padding (renderer, 10, 0);
/* Translators: Name of column showing printer drivers */
column = gtk_tree_view_column_new_with_attributes (_("Driver"), renderer,
"text", PPD_DISPLAY_NAMES_COLUMN,
NULL);
gtk_tree_view_column_set_expand (column, TRUE);
header = gtk_label_new (gtk_tree_view_column_get_title (column));
gtk_widget_set_margin_start (header, 10);
gtk_tree_view_column_set_widget (column, header);
gtk_widget_show (header);
gtk_tree_view_append_column (models_treeview, column);
g_signal_connect (gtk_tree_view_get_selection (models_treeview),
"changed", G_CALLBACK (model_selection_changed_cb), dialog);
g_signal_connect (gtk_tree_view_get_selection (manufacturers_treeview),
"changed", G_CALLBACK (manufacturer_selection_changed_cb), dialog);
gtk_widget_show_all (dialog->dialog);
if (!dialog->list)
{
widget = (GtkWidget*)
gtk_builder_get_object (dialog->builder, "ppd-spinner");
gtk_widget_show (widget);
gtk_spinner_start (GTK_SPINNER (widget));
widget = (GtkWidget*)
gtk_builder_get_object (dialog->builder, "progress-label");
gtk_widget_show (widget);
}
else
{
fill_ppds_list (dialog);
}
}
static GtkWidget *
create_field_page(GtkWidget *tree, const gchar *child_schema, const gchar *text)
{
GtkWidget *vbox;
GtkWidget *scrolled;
GtkWidget *label;
GtkWidget *treeview;
GList *it, *columns;
GtkListStore *model;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
label = gtk_label_new_with_mnemonic (text);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_container_add (GTK_CONTAINER (scrolled), treeview);
g_object_unref (G_OBJECT (model));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"active", 0,
NULL);
if (g_strcmp0 (child_schema, "proctree") == 0)
g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (proc_field_toggled), model);
else if (g_strcmp0 (child_schema, "disktreenew") == 0)
g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (disk_field_toggled), model);
gtk_tree_view_column_set_clickable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"text", 1,
NULL);
gtk_tree_view_column_set_title (column, "Not Shown");
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
for(it = columns; it; it = it->next)
{
GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data);
GtkTreeIter iter;
const gchar *title;
gboolean visible;
gint column_id;
title = gtk_tree_view_column_get_title (column);
if (!title)
title = _("Icon");
column_id = gtk_tree_view_column_get_sort_column_id(column);
if ((column_id == COL_CGROUP) && (!cgroups_enabled()))
continue;
if ((column_id == COL_UNIT ||
column_id == COL_SESSION ||
column_id == COL_SEAT ||
column_id == COL_OWNER)
#ifdef HAVE_SYSTEMD
&& !LOGIND_RUNNING()
#endif
)
continue;
visible = gtk_tree_view_column_get_visible (column);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1);
}
g_list_free(columns);
return vbox;
}
/* List Selection Callback */
static gboolean selection_made_callback(GtkTreeSelection *selection,
gpointer data)
{
gchar *entry_name;
gchar *entry_pass;
gchar *entry_service;
gboolean autoconnect;
int x, y;
GtkTreeViewColumn *column = NULL;
GtkTreeIter sel;
GList *path_list;
gint sel_count = gtk_tree_selection_count_selected_rows(selection);
if (sel_count < 1 || sel_count > 1) {
gtk_entry_set_text(GTK_ENTRY(username), "");
gtk_entry_set_text(GTK_ENTRY(password), "");
if (sel_count > 1) {
gtk_widget_set_sensitive(GTK_WIDGET(mod_button), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(del_button), TRUE);
gtk_combo_box_set_active(GTK_COMBO_BOX(service_type),
-1);
} else {
gtk_widget_set_sensitive(GTK_WIDGET(mod_button), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(del_button), FALSE);
gtk_combo_box_set_active(GTK_COMBO_BOX(service_type),
-1);
}
return FALSE;
}
path_list = gtk_tree_selection_get_selected_rows(selection, NULL);
gtk_tree_model_get_iter(GTK_TREE_MODEL(account_list_store), &sel,
path_list->data);
g_list_foreach(path_list, (GFunc) gtk_tree_path_free, NULL);
g_list_free(path_list);
selected_row = sel;
gtk_widget_get_pointer(account_list, &x, &y);
gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(account_list),
x, y, NULL, &column, NULL, NULL);
if (column && !strcmp(gtk_tree_view_column_get_title(column), _("C"))) {
gboolean autoconnect;
gtk_tree_model_get(GTK_TREE_MODEL(account_list_store),
&selected_row, CONNECT, &autoconnect, -1);
gtk_list_store_set(account_list_store, &selected_row,
CONNECT, !autoconnect, -1);
}
gtk_tree_model_get(GTK_TREE_MODEL(account_list_store), &sel,
CONNECT, &autoconnect,
USER_NAME, &entry_name,
PASSWORD, &entry_pass, SERVICE_TYPE, &entry_service, -1);
gtk_entry_set_text(GTK_ENTRY(username), entry_name);
gtk_entry_set_text(GTK_ENTRY(password), entry_pass);
{
int i;
LList *l, *list = get_service_list();
for (l = list, i = 0; l; l = l_list_next(l), i++) {
char *name = l->data;
if (!strcmp(name, entry_service)) {
gtk_combo_box_set_active(GTK_COMBO_BOX
(service_type), i);
break;
}
}
l_list_free(list);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(connect_at_startup),
autoconnect);
gtk_widget_set_sensitive(GTK_WIDGET(mod_button), TRUE);
gtk_widget_set_sensitive(GTK_WIDGET(del_button), TRUE);
return FALSE;
}
/**
* draw the title of the columns
*
* \param context the GtkPrintContext
* \param line_position the position to insert the titles
*
* \return the new line_position to continue to fill the page
* */
static gint print_tree_view_list_draw_columns_title ( GtkPrintContext *context,
gint line_position,
GtkTreeView *tree_view )
{
GList *list;
GList *list_tmp;
gint column = 0;
gint column_position;
devel_debug_int ( line_position );
if ( !gsb_data_print_config_get_draw_columns_name () )
return line_position;
/* begin a row : fill the line before the row */
line_position = print_tree_view_list_draw_line ( line_position );
list = gtk_tree_view_get_columns ( tree_view );
if ( nbre_lines_col_title == 1 )
{
/* draw the last column */
print_tree_view_list_draw_column ( page_width, line_position );
list_tmp = list;
while ( list_tmp )
{
GtkTreeViewColumn *col;
const gchar *text;
col = ( GtkTreeViewColumn * ) list_tmp -> data;
column_position = columns_position[column];
/* get the text */
text = gtk_tree_view_column_get_title ( col );
if (!text)
{
list_tmp = list_tmp -> next;
column++;
continue;
}
print_tree_view_list_draw_cell ( context, line_position, column_position, column, text );
list_tmp = list_tmp -> next;
column++;
}
line_position = line_position + size_columns_title;
}
else
{
gchar **tab;
gchar *str_tmp;
gint i = 0;
for ( i = 0; i < nbre_lines_col_title; i ++ )
{
/* draw the last column */
print_tree_view_list_draw_column ( page_width, line_position );
list_tmp = list;
while ( list_tmp )
{
GtkTreeViewColumn *col;
const gchar *text;
col = ( GtkTreeViewColumn * ) list_tmp -> data;
column_position = columns_position[column];
/* get the text */
text = gtk_tree_view_column_get_title ( col );
if ( text == NULL || strlen ( text ) == 0 )
{
print_tree_view_list_draw_column ( column_position, line_position );
list_tmp = list_tmp -> next;
column++;
continue;
}
str_tmp = gsb_string_uniform_new_line ( text, strlen ( text ) );
if ( str_tmp == NULL )
{
if ( i == 0 )
print_tree_view_list_draw_cell ( context, line_position, column_position, column, text );
else
print_tree_view_list_draw_column ( column_position, line_position );
list_tmp = list_tmp -> next;
column++;
continue;
}
tab = g_strsplit ( str_tmp, "\n", 0 );
if ( tab[i] && strlen ( tab[i] ) )
print_tree_view_list_draw_cell ( context, line_position, column_position, column, tab[i] );
else
print_tree_view_list_draw_column ( column_position, line_position );
list_tmp = list_tmp -> next;
column++;
g_strfreev ( tab );
g_free ( str_tmp );
}
line_position = line_position + size_row + gsb_data_print_config_get_draw_lines ( );
column = 0;
}
}
return line_position;
}
static GtkWidget *
create_field_page(GtkWidget *tree, const char* text)
{
GtkWidget *vbox;
GtkWidget *scrolled;
GtkWidget *label;
GtkWidget *treeview;
GList *it, *columns;
GtkListStore *model;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
vbox = gtk_vbox_new (FALSE, 6);
label = gtk_label_new_with_mnemonic (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_container_add (GTK_CONTAINER (scrolled), treeview);
g_object_unref (G_OBJECT (model));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"active", 0,
NULL);
g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (field_toggled), model);
gtk_tree_view_column_set_clickable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"text", 1,
NULL);
gtk_tree_view_column_set_title (column, "Not Shown");
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
for(it = columns; it; it = it->next)
{
GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data);
GtkTreeIter iter;
const gchar *title;
gboolean visible;
title = gtk_tree_view_column_get_title (column);
if (!title)
title = _("Icon");
visible = gtk_tree_view_column_get_visible (column);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1);
}
g_list_free(columns);
return vbox;
}
/**
* Print a column's title.
* @param column tree view column to print information about
*/
void mk_print_GtkTreeViewColumn_info(GtkTreeViewColumn* column)
{
const gchar* title = gtk_tree_view_column_get_title(column);
gint sort_column_id = gtk_tree_view_column_get_sort_column_id(column);
g_printf("\t%d\t%s", sort_column_id, title);
}
static void search_tree(gpointer data)
{
struct search_info *info = data;
GtkTreePath *path;
GtkTreeViewColumn *col;
GtkTreeModel *model;
TraceViewStore *store;
GtkTreeIter iter;
GtkEntry *entry = GTK_ENTRY(info->entry);
GtkComboBox *col_combo = GTK_COMBO_BOX(info->column);
GtkComboBox *sel_combo = GTK_COMBO_BOX(info->selection);
const gchar *title;
const gchar *search_text;
gint col_num;
gint sel;
gint search_val;
gint start_row;
gboolean found = FALSE;
gint i = 0;
col_num = gtk_combo_box_get_active(col_combo);
sel = gtk_combo_box_get_active(sel_combo);
if (col_num >= TRACE_VIEW_STORE_N_COLUMNS)
return;
search_text = gtk_entry_get_text(entry);
if (!search_text || !strlen(search_text))
return;
col = gtk_tree_view_get_column(info->treeview, col_num);
if (!col)
return;
title = gtk_tree_view_column_get_title(col);
if (!title)
return;
model = gtk_tree_view_get_model(info->treeview);
if (!model)
return;
store = TRACE_VIEW_STORE(model);
if (!trace_view_store_visible_rows(store))
return;
start_row = trace_view_get_selected_row(GTK_WIDGET(info->treeview));
if (start_row < 0)
start_row = 0;
if (!gtk_tree_model_iter_nth_child(model, &iter, NULL, start_row))
return;
trace_set_cursor(GDK_WATCH);
trace_freeze_all();
search_val = atoi(search_text);
while (gtk_tree_model_iter_next(model, &iter)) {
/* Needed to process the cursor change */
if (!(i++ & ((1 << 5)-1)))
gtk_main_iteration_do(FALSE);
found = test_row(model, &iter, sel, col_num, search_val, search_text);
if (found)
break;
}
trace_unfreeze_all();
trace_put_cursor();
if (!found) {
GtkResponseType ret;
gint pages = trace_view_store_get_pages(store);
gint page = trace_view_store_get_page(store);
if (page < pages) {
ret = trace_dialog(NULL, TRACE_GUI_ASK,
"Not found on this page\n"
"Search next pages?");
if (ret == GTK_RESPONSE_YES)
search_next_pages(info->treeview, store, sel,
col_num, search_val, search_text);
return;
}
trace_dialog(NULL, TRACE_GUI_INFO, "Not found");
return;
}
path = gtk_tree_model_get_path(model, &iter);
select_row_from_path(info->treeview, path);
gtk_tree_path_free(path);
}
/* callbacks */
static void
gmdb_sql_write_rslt_cb(GtkWidget *w, GladeXML *xml)
{
gchar *file_path;
GladeXML *sql_xml;
GtkWidget *filesel, *dlg;
FILE *outfile;
int i;
int need_headers = 0;
int need_quote = 0;
gchar delimiter[11];
gchar quotechar;
gchar lineterm[5];
gchar *str, *buf;
int rows=0, n_columns;
GtkWidget *treeview;
GtkTreeViewColumn *col;
GList *glist;
GtkTreeStore *store;
GtkTreeIter iter;
GValue value = { 0, };
filesel = glade_xml_get_widget (xml, "export_dialog");
sql_xml = g_object_get_data(G_OBJECT(filesel), "sql_xml");
printf("sql_xml %lu\n",sql_xml);
gmdb_export_get_delimiter(xml, delimiter, 10);
gmdb_export_get_lineterm(xml, lineterm, 5);
need_quote = gmdb_export_get_quote(xml);
quotechar = gmdb_export_get_quotechar(xml);
need_headers = gmdb_export_get_headers(xml);
file_path = gmdb_export_get_filepath(xml);
if ((outfile=fopen(file_path, "w"))==NULL) {
dlg = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (w)),
GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE,
_("Unable to open file."));
gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
return;
}
treeview = glade_xml_get_widget (sql_xml, "sql_results");
glist = gtk_tree_view_get_columns(GTK_TREE_VIEW(treeview));
i = 0;
if (need_headers) {
while (col = g_list_nth_data(glist, i)) {
gchar *title;
if (i>0) fputs(delimiter, outfile);
title = g_strdup(gtk_tree_view_column_get_title(col));
gmdb_print_quote(outfile, need_quote, quotechar,
delimiter, title);
fputs(title, outfile);
gmdb_print_quote(outfile, need_quote, quotechar,
delimiter, title);
g_free(title);
i++;
}
fputs(lineterm, outfile);
g_list_free(glist);
}
store = (GtkTreeStore *) gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
rows=0;
g_value_init (&value, G_TYPE_STRING);
do {
rows++;
n_columns = gtk_tree_model_get_n_columns(GTK_TREE_MODEL(store));
for (i=0; i < n_columns; i++) {
if (i>0) fputs(delimiter, outfile);
gtk_tree_model_get_value(GTK_TREE_MODEL(store),
&iter, i, &value);
str = (gchar *) g_value_get_string(&value);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, str);
fputs(str, outfile);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, str);
g_value_unset(&value);
}
fputs(lineterm, outfile);
} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
fclose(outfile);
gtk_widget_destroy(filesel);
dlg = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (w)),
GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE,
_("%d rows successfully exported."), rows);
gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
}
