static rc_t passes_loader( ld_context * lctx, KDirectory * hdf5_src, VCursor * cursor, const char * table_name )
{
uint32_t col_idx[ passes_tab_count ];
rc_t rc = add_columns( cursor, passes_tab_count, -1, col_idx, passes_tab_names );
if ( rc == 0 )
{
rc = VCursorOpen( cursor );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot open cursor on PASSES-tab" );
else
{
Passes_src Passes;
rc = open_Passes_src( hdf5_src, &Passes,
"PulseData/ConsensusBaseCalls/Passes",
lctx->cache_content );
if ( rc == 0 )
{
if ( check_Passes_extents( &Passes ) )
rc = passes_load_loop( lctx, cursor, &Passes, col_idx );
else
rc = RC( rcExe, rcNoTarg, rcAllocating, rcParam, rcInvalid );
close_Passes_src( &Passes );
}
}
}
return rc;
}
nomad_fits* nomad_fits_open_for_writing(char* fn) {
nomad_fits* cat;
qfits_header* hdr;
cat = fitstable_open_for_writing(fn);
if (!cat)
return NULL;
add_columns(cat, TRUE);
hdr = fitstable_get_primary_header(cat);
qfits_header_add(hdr, "NOMAD", "T", "This is a NOMAD 1.0 catalog.", NULL);
qfits_header_add(hdr, "AN_FILE", AN_FILETYPE_NOMAD, "Astrometry.net file type", NULL);
qfits_header_add(hdr, "COMMENT", "The FLAGS variable is composed of 15 boolean values packed into 2 bytes.", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " Byte 0:", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x80: UBBIT / usnob_fail", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x40: TMBIT / twomass_fail", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x20: TYBIT / tycho_astrometry", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x10: XRBIT / alt_radec", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x08: IUCBIT / alt_ucac", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x04: ITYBIT / alt_tycho", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x02: OMAGBIT / blue_o", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x01: EMAGBIT / red_e", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " Byte 1:", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x80: TMONLY / twomass_only", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x40: HIPAST / hipp_astrometry", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x20: SPIKE / diffraction", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x10: TYCONF / confusion", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x08: BSCONF / bright_confusion", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x04: BSART / bright_artifact", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x02: USEME / standard", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x01: unused", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " Note that the ITMBIT and EXCAT bits were not set for any entry in the ", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " released NOMAD catalog, so were not included here.", NULL, NULL);
return cat;
}
static rc_t consensus_loader( ld_context *lctx, const char * table_name,
bool cache_content )
{
uint32_t col_idx[ consensus_tab_count ];
rc_t rc = add_columns( lctx->cursor, consensus_tab_count, -1,
col_idx, consensus_tab_names );
if ( rc == 0 )
{
rc = VCursorOpen( lctx->cursor );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot open cursor on consensus-table" );
else
{
BaseCalls_cmn ConsensusTab;
const INSDC_SRA_platform_id platform = SRA_PLATFORM_PACBIO_SMRT;
rc = VCursorDefault ( lctx->cursor, col_idx[ consensus_tab_PLATFORM ],
sizeof platform * 8, &platform, 0, 1 );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot set cursor-default on consensus-table for platform-column" );
else
{
const INSDC_SRA_read_filter filter = SRA_READ_FILTER_PASS;
rc = VCursorDefault ( lctx->cursor, col_idx[ consensus_tab_READ_FILTER ],
sizeof filter * 8, &filter, 0, 1 );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot set cursor-default on consensus-table for read-filter-column" );
}
if ( rc == 0 )
rc = open_BaseCalls_cmn( lctx->hdf5_dir, &ConsensusTab, true,
"PulseData/ConsensusBaseCalls", cache_content, true );
if ( rc == 0 )
{
uint64_t total_bases = zmw_total( &ConsensusTab.zmw );
uint64_t total_spots = ConsensusTab.zmw.NumEvent.extents[ 0 ];
KLogLevel tmp_lvl = KLogLevelGet();
KLogLevelSet( klogInfo );
PLOGMSG( klogInfo, ( klogInfo,
"loading consensus-table ( $(bases) bases / $(spots) spots ):",
"bases=%lu,spots=%lu", total_bases, total_spots ));
KLogLevelSet( tmp_lvl );
if ( check_Consensus_totalcount( &ConsensusTab, total_bases ) )
rc = zmw_for_each( &ConsensusTab.zmw, lctx, col_idx, NULL,
true, consensus_load_spot, &ConsensusTab );
else
rc = RC( rcExe, rcNoTarg, rcAllocating, rcParam, rcInvalid );
close_BaseCalls_cmn( &ConsensusTab );
}
}
}
return rc;
}
matchfile* matchfile_open_for_writing(char* fn) {
matchfile* mf;
qfits_header* hdr;
mf = fitstable_open_for_writing(fn);
if (!mf)
return NULL;
add_columns(mf, TRUE);
hdr = fitstable_get_primary_header(mf);
qfits_header_add(hdr, "AN_FILE", AN_FILETYPE_MATCH, "Astrometry.net file type", NULL);
return mf;
}
static GtkWidget *
create_accounts_list(AccountsWindow *dialog)
{
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeSelection *sel;
GtkTargetEntry gte[] = {{"PURPLE_ACCOUNT", GTK_TARGET_SAME_APP, 0}};
/* Create the scrolled window. */
sw = gtk_scrolled_window_new(0, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN);
gtk_widget_show(sw);
/* Create the list model. */
dialog->model = gtk_list_store_new(NUM_COLUMNS,
GDK_TYPE_PIXBUF, G_TYPE_STRING,
G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER,
G_TYPE_POINTER);
/* And now the actual treeview */
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dialog->model));
dialog->treeview = treeview;
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
g_signal_connect(G_OBJECT(sel), "changed",
G_CALLBACK(account_selected_cb), dialog);
gtk_container_add(GTK_CONTAINER(sw), treeview);
gtk_widget_show(treeview);
add_columns(treeview, dialog);
populate_accounts_list(dialog);
/* Setup DND. I wanna be an orc! */
gtk_tree_view_enable_model_drag_source(
GTK_TREE_VIEW(treeview), GDK_BUTTON1_MASK, gte,
1, GDK_ACTION_COPY);
gtk_tree_view_enable_model_drag_dest(
GTK_TREE_VIEW(treeview), gte, 1,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(treeview), "drag-data-received",
G_CALLBACK(drag_data_received_cb), dialog);
g_signal_connect(G_OBJECT(treeview), "drag-data-get",
G_CALLBACK(drag_data_get_cb), dialog);
return sw;
}
static void create_search_results_page(GtkWidget *notebook)
{
GtkWidget *scrolledwindow3;
GtkTreeSelection *selection;
sidebar.menu_item_save_search = create_results_menu();
scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow3);
gtk_container_add(GTK_CONTAINER(notebook), scrolledwindow3);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow3),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow *)
scrolledwindow3,
settings.shadow_type);
/* create list model */
model_verselist = gtk_list_store_new(1, G_TYPE_STRING);
sidebar.results_list =
gtk_tree_view_new_with_model(GTK_TREE_MODEL(model_verselist));
gtk_widget_show(sidebar.results_list);
gtk_container_add(GTK_CONTAINER(scrolledwindow3),
sidebar.results_list);
#ifndef HAVE_GTK_310
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(sidebar.results_list),
TRUE);
#endif
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(sidebar.results_list), FALSE);
add_columns(GTK_TREE_VIEW(sidebar.results_list));
selection =
gtk_tree_view_get_selection(GTK_TREE_VIEW(sidebar.results_list));
g_signal_connect((gpointer)sidebar.results_list,
"key_press_event",
G_CALLBACK(tree_key_press_cb), NULL);
g_signal_connect((gpointer)selection,
"changed",
G_CALLBACK(tree_selection_changed_cb), NULL);
g_signal_connect((gpointer)sidebar.results_list,
"button_release_event",
G_CALLBACK(gui_verselist_button_release_event),
NULL);
g_signal_connect((gpointer)sidebar.results_list,
"button_press_event",
G_CALLBACK(on_treeview_button_press_event), NULL);
}
/* special case for SEQUENCE: in order to prepare the cursor correctly, we have to know the first HDF5-source-obj !*/
rc_t prepare_seq( VDatabase * database, seq_ctx * sctx, KDirectory * hdf5_src, ld_context *lctx )
{
rc_t rc = prepare_table( database, &sctx->cursor, seq_schema_template, seq_table_to_create ); /* pl-tools.c ... this creates the cursor */
sctx->src_open = false;
if ( rc == 0 )
{
rc = open_BaseCalls( hdf5_src, &sctx->BaseCallsTab, "PulseData/BaseCalls", lctx->cache_content, &sctx->rgn_present );
if ( rc == 0 )
{
int32_t to_exclude;
/* depending on the bit-size of the PulseIndex-table in HDF5
exclude the opposite column from VDB */
if ( sctx->BaseCallsTab.PulseIndex.element_bits == PULSE_INDEX_BITSIZE_16 )
to_exclude = seq_tab_PULSE_INDEX_32;
else
to_exclude = seq_tab_PULSE_INDEX_16;
/* add all columns to the vdb-cursor */
rc = add_columns( sctx->cursor, seq_tab_count, to_exclude, sctx->col_idx, seq_tab_names );
if ( rc == 0 )
{
rc = VCursorOpen( sctx->cursor );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "cannot open cursor on seq-table" );
}
else
{
const uint8_t platform = SRA_PLATFORM_PACBIO_SMRT;
rc = VCursorDefault ( sctx->cursor, sctx->col_idx[ seq_tab_PLATFORM ], 8, &platform, 0, 1 );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "cannot set cursor-default on seq-table for platform-column" );
}
else
{
sctx->src_open = true;
sctx->lctx = lctx;
}
}
}
}
}
return rc;
}
void
table_create (void)
{
GtkWidget *runlevel_table = gst_dialog_get_widget (tool->main_dialog, "services_list");
GtkTreeModel *model;
GtkTreeSelection *selection;
model = create_model ();
gtk_tree_view_set_model (GTK_TREE_VIEW (runlevel_table), model);
g_object_unref (G_OBJECT (model));
add_columns (GTK_TREE_VIEW (runlevel_table));
table_popup_menu_create (GTK_TREE_VIEW (runlevel_table));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (runlevel_table));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
}
void todo_init()
{
todo = g_new(GtkToDo, 1);
todo->dialog = NULL;
todo->store = gtk_tree_store_new(TODO_NCOLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_INT);
/* TreeView */
todo->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(todo->store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(todo->treeview), TRUE);
add_columns(todo->treeview);
populate_model(todo->store);
}
matchfile* matchfile_open(const char* fn) {
matchfile* mf = NULL;
mf = fitstable_open(fn);
if (!mf)
return NULL;
add_columns(mf, FALSE);
fitstable_use_buffered_reading(mf, sizeof(MatchObj), 1000);
mf->postprocess_read_structs = postprocess_read_structs;
if (fitstable_read_extension(mf, 1)) {
fprintf(stderr, "matchfile: table in extension 1 didn't contain the required columns.\n");
fprintf(stderr, " missing: ");
fitstable_print_missing(mf, stderr);
fprintf(stderr, "\n");
matchfile_close(mf);
return NULL;
}
return mf;
}
nomad_fits* nomad_fits_open(char* fn) {
nomad_fits* cat = NULL;
cat = fitstable_open(fn);
if (!cat)
return NULL;
add_columns(cat, FALSE);
fitstable_use_buffered_reading(cat, sizeof(nomad_entry), 1000);
cat->postprocess_read_structs = postprocess_read_structs;
if (fitstable_read_extension(cat, 1)) {
fprintf(stderr, "nomad-fits: table in extension 1 didn't contain the required columns.\n");
fprintf(stderr, " missing: ");
fitstable_print_missing(cat, stderr);
fprintf(stderr, "\n");
nomad_fits_close(cat);
return NULL;
}
return cat;
}
rc_t prepare_consensus( VDatabase * database, con_ctx * sctx, ld_context *lctx )
{
rc_t rc = prepare_table( database, &sctx->cursor,
consensus_schema_template, consensus_table_to_create ); /* pl-tools.c ... this creates the cursor */
if ( rc == 0 )
{
rc = add_columns( sctx->cursor, consensus_tab_count, -1, sctx->col_idx, consensus_tab_names );
if ( rc == 0 )
{
rc = VCursorOpen( sctx->cursor );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "cannot open cursor on consensus-table" );
}
else
{
const INSDC_SRA_platform_id platform = SRA_PLATFORM_PACBIO_SMRT;
rc = VCursorDefault ( sctx->cursor, sctx->col_idx[ consensus_tab_PLATFORM ],
sizeof platform * 8, &platform, 0, 1 );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "cannot set cursor-default on consensus-table for platform-column" );
}
else
{
const INSDC_SRA_read_filter filter = SRA_READ_FILTER_PASS;
rc = VCursorDefault ( sctx->cursor, sctx->col_idx[ consensus_tab_READ_FILTER ],
sizeof filter * 8, &filter, 0, 1 );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "cannot set cursor-default on consensus-table for read-filter-column" );
}
else
{
sctx->lctx = lctx;
}
}
}
}
}
return rc;
}
rc_t prepare_passes( VDatabase * database, pas_ctx * sctx, ld_context *lctx )
{
rc_t rc = prepare_table( database, &sctx->cursor,
passes_schema_template, passes_table_to_create ); /* pl-tools.c ... this creates the cursor */
if ( rc == 0 )
{
rc = add_columns( sctx->cursor, passes_tab_count, -1, sctx->col_idx, passes_tab_names );
if ( rc == 0 )
{
rc = VCursorOpen( sctx->cursor );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "cannot open cursor on PASSES-tab" );
}
else
{
sctx->lctx = lctx;
}
}
}
return rc;
}
BookmarkList *
bookmark_list_new (gboolean menu_icons)
{
BookmarkList *book_list;
GtkWidget *scrolled;
GtkTreeView *list_view;
book_list = g_new0 (BookmarkList, 1);
book_list->list = NULL;
book_list->menu_icons = menu_icons;
/* Create the widgets. */
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_ETCHED_IN);
book_list->list_store = gtk_list_store_new (BOOK_LIST_NUM_COLUMNS,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_STRING);
list_view = (GtkTreeView*) gtk_tree_view_new_with_model (GTK_TREE_MODEL (book_list->list_store));
gtk_tree_view_set_rules_hint (list_view, FALSE);
add_columns (list_view);
gtk_tree_view_set_headers_visible (list_view, FALSE);
gtk_tree_view_set_enable_search (list_view, TRUE);
gtk_tree_view_set_search_column (list_view, BOOK_LIST_COLUMN_NAME);
book_list->list_view = (GtkWidget*) list_view;
gtk_container_add (GTK_CONTAINER (scrolled), book_list->list_view);
book_list->root_widget = scrolled;
return book_list;
}
static rc_t seq_loader( ld_context *lctx, KDirectory * hdf5_src, VCursor * cursor, const char * table_name )
{
BaseCalls BaseCallsTab;
bool rgn_present;
/* opens all hdf5-tables, which are needed to load the sequence-table */
rc_t rc = open_BaseCalls( hdf5_src, &BaseCallsTab,
"PulseData/BaseCalls", lctx->cache_content, &rgn_present );
if ( rc == 0 )
{
/* calculates the total number of bases, according to the zmw-table */
uint64_t total_bases = zmw_total( &BaseCallsTab.cmn.zmw );
/* calculates the total number of spots, according to the zmw-table */
uint64_t total_spots = BaseCallsTab.cmn.zmw.NumEvent.extents[ 0 ];
KLogLevel tmp_lvl = KLogLevelGet();
KLogLevelSet( klogInfo );
PLOGMSG( klogInfo, ( klogInfo,
"loading sequence-table ( $(bases) bases / $(spots) spots ):",
"bases=%lu,spots=%lu", total_bases, total_spots ));
KLogLevelSet( tmp_lvl );
/* checks that all tables, which are loaded do have the correct
number of values (the number that the zmw-table requests) */
if ( check_BaseCall_totalcount( &BaseCallsTab, total_bases ) )
{
region_type_mapping mapping;
if ( rgn_present )
{
const KNamelist *region_types;
/* read the meta-data-entry "RegionTypes" of the hdf5-regions-table
into a KNamelist */
rc = KArrayFileGetMeta ( BaseCallsTab.rgn.hdf5_regions.af, "RegionTypes", ®ion_types );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "cannot read Regions.RegionTypes" );
}
else
{
/* extract the region-type-mapping out of the read KNamelist */
rc = rgn_extract_type_mappings( region_types, &mapping, false );
KNamelistRelease ( region_types );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "cannot map regions-types" );
}
}
}
if ( rc == 0 )
{
/* holds the vdb-column-index for every column we write */
uint32_t col_idx[ seq_tab_count ];
int32_t to_exclude;
/* depending on the bit-size of the PulseIndex-table in HDF5
exclude the opposite column from VDB */
if ( BaseCallsTab.PulseIndex.element_bits == PULSE_INDEX_BITSIZE_16 )
to_exclude = seq_tab_PULSE_INDEX_32;
else
to_exclude = seq_tab_PULSE_INDEX_16;
/* add all columns to the vdb-cursor */
rc = add_columns( cursor, seq_tab_count, to_exclude, col_idx, seq_tab_names );
if ( rc == 0 )
{
rc = VCursorOpen( cursor );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot open cursor on seq-table" );
else
{
const uint8_t platform = SRA_PLATFORM_PACBIO_SMRT;
rc = VCursorDefault ( cursor, col_idx[ seq_tab_PLATFORM ], 8, &platform, 0, 1 );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot set cursor-default on seq-table for platform-column" );
else
{
region_type_mapping *mapping_ptr = NULL;
if ( rgn_present )
{
mapping_ptr = &mapping;
}
/* call for every spot the function >seq_load_spot< */
rc = zmw_for_each( &BaseCallsTab.cmn.zmw, &lctx->xml_progress, cursor,
lctx->with_progress, col_idx, mapping_ptr, false, seq_load_spot, &BaseCallsTab );
}
}
}
}
if ( rgn_present )
{
seq_load_info( &BaseCallsTab.rgn.stat );
if ( mapping.count_of_unknown_rgn_types > 0 )
{
KLogLevel tmp_lvl = KLogLevelGet();
KLogLevelSet( klogInfo );
PLOGMSG( klogInfo, ( klogInfo,
"$(times) x unknown region types encountered",
"times=%i", mapping.count_of_unknown_rgn_types ) );
KLogLevelSet( tmp_lvl );
}
}
lctx->total_seq_bases += total_bases;
lctx->total_seq_spots += total_spots;
}
else
rc = RC( rcExe, rcNoTarg, rcAllocating, rcParam, rcInvalid );
close_BaseCalls( &BaseCallsTab );
}
return rc;
}
GtkWidget *
do_list_store (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *sw;
GtkWidget *treeview;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "GtkListStore demo");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new ("This is the bug list (note: not based on real data, it would be nice to have a nice ODBC interface to bugzilla or so, though).");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create tree model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview),
COLUMN_DESCRIPTION);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* add columns to the tree view */
add_columns (GTK_TREE_VIEW (treeview));
/* finish & show */
gtk_window_set_default_size (GTK_WINDOW (window), 280, 250);
g_signal_connect (window, "delete-event",
G_CALLBACK (window_closed), NULL);
}
if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
if (timeout == 0) {
/* FIXME this should use the animation-duration instead */
timeout = g_timeout_add (80, spinner_timeout, NULL);
}
}
else
{
gtk_widget_destroy (window);
window = NULL;
if (timeout != 0)
{
g_source_remove (timeout);
timeout = 0;
}
}
return window;
}
GtkWidget *
do_tree_store (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeModel *model;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_display (GTK_WINDOW (window),
gtk_widget_get_display (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Tree Store");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
g_object_set (vbox, "margin", 8, NULL);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox),
gtk_label_new ("Jonathan's Holiday Card Planning Sheet"));
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw);
/* create model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_widget_set_vexpand (treeview, TRUE);
g_object_unref (model);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_MULTIPLE);
add_columns (GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* expand all rows after the treeview widget has been realized */
g_signal_connect (treeview, "realize",
G_CALLBACK (gtk_tree_view_expand_all), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 650, 400);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
void gui_show_search_results(GSList * list, gchar * plugin_name)
{
GtkWidget *search;
GtkWidget *vbox;
GtkListStore *search_liststore;
GtkWidget *tree_view;
GtkWidget *scrolled_window;
GtkWidget *hbox;
GtkWidget *button_close;
GtkWidget *frame;
GSList *tmplist = list;
GtkTreeIter search_iter;
gui_protocol *gp;
search = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name(search, "GGSearchResults");
gtk_window_set_title(GTK_WINDOW(search), _("Search results"));
gtk_window_set_default_size(GTK_WINDOW(search), 350, 300);
search_liststore = gtk_list_store_new(6, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(search_liststore));
/*
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)), GTK_SELECTION_MULTIPLE);
*/
add_columns(GTK_TREE_VIEW(tree_view));
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolled_window), tree_view);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(frame), scrolled_window);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(search), vbox);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
button_close = gtk_button_new_from_stock("gtk-close");
gtk_box_pack_end(GTK_BOX(hbox), button_close, FALSE, FALSE, 0);
g_signal_connect(search, "destroy", G_CALLBACK(on_destroy_search), list);
g_signal_connect_swapped(button_close, "clicked", G_CALLBACK(gtk_widget_destroy), search);
g_signal_connect(G_OBJECT(tree_view), "button-press-event", G_CALLBACK(search_list_clicked), search_liststore);
gtk_widget_show_all(search);
gp = gui_find_protocol(plugin_name, protocols);
if (gp)
{
g_object_set_data(G_OBJECT(tree_view), "plugin_name", gp->plugin_name);
while (tmplist)
{
GGaduContact *k = tmplist->data;
GGaduStatusPrototype *sp = ggadu_find_status_prototype(gp->p, k->status);
print_debug("adding kontakt to results list: %s\n", k->id);
if (sp && sp->image != NULL)
{
gchar *display;
gchar *dispcity;
gchar *dispage;
GdkPixbuf *image = create_pixbuf(sp->image);
display = g_strdup_printf("%s %s%s%s", (k->first_name) ? k->first_name : "", (k->nick) ? "(" : "", (k->nick) ? k->nick : "", (k->nick) ? ")" : "");
dispcity = g_strdup_printf("%s", (k->city) ? k->city : "");
dispage = g_strdup_printf("%s", (k->age) ? k->age : "");
gtk_list_store_append(search_liststore, &search_iter);
gtk_list_store_set(search_liststore, &search_iter, 0, image, 1, k->id, 2, (gpointer) k, 3, display, 4, dispcity, 5, dispage, -1);
gdk_pixbuf_unref(image);
}
GGaduStatusPrototype_free(sp);
tmplist = tmplist->next;
}
}
}
GtkWidget *
do_tree_store (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeModel *model;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Card planning sheet");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox),
gtk_label_new ("Jonathan's Holiday Card Planning Sheet"),
FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
g_object_unref (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_MULTIPLE);
add_columns (GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* expand all rows after the treeview widget has been realized */
g_signal_connect (treeview, "realize",
G_CALLBACK (gtk_tree_view_expand_all), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 650, 400);
}
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
gpointer do_tree_store()
{
GtkWidget *window = __g_priv.window;
if (!window) {
GtkWidget *vbox, *tool_hbox, *grep_hbox;
GtkWidget *scan_button;
GtkWidget *grep_button;
GtkWidget *grep_entry;
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeModel *model;
GtkTreeModel *filter;
/* create window, etc */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen(GTK_WINDOW(window), gtk_widget_get_screen(NULL));
gtk_window_set_title(GTK_WINDOW(window), "list");
g_signal_connect(window, "destroy", G_CALLBACK(gtk_widget_destroyed), &window);
vbox = gtk_vbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 1);
gtk_container_add(GTK_CONTAINER(window), vbox);
tool_hbox = gtk_hbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(tool_hbox), 1);
gtk_box_pack_start(GTK_BOX(vbox), tool_hbox, FALSE, FALSE, 0);
scan_button = gtk_toggle_button_new_with_mnemonic("_Rescan");
gtk_box_pack_start(GTK_BOX(tool_hbox), scan_button, FALSE, FALSE, 0);
grep_button = gtk_toggle_button_new_with_mnemonic("_Search");
gtk_box_pack_end(GTK_BOX(tool_hbox), grep_button, FALSE, FALSE, 0);
grep_hbox = gtk_hbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(grep_hbox), 1);
gtk_box_pack_start(GTK_BOX(vbox), grep_hbox, FALSE, FALSE, 0);
grep_entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(grep_hbox), grep_entry, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(grep_button), "toggled", G_CALLBACK(cb_search_toggled), GTK_ENTRY(grep_entry));
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
/* create model */
model = create_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(model));
/* Create filter and set visible function */
filter = gtk_tree_model_filter_new(model, NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter), (GtkTreeModelFilterVisibleFunc)
filter_func, grep_entry, NULL);
/* Create treeview with model */
treeview = gtk_tree_view_new_with_model(filter);
fill_data(treeview, GTK_TREE_STORE(model));
g_signal_connect(G_OBJECT(grep_entry), "changed", G_CALLBACK(cb_entry_changed), GTK_TREE_VIEW(treeview));
g_object_unref(model);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), GTK_SELECTION_SINGLE);
add_columns(GTK_TREE_VIEW(treeview));
gtk_container_add(GTK_CONTAINER(sw), treeview);
/* expand all rows after the treeview widget has been realized */
g_signal_connect(treeview, "realize", G_CALLBACK(gtk_tree_view_expand_all), NULL);
gtk_window_set_default_size(GTK_WINDOW(window), 650, 400);
/* set priv */
__g_priv.window = window;
__g_priv.treeview = treeview;
__g_priv.model = model;
__g_priv.filter = filter;
__g_priv.scan_button = scan_button;
__g_priv.grep_button = grep_button;
__g_priv.grep_entry = grep_entry;
}
if (!GTK_WIDGET_VISIBLE(window))
gtk_widget_show_all(window);
else {
gtk_widget_destroy(window);
window = NULL;
}
return (gpointer) & __g_priv;
}
void
dlg_personalize_scripts (GthBrowser *browser)
{
DialogData *data;
if (gth_browser_get_dialog (browser, "personalize_scripts") != NULL) {
gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "personalize_scripts")));
return;
}
data = g_new0 (DialogData, 1);
data->browser = browser;
data->builder = _gtk_builder_new_from_file ("personalize-scripts.ui", "list_tools");
/* Get the widgets. */
data->dialog = _gtk_builder_get_widget (data->builder, "personalize_scripts_dialog");
gth_browser_set_dialog (browser, "personalize_scripts", data->dialog);
g_object_set_data (G_OBJECT (data->dialog), "dialog_data", data);
/**/
data->list_store = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_OBJECT,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
data->list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (data->list_store));
g_object_unref (data->list_store);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (data->list_view), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (data->list_view), TRUE);
add_columns (GTK_TREE_VIEW (data->list_view), data);
gtk_widget_show (data->list_view);
gtk_container_add (GTK_CONTAINER (GET_WIDGET ("scripts_scrolledwindow")), data->list_view);
gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("scripts_label")), data->list_view);
gtk_label_set_use_underline (GTK_LABEL (GET_WIDGET ("scripts_label")), TRUE);
update_script_list (data);
update_sensitivity (data);
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (destroy_cb),
data);
g_signal_connect_swapped (G_OBJECT (GET_WIDGET ("close_button")),
"clicked",
G_CALLBACK (gtk_widget_destroy),
G_OBJECT (data->dialog));
g_signal_connect (G_OBJECT (GET_WIDGET ("new_button")),
"clicked",
G_CALLBACK (new_script_cb),
data);
g_signal_connect (G_OBJECT (GET_WIDGET ("edit_button")),
"clicked",
G_CALLBACK (edit_script_cb),
data);
g_signal_connect (G_OBJECT (GET_WIDGET ("delete_button")),
"clicked",
G_CALLBACK (delete_script_cb),
data);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->list_view)),
"changed",
G_CALLBACK (list_view_selection_changed_cb),
data);
g_signal_connect (GTK_TREE_VIEW (data->list_view),
"row-activated",
G_CALLBACK (list_view_row_activated_cb),
data);
g_signal_connect (data->list_store,
"row-deleted",
G_CALLBACK (row_deleted_cb),
data);
g_signal_connect (data->list_store,
"row-inserted",
G_CALLBACK (row_inserted_cb),
data);
data->scripts_changed_id = g_signal_connect (gth_script_file_get (),
"changed",
G_CALLBACK (scripts_changed_cb),
data);
/* run dialog. */
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser));
gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE);
gtk_widget_show (data->dialog);
}
/**
* grg_list_run:
*
* Creates, manages and displays a dialog with the entry list
*/
void
grg_list_run (void)
{
GtkWidget *dialog, *sw, *tbar, *hbox, *bup, *bdown;
GtkTreePath *path = gtk_tree_path_new ();
guint res;
dialog = gtk_dialog_new_with_buttons (_("Index of entries"), NULL,
GTK_DIALOG_MODAL, GTK_STOCK_OK,
GTK_RESPONSE_OK, NULL);
gtk_container_set_border_width (GTK_CONTAINER (dialog), GRG_PAD);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), GRG_PAD);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
model = create_model ();
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview), COL_ID);
g_signal_connect (G_OBJECT (treeview), "button-press-event",
G_CALLBACK (double_click), (gpointer) dialog);
g_object_unref (G_OBJECT (model));
gtk_container_add (GTK_CONTAINER (sw), treeview);
add_columns (GTK_TREE_VIEW (treeview));
tbar = gtk_toolbar_new ();
gtk_toolbar_set_orientation (GTK_TOOLBAR (tbar),
GTK_ORIENTATION_VERTICAL);
#if 0
gtk_toolbar_set_icon_size (GTK_TOOLBAR (tbar),
GTK_ICON_SIZE_LARGE_TOOLBAR);
#endif
bup = grg_toolbar_insert_stock (GTK_TOOLBAR (tbar), GTK_STOCK_GO_UP,
_("Move up"),
(GtkSignalFunc) move_row,
GINT_TO_POINTER (TRUE), -1);
bdown = grg_toolbar_insert_stock (GTK_TOOLBAR (tbar),
GTK_STOCK_GO_DOWN, _("Move down"),
(GtkSignalFunc) move_row,
GINT_TO_POINTER (FALSE), -1);
hbox = gtk_hbox_new (FALSE, GRG_PAD);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), tbar, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE,
TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW (dialog), 180, 250);
gtk_tree_path_append_index (path, grg_entries_position ());
gtk_tree_view_set_cursor (GTK_TREE_VIEW (treeview), path, NULL,
FALSE);
gtk_tree_path_free (path);
gtk_widget_show_all (dialog);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_OK)
grg_entries_nth (get_sel_row_num ());
else
grg_entries_nth (0);
gtk_widget_destroy (dialog);
}
void
gevo_add_buddy_dialog_show(PurpleAccount *account, const char *username,
const char *group, const char *alias)
{
GevoAddBuddyDialog *dialog;
GtkWidget *button;
GtkWidget *sw;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *bbox;
GtkWidget *sep;
GtkTreeSelection *selection;
GtkCellRenderer *cell;
dialog = g_new0(GevoAddBuddyDialog, 1);
dialog->account =
(account != NULL
? account
: purple_connection_get_account(purple_connections_get_all()->data));
if (username != NULL)
dialog->username = g_strdup(username);
dialog->win = pidgin_create_window(_("Add Buddy"), PIDGIN_HIG_BORDER, "add_buddy", TRUE);
gtk_widget_set_size_request(dialog->win, -1, 400);
g_signal_connect(G_OBJECT(dialog->win), "delete_event",
G_CALLBACK(delete_win_cb), dialog);
/* Setup the vbox */
vbox = gtk_vbox_new(FALSE, 12);
gtk_container_add(GTK_CONTAINER(dialog->win), vbox);
gtk_widget_show(vbox);
/* Add the label. */
label = gtk_label_new(_("Select a person from your address book below, "
"or add a new person."));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0);
gtk_widget_show(label);
/* Add the search hbox */
hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_widget_show(hbox);
/* "Search" */
label = gtk_label_new(_("Search"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
/* Addressbooks */
dialog->addrbooks = gevo_addrbooks_model_new();
dialog->addrbooks_combo = gtk_combo_box_new_with_model(
dialog->addrbooks);
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dialog->addrbooks_combo),
cell, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(dialog->addrbooks_combo),
cell,
"text", ADDRBOOK_COLUMN_NAME,
NULL);
gtk_box_pack_start(GTK_BOX(hbox), dialog->addrbooks_combo, FALSE,
FALSE, 0);
gtk_widget_show(dialog->addrbooks_combo);
/* Search field */
dialog->search_field = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), dialog->search_field, TRUE, TRUE, 0);
gtk_widget_show(dialog->search_field);
g_signal_connect(G_OBJECT(dialog->search_field), "changed",
G_CALLBACK(search_changed_cb), dialog);
/* Clear button */
button = gtk_button_new_from_stock(GTK_STOCK_CLEAR);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(clear_cb), dialog);
/* Scrolled Window */
sw = gtk_scrolled_window_new(0, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
gtk_widget_show(sw);
/* Create the list model for the treeview. */
dialog->model = gtk_list_store_new(NUM_COLUMNS,
G_TYPE_STRING, GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_POINTER);
/* Now for the treeview */
dialog->treeview =
gtk_tree_view_new_with_model(GTK_TREE_MODEL(dialog->model));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(dialog->treeview), TRUE);
gtk_container_add(GTK_CONTAINER(sw), dialog->treeview);
gtk_widget_show(dialog->treeview);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(selected_cb), dialog);
add_columns(dialog);
/*
* Catch addressbook selection and populate treeview with the first
* addressbook
*/
gevo_addrbooks_model_populate(dialog->addrbooks);
g_signal_connect(G_OBJECT(dialog->addrbooks_combo), "changed",
G_CALLBACK(addrbook_change_cb), dialog);
gtk_combo_box_set_active(GTK_COMBO_BOX(dialog->addrbooks_combo), 0);
/* Group box */
dialog->group_combo =
pidgin_text_combo_box_entry_new(group, gevo_get_groups());
pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("Group:"), NULL,
dialog->group_combo, TRUE, NULL);
gtk_widget_show_all(dialog->group_combo);
/* Cool. Now we only have a little left... */
/* Separator. */
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0);
gtk_widget_show(sep);
/* Button box */
bbox = gtk_hbutton_box_new();
gtk_box_set_spacing(GTK_BOX(bbox), 6);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_pack_end(GTK_BOX(vbox), bbox, FALSE, TRUE, 0);
gtk_widget_show(bbox);
/* "New Person" button */
button = pidgin_pixbuf_button_from_stock(_("New Person"), GTK_STOCK_NEW,
PIDGIN_BUTTON_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(new_person_cb), dialog);
/* "Cancel" button */
button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(cancel_cb), dialog);
/* "Select Buddy" button */
button = pidgin_pixbuf_button_from_stock(_("Select Buddy"), GTK_STOCK_APPLY,
PIDGIN_BUTTON_HORIZONTAL);
dialog->select_button = button;
gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0);
gtk_widget_set_sensitive(button, FALSE);
gtk_widget_show(button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(select_buddy_cb), dialog);
/* Show it. */
gtk_widget_show(dialog->win);
}
GtkWidget *
do_editable_cells (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *sw;
GtkWidget *treeview;
GtkWidget *button;
GtkTreeModel *items_model;
GtkTreeModel *numbers_model;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Shopping list");
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox),
gtk_label_new ("Shopping list (you can edit the cells!)"),
FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create models */
items_model = create_items_model ();
numbers_model = create_numbers_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (items_model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_SINGLE);
add_columns (GTK_TREE_VIEW (treeview), items_model, numbers_model);
g_object_unref (numbers_model);
g_object_unref (items_model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* some buttons */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Add item");
g_signal_connect (button, "clicked",
G_CALLBACK (add_item), items_model);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Remove item");
g_signal_connect (button, "clicked",
G_CALLBACK (remove_item), treeview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW (window), 320, 200);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
void Config_macros(GtkAction *action, gpointer data)
{
GtkWidget *vbox, *hbox;
GtkWidget *sw;
GtkTreeModel *model;
GtkWidget *treeview;
GtkWidget *button;
GtkWidget *separator;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), _("Configure Macros"));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create tree model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview),
COLUMN_SHORTCUT);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* add columns to the tree view */
add_columns (GTK_TREE_VIEW (treeview));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic (_("_Add"));
g_signal_connect(button, "clicked", G_CALLBACK(Add_shortcut), (gpointer)model);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_mnemonic (_("_Delete"));
g_signal_connect(button, "clicked", G_CALLBACK(Delete_shortcut), (gpointer)treeview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_mnemonic (_("_Capture Shortcut"));
g_signal_connect(button, "clicked", G_CALLBACK(Capture_shortcut), (gpointer)treeview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_HELP);
g_signal_connect(button, "clicked", G_CALLBACK(Help_screen), (gpointer)window);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
g_signal_connect(button, "clicked", G_CALLBACK(Save_shortcuts), (gpointer)treeview);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer)window);
gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer)window);
gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW(window), 300, 400);
gtk_widget_show_all(window);
}
static void
run_logged_in_dialogue (char **vec)
{
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *w;
GtkWidget *sw;
GtkTreeModel *model;
GtkWidget *treeview;
GtkTreeIter iter;
GtkTreeSelection *selection;
gint response;
if (startnew == TRUE) {
/* Just return if the user doesn't want to see the dialog */
return;
}
dialog = gtk_dialog_new_with_buttons (_("Open Displays"),
NULL /* parent */,
0 /* flags */,
_("_Open New Display"),
RESPONSE_OPEN_NEW_DISPLAY,
_("Change to _Existing Display"),
RESPONSE_OPEN_EXISTING_DISPLAY,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
NULL);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
vbox = GTK_DIALOG (dialog)->vbox;
w = gtk_label_new (_("There are some displays already open. You can select "
"one from the list below or open a new one."));
gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create tree model */
model = create_model (vec);
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* add columns to the tree view */
add_columns (GTK_TREE_VIEW (treeview));
/* finish & show */
gtk_window_set_default_size (GTK_WINDOW (dialog), 280, 250);
g_signal_connect (G_OBJECT (treeview), "row_activated",
G_CALLBACK (row_activated),
dialog);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
g_signal_connect (selection, "changed",
G_CALLBACK (selection_changed),
dialog);
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
RESPONSE_OPEN_EXISTING_DISPLAY,
FALSE);
gtk_widget_show_all (dialog);
response = gtk_dialog_run (GTK_DIALOG (dialog));
run_again:
switch (response) {
case RESPONSE_OPEN_NEW_DISPLAY:
gtk_widget_destroy (dialog);
/* just continue what you are doing */
return;
case RESPONSE_OPEN_EXISTING_DISPLAY:
if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
GValue value = {0};
int vt;
gtk_tree_model_get_value (model, &iter,
COLUMN_VT,
&value);
vt = g_value_get_int (&value);
g_value_unset (&value);
/* we switched to a different screen as a result of this,
* lock the current screen */
if ( ! no_lock && vt != get_cur_vt () && vt >= 0) {
maybe_lock_screen ();
}
change_vt (vt);
/* FIXME: wait + disturb the pointer (need SUP?),
* perhaps part of the sup command to CHVT ?? */
exit (0);
} else {
/* EEK */
goto run_again;
}
break;
default:
gtk_widget_destroy (dialog);
/* cancel, or close */
exit (0);
break;
}
}
