static GtkWidget *
create_treeview (int n_columns)
{
GtkWidget *treeview;
GtkListStore *store;
GtkTreeIter iter;
GtkTreeSelection *selection;
int i;
store = gtk_list_store_new (1, G_TYPE_STRING);
for (i = 0; i < 10; i++)
{
char buf[128];
g_snprintf (buf, sizeof(buf), "Row %d", i+1);
gtk_list_store_insert_with_values (store, &iter, -1, 0, buf, -1);
}
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
g_object_unref (store);
while (n_columns-- > 0)
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "",
gtk_cell_renderer_text_new (),
"text", 0,
NULL);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (treeview), TRUE);
#endif
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
return treeview;
}
static GtkWidget *
create_tree_view(int n, n_list_store *list, int tree)
{
GType *tarray;
GtkTreeModel *lstore;
GtkWidget *tview;
GtkTreeViewColumn *col;
GtkTreeSelection *sel;
int i;
if (n < 1 || list == NULL)
return NULL;
tarray = g_malloc(sizeof(*tarray) * n);
if (tarray == NULL)
return NULL;
for (i = 0; i < n; i++) {
if (list[i].type == G_TYPE_DOUBLE || list[i].type == G_TYPE_ENUM || list[i].type == G_TYPE_PARAM) {
tarray[i] = G_TYPE_STRING;
} else {
tarray[i] = list[i].type;
}
list[i].edited_id = 0;
}
if (tree) {
lstore = GTK_TREE_MODEL(gtk_tree_store_newv(n, tarray));
} else {
lstore = GTK_TREE_MODEL(gtk_list_store_newv(n, tarray));
}
g_free(tarray);
tview = gtk_tree_view_new_with_model(lstore);
#if ! GTK_CHECK_VERSION(3, 14, 0)
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tview), TRUE);
#endif
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tview), TRUE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tview), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tview));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
for (i = 0; i < n; i++) {
if (list[i].visible) {
col = create_column(list, i);
gtk_tree_view_column_set_visible(col, list[i].visible);
gtk_tree_view_append_column(GTK_TREE_VIEW(tview), col);
}
}
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), n > 1);
return tview;
}
static void trg_tree_view_init(TrgTreeView * tv)
{
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tv), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(tv), TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tv), TRUE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection
(GTK_TREE_VIEW(tv)),
GTK_SELECTION_MULTIPLE);
gtk_widget_set_sensitive(GTK_WIDGET(tv), FALSE);
}
static inline void create_list_view(FmFolderView* fv, GList* sels)
{
GtkTreeViewColumn* col;
GtkTreeSelection* ts;
GList *l;
GtkCellRenderer* render;
FmFolderModel* model = (FmFolderModel*)fv->model;
int icon_size = 0;
fv->view = exo_tree_view_new();
render = fm_cell_renderer_pixbuf_new();
fv->renderer_pixbuf = render;
// fv->icon_size_changed_handler = g_signal_connect(fm_config, "changed::small_icon_size", G_CALLBACK(on_small_icon_size_changed), fv);
icon_size = fm_config->small_icon_size;
fm_cell_renderer_pixbuf_set_fixed_size(FM_CELL_RENDERER_PIXBUF(fv->renderer_pixbuf), icon_size, icon_size);
if(model)
fm_folder_model_set_icon_size(model, icon_size);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(fv->view), TRUE);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Name"));
gtk_tree_view_column_pack_start(col, render, FALSE);
gtk_tree_view_column_set_attributes(col, render,
"pixbuf", COL_FILE_ICON,
"info", COL_FILE_INFO, NULL);
render = gtk_cell_renderer_text_new();
g_object_set(render, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start(col, render, TRUE);
gtk_tree_view_column_set_attributes(col, render, "text", COL_FILE_NAME, NULL);
gtk_tree_view_column_set_sort_column_id(col, COL_FILE_NAME);
gtk_tree_view_column_set_expand(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width(col, 200);
gtk_tree_view_append_column((GtkTreeView*)fv->view, col);
/* only this column is activable */
exo_tree_view_set_activable_column((ExoTreeView*)fv->view, col);
render = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(_("Description"), render, "text", COL_FILE_DESC, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, COL_FILE_DESC);
gtk_tree_view_append_column((GtkTreeView*)fv->view, col);
render = gtk_cell_renderer_text_new();
g_object_set(render, "xalign", 1.0, NULL);
col = gtk_tree_view_column_new_with_attributes(_("Size"), render, "text", COL_FILE_SIZE, NULL);
gtk_tree_view_column_set_sort_column_id(col, COL_FILE_SIZE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_append_column((GtkTreeView*)fv->view, col);
render = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(_("Modified"), render, "text", COL_FILE_MTIME, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, COL_FILE_MTIME);
gtk_tree_view_append_column((GtkTreeView*)fv->view, col);
gtk_tree_view_set_search_column((GtkTreeView*)fv->view, COL_FILE_NAME);
gtk_tree_view_set_rubber_banding((GtkTreeView*)fv->view, TRUE);
exo_tree_view_set_single_click((ExoTreeView*)fv->view, fm_config->single_click);
exo_tree_view_set_single_click_timeout((ExoTreeView*)fv->view, SINGLE_CLICK_TIMEOUT);
ts = gtk_tree_view_get_selection((GtkTreeView*)fv->view);
g_signal_connect(fv->view, "row-activated", G_CALLBACK(on_tree_view_row_activated), fv);
g_signal_connect(ts, "changed", G_CALLBACK(on_sel_changed), fv);
/*cancel_pending_row_activated(fv);*/ /* FIXME: is this needed? */
gtk_tree_view_set_model((GtkTreeView*)fv->view, fv->model);
gtk_tree_selection_set_mode(ts, fv->sel_mode);
for(l = sels;l;l=l->next)
gtk_tree_selection_select_path(ts, (GtkTreePath*)l->data);
}
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);
}
static int gtkListMapMethod(Ihandle* ih)
{
GtkScrolledWindow* scrolled_window = NULL;
GtkListStore *store;
store = gtk_list_store_new(1, G_TYPE_STRING);
if (ih->data->is_dropdown)
{
GtkCellRenderer *renderer = NULL;
if (ih->data->has_editbox)
ih->handle = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(store), 0);
else
ih->handle = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
if (!ih->handle)
return IUP_ERROR;
g_object_set(G_OBJECT(ih->handle), "has-frame", TRUE, NULL);
if (ih->data->has_editbox)
{
GtkWidget *entry;
#if GTK_CHECK_VERSION(2, 12, 0)
GList* list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(ih->handle));
renderer = list->data;
g_list_free(list);
#endif
entry = gtk_bin_get_child(GTK_BIN(ih->handle));
iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry);
g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih);
g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih);
g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */
g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih);
g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */
g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
}
else
{
/* had to add an event box just to get get/killfocus,enter/leave events */
GtkWidget *box = gtk_event_box_new();
gtk_container_add((GtkContainer*)box, ih->handle);
iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)box);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ih->handle), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ih->handle), renderer, "text", 0, NULL);
g_signal_connect(G_OBJECT(box), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(box), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(box), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(box), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
else
GTK_WIDGET_FLAGS(box) |= GTK_CAN_FOCUS;
}
g_signal_connect(ih->handle, "changed", G_CALLBACK(gtkListComboBoxChanged), ih);
g_signal_connect(ih->handle, "notify::popup-shown", G_CALLBACK(gtkListComboBoxPopupShownChanged), ih);
if (renderer)
{
renderer->xpad = 0;
renderer->ypad = 0;
iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer);
}
}
else
{
GtkCellRenderer *renderer;
GtkTreeSelection* selection;
GtkTreeViewColumn *column;
GtkPolicyType scrollbar_policy;
ih->handle = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
if (!ih->handle)
return IUP_ERROR;
scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new(NULL, NULL);
if (ih->data->has_editbox)
{
GtkBox* vbox = (GtkBox*)gtk_vbox_new(FALSE, 0);
GtkWidget *entry = gtk_entry_new();
gtk_widget_show(entry);
gtk_box_pack_start(vbox, entry, FALSE, FALSE, 0);
iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry);
gtk_widget_show((GtkWidget*)vbox);
gtk_box_pack_end(vbox, (GtkWidget*)scrolled_window, TRUE, TRUE, 0);
iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)vbox);
iupAttribSetStr(ih, "_IUPGTK_SCROLLED_WINDOW", (char*)scrolled_window);
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; /* focus goes only to the edit box */
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(entry) &= ~GTK_CAN_FOCUS;
g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih);
g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih);
g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */
g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(gtkListEditKeyPressEvent), ih);
g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih);
g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */
g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih);
}
else
{
iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)scrolled_window);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkListSimpleKeyPressEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
}
column = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(column), renderer, "text", 0, NULL);
iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer);
g_object_set(G_OBJECT(renderer), "xpad", 0, NULL);
g_object_set(G_OBJECT(renderer), "ypad", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(ih->handle), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(ih->handle), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ih->handle), FALSE);
gtk_container_add((GtkContainer*)scrolled_window, ih->handle);
gtk_widget_show((GtkWidget*)scrolled_window);
gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_IN);
if (ih->data->sb)
{
if (iupStrBoolean(iupAttribGetStr(ih, "AUTOHIDE")))
scrollbar_policy = GTK_POLICY_AUTOMATIC;
else
scrollbar_policy = GTK_POLICY_ALWAYS;
}
else
scrollbar_policy = GTK_POLICY_NEVER;
gtk_scrolled_window_set_policy(scrolled_window, scrollbar_policy, scrollbar_policy);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle));
if (!ih->data->has_editbox && ih->data->is_multiple)
{
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(ih->handle), TRUE);
#endif
}
else
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(gtkListSelectionChanged), ih);
g_signal_connect(G_OBJECT(ih->handle), "row-activated", G_CALLBACK(gtkListRowActivated), ih);
g_signal_connect(G_OBJECT(ih->handle), "motion-notify-event",G_CALLBACK(iupgtkMotionNotifyEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(iupgtkButtonEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(iupgtkButtonEvent), ih);
}
/* add to the parent, all GTK controls must call this. */
iupgtkBaseAddToParent(ih);
if (scrolled_window)
gtk_widget_realize((GtkWidget*)scrolled_window);
gtk_widget_realize(ih->handle);
/* configure for DRAG&DROP */
if (IupGetCallback(ih, "DROPFILES_CB"))
iupAttribSetStr(ih, "DRAGDROP", "YES");
iupListSetInitialItems(ih);
return IUP_NOERROR;
}
static void
create_and_set_up_tree_view (FMListView *view)
{
int k;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
view->model = FM_DIRECTORY_VIEW (view)->model;
g_object_set (G_OBJECT (view->model), "has-child", TRUE, NULL);
view->tree = GTK_TREE_VIEW (exo_tree_view_new ());
gtk_tree_view_set_model (view->tree, GTK_TREE_MODEL (view->model));
gtk_tree_view_set_search_column (view->tree, FM_LIST_MODEL_FILENAME);
gtk_tree_view_set_rubber_banding (view->tree, TRUE);
gtk_tree_view_set_rules_hint (view->tree, TRUE);
g_signal_connect (view->tree, "item-hovered", G_CALLBACK (fm_list_view_item_hovered), view);
g_signal_connect_object (gtk_tree_view_get_selection (view->tree), "changed",
G_CALLBACK (list_selection_changed_callback), view, 0);
g_signal_connect_object (view->tree, "button-press-event",
G_CALLBACK (button_press_callback), view, 0);
g_signal_connect (view->tree, "draw",
G_CALLBACK (fm_list_view_draw), view);
g_signal_connect_object (view->tree, "key_press_event",
G_CALLBACK (key_press_callback), view, 0);
g_signal_connect_object (view->tree, "row_expanded",
G_CALLBACK (row_expanded_callback), view, 0);
g_signal_connect_object (view->tree, "row_collapsed",
G_CALLBACK (row_collapsed_callback), view, 0);
g_signal_connect_object (view->tree, "row-activated",
G_CALLBACK (row_activated_callback), view, 0);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (view->tree), GTK_SELECTION_MULTIPLE);
g_signal_connect_object (view->model, "subdirectory_unloaded",
G_CALLBACK (subdirectory_unloaded_callback), view, 0);
for(k=FM_LIST_MODEL_FILENAME; k< FM_LIST_MODEL_NUM_COLUMNS; k++) {
if (k == FM_LIST_MODEL_FILENAME) {
col = gtk_tree_view_column_new ();
view->details->file_name_column = col;
gtk_tree_view_column_set_sort_column_id (col,k);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_column_set_title (col, gettext(col_title[k-FM_LIST_MODEL_FILENAME]));
gtk_tree_view_column_set_expand (col, TRUE);
/* add the icon renderer */
gtk_tree_view_column_pack_start (col, FM_DIRECTORY_VIEW (view)->icon_renderer, FALSE);
gtk_tree_view_column_set_attributes (col, FM_DIRECTORY_VIEW (view)->icon_renderer,
"file", FM_LIST_MODEL_FILE_COLUMN, NULL);
renderer = marlin_cell_renderer_text_ellipsized_new ();
view->details->file_name_cell = (GtkCellRendererText *) renderer;
g_signal_connect (renderer, "edited", G_CALLBACK (cell_renderer_edited), view);
g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_renderer_editing_canceled), view);
g_signal_connect (renderer, "editing-started", G_CALLBACK (cell_renderer_editing_started_cb), view);
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func (col, renderer,
(GtkTreeCellDataFunc) filename_cell_data_func,
view, NULL);
} else {
renderer = gtk_cell_renderer_text_new( );
col = gtk_tree_view_column_new_with_attributes(gettext(col_title[k-FM_LIST_MODEL_FILENAME]), renderer, "text", k, NULL);
gtk_tree_view_column_set_sort_column_id (col,k);
gtk_tree_view_column_set_resizable (col, TRUE);
//gtk_tree_view_column_set_fixed_width (col, 240);
//amtest
gtk_tree_view_column_set_cell_data_func (col, renderer,
(GtkTreeCellDataFunc) color_row_func,
NULL, NULL);
}
gtk_tree_view_append_column(view->tree, col);
}
gtk_widget_show (GTK_WIDGET (view->tree));
gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (view->tree));
}
static gboolean
exo_tree_view_button_release_event (GtkWidget *widget,
GdkEventButton *event)
{
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkTreePath *path;
ExoTreeView *tree_view = EXO_TREE_VIEW (widget);
/* verify that the release event is for the internal tree view window */
if (G_LIKELY (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (tree_view))))
{
/* check if we're in single-click mode and the button-release-event should emit a "row-activate" */
if (G_UNLIKELY (tree_view->priv->single_click && tree_view->priv->button_release_activates))
{
/* reset the "release-activates" flag */
tree_view->priv->button_release_activates = FALSE;
/* determine the path to the row that should be activated */
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view), event->x, event->y, &path, &column, NULL, NULL))
{
/* emit row-activated for the determined row */
if( ! tree_view->priv->activable_column || tree_view->priv->activable_column == column )
gtk_tree_view_row_activated (GTK_TREE_VIEW (tree_view), path, column);
/* cleanup */
gtk_tree_path_free (path);
}
}
else if ((event->state & gtk_accelerator_get_default_mod_mask ()) == 0 && !tree_view->priv->button_release_unblocks_dnd)
{
/* determine the path on which the button was released and select only this row, this way
* the user is still able to alter the selection easily if all rows are selected.
*/
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view), event->x, event->y, &path, &column, NULL, NULL))
{
/* check if the path is selected */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
if (gtk_tree_selection_path_is_selected (selection, path))
{
/* unselect all rows */
gtk_tree_selection_unselect_all (selection);
/* select the row and place the cursor on it */
gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree_view), path, column, FALSE);
}
/* cleanup */
gtk_tree_path_free (path);
}
}
}
/* check if we need to re-enable drag and drop */
if (G_LIKELY (tree_view->priv->button_release_unblocks_dnd))
{
gpointer drag_data = g_object_get_data (G_OBJECT (tree_view), I_("gtk-site-data"));
if (G_LIKELY (drag_data != NULL))
{
g_signal_handlers_unblock_matched (G_OBJECT (tree_view),
G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL,
drag_data);
}
tree_view->priv->button_release_unblocks_dnd = FALSE;
}
/* check if we need to re-enable rubberbanding */
if (G_UNLIKELY (tree_view->priv->button_release_enables_rubber_banding))
{
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (tree_view), TRUE);
tree_view->priv->button_release_enables_rubber_banding = FALSE;
}
/* call the parent's button release handler */
return (*GTK_WIDGET_CLASS (exo_tree_view_parent_class)->button_release_event) (widget, event);
}
static gboolean
exo_tree_view_button_press_event (GtkWidget *widget,
GdkEventButton *event)
{
GtkTreeSelection *selection;
ExoTreeView *tree_view = EXO_TREE_VIEW (widget);
GtkTreePath *path = NULL;
gboolean result;
GList *selected_paths = NULL;
GList *lp;
GtkTreeViewColumn* col;
gboolean treat_as_blank = FALSE;
/* by default we won't emit "row-activated" on button-release-events */
tree_view->priv->button_release_activates = FALSE;
/* grab the tree selection */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
/* be sure to cancel any pending single-click timeout */
if (G_UNLIKELY (tree_view->priv->single_click_timeout_id >= 0))
g_source_remove (tree_view->priv->single_click_timeout_id);
/* check if the button press was on the internal tree view window */
if (G_LIKELY (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (tree_view))))
{
/* determine the path at the event coordinates */
if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view), event->x, event->y, &path, &col, NULL, NULL))
path = NULL;
if( tree_view->priv->activable_column && col != tree_view->priv->activable_column )
{
treat_as_blank = TRUE;
if( path )
{
gtk_tree_path_free( path );
path = NULL;
}
gtk_tree_selection_unselect_all (selection);
}
/* we unselect all selected items if the user clicks on an empty
* area of the tree view and no modifier key is active.
*/
if (path == NULL && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0)
gtk_tree_selection_unselect_all (selection);
/* completely ignore double-clicks in single-click mode */
if (tree_view->priv->single_click && event->type == GDK_2BUTTON_PRESS)
{
/* make sure we ignore the GDK_BUTTON_RELEASE
* event for this GDK_2BUTTON_PRESS event.
*/
gtk_tree_path_free (path);
return TRUE;
}
/* check if the next button-release-event should activate the selected row (single click support) */
tree_view->priv->button_release_activates = (tree_view->priv->single_click && event->type == GDK_BUTTON_PRESS && event->button == 1
&& (event->state & gtk_accelerator_get_default_mod_mask ()) == 0);
}
/* unfortunately GtkTreeView will unselect rows except the clicked one,
* which makes dragging from a GtkTreeView problematic. That's why we
* remember the selected paths here and restore them later.
*/
if (event->type == GDK_BUTTON_PRESS && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0
&& path != NULL && gtk_tree_selection_path_is_selected (selection, path))
{
/* if no custom select function is set, we simply use exo_noop_false here,
* to tell the tree view that it may not alter the selection.
*/
//MOD disabled exo_noop_false due to GTK 2.20 bug https://bugzilla.gnome.org/show_bug.cgi?id=612802
/* if (G_LIKELY (selection->user_func == NULL))
gtk_tree_selection_set_select_function (selection, (GtkTreeSelectionFunc) exo_noop_false, NULL, NULL);
else
*/
selected_paths = gtk_tree_selection_get_selected_rows (selection, NULL);
}
/* Rubberbanding in GtkTreeView 2.9.0 and above is rather buggy, unfortunately, and
* doesn't interact properly with GTKs own DnD mechanism. So we need to block all
* dragging here when pressing the mouse button on a not yet selected row if
* rubberbanding is active, or disable rubberbanding when starting a drag.
*/
if (gtk_tree_selection_get_mode (selection) == GTK_SELECTION_MULTIPLE
&& gtk_tree_view_get_rubber_banding (GTK_TREE_VIEW (tree_view))
&& event->button == 1 && event->type == GDK_BUTTON_PRESS)
{
/* check if clicked on empty area or on a not yet selected row */
if (G_LIKELY (path == NULL || !gtk_tree_selection_path_is_selected (selection, path)))
{
/* need to disable drag and drop because we're rubberbanding now */
gpointer drag_data = g_object_get_data (G_OBJECT (tree_view), I_("gtk-site-data"));
if (G_LIKELY (drag_data != NULL))
{
g_signal_handlers_block_matched (G_OBJECT (tree_view),
G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL,
drag_data);
}
/* remember to re-enable drag and drop later */
tree_view->priv->button_release_unblocks_dnd = TRUE;
}
else
{
/* need to disable rubberbanding because we're dragging now */
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (tree_view), FALSE);
/* remember to re-enable rubberbanding later */
tree_view->priv->button_release_enables_rubber_banding = TRUE;
}
}
/* call the parent's button press handler */
result = (*GTK_WIDGET_CLASS (exo_tree_view_parent_class)->button_press_event) (widget, event);
if( treat_as_blank )
gtk_tree_selection_unselect_all( selection );
/* restore previous selection if the path is still selected */
if (event->type == GDK_BUTTON_PRESS && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0
&& path != NULL && gtk_tree_selection_path_is_selected (selection, path))
{
/* check if we have to restore paths */
if (G_LIKELY (gtk_tree_selection_get_select_function (selection) == (GtkTreeSelectionFunc) exo_noop_false))
{
/* just reset the select function (previously set to exo_noop_false),
* there's no clean way to do this, so what the heck.
*/
gtk_tree_selection_set_select_function (selection, NULL, NULL, NULL);
}
else
{
/* select all previously selected paths */
for (lp = selected_paths; lp != NULL; lp = lp->next)
gtk_tree_selection_select_path (selection, lp->data);
}
}
/* release the path (if any) */
if (G_LIKELY (path != NULL))
gtk_tree_path_free (path);
/* release the selected paths list */
g_list_foreach (selected_paths, (GFunc) gtk_tree_path_free, NULL);
g_list_free (selected_paths);
return result;
}
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;
}
static void
_dtv_init (DiagramTreeView *dtv)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
gint font_size;
GtkStyle *style;
/* connect the model with the view */
gtk_tree_view_set_model (GTK_TREE_VIEW (dtv), diagram_tree_model_new ());
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (dtv), TRUE);
/* the tree requires reading across rows (semantic hint) */
#if 0 /* stripe style */
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dtv), TRUE);
#endif
style = gtk_widget_get_style (GTK_WIDGET (dtv));
font_size = pango_font_description_get_size (style->font_desc);
font_size = PANGO_PIXELS (font_size);
/* first colum: name of diagram/layer/object - here is the tree */
cell = gtk_cell_renderer_text_new ();
gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (cell), 1);
g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Name"));
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width (column, font_size * 10);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell, "text", NAME_COLUMN);
gtk_tree_view_insert_column (GTK_TREE_VIEW (dtv), column, -1);
/* this is enough for simple name search (just typing) */
gtk_tree_view_set_search_column (GTK_TREE_VIEW (dtv), NAME_COLUMN);
/* must have a sortable model ... */
gtk_tree_view_column_set_sort_column_id (column, NAME_COLUMN);
/* type column - show the type icon */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Type"));
/* must have fixed size, too */
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
/* without it gets zero size - not very useful! */
gtk_tree_view_column_set_min_width (column, font_size * 6);
gtk_tree_view_column_set_resizable (column, TRUE);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (column), cell,
_dtv_cell_pixbuf_func, dtv, NULL);
gtk_tree_view_insert_column (GTK_TREE_VIEW (dtv), column, -1);
gtk_tree_view_column_set_sort_column_id (column, OBJECT_COLUMN);
/* TODO: other fancy stuff */
{
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dtv));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (dtv), TRUE);
}
gtk_widget_set_has_tooltip (GTK_WIDGET (dtv), TRUE);
_dtv_create_popup_menu (dtv);
}
void SetupHashWindow()
{
/* Setup window */
gui.windows.hash = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(gui.windows.hash), "Hashes");
gtk_window_set_default_size(GTK_WINDOW(gui.windows.hash), 580, 340);
gtk_window_set_deletable(GTK_WINDOW(gui.windows.hash), false);
gui.fixed.hash = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(gui.windows.hash), gui.fixed.hash);
/* Load hashes */
gui.entries.hash = gtk_entry_new();
gtk_widget_set_size_request(gui.entries.hash, 380, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.entries.hash, 8, 8);
gui.cbox.hash = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hashlist");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hash");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "pwdump");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Cain");
gtk_widget_set_size_request(gui.cbox.hash, 90, 32);
gtk_combo_box_set_active(GTK_COMBO_BOX(gui.cbox.hash), 0);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.cbox.hash, 390, 8);
gui.buttons.hash_load = gtk_button_new_with_label("Load");
gtk_widget_set_size_request(gui.buttons.hash_load, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_load, 485, 8);
/* TreeView */
gui.hash.scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gui.hash.scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gui.hash.tree = gtk_tree_view_new();
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(gui.hash.tree), true);
gui.hash.store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(gui.hash.tree), GTK_TREE_MODEL(gui.hash.store));
gui.hash.render = gtk_cell_renderer_text_new();
GtkTreeViewColumn *col = gtk_tree_view_column_new_with_attributes("Algorithm", gui.hash.render, "text", 0, NULL);
gtk_tree_view_column_set_sort_column_id(col, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
col = gtk_tree_view_column_new_with_attributes("Length", gui.hash.render, "text", 1, NULL);
gtk_tree_view_column_set_sort_column_id(col, 1);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
col = gtk_tree_view_column_new_with_attributes("Hash", gui.hash.render, "text", 2, NULL);
gtk_tree_view_column_set_sort_column_id(col, 2);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gui.hash.tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_container_add(GTK_CONTAINER(gui.hash.scroll), gui.hash.tree);
gtk_widget_set_size_request(gui.hash.tree, 560, 240);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.hash.scroll, 8, 48);
/* Buttons */
gui.buttons.hash_delete = gtk_button_new_with_label("Remove");
gtk_widget_set_size_request(gui.buttons.hash_delete, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_delete, 8, 300);
gui.buttons.hash_clear = gtk_button_new_with_label("Clear");
gtk_widget_set_size_request(gui.buttons.hash_clear, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_clear, 100, 300);
gui.buttons.hash_ok = gtk_button_new_with_label("OK");
gtk_widget_set_size_request(gui.buttons.hash_ok, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_ok, 480, 300);
g_signal_connect(gui.buttons.hash_load, "clicked", G_CALLBACK(LoadHashes), NULL);
g_signal_connect(gui.buttons.hash_ok, "clicked", G_CALLBACK(HideHashWindow), NULL);
g_signal_connect(gui.buttons.hash_delete, "clicked", G_CALLBACK(DeleteHashes), NULL);
g_signal_connect(gui.buttons.hash_clear, "clicked", G_CALLBACK(ClearHashes), NULL);
return;
}
static void
xfmpc_lists_init (XfmpcLists *lists)
{
XfmpcListsPrivate *priv = lists->priv = GET_PRIVATE (lists);
lists->preferences = xfmpc_preferences_get ();
lists->mpdclient = xfmpc_mpdclient_get ();
/* === Tree model === */
priv->store = gtk_list_store_new (N_COLUMNS,
G_TYPE_INT,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_INT);
/* === Tree view === */
priv->treeview = gtk_tree_view_new ();
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)), GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (priv->treeview), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (priv->treeview), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (priv->treeview), COLUMN_NAME);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->treeview), TRUE);
gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), GTK_TREE_MODEL (priv->store));
g_object_unref (priv->store);
/* Columns */
GtkCellRenderer *cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview),
-1, "", cell,
"pixbuf", COLUMN_PIXBUF,
NULL);
cell = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (cell),
"ellipsize", PANGO_ELLIPSIZE_END,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview),
-1, "Filename", cell,
"text", COLUMN_NAME,
NULL);
/* Scrolled window */
GtkWidget *scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
/* Menu */
priv->menu = gtk_menu_new ();
/* Menu -> Add */
GtkWidget *mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_ADD, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
g_signal_connect_swapped (mi, "activate",
G_CALLBACK (xfmpc_lists_add_playlist), lists);
/* Menu -> Replace */
mi = gtk_image_menu_item_new_with_mnemonic (_("Replace"));
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
g_signal_connect_swapped (mi, "activate",
G_CALLBACK (xfmpc_lists_replace_playlist), lists);
GtkWidget *image = gtk_image_new_from_stock (GTK_STOCK_UNDO, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), image);
/* Menu -> Separator */
mi = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
/* Menu -> Create */
mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
g_signal_connect_swapped (mi, "activate",
G_CALLBACK (xfmpc_lists_create), lists);
/* Menu -> Edit */
mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_EDIT, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
g_signal_connect_swapped (mi, "activate",
G_CALLBACK (xfmpc_lists_edit), lists);
/* Menu -> Remove */
mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
g_signal_connect_swapped (mi, "activate",
G_CALLBACK (xfmpc_lists_delete), lists);
xfmpc_menu_add(xfmpc_menu_get(), priv->menu);
gtk_widget_show_all (priv->menu);
/* === Containers === */
gtk_container_add (GTK_CONTAINER (scrolled), priv->treeview);
gtk_box_pack_start (GTK_BOX (lists), scrolled, TRUE, TRUE, 0);
/* === Signals === */
g_signal_connect_swapped (lists->mpdclient, "connected",
G_CALLBACK (xfmpc_lists_reload), lists);
/* Tree view */
g_signal_connect_swapped (priv->treeview, "row-activated",
G_CALLBACK (xfmpc_lists_add_playlist), lists);
g_signal_connect_swapped (priv->treeview, "key-press-event",
G_CALLBACK (cb_key_pressed), lists);
g_signal_connect_swapped (priv->treeview, "button-press-event",
G_CALLBACK (cb_button_pressed), lists);
g_signal_connect_swapped (priv->treeview, "popup-menu",
G_CALLBACK (cb_popup_menu), lists);
}
