static void create_view_and_model()
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
bdk_window.view = gtk_tree_view_new();
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(bdk_window.view), TRUE);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, "Variable");
gtk_tree_view_append_column(GTK_TREE_VIEW(bdk_window.view), col);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_VARIABLE);
/* Columm #2 */
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, "Value");
gtk_tree_view_append_column(GTK_TREE_VIEW(bdk_window.view), col);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_VALUE);
gtk_tree_view_column_set_cell_data_func(col, renderer, age_cell_data_func, NULL, NULL);
create_and_fill_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(bdk_window.view), bdk_window.model);
g_object_unref(bdk_window.model);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(bdk_window.view)), GTK_SELECTION_NONE);
g_signal_connect(bdk_window.view, "row-activated", (GCallback) view_onRowActivated, NULL);
}
void
qtcTreeViewSetup(GtkWidget *widget)
{
QTC_DEF_WIDGET_PROPS(props, widget);
if (widget && !qtcWidgetProps(props)->treeViewHacked) {
QtCTreeView *tv = qtcTreeViewLookupHash(widget, true);
GtkTreeView *treeView = GTK_TREE_VIEW(widget);
GtkWidget *parent = gtk_widget_get_parent(widget);
if (tv) {
qtcWidgetProps(props)->treeViewHacked = true;
int x, y;
#if GTK_CHECK_VERSION(2, 90, 0) /* Gtk3:TODO !!! */
tv->fullWidth = true;
#else
gtk_widget_style_get(widget, "row_ending_details",
&tv->fullWidth, NULL);
#endif
gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, 0L);
gtk_tree_view_convert_widget_to_bin_window_coords(treeView, x, y,
&x, &y);
qtcTreeViewUpdatePosition(widget, x, y);
qtcConnectToProp(props, treeViewDestroy, "destroy-event",
qtcTreeViewDestroy, NULL);
qtcConnectToProp(props, treeViewUnrealize, "unrealize",
qtcTreeViewDestroy, NULL);
qtcConnectToProp(props, treeViewStyleSet, "style-set",
qtcTreeViewStyleSet, NULL);
qtcConnectToProp(props, treeViewMotion, "motion-notify-event",
qtcTreeViewMotion, NULL);
qtcConnectToProp(props, treeViewLeave, "leave-notify-event",
qtcTreeViewLeave, NULL);
}
if (!gtk_tree_view_get_show_expanders(treeView))
gtk_tree_view_set_show_expanders(treeView, true);
if (gtk_tree_view_get_enable_tree_lines(treeView))
gtk_tree_view_set_enable_tree_lines(treeView, false);
if (GTK_IS_SCROLLED_WINDOW(parent) &&
gtk_scrolled_window_get_shadow_type(GTK_SCROLLED_WINDOW(parent)) !=
GTK_SHADOW_IN) {
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(parent),
GTK_SHADOW_IN);
}
}
}
/* Create a new dir tree view */
GtkWidget* ptk_dir_tree_view_new( PtkFileBrowser* browser,
gboolean show_hidden )
{
GtkTreeView * dir_tree_view;
GtkTreeViewColumn* col;
GtkCellRenderer* renderer;
GtkTreeModel* model;
GtkTreeSelection* tree_sel;
GtkTreePath* tree_path;
GtkTreeModel* filter;
dir_tree_view = GTK_TREE_VIEW( gtk_tree_view_new () );
gtk_tree_view_set_headers_visible( dir_tree_view, FALSE );
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_tree_view_set_enable_tree_lines(dir_tree_view, TRUE);
#endif
/*
FIXME: Temporarily disable drag & drop since it doesn't work right now.
gtk_tree_view_enable_model_drag_dest ( dir_tree_view,
drag_targets,
sizeof( drag_targets ) / sizeof( GtkTargetEntry ),
GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK );
gtk_tree_view_enable_model_drag_source ( dir_tree_view,
( GDK_CONTROL_MASK | GDK_BUTTON1_MASK | GDK_BUTTON3_MASK ),
drag_targets,
sizeof( drag_targets ) / sizeof( GtkTargetEntry ),
GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK );
*/
col = gtk_tree_view_column_new ();
renderer = ( GtkCellRenderer* ) ptk_file_icon_renderer_new();
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_tree_view_column_set_attributes( col, renderer, "pixbuf", COL_DIR_TREE_ICON,
"info", COL_DIR_TREE_INFO, NULL );
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start( col, renderer, TRUE );
gtk_tree_view_column_set_attributes( col, renderer, "text", COL_DIR_TREE_DISP_NAME, NULL );
gtk_tree_view_append_column ( dir_tree_view, col );
tree_sel = gtk_tree_view_get_selection( dir_tree_view );
gtk_tree_selection_set_select_function( tree_sel, sel_func, NULL, NULL );
if ( G_UNLIKELY( !dir_tree_view_data ) )
dir_tree_view_data = g_quark_from_static_string( "show_hidden" );
g_object_set_qdata( G_OBJECT( dir_tree_view ),
dir_tree_view_data, ( gpointer ) show_hidden );
model = get_dir_tree_model();
filter = gtk_tree_model_filter_new( model, NULL );
g_object_unref( G_OBJECT( model ) );
gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( filter ),
filter_func, dir_tree_view, NULL );
gtk_tree_view_set_model( dir_tree_view, filter );
g_object_unref( G_OBJECT( filter ) );
g_signal_connect ( dir_tree_view, "row-expanded",
G_CALLBACK ( on_dir_tree_view_row_expanded ),
model );
g_signal_connect_data ( dir_tree_view, "row-collapsed",
G_CALLBACK ( on_dir_tree_view_row_collapsed ),
model, NULL, G_CONNECT_AFTER );
g_signal_connect ( dir_tree_view, "button-press-event",
G_CALLBACK ( on_dir_tree_view_button_press ),
browser );
g_signal_connect ( dir_tree_view, "key-press-event",
G_CALLBACK ( on_dir_tree_view_key_press ),
NULL );
tree_path = gtk_tree_path_new_first();
gtk_tree_view_expand_row( dir_tree_view, tree_path, FALSE );
gtk_tree_path_free( tree_path );
g_signal_connect( dir_tree_view, "destroy", G_CALLBACK(on_destroy), NULL );
return GTK_WIDGET( dir_tree_view );
}
void project_main_dialog_init_list(GtkWidget *treeview)
{
GtkCellRenderer *renderer;
GtkListStore *store;
// Tree view configuration
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(treeview), GTK_TREE_VIEW_GRID_LINES_BOTH);
// Render
renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new_with_attributes("Project", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_column_set_sort_column_id(column, PROJECT_MAIN_DIALOG_LIST_COLUMN_PROJECT_ID);
gtk_tree_view_column_set_resizable(column, TRUE);
column = gtk_tree_view_column_new_with_attributes("Issues", renderer, "text", 1, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_column_set_sort_column_id(column, PROJECT_MAIN_DIALOG_LIST_COLUMN_ISSUES_COUNT_ID);
gtk_tree_view_column_set_resizable(column, TRUE);
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", 2, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_column_set_sort_column_id(column, PROJECT_MAIN_DIALOG_LIST_COLUMN_STATUS_ID);
gtk_tree_view_column_set_resizable(column, TRUE);
// List model
store = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(store));
g_object_unref(store);
// Setup the selection handler
GtkTreeSelection *select;
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
// Sort columns
GtkTreeSortable *sortable = GTK_TREE_SORTABLE(store);
gtk_tree_sortable_set_sort_func(sortable,
PROJECT_MAIN_DIALOG_LIST_COLUMN_PROJECT_ID,
project_main_dialog_list_sort_callback,
GINT_TO_POINTER(PROJECT_MAIN_DIALOG_LIST_COLUMN_PROJECT_ID),
NULL);
gtk_tree_sortable_set_sort_func(sortable,
PROJECT_MAIN_DIALOG_LIST_COLUMN_ISSUES_COUNT_ID,
project_main_dialog_list_sort_callback,
GINT_TO_POINTER(PROJECT_MAIN_DIALOG_LIST_COLUMN_ISSUES_COUNT_ID),
NULL);
gtk_tree_sortable_set_sort_func(sortable,
PROJECT_MAIN_DIALOG_LIST_COLUMN_STATUS_ID,
project_main_dialog_list_sort_callback,
GINT_TO_POINTER(PROJECT_MAIN_DIALOG_LIST_COLUMN_STATUS_ID),
NULL);
// List callbacks
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(project_main_dialog_on_list_row_activated),
NULL);
}
/*
* create variables tree view widget
* arguments:
* on_render_name - custom name column renderer function
* on_expression_changed - callback to call on expression changed
*/
GtkWidget* vtree_create(watch_render_name on_render_name, watch_expression_changed on_expression_changed)
{
/* create tree view */
GtkTreeStore* store = gtk_tree_store_new (
W_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT);
GtkWidget* tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
/* set tree view parameters */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
g_object_set(tree, "rules-hint", TRUE, NULL);
/* connect signals */
g_signal_connect(G_OBJECT(tree), "row-collapsed", G_CALLBACK (on_row_collapsed), NULL);
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_key_pressed), NULL);
/* create columns */
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gchar *header;
int char_width = get_char_width(tree);
/* Name */
header = _("Name");
renderer = gtk_cell_renderer_text_new ();
column = create_column(header, renderer, FALSE,
get_header_string_width(header, MW_NAME, char_width),
"text", W_NAME);
if (on_render_name)
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_name, NULL, NULL);
if (on_expression_changed)
{
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (on_expression_changed), NULL);
}
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Value */
header = _("Value");
renderer = gtk_cell_renderer_text_new ();
column = create_column(header, renderer, TRUE,
get_header_string_width(header, MW_VALUE, char_width),
"text", W_VALUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, render_value, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Type */
header = _("Type");
renderer = gtk_cell_renderer_text_new ();
column = create_column(header, renderer, FALSE,
get_header_string_width(header, MW_TYPE, char_width),
"text", W_TYPE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Internal (unvisible column) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Internal", renderer, "text", W_INTERNAL, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Path expression (unvisible column) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Expression", renderer, "text", W_EXPRESSION, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* STUB (unvisible column) */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Need Update", renderer, "active", W_STUB, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_visible(column, FALSE);
/* Changed (unvisible column) */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Changed", renderer, "active", W_CHANGED, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_visible(column, FALSE);
return tree;
}
static GtkWidget *
buildExplorer ( void *pData )
{
GtkWidget *dialog;
GtkWidget *vbox, *buttonBox, *closeButton, *statusBar;
char windowTitle[strlen(PROGRAM_NAME) + strlen(TAG_EVENTOR_EXPLORER_WINDOW_TITLE) + 10];
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
dialog = gtk_window_new( GTK_WINDOW_TOPLEVEL );
sprintf(windowTitle, "%s%s", PROGRAM_NAME, TAG_EVENTOR_EXPLORER_WINDOW_TITLE );
gtk_window_set_title( (GtkWindow *)dialog, windowTitle );
/* set the icon for the window */
gtk_window_set_icon_name( (GtkWindow *)dialog, ICON_NAME_CONNECTED );
/* When the window is given the "delete" signal (this is given
* by the window manager, usually by the "close" option, or on the
* titlebar) */
g_signal_connect (G_OBJECT (dialog), "delete_event",
G_CALLBACK (deleteSignalHandler), NULL);
/* Here we connect the "destroy" event to a signal handler.
* This event occurs when we call gtk_widget_destroy() on the window,
* or if we return FALSE in the "delete_event" callback. */
g_signal_connect (G_OBJECT (dialog), "destroy",
G_CALLBACK (destroy), NULL);
/******************************* Vertical Box ***********************************/
/* vertical box to hold things, Not homogeneous sizes and spaceing 0 */
vbox = gtk_vbox_new(FALSE, 0);
/* This packs the vbox into the window (a gtk container). */
gtk_container_add (GTK_CONTAINER (dialog), vbox);
/****************************** Tree View ***************************************/
/* Create a model for the tree view. with two text columns */
store = gtk_tree_store_new ( N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
/* custom function to fill the model with data */
explorerFillTreeModel();
/* Create a view */
treeView = gtk_tree_view_new_with_model ( GTK_TREE_MODEL ( store ) );
/* The view now holds a reference. We can get rid of our own reference */
g_object_unref (G_OBJECT (store));
/* Create a columnfor the object name */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Object", renderer,
"text", OBJECT_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), column);
/* Second column.. description of object */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Description", renderer,
"text", DESCRIPTION_COLUMN,
NULL);
gtk_tree_view_append_column( GTK_TREE_VIEW (treeView), column);
gtk_tree_view_set_enable_tree_lines( GTK_TREE_VIEW(treeView), TRUE );
gtk_tree_view_expand_all( GTK_TREE_VIEW( treeView ) );
/************** Pack in Tree View *********************************/
/* This packs the scrolled window into the vbox (a gtk container). */
gtk_box_pack_start( GTK_BOX(vbox), treeView, TRUE, TRUE, 3);
/******************************* Button Box ***************************************/
/* create the box for the buttons */
buttonBox = gtk_hbox_new( FALSE, 0);
/********************************************* Close Button ***********************/
closeButton = gtk_button_new_from_stock( "gtk-close" );
/* This packs the button into the hbutton box (a gtk container). */
gtk_box_pack_end( GTK_BOX(buttonBox), closeButton, FALSE, TRUE, 3);
/* When the button receives the "clicked" signal, it will call the
* function applyChanges() passing it NULL as its argument. */
/* TODO can't get this signal to work and close things! */
g_signal_connect (G_OBJECT (closeButton), "released", G_CALLBACK (closeSignalHandler), NULL);
/**************************** End of buttons **************************************/
/* This packs the hbutton box into the vbox (a gtk container). */
gtk_box_pack_start(GTK_BOX(vbox), buttonBox, FALSE, TRUE, 3);
/**************************** Status Bar ******************************************/
/* create the status bar */
statusBar = gtk_statusbar_new();
/* This packs the status bar into the vbox (a gtk container) */
gtk_box_pack_start(GTK_BOX(vbox), statusBar, FALSE, TRUE, 0);
return ( dialog );
}
static void
cv_tree_init (chanview *cv)
{
GtkWidget *view, *win;
GtkCellRenderer *renderer;
static const GtkTargetEntry dnd_src_target[] =
{
{"XCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 }
};
static const GtkTargetEntry dnd_dest_target[] =
{
{"XCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 }
};
win = gtk_scrolled_window_new (0, 0);
/*gtk_container_set_border_width (GTK_CONTAINER (win), 1);*/
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (win),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (cv->box), win);
gtk_widget_show (win);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (cv->store));
gtk_widget_set_name (view, "xchat-tree");
if (cv->style)
gtk_widget_set_style (view, cv->style);
/*gtk_widget_modify_base (view, GTK_STATE_NORMAL, &colors[COL_BG]);*/
GTK_WIDGET_UNSET_FLAGS (view, GTK_CAN_FOCUS);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
#if GTK_CHECK_VERSION(2,10,0)
if (!(prefs.gui_tweaks & 8))
gtk_tree_view_set_enable_tree_lines (GTK_TREE_VIEW (view), TRUE);
#endif
gtk_container_add (GTK_CONTAINER (win), view);
/* icon column */
if (cv->use_icons)
{
renderer = gtk_cell_renderer_pixbuf_new ();
if (prefs.gui_tweaks & 32)
g_object_set (G_OBJECT (renderer), "ypad", 0, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),
-1, NULL, renderer,
"pixbuf", COL_PIXBUF, NULL);
}
/* main column */
renderer = gtk_cell_renderer_text_new ();
if (prefs.gui_tweaks & 32)
g_object_set (G_OBJECT (renderer), "ypad", 0, NULL);
gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),
-1, NULL, renderer,
"text", COL_NAME, "attributes", COL_ATTR, NULL);
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (view))),
"changed", G_CALLBACK (cv_tree_sel_cb), cv);
g_signal_connect (G_OBJECT (view), "button-press-event",
G_CALLBACK (cv_tree_click_cb), cv);
g_signal_connect (G_OBJECT (view), "row-activated",
G_CALLBACK (cv_tree_activated_cb), NULL);
gtk_drag_dest_set (view, GTK_DEST_DEFAULT_ALL, dnd_dest_target, 1,
GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK);
gtk_drag_source_set (view, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_COPY);
#ifndef WIN32
g_signal_connect (G_OBJECT (view), "drag_begin",
G_CALLBACK (mg_drag_begin_cb), NULL);
g_signal_connect (G_OBJECT (view), "drag_drop",
G_CALLBACK (mg_drag_drop_cb), NULL);
g_signal_connect (G_OBJECT (view), "drag_motion",
G_CALLBACK (mg_drag_motion_cb), NULL);
g_signal_connect (G_OBJECT (view), "drag_end",
G_CALLBACK (mg_drag_end_cb), NULL);
#endif
((treeview *)cv)->tree = GTK_TREE_VIEW (view);
((treeview *)cv)->scrollw = win;
gtk_widget_show (view);
}
static void
rejilla_split_dialog_init (RejillaSplitDialog *object)
{
gchar *title;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *vbox2;
GtkWidget *hbox2;
GtkWidget *label;
GtkWidget *scroll;
GtkWidget *button;
GtkTreeModel *model;
GtkSizeGroup *size_group;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
RejillaSplitDialogPrivate *priv;
priv = REJILLA_SPLIT_DIALOG_PRIVATE (object);
gtk_window_set_title (GTK_WINDOW (object), _("Split Track"));
gtk_window_set_default_size (GTK_WINDOW (object), 500, 600);
gtk_dialog_add_button (GTK_DIALOG (object), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (object), GTK_STOCK_OK, GTK_RESPONSE_OK);
vbox = gtk_dialog_get_content_area (GTK_DIALOG (object));
gtk_box_set_spacing (GTK_BOX (vbox), 0);
size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
/* Slicing method */
hbox = gtk_hbox_new (FALSE, 6);
gtk_widget_show (hbox);
priv->combo = gtk_combo_box_new_text ();
label = gtk_label_new_with_mnemonic (_("M_ethod:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->combo);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text (priv->combo, _("Method to be used to split the track"));
gtk_widget_show (priv->combo);
gtk_box_pack_start (GTK_BOX (hbox), priv->combo, TRUE, TRUE, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), _("Split track manually"));
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), _("Split track in parts with a fixed length"));
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), _("Split track in a fixed number of parts"));
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), _("Split track for each silence"));
g_signal_connect (priv->combo,
"changed",
G_CALLBACK (rejilla_split_dialog_combo_changed_cb),
object);
button = rejilla_utils_make_button (_("_Slice"),
NULL,
"transform-crop-and-resize",
GTK_ICON_SIZE_BUTTON);
gtk_widget_show (button);
gtk_size_group_add_widget (size_group, button);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_signal_connect (button,
"clicked",
G_CALLBACK (rejilla_split_dialog_cut_clicked_cb),
object);
gtk_widget_set_tooltip_text (button, _("Add a splitting point"));
priv->cut = button;
priv->notebook = gtk_notebook_new ();
gtk_widget_show (priv->notebook);
gtk_notebook_set_show_border (GTK_NOTEBOOK (priv->notebook), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (priv->notebook), FALSE);
priv->player = rejilla_song_control_new ();
gtk_widget_show (priv->player);
gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), priv->player, NULL);
hbox2 = gtk_hbox_new (FALSE, 6);
gtk_widget_show (hbox2);
gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), hbox2, NULL);
/* Translators: this goes with the next (= "seconds") */
label = gtk_label_new (_("Split this track every"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
priv->spin_sec = gtk_spin_button_new_with_range (1.0, 1000.0, 1.0);
gtk_widget_show (priv->spin_sec);
gtk_box_pack_start (GTK_BOX (hbox2), priv->spin_sec, FALSE, FALSE, 0);
/* Translators: this goes with the previous (= "Split track every") */
label = gtk_label_new (_("seconds"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
hbox2 = gtk_hbox_new (FALSE, 6);
gtk_widget_show (hbox2);
gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), hbox2, NULL);
/* Translators: this goes with the next (= "parts") */
label = gtk_label_new (_("Split this track in"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
priv->spin_parts = gtk_spin_button_new_with_range (2.0, 1000.0, 1.0);
gtk_widget_show (priv->spin_parts);
gtk_box_pack_start (GTK_BOX (hbox2), priv->spin_parts, FALSE, FALSE, 0);
/* Translators: this goes with the previous (= "Split this track in") */
label = gtk_label_new (_("parts"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
priv->silence_label = gtk_label_new (NULL);
gtk_widget_show (priv->silence_label);
gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), priv->silence_label, NULL);
title = g_strdup_printf ("<b>%s</b>", _("Slicing Method"));
gtk_box_pack_start (GTK_BOX (vbox),
rejilla_utils_pack_properties (title,
priv->notebook,
hbox,
NULL),
FALSE,
FALSE,
0);
g_free (title);
/* slices preview */
hbox = gtk_hbox_new (FALSE, 6);
gtk_widget_show (hbox);
priv->model = gtk_list_store_new (COLUMN_NUM,
G_TYPE_INT64,
G_TYPE_INT64,
G_TYPE_INT64,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
g_signal_connect (priv->model,
"row-inserted",
G_CALLBACK (rejilla_split_dialog_row_inserted_cb),
object);
g_signal_connect (priv->model,
"row-deleted",
G_CALLBACK (rejilla_split_dialog_row_deleted_cb),
object);
model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (priv->model));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
START_COL,
GTK_SORT_ASCENDING);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (scroll);
gtk_box_pack_start (GTK_BOX (hbox), scroll, TRUE, TRUE, 0);
priv->tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_view_set_enable_tree_lines (GTK_TREE_VIEW (priv->tree), TRUE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->tree), TRUE);
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (priv->tree), TRUE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree)),
GTK_SELECTION_MULTIPLE);
gtk_widget_show (priv->tree);
gtk_container_add (GTK_CONTAINER (scroll), priv->tree);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Start"),
renderer,
"text", START_STR_COL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("End"),
renderer,
"text", END_STR_COL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Length"),
renderer,
"text", LENGTH_STR_COL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree), column);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree)),
"changed",
G_CALLBACK (rejilla_split_dialog_selection_changed_cb),
object);
/* buttons */
vbox2 = gtk_vbox_new (FALSE, 6);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, TRUE, 0);
button = rejilla_utils_make_button (_("Mer_ge"),
NULL,
NULL,
GTK_ICON_SIZE_BUTTON);
gtk_widget_show (button);
gtk_size_group_add_widget (size_group, button);
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
g_signal_connect (button,
"clicked",
G_CALLBACK (rejilla_split_dialog_merge_clicked_cb),
object);
gtk_widget_set_tooltip_text (button, _("Merge a selected slice with the next selected one"));
priv->merge_button = button;
button = rejilla_utils_make_button (_("_Remove"),
GTK_STOCK_REMOVE,
NULL,
GTK_ICON_SIZE_BUTTON);
gtk_widget_show (button);
gtk_size_group_add_widget (size_group, button);
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
g_signal_connect (button,
"clicked",
G_CALLBACK (rejilla_split_dialog_remove_clicked_cb),
object);
gtk_widget_set_tooltip_text (button, _("Remove the selected slices"));
priv->remove_button = button;
button = rejilla_utils_make_button (_("Re_move All"),
NULL,
NULL,
GTK_ICON_SIZE_BUTTON);
gtk_widget_show (button);
gtk_size_group_add_widget (size_group, button);
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
g_signal_connect (button,
"clicked",
G_CALLBACK (rejilla_split_dialog_reset_clicked_cb),
object);
gtk_widget_set_tooltip_text (button, _("Clear the slices preview"));
priv->reset_button = button;
gtk_widget_set_sensitive (priv->reset_button, FALSE);
gtk_widget_set_sensitive (priv->merge_button, FALSE);
gtk_widget_set_sensitive (priv->remove_button, FALSE);
vbox2 = gtk_vbox_new (FALSE, 6);
gtk_widget_show (vbox2);
label = gtk_label_new_with_mnemonic (_("_List of slices that are to be created:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->tree);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, TRUE, TRUE, 0);
title = g_strdup_printf ("<b>%s</b>", _("Slices Preview"));
gtk_box_pack_start (GTK_BOX (vbox),
rejilla_utils_pack_properties (title,
vbox2,
NULL),
TRUE,
TRUE,
0);
g_free (title);
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->combo), 0);
g_object_unref (size_group);
}
/* Create the window for selecting folders with checkboxes */
static void foldercheck_create_window(SpecificFolderArrayEntry *entry)
{
GtkWidget *vbox;
GtkWidget *scrolledwin;
GtkWidget *confirm_area;
GtkWidget *checkbox;
GtkWidget *cancel_button;
GtkWidget *ok_button;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
static GdkGeometry geometry;
/* Create window */
entry->window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "notification_foldercheck");
gtk_window_set_title(GTK_WINDOW(entry->window), _("Select folder(s)"));
gtk_container_set_border_width(GTK_CONTAINER(entry->window), 4);
gtk_window_set_position(GTK_WINDOW(entry->window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(entry->window), TRUE);
gtk_window_set_resizable(GTK_WINDOW(entry->window), TRUE);
gtk_window_set_wmclass
(GTK_WINDOW(entry->window), "folder_selection", "Claws Mail");
g_signal_connect(G_OBJECT(entry->window), "delete_event",
G_CALLBACK(delete_event), entry);
g_signal_connect(G_OBJECT(entry->window), "key_press_event",
G_CALLBACK(key_pressed), entry);
MANAGE_WINDOW_SIGNALS_CONNECT(entry->window);
/* vbox */
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(entry->window), vbox);
/* scrolled window */
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);
/* pixbufs */
if(!folder_pixbuf)
stock_pixbuf_gdk(STOCK_PIXMAP_DIR_CLOSE,
&folder_pixbuf);
if(!folderopen_pixbuf)
stock_pixbuf_gdk(STOCK_PIXMAP_DIR_OPEN,
&folderopen_pixbuf);
if(!foldernoselect_pixbuf)
stock_pixbuf_gdk(STOCK_PIXMAP_DIR_NOSELECT_CLOSE,
&foldernoselect_pixbuf);
if(!foldernoselectopen_pixbuf)
stock_pixbuf_gdk(STOCK_PIXMAP_DIR_NOSELECT_OPEN,
&foldernoselectopen_pixbuf);
/* Tree store */
foldercheck_set_tree(entry);
gtk_tree_model_foreach(GTK_TREE_MODEL(entry->tree_store),
foldercheck_foreach_update_to_list, entry);
/* tree view */
entry->treeview =
gtk_tree_view_new_with_model(GTK_TREE_MODEL(entry->tree_store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(entry->treeview), FALSE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(entry->treeview),
FOLDERCHECK_FOLDERNAME);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(entry->treeview),
prefs_common_get_prefs()->use_stripes_everywhere);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(entry->treeview), FALSE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(entry->treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selection, foldercheck_selected,
NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolledwin), entry->treeview);
/* --- column 1 --- */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "sel");
gtk_tree_view_column_set_spacing(column, 2);
/* checkbox */
renderer = gtk_cell_renderer_toggle_new();
g_object_set(renderer, "xalign", 0.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
g_signal_connect(renderer, "toggled", G_CALLBACK(folder_toggle_cb),entry);
gtk_tree_view_column_set_attributes(column, renderer,
"active", FOLDERCHECK_CHECK,NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(entry->treeview), column);
/* --- column 2 --- */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Folder");
gtk_tree_view_column_set_spacing(column, 2);
/* pixbuf */
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes
(column, renderer,
"pixbuf", FOLDERCHECK_PIXBUF,
"pixbuf-expander-open", FOLDERCHECK_PIXBUF_OPEN,
"pixbuf-expander-closed", FOLDERCHECK_PIXBUF,
NULL);
/* text */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", FOLDERCHECK_FOLDERNAME,
NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(entry->treeview), column);
/* recursive */
checkbox = gtk_check_button_new_with_label( _("select recursively"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), FALSE);
g_signal_connect(G_OBJECT(checkbox), "toggled",
G_CALLBACK(foldercheck_recursive_cb), entry);
gtk_box_pack_start(GTK_BOX(vbox), checkbox, FALSE, FALSE, 10);
gtkut_stock_button_set_create(&confirm_area,
&cancel_button, GTK_STOCK_CANCEL,
&ok_button, GTK_STOCK_OK,
NULL, NULL);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(foldercheck_ok), entry);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(foldercheck_cancel), entry);
if(!geometry.min_height) {
geometry.min_width = 360;
geometry.min_height = 360;
}
gtk_window_set_geometry_hints(GTK_WINDOW(entry->window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_tree_view_expand_all(GTK_TREE_VIEW(entry->treeview));
gtk_widget_show_all(vbox);
}
static void foldersel_create(void)
{
GtkWidget *vbox;
GtkWidget *scrolledwin;
GtkWidget *confirm_area;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
static GdkGeometry geometry;
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "foldersel");
gtk_window_set_title(GTK_WINDOW(window), _("Select folder"));
gtk_container_set_border_width(GTK_CONTAINER(window), 4);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
gtk_widget_realize(window);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(delete_event), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(key_pressed), NULL);
g_signal_connect(G_OBJECT(window), "size_allocate",
G_CALLBACK(foldersel_size_allocate_cb), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(window), vbox);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);
tree_store = gtk_tree_store_new(N_FOLDERSEL_COLUMNS,
G_TYPE_STRING,
G_TYPE_POINTER,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_COLOR,
G_TYPE_INT);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(tree_store),
FOLDERSEL_FOLDERNAME,
foldersel_folder_name_compare,
NULL, NULL);
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_store));
g_object_unref(G_OBJECT(tree_store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview),
prefs_common.use_stripes_everywhere);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview),
FOLDERSEL_FOLDERNAME);
if (prefs_common.folder_search_wildcard)
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeview),
foldersel_search_name_func, NULL, NULL);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selection, foldersel_selected,
NULL, NULL);
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(foldersel_tree_activated), NULL);
gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_spacing(column, 2);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes
(column, renderer,
"pixbuf", FOLDERSEL_PIXBUF,
"pixbuf-expander-open", FOLDERSEL_PIXBUF_OPEN,
"pixbuf-expander-closed", FOLDERSEL_PIXBUF,
NULL);
/* create text renderer */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes
(column, renderer,
"text", FOLDERSEL_FOLDERNAME,
"foreground-gdk", FOLDERSEL_FOREGROUND,
"weight", FOLDERSEL_BOLD,
NULL);
g_object_set(G_OBJECT(renderer), "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
entry = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(entry), "activate",
G_CALLBACK(foldersel_entry_activated), NULL);
gtkut_stock_button_set_create(&confirm_area,
&new_button, GTK_STOCK_NEW,
&cancel_button, GTK_STOCK_CANCEL,
&ok_button, GTK_STOCK_OK);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(foldersel_ok), NULL);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(foldersel_cancel), NULL);
g_signal_connect(G_OBJECT(new_button), "clicked",
G_CALLBACK(foldersel_new_folder), NULL);
if (!geometry.min_height) {
geometry.min_width = 300;
geometry.min_height = 360;
}
gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_widget_set_size_request(window, prefs_common.folderselwin_width,
prefs_common.folderselwin_height);
gtk_widget_show_all(vbox);
}
void
update_user_entry(GList *top,GtkWidget *view,gboolean is_forced) {
GtkTreeIter toplevel;
GtkListStore *liststore = NULL;
GtkWidget *usersEntry = NULL;
GtkTreeViewColumn *col = NULL;
userdb_t *current_user = NULL;
int i = 0;
int users_count = 0;
int prio = 0;
guint state = 0;
int id = 0;
gchar *nick_name_ref = NULL;
gchar num_str[32];
if ( (!top) || (!view) )
return;
state=hostinfo_refer_header_state();
release_user_entry(GTK_TREE_VIEW(view));
liststore = gtk_list_store_new(MAX_VIEW_ID,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
for(i=0;(current_user=g_list_nth_data(top,i));++i) {
g_assert(current_user);
nick_name_ref = current_user->nickname;
if ( (current_user->nickname == NULL) || ( current_user->nickname[0] == '\0' ) ) {
if ( (current_user->user != NULL) && (current_user->user[0] != '\0') )
nick_name_ref = current_user->user;
else
nick_name_ref = _("Unknown");
}
dbg_out("Update\n");
dbg_out("NickName: %s\n", current_user->nickname);
dbg_out("Group: %s\n",current_user->group);
dbg_out("User: %s\n",current_user->user);
dbg_out("Host: %s\n",current_user->host);
dbg_out("IP Addr: %s\n",current_user->ipaddr);
dbg_out("Priority: %d\n",current_user->prio);
prio=current_user->prio;
memset(num_str,0,32);
if (prio>0)
snprintf(num_str,31,"%d",prio);
else
snprintf(num_str,31,"-");
num_str[31]='\0';
if ( (prio>=0) || (is_forced) ){
/* Append a top level row and leave it empty */
gtk_list_store_append(liststore, &toplevel);
gtk_list_store_set(liststore, &toplevel,
USER_VIEW_NICKNAME_ID, nick_name_ref,
USER_VIEW_GROUP_ID,current_user->group,
USER_VIEW_HOST_ID,current_user->host,
USER_VIEW_IPADDR_ID,current_user->ipaddr,
USER_VIEW_LOGON_ID,current_user->user,
USER_VIEW_PRIO_ID,num_str,
-1);
}
++users_count;
fflush(stdout);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(liststore));
g_object_unref(liststore); /* destroy model automatically with view */
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
GTK_SELECTION_MULTIPLE );
/*
* ユーザ数更新
*/
usersEntry=lookup_widget(GTK_WIDGET(view),"messageWinUsersEntry");
g_assert(usersEntry);
snprintf(num_str,31,"%d",users_count);
gtk_entry_set_text(GTK_ENTRY(usersEntry), num_str);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW(view),TRUE);
if (GTK_WIDGET_REALIZED(view)) {
#if GTK_CHECK_VERSION(2,10,6)
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(view),TRUE);
if (state & HEADER_VISUAL_GRID_ID)
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(view),GTK_TREE_VIEW_GRID_LINES_BOTH);
#endif
}
#endif
return;
}
/*
* create variables tree view widget
* arguments:
* on_render_name - custom name column renderer function
* on_expression_changed - callback to call on expression changed
*/
GtkWidget* vtree_create(watch_render_name on_render_name, watch_expression_changed on_expression_changed)
{
/* create tree view */
GtkCellRenderer *renderer;
GtkCellRenderer *icon_renderer;
GtkTreeViewColumn *column;
GtkTreeStore* store = gtk_tree_store_new (
W_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
GtkWidget* tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
g_object_unref(store);
/* set tree view parameters */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_level_indentation(GTK_TREE_VIEW(tree), 10);
/* connect signals */
if (NULL != on_key_pressed)
{
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_key_pressed), NULL);
}
/* create columns */
/* Name */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_end(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer, "text", W_NAME, NULL);
icon_renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set(icon_renderer, "follow-state", TRUE, NULL);
gtk_tree_view_column_pack_end(column, icon_renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, icon_renderer, render_icon, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
if (on_render_name)
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_name, NULL, NULL);
if (on_expression_changed)
{
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (on_expression_changed), NULL);
}
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Value */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Value"), renderer, "text", W_VALUE, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, render_value, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Type */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Type"), renderer, "text", W_TYPE, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Last invisible column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", W_LAST_VISIBLE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Internal (unvisible column) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Internal", renderer, "text", W_INTERNAL, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Path expression (unvisible column) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Expression", renderer, "text", W_EXPRESSION, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* STUB (unvisible column) */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Need Update", renderer, "active", W_STUB, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_visible(column, FALSE);
/* Changed (unvisible column) */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Changed", renderer, "active", W_CHANGED, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_visible(column, FALSE);
return tree;
}
extern "C" int addToGui(gpointer data)
{
plugData* plugdata=(plugData*)data;
GtkTreeViewColumn* column;
GtkTreeModel* model=NULL;
GtkCellRenderer* renderer;
GtkTreeIter iter;
GtkWidget* menu;
setTextDomain(true,plugdata);
menu=gtk_menu_item_get_submenu((GtkMenuItem*)plugdata->mlist.menuView);
hideMenu=gtk_menu_item_new_with_label(gettext("Hide Browser"));
g_signal_connect(G_OBJECT(hideMenu),"activate",G_CALLBACK(toggleBrowser),plugdata);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),hideMenu);
gtk_widget_show_all(plugdata->mlist.menuView);
store=gtk_tree_store_new(NUM_COLUMNS,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING);
addFolderContents("/",&iter,true);
model=GTK_TREE_MODEL(store);
treeview=gtk_tree_view_new_with_model(model);
gtk_tree_view_set_enable_tree_lines((GtkTreeView*)treeview,true);
scrollbox=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrollbox,GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrollbox),(GtkWidget*)treeview);
gtk_box_pack_start((GtkBox*)plugdata->leftUserBox,scrollbox,true,true,0);
gtk_widget_show_all(plugdata->leftUserBox);
gtk_widget_set_size_request((GtkWidget*)scrollbox,100,-1);
//pixbuf
renderer=gtk_cell_renderer_pixbuf_new();
column=gtk_tree_view_column_new_with_attributes("path",renderer,"pixbuf",COLUMN_PIXBUF,NULL);
gtk_tree_view_column_set_resizable(column,false);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column((GtkTreeView*)treeview,column);
gtk_tree_view_column_set_spacing(column,0);
gtk_tree_view_column_set_expand(column,false);
//colom file
renderer=gtk_cell_renderer_text_new();
column=gtk_tree_view_column_new_with_attributes(NULL,renderer,"text",COLUMN_FILENAME,NULL);
gtk_tree_view_column_set_resizable(column,true);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column((GtkTreeView*)treeview,column);
gtk_tree_view_column_set_expand(column,true);
gtk_tree_view_column_set_spacing(column,0);
gtk_tree_view_set_headers_visible((GtkTreeView*)treeview,false);
g_signal_connect(treeview,"row-expanded",G_CALLBACK(expandRow),column);
g_signal_connect(treeview,"row-collapsed",G_CALLBACK(collapseRow),column);
g_signal_connect(treeview,"row-activated",G_CALLBACK(onRowActivated),NULL);
leftBox=(GtkWidget*)plugdata->leftUserBox;
doStartUpCheck(plugdata);
showHideBrowser(plugdata,true);
if(showing==true)
showSide(true);
else
hideSide(true);
setTextDomain(false,plugdata);
return(0);
}
static GtkWidget *
make_results_view (XpathExplorer * ttt)
{
g_return_val_if_fail(ttt != NULL, NULL);
GtkTreeViewColumn *col;
GtkCellRenderer *renderer, *icon_renderer;
GtkWidget *view;
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(make_results_blank()));
//view = gtk_tree_view_new();
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(view), TRUE);
g_signal_connect(view, "button-press-event",
G_CALLBACK(xpath_explorer_button_press_event), ttt);
/*
g_signal_connect(view, "popup-menu",
G_CALLBACK(xpath_view_onPopupMenu), ttt);*/
g_signal_connect(view, "row-activated",
G_CALLBACK(xpath_explorer_row_activated), ttt);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (col, _("Name"));
gtk_tree_view_column_set_resizable(col, TRUE);
icon_renderer = xml_cell_renderer_new();
gtk_tree_view_column_pack_start(col, icon_renderer, FALSE);
gtk_tree_view_column_set_attributes(col, icon_renderer,
"node-id", XML_TREE_MODEL_COL_TYPE,
NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_add_attribute (col, renderer, "text", XML_TREE_MODEL_COL_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_add_attribute (col, renderer, "text", XML_TREE_MODEL_COL_XPATH);
gtk_tree_view_column_set_title (col, _("XPath"));
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_add_attribute (col, renderer, "text", XML_TREE_MODEL_COL_LINE);
gtk_tree_view_column_set_title (col, _("Line"));
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer,"ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_object_set(renderer,"single-paragraph-mode", TRUE, NULL);
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_add_attribute (col, renderer, "text", XML_TREE_MODEL_COL_CONTENT);
gtk_tree_view_column_set_title (col, _("Value"));
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
return view;
}
static void
cv_tree_init (chanview *cv)
{
GtkWidget *view, *win;
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
int wid1, wid2;
static const GtkTargetEntry dnd_src_target[] =
{
{"XCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 }
};
static const GtkTargetEntry dnd_dest_target[] =
{
{"XCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 }
};
win = gtk_scrolled_window_new (0, 0);
/*gtk_container_set_border_width (GTK_CONTAINER (win), 1);*/
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (win),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (cv->box), win);
gtk_widget_show (win);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (cv->store));
gtk_widget_set_name (view, "xchat-tree");
if (cv->style)
gtk_widget_set_style (view, cv->style);
/*gtk_widget_modify_base (view, GTK_STATE_NORMAL, &colors[COL_BG]);*/
gtk_widget_set_can_focus (view, FALSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
if (prefs.pchat_gui_tab_dots)
{
gtk_tree_view_set_enable_tree_lines (GTK_TREE_VIEW (view), TRUE);
}
/* Indented channels with no server looks silly, but we still want expanders */
if (!prefs.pchat_gui_tab_server)
{
gtk_widget_style_get (view, "expander-size", &wid1, "horizontal-separator", &wid2, NULL);
gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (view), -wid1 - wid2);
}
gtk_container_add (GTK_CONTAINER (win), view);
col = gtk_tree_view_column_new();
/* icon column */
if (cv->use_icons)
{
renderer = gtk_cell_renderer_pixbuf_new ();
if (prefs.pchat_gui_compact)
g_object_set (G_OBJECT (renderer), "ypad", 0, NULL);
gtk_tree_view_column_pack_start(col, renderer, FALSE);
gtk_tree_view_column_set_attributes (col, renderer, "pixbuf", COL_PIXBUF, NULL);
}
/* main column */
renderer = gtk_cell_renderer_text_new ();
if (prefs.pchat_gui_compact)
g_object_set (G_OBJECT (renderer), "ypad", 0, NULL);
gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1);
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_set_attributes (col, renderer, "text", COL_NAME, "attributes", COL_ATTR, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (view))),
"changed", G_CALLBACK (cv_tree_sel_cb), cv);
g_signal_connect (G_OBJECT (view), "button-press-event",
G_CALLBACK (cv_tree_click_cb), cv);
g_signal_connect (G_OBJECT (view), "row-activated",
G_CALLBACK (cv_tree_activated_cb), NULL);
g_signal_connect (G_OBJECT (view), "scroll_event",
G_CALLBACK (cv_tree_scroll_event_cb), NULL);
gtk_drag_dest_set (view, GTK_DEST_DEFAULT_ALL, dnd_dest_target, 1,
GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK);
gtk_drag_source_set (view, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_COPY);
g_signal_connect (G_OBJECT (view), "drag_begin",
G_CALLBACK (mg_drag_begin_cb), NULL);
g_signal_connect (G_OBJECT (view), "drag_drop",
G_CALLBACK (mg_drag_drop_cb), NULL);
g_signal_connect (G_OBJECT (view), "drag_motion",
G_CALLBACK (mg_drag_motion_cb), NULL);
g_signal_connect (G_OBJECT (view), "drag_end",
G_CALLBACK (mg_drag_end_cb), NULL);
((treeview *)cv)->tree = GTK_TREE_VIEW (view);
((treeview *)cv)->scrollw = win;
gtk_widget_show (view);
}
