static sequence_view_t *new_sequence_view( void *vp, int num ) { sequence_view_t *seqv = (sequence_view_t*) vj_calloc(sizeof(sequence_view_t)); seqv->num = num; seqv->backlink = vp; seqv->event_box = gtk_event_box_new(); gtk_event_box_set_visible_window( GTK_EVENT_BOX(seqv->event_box), TRUE ); GTK_WIDGET_SET_FLAGS( seqv->event_box, GTK_CAN_FOCUS ); g_signal_connect( G_OBJECT( seqv->event_box ), "button_press_event", G_CALLBACK( seqv_mouse_press_event ), (gpointer*) seqv ); gtk_widget_show( GTK_WIDGET( seqv->event_box ) ); gchar *track_title = g_new0( gchar, 20 ); sprintf(track_title, "Track %d", num ); seqv->frame = gtk_frame_new( track_title ); g_free(track_title); gtk_container_set_border_width( GTK_CONTAINER( seqv->frame) , 1 ); gtk_widget_show( GTK_WIDGET( seqv->frame ) ); gtk_container_add( GTK_CONTAINER( seqv->event_box), seqv->frame ); seqv->main_vbox = gtk_vbox_new(FALSE,0); gtk_container_add( GTK_CONTAINER( seqv->frame ), seqv->main_vbox ); gtk_widget_show( GTK_WIDGET( seqv->main_vbox ) ); seqv->area = gtk_image_new(); gtk_box_pack_start( GTK_BOX(seqv->main_vbox),GTK_WIDGET( seqv->area), FALSE,FALSE,0); gtk_widget_set_size_request_( seqv->area, 176,144 ); //FIXME seqv->panel = gtk_frame_new(NULL); seqv->toggle = gtk_toggle_button_new_with_label( "preview" ); if(num>0) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(seqv->toggle), FALSE ); g_signal_connect( G_OBJECT( seqv->toggle ), "toggled", G_CALLBACK(sequence_preview_cb), (gpointer)seqv ); gtk_box_pack_start( GTK_BOX(seqv->main_vbox), seqv->toggle,FALSE,FALSE, 0 ); gtk_widget_set_sensitive_( GTK_WIDGET( seqv->toggle ), FALSE ); gtk_widget_show( seqv->toggle ); } else { gtk_box_pack_start( GTK_BOX(seqv->main_vbox), seqv->toggle,FALSE,FALSE, 0 ); gtk_widget_show( seqv->toggle ); gtk_widget_set_sensitive_( GTK_WIDGET( seqv->toggle ), FALSE ); } GtkWidget *vvbox = gtk_vbox_new(FALSE, 0); seqv->button_box = gtk_hbox_new(FALSE,0); gtk_box_pack_start( GTK_BOX(vvbox), seqv->button_box ,FALSE,FALSE, 0 ); add_buttons( seqv,seqv,seqv->button_box ); gtk_widget_show( seqv->button_box ); gtk_container_add( GTK_CONTAINER( seqv->main_vbox ), seqv->panel ); seqv->button_box2 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start( GTK_BOX(vvbox), seqv->button_box2, FALSE,FALSE, 0 ); add_buttons2( seqv,seqv,seqv->button_box2 ); gtk_widget_show( seqv->button_box2 ); gtk_container_add( GTK_CONTAINER( seqv->panel ), vvbox ); gtk_widget_show(vvbox); GtkWidget *box = gtk_vbox_new(FALSE,0); seqv->timeline_ = gtk_hscale_new_with_range( 0.0,1.0,0.1 ); gtk_scale_set_draw_value( GTK_SCALE(seqv->timeline_), FALSE ); //gtk_widget_set_size_request_( seqv->panel,180 ,180); gtk_adjustment_set_value( GTK_ADJUSTMENT(GTK_RANGE(seqv->timeline_)->adjustment), 0.0 ); gtk_widget_show( seqv->panel ); gtk_box_pack_start( GTK_BOX( box ), seqv->timeline_, FALSE,FALSE, 0 ); gtk_box_pack_start( GTK_BOX( vvbox ), box , FALSE,FALSE,0); gtk_widget_show(seqv->timeline_); g_signal_connect( seqv->timeline_, "value_changed", (GCallback) sequence_set_current_frame, (gpointer*) seqv ); GtkWidget *scroll = gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN ); gtk_widget_set_size_request_(scroll,30,140); gtk_container_set_border_width(GTK_CONTAINER(scroll),0); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC ); GtkWidget *vvvbox = gtk_hbox_new(FALSE,0); seqv->tracks = create_track_view(seqv->num, MAX_TRACKS, (void*) seqv ); gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( get_track_tree(seqv->tracks)) , FALSE ); gtk_widget_set_size_request_( get_track_tree(seqv->tracks),20,80 ); gtk_widget_show(scroll); gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW( scroll ), get_track_tree(seqv->tracks) ); gtk_widget_show( get_track_tree(seqv->tracks)); gtk_box_pack_start( GTK_BOX(vvvbox), scroll, TRUE,TRUE, 0); GtkWidget *hhbox = gtk_hbox_new(FALSE,0); seqv->sliders_[0] = gtk_vscale_new_with_range( -12.0,12.0,1.0 ); seqv->sliders_[1] = gtk_vscale_new_with_range( 0.0, 1.0, 0.01 ); gtk_adjustment_set_value( GTK_ADJUSTMENT(GTK_RANGE(seqv->sliders_[0])->adjustment), 1.0 ); gtk_adjustment_set_value( GTK_ADJUSTMENT(GTK_RANGE(seqv->sliders_[1])->adjustment), 0.0 ); gtk_scale_set_digits( GTK_SCALE(seqv->sliders_[1]), 2 ); g_signal_connect( G_OBJECT( seqv->sliders_[0] ), "value_changed", G_CALLBACK( seq_speed ), (gpointer*)seqv ); g_signal_connect( G_OBJECT( seqv->sliders_[1] ), "value_changed", G_CALLBACK( seq_opacity ), (gpointer*)seqv ); gtk_box_pack_start( GTK_BOX( hhbox ), seqv->sliders_[0], TRUE, TRUE, 0 ); gtk_box_pack_start( GTK_BOX( hhbox ), seqv->sliders_[1], TRUE, TRUE, 0 ); gtk_widget_show( seqv->sliders_[0] ); gtk_widget_show( seqv->sliders_[1] ); gtk_box_pack_start( GTK_BOX(vvvbox), hhbox, TRUE,TRUE, 0 ); gtk_widget_show( hhbox ); gtk_container_add( GTK_CONTAINER( box ), vvvbox ); gtk_widget_show( vvvbox ); gtk_widget_show( box ); GtkWidget *hbox = gtk_hbox_new(FALSE,0); gtk_box_set_spacing( GTK_BOX(hbox), 10 ); seqv->labels_[0] = gtk_label_new( "00:00:00:00" ); seqv->labels_[1] = gtk_label_new( "00:00:00:00" ); gtk_box_pack_start( GTK_BOX( hbox ), seqv->labels_[0], FALSE, FALSE, 0 ); gtk_box_pack_start( GTK_BOX( hbox ), seqv->labels_[1], FALSE, FALSE, 0 ); gtk_widget_show( seqv->labels_[0] ); gtk_widget_show( seqv->labels_[1] ); gtk_box_pack_start( GTK_BOX(seqv->main_vbox), hbox, FALSE,FALSE, 0 ); gtk_widget_show( hbox ); gtk_widget_set_sensitive_(GTK_WIDGET(seqv->panel), FALSE ); gtk_widget_show( GTK_WIDGET( seqv->area ) ); return seqv; }
int DoLoadPortalFileDialog( GtkWidget *parent ){ GtkWidget *dialog, *vbox, *hbox, *button, *entry, *check2d, *check3d; GtkWidget *content_area, *ok_button, *cancel_button, *change_button; gint response_id; int ret; GtkSizeGroup *size_group; GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT; dialog = gtk_dialog_new_with_buttons( _( "Load .prt" ), NULL, flags, NULL ); gtk_window_set_transient_for( GTK_WINDOW( dialog ), GTK_WINDOW( parent ) ); ok_button = gtk_dialog_add_button( GTK_DIALOG( dialog ), _( "OK" ), GTK_RESPONSE_OK ); cancel_button = gtk_dialog_add_button( GTK_DIALOG( dialog ), _( "Cancel" ), GTK_RESPONSE_CANCEL ); content_area = gtk_dialog_get_content_area( GTK_DIALOG( dialog ) ); vbox = gtk_vbox_new( FALSE, 5 ); gtk_container_add( GTK_CONTAINER( content_area ), vbox ); gtk_container_set_border_width( GTK_CONTAINER( vbox ), 5 ); gtk_widget_show( vbox ); entry = gtk_entry_new(); gtk_editable_set_editable( GTK_EDITABLE( entry ), FALSE ); gtk_box_pack_start( GTK_BOX( vbox ), entry, FALSE, FALSE, 0 ); gtk_widget_show( entry ); hbox = gtk_hbox_new( FALSE, 5 ); gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 ); gtk_widget_show( hbox ); check3d = gtk_check_button_new_with_label( _( "Show 3D" ) ); gtk_box_pack_start( GTK_BOX( hbox ), check3d, FALSE, FALSE, 0 ); gtk_widget_show( check3d ); check2d = gtk_check_button_new_with_label( _( "Show 2D" ) ); gtk_box_pack_start( GTK_BOX( hbox ), check2d, FALSE, FALSE, 0 ); gtk_widget_show( check2d ); change_button = button = gtk_button_new_with_label( _( "Change" ) ); gtk_box_pack_end( GTK_BOX( hbox ), button, FALSE, FALSE, 0 ); g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( change_clicked ), parent ); gtk_widget_show( button ); size_group = gtk_size_group_new( GTK_SIZE_GROUP_BOTH ); gtk_size_group_add_widget( size_group, ok_button ); gtk_size_group_add_widget( size_group, cancel_button ); gtk_size_group_add_widget( size_group, change_button ); g_object_unref( size_group ); char *fn = g_FuncTable.m_pfnGetMapName(); strcpy( portals.fn, fn ); fn = strrchr( portals.fn, '.' ); if ( fn != NULL ) { *fn = '\0'; strcat( portals.fn, ".prt" ); } gtk_entry_set_text( GTK_ENTRY( entry ), portals.fn ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check2d ), portals.show_2d ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check3d ), portals.show_3d ); response_id = gtk_dialog_run( GTK_DIALOG( dialog ) ); if( response_id == GTK_RESPONSE_OK ) { portals.Purge(); portals.show_3d = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( check3d ) ) ? true : false; portals.show_2d = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( check2d ) ) ? true : false; ret = IDOK; } else { ret = IDCANCEL; } gtk_widget_destroy( dialog ); return ret; }
GtkWidget *sat_pref_debug_create() { GtkWidget *vbox; /* vbox containing the list part and the details part */ GtkWidget *hbox; GtkWidget *rbut; GtkWidget *label; GtkWidget *butbox; gchar *msg; gchar *confdir; vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE); gtk_container_set_border_width(GTK_CONTAINER(vbox), 20); gtk_box_set_spacing(GTK_BOX(vbox), 10); /* debug level */ hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10); gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE); label = gtk_label_new(_("Debug level:")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); level = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(level), _("Level 0: None")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(level), _("Level 1: Error")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(level), _("Level 2: Warning")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(level), _("Level 3: Info")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(level), _("Level 4: Debug")); gtk_combo_box_set_active(GTK_COMBO_BOX(level), sat_cfg_get_int(SAT_CFG_INT_LOG_LEVEL)); g_signal_connect(G_OBJECT(level), "realize", G_CALLBACK(gpredict_set_combo_tooltips), _("Select the debug level. The higher the level, " "the more messages will be logged.")); g_signal_connect(G_OBJECT(level), "changed", G_CALLBACK(state_change_cb), NULL); gtk_box_pack_start(GTK_BOX(hbox), level, FALSE, FALSE, 10); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* clean frequency */ hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10); gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE); label = gtk_label_new(_("Delete log files older than:")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); age = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(age), _("Always delete")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(age), _("1 day")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(age), _("1 week")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(age), _("1 month")); select_age(); g_signal_connect(G_OBJECT(age), "realize", G_CALLBACK(gpredict_set_combo_tooltips), _("Select how often gpredict should delete " "old log files.")); g_signal_connect(G_OBJECT(age), "changed", G_CALLBACK(state_change_cb), NULL); gtk_box_pack_start(GTK_BOX(hbox), age, FALSE, FALSE, 10); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* separator */ gtk_box_pack_start(GTK_BOX(vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); /* info label */ confdir = get_user_conf_dir(); msg = g_strdup_printf(_ ("Gpredict stores all run-time messages in the %s%slogs%s\n" "directory. The current log file is called gpredict.log and the file is\n" "always kept until the next execution, so that you can examine it in case\n" "of a failure. If old log files are kept, they are called gpredict-XYZ.log\n" "where XYZ is a unique timestamp."), confdir, G_DIR_SEPARATOR_S, G_DIR_SEPARATOR_S); label = gtk_label_new(msg); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); g_free(msg); /* reset button */ rbut = gtk_button_new_with_label(_("Reset")); gtk_widget_set_tooltip_text(rbut, _("Reset settings to the default values.")); g_signal_connect(G_OBJECT(rbut), "clicked", G_CALLBACK(reset_cb), NULL); butbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout(GTK_BUTTON_BOX(butbox), GTK_BUTTONBOX_END); gtk_box_pack_end(GTK_BOX(butbox), rbut, FALSE, TRUE, 10); gtk_box_pack_end(GTK_BOX(vbox), butbox, FALSE, TRUE, 0); return vbox; }
void FormDialog::multiple_choice (const std::string name, const std::string description, const std::set<std::string> values, const std::map<std::string, std::string> choices, bool advanced) { GtkWidget *label = NULL; GtkWidget *scroll = NULL; GtkWidget *tree_view = NULL; GtkWidget *frame = NULL; GtkListStore *list_store = NULL; GtkTreeViewColumn *column = NULL; GtkCellRenderer *renderer = NULL; GtkTreeIter iter; gchar *label_text = NULL; MultipleChoiceSubmitter *submitter = NULL; grow_fields (advanced); /* The label */ label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); label_text = g_strdup_printf ("<b>%s</b>", description.c_str()); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text); g_free (label_text); /* The GtkListStore containing the choices */ tree_view = gtk_tree_view_new (); list_store = gtk_list_store_new (MultipleChoiceSubmitter::COLUMN_NUMBER, G_TYPE_BOOLEAN, G_TYPE_STRING); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); frame = gtk_frame_new (NULL); gtk_widget_set_size_request (GTK_WIDGET (frame), -1, 125); gtk_container_set_border_width (GTK_CONTAINER (frame), 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (frame), scroll); gtk_container_add (GTK_CONTAINER (scroll), tree_view); renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "active", MultipleChoiceSubmitter::COLUMN_ACTIVE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); g_signal_connect (renderer, "toggled", G_CALLBACK (multiple_choice_choice_toggled_cb), list_store); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", MultipleChoiceSubmitter::COLUMN_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); for (std::map<std::string, std::string>::const_iterator map_iter = choices.begin (); map_iter != choices.end (); map_iter++) { bool active = (std::find (values.begin (), values.end (), map_iter->first) != values.end ()); gtk_list_store_append (GTK_LIST_STORE (list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (list_store), &iter, MultipleChoiceSubmitter::COLUMN_ACTIVE, active, MultipleChoiceSubmitter::COLUMN_NAME, map_iter->second.c_str (), -1); } if (advanced) { gtk_table_attach (GTK_TABLE (advanced_fields), label, 0, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); gtk_table_attach (GTK_TABLE (advanced_fields), frame, 0, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } else { gtk_table_attach (GTK_TABLE (fields), label, 0, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); gtk_table_attach (GTK_TABLE (fields), frame, 0, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } submitter = new MultipleChoiceSubmitter (name, description, choices, advanced, tree_view); submitters.push_back (submitter); }
static gboolean maskcor_dialog(MaskcorArgs *args) { MaskcorControls controls; GtkWidget *dialog, *table, *chooser, *spin, *combo, *method; GtkObject *adj; gint row, response; gboolean ok; controls.args = args; dialog = gtk_dialog_new_with_buttons(_("Mask by Correlation"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT); table = gtk_table_new(5, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 4); row = 0; /* Kernel */ chooser = gwy_data_chooser_new_channels(); g_object_set_data(G_OBJECT(chooser), "dialog", dialog); gwy_data_chooser_set_active(GWY_DATA_CHOOSER(chooser), NULL, -1); gwy_data_chooser_set_filter(GWY_DATA_CHOOSER(chooser), maskcor_kernel_filter, &args->data, NULL); gwy_data_chooser_set_active_id(GWY_DATA_CHOOSER(chooser), &args->kernel); gwy_data_chooser_get_active_id(GWY_DATA_CHOOSER(chooser), &args->kernel); g_signal_connect(chooser, "changed", G_CALLBACK(maskcor_kernel_changed), &args->kernel); gwy_table_attach_hscale(table, row, _("Correlation _kernel:"), NULL, GTK_OBJECT(chooser), GWY_HSCALE_WIDGET); row++; /* Result */ combo = gwy_enum_combo_box_newl(G_CALLBACK(maskcor_operation_changed), &controls, args->result, _("Objects marked"), GWY_MASKCOR_OBJECTS, _("Correlation maxima"), GWY_MASKCOR_MAXIMA, _("Correlation score"), GWY_MASKCOR_SCORE, NULL); gwy_table_attach_row(table, row, _("Output _type:"), NULL, combo); row++; /* Parameters */ method = gwy_enum_combo_box_new(gwy_correlation_type_get_enum(), -1, G_CALLBACK(gwy_enum_combo_box_update_int), &args->method, args->method, TRUE); gwy_table_attach_row(table, row, _("Correlation _method:"), NULL, method); row++; adj = gtk_adjustment_new(args->threshold, -1.0, 1.0, 0.01, 0.1, 0); controls.threshold = adj; spin = gwy_table_attach_hscale(table, row, _("T_hreshold:"), NULL, adj, 0); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 3); gwy_table_hscale_set_sensitive(adj, args->result != GWY_MASKCOR_SCORE); g_signal_connect(adj, "value-changed", G_CALLBACK(maskcor_threshold_changed), &args->threshold); row++; gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: gtk_widget_destroy(dialog); ok = TRUE; break; default: g_assert_not_reached(); break; } } while (!ok); return ok; }
struct master *add_master_dialog (struct master *m) { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *table; GtkWidget *option_menu; GtkWidget *hbox; GtkWidget *label; GtkWidget *button; GtkWidget *hseparator; char *typestr; enum master_query_type i; struct master *master_to_edit; char *windowtitle; master_name_result = NULL; master_addr_result = NULL; current_master_query_type = MASTER_NATIVE; master_to_edit = NULL; master_to_add = NULL; for (i=MASTER_NATIVE;i<MASTER_NUM_QUERY_TYPES;i++) master_query_type_radios[i]=NULL; master_to_edit = m; if (master_to_edit) { current_master_query_type = master_to_edit->master_type; master_type = master_to_edit->type; } else { // Get last game type added (stored in master_okbutton_callback) typestr = config_get_string ("/" CONFIG_FILE "/Add Master/game"); if (typestr) { master_type = id2type (typestr); g_free (typestr); } else { master_type = QW_SERVER; } } if (master_to_edit) { windowtitle=_("Rename Master"); } else { windowtitle=_("Add Master"); } window = dialog_create_modal_transient_window(windowtitle, TRUE, FALSE, NULL); main_vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), main_vbox); table = gtk_table_new (2, 2, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_container_set_border_width (GTK_CONTAINER (table), 16); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); /* Master Name (Description) */ label = gtk_label_new (_("Master Name")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 4); gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 2, 0, 1); master_name_combo = gtk_combo_new (); gtk_widget_set_usize (master_name_combo, 200, -1); gtk_box_pack_start (GTK_BOX (hbox), master_name_combo, TRUE, TRUE, 0); gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (master_name_combo)->entry), 256); gtk_combo_set_case_sensitive (GTK_COMBO (master_name_combo), TRUE); gtk_combo_set_use_arrows_always (GTK_COMBO (master_name_combo), TRUE); gtk_combo_disable_activate (GTK_COMBO (master_name_combo)); gtk_signal_connect( GTK_OBJECT (GTK_COMBO (master_name_combo)->entry), "activate", GTK_SIGNAL_FUNC (master_okbutton_callback), GTK_OBJECT (window)); GTK_WIDGET_SET_FLAGS (GTK_COMBO (master_name_combo)->entry, GTK_CAN_FOCUS); GTK_WIDGET_UNSET_FLAGS (GTK_COMBO (master_name_combo)->button, GTK_CAN_FOCUS); gtk_widget_grab_focus (GTK_COMBO (master_name_combo)->entry); gtk_widget_show (master_name_combo); if (master_history_name->items) combo_set_vals (master_name_combo, master_history_name->items, ""); if (master_to_edit) { gtk_entry_set_text(GTK_ENTRY (GTK_COMBO (master_name_combo)->entry), master_to_edit->name); } /* Master Type Option Menu */ option_menu = create_server_type_menu (master_type, create_server_type_menu_filter_configured, GTK_SIGNAL_FUNC(select_master_type_callback)); gtk_box_pack_start (GTK_BOX (hbox), option_menu, FALSE, FALSE, 0); if (master_to_edit) { gtk_widget_set_state (option_menu, GTK_STATE_NORMAL); gtk_widget_set_sensitive (GTK_WIDGET(option_menu),FALSE); } gtk_widget_show (option_menu); gtk_widget_show (hbox); /* Master Address */ label = gtk_label_new (_("Master Address")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (label); master_addr_combo = gtk_combo_new (); gtk_table_attach_defaults (GTK_TABLE (table), master_addr_combo, 1, 2, 1, 2); gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (master_addr_combo)->entry), 4096); gtk_combo_set_case_sensitive (GTK_COMBO (master_addr_combo), TRUE); gtk_combo_set_use_arrows_always (GTK_COMBO (master_addr_combo), TRUE); gtk_combo_disable_activate (GTK_COMBO (master_addr_combo)); gtk_signal_connect ( GTK_OBJECT (GTK_COMBO (master_addr_combo)->entry), "activate", GTK_SIGNAL_FUNC (master_okbutton_callback), GTK_OBJECT (window)); gtk_signal_connect ( GTK_OBJECT (GTK_COMBO (master_addr_combo)->list), "selection-changed", GTK_SIGNAL_FUNC (master_address_from_history_selected_callback),NULL); GTK_WIDGET_SET_FLAGS (GTK_COMBO (master_addr_combo)->entry, GTK_CAN_FOCUS); GTK_WIDGET_UNSET_FLAGS (GTK_COMBO (master_addr_combo)->button, GTK_CAN_FOCUS); // gtk_widget_grab_focus (GTK_COMBO (master_addr_combo)->entry); gtk_widget_show (master_addr_combo); if (master_history_addr->items) combo_set_vals (master_addr_combo, master_history_addr->items, ""); if (master_to_edit) { char* url = master_to_url(master_to_edit); gtk_entry_set_text(GTK_ENTRY (GTK_COMBO (master_addr_combo)->entry), url); gtk_widget_set_state (master_addr_combo, GTK_STATE_NORMAL); gtk_widget_set_sensitive (GTK_WIDGET(master_addr_combo),FALSE); g_free(url); } gtk_widget_show (table); /* query type */ hbox = gtk_hbox_new (TRUE, 8); for (i=MASTER_NATIVE;i<MASTER_NUM_QUERY_TYPES;i++) { master_query_type_radios[i] = gtk_radio_button_new_with_label_from_widget( i==MASTER_NATIVE?NULL:GTK_RADIO_BUTTON(master_query_type_radios[MASTER_NATIVE]), _(master_designation[i])); if (master_to_edit) { gtk_widget_set_sensitive (GTK_WIDGET(master_query_type_radios[i]),FALSE); } gtk_signal_connect(GTK_OBJECT (master_query_type_radios[i]), "toggled", GTK_SIGNAL_FUNC (master_type_radio_callback), (gpointer)i); gtk_widget_show (master_query_type_radios[i]); gtk_box_pack_start (GTK_BOX (hbox),master_query_type_radios[i], FALSE, FALSE, 0); } if (master_to_edit) { master_activate_radio_for_type(current_master_query_type); } else if (!games[master_type].default_master_port && current_master_query_type == MASTER_NATIVE) { gtk_widget_set_state (master_query_type_radios[MASTER_NATIVE], GTK_STATE_NORMAL); gtk_widget_set_sensitive (GTK_WIDGET(master_query_type_radios[MASTER_NATIVE]),FALSE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(master_query_type_radios[MASTER_GAMESPY]),TRUE); } gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); /* Separator */ hseparator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (main_vbox), hseparator, FALSE, FALSE, 0); gtk_widget_show (hseparator); /* Buttons */ hbox = gtk_hbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (hbox), 8); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); /* Cancel Button */ button = gtk_button_new_with_label (_("Cancel")); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_set_usize (button, 80, -1); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_show (button); /* OK Button */ button = gtk_button_new_with_label ("OK"); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_set_usize (button, 80, -1); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(master_okbutton_callback), window); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); gtk_widget_show (hbox); gtk_widget_show (main_vbox); gtk_widget_show (window); gtk_main (); unregister_window (window); return master_to_add; }
static void stm_new_transfer_window_ui (StmNewTransferWindow *self) { StmNewTransferWindowPrivate *priv = self->priv; gtk_window_set_title (GTK_WINDOW (self), _("Add transfer")); /* Buttons */ GtkWidget *close = gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); g_signal_connect (G_OBJECT (close), "clicked", G_CALLBACK (stm_new_transfer_window_close_clicked), self); /* Table */ GtkWidget *table = gtk_table_new (3, 2, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_container_set_border_width (GTK_CONTAINER (table), 12); GtkWidget *label; /* Left column */ label = gtk_label_new (""); gtk_label_set_markup (GTK_LABEL (label), _("<b>URL:</b>")); gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); label = gtk_label_new (""); gtk_label_set_markup (GTK_LABEL (label), _("<b>Save to:</b>")); gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_SHRINK, 0, 0); /* Right column */ GtkWidget *entry; entry = gtk_entry_new (); gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0); priv->source = GTK_ENTRY (entry); entry = gtk_file_chooser_button_new (_("Select destination"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0); priv->destination = GTK_FILE_CHOOSER_BUTTON (entry); entry = gtk_check_button_new_with_label (_("Automatically start transfer")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (entry), TRUE); gtk_table_attach (GTK_TABLE (table), entry, 0, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0); priv->auto_start = GTK_CHECK_BUTTON (entry); gtk_widget_show_all (table); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (self)->vbox), table, FALSE, FALSE, 0); /* Buttons */ GtkWidget *ok = gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_OK, GTK_RESPONSE_OK); g_signal_connect (G_OBJECT (ok), "clicked", G_CALLBACK (stm_new_transfer_window_close_clicked), self); }
static void configurewin_check_drive(GtkButton *w, gpointer data) { struct driveconfig *drive = data; GtkWidget *window, *vbox, *label, *bbox, *closeb; char *device, *directory; int fd, dae_track = -1; GString *str = g_string_new(""); struct stat stbuf; device = gtk_entry_get_text(GTK_ENTRY(drive->device)); directory = gtk_entry_get_text(GTK_ENTRY(drive->directory)); if ((fd = open(device, CDOPENFLAGS)) < 0) g_string_sprintfa(str, _("Failed to open device %s\n" "Error: %s\n\n"), device, strerror(errno)); else { cdda_disc_toc_t toc; if (!cdda_get_toc(&toc, device)) g_string_append(str, _("Failed to read \"Table of Contents\"" "\nMaybe no disc in the drive?\n\n")); else { int i, data = 0; g_string_sprintfa(str, _("Device %s OK.\n" "Disc has %d tracks"), device, toc.last_track - toc.first_track + 1); for (i = toc.first_track; i <= toc.last_track; i++) if (toc.track[i].flags.data_track) data++; else if (dae_track < 0) dae_track = i; if (data > 0) g_string_sprintfa(str, _(" (%d data tracks)"), data); g_string_sprintfa(str, _("\nTotal length: %d:%.2d\n"), toc.leadout.minute, toc.leadout.second); #ifdef CDDA_HAS_READAUDIO if (dae_track == -1) g_string_sprintfa(str, _("Digital audio extraction " "not tested as the disc has " "no audio tracks\n")); else { int start, end, fr; char buffer[CD_FRAMESIZE_RAW]; start = LBA(toc.track[dae_track]); if (dae_track == toc.last_track) end = LBA(toc.leadout); else end = LBA(toc.track[dae_track + 1]); fr = read_audio_data(fd, start + (end - start) / 2, 1, buffer); if (fr > 0) g_string_sprintfa(str, _("Digital audio extraction " "test: OK\n\n")); else g_string_sprintfa(str, _("Digital audio extraction " "test failed: %s\n\n"), strerror(-fr)); } #else g_string_sprintfa(str, "\n"); #endif } close(fd); } if (stat(directory, &stbuf) < 0) { g_string_sprintfa(str, _("Failed to check directory %s\n" "Error: %s"), directory, strerror(errno)); } else { if (!S_ISDIR(stbuf.st_mode)) g_string_sprintfa(str, _("Error: %s exists, but is not a directory"), directory); else { if (!access(directory, R_OK)) g_string_sprintfa(str, _("Directory %s OK."), directory); else g_string_sprintfa(str, _("Directory %s exists, but " "you do not have permission " "to access it."), directory); } } window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(cdda_configure_win)); gtk_container_set_border_width(GTK_CONTAINER(window), 10); vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(window), vbox); label = gtk_label_new(str->str); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_SPREAD); gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); closeb = gtk_button_new_with_label("Close"); GTK_WIDGET_SET_FLAGS(closeb, GTK_CAN_DEFAULT); gtk_signal_connect_object(GTK_OBJECT(closeb), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window)); gtk_box_pack_start(GTK_BOX(bbox), closeb, TRUE, TRUE, 0); gtk_widget_grab_default(closeb); g_string_free(str, TRUE); gtk_widget_show_all(window); }
static GtkWidget* configurewin_add_drive(struct driveinfo *drive, void *nb) { GtkWidget *vbox, *bbox, *dev_frame, *dev_table, *dev_label; GtkWidget *dev_dir_label, *check_btn; GtkWidget *volume_frame, *volume_box, *volume_none; GtkWidget *readmode_frame, *readmode_box, *readmode_analog; struct driveconfig *d = g_malloc(sizeof (struct driveconfig)); vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); dev_frame = gtk_frame_new(_("Device:")); gtk_box_pack_start(GTK_BOX(vbox), dev_frame, FALSE, FALSE, 0); dev_table = gtk_table_new(2, 2, FALSE); gtk_container_set_border_width(GTK_CONTAINER(dev_table), 5); gtk_container_add(GTK_CONTAINER(dev_frame), dev_table); gtk_table_set_row_spacings(GTK_TABLE(dev_table), 5); gtk_table_set_col_spacings(GTK_TABLE(dev_table), 5); dev_label = gtk_label_new(_("Device:")); gtk_misc_set_alignment(GTK_MISC(dev_label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(dev_table), dev_label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); d->device = gtk_entry_new(); gtk_table_attach(GTK_TABLE(dev_table), d->device, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, 0, 0 , 0); dev_dir_label = gtk_label_new(_("Directory:")); gtk_misc_set_alignment(GTK_MISC(dev_dir_label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(dev_table), dev_dir_label, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); d->directory = gtk_entry_new(); gtk_table_attach(GTK_TABLE(dev_table), d->directory, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, 0, 0, 0); readmode_frame = gtk_frame_new(_("Play mode:")); gtk_box_pack_start(GTK_BOX(vbox), readmode_frame, FALSE, FALSE, 0); readmode_box = gtk_vbox_new(5, FALSE); gtk_container_add(GTK_CONTAINER(readmode_frame), readmode_box); readmode_analog = gtk_radio_button_new_with_label(NULL, _("Analog")); gtk_box_pack_start(GTK_BOX(readmode_box), readmode_analog, FALSE, FALSE, 0); d->dae = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(readmode_analog), _("Digital audio extraction")); gtk_box_pack_start(GTK_BOX(readmode_box), d->dae, FALSE, FALSE, 0); #ifndef CDDA_HAS_READAUDIO gtk_widget_set_sensitive(readmode_frame, FALSE); #endif /* * Volume config */ volume_frame = gtk_frame_new(_("Volume control:")); gtk_box_pack_start(GTK_BOX(vbox), volume_frame, FALSE, FALSE, 0); volume_box = gtk_vbox_new(5, FALSE); gtk_container_add(GTK_CONTAINER(volume_frame), volume_box); volume_none = gtk_radio_button_new_with_label(NULL, _("No mixer")); gtk_box_pack_start(GTK_BOX(volume_box), volume_none, FALSE, FALSE, 0); d->mixer_drive = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(volume_none), _("CD-ROM drive")); gtk_box_pack_start(GTK_BOX(volume_box), d->mixer_drive, FALSE, FALSE, 0); d->mixer_oss = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(volume_none), _("OSS mixer")); gtk_box_pack_start(GTK_BOX(volume_box), d->mixer_oss, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(readmode_analog), "toggled", toggle_set_sensitive_cb, volume_frame); #ifndef HAVE_OSS gtk_widget_set_sensitive(d->mixer_oss, FALSE); #endif if (drive) { gtk_entry_set_text(GTK_ENTRY(d->device), drive->device); gtk_entry_set_text(GTK_ENTRY(d->directory), drive->directory); if (drive->mixer == CDDA_MIXER_DRIVE) SET_TB(d->mixer_drive); else if (drive->mixer == CDDA_MIXER_OSS) SET_TB(d->mixer_oss); if (drive->dae == CDDA_READ_DAE) SET_TB(d->dae); } bbox = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_SPREAD); check_btn = gtk_button_new_with_label(_("Check drive...")); GTK_WIDGET_SET_FLAGS(check_btn, GTK_CAN_DEFAULT); gtk_box_pack_start_defaults(GTK_BOX(bbox), check_btn); gtk_signal_connect(GTK_OBJECT(check_btn), "clicked", GTK_SIGNAL_FUNC(configurewin_check_drive), d); d->remove_button = gtk_button_new_with_label(_("Remove drive")); GTK_WIDGET_SET_FLAGS(d->remove_button, GTK_CAN_DEFAULT); gtk_box_pack_start_defaults(GTK_BOX(bbox), d->remove_button); gtk_signal_connect(GTK_OBJECT(d->remove_button), "clicked", GTK_SIGNAL_FUNC(configurewin_remove_page), nb); if (drives == NULL) gtk_widget_set_sensitive(d->remove_button, FALSE); else { struct driveconfig *tmp = drives->data; gtk_widget_set_sensitive(tmp->remove_button, TRUE); } drives = g_list_append(drives, d); return vbox; }
GtkWidget * mate_volume_applet_dock_new (GtkOrientation orientation, MateVolumeApplet *parent) { /* FIXME: Remove the orientation argument, or fix it for vertical boxes (a "horizontal" orientation - the meaning is reversed for historical reasons. */ GtkWidget *button, *scale, *mute, *more, *label; GtkWidget *container, *outerline, *innerline, *frame; MateVolumeAppletDock *dock; gint i; static struct { GtkWidget * (* sfunc) (GtkAdjustment *adj); GtkWidget * (* container) (gboolean, gint); GtkWidget * (* subcontainer) (gboolean, gint); gint sw, sh; gboolean inverted; } magic[2] = { { gtk_vscale_new, gtk_hbox_new, gtk_vbox_new, -1, 200, TRUE}, { gtk_hscale_new, gtk_vbox_new, gtk_hbox_new, 200, -1, FALSE} }; dock = g_object_new (MATE_VOLUME_APPLET_TYPE_DOCK, NULL); gtk_window_set_screen (GTK_WINDOW (dock), gtk_widget_get_screen(GTK_WIDGET (parent))); dock->orientation = orientation; dock->model = parent; g_signal_connect (dock, "key_press_event", G_CALLBACK (cb_key_press), NULL); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_container_add (GTK_CONTAINER (dock), frame); container = magic[orientation].container (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (container), 6); gtk_container_add (GTK_CONTAINER (frame), container); outerline = magic[orientation].subcontainer (FALSE, 0); innerline = magic[orientation].subcontainer (FALSE, 0); gtk_box_pack_start (GTK_BOX (container), outerline, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (container), innerline, FALSE, FALSE, 0); dock->minus = GTK_BUTTON (gtk_button_new ()); gtk_box_pack_start (GTK_BOX (outerline), GTK_WIDGET (dock->minus), FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (dock->minus), gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON)); dock->plus = GTK_BUTTON (gtk_button_new ()); gtk_box_pack_end (GTK_BOX (outerline), GTK_WIDGET (dock->plus), FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (dock->plus), gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON)); button = GTK_WIDGET (dock->plus); for (i = 0; i<2; i++) { /* For button in (dock->plus, dock->minus): */ gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); g_signal_connect (button, "button-press-event", G_CALLBACK (cb_button_press), dock); g_signal_connect (button, "button-release-event", G_CALLBACK (cb_button_release), dock); button = GTK_WIDGET (dock->minus); } scale = magic[orientation].sfunc (NULL); g_signal_connect (scale, "key-press-event", G_CALLBACK (proxy_key_event), parent); g_signal_connect (scale, "scroll-event", G_CALLBACK (proxy_scroll_event), parent); dock->scale = GTK_RANGE (scale); gtk_widget_set_size_request (scale, magic[orientation].sw, magic[orientation].sh); gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE); gtk_range_set_inverted (dock->scale, magic[orientation].inverted); gtk_box_pack_start (GTK_BOX (outerline), GTK_WIDGET (dock->scale), TRUE, TRUE, 0); dock->mute = gtk_check_button_new_with_label (_("Mute")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dock->mute), mixer_is_muted (dock->model)); g_signal_connect (dock->mute, "toggled", G_CALLBACK (mute_cb), dock); gtk_box_pack_start (GTK_BOX (innerline), dock->mute, TRUE, TRUE, 0); more = gtk_button_new_with_label (_("Volume Control...")); g_signal_connect (more, "clicked", G_CALLBACK (launch_mixer_cb), dock); gtk_box_pack_end (GTK_BOX (innerline), more, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (dock), frame); return GTK_WIDGET (dock); }
int main (int argc, char *argv[]) { GtkWidget *load_button; GtkWidget *table; GtkWidget *pixmapwid; GtkStyle *style; GdkPixmap *pixmap; GdkBitmap *mask; GtkWidget *label_core; GList *glist_gfx = NULL; GtkWidget *label_gfx; GtkWidget *config_gfx_button; GtkWidget *test_gfx_button; GtkWidget *about_gfx_button; GList *glist_audio = NULL; GtkWidget *label_audio; GtkWidget *config_audio_button; GtkWidget *test_audio_button; GtkWidget *about_audio_button; GList *glist_input = NULL; GtkWidget *label_input; GtkWidget *config_input_button; GtkWidget *test_input_button; GtkWidget *about_input_button; GList *glist_RSP = NULL; GtkWidget *label_RSP; GtkWidget *config_RSP_button; GtkWidget *test_RSP_button; GtkWidget *about_RSP_button; #ifdef DBG if (!g_thread_supported()) g_thread_init(NULL); else { fprintf(stderr, "mupen64 will certainly have problems with GTK threads.\n"); fprintf(stderr, "Check your GLIB/GDK/GTK installation for thread support.\n"); } #endif gtk_init(&argc, &argv); if (argv[0][0] != '/') { getcwd(cwd, 1024); strcat(cwd, "/"); strcat(cwd, argv[0]); } else strcpy(cwd, argv[0]); while(cwd[strlen(cwd)-1] != '/') cwd[strlen(cwd)-1] = '\0'; // création de la fenêtre window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(window), 10); gtk_widget_show(window); // création du bouton Load rom load_button = gtk_button_new_with_label("Load rom..."); gtk_widget_show(load_button); // création du logo style = gtk_widget_get_style(window); pixmap = gdk_pixmap_create_from_xpm_d(window->window, &mask, &style->bg[GTK_STATE_NORMAL], (gchar **)logo_xpm); pixmapwid = gtk_pixmap_new(pixmap, mask); gtk_widget_show(pixmapwid); // création de la selection du mode d'émulation label_core = gtk_frame_new("cpu core : "); gtk_widget_show(label_core); interp = gtk_radio_button_new_with_label(NULL, "interpreter"); gtk_widget_show(interp); dynam = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(interp)), "dynamic compiler"); gtk_widget_show(dynam); pure_interp = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(interp)), "pure interpreter"); gtk_widget_show(pure_interp); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dynam), TRUE); // création de l'option 'debugger' #ifdef DBG button_debug = gtk_check_button_new_with_label("debugger mode"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_debug), FALSE); gtk_widget_show(button_debug); #endif // recherche des plugins plugin_scan_directory(cwd); while(plugin_type() != -1) switch (plugin_type()) { case PLUGIN_TYPE_GFX: glist_gfx = g_list_append(glist_gfx, plugin_next()); break; case PLUGIN_TYPE_AUDIO: glist_audio = g_list_append(glist_audio, plugin_next()); break; case PLUGIN_TYPE_CONTROLLER: glist_input = g_list_append(glist_input, plugin_next()); break; case PLUGIN_TYPE_RSP: glist_RSP = g_list_append(glist_RSP, plugin_next()); break; } label_gfx = gtk_frame_new("gfx plugin : "); gtk_widget_show(label_gfx); combo_gfx = gtk_combo_new(); gtk_combo_set_popdown_strings(GTK_COMBO(combo_gfx), glist_gfx); gtk_combo_set_value_in_list(GTK_COMBO(combo_gfx), TRUE, FALSE); gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_gfx)->entry), FALSE); gtk_widget_show(combo_gfx); config_gfx_button = gtk_button_new_with_label("Config"); gtk_widget_show(config_gfx_button); test_gfx_button = gtk_button_new_with_label("Test"); gtk_widget_show(test_gfx_button); about_gfx_button = gtk_button_new_with_label("About"); gtk_widget_show(about_gfx_button); label_audio = gtk_frame_new("audio plugin : "); gtk_widget_show(label_audio); combo_audio = gtk_combo_new(); gtk_combo_set_popdown_strings(GTK_COMBO(combo_audio), glist_audio); gtk_combo_set_value_in_list(GTK_COMBO(combo_audio), TRUE, FALSE); gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_audio)->entry), FALSE); gtk_widget_show(combo_audio); config_audio_button = gtk_button_new_with_label("Config"); gtk_widget_show(config_audio_button); test_audio_button = gtk_button_new_with_label("Test"); gtk_widget_show(test_audio_button); about_audio_button = gtk_button_new_with_label("About"); gtk_widget_show(about_audio_button); label_input = gtk_frame_new("input plugin : "); gtk_widget_show(label_input); combo_input = gtk_combo_new(); gtk_combo_set_popdown_strings(GTK_COMBO(combo_input), glist_input); gtk_combo_set_value_in_list(GTK_COMBO(combo_input), TRUE, FALSE); gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_input)->entry), FALSE); gtk_widget_show(combo_input); config_input_button = gtk_button_new_with_label("Config"); gtk_widget_show(config_input_button); test_input_button = gtk_button_new_with_label("Test"); gtk_widget_show(test_input_button); about_input_button = gtk_button_new_with_label("About"); gtk_widget_show(about_input_button); label_RSP = gtk_frame_new("RSP plugin : "); gtk_widget_show(label_RSP); combo_RSP = gtk_combo_new(); gtk_combo_set_popdown_strings(GTK_COMBO(combo_RSP), glist_RSP); gtk_combo_set_value_in_list(GTK_COMBO(combo_RSP), TRUE, FALSE); gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_RSP)->entry), FALSE); gtk_widget_show(combo_RSP); config_RSP_button = gtk_button_new_with_label("Config"); gtk_widget_show(config_RSP_button); test_RSP_button = gtk_button_new_with_label("Test"); gtk_widget_show(test_RSP_button); about_RSP_button = gtk_button_new_with_label("About"); gtk_widget_show(about_RSP_button); // mise en place des évenements gtk_signal_connect(GTK_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC(delete_event), NULL); gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(destroy), NULL); gtk_signal_connect(GTK_OBJECT(load_button), "clicked", GTK_SIGNAL_FUNC(load), NULL); gtk_signal_connect(GTK_OBJECT(config_gfx_button), "clicked", GTK_SIGNAL_FUNC(config_gfx), NULL); gtk_signal_connect(GTK_OBJECT(test_gfx_button), "clicked", GTK_SIGNAL_FUNC(test_gfx), NULL); gtk_signal_connect(GTK_OBJECT(about_gfx_button), "clicked", GTK_SIGNAL_FUNC(about_gfx), NULL); gtk_signal_connect(GTK_OBJECT(config_audio_button), "clicked", GTK_SIGNAL_FUNC(config_audio), NULL); gtk_signal_connect(GTK_OBJECT(test_audio_button), "clicked", GTK_SIGNAL_FUNC(test_audio), NULL); gtk_signal_connect(GTK_OBJECT(about_audio_button), "clicked", GTK_SIGNAL_FUNC(about_audio), NULL); gtk_signal_connect(GTK_OBJECT(config_input_button), "clicked", GTK_SIGNAL_FUNC(config_input), NULL); gtk_signal_connect(GTK_OBJECT(test_input_button), "clicked", GTK_SIGNAL_FUNC(test_input), NULL); gtk_signal_connect(GTK_OBJECT(about_input_button), "clicked", GTK_SIGNAL_FUNC(about_input), NULL); gtk_signal_connect(GTK_OBJECT(config_RSP_button), "clicked", GTK_SIGNAL_FUNC(config_RSP), NULL); gtk_signal_connect(GTK_OBJECT(test_RSP_button), "clicked", GTK_SIGNAL_FUNC(test_RSP), NULL); gtk_signal_connect(GTK_OBJECT(about_RSP_button), "clicked", GTK_SIGNAL_FUNC(about_RSP), NULL); // mise en page table = gtk_table_new(55, 30, TRUE); gtk_widget_show(table); gtk_container_add(GTK_CONTAINER(window), table); gtk_table_attach_defaults(GTK_TABLE(table), load_button, 0, 10, 0, 3); gtk_table_attach_defaults(GTK_TABLE(table), label_core, 0, 10, 5, 15); gtk_table_attach_defaults(GTK_TABLE(table), pixmapwid, 10, 30, 0, 10); gtk_table_attach_defaults(GTK_TABLE(table), interp, 1, 10, 6, 9); gtk_table_attach_defaults(GTK_TABLE(table), dynam, 1, 10, 9, 12); gtk_table_attach_defaults(GTK_TABLE(table), pure_interp, 1, 10, 12, 15); #ifdef DBG gtk_table_attach_defaults(GTK_TABLE(table), button_debug, 15, 25, 12, 15); #endif gtk_table_attach_defaults(GTK_TABLE(table), label_gfx, 0, 30, 15, 25); gtk_table_attach_defaults(GTK_TABLE(table), combo_gfx, 1, 29, 17, 22); gtk_table_attach_defaults(GTK_TABLE(table), config_gfx_button, 1, 10, 22, 24); gtk_table_attach_defaults(GTK_TABLE(table), test_gfx_button, 10, 20, 22, 24); gtk_table_attach_defaults(GTK_TABLE(table), about_gfx_button, 20, 29, 22, 24); gtk_table_attach_defaults(GTK_TABLE(table), label_audio, 0, 30, 25, 35); gtk_table_attach_defaults(GTK_TABLE(table), combo_audio, 1, 29, 27, 32); gtk_table_attach_defaults(GTK_TABLE(table), config_audio_button, 1, 10, 32, 34); gtk_table_attach_defaults(GTK_TABLE(table), test_audio_button, 10, 20, 32, 34); gtk_table_attach_defaults(GTK_TABLE(table), about_audio_button, 20, 29, 32, 34); gtk_table_attach_defaults(GTK_TABLE(table), label_input, 0, 30, 35, 45); gtk_table_attach_defaults(GTK_TABLE(table), combo_input, 1, 29, 37, 42); gtk_table_attach_defaults(GTK_TABLE(table), config_input_button, 1, 10, 42, 44); gtk_table_attach_defaults(GTK_TABLE(table), test_input_button, 10, 20, 42, 44); gtk_table_attach_defaults(GTK_TABLE(table), about_input_button, 20, 29, 42, 44); gtk_table_attach_defaults(GTK_TABLE(table), label_RSP, 0, 30, 45, 55); gtk_table_attach_defaults(GTK_TABLE(table), combo_RSP, 1, 29, 47, 52); gtk_table_attach_defaults(GTK_TABLE(table), config_RSP_button, 1, 10, 52, 54); gtk_table_attach_defaults(GTK_TABLE(table), test_RSP_button, 10, 20, 52, 54); gtk_table_attach_defaults(GTK_TABLE(table), about_RSP_button, 20, 29, 52, 54); gtk_main(); return 0; }
/* Creates menu item. Text and image are read from xconf. Action * depends on @menu. If @menu is NULL, action is to execute external * command. Otherwise it is to pop up @menu menu */ static GtkWidget * menu_create_item(xconf *xc, GtkWidget *menu, menu_priv *m) { gchar *name, *fname, *iname, *action, *cmd; GtkWidget *mi; cmd = name = fname = action = iname = NULL; XCG(xc, "name", &name, str); mi = gtk_image_menu_item_new_with_label(name ? name : ""); gtk_container_set_border_width(GTK_CONTAINER(mi), 0); XCG(xc, "image", &fname, str); fname = expand_tilda(fname); XCG(xc, "icon", &iname, str); if (fname || iname) { GdkPixbuf *pb; if ((pb = fb_pixbuf_new(iname, fname, m->icon_size, m->icon_size, FALSE))) { gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), gtk_image_new_from_pixbuf(pb)); g_object_unref(G_OBJECT(pb)); } } g_free(fname); if (menu) { gtk_menu_item_set_submenu(GTK_MENU_ITEM(mi), menu); goto done; } XCG(xc, "action", &action, str); if (action) { action = expand_tilda(action); g_signal_connect_swapped(G_OBJECT(mi), "activate", (GCallback)run_app, action); g_object_set_data_full(G_OBJECT(mi), "activate", action, g_free); goto done; } XCG(xc, "command", &cmd, str); if (cmd) { /* XXX: implement command API */ #if 0 command *tmp; for (tmp = commands; tmp->name; tmp++) if (!g_ascii_strcasecmp(cmd, tmp->name)) { g_signal_connect(G_OBJECT(mi), "activate", (GCallback)run_command, tmp->cmd); goto done; } #endif } done: return mi; }
int l_uosindm(int innom,GtkWidget *wpredok) { l_uosindm_data data; char bros[512]; SQL_str row; class SQLCURSOR cur; data.innom=innom; sprintf(bros,"select naim from Uosin where innom=%d",innom); if(iceb_sql_readkey(bros,&row,&cur,wpredok) == 1) data.naim_in.new_plus(row[0]); data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); sprintf(bros,"%s %s",name_system,gettext("Список драгоценных металлов")); gtk_window_set_title (GTK_WINDOW (data.window),bros); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_uosindm_key_press),&data); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift); GtkWidget *hbox = gtk_hbox_new (FALSE, 1); gtk_container_add (GTK_CONTAINER (data.window), hbox); GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1); GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1); gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); gtk_widget_show(hbox); data.label_kolstr=gtk_label_new (gettext("Список драгоценных металлов")); //gdk_color_parse("green",&color); //gtk_widget_modify_fg(data.label_kolstr,GTK_STATE_NORMAL,&color); gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0); gtk_widget_show(vbox1); gtk_widget_show(vbox2); data.sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_usize(GTK_WIDGET(data.sw),400,300); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); //gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0); //Кнопки GtkTooltips *tooltips[KOL_F_KL]; sprintf(bros,"F2 %s",gettext("Запись")); data.knopka[FK2]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_widget_show(data.knopka[FK2]); sprintf(bros,"%sF2 %s",RFK,gettext("Корректировать")); data.knopka[SFK2]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data); tooltips[SFK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2); gtk_widget_show(data.knopka[SFK2]); sprintf(bros,"F3 %s",gettext("Удалить")); data.knopka[FK3]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data); tooltips[FK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удаление выбранной записи"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3); gtk_widget_show(data.knopka[FK3]); sprintf(bros,"F5 %s",gettext("Печать")); data.knopka[FK5]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data); tooltips[FK5]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5); gtk_widget_show(data.knopka[FK5]); sprintf(bros,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_widget_show(data.knopka[FK10]); gtk_widget_realize(data.window); gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR)); gtk_widget_grab_focus(data.knopka[FK10]); l_uosindm_create_list(&data); gtk_widget_show(data.window); gtk_window_maximize(GTK_WINDOW(data.window)); //gtk_window_fullscreen(GTK_WINDOW(data.window)); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.metka_voz); }
static void create_adapter(adapter_data *adapter) { GHashTable *hash = NULL; GValue *value; DBusGProxy *default_proxy; const gchar *name; gboolean powered, discoverable; guint timeout; GtkWidget *mainbox; GtkWidget *vbox; GtkWidget *alignment; GtkWidget *table; GtkWidget *label; GtkWidget *image; GtkWidget *button; GtkWidget *entry; GtkWidget *buttonbox; int page_num; dbus_g_proxy_call(adapter->proxy, "GetProperties", NULL, G_TYPE_INVALID, dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &hash, G_TYPE_INVALID); if (hash != NULL) { value = g_hash_table_lookup(hash, "Name"); name = value ? g_value_get_string(value) : NULL; value = g_hash_table_lookup(hash, "Powered"); powered = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "Discoverable"); discoverable = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "DiscoverableTimeout"); timeout = value ? g_value_get_uint(value) : 0; } else { name = NULL; powered = FALSE; discoverable = FALSE; timeout = 0; } adapter->powered = powered; adapter->discoverable = discoverable; adapter->timeout_value = timeout; default_proxy = bluetooth_client_get_default_adapter (client); if (default_proxy != NULL) { adapter->is_default = g_str_equal (dbus_g_proxy_get_path (default_proxy), dbus_g_proxy_get_path (adapter->proxy)); g_object_unref (default_proxy); } mainbox = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12); page_num = gtk_notebook_prepend_page(GTK_NOTEBOOK(adapter->notebook), mainbox, NULL); adapter->child = mainbox; vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, TRUE, 0); /* The discoverable checkbox */ button = gtk_check_button_new_with_mnemonic (_("Make computer _visible")); if (powered == FALSE) discoverable = FALSE; if (discoverable != FALSE && timeout == 0) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); else if (discoverable == FALSE) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE); } gtk_widget_set_sensitive (button, adapter->powered); adapter->button_discoverable = button; adapter->signal_discoverable = g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(discoverable_changed_cb), adapter); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); /* The friendly name */ vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); label = create_label(_("Friendly name")); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(entry), 248); gtk_widget_set_size_request(entry, 240, -1); gtk_container_add (GTK_CONTAINER (alignment), entry); if (name != NULL) gtk_entry_set_text(GTK_ENTRY(entry), name); adapter->entry = entry; adapter->name_vbox = vbox; g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(name_callback), adapter); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(focus_callback), adapter); gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered); /* The known devices */ table = gtk_table_new(2, 2, FALSE); gtk_box_pack_start(GTK_BOX(mainbox), table, TRUE, TRUE, 0); label = create_label(_("Devices")); gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 6); /* Note that this will only ever show the devices on the default * adapter, this is on purpose */ adapter->chooser = bluetooth_chooser_new (NULL); g_object_set (adapter->chooser, "show-searching", FALSE, "show-device-type", FALSE, "show-device-category", FALSE, "show-pairing", TRUE, "show-connected", TRUE, "device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED, NULL); g_signal_connect (adapter->chooser, "notify::device-selected", G_CALLBACK(device_selected_cb), adapter); gtk_table_attach(GTK_TABLE(table), adapter->chooser, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); adapter->devices_table = table; buttonbox = gtk_vbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_START); gtk_box_set_spacing(GTK_BOX(buttonbox), 6); gtk_box_set_homogeneous(GTK_BOX(buttonbox), FALSE); gtk_table_attach(GTK_TABLE(table), buttonbox, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 6, 6); button = gtk_button_new_with_mnemonic(_("Set up _new device...")); image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wizard_callback), adapter); button = gtk_button_new_with_label(_("Disconnect")); image = gtk_image_new_from_stock(GTK_STOCK_DISCONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(disconnect_callback), adapter); adapter->button_disconnect = button; button = gtk_button_new_with_mnemonic(_("_Remove")); image = gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remove_callback), adapter); adapter->button_delete = button; gtk_widget_set_sensitive (adapter->devices_table, adapter->powered); g_object_set_data(G_OBJECT(mainbox), "adapter", adapter); gtk_widget_show_all(mainbox); if (adapter->is_default != FALSE) gtk_notebook_set_current_page (GTK_NOTEBOOK (adapter->notebook), page_num); }
/** * create_directory_config_window(): Create the Directory Configuration Window. * @return Directory Configuration Window. */ GtkWidget* create_directory_config_window(void) { GdkPixbuf *directory_config_window_icon_pixbuf; GtkWidget *vbox_dc; GtkWidget *frame_direntry = NULL, *label_frame_direntry = NULL, *table_frame_direntry = NULL; GtkWidget *label_direntry = NULL, *entry_direntry = NULL, *button_direntry = NULL; GtkWidget *hbutton_box_dc_buttonRow; GtkWidget *button_dc_Cancel, *button_dc_Apply, *button_dc_Save; char tmp[64]; int dir = 0; if (directory_config_window) { // Directory Configuration window is already created. Set focus. gtk_widget_grab_focus(directory_config_window); return NULL; } accel_group = gtk_accel_group_new(); // Create the Directory Configuration window. CREATE_GTK_WINDOW(directory_config_window, "directory_config_window", "Configure Directories", directory_config_window_icon_pixbuf, "Gens2.ico"); // Callbacks for if the window is closed. g_signal_connect((gpointer)directory_config_window, "delete_event", G_CALLBACK(on_directory_config_window_close), NULL); g_signal_connect((gpointer)directory_config_window, "destroy_event", G_CALLBACK(on_directory_config_window_close), NULL); // Create the main VBox. vbox_dc = gtk_vbox_new(FALSE, 10); gtk_widget_set_name(vbox_dc, "vbox_dc"); gtk_widget_show(vbox_dc); gtk_container_add(GTK_CONTAINER(directory_config_window), vbox_dc); GLADE_HOOKUP_OBJECT(directory_config_window, vbox_dc, "vbox_dc"); // Create the directory entry frame. frame_direntry = gtk_frame_new(NULL); gtk_widget_set_name(frame_direntry, "frame_direntry"); gtk_container_set_border_width(GTK_CONTAINER(frame_direntry), 4); gtk_frame_set_shadow_type(GTK_FRAME(frame_direntry), GTK_SHADOW_ETCHED_IN); gtk_widget_show(frame_direntry); gtk_box_pack_start(GTK_BOX(vbox_dc), frame_direntry, TRUE, TRUE, 0); GLADE_HOOKUP_OBJECT(directory_config_window, frame_direntry, "frame_direntry"); // Add the frame label. label_frame_direntry = gtk_label_new("<b><i>Configure Directories</i></b>"); gtk_widget_set_name(label_frame_direntry, "label_frame_direntry"); gtk_label_set_use_markup(GTK_LABEL(label_frame_direntry), TRUE); gtk_widget_show(label_frame_direntry); gtk_frame_set_label_widget(GTK_FRAME(frame_direntry), label_frame_direntry); GLADE_HOOKUP_OBJECT(directory_config_window, label_frame_direntry, "label_frame_direntry"); // Add the frame table. table_frame_direntry = gtk_table_new(1, 3, FALSE); gtk_widget_set_name(table_frame_direntry, "table_frame_direntry"); gtk_container_set_border_width(GTK_CONTAINER(table_frame_direntry), 8); gtk_table_set_row_spacings(GTK_TABLE(table_frame_direntry), 4); gtk_table_set_col_spacings(GTK_TABLE(table_frame_direntry), 4); gtk_widget_show(table_frame_direntry); gtk_container_add(GTK_CONTAINER(frame_direntry), table_frame_direntry); GLADE_HOOKUP_OBJECT(directory_config_window, table_frame_direntry, "table_frame_direntry"); // Create all directory entries. while (DirEntries[dir].title) { // Check if the table needs to be resized. if (dir > 0) gtk_table_resize(GTK_TABLE(table_frame_direntry), dir + 1, 3); // Create the label for this file. sprintf(tmp, "label_%s", DirEntries[dir].tag); label_direntry = gtk_label_new(DirEntries[dir].title); gtk_widget_set_name(label_direntry, tmp); gtk_widget_set_size_request(label_direntry, 100, -1); gtk_misc_set_alignment(GTK_MISC(label_direntry), 0, 0.5); gtk_widget_show(label_direntry); gtk_table_attach(GTK_TABLE(table_frame_direntry), label_direntry, 0, 1, dir, dir + 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); GLADE_HOOKUP_OBJECT(directory_config_window, label_direntry, tmp); // Create the entry for this file. sprintf(tmp, "entry_%s", DirEntries[dir].tag); entry_direntry = gtk_entry_new(); gtk_widget_set_name(entry_direntry, tmp); gtk_entry_set_max_length(GTK_ENTRY(entry_direntry), GENS_PATH_MAX - 1); gtk_entry_set_text(GTK_ENTRY(entry_direntry), DirEntries[dir].entry); gtk_widget_set_size_request(entry_direntry, 250, -1); gtk_widget_show(entry_direntry); gtk_table_attach(GTK_TABLE(table_frame_direntry), entry_direntry, 1, 2, dir, dir + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(0), 0, 0); GLADE_HOOKUP_OBJECT(directory_config_window, entry_direntry, tmp); // Create the button for this file. // TODO: Use an icon? sprintf(tmp, "button_%s", DirEntries[dir].tag); button_direntry = gtk_button_new_with_label("Change..."); gtk_widget_set_name(button_direntry, tmp); gtk_widget_show(button_direntry); gtk_table_attach(GTK_TABLE(table_frame_direntry), button_direntry, 2, 3, dir, dir + 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); g_signal_connect((gpointer)button_direntry, "clicked", G_CALLBACK(on_button_dc_Change_clicked), GINT_TO_POINTER(dir)); GLADE_HOOKUP_OBJECT(directory_config_window, button_direntry, tmp); dir++; } // HButton Box for the row of buttons on the bottom of the window hbutton_box_dc_buttonRow = gtk_hbutton_box_new(); gtk_widget_set_name(hbutton_box_dc_buttonRow, "hbutton_box_dc_buttonRow"); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbutton_box_dc_buttonRow), GTK_BUTTONBOX_END); gtk_widget_show(hbutton_box_dc_buttonRow); gtk_box_pack_start(GTK_BOX(vbox_dc), hbutton_box_dc_buttonRow, FALSE, FALSE, 0); GLADE_HOOKUP_OBJECT(directory_config_window, hbutton_box_dc_buttonRow, "hbutton_box_dc_buttonRow"); // Cancel button_dc_Cancel = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_set_name(button_dc_Cancel, "button_dc_cancel"); gtk_widget_show(button_dc_Cancel); gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Cancel, FALSE, FALSE, 0); gtk_widget_add_accelerator(button_dc_Cancel, "activate", accel_group, GDK_Escape, (GdkModifierType)(0), (GtkAccelFlags)(0)); AddButtonCallback_Clicked(button_dc_Cancel, on_button_dc_Cancel_clicked); GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Cancel, "button_dc_Cancel"); // Apply button_dc_Apply = gtk_button_new_from_stock("gtk-apply"); gtk_widget_set_name(button_dc_Apply, "button_dc_Apply"); gtk_widget_show(button_dc_Apply); gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Apply, FALSE, FALSE, 0); gtk_widget_add_accelerator(button_dc_Apply, "activate", accel_group, GDK_Escape, (GdkModifierType)(0), (GtkAccelFlags)(0)); AddButtonCallback_Clicked(button_dc_Apply, on_button_dc_Apply_clicked); GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Apply, "button_dc_Apply"); // Save button_dc_Save = gtk_button_new_from_stock("gtk-save"); gtk_widget_set_name(button_dc_Save, "button_dc_Save"); gtk_widget_show(button_dc_Save); gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Save, FALSE, FALSE, 0); gtk_widget_add_accelerator(button_dc_Save, "activate", accel_group, GDK_Return, (GdkModifierType)(0), (GtkAccelFlags)(0)); gtk_widget_add_accelerator(button_dc_Save, "activate", accel_group, GDK_KP_Enter, (GdkModifierType)(0), (GtkAccelFlags)(0)); AddButtonCallback_Clicked(button_dc_Save, on_button_dc_Save_clicked); GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Save, "button_dc_Save"); // Add the accel group. gtk_window_add_accel_group(GTK_WINDOW(directory_config_window), accel_group); return directory_config_window; }
void cdda_configure(void) { GtkWidget *vbox, *notebook; GtkWidget *dev_vbox, *dev_notebook, *add_drive, *add_bbox; GtkWidget *cdi_vbox; GtkWidget *cdi_cddb_frame, *cdi_cddb_vbox, *cdi_cddb_hbox; GtkWidget *cdi_cddb_server_hbox, *cdi_cddb_server_label; GtkWidget *cdi_cddb_server_list, *cdi_cddb_debug_win; #if 0 GtkWidget *cdi_cdin_frame, *cdi_cdin_vbox; GtkWidget *cdi_cdin_server_hbox, *cdi_cdin_server_label; #endif GtkWidget *cdi_name_frame, *cdi_name_vbox, *cdi_name_hbox; GtkWidget *cdi_name_label, *cdi_desc; GtkWidget *cdi_name_enable_vbox; GtkWidget *bbox, *ok, *cancel; GList *node; int i = 1; if (cdda_configure_win) return; cdda_configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_signal_connect(GTK_OBJECT(cdda_configure_win), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &cdda_configure_win); gtk_window_set_title(GTK_WINDOW(cdda_configure_win), _("CD Audio Player Configuration")); gtk_window_set_policy(GTK_WINDOW(cdda_configure_win), FALSE, FALSE, FALSE); gtk_window_set_position(GTK_WINDOW(cdda_configure_win), GTK_WIN_POS_MOUSE); gtk_container_border_width(GTK_CONTAINER(cdda_configure_win), 10); vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(cdda_configure_win), vbox); notebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0); /* * Device config */ dev_vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(dev_vbox), 5); dev_notebook = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(dev_notebook), TRUE); gtk_box_pack_start(GTK_BOX(dev_vbox), dev_notebook, FALSE, FALSE, 0); for (node = cdda_cfg.drives; node; node = node->next) { struct driveinfo *drive = node->data; char *label = g_strdup_printf(_("Drive %d"), i++); GtkWidget *w; w = configurewin_add_drive(drive, dev_notebook); gtk_notebook_append_page(GTK_NOTEBOOK(dev_notebook), w, gtk_label_new(label)); g_free(label); } add_bbox = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(dev_vbox), add_bbox, FALSE, FALSE, 0); add_drive = gtk_button_new_with_label(_("Add drive")); gtk_signal_connect(GTK_OBJECT(add_drive), "clicked", GTK_SIGNAL_FUNC(configurewin_add_page), dev_notebook); GTK_WIDGET_SET_FLAGS(add_drive, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(add_bbox), add_drive, FALSE, FALSE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), dev_vbox, gtk_label_new(_("Device"))); /* * CD Info config */ cdi_vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(cdi_vbox), 5); /* CDDB */ cdi_cddb_frame = gtk_frame_new(_("CDDB:")); gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_cddb_frame, FALSE, FALSE, 0); cdi_cddb_vbox = gtk_vbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(cdi_cddb_vbox), 5); gtk_container_add(GTK_CONTAINER(cdi_cddb_frame), cdi_cddb_vbox); cdi_cddb_hbox = gtk_hbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(cdi_cddb_hbox), 0); gtk_box_pack_start(GTK_BOX(cdi_cddb_vbox), cdi_cddb_hbox, FALSE, FALSE, 0); cdi_use_cddb = gtk_check_button_new_with_label(_("Use CDDB")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_use_cddb), cdda_cfg.use_cddb); gtk_box_pack_start(GTK_BOX(cdi_cddb_hbox), cdi_use_cddb, FALSE, FALSE, 0); cdi_cddb_server_list = gtk_button_new_with_label(_("Get server list")); gtk_box_pack_end(GTK_BOX(cdi_cddb_hbox), cdi_cddb_server_list, FALSE, FALSE, 0); cdi_cddb_debug_win = gtk_button_new_with_label(_("Show network window")); gtk_signal_connect(GTK_OBJECT(cdi_cddb_debug_win), "clicked", GTK_SIGNAL_FUNC(cdda_cddb_show_network_window), NULL); gtk_box_pack_end(GTK_BOX(cdi_cddb_hbox), cdi_cddb_debug_win, FALSE, FALSE, 0); cdi_cddb_server_hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(cdi_cddb_vbox), cdi_cddb_server_hbox, FALSE, FALSE, 0); cdi_cddb_server_label = gtk_label_new(_("CDDB server:")); gtk_box_pack_start(GTK_BOX(cdi_cddb_server_hbox), cdi_cddb_server_label, FALSE, FALSE, 0); cdi_cddb_server = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(cdi_cddb_server), cdda_cfg.cddb_server); gtk_box_pack_start(GTK_BOX(cdi_cddb_server_hbox), cdi_cddb_server, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(cdi_cddb_server_list), "clicked", GTK_SIGNAL_FUNC(cdda_cddb_show_server_dialog), cdi_cddb_server); #if 0 /* * CDindex */ cdi_cdin_frame = gtk_frame_new(_("CD Index:")); gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_cdin_frame, FALSE, FALSE, 0); cdi_cdin_vbox = gtk_vbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(cdi_cdin_vbox), 5); gtk_container_add(GTK_CONTAINER(cdi_cdin_frame), cdi_cdin_vbox); cdi_use_cdin = gtk_check_button_new_with_label(_("Use CD Index")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_use_cdin), cdda_cfg.use_cdin); gtk_box_pack_start(GTK_BOX(cdi_cdin_vbox), cdi_use_cdin, FALSE, FALSE, 0); cdi_cdin_server_hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(cdi_cdin_vbox), cdi_cdin_server_hbox, FALSE, FALSE, 0); cdi_cdin_server_label = gtk_label_new(_("CD Index server:")); gtk_box_pack_start(GTK_BOX(cdi_cdin_server_hbox), cdi_cdin_server_label, FALSE, FALSE, 0); cdi_cdin_server = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(cdi_cdin_server), cdda_cfg.cdin_server); gtk_box_pack_start(GTK_BOX(cdi_cdin_server_hbox), cdi_cdin_server, TRUE, TRUE, 0); #ifndef WITH_CDINDEX gtk_widget_set_sensitive(cdi_cdin_frame, FALSE); #endif #endif /* * Track names */ cdi_name_frame = gtk_frame_new(_("Track names:")); gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_name_frame, FALSE, FALSE, 0); cdi_name_vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(cdi_name_frame), cdi_name_vbox); gtk_container_border_width(GTK_CONTAINER(cdi_name_vbox), 5); cdi_name_override = gtk_check_button_new_with_label(_("Override generic titles")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_name_override), cdda_cfg.title_override); gtk_box_pack_start(GTK_BOX(cdi_name_vbox), cdi_name_override, FALSE, FALSE, 0); cdi_name_enable_vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(cdi_name_vbox), cdi_name_enable_vbox); gtk_widget_set_sensitive(cdi_name_enable_vbox, cdda_cfg.title_override); gtk_signal_connect(GTK_OBJECT(cdi_name_override), "toggled", toggle_set_sensitive_cb, cdi_name_enable_vbox); cdi_name_hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(cdi_name_enable_vbox), cdi_name_hbox, FALSE, FALSE, 0); cdi_name_label = gtk_label_new(_("Name format:")); gtk_box_pack_start(GTK_BOX(cdi_name_hbox), cdi_name_label, FALSE, FALSE, 0); cdi_name = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(cdi_name), cdda_cfg.name_format); gtk_box_pack_start(GTK_BOX(cdi_name_hbox), cdi_name, TRUE, TRUE, 0); cdi_desc = xmms_titlestring_descriptions("patn", 2); gtk_box_pack_start(GTK_BOX(cdi_name_enable_vbox), cdi_desc, FALSE, FALSE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), cdi_vbox, gtk_label_new(_("CD Info"))); bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); ok = gtk_button_new_with_label(_("OK")); gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(cdda_configurewin_ok_cb), NULL); gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(configurewin_close), NULL); GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0); gtk_widget_grab_default(ok); cancel = gtk_button_new_with_label(_("Cancel")); gtk_signal_connect(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(configurewin_close), NULL); GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0); gtk_widget_show_all(cdda_configure_win); }
int main( int argc, char *argv[] ) { /* GtkWidget is the storage type for widgets */ GtkWidget *window; GtkWidget *button; GtkWidget *box1; /* This is called in all GTK applications. Arguments are parsed * from the command line and are returned to the application. */ gtk_init (&argc, &argv); /* Create a new window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); /* This is a new call, which just sets the title of our * new window to "Hello Buttons!" */ gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!"); /* Here we just set a handler for delete_event that immediately * exits GTK. */ g_signal_connect (window, "delete-event", G_CALLBACK (delete_event), NULL); /* Sets the border width of the window. */ gtk_container_set_border_width (GTK_CONTAINER (window), 10); /* We create a box to pack widgets into. This is described in detail * in the "packing" section. The box is not really visible, it * is just used as a tool to arrange widgets. */ box1 = gtk_hbox_new (FALSE, 0); /* Put the box into the main window. */ gtk_container_add (GTK_CONTAINER (window), box1); /* Creates a new button with the label "Button 1". */ button = gtk_button_new_with_label ("Button 1"); /* Now when the button is clicked, we call the "callback" function * with a pointer to "button 1" as its argument */ g_signal_connect (button, "clicked", G_CALLBACK (callback), (gpointer) "button 1"); /* Instead of gtk_container_add, we pack this button into the invisible * box, which has been packed into the window. */ gtk_box_pack_start (GTK_BOX(box1), button, TRUE, TRUE, 0); /* Always remember this step, this tells GTK that our preparation for * this button is complete, and it can now be displayed. */ gtk_widget_show (button); /* Do these same steps again to create a second button */ button = gtk_button_new_with_label ("Button 2"); /* Call the same callback function with a different argument, * passing a pointer to "button 2" instead. */ g_signal_connect (button, "clicked", G_CALLBACK (callback), (gpointer) "button 2"); gtk_box_pack_start(GTK_BOX (box1), button, TRUE, TRUE, 0); /* The order in which we show the buttons is not really important, but I * recommend showing the window last, so it all pops up at once. */ gtk_widget_show (button); gtk_widget_show (box1); gtk_widget_show (window); /* Rest in gtk_main and wait for the fun to begin! */ gtk_main (); return 0; }
bool gtkgui_init(int argc, char *argv[], Stream_mixer *mix) { GtkWidget *bbox = NULL; bool isx = false; /* FIXME: bisogan mettere l'enable_nls*/ /* i18n */ setlocale(LC_ALL, ""); bindtextdomain("muse", LOCALEDIR); bind_textdomain_codeset("muse", "UTF-8"); textdomain("muse"); /* initialization */ state = true; mixer = mix; list_init(&listachan); list_init(&lamelist); list_init(&ogglist); iceprof = lameprof = vorbisprof = NULL; if(!profile_init()) error(_("profile initialization error")); profile_ice_load(); /* profile_lame_load and profile_vorbis_load are into encoder.cpp */ pathfile = NULL; /* signal to glib we're going to use threads */ g_thread_init(NULL); isx = gtk_init_check(&argc,&argv); if(!isx) return false; isx = mixer->set_lineout(true); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), _("MuSE-cvs Gtk+2")); gtk_window_set_resizable(GTK_WINDOW(window), FALSE); gtk_container_set_border_width(GTK_CONTAINER(window), 12); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(gcb_exit), NULL); /* FIXME: gtk2 remove ? */ gtk_widget_realize(window); vbox=gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); fix = gtk_fixed_new(); gtk_box_pack_start(GTK_BOX(vbox), fix, FALSE, FALSE, 0); bbox = createbbox(bbox); gtk_fixed_put(GTK_FIXED(fix), bbox, 0, 0); if(isx) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speakout), TRUE); pack_new(); createch(); putstatusbar(); /*let's show window */ gtk_widget_show_all(window); gtk_widget_hide(pack1.hscale); gtk_widget_hide(pack2.hscale); gtk_widget_hide(pack3.hscale); return true; }
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), "List Store"); 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; }
static void gdict_applet_build_window (GdictApplet *applet) { GdictAppletPrivate *priv = applet->priv; GtkWidget *window; GtkWidget *frame; GtkWidget *vbox; GtkWidget *bbox; GtkWidget *button; if (!priv->entry) { g_warning ("No entry widget defined"); return; } window = gdict_aligned_window_new (priv->toggle); g_signal_connect (window, "key-press-event", G_CALLBACK (window_key_press_event_cb), applet); g_signal_connect (window, "show", G_CALLBACK (window_show_cb), applet); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (window), frame); gtk_widget_show (frame); priv->frame = frame; vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); priv->defbox = gdict_defbox_new (); if (priv->context) gdict_defbox_set_context (GDICT_DEFBOX (priv->defbox), priv->context); gtk_box_pack_start (GTK_BOX (vbox), priv->defbox, TRUE, TRUE, 0); gtk_widget_show (priv->defbox); gtk_widget_set_can_focus (priv->defbox, TRUE); gtk_widget_set_can_default (priv->defbox, TRUE); bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (bbox), 6); gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 0); gtk_widget_show (bbox); button = gtk_button_new_from_stock (GTK_STOCK_CLEAR); gtk_widget_set_tooltip_text (button, _("Clear the definitions found")); set_atk_name_description (button, _("Clear definition"), _("Clear the text of the definition")); g_signal_connect (button, "clicked", G_CALLBACK (clear_cb), applet); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gtk_button_new_from_stock (GTK_STOCK_PRINT); gtk_widget_set_tooltip_text (button, _("Print the definitions found")); set_atk_name_description (button, _("Print definition"), _("Print the text of the definition")); g_signal_connect (button, "clicked", G_CALLBACK (print_cb), applet); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gtk_button_new_from_stock (GTK_STOCK_SAVE); gtk_widget_set_tooltip_text (button, _("Save the definitions found")); set_atk_name_description (button, _("Save definition"), _("Save the text of the definition to a file")); g_signal_connect (button, "clicked", G_CALLBACK (save_cb), applet); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_window_set_default (GTK_WINDOW (window), priv->defbox); priv->window = window; priv->is_window_showing = FALSE; }
static void prefs_summary_column_create(void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *label_hbox; GtkWidget *label; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *clist_hbox; GtkWidget *scrolledwin; GtkWidget *stock_clist; GtkWidget *shown_clist; GtkWidget *btn_vbox; GtkWidget *btn_vbox1; GtkWidget *add_btn; GtkWidget *remove_btn; GtkWidget *up_btn; GtkWidget *down_btn; GtkWidget *btn_hbox; GtkWidget *default_btn; GtkWidget *confirm_area; GtkWidget *ok_btn; GtkWidget *cancel_btn; gchar *title[1]; debug_print("Creating summary column setting window...\n"); window = gtk_window_new(GTK_WINDOW_DIALOG); gtk_container_set_border_width(GTK_CONTAINER(window), 8); gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(window), TRUE); gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE); gtk_window_set_title(GTK_WINDOW(window), _("Displayed items configuration")); gtk_signal_connect(GTK_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC(prefs_summary_column_delete_event), NULL); gtk_signal_connect(GTK_OBJECT(window), "key_press_event", GTK_SIGNAL_FUNC(prefs_summary_column_key_pressed), NULL); vbox = gtk_vbox_new(FALSE, 6); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(window), vbox); label_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(label_hbox); gtk_box_pack_start(GTK_BOX(vbox), label_hbox, FALSE, FALSE, 4); label = gtk_label_new (_("Select items to be displayed in the summary view. You can modify\n" "the order by using the Up / Down buttons or by dragging the items.")); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(label_hbox), label, FALSE, FALSE, 4); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); vbox1 = gtk_vbox_new(FALSE, VSPACING); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox1), 2); hbox1 = gtk_hbox_new(FALSE, 8); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0); clist_hbox = gtk_hbox_new(FALSE, 8); gtk_widget_show(clist_hbox); gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0); scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_usize(scrolledwin, 180, 210); gtk_widget_show(scrolledwin); gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); title[0] = _("Available items"); stock_clist = gtk_clist_new_with_titles(1, title); gtk_widget_show(stock_clist); gtk_container_add(GTK_CONTAINER(scrolledwin), stock_clist); gtk_clist_set_selection_mode(GTK_CLIST(stock_clist), GTK_SELECTION_BROWSE); GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(stock_clist)->column[0].button, GTK_CAN_FOCUS); /* add/remove button */ btn_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(btn_vbox); gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0); btn_vbox1 = gtk_vbox_new(FALSE, 8); gtk_widget_show(btn_vbox1); gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0); add_btn = gtk_button_new_with_label(_(" -> ")); gtk_widget_show(add_btn); gtk_box_pack_start(GTK_BOX(btn_vbox1), add_btn, FALSE, FALSE, 0); remove_btn = gtk_button_new_with_label(_(" <- ")); gtk_widget_show(remove_btn); gtk_box_pack_start(GTK_BOX(btn_vbox1), remove_btn, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(add_btn), "clicked", GTK_SIGNAL_FUNC(prefs_summary_column_add), NULL); gtk_signal_connect(GTK_OBJECT(remove_btn), "clicked", GTK_SIGNAL_FUNC(prefs_summary_column_remove), NULL); clist_hbox = gtk_hbox_new(FALSE, 8); gtk_widget_show(clist_hbox); gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0); scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_usize(scrolledwin, 180, 210); gtk_widget_show(scrolledwin); gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); title[0] = _("Displayed items"); shown_clist = gtk_clist_new_with_titles(1, title); gtk_widget_show(shown_clist); gtk_container_add(GTK_CONTAINER(scrolledwin), shown_clist); gtk_clist_set_selection_mode(GTK_CLIST(shown_clist), GTK_SELECTION_BROWSE); gtk_clist_set_reorderable(GTK_CLIST(shown_clist), TRUE); gtk_clist_set_use_drag_icons(GTK_CLIST(shown_clist), FALSE); GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(shown_clist)->column[0].button, GTK_CAN_FOCUS); /* up/down button */ btn_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(btn_vbox); gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0); btn_vbox1 = gtk_vbox_new(FALSE, 8); gtk_widget_show(btn_vbox1); gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0); up_btn = gtk_button_new_with_label(_("Up")); gtk_widget_show(up_btn); gtk_box_pack_start(GTK_BOX(btn_vbox1), up_btn, FALSE, FALSE, 0); down_btn = gtk_button_new_with_label(_("Down")); gtk_widget_show(down_btn); gtk_box_pack_start(GTK_BOX(btn_vbox1), down_btn, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(up_btn), "clicked", GTK_SIGNAL_FUNC(prefs_summary_column_up), NULL); gtk_signal_connect(GTK_OBJECT(down_btn), "clicked", GTK_SIGNAL_FUNC(prefs_summary_column_down), NULL); btn_hbox = gtk_hbox_new(FALSE, 8); gtk_widget_show(btn_hbox); gtk_box_pack_end(GTK_BOX(vbox), btn_hbox, FALSE, FALSE, 0); btn_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(btn_vbox); gtk_box_pack_start(GTK_BOX(btn_hbox), btn_vbox, FALSE, FALSE, 0); default_btn = gtk_button_new_with_label(_(" Use default ")); gtk_widget_show(default_btn); gtk_box_pack_start(GTK_BOX(btn_vbox), default_btn, TRUE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(default_btn), "clicked", GTK_SIGNAL_FUNC(prefs_summary_column_set_to_default), NULL); gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"), &cancel_btn, _("Cancel"), NULL, NULL); gtk_widget_show(confirm_area); gtk_box_pack_end(GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default(ok_btn); gtk_signal_connect(GTK_OBJECT(ok_btn), "clicked", GTK_SIGNAL_FUNC(prefs_summary_column_ok), NULL); gtk_signal_connect(GTK_OBJECT(cancel_btn), "clicked", GTK_SIGNAL_FUNC(prefs_summary_column_cancel), NULL); summary_col.window = window; summary_col.stock_clist = stock_clist; summary_col.shown_clist = shown_clist; summary_col.add_btn = add_btn; summary_col.remove_btn = remove_btn; summary_col.up_btn = up_btn; summary_col.down_btn = down_btn; summary_col.ok_btn = ok_btn; summary_col.cancel_btn = cancel_btn; }
static gboolean gdict_applet_draw (GdictApplet *applet) { GdictAppletPrivate *priv = applet->priv; GtkWidget *box; GtkWidget *hbox; gchar *text = NULL; if (priv->entry) text = gtk_editable_get_chars (GTK_EDITABLE (priv->entry), 0, -1); if (priv->box) gtk_widget_destroy (priv->box); switch (priv->orient) { case GTK_ORIENTATION_VERTICAL: box = gtk_vbox_new (FALSE, 0); break; case GTK_ORIENTATION_HORIZONTAL: box = gtk_hbox_new (FALSE, 0); break; default: g_assert_not_reached (); break; } gtk_container_add (GTK_CONTAINER (applet), box); gtk_widget_show (box); /* toggle button */ priv->toggle = gtk_toggle_button_new (); gtk_widget_set_tooltip_text (priv->toggle, _("Click to view the dictionary window")); set_atk_name_description (priv->toggle, _("Toggle dictionary window"), _("Show or hide the definition window")); gtk_button_set_relief (GTK_BUTTON (priv->toggle), GTK_RELIEF_NONE); g_signal_connect (priv->toggle, "toggled", G_CALLBACK (gdict_applet_icon_toggled_cb), applet); g_signal_connect (priv->toggle, "button-press-event", G_CALLBACK (gdict_applet_icon_button_press_event_cb), applet); gtk_box_pack_start (GTK_BOX (box), priv->toggle, FALSE, FALSE, 0); gtk_widget_show (priv->toggle); hbox = gtk_hbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 0); gtk_container_add (GTK_CONTAINER (priv->toggle), hbox); gtk_widget_show (hbox); if (priv->icon) { GdkPixbuf *scaled; priv->image = gtk_image_new (); gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10); scaled = gdk_pixbuf_scale_simple (priv->icon, priv->size - 5, priv->size - 5, GDK_INTERP_BILINEAR); gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled); g_object_unref (scaled); gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0); gtk_widget_show (priv->image); } else { priv->image = gtk_image_new (); gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10); gtk_image_set_from_stock (GTK_IMAGE (priv->image), GTK_STOCK_MISSING_IMAGE, -1); gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0); gtk_widget_show (priv->image); } /* entry */ priv->entry = gtk_entry_new (); gtk_widget_set_tooltip_text (priv->entry, _("Type the word you want to look up")); set_atk_name_description (priv->entry, _("Dictionary entry"), _("Look up words in dictionaries")); gtk_editable_set_editable (GTK_EDITABLE (priv->entry), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (priv->entry), 12); g_signal_connect (priv->entry, "activate", G_CALLBACK (gdict_applet_entry_activate_cb), applet); g_signal_connect (priv->entry, "button-press-event", G_CALLBACK (gdict_applet_entry_button_press_event_cb), applet); g_signal_connect (priv->entry, "key-press-event", G_CALLBACK (gdict_applet_entry_key_press_cb), applet); gtk_box_pack_end (GTK_BOX (box), priv->entry, FALSE, FALSE, 0); gtk_widget_show (priv->entry); if (text) { gtk_entry_set_text (GTK_ENTRY (priv->entry), text); g_free (text); } priv->box = box; #if 0 gtk_widget_grab_focus (priv->entry); #endif gtk_widget_show_all (GTK_WIDGET (applet)); return FALSE; }
void FormDialog::editable_set (const std::string name, const std::string description, const std::set<std::string> values, const std::set<std::string> proposed_values, bool advanced) { GtkWidget *label = NULL; GtkWidget *scroll = NULL; GtkWidget *button = NULL; GtkWidget *tree_view = NULL; GtkWidget *frame = NULL; GtkWidget *hbox = NULL; GtkWidget *entry = NULL; GtkListStore *list_store = NULL; GtkTreeViewColumn *column = NULL; GtkCellRenderer *renderer = NULL; GtkTreeIter iter; gchar *label_text = NULL; EditableSetSubmitter *submitter = NULL; /* The label */ label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); label_text = g_strdup_printf ("<b>%s</b>", description.c_str()); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text); g_free (label_text); /* The GtkListStore containing the values */ list_store = gtk_list_store_new (EditableSetSubmitter::COLUMN_NUMBER, G_TYPE_BOOLEAN, G_TYPE_STRING); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); frame = gtk_frame_new (NULL); gtk_widget_set_size_request (GTK_WIDGET (frame), -1, 125); gtk_container_set_border_width (GTK_CONTAINER (frame), 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (frame), scroll); gtk_container_add (GTK_CONTAINER (scroll), tree_view); renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "active", EditableSetSubmitter::COLUMN_ACTIVE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); g_signal_connect (renderer, "toggled", G_CALLBACK (editable_set_choice_toggled_cb), list_store); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", EditableSetSubmitter::COLUMN_VALUE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); for (std::set<std::string>::const_iterator set_iter = values.begin (); set_iter != values.end (); set_iter++) { gtk_list_store_append (GTK_LIST_STORE (list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (list_store), &iter, EditableSetSubmitter::COLUMN_ACTIVE, TRUE, EditableSetSubmitter::COLUMN_VALUE, set_iter->c_str (), -1); } for (std::set<std::string>::const_iterator set_iter = proposed_values.begin (); set_iter != proposed_values.end (); set_iter++) { if (values.find (*set_iter) == values.end ()) { gtk_list_store_append (GTK_LIST_STORE (list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (list_store), &iter, EditableSetSubmitter::COLUMN_ACTIVE, FALSE, EditableSetSubmitter::COLUMN_VALUE, set_iter->c_str (), -1); } } if (advanced) { grow_fields (advanced); gtk_table_attach (GTK_TABLE (advanced_fields), label, 0, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); grow_fields (advanced); gtk_table_attach (GTK_TABLE (advanced_fields), frame, 0, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } else { grow_fields (advanced); gtk_table_attach (GTK_TABLE (fields), label, 0, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); grow_fields (advanced); gtk_table_attach (GTK_TABLE (fields), frame, 0, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } hbox = gtk_hbox_new (FALSE, 2); entry = gtk_entry_new (); button = gtk_button_new_from_stock (GTK_STOCK_ADD); gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2); g_signal_connect (entry, "activate", (GCallback) editable_set_add_value_activated_cb, (gpointer) tree_view); g_signal_connect (button, "clicked", (GCallback) editable_set_add_value_clicked_cb, (gpointer) entry); grow_fields (advanced); if (advanced) { gtk_table_attach (GTK_TABLE (advanced_fields), hbox, 0, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } else { gtk_table_attach (GTK_TABLE (fields), hbox, 0, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } submitter = new EditableSetSubmitter (name, description, advanced, tree_view); submitters.push_back (submitter); }
static void gimp_color_dialog_init (GimpColorDialog *dialog) { GtkWidget *table; GtkWidget *button; GtkWidget *arrow; gint i; color_dialogs = g_list_prepend (color_dialogs, dialog); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); dialog->selection = gimp_color_selection_new (); gtk_container_set_border_width (GTK_CONTAINER (dialog->selection), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), dialog->selection, TRUE, TRUE, 0); gtk_widget_show (dialog->selection); g_signal_connect (dialog->selection, "color-changed", G_CALLBACK (gimp_color_dialog_color_changed), dialog); /* The color history */ table = gtk_table_new (2, 1 + COLOR_HISTORY_SIZE / 2, TRUE); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4); gtk_box_pack_end (GTK_BOX (GIMP_COLOR_SELECTION (dialog->selection)->right_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); button = gtk_button_new (); gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 1, 0, 1); gimp_help_set_help_data (button, _("Add the current color to the color history"), NULL); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_color_history_add_clicked), dialog); arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT); gtk_container_add (GTK_CONTAINER (button), arrow); gtk_widget_show (arrow); for (i = 0; i < COLOR_HISTORY_SIZE; i++) { GimpRGB history_color; gint row, column; column = i % (COLOR_HISTORY_SIZE / 2); row = i / (COLOR_HISTORY_SIZE / 2); button = gtk_button_new (); gtk_widget_set_size_request (button, COLOR_AREA_SIZE, COLOR_AREA_SIZE); gtk_table_attach_defaults (GTK_TABLE (table), button, column + 1, column + 2, row, row + 1); gtk_widget_show (button); color_history_get (i, &history_color); dialog->history[i] = gimp_color_area_new (&history_color, GIMP_COLOR_AREA_SMALL_CHECKS, GDK_BUTTON2_MASK); gtk_container_add (GTK_CONTAINER (button), dialog->history[i]); gtk_widget_show (dialog->history[i]); g_signal_connect (button, "clicked", G_CALLBACK (gimp_color_history_color_clicked), dialog); g_signal_connect (dialog->history[i], "color-changed", G_CALLBACK (gimp_color_history_color_changed), GINT_TO_POINTER (i)); } }
GtkDialog* seahorse_passphrase_prompt_show (const gchar *title, const gchar *description, const gchar *prompt, const gchar *check, gboolean confirm) { GtkEntryBuffer *buffer; GtkEntry *entry; GtkDialog *dialog; GtkWidget *w; GtkWidget *box; GtkTable *table; GtkWidget *wvbox; GtkWidget *chbox; gchar *msg; if (!title) title = _("Passphrase"); if (!prompt) prompt = _("Password:"******"size-request", G_CALLBACK (constrain_size), NULL); g_signal_connect (G_OBJECT (dialog), "map-event", G_CALLBACK (grab_keyboard), NULL); g_signal_connect (G_OBJECT (dialog), "unmap-event", G_CALLBACK (ungrab_keyboard), NULL); g_signal_connect (G_OBJECT (dialog), "window-state-event", G_CALLBACK (window_state_changed), NULL); wvbox = gtk_vbox_new (FALSE, HIG_LARGE * 2); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (dialog)), wvbox); gtk_container_set_border_width (GTK_CONTAINER (wvbox), HIG_LARGE); chbox = gtk_hbox_new (FALSE, HIG_LARGE); gtk_box_pack_start (GTK_BOX (wvbox), chbox, FALSE, FALSE, 0); /* The image */ w = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (chbox), w, FALSE, FALSE, 0); box = gtk_vbox_new (FALSE, HIG_SMALL); gtk_box_pack_start (GTK_BOX (chbox), box, TRUE, TRUE, 0); /* The description text */ if (description) { msg = utf8_validate (description); w = gtk_label_new (msg); g_free (msg); gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (w), TRUE); gtk_box_pack_start (GTK_BOX (box), w, TRUE, FALSE, 0); } /* Two entries (usually on is hidden) in a vbox */ table = GTK_TABLE (gtk_table_new (3, 2, FALSE)); gtk_table_set_row_spacings (table, HIG_SMALL); gtk_table_set_col_spacings (table, HIG_LARGE); gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (table), FALSE, FALSE, 0); /* The first entry if we have one */ if (confirm) { msg = utf8_validate (prompt); w = gtk_label_new (msg); g_free (msg); gtk_table_attach (table, w, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); buffer = seahorse_secure_buffer_new (); entry = GTK_ENTRY (gtk_entry_new_with_buffer (buffer)); g_object_unref (buffer); gtk_entry_set_visibility (entry, FALSE); gtk_widget_set_size_request (GTK_WIDGET (entry), 200, -1); g_object_set_data (G_OBJECT (dialog), "confirm-entry", entry); g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (confirm_callback), dialog); g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (entry_changed), dialog); gtk_table_attach_defaults (table, GTK_WIDGET (entry), 1, 2, 0, 1); gtk_widget_grab_focus (GTK_WIDGET (entry)); } /* The second and main entry */ msg = utf8_validate (confirm ? _("Confirm:") : prompt); w = gtk_label_new (msg); g_free (msg); gtk_table_attach (table, w, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); buffer = seahorse_secure_buffer_new (); entry = GTK_ENTRY (gtk_entry_new_with_buffer (buffer)); g_object_unref (buffer); gtk_widget_set_size_request (GTK_WIDGET (entry), 200, -1); gtk_entry_set_visibility (entry, FALSE); g_object_set_data (G_OBJECT (dialog), "secure-entry", entry); g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (enter_callback), dialog); gtk_table_attach_defaults (table, GTK_WIDGET (entry), 1, 2, 1, 2); if (!confirm) gtk_widget_grab_focus (GTK_WIDGET (entry)); else g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (entry_changed), dialog); /* The checkbox */ if (check) { w = gtk_check_button_new_with_mnemonic (check); gtk_table_attach_defaults (table, w, 1, 2, 2, 3); g_object_set_data (G_OBJECT (dialog), "check-option", w); } gtk_widget_show_all (GTK_WIDGET (table)); w = gtk_button_new_from_stock (GTK_STOCK_CANCEL); gtk_dialog_add_action_widget (dialog, w, GTK_RESPONSE_REJECT); gtk_widget_set_can_default (w, TRUE); w = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_dialog_add_action_widget (dialog, w, GTK_RESPONSE_ACCEPT); gtk_widget_set_can_default (w, TRUE); g_signal_connect_object (G_OBJECT (entry), "focus_in_event", G_CALLBACK (gtk_widget_grab_default), G_OBJECT (w), 0); gtk_widget_grab_default (w); g_signal_connect (dialog, "key_press_event", G_CALLBACK (key_press), NULL); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_NORMAL); gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE); gtk_widget_show_all (GTK_WIDGET (dialog)); gdk_window_focus (gtk_widget_get_window (GTK_WIDGET (dialog)), GDK_CURRENT_TIME); if (confirm) entry_changed (NULL, dialog); return dialog; }
GtkWidget * module_dialog_new (Gimp *gimp) { GtkWidget *shell; GtkWidget *vbox; GtkWidget *sw; GtkWidget *view; GtkWidget *image; ModuleDialog *dialog; GtkTreeSelection *sel; GtkTreeIter iter; GtkTreeViewColumn *col; GtkCellRenderer *rend; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); dialog = g_slice_new0 (ModuleDialog); dialog->gimp = gimp; shell = gimp_dialog_new (_("Module Manager"), "gimp-modules", NULL, 0, gimp_standard_help_func, GIMP_HELP_MODULE_DIALOG, GTK_STOCK_REFRESH, RESPONSE_REFRESH, GTK_STOCK_CLOSE, GTK_STOCK_CLOSE, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell), GTK_RESPONSE_CLOSE, RESPONSE_REFRESH, -1); g_signal_connect (shell, "response", G_CALLBACK (dialog_response), dialog); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (shell))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); dialog->hint = gimp_hint_box_new (_("You will have to restart GIMP " "for the changes to take effect.")); gtk_box_pack_start (GTK_BOX (vbox), dialog->hint, FALSE, FALSE, 0); if (gimp->write_modulerc) gtk_widget_show (dialog->hint); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_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); gtk_widget_set_size_request (sw, 124, 100); gtk_widget_show (sw); dialog->list = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, GIMP_TYPE_MODULE); view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog->list)); g_object_unref (dialog->list); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE); g_list_foreach (gimp->module_db->modules, make_list_item, dialog); rend = gtk_cell_renderer_toggle_new (); g_signal_connect (rend, "toggled", G_CALLBACK (dialog_enabled_toggled), dialog); col = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (col, rend, FALSE); gtk_tree_view_column_add_attribute (col, rend, "active", COLUMN_ENABLED); gtk_tree_view_append_column (GTK_TREE_VIEW (view), col); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 1, _("Module"), gtk_cell_renderer_text_new (), "text", COLUMN_NAME, NULL); gtk_container_add (GTK_CONTAINER (sw), view); gtk_widget_show (view); dialog->table = gtk_table_new (2, N_INFOS, FALSE); gtk_table_set_col_spacings (GTK_TABLE (dialog->table), 6); gtk_box_pack_start (GTK_BOX (vbox), dialog->table, FALSE, FALSE, 0); gtk_widget_show (dialog->table); dialog->error_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), dialog->error_box, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GIMP_STOCK_WARNING, GTK_ICON_SIZE_BUTTON); gtk_box_pack_start (GTK_BOX (dialog->error_box), image, FALSE, FALSE, 0); gtk_widget_show (image); dialog->error_label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (dialog->error_label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (dialog->error_box), dialog->error_label, TRUE, TRUE, 0); gtk_widget_show (dialog->error_label); dialog_info_init (dialog, dialog->table); dialog_info_update (gimp->module_db, dialog->selected, dialog); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); g_signal_connect (sel, "changed", G_CALLBACK (dialog_select_callback), dialog); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (dialog->list), &iter)) gtk_tree_selection_select_iter (sel, &iter); /* hook the GimpModuleDB signals so we can refresh the display * appropriately. */ g_signal_connect (gimp->module_db, "add", G_CALLBACK (dialog_info_add), dialog); g_signal_connect (gimp->module_db, "remove", G_CALLBACK (dialog_info_remove), dialog); g_signal_connect (gimp->module_db, "module-modified", G_CALLBACK (dialog_info_update), dialog); g_signal_connect (shell, "destroy", G_CALLBACK (dialog_destroy_callback), dialog); return shell; }
static gboolean level_grains_dialog(LevelGrainsArgs *args) { GtkWidget *dialog, *table, *label; LevelGrainsControls controls; gint response, row; controls.args = args; dialog = gtk_dialog_new_with_buttons(_("Level Grains"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT); table = gtk_table_new(2 + G_N_ELEMENTS(level_grains_bases), 1, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 4); row = 0; label = gtk_label_new(_("Quantity to level:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_FILL, 0, 0, 0); row++; controls.base = construct_bases_radio(args->base, G_CALLBACK(base_changed), &controls); row = gwy_radio_buttons_attach_to_table(controls.base, GTK_TABLE(table), 1, row); gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8); controls.do_extract = gtk_check_button_new_with_mnemonic(_("E_xtract background")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.do_extract), args->do_extract); gtk_table_attach(GTK_TABLE(table), controls.do_extract, 0, 1, row, row+1, GTK_FILL, 0, 0, 0); g_signal_connect_swapped(controls.do_extract, "toggled", G_CALLBACK(do_extract_changed), &controls); row++; gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); gtk_widget_destroy(dialog); return TRUE; }
GtkWidget* gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor) { const char * str; GtkWidget * w; GtkWidget * d; GtkGrid * grid; int row; GtkWidget * l; GtkWidget * source_chooser; struct OpenData * data; bool flag; GSList * list; GSList * walk; /* make the dialog */ d = gtk_dialog_new_with_buttons (_("Torrent Options"), parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT); gtk_dialog_set_alternative_button_order (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); gtk_window_set_default_size(GTK_WINDOW(d), gtr_pref_int_get (TR_KEY_details_window_width), gtr_pref_int_get (TR_KEY_details_window_height)); if (!tr_ctorGetDownloadDir (ctor, TR_FORCE, &str)) g_assert_not_reached (); g_assert (str); data = g_new0 (struct OpenData, 1); data->core = core; data->ctor = ctor; data->filename = g_strdup (tr_ctorGetSourceFile (ctor)); data->downloadDir = g_strdup (str); data->file_list = gtr_file_list_new (core, 0); str = _("Mo_ve .torrent file to the trash"); data->trash_check = gtk_check_button_new_with_mnemonic (str); str = _("_Start when added"); data->run_check = gtk_check_button_new_with_mnemonic (str); w = data->priority_combo = gtr_priority_combo_new (); gtr_priority_combo_set_value (GTK_COMBO_BOX (w), TR_PRI_NORMAL); g_signal_connect (G_OBJECT (d), "response", G_CALLBACK (addResponseCB), data); row = 0; grid = GTK_GRID (gtk_grid_new ()); gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG); gtk_grid_set_row_spacing (grid, GUI_PAD); gtk_grid_set_column_spacing (grid, GUI_PAD_BIG); /* "torrent file" row */ l = gtk_label_new_with_mnemonic (_("_Torrent file:")); gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 1, 1); w = gtk_file_chooser_button_new (_("Select Source File"), GTK_FILE_CHOOSER_ACTION_OPEN); source_chooser = w; gtk_widget_set_hexpand (w, TRUE); gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (l), w); addTorrentFilters (GTK_FILE_CHOOSER (w)); g_signal_connect (w, "selection-changed", G_CALLBACK (sourceChanged), data); /* "destination folder" row */ row++; l = gtk_label_new_with_mnemonic (_("_Destination folder:")); gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 1, 1); w = gtk_file_chooser_button_new (_("Select Destination Folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); if (!gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), data->downloadDir)) g_warning ("couldn't select '%s'", data->downloadDir); list = get_recent_destinations (); for (walk = list; walk; walk = walk->next) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (w), walk->data, NULL); g_slist_free (list); gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (l), w); g_signal_connect (w, "selection-changed", G_CALLBACK (downloadDirChanged), data); row++; l = data->freespace_label = gtr_freespace_label_new (core, data->downloadDir); gtk_widget_set_margin_bottom (l, GUI_PAD_BIG); gtk_misc_set_alignment (GTK_MISC (l), 1.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 2, 1); /* file list row */ row++; w = data->file_list; gtk_widget_set_vexpand (w, TRUE); gtk_widget_set_size_request (w, 466u, 300u); gtk_grid_attach (grid, w, 0, row, 2, 1); /* torrent priority row */ row++; l = gtk_label_new_with_mnemonic (_("Torrent _priority:")); gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 1, 1); w = data->priority_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (l), w); gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1); /* torrent priority row */ row++; w = data->run_check; if (!tr_ctorGetPaused (ctor, TR_FORCE, &flag)) g_assert_not_reached (); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), !flag); gtk_grid_attach (grid, w, 0, row, 2, 1); /* "trash .torrent file" row */ row++; w = data->trash_check; if (!tr_ctorGetDeleteSource (ctor, &flag)) g_assert_not_reached (); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), flag); gtk_grid_attach (grid, w, 0, row, 2, 1); /* trigger sourceChanged, either directly or indirectly, * so that it creates the tor/gtor objects */ w = source_chooser; if (data->filename) gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), data->filename); else sourceChanged (GTK_FILE_CHOOSER_BUTTON (w), data); gtr_dialog_set_content (GTK_DIALOG (d), GTK_WIDGET (grid)); w = gtk_dialog_get_widget_for_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT); gtk_widget_grab_focus (w); return d; }
/** * Constructor */ GtkWidget *create_control_window(GtkWidget *parent) { GtkWidget *pp_button, *next_button, *prev_button, *ff_button; GtkWidget *vol, *progress, *hbox, *play_image; int new_volume; /* Create window */ GtkWidget *base = gtk_event_box_new(); GtkWidget *ali = gtk_alignment_new(0.5,0,0.6,1); g_signal_connect(G_OBJECT(base), "enter-notify-event" , G_CALLBACK(control_window_enter_notify_event), NULL); g_signal_connect(G_OBJECT(base), "leave-notify-event" , G_CALLBACK(control_window_leave_notify_event), NULL); /* Overwrite background drawing */ gtk_widget_set_app_paintable(base, TRUE); g_signal_connect(G_OBJECT(base), "draw", G_CALLBACK(expose_window), NULL); hbox = gtk_hbox_new(FALSE, 6); g_object_set_data(G_OBJECT(base), "hbox" , hbox); gtk_container_add(GTK_CONTAINER(base), ali); gtk_container_add(GTK_CONTAINER(ali), hbox); gtk_container_set_border_width(GTK_CONTAINER(ali), 1); /* Previous button */ ff_button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(ff_button), gtk_image_new_from_stock(GTK_STOCK_LEAVE_FULLSCREEN, GTK_ICON_SIZE_BUTTON)); gtk_button_set_relief(GTK_BUTTON(ff_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), ff_button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(ff_button), "clicked", G_CALLBACK(control_window_leave_fullscreen), parent); /* Volume button */ vol = (GtkWidget *)gtk_volume_button_new(); gtk_box_pack_end(GTK_BOX(hbox), vol, FALSE, FALSE, 0); new_volume = mpd_status_get_volume(connection); gtk_scale_button_set_value(GTK_SCALE_BUTTON(vol), new_volume/100.0); g_object_set_data(G_OBJECT(base), "vol", vol); g_signal_connect(G_OBJECT(vol), "value_changed", G_CALLBACK(playlist_player_volume_changed), NULL); /* Progress */ progress = (GtkWidget *)gmpc_progress_new(); gmpc_progress_set_hide_text(GMPC_PROGRESS(progress), FALSE); gtk_box_pack_start(GTK_BOX(hbox), progress, TRUE, TRUE, 0); g_object_set_data(G_OBJECT(base), "progress", progress); g_signal_connect(G_OBJECT(progress), "seek-event", G_CALLBACK(pl3_pb_seek_event), NULL); /* Previous button */ prev_button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(prev_button), gtk_image_new_from_stock("gtk-media-previous", GTK_ICON_SIZE_BUTTON)); gtk_activatable_set_related_action(GTK_ACTIVATABLE(prev_button), GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPrevious"))); gtk_button_set_relief(GTK_BUTTON(prev_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), prev_button, FALSE, FALSE, 0); /* Play button */ pp_button = gtk_button_new(); if(mpd_player_get_state(connection) == MPD_PLAYER_PLAY) { play_image = gtk_image_new_from_stock("gtk-media-pause", GTK_ICON_SIZE_BUTTON); } else { play_image = gtk_image_new_from_stock("gtk-media-play", GTK_ICON_SIZE_BUTTON); } gtk_container_add(GTK_CONTAINER(pp_button), play_image); g_object_set_data(G_OBJECT(base), "play_image", play_image); gtk_activatable_set_related_action(GTK_ACTIVATABLE(pp_button), GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause"))); gtk_button_set_relief(GTK_BUTTON(pp_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), pp_button, FALSE, FALSE, 0); /* Next */ next_button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(next_button), gtk_image_new_from_stock("gtk-media-next", GTK_ICON_SIZE_BUTTON)); gtk_activatable_set_related_action(GTK_ACTIVATABLE(next_button), GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDNext"))); gtk_button_set_relief(GTK_BUTTON(next_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), next_button, FALSE, FALSE, 0); /* Change colors */ control_window_modify_colors(base); gtk_widget_show_all(base); timeout = g_timeout_add_seconds(5, (GSourceFunc) gtk_widget_hide, hbox); return base; }
GtkWidget * do_data_model_dir (GtkWidget *do_widget) { if (!window) { GtkWidget *vbox; GtkWidget *label; GdaDataModel *model; GtkWidget *form, *grid, *nb; GdaSet *data_set; GdaHolder *param; gchar *path; GValue *value; window = gtk_dialog_new_with_buttons ("GdaDataModelDir data model", GTK_WINDOW (do_widget), 0, GTK_STOCK_CLOSE, GTK_RESPONSE_NONE, NULL); g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))), vbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); label = gtk_label_new ("The following GdauiForm widget displays data from a GdaDataModelDir " "data model which lists the files contained in the selected directory.\n\n" "Each file contents is then displayed using the 'picture' plugin \n" "(right click to open a menu, or double click to load an image)."); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); /* GdaDataModelDir object */ path = get_data_path (); model = gda_data_model_dir_new (path); g_free (path); /* Create the demo widget */ nb = gtk_notebook_new (); gtk_box_pack_start (GTK_BOX (vbox), nb, TRUE, TRUE, 0); form = gdaui_form_new (model); gtk_notebook_append_page (GTK_NOTEBOOK (nb), form, gtk_label_new ("Form")); grid = gdaui_grid_new (model); gtk_notebook_append_page (GTK_NOTEBOOK (nb), grid, gtk_label_new ("Grid")); g_object_unref (model); /* specify that we want to use the 'picture' plugin */ data_set = GDA_SET (gdaui_data_selector_get_data_set (GDAUI_DATA_SELECTOR (grid))); param = gda_set_get_holder (data_set, "data"); value = gda_value_new_from_string ("picture", G_TYPE_STRING); gda_holder_set_attribute_static (param, GDAUI_ATTRIBUTE_PLUGIN, value); gdaui_data_proxy_column_show_actions (GDAUI_DATA_PROXY (grid), -1, TRUE); gda_value_free (value); } gboolean visible; g_object_get (G_OBJECT (window), "visible", &visible, NULL); if (!visible) gtk_widget_show_all (window); else { gtk_widget_destroy (window); window = NULL; } return window; }