static GtkTreeViewColumn *
create_user_view_column(int id,const char *title, GCallback callback){
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
if ( (id<0) || (id>=MAX_VIEW_ID) || (!title) )
return NULL;
/* --- Column #1 --- */
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, title);
renderer = gtk_cell_renderer_text_new();
/* pack cell renderer into tree view column */
gtk_tree_view_column_pack_start(col, renderer, TRUE);
/* connect 'text' property of the cell renderer to
* model column that contains the first name */
gtk_tree_view_column_add_attribute(col, renderer, "text", id);
gtk_tree_view_column_set_resizable (col,TRUE);
gtk_tree_view_column_set_clickable(col,TRUE);
gtk_tree_view_column_set_reorderable(col, TRUE);
g_signal_connect ((gpointer) col, "clicked",
G_CALLBACK (callback),
NULL);
HOOKUP_ID(col,id);
return col;
}
static GtkTreeViewColumn *my_new_column_text ( const gchar *title, GtkCellRenderer *renderer, GtkWidget *view, gint column_runner )
{
GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes ( title, renderer, "text", column_runner, NULL );
gtk_tree_view_column_set_sort_column_id ( column, column_runner );
gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column );
gtk_tree_view_column_set_reorderable ( column, TRUE );
gtk_tree_view_column_set_resizable ( column, TRUE );
return column;
}
void gtk_assert_dialog_append_text_column (GtkWidget *treeview, const gchar *name, int index)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (name, renderer,
"text", index, NULL);
gtk_tree_view_insert_column (GTK_TREE_VIEW (treeview), column, index);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
}
void create_column(void *view, int type,
char *title, int width)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
debug("create_column()");
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(title, renderer,
"text", type,
NULL);
gtk_tree_view_column_set_title(column, title);
gtk_tree_view_column_set_visible(column, TRUE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_min_width(column, width);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_column_set_clickable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_order(column, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
}
static void setup_tree_view (GtkWidget *treeview, Data *p)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
guint i = NUMBER;
while (i != COLUMNS)
{
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (properties[i].name, renderer, "text", i, NULL);
gtk_tree_view_column_set_resizable (column, properties[i].resizable);
gtk_tree_view_column_set_visible (column, properties[i].visible);
gtk_tree_view_column_set_reorderable (column, properties[i].reorderable);
gtk_tree_view_column_set_sort_indicator (column, properties[i].sort_indicator);
if (properties[i].reorderable)
gtk_tree_view_column_set_sort_column_id (column, i);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
i++;
}
}
static void
add_clicked (GtkWidget *button, gpointer data)
{
static gint i = 0;
GtkTreeIter iter;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkCellRenderer *cell;
gchar *label = g_strdup_printf ("Column %d", i);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (label, cell, "text", 0, NULL);
g_object_set_data_full (G_OBJECT (column), column_data, label, g_free);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_list_store_append (GTK_LIST_STORE (left_tree_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (left_tree_model), &iter, 0, label, 1, column, -1);
i++;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view));
gtk_tree_selection_select_iter (selection, &iter);
}
static void setup_tree_view (GtkTreeView *treeview)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
guint i = WORD_WRITING;
while (i != COLUMNS)
{
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, "editable-set", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "column-num", GUINT_TO_POINTER (i));
g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (cell_edited), (gpointer) treeview);
column = gtk_tree_view_column_new_with_attributes (column_names[i], renderer, "text", i, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_sort_indicator (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, i);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
i++;
}
}
void library_view_init(library_view_t* view)
{
// library view.
GObject* object = gtk_builder_get_object(view->builder,"view_library");
g_object_set_data(object, "library_view_t", (gpointer) view);
// playlists (initially not viewed)
//GtkWidget* scw_playlists = GTK_WIDGET(gtk_builder_get_object(view->builder,"scw_playlists"));
//gtk_widget_hide(scw_playlists);
// library list
GtkTreeView* tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_library"));
view->tview = tview;
GtkTreeViewColumn *col;
GtkCellRenderer* renderer;
renderer = gtk_cell_renderer_text_new();
view->cols = (GtkTreeViewColumn**) mc_malloc(sizeof(GtkTreeViewColumn*) * PLAYLIST_MODEL_N_COLUMNS);
playlist_column_enum e;
for(e = PLAYLIST_MODEL_COL_NR; e < PLAYLIST_MODEL_N_COLUMNS; ++e) {
col = gtk_tree_view_column_new_with_attributes(i18n_column_name(e), renderer, "text", e, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
char path [500];
sprintf(path, "library.column.%s.width", column_id(e));
int width = el_config_get_int(btb_config(view->btb), path, 100);
if (width < 10) { width = 100; }
g_object_set_data(G_OBJECT(col), "column_id", (gpointer) column_id(e));
gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_clickable(col, TRUE);
g_signal_connect(col, "clicked", (GCallback) library_view_library_col_sort, view);
g_signal_connect (col, "notify::width", G_CALLBACK (library_view_col_width_set), view);
view->cols[e] = col;
g_object_ref(view->cols[e]);
gtk_tree_view_append_column(tview, col);
}
gtk_tree_view_set_model(tview, GTK_TREE_MODEL(playlist_model_gtk_model(view->playlist_model)));
// Aspect lists
int width;
// Genres
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_genre_aspect"));
col = gtk_tree_view_column_new_with_attributes(_("Genre"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
//width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200);
//gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, string_model_gtk_model(view->genre_model));
// Artists
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_artist_aspect"));
col = gtk_tree_view_column_new_with_attributes(_("Artists"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
//width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200);
//gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, string_model_gtk_model(view->artist_model));
// Albums
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_album_aspect"));
col = gtk_tree_view_column_new_with_attributes(_("Artists"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
//width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200);
//gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, string_model_gtk_model(view->album_model));
// Activate genres
library_view_aspect_page(view, GENRE_ASPECT);
GtkToggleToolButton* g_btn = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(view->builder, "tbtn_genres"));
gtk_toggle_tool_button_set_active(g_btn, TRUE);
// playback scale, song info
GtkScale* sc_playback = GTK_SCALE(gtk_builder_get_object(view->builder, "sc_library_playback"));
gtk_range_set_range(GTK_RANGE(sc_playback), 0.0, 100.0);
{
char ss[300];
sprintf(ss,"<span size=\"x-small\"><i><b> </b></i></span>");
GtkLabel* lbl = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_song_info"));
gtk_label_set_markup(lbl, ss);
}
// Set logo
{
char *path = backtobasics_logo(view->btb);
file_info_t* info = file_info_new(path);
mc_free(path);
if (file_info_is_file(info)) {
GError *err = NULL;
GdkPixbuf* pb = gdk_pixbuf_new_from_file_at_scale(file_info_path(info),
view->img_w, view->img_h,
TRUE,
&err
);
GtkImage* img = GTK_IMAGE(gtk_builder_get_object(view->builder, "img_art"));
gtk_widget_set_size_request(GTK_WIDGET(img), view->img_w, view->img_h);
if (pb != NULL) {
gtk_image_set_from_pixbuf(img, pb);
g_object_unref(pb);
} else {
log_error3("error loading image art: %d, %s", err->code, err->message);
//g_free(err);
}
}
file_info_destroy(info);
}
// Playlists
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_playlists"));
col = gtk_tree_view_column_new_with_attributes(_("Playlist"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
width = el_config_get_int(btb_config(view->btb), "library.playlists.column_width", 200);
gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, playlists_model_gtk_model(view->playlists_model));
// Lyric view
view->lyric_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
view->lbl_lyric_track = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_lyric_track"));
GtkScrolledWindow* scw_lyric = GTK_SCROLLED_WINDOW(gtk_builder_get_object(view->builder, "scw_lyric"));
gtk_container_add(GTK_CONTAINER(scw_lyric), GTK_WIDGET(view->lyric_view));
// visibility of columns
{
const char* names[] = {
"chk_col_nr", "chk_col_title", "chk_col_artist", "chk_col_composer",
"chk_col_piece", "chk_col_album", "chk_col_albumartist", "chk_col_genre",
"chk_col_year", "chk_col_length", NULL
};
const playlist_column_enum es[] = {
PLAYLIST_MODEL_COL_NR, PLAYLIST_MODEL_COL_TITLE, PLAYLIST_MODEL_COL_ARTIST,
PLAYLIST_MODEL_COL_COMPOSER, PLAYLIST_MODEL_COL_PIECE,
PLAYLIST_MODEL_COL_ALBUM_TITLE, PLAYLIST_MODEL_COL_ALBUM_ARTIST,
PLAYLIST_MODEL_COL_GENRE, PLAYLIST_MODEL_COL_YEAR, PLAYLIST_MODEL_COL_LENGTH,
PLAYLIST_MODEL_N_COLUMNS
};
int i;
for(i = 0;names[i] != NULL; ++i) {
GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(gtk_builder_get_object(view->builder, names[i]));
gtk_widget_set_name(GTK_WIDGET(item), names[i]);
char cfgitem[100];
sprintf(cfgitem, "library.cols.%s", names[i]);
int yes = el_config_get_int(btb_config(view->btb), cfgitem, 1);
gtk_check_menu_item_set_active(item, yes);
gtk_tree_view_column_set_visible(view->cols[es[i]], yes);
}
}
// Start timeout every 250 ms
g_timeout_add(250, (GSourceFunc) library_view_update_info, view);
}
static void setup_view(GtkWidget* view)
{
GtkListStore* store = gtk_list_store_new (23,
G_TYPE_STRING, /* 0 Country */
G_TYPE_STRING, /* 1 Good Name */
GDK_TYPE_PIXBUF, /* 2 NULL for Status handle / empty */
G_TYPE_STRING, /* 3 User Comments */
G_TYPE_STRING, /* 4 File Name */
G_TYPE_STRING, /* 5 MD5 Hash */
G_TYPE_STRING, /* 6 CRC1 */
G_TYPE_STRING, /* 7 CRC2 */
G_TYPE_STRING, /* 8 Internal Name */
G_TYPE_STRING, /* 9 Save Type */
G_TYPE_STRING, /* 10 Players */
G_TYPE_STRING, /* 11 Size */
G_TYPE_STRING, /* 12 Compression */
G_TYPE_STRING, /* 13 Image Type */
G_TYPE_STRING, /* 14 CIC Chip */
G_TYPE_STRING, /* 15 Rumble */
GDK_TYPE_PIXBUF, /* 16-20 Pixbufs for Status stars. */
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF, /* 21 Flag */
G_TYPE_POINTER, /* 22 RCS Entry */
-1);
GtkCellRenderer* renderer;
GtkTreeViewColumn* column;
GtkWidget* item;
char buffer[128];
int i;
unsigned char visible;
/* Create country flag / string dual rendered cell. */
renderer = gtk_cell_renderer_pixbuf_new();
g_MainWindow.column[0] = gtk_tree_view_column_new();
column = g_MainWindow.column[0];
gtk_tree_view_column_set_title(column, g_MainWindow.column_names[0][0]);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 21);
g_object_set(renderer, "xpad", 5, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 0);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
renderer = gtk_cell_renderer_text_new();
g_MainWindow.column[1] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[1][0], renderer, "text", 1, NULL);
column = g_MainWindow.column[1];
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, 1);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 1);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
/* Status stars. */
g_MainWindow.column[2] = gtk_tree_view_column_new();
column = g_MainWindow.column[2];
gtk_tree_view_column_set_title(column, g_MainWindow.column_names[2][0]);
renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(renderer, "xpad", 2, NULL);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2);
for(i = 0; i < 5; ++i)
{
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 16+i);
}
renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(renderer, "xpad", 2, NULL);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, 2);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 2);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
for(i = 3; i < 16; ++i)
{
renderer = gtk_cell_renderer_text_new();
g_MainWindow.column[i] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[i][0], renderer, "text", i, NULL);
column = g_MainWindow.column[i];
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, i);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, i);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
}
renderer = gtk_cell_renderer_text_new ();
g_MainWindow.column[16] = gtk_tree_view_column_new();
column = g_MainWindow.column[16];
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_insert_column(GTK_TREE_VIEW(view), column, 2);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
g_MainWindow.romHeaderMenu = gtk_menu_new();
/* Toggle column visibility from config file, make menu. */
for(i = 0; i < 16; ++i)
{
snprintf(buffer, sizeof(buffer), " %s", g_MainWindow.column_names[i][0]);
item = gtk_check_menu_item_new_with_mnemonic(buffer);
if((visible=config_get_bool(g_MainWindow.column_names[i][1], 2))==2)
{
visible = (i<5) ? TRUE: FALSE;
config_put_bool(g_MainWindow.column_names[i][1], visible);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), visible);
gtk_tree_view_column_set_visible(g_MainWindow.column[i], visible);
gtk_menu_shell_append(GTK_MENU_SHELL(g_MainWindow.romHeaderMenu), item);
g_signal_connect(item, "activate", G_CALLBACK(callback_column_visible), GUINT_TO_POINTER(i));
}
gtk_tree_view_column_set_visible(g_MainWindow.column[16], FALSE);
for(i = 0; i < 16; ++i)
{
if(gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(g_MainWindow.column[i])))
return;
}
gtk_tree_view_column_set_visible(g_MainWindow.column[16], TRUE);
}
GtkWidget *
create_disk_view(ProcData *procdata)
{
GtkWidget *disk_box;
GtkWidget *label;
GtkWidget *scrolled;
GtkWidget *disk_tree;
GtkListStore *model;
GtkTreeViewColumn *col;
GtkCellRenderer *cell;
guint i;
const gchar * const titles[] = {
N_("Device"),
N_("Directory"),
N_("Type"),
N_("Total"),
N_("Free"),
N_("Available"),
N_("Used")
};
disk_box = gtk_vbox_new(FALSE, 6);
gtk_container_set_border_width(GTK_CONTAINER(disk_box), 12);
label = make_title_label(_("File Systems"));
gtk_box_pack_start(GTK_BOX(disk_box), label, FALSE, FALSE, 0);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(disk_box), scrolled, TRUE, TRUE, 0);
model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */
G_TYPE_STRING, /* DISK_DEVICE */
G_TYPE_STRING, /* DISK_DIR */
G_TYPE_STRING, /* DISK_TYPE */
G_TYPE_UINT64, /* DISK_TOTAL */
G_TYPE_UINT64, /* DISK_FREE */
G_TYPE_UINT64, /* DISK_AVAIL */
G_TYPE_UINT64, /* DISK_USED */
GDK_TYPE_PIXBUF, /* DISK_ICON */
G_TYPE_INT /* DISK_USED_PERCENTAGE */
);
disk_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL);
procdata->disk_list = disk_tree;
gtk_container_add(GTK_CONTAINER(scrolled), disk_tree);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(disk_tree), TRUE);
g_object_unref(G_OBJECT(model));
/* icon + device */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON,
NULL);
cell = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE,
NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE]));
gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
/* sizes - used */
for (i = DISK_DIR; i <= DISK_AVAIL; i++) {
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_title(col, _(titles[i]));
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, i);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
switch (i) {
case DISK_TOTAL:
case DISK_FREE:
case DISK_AVAIL:
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_cell_data_func,
GUINT_TO_POINTER(i),
NULL);
break;
default:
gtk_tree_view_column_set_attributes(col, cell,
"text", i,
NULL);
break;
}
}
/* used + percentage */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_text_new();
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_cell_data_func,
GUINT_TO_POINTER(DISK_USED),
NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_USED]));
cell = gtk_cell_renderer_progress_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_attributes(col, cell, "value",
DISK_USED_PERCENTAGE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, DISK_USED);
gtk_tree_view_column_set_reorderable(col, TRUE);
/* numeric sort */
gtk_widget_show_all(disk_box);
procman_get_tree_state(procdata->client, disk_tree,
"/apps/procman/disktreenew");
g_signal_connect (G_OBJECT(disk_tree), "columns-changed",
G_CALLBACK(cb_disk_columns_changed), procdata);
return disk_box;
}
void
ephy_permissions_dialog_add_tab (EphyPermissionsDialog *dialog,
const char *type,
const char *title)
{
EphyPermissionsDialogPrivate *priv = dialog->priv;
GtkWidget *hbox, *view, *vbuttonbox, *button;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeView *treeview;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
DialogTab *tab;
tab = g_new0 (DialogTab, 1);
tab->dialog = dialog;
tab->type = g_strdup (type);
tab->qtype = g_quark_from_string (type);
tab->filled = FALSE;
priv->tabs = g_list_prepend (priv->tabs, tab);
hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
g_object_set_data (G_OBJECT (hbox), TAB_DATA_KEY, tab);
view = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view),
GTK_POLICY_NEVER /* FIXME? */,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (view),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), view, TRUE, TRUE, 0);
tab->store = store = gtk_list_store_new (2,
G_TYPE_STRING,
G_TYPE_STRING);
tab->model = GTK_TREE_MODEL (store);
tab->treeview = treeview = GTK_TREE_VIEW (gtk_tree_view_new_with_model (tab->model));
g_object_unref (store);
g_signal_connect (treeview, "key-press-event",
G_CALLBACK (treeview_key_press_event_cb), tab);
gtk_tree_view_set_headers_visible (treeview, TRUE);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (treeview,
COL_HOST,
_("Domain"),
renderer,
"text", COL_HOST,
NULL);
column = gtk_tree_view_get_column (treeview, COL_HOST);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sort_column_id (column, COL_HOST);
gtk_tree_view_insert_column_with_attributes (treeview,
COL_PERM,
_("State"),
renderer,
"text", COL_PERM,
NULL);
column = gtk_tree_view_get_column (treeview, COL_PERM);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sort_column_id (column, COL_PERM);
gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (treeview));
tab->selection = selection = gtk_tree_view_get_selection (treeview);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
g_signal_connect (selection, "changed",
G_CALLBACK (treeview_selection_changed_cb), tab);
/* Button box */
vbuttonbox = gtk_vbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox),
GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (hbox), vbuttonbox, FALSE, FALSE, 0);
/* Remove button */
tab->remove_button = button = gtk_button_new_from_stock (GTK_STOCK_REMOVE);
g_signal_connect (button, "clicked",
G_CALLBACK (remove_button_clicked_cb), tab);
gtk_box_pack_start (GTK_BOX (vbuttonbox), button, FALSE, FALSE, 0);
gtk_size_group_add_widget (priv->buttons_size_group, button);
gtk_widget_show_all (hbox);
/* And finally insert it in the notebook */
gtk_notebook_append_page (priv->notebook, hbox,
gtk_label_new (title));
}
GtkWidget *
create_directory_treeview (void)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
GtkWidget *scrolled;
GtkWidget *tvw = GTK_WIDGET (gtk_builder_get_object (baobab.main_ui, "treeview1"));
g_signal_connect (tvw, "row-expanded",
G_CALLBACK (on_tv_row_expanded), NULL);
g_signal_connect (tvw, "cursor-changed",
G_CALLBACK (on_tv_cur_changed), NULL);
g_signal_connect (tvw, "button-press-event",
G_CALLBACK (on_tv_button_press), NULL);
/* dir name column */
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (tvw)), "changed",
G_CALLBACK (on_tv_selection_changed), NULL);
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_DIR_NAME, "text",
COL_DIR_NAME, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_DIR_NAME);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Folder"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* percentage bar & text column */
col = gtk_tree_view_column_new ();
cell = baobab_cell_renderer_progress_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_set_attributes (col, cell, "perc",
COL_H_PERC, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, cell, TRUE);
gtk_tree_view_column_set_cell_data_func (col, cell,
perc_cell_data_func,
NULL, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_H_PERC);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Usage"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* directory size column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_DIR_SIZE, "text",
COL_DIR_SIZE, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col,
baobab.show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Size"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* store this column, we need it when toggling 'allocated' */
g_object_set_data (G_OBJECT (tvw), "baobab_size_col", col);
/* objects column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_ELEMENTS, "text",
COL_ELEMENTS, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_H_ELEMENTS);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Contents"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* hardlink column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_HARDLINK, "text",
COL_HARDLINK, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
gtk_tree_view_collapse_all (GTK_TREE_VIEW (tvw));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tvw), FALSE);
scrolled = GTK_WIDGET (gtk_builder_get_object (baobab.main_ui, "scrolledwindow1"));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (tvw),
baobab_treeview_equal_func,
NULL, NULL);
baobab.model = create_model ();
/* By default, sort by size */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (baobab.model),
baobab.show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE,
GTK_SORT_DESCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (tvw),
GTK_TREE_MODEL (baobab.model));
g_object_unref (baobab.model);
return tvw;
}
static void
setup_filters (EventLog *log)
{
int i;
EventType last_toplevel_type = EVENT_TYPE_LAST;
GtkTreeIter cur_toplevel;
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
log->filters = gtk_tree_store_new(FILTER_COLUMN_LAST,
G_TYPE_STRING, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN, G_TYPE_STRING);
g_signal_connect (log->filters, "row_changed",
G_CALLBACK (update_listener_row_changed), log);
for (i = 0; i < G_N_ELEMENTS (event_info); i++) {
GtkTreeIter item;
EventType type = event_info[i].type;
const char *event_type_name = event_type_names[type];
if (type != last_toplevel_type) {
char *event_type_name_colon = g_strconcat (event_type_name, ":", NULL);
last_toplevel_type = type;
gtk_tree_store_append (log->filters, &cur_toplevel, NULL);
gtk_tree_store_set (log->filters, &cur_toplevel,
FILTER_COLUMN_NAME, event_type_name,
FILTER_COLUMN_ENABLED, (gboolean) FALSE,
FILTER_COLUMN_INCONSISTENT, (gboolean) FALSE,
FILTER_COLUMN_FULL_NAME, event_type_name_colon,
-1);
g_free (event_type_name_colon);
}
if (event_info[i].name) {
char *full_name;
gtk_tree_store_append (log->filters, &item, &cur_toplevel);
full_name = g_strconcat (event_type_name, ":", event_info[i].name, NULL);
gtk_tree_store_set (log->filters, &item,
FILTER_COLUMN_NAME, event_info[i].name,
FILTER_COLUMN_ENABLED, (gboolean) FALSE,
FILTER_COLUMN_INCONSISTENT, (gboolean) FALSE,
FILTER_COLUMN_FULL_NAME, full_name,
-1);
g_free (full_name);
}
}
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_title (column, "Name");
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes
(column, cell, "active", FILTER_COLUMN_ENABLED,
"inconsistent", FILTER_COLUMN_INCONSISTENT, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
g_signal_connect (cell, "toggled", G_CALLBACK (update_filter_model), log);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes
(column, cell, "text", FILTER_COLUMN_NAME, NULL);
gtk_tree_view_column_set_sort_column_id (column, FILTER_COLUMN_NAME);
gtk_tree_view_append_column (log->filters_view, column);
gtk_tree_view_insert_column_with_attributes
(log->filters_view, 2, "Full name",
gtk_cell_renderer_text_new (), "text",
FILTER_COLUMN_FULL_NAME, NULL);
gtk_tree_view_set_model (log->filters_view,
GTK_TREE_MODEL (log->filters));
gtk_tree_view_set_headers_visible (log->filters_view, TRUE);
gtk_tree_selection_set_mode
(gtk_tree_view_get_selection (log->filters_view),
GTK_SELECTION_NONE);
gtk_tree_view_columns_autosize (log->filters_view);
}
static void
history_dialog_setup_view (HistoryDialog *dialog)
{
GtkTreeView *treeview = dialog->priv->treeview;
GtkTreeStore *treestore;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
/* set tree model */
treestore = gtk_tree_store_new (8,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_POINTER,
G_TYPE_INT,
G_TYPE_INT);
dialog->priv->model = GTK_TREE_MODEL(treestore);
gtk_tree_view_set_model (treeview,
GTK_TREE_MODEL (treestore));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview),
TRUE);
g_signal_connect (treeview, "row_activated",
G_CALLBACK (history_dialog_row_activated_cb),
dialog);
selection = gtk_tree_view_get_selection (treeview);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_enable_model_drag_source (treeview,
GDK_BUTTON1_MASK,
url_drag_types,
G_N_ELEMENTS (url_drag_types),
GDK_ACTION_COPY);
g_signal_connect (G_OBJECT(treeview),
"drag_data_get",
G_CALLBACK(treeview_drag_data_get_cb),
dialog);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (treeview,
0, _("Title"),
renderer,
"text", 0,
NULL);
column = gtk_tree_view_get_column (treeview, 0);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_min_width (column, 20);
gtk_tree_view_column_set_max_width (column, 400);
gtk_tree_view_column_set_sort_column_id (column, 0);
gtk_tree_view_insert_column_with_attributes (treeview,
1, _("URL"),
renderer,
"text", 1,
NULL);
column = gtk_tree_view_get_column (treeview, 1);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_min_width (column, 20);
gtk_tree_view_column_set_max_width (column, 500);
gtk_tree_view_column_set_sort_column_id (column, 1);
gtk_tree_view_insert_column_with_attributes (treeview,
2, _("Last visited"),
renderer,
"text", 2,
NULL);
column = gtk_tree_view_get_column (treeview, 2);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, 6);
gtk_tree_view_insert_column_with_attributes (treeview,
3, _("First visited"),
renderer,
"text", 3,
NULL);
column = gtk_tree_view_get_column (treeview, 3);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, 7);
gtk_tree_view_insert_column_with_attributes (treeview,
4, _("Times visited"),
renderer,
"text", 4,
NULL);
column = gtk_tree_view_get_column (treeview, 4);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, 4);
}
static GtkWidget *
setup_popup_sites_treeview (PdmDialog *dialog)
{
GtkTreeView *treeview;
GtkListStore *liststore;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkTreeModel *sorter, *filter;
treeview = GTK_TREE_VIEW(galeon_dialog_get_control
(GALEON_DIALOG(dialog),
PROP_POPUP_SITES_TREEVIEW));
/* set tree model */
liststore = gtk_list_store_new(3,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_POINTER);
filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(liststore), NULL);
sorter = gtk_tree_model_sort_new_with_model(filter);
gtk_tree_view_set_model (treeview, GTK_TREE_MODEL(sorter));
g_object_unref (liststore);
g_object_unref (filter);
g_object_unref (sorter);
gtk_tree_view_set_headers_visible(treeview, TRUE);
selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection,
GTK_SELECTION_MULTIPLE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(treeview,
COL_POPUP_SITES_DOMAIN,
_("Domain"),
renderer,
"text", COL_POPUP_SITES_DOMAIN,
NULL);
column = gtk_tree_view_get_column(treeview, COL_POPUP_SITES_DOMAIN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sort_column_id(column, COL_POPUP_SITES_DOMAIN);
gtk_tree_view_insert_column_with_attributes(treeview,
COL_POPUP_SITES_STATUS,
_("Status"),
renderer,
"text", COL_POPUP_SITES_STATUS,
NULL);
column = gtk_tree_view_get_column(treeview, COL_POPUP_SITES_STATUS);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sort_column_id(column, COL_POPUP_SITES_STATUS);
return GTK_WIDGET(treeview);
}
void
create_disk_view(GsmApplication *app, GtkBuilder *builder)
{
GtkScrolledWindow *scrolled;
GsmTreeView *disk_tree;
GtkListStore *model;
GtkTreeViewColumn *col;
GtkCellRenderer *cell;
guint i;
init_volume_monitor (app);
const gchar * const titles[] = {
N_("Device"),
N_("Directory"),
N_("Type"),
N_("Total"),
N_("Free"),
N_("Available"),
N_("Used")
};
scrolled = GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "disks_scrolled"));
model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */
G_TYPE_STRING, /* DISK_DEVICE */
G_TYPE_STRING, /* DISK_DIR */
G_TYPE_STRING, /* DISK_TYPE */
G_TYPE_UINT64, /* DISK_TOTAL */
G_TYPE_UINT64, /* DISK_FREE */
G_TYPE_UINT64, /* DISK_AVAIL */
G_TYPE_UINT64, /* DISK_USED */
GDK_TYPE_PIXBUF, /* DISK_ICON */
G_TYPE_INT /* DISK_USED_PERCENTAGE */
);
disk_tree = gsm_tree_view_new (g_settings_get_child (app->settings->gobj(), GSM_SETTINGS_CHILD_DISKS), TRUE);
gtk_tree_view_set_model (GTK_TREE_VIEW (disk_tree), GTK_TREE_MODEL (model));
g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL);
app->disk_list = disk_tree;
gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET (disk_tree));
g_object_unref(G_OBJECT(model));
/* icon + device */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON,
NULL);
cell = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE,
NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE]));
gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col);
/* sizes - used */
for (i = DISK_DIR; i <= DISK_AVAIL; i++) {
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_title(col, _(titles[i]));
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, i);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col);
switch (i) {
case DISK_TOTAL:
case DISK_FREE:
case DISK_AVAIL:
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_si_cell_data_func,
GUINT_TO_POINTER(i),
NULL);
break;
default:
gtk_tree_view_column_set_attributes(col, cell,
"text", i,
NULL);
break;
}
}
/* used + percentage */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_text_new();
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_si_cell_data_func,
GUINT_TO_POINTER(DISK_USED),
NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_USED]));
cell = gtk_cell_renderer_progress_new();
gtk_cell_renderer_set_padding(cell, 4.0f, 4.0f);
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_attributes(col, cell, "value",
DISK_USED_PERCENTAGE, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, DISK_USED);
gtk_tree_view_column_set_reorderable(col, TRUE);
gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col);
/* numeric sort */
gsm_tree_view_load_state (GSM_TREE_VIEW (disk_tree));
g_signal_connect (G_OBJECT(disk_tree), "destroy",
G_CALLBACK(cb_disk_list_destroying),
app);
g_signal_connect (G_OBJECT(disk_tree), "columns-changed",
G_CALLBACK(cb_disk_columns_changed), app);
g_signal_connect (G_OBJECT (model), "sort-column-changed",
G_CALLBACK (cb_sort_changed), app);
app->settings->signal_changed(GSM_SETTING_SHOW_ALL_FS).connect ([app](const Glib::ustring&) { disks_update (app); disks_reset_timeout (app); });
gtk_widget_show (GTK_WIDGET (disk_tree));
}
GtkWidget*
listview__new()
{
//the main pane. A treeview with a list of samples.
LibraryView* lv = app->libraryview = g_new0(LibraryView, 1);
lv->scroll = scrolled_window_new();
GtkWidget* view = app->libraryview->widget = gtk_tree_view_new_with_model(GTK_TREE_MODEL(samplecat.store));
gtk_container_add(GTK_CONTAINER(lv->scroll), view);
g_signal_connect(view, "realize", G_CALLBACK(listview__on_realise), NULL);
g_signal_connect(view, "motion-notify-event", (GCallback)listview__on_motion, NULL);
g_signal_connect(view, "drag-data-received", G_CALLBACK(listview__drag_received), NULL); //currently the window traps this before we get here.
g_signal_connect(view, "drag-motion", G_CALLBACK(drag_motion), NULL);
#if 0 // TODO why does this not work?
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(view), TRUE);
#endif
//set up as dnd source:
gtk_drag_source_set(view, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
dnd_file_drag_types, dnd_file_drag_types_count,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_ASK);
g_signal_connect(G_OBJECT(view), "drag_data_get", G_CALLBACK(listview__dnd_get), NULL);
//icon:
GtkCellRenderer* cell9 = gtk_cell_renderer_pixbuf_new();
GtkTreeViewColumn* col9 /*= app->col_icon*/ = gtk_tree_view_column_new_with_attributes("", cell9, "pixbuf", COL_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col9);
//g_object_set(cell4, "cell-background", "Orange", "cell-background-set", TRUE, NULL);
g_object_set(G_OBJECT(cell9), "xalign", 0.0, NULL);
gtk_tree_view_column_set_resizable(col9, TRUE);
gtk_tree_view_column_set_min_width(col9, 0);
gtk_tree_view_column_set_cell_data_func(col9, cell9, listview__cell_data_bg, NULL, NULL);
#ifdef SHOW_INDEX
GtkCellRenderer* cell0 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col0 = gtk_tree_view_column_new_with_attributes("Id", cell0, "text", COL_IDX, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col0);
#endif
GtkCellRenderer* cell1 = lv->cells.name = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col1 = lv->col_name = gtk_tree_view_column_new_with_attributes("Sample Name", cell1, "text", COL_NAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col1);
gtk_tree_view_column_set_sort_column_id(col1, COL_NAME);
gtk_tree_view_column_set_reorderable(col1, TRUE);
gtk_tree_view_column_set_min_width(col1, 0);
//gtk_tree_view_column_set_spacing(col1, 10);
//g_object_set(cell1, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col1, cell1, (gpointer)listview__cell_data_bg, NULL, NULL);
//gtk_tree_view_column_set_cell_data_func(col1, cell1, (gpointer)cell_bg_lighter, NULL, NULL);
gtk_tree_view_column_set_sizing(col1, GTK_TREE_VIEW_COLUMN_FIXED);
int width = atoi(app->config.column_widths[0]);
if(width > 0) gtk_tree_view_column_set_fixed_width(col1, MAX(width, 30)); //FIXME set range in config section instead.
else gtk_tree_view_column_set_fixed_width(col1, 130);
GtkCellRenderer* cell2 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col2 = lv->col_path = gtk_tree_view_column_new_with_attributes("Path", cell2, "text", COL_FNAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col2);
gtk_tree_view_column_set_sort_column_id(col2, COL_FNAME);
//gtk_tree_view_column_set_resizable(col2, FALSE);
gtk_tree_view_column_set_reorderable(col2, TRUE);
gtk_tree_view_column_set_min_width(col2, 0);
//g_object_set(cell2, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col2, cell2, listview__path_cell_data, NULL, NULL);
#ifdef USE_AYYI
//icon that shows when file is in current active song.
GtkCellRenderer* ayyi_renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col2, ayyi_renderer, FALSE);
gtk_tree_view_column_add_attribute(col2, ayyi_renderer, "pixbuf", COL_AYYI_ICON);
//gtk_tree_view_column_set_cell_data_func(col2, ayyi_renderer, vdtree_color_cb, vdt, NULL);
#endif
gtk_tree_view_column_set_sizing(col2, GTK_TREE_VIEW_COLUMN_FIXED);
width = atoi(app->config.column_widths[1]);
if(width > 0) gtk_tree_view_column_set_fixed_width(col2, MAX(width, 30));
else gtk_tree_view_column_set_fixed_width(col2, 130);
//GtkCellRenderer *cell3 /*= app->cell_tags*/ = gtk_cell_renderer_text_new();
GtkCellRenderer* cell3 = lv->cells.tags = gtk_cell_renderer_hyper_text_new();
GtkTreeViewColumn* column3 = lv->col_tags = gtk_tree_view_column_new_with_attributes("Tags", cell3, "text", COL_KEYWORDS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column3);
gtk_tree_view_column_set_sort_column_id(column3, COL_KEYWORDS);
gtk_tree_view_column_set_resizable(column3, TRUE);
gtk_tree_view_column_set_reorderable(column3, TRUE);
gtk_tree_view_column_set_min_width(column3, 0);
g_object_set(cell3, "editable", TRUE, NULL);
g_signal_connect(cell3, "edited", (GCallback)listview__on_keywords_edited, NULL);
gtk_tree_view_column_add_attribute(column3, cell3, "markup", COL_KEYWORDS);
gtk_tree_view_column_set_cell_data_func(column3, cell3, listview__tag_cell_data, NULL, NULL);
GtkCellRenderer* cell4 = gtk_cell_renderer_pixbuf_new();
GtkTreeViewColumn* col4 = lv->col_pixbuf = gtk_tree_view_column_new_with_attributes("Overview", cell4, "pixbuf", COL_OVERVIEW, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col4);
//g_object_set(cell4, "cell-background", "Orange", "cell-background-set", TRUE, NULL);
g_object_set(G_OBJECT(cell4), "xalign", 0.0, NULL);
gtk_tree_view_column_set_resizable(col4, TRUE);
gtk_tree_view_column_set_min_width(col4, 0);
//g_object_set(cell4, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col4, cell4, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell5 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col5 = gtk_tree_view_column_new_with_attributes("Length", cell5, "text", COL_LENGTH, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col5);
gtk_tree_view_column_set_sort_column_id(col5, COL_LEN);
gtk_tree_view_column_set_resizable(col5, TRUE);
gtk_tree_view_column_set_reorderable(col5, TRUE);
gtk_tree_view_column_set_min_width(col5, 0);
g_object_set(G_OBJECT(cell5), "xalign", 1.0, NULL);
//g_object_set(cell5, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col5, cell5, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell6 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col6 = gtk_tree_view_column_new_with_attributes("Srate", cell6, "text", COL_SAMPLERATE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col6);
gtk_tree_view_column_set_resizable(col6, TRUE);
gtk_tree_view_column_set_reorderable(col6, TRUE);
gtk_tree_view_column_set_min_width(col6, 0);
g_object_set(G_OBJECT(cell6), "xalign", 1.0, NULL);
//g_object_set(cell6, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col6, cell6, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell7 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col7 = gtk_tree_view_column_new_with_attributes("Chs", cell7, "text", COL_CHANNELS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col7);
gtk_tree_view_column_set_resizable(col7, TRUE);
gtk_tree_view_column_set_reorderable(col7, TRUE);
gtk_tree_view_column_set_min_width(col7, 0);
g_object_set(G_OBJECT(cell7), "xalign", 1.0, NULL);
gtk_tree_view_column_set_cell_data_func(col7, cell7, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell8 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col8 = gtk_tree_view_column_new_with_attributes("Mimetype", cell8, "text", COL_MIMETYPE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col8);
gtk_tree_view_column_set_resizable(col8, TRUE);
gtk_tree_view_column_set_reorderable(col8, TRUE);
gtk_tree_view_column_set_min_width(col8, 0);
//g_object_set(G_OBJECT(cell8), "xalign", 1.0, NULL);
gtk_tree_view_column_set_cell_data_func(col8, cell8, listview__cell_data_bg, NULL, NULL);
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(view), COL_NAME);
g_signal_connect((gpointer)view, "button-press-event", G_CALLBACK(listview__on_row_clicked), NULL);
g_signal_connect((gpointer)view, "cursor-changed", G_CALLBACK(listview__on_cursor_change), NULL);
g_signal_connect(G_OBJECT(samplecat.store), "content-changed", G_CALLBACK(listview__on_store_changed), NULL);
#if 0
void on_unrealize(GtkWidget* widget, gpointer user_data)
{
PF0;
}
g_signal_connect((gpointer)view, "unrealize", G_CALLBACK(on_unrealize), NULL);
#endif
void listview_on_play(GObject* _app, gpointer _)
{
if(app->play.sample->row_ref){
listview__highlight_playing_by_ref(app->play.sample->row_ref);
}
}
g_signal_connect(app, "play-start", (GCallback)listview_on_play, NULL);
void on_sort_order_changed(GtkTreeSortable* sortable, gpointer user_data)
{
gint sort_column_id;
GtkSortType order;
if(gtk_tree_sortable_get_sort_column_id(sortable, &sort_column_id, &order)){
if(sort_column_id == COL_LEN){
int n_rows = ((SamplecatListStore*)samplecat.store)->row_count;
if(n_rows >= LIST_STORE_MAX_ROWS){
dbg(0, "TODO need to requery database ordered by length...");
}
}
}
}
static void
trg_tree_view_add_column_after(TrgTreeView * tv,
trg_column_description * desc,
gint64 width, GtkTreeViewColumn * after_col)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column = NULL;
GtkButton *column_button = NULL;
switch (desc->type) {
case TRG_COLTYPE_TEXT:
renderer =
desc->customRenderer ? desc->customRenderer :
gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer, "text",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_SPEED:
renderer = trg_cell_renderer_speed_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"speed-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_EPOCH:
renderer = trg_cell_renderer_epoch_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"epoch-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_ETA:
renderer = trg_cell_renderer_eta_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"eta-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_SIZE:
renderer = trg_cell_renderer_size_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"size-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_PROG:
renderer = gtk_cell_renderer_progress_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_RATIO:
renderer = trg_cell_renderer_ratio_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"ratio-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_WANTED:
column = gtk_tree_view_column_new();
renderer = trg_cell_renderer_wanted_new();
/*gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), 0.5f,
0.0); */
gtk_tree_view_column_set_title(column, desc->header);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer,
"wanted-value",
desc->model_column, NULL);
break;
case TRG_COLTYPE_ICONTEXT:
column = trg_tree_view_icontext_column_new(desc, "icon-name");
break;
case TRG_COLTYPE_FILEICONTEXT:
column = trg_tree_view_fileicontext_column_new(desc);
break;
case TRG_COLTYPE_PRIO:
renderer = trg_cell_renderer_priority_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"priority-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_NUMGTZERO:
renderer = trg_cell_renderer_numgteqthan_new(1);
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_NUMGTEQZERO:
renderer = trg_cell_renderer_numgteqthan_new(0);
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"value",
desc->
model_column,
NULL);
break;
default:
g_critical("unknown TrgTreeView column");
return;
}
//gtk_tree_view_column_set_min_width(column, 0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, desc->model_column);
gtk_tree_view_column_set_expand(column, TRUE);
/*gtk_tree_view_column_set_sizing(column,
GTK_TREE_VIEW_COLUMN_FIXED);*/
if (width > 0) {
//gtk_tree_view_column_set_fixed_width(column, width);
}
g_object_set_data(G_OBJECT(column), GDATA_KEY_COLUMN_DESC, desc);
gtk_tree_view_append_column(GTK_TREE_VIEW(tv), column);
if (after_col)
gtk_tree_view_move_column_after(GTK_TREE_VIEW(tv), column,
after_col);
column_button = GTK_BUTTON(gtk_tree_view_column_get_button(column));
g_signal_connect(column_button,
"button-press-event", G_CALLBACK(col_onButtonPressed),
desc);
if (desc->out)
*(desc->out) = column;
desc->flags |= TRG_COLUMN_SHOWING;
}
void user_install_dialog_create(UserInstallCallback callback)
{
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *ebox;
GtkWidget *table;
GtkWidget *darea;
GtkWidget *page;
GtkWidget *sep;
PangoFontDescription *large_font_desc;
gchar* Version_S = g_strdup_printf("%d.%d.%d",MAJOR_VERSION,MINOR_VERSION,MICRO_VERSION);
gchar* temp = NULL;
dialog = user_install_dialog = gtk_dialog_new ();
gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_CENTER);
gtk_window_set_title(>K_DIALOG(dialog)->window,_("Gabedit User Installation"));
gtk_widget_realize (dialog);
set_icone(GTK_WIDGET(dialog));
action_area = gtk_hbox_new(FALSE, 8);
gtk_box_set_homogeneous(GTK_BOX(action_area), FALSE);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), action_area);
/* B/W Style for the page contents */
page_style = gtk_style_copy(gtk_widget_get_default_style());
colormap = gtk_widget_get_colormap(dialog);
black_color.red = 0;
black_color.green = 0;
black_color.blue = 0;
gdk_colormap_alloc_color (colormap, &black_color, FALSE, TRUE);
white_color.red = 65535;
white_color.green = 65535;
white_color.blue = 65535;
gdk_colormap_alloc_color (colormap, &white_color, FALSE, TRUE);
page_style->fg[GTK_STATE_NORMAL] = black_color;
page_style->text[GTK_STATE_NORMAL] = black_color;
page_style->bg[GTK_STATE_NORMAL] = white_color;
/*
gdk_font_unref(page_style->font);
page_style->font = dialog->style->font;
gdk_font_ref(page_style->font);
*/
/* B/Colored Style for the page title */
title_style = gtk_style_copy(page_style);
if (gdk_color_parse("royal blue", &title_color) && gdk_colormap_alloc_color(colormap, &title_color, FALSE, TRUE))
{
title_style->bg[GTK_STATE_NORMAL] = title_color;
}
large_font_desc = pango_font_description_from_string ("sans bold 20");
if (large_font_desc)
{
title_style->font_desc = large_font_desc;
}
/* W/W GC for the corner */
white_gc = gdk_gc_new(dialog->window);
gdk_gc_set_foreground(white_gc, &white_color);
TITLE_STYLE(dialog);
footer_label = gtk_label_new(NULL);
PAGE_STYLE(footer_label);
gtk_label_set_justify(GTK_LABEL(footer_label), GTK_JUSTIFY_RIGHT);
gtk_box_pack_start(GTK_BOX(action_area), footer_label, FALSE, FALSE, 8);
gtk_widget_show(footer_label);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), vbox);
ebox = gtk_event_box_new();
TITLE_STYLE(ebox);
gtk_widget_set_events(ebox, GDK_EXPOSURE_MASK);
gtk_widget_set_size_request(ebox, WILBER_WIDTH + 16, -1);
gtk_box_pack_start(GTK_BOX(vbox), ebox, FALSE, FALSE, 0);
gtk_widget_show(ebox);
hbox = gtk_hbox_new(FALSE, 8);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
gtk_container_add(GTK_CONTAINER(ebox), hbox);
gtk_widget_show(hbox);
title_pixmap = create_pixmap(dialog,gabedit_xpm);
gtk_box_pack_start(GTK_BOX(hbox), title_pixmap, FALSE, FALSE, 8);
gtk_widget_show(title_pixmap);
title_label = gtk_label_new(NULL);
TITLE_STYLE(title_label);
gtk_label_set_justify(GTK_LABEL(title_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(hbox), title_label, FALSE, FALSE, 0);
gtk_widget_show(title_label);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
ebox = gtk_event_box_new();
TITLE_STYLE(ebox);
gtk_widget_set_size_request(ebox, 16, -1);
gtk_box_pack_start(GTK_BOX(hbox), ebox, FALSE, FALSE, 0);
gtk_widget_show(ebox);
ebox = gtk_event_box_new();
PAGE_STYLE(ebox);
gtk_box_pack_start(GTK_BOX(hbox), ebox, TRUE, TRUE, 0);
gtk_widget_show(ebox);
table = gtk_table_new(3, 3, FALSE);
gtk_table_set_col_spacing(GTK_TABLE(table), 1, 8);
gtk_container_add(GTK_CONTAINER(ebox), table);
gtk_widget_show(table);
darea = gtk_drawing_area_new();
TITLE_STYLE(darea);
gtk_widget_set_size_request(GTK_WIDGET(darea), 16, 16);
g_signal_connect_after(G_OBJECT(darea), "expose_event",
(GCallback)user_install_corner_expose,
(gpointer)GTK_CORNER_TOP_LEFT);
gtk_table_attach(GTK_TABLE(table), darea, 0,1, 0,1,
GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show(darea);
darea = gtk_drawing_area_new();
TITLE_STYLE(darea);
gtk_widget_set_size_request(GTK_WIDGET(darea), 16, 16);
g_signal_connect_after(G_OBJECT(darea), "expose_event",
(GCallback)user_install_corner_expose,
(gpointer)GTK_CORNER_BOTTOM_LEFT);
gtk_table_attach(GTK_TABLE(table), darea, 0,1, 2,3,
GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show(darea);
notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
gtk_table_attach_defaults(GTK_TABLE(table), notebook, 1,2, 1,2);
gtk_widget_show(notebook);
gtk_widget_show(vbox);
/* Page 1 */
temp = g_strdup_printf("Welcome to The GABEDIT %s User Installation",Version_S);
g_free(Version_S);
page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
temp,
_("Click \"Continue\" to enter the GABEDIT user installation."));
add_label(GTK_BOX(page),
_(
"Gabedit is a Graphical User Interface to FireFly, Gamess-US, Gaussian, Molcas, Molpro, \nMopac, MPQC , NWChem, Orca, Psicode and Q-Chem\n"
"computational chemistry packages.\n"
"It can display a variety of calculation results including support for most major molecular file formats.\n"
"The advanced 'Molecule Builder' allows to rapidly sketch in molecules and examine them in 3D\n"
"Graphics can be exported to various formats, including animations\n"
"\n"
"Gabedit can creates input file for the computational chemistry packages(CCP) cited above.\n"
"Gabedit can graphically display a variety of the CCP calculation results\n"
"Gabedit can display UV-Vis, IR and Raman computed spectra.\n"
"Gabedit can generate a povray file for geometry, surfaces, contours, planes colorcoded.\n"
"Gabedit can save picture in BMP, JPEG, PNG, PPM, PDF and PS format.\n"
"It can generate automatically a series of pictures for animation(vibration, geometry convergence, ....).\n"
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show(sep);
add_label(GTK_BOX(page),
_(
"Copyright (c) 2002-2013 Abdul-Rahman Allouche.\n"
"All rights reserved.\n"
"\nGabedit is free.\n"
)
);
/* Page 2 */
{
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *notebook2;
GtkWidget *page2;
GtkWidget *label;
GtkTreeIter main_node;
GtkTreeIter sub_node;
gchar *str;
GtkTreeStore *store;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget* treeView;
GtkTreeSelection *select;
gint i;
gchar *node[1];
set_pixbuf();
page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("Personal GABEDIT Directory"),
_(
"Click \"Continue\" to create "
"your personal GABEDIT directory.")
);
hbox = gtk_hbox_new(FALSE, 8);
gtk_box_pack_start(GTK_BOX(page), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
store = gtk_tree_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
model = GTK_TREE_MODEL (store);
treeView = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeView), FALSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeView), FALSE);
PAGE_STYLE(treeView);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, " ");
gtk_tree_view_column_set_reorderable(column, FALSE);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", LIST_PIXBUF);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_add_attribute (column, renderer, "text", LIST_NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), column);
gtk_box_pack_start(GTK_BOX(hbox), treeView, FALSE, FALSE, 0);
gtk_widget_show(treeView);
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show(vbox);
str = g_strdup_printf(_("For a proper GABEDIT installation, a subdirectory named\n"
"%s needs to be created."), gabedit_directory());
add_label(GTK_BOX(vbox), str);
g_free(str);
add_label(GTK_BOX(vbox),
_(
"This subdirectory will contain a number of important files.\n"
"Click on one of the files or subdirectories in the tree\n"
"to get more information about the selected item."
)
);
notebook2 = gtk_notebook_new();
gtk_container_set_border_width(GTK_CONTAINER(notebook2), 8);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook2), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook2), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), notebook2, TRUE, TRUE, 0);
gtk_widget_show(notebook2);
/* empty page */
page2 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(page2);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook2), page2, NULL);
node[0] = (gchar *)gabedit_directory();
gtk_tree_store_append(store, &main_node, NULL);
gtk_tree_store_set (store, &main_node, LIST_NAME, node[0], -1);
gtk_tree_store_set (store, &main_node, LIST_PIXBUF, bookPixbuf, -1);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeView));
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (select), "changed", G_CALLBACK (user_install_treeview_select_row), notebook2);
for (i = 0; i < num_tree_items; i++)
{
node[0] = tree_items[i].text;
if (tree_items[i].directory)
{
gtk_tree_store_append(store, &sub_node, &main_node);
gtk_tree_store_set (store, &sub_node, LIST_NAME, node[0], -1);
gtk_tree_store_set (store, &sub_node, LIST_PIXBUF, bookPixbuf, -1);
} else
{
gtk_tree_store_append(store, &sub_node, &main_node);
gtk_tree_store_set (store, &sub_node, LIST_NAME, node[0], -1);
gtk_tree_store_set (store, &sub_node, LIST_PIXBUF, pagePixbuf, -1);
}
page2 = gtk_vbox_new(FALSE, 0);
label = gtk_label_new(tree_items[i].description);
PAGE_STYLE(label);
PAGE_STYLE(label);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(page2), label, TRUE, TRUE, 0);
gtk_widget_show(label);
gtk_widget_show(page2);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook2), page2, NULL);
}
{
GtkTreePath *path = gtk_tree_path_new_from_string ("0");
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(treeView), path);
gtk_tree_path_free(path);
}
}
/* Page 3 */
page = log_page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("Creation of Directories"),
NULL);
/* Page 4 */
page = prop_page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Atoms Properties"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(page),_("Setting for atoms properties."));
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show(sep);
/* Page 5 */
page = commands_network_page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Commands/Network"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(commands_network_page),
_(
"To execute FireFly, Gamess-US, Gaussian, Molcas, Molpro, \nMopac, MPQC, NWChem, Orca, Psicode and Q-Chem program, "
"GABEDIT needs to know commands system.\n"
"GABEDIT needs to know network protocols.\n"
"You can change them after installation (Settings/Preferences)."
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
/* Page 6 */
page = fontscolors_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Fonts/Colors setting"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(fontscolors_page),
_(
"Setting for Text Font and Text Colors, "
"GABEDIT needs to know the defaults Fonts/Colors for Data and Result editors."
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
/* Page 7 */
page = colorsurfaces_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Color Surfaces setting"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(colorsurfaces_page),
_("Setting for color surfaces, "
"GABEDIT needs to know the defaults Color for surfaces(density,Orbitals,....)."
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
/* Page 8 */
page = molpro_basis_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of molpro basis list file"),
_("Click \"Continue\" for next page."));
add_label(GTK_BOX(molpro_basis_page),
_(
"If the libmol program (delivered with molpro) is not installed on your local host,\n"
"GABEDIT uses this file for get the list of basis(only the names of basis)supported by molpro.\n"
"Please note that this file contains the list of basis supported by molpro2002.6."
)
);
/* Page 9 */
page = molcas_basis_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of molcas basis list file"),
_("Click \"Continue\" for next page."));
add_label(GTK_BOX(molcas_basis_page),
_(
"GABEDIT uses this file for get the list of basis(only the names of basis)supported by molcas.\n"
"Please note that this file contains the list of basis supported by Molcas7."
)
);
/* Page 10 */
page = mpqc_basis_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of mpqc basis list file"),
_("Click \"Continue\" for next page."));
add_label(GTK_BOX(mpqc_basis_page),
_(
"GABEDIT uses this file for get the list of basis(only the names of basis)supported by MPQC.\n"
"Please note that this file contains the list of basis supported by MPQC2.2.2."
)
);
/* Page 11 */
page = mm_file_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of Molecular Mechanics file"),
_("Click \"Continue\" to start GABEDIT."));
add_label(GTK_BOX(mm_file_page),
_("Gabedit use this file for load molecular mechanics parameters "));
/* EEK page */
page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("Aborting Installation..."),
NULL);
user_install_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
create_buttons_dialog(dialog,callback);
gtk_widget_show_all(dialog);
}
