GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *frame1; GtkWidget *table2; GtkWidget *label4; GtkWidget *label5; GtkWidget *hscaleBrightness; GtkWidget *hscaleSaturation; GtkWidget *hscaleContrast; GtkWidget *label3; GtkWidget *label1; GtkWidget *frame2; GtkWidget *table3; GtkWidget *label6; GtkWidget *hscaleGamma; GtkWidget *hscaleGammaR; GtkWidget *label8; GtkWidget *hscaleGammaG; GtkWidget *label9; GtkWidget *label10; GtkWidget *label7; GtkWidget *hscaleGammaB; GtkWidget *hscaleGammaWeight; GtkWidget *label2; GtkWidget *hscale1; GtkWidget *drawingarea1; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_container_set_border_width (GTK_CONTAINER (dialog1), 6); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("MPlayer eq2")); gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0); frame1 = gtk_frame_new (NULL); gtk_widget_show (frame1); gtk_box_pack_start (GTK_BOX (hbox1), frame1, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE); table2 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table2); gtk_container_add (GTK_CONTAINER (frame1), table2); gtk_container_set_border_width (GTK_CONTAINER (table2), 12); gtk_table_set_row_spacings (GTK_TABLE (table2), 6); gtk_table_set_col_spacings (GTK_TABLE (table2), 12); label4 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Brigh_tness:")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table2), label4, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); label5 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Saturation:")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); hscaleBrightness = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -1, 1, 0.05, 1, 0))); gtk_widget_show (hscaleBrightness); gtk_table_attach (GTK_TABLE (table2), hscaleBrightness, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleBrightness, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleBrightness), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleBrightness), 2); hscaleSaturation = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 3, 0.05, 1, 0))); gtk_widget_show (hscaleSaturation); gtk_table_attach (GTK_TABLE (table2), hscaleSaturation, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleSaturation, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleSaturation), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleSaturation), 2); hscaleContrast = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, -2, 2, 0.05, 1, 0))); gtk_widget_show (hscaleContrast); gtk_table_attach (GTK_TABLE (table2), hscaleContrast, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleContrast, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleContrast), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleContrast), 2); label3 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Contrast:")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table2), label3, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label1 = gtk_label_new (""); gtk_widget_show (label1); gtk_frame_set_label_widget (GTK_FRAME (frame1), label1); gtk_label_set_use_markup (GTK_LABEL (label1), TRUE); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); frame2 = gtk_frame_new (NULL); gtk_widget_show (frame2); gtk_box_pack_start (GTK_BOX (hbox1), frame2, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE); table3 = gtk_table_new (5, 2, FALSE); gtk_widget_show (table3); gtk_container_add (GTK_CONTAINER (frame2), table3); gtk_container_set_border_width (GTK_CONTAINER (table3), 12); gtk_table_set_row_spacings (GTK_TABLE (table3), 6); gtk_table_set_col_spacings (GTK_TABLE (table3), 12); label6 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Initial:")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table3), label6, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); hscaleGamma = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGamma); gtk_table_attach (GTK_TABLE (table3), hscaleGamma, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGamma, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGamma), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGamma), 2); hscaleGammaR = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGammaR); gtk_table_attach (GTK_TABLE (table3), hscaleGammaR, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaR, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaR), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaR), 2); label8 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Red:")); gtk_widget_show (label8); gtk_table_attach (GTK_TABLE (table3), label8, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); hscaleGammaG = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGammaG); gtk_table_attach (GTK_TABLE (table3), hscaleGammaG, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaG, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaG), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaG), 2); label9 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Green:")); gtk_widget_show (label9); gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); label10 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Blue:")); gtk_widget_show (label10); gtk_table_attach (GTK_TABLE (table3), label10, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5); label7 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Weight:")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table3), label7, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); hscaleGammaB = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGammaB); gtk_table_attach (GTK_TABLE (table3), hscaleGammaB, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaB, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaB), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaB), 2); hscaleGammaWeight = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 1, 0.05, 1, 0))); gtk_widget_show (hscaleGammaWeight); gtk_table_attach (GTK_TABLE (table3), hscaleGammaWeight, 1, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaWeight, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaWeight), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaWeight), 2); label2 = gtk_label_new (QT_TR_NOOP("<b>Gamma</b>")); gtk_widget_show (label2); gtk_frame_set_label_widget (GTK_FRAME (frame2), label2); gtk_label_set_use_markup (GTK_LABEL (label2), TRUE); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 1, 0))); gtk_widget_show (hscale1); gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0); drawingarea1 = gtk_drawing_area_new (); gtk_widget_show (drawingarea1); gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 0); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); gtk_label_set_mnemonic_widget (GTK_LABEL (label4), hscaleBrightness); gtk_label_set_mnemonic_widget (GTK_LABEL (label5), hscaleSaturation); gtk_label_set_mnemonic_widget (GTK_LABEL (label3), hscaleContrast); gtk_label_set_mnemonic_widget (GTK_LABEL (label6), hscaleGamma); gtk_label_set_mnemonic_widget (GTK_LABEL (label8), hscaleGammaR); gtk_label_set_mnemonic_widget (GTK_LABEL (label9), hscaleGammaG); gtk_label_set_mnemonic_widget (GTK_LABEL (label10), hscaleGammaB); gtk_label_set_mnemonic_widget (GTK_LABEL (label7), hscaleGammaWeight); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (dialog1, frame1, "frame1"); GLADE_HOOKUP_OBJECT (dialog1, table2, "table2"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT (dialog1, hscaleBrightness, "hscaleBrightness"); GLADE_HOOKUP_OBJECT (dialog1, hscaleSaturation, "hscaleSaturation"); GLADE_HOOKUP_OBJECT (dialog1, hscaleContrast, "hscaleContrast"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2"); GLADE_HOOKUP_OBJECT (dialog1, table3, "table3"); GLADE_HOOKUP_OBJECT (dialog1, label6, "label6"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGamma, "hscaleGamma"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaR, "hscaleGammaR"); GLADE_HOOKUP_OBJECT (dialog1, label8, "label8"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaG, "hscaleGammaG"); GLADE_HOOKUP_OBJECT (dialog1, label9, "label9"); GLADE_HOOKUP_OBJECT (dialog1, label10, "label10"); GLADE_HOOKUP_OBJECT (dialog1, label7, "label7"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaB, "hscaleGammaB"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaWeight, "hscaleGammaWeight"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1"); GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
/** * create the page to create new reconciles * * \param * * \return a GtkWidget, the page to the assistant * */ static GtkWidget *gsb_assistant_reconcile_config_page_new_reconcile ( void ) { GtkWidget *page; GtkWidget *label; GtkWidget *paddingbox; GtkWidget *table; GtkWidget *button; GtkWidget *hbox; page = gtk_box_new ( GTK_ORIENTATION_VERTICAL, 0 ); gtk_container_set_border_width ( GTK_CONTAINER(page), 12 ); paddingbox = new_paddingbox_with_title ( page, FALSE, _("Fill the fields and click the button \"Create the new reconciliation\"")); /* create the table, this is the same as the reconcile config, * but here it's to create new ones */ table = gtk_table_new ( 4, 3, FALSE ); gtk_table_set_row_spacings ( GTK_TABLE ( table ), 6 ); gtk_table_set_col_spacings ( GTK_TABLE ( table ), 6 ); gtk_box_pack_start ( GTK_BOX (paddingbox), table, FALSE, FALSE, 0 ); /* set the name */ label = gtk_label_new ( _("Reconciliation reference: ") ); gtk_misc_set_alignment (GTK_MISC (label), 0, 1); gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT ); gtk_table_attach ( GTK_TABLE ( table ), label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, 0, 0, 0 ); reconcile_name_entry = gtk_entry_new (); gtk_table_attach ( GTK_TABLE ( table ), reconcile_name_entry, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, 0, 10, 0 ); /* set the choice of account */ label = gtk_label_new ( _("Account: ") ); gtk_misc_set_alignment (GTK_MISC (label), 0, 1); gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT ); gtk_table_attach ( GTK_TABLE ( table ), label, 2, 3, 0, 1, GTK_SHRINK | GTK_FILL, 0, 10, 0 ); reconcile_account_button = gsb_account_create_combo_list ( NULL, NULL, TRUE ); gtk_combo_box_set_active ( GTK_COMBO_BOX (reconcile_account_button), 0 ); gtk_table_attach ( GTK_TABLE ( table ), reconcile_account_button, 3, 4, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0 ); /* set the initial date */ label = gtk_label_new ( _("Initial date: ") ); gtk_misc_set_alignment (GTK_MISC (label), 0, 1); gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT ); gtk_table_attach ( GTK_TABLE ( table ), label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, 0, 0, 0 ); reconcile_init_date_entry = gsb_calendar_entry_new (FALSE); gtk_table_attach ( GTK_TABLE ( table ), reconcile_init_date_entry, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 10, 0 ); /* set the final date */ label = gtk_label_new ( _("Final date: ") ); gtk_misc_set_alignment (GTK_MISC (label), 0, 1); gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT ); gtk_table_attach ( GTK_TABLE ( table ), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, 0, 0, 0 ); reconcile_final_date_entry = gsb_calendar_entry_new (FALSE); gtk_table_attach ( GTK_TABLE ( table ), reconcile_final_date_entry, 1, 2, 2, 3, GTK_EXPAND | GTK_FILL, 0, 10, 0 ); /* set the initial balance */ label = gtk_label_new ( _("Initial balance: ") ); gtk_misc_set_alignment (GTK_MISC (label), 0, 1); gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT ); gtk_table_attach ( GTK_TABLE ( table ), label, 2, 3, 1, 2, GTK_SHRINK | GTK_FILL, 0, 10, 0 ); reconcile_init_balance_entry = gtk_entry_new (); gtk_table_attach ( GTK_TABLE ( table ), reconcile_init_balance_entry, 3, 4, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0 ); /* set the final balance */ label = gtk_label_new ( _("Final balance: ") ); gtk_misc_set_alignment (GTK_MISC (label), 0, 1); gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT ); gtk_table_attach ( GTK_TABLE ( table ), label, 2, 3, 2, 3, GTK_SHRINK | GTK_FILL, 0, 10, 0 ); reconcile_final_balance_entry = gtk_entry_new (); gtk_table_attach ( GTK_TABLE ( table ), reconcile_final_balance_entry, 3, 4, 2, 3, GTK_EXPAND | GTK_FILL, 0, 0, 0 ); /* create the button */ hbox = gtk_box_new ( GTK_ORIENTATION_HORIZONTAL, 0 ); gtk_box_set_homogeneous ( GTK_BOX ( hbox ), TRUE ); gtk_box_pack_start ( GTK_BOX (page), hbox, FALSE, FALSE, 0 ); button = gtk_button_new_with_label (_("Create the new reconciliation")); gtk_box_pack_end ( GTK_BOX (hbox), button, FALSE, FALSE, 0 ); /* create the label */ label = gtk_label_new (NULL); gtk_box_pack_start ( GTK_BOX (page), label, TRUE, TRUE, 0 ); /* if we change anything in the entries, hide the label */ g_signal_connect ( G_OBJECT (reconcile_name_entry), "changed", G_CALLBACK (gsb_assistant_reconcile_config_hide_label_error), label ); g_signal_connect ( G_OBJECT (reconcile_init_date_entry), "changed", G_CALLBACK (gsb_assistant_reconcile_config_hide_label_error), label ); g_signal_connect ( G_OBJECT (reconcile_final_date_entry), "changed", G_CALLBACK (gsb_assistant_reconcile_config_hide_label_error), label ); g_signal_connect ( G_OBJECT (reconcile_init_balance_entry), "changed", G_CALLBACK (gsb_assistant_reconcile_config_hide_label_error), label ); g_signal_connect ( G_OBJECT (reconcile_final_balance_entry), "changed", G_CALLBACK (gsb_assistant_reconcile_config_hide_label_error), label ); /* connect the button and give the message label as param */ g_signal_connect ( G_OBJECT (button), "clicked", G_CALLBACK (gsb_assistant_reconcile_config_page_add_new_reconcile), label ); gtk_widget_show_all (page); return page; }
void hybrid_confirm_window_create(HybridAccount *account, guchar *pic_data, gint pic_len, HybridConfirmOkFunc ok_func, HybridConfirmCancelFunc cancel_func, gpointer user_data) { HybridConfirmWindow *con; GtkWidget *vbox; GtkWidget *table; GtkWidget *action_area; GtkWidget *button; GtkWidget *label; GdkPixbuf *pixbuf; con = g_new0(HybridConfirmWindow, 1); con->account = account; con->ok_func = ok_func; con->cancel_func = cancel_func; con->user_data = user_data; con->window = hybrid_create_window(_("Confirm Code"), NULL, GTK_WIN_POS_CENTER, FALSE); gtk_widget_set_size_request(con->window, 300, 200); gtk_container_set_border_width(GTK_CONTAINER(con->window), 8); g_signal_connect(con->window, "destroy", G_CALLBACK(destroy_cb), con); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(con->window), vbox); table = gtk_table_new(3, 3, FALSE); gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 5); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<i>Please input the following code in the picture:</i>")); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 2, 0, 1); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<i>Code:</i>")); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); /* show code picture. */ pixbuf = hybrid_create_pixbuf(pic_data, pic_len); con->image = gtk_image_new_from_pixbuf(pixbuf); g_object_unref(pixbuf); gtk_table_attach_defaults(GTK_TABLE(table), con->image, 1, 2, 1, 2); con->entry = gtk_entry_new(); g_signal_connect(con->entry, "activate", G_CALLBACK(ok_cb), con); gtk_table_attach_defaults(GTK_TABLE(table), con->entry, 0, 2, 2, 3); action_area = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), action_area, FALSE, FALSE, 5); button = gtk_button_new_with_label(_("OK")); gtk_widget_set_size_request(button, 100, 30); gtk_box_pack_end(GTK_BOX(action_area), button, FALSE, FALSE, 5); g_signal_connect(button, "clicked", G_CALLBACK(ok_cb), con); button = gtk_button_new_with_label(_("Cancel")); gtk_widget_set_size_request(button, 100, 30); gtk_box_pack_end(GTK_BOX(action_area), button, FALSE, FALSE, 5); g_signal_connect(button, "clicked", G_CALLBACK(cancel_cb), con); gtk_widget_show_all(con->window); }
static void mateweather_pref_create(MateWeatherPref* pref) { GtkWidget* pref_vbox; GtkWidget* pref_notebook; #ifdef RADARMAP GtkWidget* radar_toggle_hbox; #endif /* RADARMAP */ GtkWidget* pref_basic_update_alignment; GtkWidget* pref_basic_update_lbl; GtkWidget* pref_basic_update_hbox; GtkObject* pref_basic_update_spin_adj; GtkWidget* pref_basic_update_sec_lbl; GtkWidget* pref_basic_note_lbl; GtkWidget* pref_loc_hbox; GtkWidget* pref_loc_note_lbl; GtkWidget* scrolled_window; GtkWidget* label; GtkWidget* value_hbox; GtkWidget* tree_label; GtkTreeSelection *selection; GtkWidget* pref_basic_vbox; GtkWidget* vbox; GtkWidget* frame; GtkWidget* temp_label; GtkWidget* temp_combo; GtkWidget* speed_label; GtkWidget* speed_combo; GtkWidget* pres_label; GtkWidget* pres_combo; GtkWidget* dist_label; GtkWidget* dist_combo; GtkWidget* unit_table; GtkWidget* pref_find_label; GtkWidget* pref_find_hbox; GtkWidget* image; g_object_set (pref, "destroy-with-parent", TRUE, NULL); gtk_window_set_title (GTK_WINDOW (pref), _("Weather Preferences")); gtk_dialog_add_buttons (GTK_DIALOG (pref), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_dialog_set_default_response (GTK_DIALOG (pref), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator (GTK_DIALOG (pref), FALSE); gtk_container_set_border_width (GTK_CONTAINER (pref), 5); gtk_window_set_resizable (GTK_WINDOW (pref), TRUE); gtk_window_set_screen (GTK_WINDOW (pref), gtk_widget_get_screen (GTK_WIDGET (pref->priv->applet->applet))); pref_vbox = gtk_dialog_get_content_area (GTK_DIALOG (pref)); gtk_box_set_spacing (GTK_BOX (pref_vbox), 2); gtk_widget_show (pref_vbox); pref_notebook = gtk_notebook_new (); gtk_container_set_border_width (GTK_CONTAINER (pref_notebook), 5); gtk_widget_show (pref_notebook); gtk_box_pack_start (GTK_BOX (pref_vbox), pref_notebook, TRUE, TRUE, 0); /* * General settings page. */ pref_basic_vbox = gtk_vbox_new (FALSE, 18); gtk_container_set_border_width (GTK_CONTAINER (pref_basic_vbox), 12); gtk_container_add (GTK_CONTAINER (pref_notebook), pref_basic_vbox); pref_basic_update_alignment = gtk_alignment_new (0, 0.5, 0, 1); gtk_widget_show (pref_basic_update_alignment); pref->priv->basic_update_btn = gtk_check_button_new_with_mnemonic (_("_Automatically update every:")); gtk_widget_show (pref->priv->basic_update_btn); gtk_container_add (GTK_CONTAINER (pref_basic_update_alignment), pref->priv->basic_update_btn); g_signal_connect (G_OBJECT (pref->priv->basic_update_btn), "toggled", G_CALLBACK (auto_update_toggled), pref); if (!g_settings_is_writable (pref->priv->applet->settings, "auto-update")) { hard_set_sensitive (pref->priv->basic_update_btn, FALSE); } /* * Units settings page. */ /* Temperature Unit */ temp_label = gtk_label_new_with_mnemonic (_("_Temperature unit:")); gtk_label_set_use_markup (GTK_LABEL (temp_label), TRUE); gtk_label_set_justify (GTK_LABEL (temp_label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (temp_label), 0, 0.5); gtk_widget_show (temp_label); temp_combo = gtk_combo_box_new_text (); pref->priv->basic_temp_combo = temp_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (temp_label), temp_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (temp_combo), _("Default")); gtk_combo_box_append_text (GTK_COMBO_BOX (temp_combo), _("Kelvin")); /* TRANSLATORS: Celsius is sometimes referred Centigrade */ gtk_combo_box_append_text (GTK_COMBO_BOX (temp_combo), _("Celsius")); gtk_combo_box_append_text (GTK_COMBO_BOX (temp_combo), _("Fahrenheit")); gtk_widget_show (temp_combo); if ( ! g_settings_is_writable (pref->priv->applet->settings, "temperature-unit")) { hard_set_sensitive (pref->priv->basic_temp_combo, FALSE); } /* Speed Unit */ speed_label = gtk_label_new_with_mnemonic (_("_Wind speed unit:")); gtk_label_set_use_markup (GTK_LABEL (speed_label), TRUE); gtk_label_set_justify (GTK_LABEL (speed_label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (speed_label), 0, 0.5); gtk_widget_show (speed_label); speed_combo = gtk_combo_box_new_text (); pref->priv->basic_speed_combo = speed_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (speed_label), speed_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (speed_combo), _("Default")); /* TRANSLATOR: The wind speed unit "meters per second" */ gtk_combo_box_append_text (GTK_COMBO_BOX (speed_combo), _("m/s")); /* TRANSLATOR: The wind speed unit "kilometers per hour" */ gtk_combo_box_append_text (GTK_COMBO_BOX (speed_combo), _("km/h")); /* TRANSLATOR: The wind speed unit "miles per hour" */ gtk_combo_box_append_text (GTK_COMBO_BOX (speed_combo), _("mph")); /* TRANSLATOR: The wind speed unit "knots" */ gtk_combo_box_append_text (GTK_COMBO_BOX (speed_combo), _("knots")); gtk_combo_box_append_text (GTK_COMBO_BOX (speed_combo), _("Beaufort scale")); gtk_widget_show (speed_combo); if (!g_settings_is_writable (pref->priv->applet->settings, "speed-unit")) { hard_set_sensitive (pref->priv->basic_speed_combo, FALSE); } /* Pressure Unit */ pres_label = gtk_label_new_with_mnemonic (_("_Pressure unit:")); gtk_label_set_use_markup (GTK_LABEL (pres_label), TRUE); gtk_label_set_justify (GTK_LABEL (pres_label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (pres_label), 0, 0.5); gtk_widget_show (pres_label); pres_combo = gtk_combo_box_new_text (); pref->priv->basic_pres_combo = pres_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (pres_label), pres_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("Default")); /* TRANSLATOR: The pressure unit "kiloPascals" */ gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("kPa")); /* TRANSLATOR: The pressure unit "hectoPascals" */ gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("hPa")); /* TRANSLATOR: The pressure unit "millibars" */ gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("mb")); /* TRANSLATOR: The pressure unit "millibars of mercury" */ gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("mmHg")); /* TRANSLATOR: The pressure unit "inches of mercury" */ gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("inHg")); /* TRANSLATOR: The pressure unit "atmospheres" */ gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("atm")); gtk_widget_show (pres_combo); if (!g_settings_is_writable(pref->priv->applet->settings, "pressure-unit")) { hard_set_sensitive(pref->priv->basic_pres_combo, FALSE); } /* Distance Unit */ dist_label = gtk_label_new_with_mnemonic (_("_Visibility unit:")); gtk_label_set_use_markup (GTK_LABEL (dist_label), TRUE); gtk_label_set_justify (GTK_LABEL (dist_label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (dist_label), 0, 0.5); gtk_widget_show (dist_label); dist_combo = gtk_combo_box_new_text (); pref->priv->basic_dist_combo = dist_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (dist_label), dist_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (dist_combo), _("Default")); /* TRANSLATOR: The distance unit "meters" */ gtk_combo_box_append_text (GTK_COMBO_BOX (dist_combo), _("meters")); /* TRANSLATOR: The distance unit "kilometers" */ gtk_combo_box_append_text (GTK_COMBO_BOX (dist_combo), _("km")); /* TRANSLATOR: The distance unit "miles" */ gtk_combo_box_append_text (GTK_COMBO_BOX (dist_combo), _("miles")); gtk_widget_show (dist_combo); if ( ! g_settings_is_writable (pref->priv->applet->settings, "distance-unit")) hard_set_sensitive (pref->priv->basic_dist_combo, FALSE); unit_table = gtk_table_new(5, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(unit_table), 6); gtk_table_set_col_spacings(GTK_TABLE(unit_table), 12); gtk_table_attach(GTK_TABLE(unit_table), temp_label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), temp_combo, 1, 2, 0, 1); gtk_table_attach(GTK_TABLE(unit_table), speed_label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), speed_combo, 1, 2, 1, 2); gtk_table_attach(GTK_TABLE(unit_table), pres_label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), pres_combo, 1, 2, 2, 3); gtk_table_attach(GTK_TABLE(unit_table), dist_label, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), dist_combo, 1, 2, 3, 4); gtk_widget_show(unit_table); g_signal_connect (temp_combo, "changed", G_CALLBACK (temp_combo_changed_cb), pref); g_signal_connect (speed_combo, "changed", G_CALLBACK (speed_combo_changed_cb), pref); g_signal_connect (dist_combo, "changed", G_CALLBACK (dist_combo_changed_cb), pref); g_signal_connect (pres_combo, "changed", G_CALLBACK (pres_combo_changed_cb), pref); #ifdef RADARMAP pref->priv->basic_radar_btn = gtk_check_button_new_with_mnemonic (_("Enable _radar map")); gtk_widget_show (pref->priv->basic_radar_btn); g_signal_connect (G_OBJECT (pref->priv->basic_radar_btn), "toggled", G_CALLBACK (radar_toggled), pref); if (!g_settings_is_writable (pref->priv->applet->settings, "enable-radar-map")) { hard_set_sensitive(pref->priv->basic_radar_btn, FALSE); } radar_toggle_hbox = gtk_hbox_new(FALSE, 12); gtk_widget_show(radar_toggle_hbox); label = gtk_label_new (" "); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (radar_toggle_hbox), label, FALSE, FALSE, 0); pref->priv->basic_radar_url_btn = gtk_check_button_new_with_mnemonic (_("Use _custom address for radar map")); gtk_widget_show (pref->priv->basic_radar_url_btn); gtk_box_pack_start (GTK_BOX (radar_toggle_hbox), pref->priv->basic_radar_url_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (pref->priv->basic_radar_url_btn), "toggled", G_CALLBACK (use_radar_url_toggled), pref); if ( ! g_settings_is_writable (pref->priv->applet->settings, "use-custom-radar-url")) { hard_set_sensitive (pref->priv->basic_radar_url_btn, FALSE); } pref->priv->basic_radar_url_hbox = gtk_hbox_new (FALSE, 12); gtk_widget_show (pref->priv->basic_radar_url_hbox); label = gtk_label_new (" "); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), label, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("A_ddress:")); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), label, FALSE, FALSE, 0); pref->priv->basic_radar_url_entry = gtk_entry_new (); gtk_widget_show (pref->priv->basic_radar_url_entry); gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), pref->priv->basic_radar_url_entry, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (pref->priv->basic_radar_url_entry), "focus_out_event", G_CALLBACK (radar_url_changed), pref); if ( ! g_settings_is_writable (pref->priv->applet->settings, "radar")) { hard_set_sensitive (pref->priv->basic_radar_url_entry, FALSE); } #endif /* RADARMAP */ #ifdef HAVE_LIBNOTIFY /* setup show-notifications button */ pref->priv->basic_show_notifications_btn = gtk_check_button_new_with_mnemonic (_("Show _notifications")); if (!g_settings_is_writable (pref->priv->applet->settings, "show-notifications")) { hard_set_sensitive (pref->priv->basic_show_notifications_btn, FALSE); } g_signal_connect (G_OBJECT (pref->priv->basic_show_notifications_btn), "toggled", G_CALLBACK (show_notifications_toggled), pref); #endif frame = create_hig_catagory (pref_basic_vbox, _("Update")); pref_basic_update_hbox = gtk_hbox_new (FALSE, 12); pref_basic_update_lbl = gtk_label_new_with_mnemonic (_("_Automatically update every:")); gtk_widget_show (pref_basic_update_lbl); /* gtk_label_set_justify (GTK_LABEL (pref_basic_update_lbl), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment (GTK_MISC (pref_basic_update_lbl), 1, 0.5); */ gtk_widget_show (pref_basic_update_hbox); pref_basic_update_spin_adj = gtk_adjustment_new (30, 1, 3600, 5, 25, 1); pref->priv->basic_update_spin = gtk_spin_button_new (GTK_ADJUSTMENT (pref_basic_update_spin_adj), 1, 0); gtk_widget_show (pref->priv->basic_update_spin); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (pref->priv->basic_update_spin), TRUE); gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (pref->priv->basic_update_spin), GTK_UPDATE_IF_VALID); g_signal_connect (G_OBJECT (pref->priv->basic_update_spin), "value_changed", G_CALLBACK (update_interval_changed), pref); pref_basic_update_sec_lbl = gtk_label_new (_("minutes")); gtk_widget_show (pref_basic_update_sec_lbl); if ( ! g_settings_is_writable (pref->priv->applet->settings, "auto-update-interval")) { hard_set_sensitive (pref->priv->basic_update_spin, FALSE); hard_set_sensitive (pref_basic_update_sec_lbl, FALSE); } value_hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (pref_basic_update_hbox), pref_basic_update_alignment, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (pref_basic_update_hbox), value_hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (value_hbox), pref->priv->basic_update_spin, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (value_hbox), pref_basic_update_sec_lbl, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), pref_basic_update_hbox); frame = create_hig_catagory (pref_basic_vbox, _("Display")); vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), unit_table, TRUE, TRUE, 0); #ifdef RADARMAP gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_radar_btn, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), radar_toggle_hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_radar_url_hbox, TRUE, TRUE, 0); #endif /* RADARMAP */ #ifdef HAVE_LIBNOTIFY /* add the show-notification toggle button to the vbox of the display section */ gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_show_notifications_btn, TRUE, TRUE, 0); #endif gtk_container_add (GTK_CONTAINER (frame), vbox); pref_basic_note_lbl = gtk_label_new (_("General")); gtk_widget_show (pref_basic_note_lbl); gtk_notebook_set_tab_label (GTK_NOTEBOOK (pref_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (pref_notebook), 0), pref_basic_note_lbl); /* * Location page. */ pref_loc_hbox = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (pref_loc_hbox), 12); gtk_container_add (GTK_CONTAINER (pref_notebook), pref_loc_hbox); tree_label = gtk_label_new_with_mnemonic (_("_Select a location:")); gtk_misc_set_alignment (GTK_MISC (tree_label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (pref_loc_hbox), tree_label, FALSE, FALSE, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); pref->priv->tree = gtk_tree_view_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (tree_label), GTK_WIDGET (pref->priv->tree)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pref->priv->tree), FALSE); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pref->priv->tree)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (row_selected_cb), pref); gtk_container_add (GTK_CONTAINER (scrolled_window), pref->priv->tree); gtk_widget_show (pref->priv->tree); gtk_widget_show (scrolled_window); gtk_box_pack_start (GTK_BOX (pref_loc_hbox), scrolled_window, TRUE, TRUE, 0); load_locations(pref); pref_find_hbox = gtk_hbox_new (FALSE, 6); pref_find_label = gtk_label_new (_("_Find:")); gtk_label_set_use_underline (GTK_LABEL (pref_find_label), TRUE); pref->priv->find_entry = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (pref_find_label), pref->priv->find_entry); pref->priv->find_next_btn = gtk_button_new_with_mnemonic (_("Find _Next")); gtk_widget_set_sensitive (pref->priv->find_next_btn, FALSE); image = gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (pref->priv->find_next_btn), image); g_signal_connect (G_OBJECT (pref->priv->find_next_btn), "clicked", G_CALLBACK (find_next_clicked), pref); g_signal_connect (G_OBJECT (pref->priv->find_entry), "changed", G_CALLBACK (find_entry_changed), pref); gtk_container_set_border_width (GTK_CONTAINER (pref_find_hbox), 0); gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref_find_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref->priv->find_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref->priv->find_next_btn, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (pref_loc_hbox), pref_find_hbox, FALSE, FALSE, 0); if ( ! g_settings_is_writable (pref->priv->applet->settings, "location0")) { hard_set_sensitive (scrolled_window, FALSE); } pref_loc_note_lbl = gtk_label_new (_("Location")); gtk_widget_show (pref_loc_note_lbl); gtk_notebook_set_tab_label (GTK_NOTEBOOK (pref_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (pref_notebook), 1), pref_loc_note_lbl); g_signal_connect (G_OBJECT (pref), "response", G_CALLBACK (response_cb), pref); mateweather_pref_set_accessibility (pref); gtk_label_set_mnemonic_widget (GTK_LABEL (pref_basic_update_sec_lbl), pref->priv->basic_update_spin); gtk_label_set_mnemonic_widget (GTK_LABEL (label), pref->priv->basic_radar_url_entry); }
GtkWidget *create_dialog2 (int mmin, int mmax) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *label1; GtkObject *spinbutton1_adj; GtkWidget *spinbutton1; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("dialog1")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); label1 = gtk_label_new (_("label1")); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (vbox1), label1, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); spinbutton1_adj = gtk_adjustment_new (1, mmin, mmax, 1, 10, 10); spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 0); gtk_widget_show (spinbutton1); gtk_box_pack_start (GTK_BOX (vbox1), spinbutton1, FALSE, FALSE, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton1), TRUE); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, spinbutton1, "spinbutton1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); gtk_widget_grab_focus (okbutton1); gtk_widget_grab_default (okbutton1); return dialog1; }
/* Main program. */ int main(int argc, char * argv[]) { #ifdef ENABLE_NLS setlocale(LC_ALL, ""); bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #endif /* Initialize GTK (via g_option_context_parse) and parse command line arguments. */ GOptionContext * context = g_option_context_new(""); g_option_context_add_main_entries(context, opt_entries, GETTEXT_PACKAGE); g_option_context_add_group(context, gtk_get_option_group(TRUE)); GError * err = NULL; if ( ! g_option_context_parse(context, &argc, &argv, &err)) { g_print(_("Error: %s\n"), err->message); g_error_free(err); return 1; } g_option_context_free(context); HandlerContext handler_context; memset(&handler_context, 0, sizeof(handler_context)); /* Get the lxsession PID. */ const char * p = g_getenv("_LXSESSION_PID"); if (p != NULL) handler_context.lxsession_pid = atoi(p); /* Initialize capabilities of the systemd mechanism. */ if (dbus_systemd_CanPowerOff()) { handler_context.shutdown_available = TRUE; handler_context.shutdown_systemd = TRUE; } if (dbus_systemd_CanReboot()) { handler_context.reboot_available = TRUE; handler_context.reboot_systemd = TRUE; } if (dbus_systemd_CanSuspend()) { handler_context.suspend_available = TRUE; handler_context.suspend_systemd = TRUE; } if (dbus_systemd_CanHibernate()) { handler_context.hibernate_available = TRUE; handler_context.hibernate_systemd = TRUE; } /* Initialize capabilities of the ConsoleKit mechanism. */ if (!handler_context.shutdown_available && dbus_ConsoleKit_CanStop()) { handler_context.shutdown_available = TRUE; handler_context.shutdown_ConsoleKit = TRUE; } if (!handler_context.reboot_available && dbus_ConsoleKit_CanRestart()) { handler_context.reboot_available = TRUE; handler_context.reboot_ConsoleKit = TRUE; } /* Initialize capabilities of the UPower mechanism. */ if (!handler_context.suspend_available && dbus_UPower_CanSuspend()) { handler_context.suspend_available = TRUE; handler_context.suspend_UPower = TRUE; } if (!handler_context.hibernate_available && dbus_UPower_CanHibernate()) { handler_context.hibernate_available = TRUE; handler_context.hibernate_UPower = TRUE; } /* If we are under GDM, its "Switch User" is available. */ if (verify_running("gdm", "gdmflexiserver")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_GDM = TRUE; } /* If we are under GDM3, its "Switch User" is available. */ if (verify_running("gdm3", "gdmflexiserver")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_GDM = TRUE; } /* lightdm also use gdmflexiserver */ if (verify_running("lightdm", "gdmflexiserver")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_GDM = TRUE; } /* lightdm also use gdmflexiserver */ if (verify_running("lightdm", "gdmflexiserver")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_GDM = TRUE; } /* lightdm can also be find by the env */ if (g_getenv("XDG_SEAT_PATH")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_LIGHTDM = TRUE; } /* If we are under KDM, its "Switch User" is available. */ if (verify_running("kdm", "kdmctl")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_KDM = TRUE; } if (verify_running("lxdm", "lxdm-binary")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_LXDM = TRUE; } /* LTSP support */ if (g_getenv("LTSP_CLIENT")) { handler_context.ltsp = TRUE; handler_context.shutdown_available = TRUE; handler_context.reboot_available = TRUE; } /* Lock screen */ const gchar* very_lock_screen = determine_lock_screen(); if (very_lock_screen) { handler_context.lock_screen = TRUE; } /* Make the button images accessible. */ gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), PACKAGE_DATA_DIR "/lxsession/images"); /* Get the background pixbuf. */ GdkPixbuf * pixbuf = get_background_pixbuf(); /* Create the toplevel window. */ GtkWidget * window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_decorated(GTK_WINDOW(window), FALSE); gtk_window_fullscreen(GTK_WINDOW(window)); GdkScreen* screen = gtk_widget_get_screen(window); gtk_window_set_default_size(GTK_WINDOW(window), gdk_screen_get_width(screen), gdk_screen_get_height(screen)); gtk_widget_set_app_paintable(window, TRUE); g_signal_connect(G_OBJECT(window), "expose_event", G_CALLBACK(expose_event), pixbuf); /* Toplevel container */ GtkWidget* alignment = gtk_alignment_new(0.5, 0.5, 0.0, 0.0); gtk_container_add(GTK_CONTAINER(window), alignment); GtkWidget* center_area = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(alignment), center_area); GtkWidget* center_vbox = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(center_vbox), 12); gtk_container_add(GTK_CONTAINER(center_area), center_vbox); GtkWidget* controls = gtk_vbox_new(FALSE, 6); /* If specified, apply a user-specified banner image. */ if (banner_path != NULL) { GtkWidget * banner_image = gtk_image_new_from_file(banner_path); GtkPositionType banner_position = get_banner_position(); switch (banner_position) { case GTK_POS_LEFT: case GTK_POS_RIGHT: { /* Create a horizontal box to contain the image and the controls. */ GtkWidget * box = gtk_hbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(center_vbox), box, FALSE, FALSE, 0); /* Pack the image and a separator. */ gtk_misc_set_alignment(GTK_MISC(banner_image), 0.5, 0.0); if (banner_position == GTK_POS_LEFT) { gtk_box_pack_start(GTK_BOX(box), banner_image, FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(box), gtk_vseparator_new(), FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(box), controls, FALSE, FALSE, 2); } else { gtk_box_pack_start(GTK_BOX(box), controls, FALSE, FALSE, 2); gtk_box_pack_end(GTK_BOX(box), gtk_vseparator_new(), FALSE, FALSE, 2); gtk_box_pack_end(GTK_BOX(box), banner_image, FALSE, FALSE, 2); } } break; case GTK_POS_TOP: gtk_box_pack_start(GTK_BOX(controls), banner_image, FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(controls), gtk_hseparator_new(), FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(center_vbox), controls, FALSE, FALSE, 0); break; case GTK_POS_BOTTOM: gtk_box_pack_end(GTK_BOX(controls), banner_image, FALSE, FALSE, 2); gtk_box_pack_end(GTK_BOX(controls), gtk_hseparator_new(), FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(center_vbox), controls, FALSE, FALSE, 0); break; } } else gtk_box_pack_start(GTK_BOX(center_vbox), controls, FALSE, FALSE, 0); /* Create the label. */ GtkWidget * label = gtk_label_new(""); if (prompt == NULL) { const char * session_name = g_getenv("DESKTOP_SESSION"); if (session_name == NULL) session_name = "LXDE"; const gchar *command_line = "lsb_release -r -s"; gchar *output = NULL; GError *error; if (!g_spawn_command_line_sync( command_line, &output, NULL, NULL, &error)) { fprintf (stderr, "Error: %s\n", error->message); g_error_free (error); } if (output == NULL) { output = ""; } else { output[strlen ( output ) - 1] = '\0'; } prompt = g_strdup_printf(_("<b><big>Logout %s %s session ?</big></b>"), session_name, output); } gtk_label_set_markup(GTK_LABEL(label), prompt); gtk_box_pack_start(GTK_BOX(controls), label, FALSE, FALSE, 4); /* Create the Shutdown button. */ if (handler_context.shutdown_available) { GtkWidget * shutdown_button = gtk_button_new_with_mnemonic(_("Sh_utdown")); GtkWidget * image = gtk_image_new_from_icon_name("system-shutdown", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(shutdown_button), image); gtk_button_set_alignment(GTK_BUTTON(shutdown_button), 0.0, 0.5); g_signal_connect(G_OBJECT(shutdown_button), "clicked", G_CALLBACK(shutdown_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), shutdown_button, FALSE, FALSE, 4); } /* Create the Reboot button. */ if (handler_context.reboot_available) { GtkWidget * reboot_button = gtk_button_new_with_mnemonic(_("_Reboot")); GtkWidget * image = gtk_image_new_from_icon_name("gnome-session-reboot", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(reboot_button), image); gtk_button_set_alignment(GTK_BUTTON(reboot_button), 0.0, 0.5); g_signal_connect(G_OBJECT(reboot_button), "clicked", G_CALLBACK(reboot_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), reboot_button, FALSE, FALSE, 4); } /* Create the Suspend button. */ if (handler_context.suspend_available && !handler_context.ltsp) { GtkWidget * suspend_button = gtk_button_new_with_mnemonic(_("_Suspend")); GtkWidget * image = gtk_image_new_from_icon_name("gnome-session-suspend", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(suspend_button), image); gtk_button_set_alignment(GTK_BUTTON(suspend_button), 0.0, 0.5); g_signal_connect(G_OBJECT(suspend_button), "clicked", G_CALLBACK(suspend_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), suspend_button, FALSE, FALSE, 4); } /* Create the Hibernate button. */ if (handler_context.hibernate_available && !handler_context.ltsp) { GtkWidget * hibernate_button = gtk_button_new_with_mnemonic(_("_Hibernate")); GtkWidget * image = gtk_image_new_from_icon_name("gnome-session-hibernate", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(hibernate_button), image); gtk_button_set_alignment(GTK_BUTTON(hibernate_button), 0.0, 0.5); g_signal_connect(G_OBJECT(hibernate_button), "clicked", G_CALLBACK(hibernate_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), hibernate_button, FALSE, FALSE, 4); } /* Create the Switch User button. */ if (handler_context.switch_user_available && !handler_context.ltsp) { GtkWidget * switch_user_button = gtk_button_new_with_mnemonic(_("S_witch User")); GtkWidget * image = gtk_image_new_from_icon_name("gnome-session-switch", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(switch_user_button), image); gtk_button_set_alignment(GTK_BUTTON(switch_user_button), 0.0, 0.5); g_signal_connect(G_OBJECT(switch_user_button), "clicked", G_CALLBACK(switch_user_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), switch_user_button, FALSE, FALSE, 4); } /* Create the Lock Screen button. */ if (handler_context.lock_screen && !handler_context.ltsp) { GtkWidget * lock_screen_button = gtk_button_new_with_mnemonic(_("L_ock Screen")); GtkWidget * image = gtk_image_new_from_icon_name("system-lock-screen", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(lock_screen_button), image); gtk_button_set_alignment(GTK_BUTTON(lock_screen_button), 0.0, 0.5); g_signal_connect(G_OBJECT(lock_screen_button), "clicked", G_CALLBACK(lock_screen_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), lock_screen_button, FALSE, FALSE, 4); } /* Create the Logout button. */ GtkWidget * logout_button = gtk_button_new_with_mnemonic(_("_Logout")); GtkWidget * image = gtk_image_new_from_icon_name("system-log-out", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(logout_button), image); gtk_button_set_alignment(GTK_BUTTON(logout_button), 0.0, 0.5); g_signal_connect(G_OBJECT(logout_button), "clicked", G_CALLBACK(logout_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), logout_button, FALSE, FALSE, 4); /* Create the Cancel button. */ GtkWidget * cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_button_set_alignment(GTK_BUTTON(cancel_button), 0.0, 0.5); g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(cancel_clicked), NULL); gtk_box_pack_start(GTK_BOX(controls), cancel_button, FALSE, FALSE, 4); /* Create the error text. */ handler_context.error_label = gtk_label_new(""); gtk_label_set_justify(GTK_LABEL(handler_context.error_label), GTK_JUSTIFY_CENTER); gtk_box_pack_start(GTK_BOX(controls), handler_context.error_label, FALSE, FALSE, 4); /* Show everything. */ gtk_widget_show_all(window); /* Run the main event loop. */ gtk_main(); /* Return. */ return 0; }
void uade_gui_file_info(char *filename, char *gui_player_filename, char *modulename, char *playername, char *formatname) { GtkWidget *fileinfo_base_vbox; GtkWidget *fileinfo_frame; GtkWidget *fileinfo_table; GtkWidget *fileinfo_modulename_label; GtkWidget *fileinfo_modulename_hbox; GtkWidget *fileinfo_hrule1; GtkWidget *fileinfo_playername_hbox; GtkWidget *fileinfo_playername_label; GtkWidget *fileinfo_playerinfo_button; GtkWidget *fileinfo_hrule2; GtkWidget *fileinfo_subsong_label; GtkWidget *fileinfo_minsubsong_label; GtkWidget *fileinfo_maxsubsong_label; GtkWidget *fileinfo_hrule3; GtkWidget *fileinfo_hrule4; GtkWidget *fileinfo_button_box; GtkWidget *ok_button; #ifdef __AUDACIOUS_INPUT_PLUGIN_API__ char * decoded = NULL; if (strncmp(filename, "file:/",6) == 0) { decoded = g_filename_from_uri((char *) filename, NULL, NULL); filename = decoded; } #endif strlcpy(module_filename, filename, sizeof module_filename); strlcpy(player_filename, gui_player_filename, sizeof player_filename); if (fileinfowin == NULL) { fileinfo_tooltips = gtk_tooltips_new(); fileinfowin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(fileinfowin), "UADE file info"); gtk_window_set_position(GTK_WINDOW(fileinfowin), GTK_WIN_POS_MOUSE); gtk_container_set_border_width(GTK_CONTAINER(fileinfowin), 10); gtk_window_set_policy(GTK_WINDOW(fileinfowin), FALSE, FALSE, FALSE); gtk_signal_connect(GTK_OBJECT(fileinfowin), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &fileinfowin); /* Start of Contents Box */ fileinfo_base_vbox = gtk_vbox_new(FALSE, 10); gtk_container_set_border_width(GTK_CONTAINER (fileinfo_base_vbox), 5); gtk_container_add(GTK_CONTAINER(fileinfowin), fileinfo_base_vbox); /* Start of File info frame, text and option widgets */ fileinfo_frame = gtk_frame_new("File info: "); gtk_box_pack_start(GTK_BOX(fileinfo_base_vbox), fileinfo_frame, TRUE, TRUE, 0); /* Start of Fileinfotable */ fileinfo_table = gtk_table_new(12, 2, FALSE); gtk_widget_show(fileinfo_table); gtk_container_add(GTK_CONTAINER(fileinfo_frame), fileinfo_table); gtk_container_set_border_width(GTK_CONTAINER(fileinfo_table), 5); /* 1x1 */ fileinfo_modulename_label = gtk_label_new("Module: "); gtk_misc_set_padding(GTK_MISC(fileinfo_modulename_label), 5, 5); /* gtk_misc_set_alignment (GTK_MISC (fileinfo_modulename_label), 1, 0); */ gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_modulename_label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); /* 1x2 */ /* 1x3 */ fileinfo_hrule1 = gtk_hseparator_new(); gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_hrule1, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); /* 1x4 */ fileinfo_playername_label = gtk_label_new("Playerformat: "); gtk_misc_set_padding(GTK_MISC(fileinfo_playername_label), 5, 5); /* gtk_misc_set_alignment (GTK_MISC (fileinfo_playername_label), 1, 0); */ gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_playername_label, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); fileinfo_hrule2 = gtk_hseparator_new(); gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_hrule2, 0, 1, 6, 7, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); /* 1x8*/ fileinfo_subsong_label = gtk_label_new("Curr. subsong: "); gtk_misc_set_padding(GTK_MISC(fileinfo_subsong_label), 5, 5); /* gtk_misc_set_alignment (GTK_MISC (fileinfo_subsong_label), 1, 0); */ gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_subsong_label, 0, 1, 7, 8, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); /* 1x9*/ fileinfo_minsubsong_label = gtk_label_new("Min. subsong: "); gtk_misc_set_padding(GTK_MISC(fileinfo_minsubsong_label), 5, 5); /* gtk_misc_set_alignment (GTK_MISC (fileinfo_minsubsong_label), 1, 0); */ gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_minsubsong_label, 0, 1, 8, 9, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); /* 1x10*/ fileinfo_maxsubsong_label = gtk_label_new("Max. subsong: "); gtk_misc_set_padding(GTK_MISC(fileinfo_maxsubsong_label), 5, 5); /* gtk_misc_set_alignment (GTK_MISC (fileinfo_maxsubsong_label), 1, 0); */ gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_maxsubsong_label, 0, 1, 9, 10, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); /* 2nd Column */ /* 2x1*/ fileinfo_modulename_hbox = gtk_hbox_new(FALSE, 10); gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_modulename_hbox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); if (modulename[0] == 0) { fileinfo_modulename_txt = gtk_label_new(basename(filename)); } else { fileinfo_modulename_txt = gtk_label_new(g_strdup_printf("%s\n(%s)", modulename, basename(filename) )); } gtk_label_set_justify(GTK_LABEL(fileinfo_modulename_txt), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap(GTK_LABEL(fileinfo_modulename_txt), TRUE); gtk_misc_set_alignment(GTK_MISC(fileinfo_modulename_txt), 0, 0.5); gtk_misc_set_padding(GTK_MISC(fileinfo_modulename_txt), 5, 5); fileinfo_hexinfo_button = gtk_button_new_with_label("hex"); GTK_WIDGET_SET_FLAGS(fileinfo_hexinfo_button, GTK_CAN_DEFAULT); gtk_widget_ref(fileinfo_hexinfo_button); gtk_object_set_data_full(GTK_OBJECT(fileinfowin), "fileinfo_hexinfo_button", fileinfo_hexinfo_button, (GtkDestroyNotify) gtk_widget_unref); gtk_tooltips_set_tip(fileinfo_tooltips, fileinfo_hexinfo_button, g_strdup_printf("%s", filename), NULL); gtk_signal_connect_object(GTK_OBJECT (fileinfo_hexinfo_button), "clicked", GTK_SIGNAL_FUNC(uade_mod_info_hex), NULL); fileinfo_moduleinfo_button = gtk_button_new_with_label("Info"); GTK_WIDGET_SET_FLAGS(fileinfo_moduleinfo_button, GTK_CAN_DEFAULT); gtk_widget_ref(fileinfo_moduleinfo_button); gtk_object_set_data_full(GTK_OBJECT(fileinfowin), "fileinfo_moduleinfo_button", fileinfo_moduleinfo_button, (GtkDestroyNotify) gtk_widget_unref); gtk_tooltips_set_tip(fileinfo_tooltips, fileinfo_moduleinfo_button, g_strdup_printf("%s", filename), NULL); gtk_signal_connect_object(GTK_OBJECT (fileinfo_moduleinfo_button), "clicked", GTK_SIGNAL_FUNC(uade_mod_info_module), NULL); gtk_box_pack_start(GTK_BOX(fileinfo_modulename_hbox), fileinfo_modulename_txt, TRUE, TRUE, 0); gtk_box_pack_start_defaults(GTK_BOX(fileinfo_modulename_hbox), fileinfo_hexinfo_button); gtk_box_pack_start_defaults(GTK_BOX(fileinfo_modulename_hbox), fileinfo_moduleinfo_button); /* 2x2*/ /* 2x3*/ fileinfo_hrule3 = gtk_hseparator_new(); gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_hrule3, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); /* 2x4*/ fileinfo_playername_hbox = gtk_hbox_new(FALSE, 10); gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_playername_hbox, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); if (formatname[0] == 0) { fileinfo_playername_txt = gtk_label_new(g_strdup_printf("%s", playername)); } else { /* memory leaks using g_strdup_printf? */ fileinfo_playername_txt = gtk_label_new(g_strdup_printf("%s\n%s", playername, formatname)); } /* fileinfo_playername_txt = gtk_label_new (get_playername()); */ gtk_label_set_justify(GTK_LABEL(fileinfo_playername_txt), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap(GTK_LABEL(fileinfo_playername_txt), TRUE); gtk_misc_set_alignment(GTK_MISC(fileinfo_playername_txt), 0, 0.5); gtk_misc_set_padding(GTK_MISC(fileinfo_playername_txt), 5, 5); fileinfo_playerinfo_button = gtk_button_new_with_label("?"); GTK_WIDGET_SET_FLAGS(fileinfo_playerinfo_button, GTK_CAN_DEFAULT); gtk_signal_connect_object(GTK_OBJECT (fileinfo_playerinfo_button), "clicked", GTK_SIGNAL_FUNC(uade_player_info), NULL); gtk_box_pack_start(GTK_BOX(fileinfo_playername_hbox), fileinfo_playername_txt, TRUE, TRUE, 0); gtk_box_pack_start_defaults(GTK_BOX(fileinfo_playername_hbox), fileinfo_playerinfo_button); fileinfo_hrule4 = gtk_hseparator_new(); gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_hrule4, 1, 2, 6, 7, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); fileinfo_subsong_txt = gtk_label_new(g_strdup_printf("%d", uade_get_cur_subsong(0))); /* gtk_widget_setusize for this widget is a bit of a cludge to set a minimal size for the FileinfoWindow. I can't get it to work either with setting the usize for the window or the table... weird */ gtk_widget_set_usize(fileinfo_subsong_txt, 176, -2); gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_subsong_txt, 1, 2, 7, 8, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(fileinfo_subsong_txt), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap(GTK_LABEL(fileinfo_subsong_txt), TRUE); gtk_misc_set_alignment(GTK_MISC(fileinfo_subsong_txt), 0, 0.5); gtk_misc_set_padding(GTK_MISC(fileinfo_subsong_txt), 5, 5); /* 2x9*/ fileinfo_minsubsong_txt = gtk_label_new(g_strdup_printf("%d", uade_get_min_subsong(0))); gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_minsubsong_txt, 1, 2, 8, 9, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(fileinfo_minsubsong_txt), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap(GTK_LABEL(fileinfo_subsong_txt), TRUE); gtk_misc_set_alignment(GTK_MISC(fileinfo_minsubsong_txt), 0, 0.5); gtk_misc_set_padding(GTK_MISC(fileinfo_minsubsong_txt), 5, 5); /* 2x10*/ fileinfo_maxsubsong_txt = gtk_label_new(g_strdup_printf("%d", uade_get_max_subsong(0))); gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_maxsubsong_txt, 1, 2, 9, 10, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(fileinfo_maxsubsong_txt), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap(GTK_LABEL(fileinfo_maxsubsong_txt), TRUE); gtk_misc_set_alignment(GTK_MISC(fileinfo_maxsubsong_txt), 0, 0.5); gtk_misc_set_padding(GTK_MISC(fileinfo_maxsubsong_txt), 5, 5); /* end of frame. */ /* Start of Ok and Cancel Button Box */ fileinfo_button_box = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(fileinfo_button_box), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(fileinfo_button_box), 5); gtk_box_pack_start(GTK_BOX(fileinfo_base_vbox), fileinfo_button_box, FALSE, FALSE, 0); ok_button = gtk_button_new_with_label("Close"); GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT); gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(fileinfowin)); gtk_box_pack_start_defaults(GTK_BOX(fileinfo_button_box), ok_button); /* End of Button Box */ gtk_widget_show_all(fileinfowin); } else { gdk_window_raise(fileinfowin->window); } #ifdef __AUDACIOUS_INPUT_PLUGIN_API__ if (decoded != NULL) free (decoded); #endif }
GtkWidget* create_step1_dbox (void) { GtkWidget *step1_dbox; GtkWidget *dialog_vbox3; GtkWidget *vbox1; GtkWidget *label10; GtkWidget *hseparator1; GSList *vbox1_group = NULL; GtkWidget *radiobutton1; GtkWidget *label14; GtkWidget *radiobutton2; GtkWidget *label13; GtkWidget *radiobutton3; GtkWidget *label12; GtkWidget *hseparator2; GtkWidget *label11; GtkWidget *dialog_action_area3; GtkWidget *hbuttonbox3; GtkWidget *button4; GtkWidget *hbox4; GtkWidget *pixmap4; guint label7_key; GtkWidget *label7; GtkWidget *button5; GtkWidget *hbox5; GtkWidget *pixmap5; guint label8_key; GtkWidget *label8; GtkWidget *button6; GtkWidget *hbox6; GtkWidget *pixmap6; guint label9_key; GtkWidget *label9; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); step1_dbox = gtk_dialog_new (); gtk_widget_set_name (step1_dbox, "step1_dbox"); gtk_object_set_data (GTK_OBJECT (step1_dbox), "step1_dbox", step1_dbox); gtk_window_set_title (GTK_WINDOW (step1_dbox), _("GtkTiEmu startup")); gtk_window_set_modal (GTK_WINDOW (step1_dbox), TRUE); gtk_window_set_policy (GTK_WINDOW (step1_dbox), TRUE, TRUE, TRUE); dialog_vbox3 = GTK_DIALOG (step1_dbox)->vbox; gtk_widget_set_name (dialog_vbox3, "dialog_vbox3"); gtk_object_set_data (GTK_OBJECT (step1_dbox), "dialog_vbox3", dialog_vbox3); gtk_widget_show (dialog_vbox3); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_set_name (vbox1, "vbox1"); gtk_widget_ref (vbox1); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "vbox1", vbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox3), vbox1, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 5); label10 = gtk_label_new (_("Welcome to GtkTiEmu. To use it, you must have a ROM image...")); gtk_widget_set_name (label10, "label10"); gtk_widget_ref (label10); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "label10", label10, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label10); gtk_box_pack_start (GTK_BOX (vbox1), label10, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label10), TRUE); gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label10), 15, 5); hseparator1 = gtk_hseparator_new (); gtk_widget_set_name (hseparator1, "hseparator1"); gtk_widget_ref (hseparator1); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "hseparator1", hseparator1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hseparator1); gtk_box_pack_start (GTK_BOX (vbox1), hseparator1, TRUE, TRUE, 0); radiobutton1 = gtk_radio_button_new (vbox1_group); vbox1_group = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton1)); gtk_widget_set_name (radiobutton1, "radiobutton1"); gtk_widget_ref (radiobutton1); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "radiobutton1", radiobutton1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (radiobutton1); gtk_box_pack_start (GTK_BOX (vbox1), radiobutton1, FALSE, FALSE, 0); label14 = gtk_label_new (_("You can use TiLP or another dumping program for getting a ROM image of your calculator.")); gtk_widget_set_name (label14, "label14"); gtk_widget_ref (label14); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "label14", label14, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label14); gtk_container_add (GTK_CONTAINER (radiobutton1), label14); gtk_label_set_justify (GTK_LABEL (label14), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label14), TRUE); gtk_misc_set_alignment (GTK_MISC (label14), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label14), 5, 0); radiobutton2 = gtk_radio_button_new (vbox1_group); vbox1_group = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton2)); gtk_widget_set_name (radiobutton2, "radiobutton2"); gtk_widget_ref (radiobutton2); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "radiobutton2", radiobutton2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (radiobutton2); gtk_box_pack_start (GTK_BOX (vbox1), radiobutton2, FALSE, FALSE, 0); label13 = gtk_label_new (_("You have downloaded a FLASH upgrade on the TI website and you would like to convert it.")); gtk_widget_set_name (label13, "label13"); gtk_widget_ref (label13); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "label13", label13, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label13); gtk_container_add (GTK_CONTAINER (radiobutton2), label13); gtk_label_set_justify (GTK_LABEL (label13), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label13), TRUE); gtk_misc_set_alignment (GTK_MISC (label13), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label13), 5, 0); radiobutton3 = gtk_radio_button_new (vbox1_group); vbox1_group = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton3)); gtk_widget_set_name (radiobutton3, "radiobutton3"); gtk_widget_ref (radiobutton3); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "radiobutton3", radiobutton3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (radiobutton3); gtk_box_pack_start (GTK_BOX (vbox1), radiobutton3, FALSE, FALSE, 0); label12 = gtk_label_new (_("You have already a ROM image and you would like to use it.")); gtk_widget_set_name (label12, "label12"); gtk_widget_ref (label12); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "label12", label12, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label12); gtk_container_add (GTK_CONTAINER (radiobutton3), label12); gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label12), TRUE); gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label12), 5, 0); hseparator2 = gtk_hseparator_new (); gtk_widget_set_name (hseparator2, "hseparator2"); gtk_widget_ref (hseparator2); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "hseparator2", hseparator2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hseparator2); gtk_box_pack_start (GTK_BOX (vbox1), hseparator2, TRUE, TRUE, 0); label11 = gtk_label_new (_("Remind you that you should not distribute your ROM images. They are copyrighted by Texas Instruments.")); gtk_widget_set_name (label11, "label11"); gtk_widget_ref (label11); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "label11", label11, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label11); gtk_box_pack_start (GTK_BOX (vbox1), label11, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label11), TRUE); gtk_misc_set_alignment (GTK_MISC (label11), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label11), 15, 5); dialog_action_area3 = GTK_DIALOG (step1_dbox)->action_area; gtk_widget_set_name (dialog_action_area3, "dialog_action_area3"); gtk_object_set_data (GTK_OBJECT (step1_dbox), "dialog_action_area3", dialog_action_area3); gtk_widget_show (dialog_action_area3); gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area3), 10); hbuttonbox3 = gtk_hbutton_box_new (); gtk_widget_set_name (hbuttonbox3, "hbuttonbox3"); gtk_widget_ref (hbuttonbox3); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "hbuttonbox3", hbuttonbox3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbuttonbox3); gtk_box_pack_start (GTK_BOX (dialog_action_area3), hbuttonbox3, TRUE, TRUE, 0); button4 = gtk_button_new (); gtk_widget_set_name (button4, "button4"); gtk_widget_ref (button4); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "button4", button4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button4); gtk_container_add (GTK_CONTAINER (hbuttonbox3), button4); GTK_WIDGET_SET_FLAGS (button4, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (button4, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE); hbox4 = gtk_hbox_new (FALSE, 0); gtk_widget_set_name (hbox4, "hbox4"); gtk_widget_ref (hbox4); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "hbox4", hbox4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox4); gtk_container_add (GTK_CONTAINER (button4), hbox4); pixmap4 = create_pixmap (step1_dbox, "yes.xpm"); gtk_widget_set_name (pixmap4, "pixmap4"); gtk_widget_ref (pixmap4); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "pixmap4", pixmap4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (pixmap4); gtk_box_pack_start (GTK_BOX (hbox4), pixmap4, TRUE, FALSE, 0); label7 = gtk_label_new (""); label7_key = gtk_label_parse_uline (GTK_LABEL (label7), _("< _Back")); gtk_widget_set_name (label7, "label7"); gtk_widget_ref (label7); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "label7", label7, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label7); gtk_box_pack_start (GTK_BOX (hbox4), label7, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label7), 5, 0); button5 = gtk_button_new (); gtk_widget_set_name (button5, "button5"); gtk_widget_ref (button5); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "button5", button5, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button5); gtk_container_add (GTK_CONTAINER (hbuttonbox3), button5); GTK_WIDGET_SET_FLAGS (button5, GTK_CAN_DEFAULT); hbox5 = gtk_hbox_new (FALSE, 0); gtk_widget_set_name (hbox5, "hbox5"); gtk_widget_ref (hbox5); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "hbox5", hbox5, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox5); gtk_container_add (GTK_CONTAINER (button5), hbox5); pixmap5 = create_pixmap (step1_dbox, "yes.xpm"); gtk_widget_set_name (pixmap5, "pixmap5"); gtk_widget_ref (pixmap5); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "pixmap5", pixmap5, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (pixmap5); gtk_box_pack_start (GTK_BOX (hbox5), pixmap5, TRUE, FALSE, 0); label8 = gtk_label_new (""); label8_key = gtk_label_parse_uline (GTK_LABEL (label8), _("_Next >")); gtk_widget_set_name (label8, "label8"); gtk_widget_ref (label8); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "label8", label8, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label8); gtk_box_pack_start (GTK_BOX (hbox5), label8, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label8), 5, 0); button6 = gtk_button_new (); gtk_widget_set_name (button6, "button6"); gtk_widget_ref (button6); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "button6", button6, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button6); gtk_container_add (GTK_CONTAINER (hbuttonbox3), button6); GTK_WIDGET_SET_FLAGS (button6, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (button6, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE); hbox6 = gtk_hbox_new (FALSE, 0); gtk_widget_set_name (hbox6, "hbox6"); gtk_widget_ref (hbox6); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "hbox6", hbox6, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox6); gtk_container_add (GTK_CONTAINER (button6), hbox6); pixmap6 = create_pixmap (step1_dbox, "no.xpm"); gtk_widget_set_name (pixmap6, "pixmap6"); gtk_widget_ref (pixmap6); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "pixmap6", pixmap6, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (pixmap6); gtk_box_pack_start (GTK_BOX (hbox6), pixmap6, TRUE, FALSE, 0); label9 = gtk_label_new (""); label9_key = gtk_label_parse_uline (GTK_LABEL (label9), _("_Cancel")); gtk_widget_set_name (label9, "label9"); gtk_widget_ref (label9); gtk_object_set_data_full (GTK_OBJECT (step1_dbox), "label9", label9, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label9); gtk_box_pack_start (GTK_BOX (hbox6), label9, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label9), 5, 0); gtk_signal_connect (GTK_OBJECT (radiobutton1), "toggled", GTK_SIGNAL_FUNC (step1_on_radiobutton1_toggled), NULL); gtk_signal_connect (GTK_OBJECT (radiobutton2), "toggled", GTK_SIGNAL_FUNC (step2_on_radiobutton2_toggled), NULL); gtk_signal_connect (GTK_OBJECT (radiobutton3), "toggled", GTK_SIGNAL_FUNC (step3_on_radiobutton3_toggled), NULL); gtk_signal_connect (GTK_OBJECT (button4), "clicked", GTK_SIGNAL_FUNC (step1_b1_button_clicked), step1_dbox); gtk_signal_connect (GTK_OBJECT (button5), "clicked", GTK_SIGNAL_FUNC (step1_b2_button_clicked), step1_dbox); gtk_signal_connect (GTK_OBJECT (button6), "clicked", GTK_SIGNAL_FUNC (step1_b3_button_clicked), step1_dbox); gtk_widget_add_accelerator (button4, "clicked", accel_group, label7_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); gtk_widget_add_accelerator (button5, "clicked", accel_group, label8_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); gtk_widget_add_accelerator (button6, "clicked", accel_group, label9_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); gtk_window_add_accel_group (GTK_WINDOW (step1_dbox), accel_group); return step1_dbox; }
GtkWidget* create_msg1_dbox (void) { GtkWidget *msg1_dbox; GtkWidget *dialog_vbox1; GtkWidget *label2; GtkWidget *dialog_action_area1; GtkWidget *hbuttonbox1; GtkWidget *button1; GtkWidget *hbox1; GtkWidget *pixmap1; guint label1_key; GtkWidget *label1; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); msg1_dbox = gtk_dialog_new (); gtk_widget_set_name (msg1_dbox, "msg1_dbox"); gtk_object_set_data (GTK_OBJECT (msg1_dbox), "msg1_dbox", msg1_dbox); gtk_window_set_title (GTK_WINDOW (msg1_dbox), _("Information")); gtk_window_set_modal (GTK_WINDOW (msg1_dbox), TRUE); gtk_window_set_policy (GTK_WINDOW (msg1_dbox), TRUE, TRUE, FALSE); dialog_vbox1 = GTK_DIALOG (msg1_dbox)->vbox; gtk_widget_set_name (dialog_vbox1, "dialog_vbox1"); gtk_object_set_data (GTK_OBJECT (msg1_dbox), "dialog_vbox1", dialog_vbox1); gtk_widget_show (dialog_vbox1); label2 = gtk_label_new (""); gtk_label_parse_uline (GTK_LABEL (label2), _("If you want get a ROM image with\nTiLP, you have to launch it, (eventually) \nconfigure it, and next, go to the 'Functions2'\nmenu for using the ROM dumper.\nTiLP can be downloaded at:\n<http://lpg.ticalc.org/prj_tilp>")); gtk_widget_set_name (label2, "label2"); gtk_widget_ref (label2); gtk_object_set_data_full (GTK_OBJECT (msg1_dbox), "label2", label2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (dialog_vbox1), label2, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label2), TRUE); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label2), 5, 5); dialog_action_area1 = GTK_DIALOG (msg1_dbox)->action_area; gtk_widget_set_name (dialog_action_area1, "dialog_action_area1"); gtk_object_set_data (GTK_OBJECT (msg1_dbox), "dialog_action_area1", dialog_action_area1); gtk_widget_show (dialog_action_area1); gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10); hbuttonbox1 = gtk_hbutton_box_new (); gtk_widget_set_name (hbuttonbox1, "hbuttonbox1"); gtk_widget_ref (hbuttonbox1); gtk_object_set_data_full (GTK_OBJECT (msg1_dbox), "hbuttonbox1", hbuttonbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbuttonbox1); gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE, 0); button1 = gtk_button_new (); gtk_widget_set_name (button1, "button1"); gtk_widget_ref (button1); gtk_object_set_data_full (GTK_OBJECT (msg1_dbox), "button1", button1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button1); gtk_container_add (GTK_CONTAINER (hbuttonbox1), button1); GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (button1, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (button1, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_set_name (hbox1, "hbox1"); gtk_widget_ref (hbox1); gtk_object_set_data_full (GTK_OBJECT (msg1_dbox), "hbox1", hbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (button1), hbox1); pixmap1 = create_pixmap (msg1_dbox, "yes.xpm"); gtk_widget_set_name (pixmap1, "pixmap1"); gtk_widget_ref (pixmap1); gtk_object_set_data_full (GTK_OBJECT (msg1_dbox), "pixmap1", pixmap1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (pixmap1); gtk_box_pack_start (GTK_BOX (hbox1), pixmap1, TRUE, FALSE, 0); label1 = gtk_label_new (""); label1_key = gtk_label_parse_uline (GTK_LABEL (label1), _("_OK")); gtk_widget_set_name (label1, "label1"); gtk_widget_ref (label1); gtk_object_set_data_full (GTK_OBJECT (msg1_dbox), "label1", label1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, TRUE, 0); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label1), 5, 0); gtk_signal_connect (GTK_OBJECT (button1), "clicked", GTK_SIGNAL_FUNC (msg1_ok_button_clicked), msg1_dbox); gtk_widget_add_accelerator (button1, "clicked", accel_group, label1_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); gtk_window_add_accel_group (GTK_WINDOW (msg1_dbox), accel_group); return msg1_dbox; }
static gboolean show_development_warning (void) { GtkWidget *action_area; GtkWidget *content_area; GtkWidget *vbox; GtkWidget *label; GtkWidget *warning_dialog; GtkWidget *checkbox; GtkWidget *alignment; gboolean skip; gchar *text; warning_dialog = gtk_dialog_new (); gtk_window_set_title ( GTK_WINDOW (warning_dialog), "Evolution " VERSION); gtk_window_set_modal ( GTK_WINDOW (warning_dialog), TRUE); gtk_dialog_add_button ( GTK_DIALOG (warning_dialog), _("_OK"), GTK_RESPONSE_OK); action_area = gtk_dialog_get_action_area (GTK_DIALOG (warning_dialog)); content_area = gtk_dialog_get_content_area (GTK_DIALOG (warning_dialog)); gtk_container_set_border_width (GTK_CONTAINER (action_area), 12); gtk_container_set_border_width (GTK_CONTAINER (content_area), 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0); text = g_strdup_printf ( /* xgettext:no-c-format */ /* Preview/Alpha/Beta version warning message */ _("Hi. Thanks for taking the time to download this preview release\n" "of the Evolution groupware suite.\n" "\n" "This version of Evolution is not yet complete. It is getting close,\n" "but some features are either unfinished or do not work properly.\n" "\n" "If you want a stable version of Evolution, we urge you to uninstall\n" "this version, and install version %s instead.\n" "\n" "If you find bugs, please report them to us at bugzilla.gnome.org.\n" "This product comes with no warranty and is not intended for\n" "individuals prone to violent fits of anger.\n" "\n" "We hope that you enjoy the results of our hard work, and we\n" "eagerly await your contributions!\n"), STABLE_VERSION); label = gtk_label_new (text); g_free (text); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0); label = gtk_label_new (_("Thanks\nThe Evolution Team\n")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment (GTK_MISC (label), 1, .5); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0); checkbox = gtk_check_button_new_with_label (_("Do not tell me again")); alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_container_add (GTK_CONTAINER (alignment), checkbox); gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0); gtk_widget_show_all (warning_dialog); gtk_dialog_run (GTK_DIALOG (warning_dialog)); skip = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbox)); gtk_widget_destroy (warning_dialog); return skip; }
int GBcreatewidget(Gwidget_t * parent, Gwidget_t * widget, int attrn, Gwattr_t * attrp) { PIXsize_t ps; char *s; int ai; GdkColor c; int color; GtkWidget *label; if (!parent) { Gerr(POS, G_ERRNOPARENTWIDGET); return -1; } WBU->func = NULL; ps.x = ps.y = MINBWSIZE; s = NULL; for (ai = 0; ai < attrn; ai++) { switch (attrp[ai].id) { case G_ATTRSIZE: GETSIZE(attrp[ai].u.s, ps, MINBWSIZE); break; case G_ATTRBORDERWIDTH: break; case G_ATTRTEXT: s = attrp[ai].u.t; label = gtk_label_new(s); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); gtk_widget_show(label); break; case G_ATTRCOLOR: color = attrp[ai].u.c.index; if (color != 0 && color != 1) { Gerr(POS, G_ERRBADCOLORINDEX, color); return -1; } c.red = attrp[ai].u.c.r * 257; c.green = attrp[ai].u.c.g * 257; c.blue = attrp[ai].u.c.b * 257; /* if (XAllocColor ( Gdisplay, DefaultColormap (Gdisplay, Gscreenn), &c )) { if (color == 0) ADD2ARGS (XtNbackground, c.pixel); else ADD2ARGS (XtNforeground, c.pixel); } */ break; case G_ATTRWINDOWID: Gerr(POS, G_ERRCANNOTSETATTR1, "windowid"); return -1; case G_ATTRBUTTONCB: WBU->func = (Gbuttoncb) attrp[ai].u.func; break; case G_ATTRUSERDATA: widget->udata = attrp[ai].u.u; break; default: Gerr(POS, G_ERRBADATTRID, attrp[ai].id); return -1; } } widget->w = gtk_button_new(); gtk_button_set_relief(widget->w, GTK_RELIEF_NONE); if (label != NULL) gtk_container_add(GTK_CONTAINER(widget->w), label); if (GTK_BOX(parent->w)) { gtk_box_pack_start(GTK_BOX(parent->w), widget->w, FALSE, TRUE, 0); } else { gtk_container_add(GTK_CONTAINER(parent->w), widget->w); } gtk_signal_connect(G_OBJECT(widget->w), "clicked", GTK_SIGNAL_FUNC(bwcallback), widget->udata); gtk_widget_show(widget->w); return 0; }
void create_plug (void) { GtkWidget *win, *vbox, *text; GtkWidget *main_widget = NULL; tabs = get_tabs (options.plug, FALSE); while (!tabs) { usleep (1000); tabs = get_tabs (options.plug, FALSE); } win = gtk_plug_new (0); /* set window borders */ if (options.data.borders == -1) options.data.borders = (gint) gtk_container_get_border_width (GTK_CONTAINER (win)); gtk_container_set_border_width (GTK_CONTAINER (win), (guint) options.data.borders); #if !GTK_CHECK_VERSION(3,0,0) vbox = gtk_vbox_new (FALSE, 0); #else vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); #endif gtk_container_add (GTK_CONTAINER (win), vbox); /* add dialog text */ if (options.data.dialog_text) { gchar *buf = g_strcompress (options.data.dialog_text); text = gtk_label_new (NULL); if (!options.data.no_markup) gtk_label_set_markup (GTK_LABEL (text), buf); else gtk_label_set_text (GTK_LABEL (text), buf); gtk_widget_set_name (text, "yad-dialog-label"); gtk_label_set_line_wrap (GTK_LABEL (text), TRUE); gtk_label_set_selectable (GTK_LABEL (text), options.data.selectable_labels); gtk_label_set_justify (GTK_LABEL (text), options.data.text_align); switch (options.data.text_align) { case GTK_JUSTIFY_LEFT: case GTK_JUSTIFY_FILL: gtk_misc_set_alignment (GTK_MISC (text), 0.0, 0.5); break; case GTK_JUSTIFY_CENTER: gtk_misc_set_alignment (GTK_MISC (text), 0.5, 0.5); break; case GTK_JUSTIFY_RIGHT: gtk_misc_set_alignment (GTK_MISC (text), 1.0, 0.5); break; } gtk_box_pack_start (GTK_BOX (vbox), text, FALSE, FALSE, 2); #if !GTK_CHECK_VERSION(3,0,0) g_signal_connect (G_OBJECT (text), "size-allocate", G_CALLBACK (text_size_allocate_cb), NULL); #endif g_free (buf); } /* add main widget */ switch (options.mode) { case YAD_MODE_CALENDAR: main_widget = calendar_create_widget (win); break; case YAD_MODE_COLOR: main_widget = color_create_widget (win); break; case YAD_MODE_ENTRY: main_widget = entry_create_widget (win); break; case YAD_MODE_FILE: main_widget = file_create_widget (win); break; case YAD_MODE_FONT: main_widget = font_create_widget (win); break; case YAD_MODE_FORM: main_widget = form_create_widget (win); break; #ifdef HAVE_HTML case YAD_MODE_HTML: main_widget = html_create_widget (win); break; #endif case YAD_MODE_ICONS: main_widget = icons_create_widget (win); break; case YAD_MODE_LIST: main_widget = list_create_widget (win); break; case YAD_MODE_MULTI_PROGRESS: main_widget = multi_progress_create_widget (win); break; case YAD_MODE_PROGRESS: main_widget = progress_create_widget (win); break; case YAD_MODE_SCALE: main_widget = scale_create_widget (win); break; case YAD_MODE_TEXTINFO: main_widget = text_create_widget (win); break; default: ; } if (main_widget) gtk_box_pack_start (GTK_BOX (vbox), main_widget, TRUE, TRUE, 2); gtk_widget_show_all (win); /* add plug data */ tabs[options.tabnum].pid = getpid (); tabs[options.tabnum].xid = gtk_plug_get_id (GTK_PLUG (win)); /* FIXME: may be a race here */ tabs[0].xid++; shmdt (tabs); }
GtkWidget * create_dialog (void) { GtkWidget *dlg; GtkWidget *hbox, *vbox, *hbox2, *bbox; GtkWidget *image; GtkWidget *text; GtkWidget *main_widget = NULL; GtkWidget *topb = NULL; /* create dialog window */ dlg = gtk_dialog_new (); if (options.data.splash) gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_SPLASHSCREEN); else gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_NORMAL); gtk_window_set_title (GTK_WINDOW (dlg), options.data.dialog_title); gtk_widget_set_name (dlg, "yad-dialog-window"); #ifndef G_OS_WIN32 if (options.parent) { gdk_window_set_transient_for (gtk_widget_get_window (dlg), gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), options.parent)); } #endif if (options.data.no_escape) g_signal_connect (G_OBJECT (dlg), "close", G_CALLBACK (ignore_close_cb) , NULL); /* get buttons container */ bbox = gtk_dialog_get_action_area (GTK_DIALOG (dlg)); /* set window icon */ if (options.data.window_icon) { if (g_file_test (options.data.window_icon, G_FILE_TEST_EXISTS)) gtk_window_set_icon_from_file (GTK_WINDOW (dlg), options.data.window_icon, NULL); else gtk_window_set_icon_name (GTK_WINDOW (dlg), options.data.window_icon); } /* set window borders */ if (options.data.borders == -1) options.data.borders = (gint) gtk_container_get_border_width (GTK_CONTAINER (dlg)); gtk_container_set_border_width (GTK_CONTAINER (dlg), (guint) options.data.borders); /* set window size and position */ if (!options.data.geometry && !options.data.maximized && !options.data.fullscreen) { gtk_window_set_default_size (GTK_WINDOW (dlg), options.data.width, options.data.height); if (options.data.center) gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER); else if (options.data.mouse) gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE); } /* set window behavior */ if (options.data.sticky) gtk_window_stick (GTK_WINDOW (dlg)); gtk_window_set_keep_above (GTK_WINDOW (dlg), options.data.ontop); gtk_window_set_decorated (GTK_WINDOW (dlg), !options.data.undecorated); gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dlg), options.data.skip_taskbar); gtk_window_set_skip_pager_hint (GTK_WINDOW (dlg), options.data.skip_taskbar); /* create timeout indicator widget */ if (options.data.timeout) { if (G_LIKELY (options.data.to_indicator) && g_ascii_strcasecmp (options.data.to_indicator, "none")) { topb = gtk_progress_bar_new (); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (topb), 1.0); gtk_widget_set_name (topb, "yad-timeout-indicator"); } } /* add top label widgets */ #if !GTK_CHECK_VERSION(3,0,0) hbox = hbox2 = gtk_hbox_new (FALSE, 0); #else hbox = hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); #endif gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), hbox, TRUE, TRUE, 5); #if !GTK_CHECK_VERSION(3,0,0) vbox = gtk_vbox_new (FALSE, 0); #else vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); #endif /* add timeout indicator */ if (topb) { if (g_ascii_strcasecmp (options.data.to_indicator, "top") == 0) { #if !GTK_CHECK_VERSION(3,0,0) gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_LEFT_TO_RIGHT); #endif gtk_box_pack_start (GTK_BOX (vbox), topb, FALSE, FALSE, 2); } else if (g_ascii_strcasecmp (options.data.to_indicator, "bottom") == 0) { #if !GTK_CHECK_VERSION(3,0,0) gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_LEFT_TO_RIGHT); #endif gtk_box_pack_end (GTK_BOX (vbox), topb, FALSE, FALSE, 2); } else if (g_ascii_strcasecmp (options.data.to_indicator, "left") == 0) { #if !GTK_CHECK_VERSION(3,0,0) gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_BOTTOM_TO_TOP); #endif gtk_box_pack_start (GTK_BOX (hbox), topb, FALSE, FALSE, 2); } else if (g_ascii_strcasecmp (options.data.to_indicator, "right") == 0) { #if !GTK_CHECK_VERSION(3,0,0) gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_BOTTOM_TO_TOP); #endif gtk_box_pack_end (GTK_BOX (hbox), topb, FALSE, FALSE, 2); } if (settings.show_remain) { gchar *lbl = g_strdup_printf (_("%d sec"), options.data.timeout); #if GTK_CHECK_VERSION(3,0,0) gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (topb), TRUE); #endif gtk_progress_bar_set_text (GTK_PROGRESS_BAR (topb), lbl); g_free (lbl); } } /* must be after indicator! */ gtk_box_pack_end (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); if (options.data.image_on_top) { #if !GTK_CHECK_VERSION(3,0,0) hbox2 = gtk_hbox_new (FALSE, 0); #else hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); #endif gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 0); } if (options.data.dialog_image) { GdkPixbuf *pb = NULL; pb = get_pixbuf (options.data.dialog_image, YAD_BIG_ICON); image = gtk_image_new_from_pixbuf (pb); if (pb) g_object_unref (pb); gtk_widget_set_name (image, "yad-dialog-image"); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox2), image, FALSE, FALSE, 2); } if (options.data.dialog_text) { /* for dnd's tooltip we don't need text label */ if (options.mode != YAD_MODE_DND || !options.dnd_data.tooltip) { gchar *buf = g_strcompress (options.data.dialog_text); text = gtk_label_new (NULL); if (!options.data.no_markup) gtk_label_set_markup (GTK_LABEL (text), buf); else gtk_label_set_text (GTK_LABEL (text), buf); g_free (buf); gtk_widget_set_name (text, "yad-dialog-label"); gtk_label_set_line_wrap (GTK_LABEL (text), TRUE); gtk_label_set_selectable (GTK_LABEL (text), options.data.selectable_labels); gtk_label_set_justify (GTK_LABEL (text), options.data.text_align); switch (options.data.text_align) { case GTK_JUSTIFY_LEFT: case GTK_JUSTIFY_FILL: gtk_misc_set_alignment (GTK_MISC (text), 0.0, 0.5); break; case GTK_JUSTIFY_CENTER: gtk_misc_set_alignment (GTK_MISC (text), 0.5, 0.5); break; case GTK_JUSTIFY_RIGHT: gtk_misc_set_alignment (GTK_MISC (text), 1.0, 0.5); break; } if (options.data.image_on_top) gtk_box_pack_start (GTK_BOX (hbox2), text, TRUE, TRUE, 2); else gtk_box_pack_start (GTK_BOX (vbox), text, FALSE, FALSE, 2); #if !GTK_CHECK_VERSION(3,0,0) if (!options.data.fixed) g_signal_connect (G_OBJECT (text), "size-allocate", G_CALLBACK (text_size_allocate_cb), NULL); #endif } } /* add main widget */ switch (options.mode) { case YAD_MODE_CALENDAR: main_widget = calendar_create_widget (dlg); break; case YAD_MODE_COLOR: main_widget = color_create_widget (dlg); break; case YAD_MODE_DND: dnd_init (dlg); break; case YAD_MODE_ENTRY: main_widget = entry_create_widget (dlg); break; case YAD_MODE_FILE: main_widget = file_create_widget (dlg); break; case YAD_MODE_FONT: main_widget = font_create_widget (dlg); break; case YAD_MODE_FORM: main_widget = form_create_widget (dlg); break; #ifdef HAVE_HTML case YAD_MODE_HTML: main_widget = html_create_widget (dlg); break; #endif case YAD_MODE_ICONS: main_widget = icons_create_widget (dlg); break; case YAD_MODE_LIST: main_widget = list_create_widget (dlg); break; case YAD_MODE_MULTI_PROGRESS: main_widget = multi_progress_create_widget (dlg); break; case YAD_MODE_NOTEBOOK: main_widget = notebook_create_widget (dlg); break; case YAD_MODE_PANED: main_widget = paned_create_widget (dlg); break; case YAD_MODE_PROGRESS: main_widget = progress_create_widget (dlg); break; case YAD_MODE_SCALE: main_widget = scale_create_widget (dlg); break; case YAD_MODE_TEXTINFO: main_widget = text_create_widget (dlg); break; default: ; } if (main_widget) { if (options.data.expander) { GtkWidget *exp; exp = gtk_expander_new_with_mnemonic (options.data.expander); gtk_expander_set_expanded (GTK_EXPANDER (exp), FALSE); gtk_container_add (GTK_CONTAINER (exp), main_widget); gtk_box_pack_start (GTK_BOX (vbox), exp, TRUE, TRUE, 2); } else gtk_box_pack_start (GTK_BOX (vbox), main_widget, TRUE, TRUE, 2); } /* add buttons */ if (!options.data.no_buttons) { if (options.data.buttons) { GSList *tmp = options.data.buttons; do { GtkWidget *btn; YadButton *b = (YadButton *) tmp->data; btn = gtk_button_new (); gtk_container_add (GTK_CONTAINER (btn), get_label (b->name, 2)); gtk_button_set_alignment (GTK_BUTTON (btn), 0.5, 0.5); g_object_set_data (G_OBJECT (btn), "resp", GINT_TO_POINTER (b->response)); g_signal_connect (G_OBJECT (btn), "clicked", G_CALLBACK (btn_cb), b->cmd); gtk_box_pack_start (GTK_BOX (bbox), btn, FALSE, FALSE, 0); tmp = tmp->next; } while (tmp != NULL); } else { if (options.mode == YAD_MODE_PROGRESS || options.mode == YAD_MODE_MULTI_PROGRESS) gtk_dialog_add_buttons (GTK_DIALOG (dlg), GTK_STOCK_CLOSE, YAD_RESPONSE_OK, NULL); else { if (gtk_alternative_dialog_button_order (NULL)) gtk_dialog_add_buttons (GTK_DIALOG (dlg), GTK_STOCK_OK, YAD_RESPONSE_OK, GTK_STOCK_CANCEL, YAD_RESPONSE_CANCEL, NULL); else gtk_dialog_add_buttons (GTK_DIALOG (dlg), GTK_STOCK_CANCEL, YAD_RESPONSE_CANCEL, GTK_STOCK_OK, YAD_RESPONSE_OK, NULL); } gtk_dialog_set_default_response (GTK_DIALOG (dlg), YAD_RESPONSE_OK); } gtk_button_box_set_layout (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dlg))), options.data.buttons_layout); } /* show widgets */ gtk_widget_show_all (gtk_dialog_get_content_area (GTK_DIALOG (dlg))); if (options.data.no_buttons) gtk_widget_hide (bbox); /* parse geometry, if given. must be after showing widget */ if (options.data.geometry && !options.data.maximized && !options.data.fullscreen) { gtk_widget_realize (dlg); gtk_window_parse_geometry (GTK_WINDOW (dlg), options.data.geometry); } gtk_widget_show (dlg); /* set maximized or fixed size after showing widget */ if (options.data.maximized) gtk_window_maximize (GTK_WINDOW (dlg)); else if (options.data.fullscreen) gtk_window_fullscreen (GTK_WINDOW (dlg)); else { gtk_window_set_resizable (GTK_WINDOW (dlg), !options.data.fixed); if (options.data.fixed) gtk_widget_set_size_request (dlg, options.data.width, options.data.height); } /* set timeout */ if (options.data.timeout) { g_timeout_add_seconds (options.data.timeout, timeout_cb, dlg); g_timeout_add_seconds (1, timeout_indicator_cb, topb); } #ifndef G_OS_WIN32 /* print xid */ if (options.print_xid) { fprintf (stderr, "0x%lX", GDK_WINDOW_XID (gtk_widget_get_window (dlg))); fflush (stderr); } #endif return dlg; }
/* * Return GtkWidget of the popup that the caller can get more control such as, * connecting some signal handlers to this widget. */ static GtkWidget* notify_new( const gchar *_caption_text, const gchar *body_text, GtkWidget* parent, GCallback click_cb, gpointer click_cb_data) { GtkWidget *win = gtk_window_new(GTK_WINDOW_POPUP); GtkWidget *context, *body, *frame; gchar *context_text = context_text = g_markup_escape_text(body_text, strlen(body_text)); gchar *caption_text = g_strdup(_caption_text); GtkWidget *imageNotify; GtkWidget *labelNotify; GtkWidget *labelCaption; GtkWidget *button; Win *w; body = gtk_vbox_new(FALSE, 2); context = gtk_hbox_new(FALSE, 0); //gtk_table_new(2, 2, TRUE); /* * load the content */ labelNotify = gtk_label_new(NULL); labelCaption = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(labelNotify), context_text); gtk_label_set_markup(GTK_LABEL(labelCaption), caption_text); if (icon_pixbuf) { imageNotify = gtk_image_new_from_pixbuf(icon_pixbuf); gtk_box_pack_start( GTK_BOX(context), imageNotify, FALSE, FALSE, 5); } gtk_box_pack_start(GTK_BOX(context), labelCaption, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(body), context); gtk_label_set_line_wrap(GTK_LABEL(labelNotify), TRUE); gtk_label_set_justify(GTK_LABEL(labelNotify), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment(GTK_MISC(labelNotify), 0.0, 0.5); gtk_misc_set_padding(GTK_MISC(labelNotify), 25, 0); gtk_box_pack_start(GTK_BOX(body), labelNotify, TRUE, TRUE, 0); button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(win), button); frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN); gtk_container_set_border_width(GTK_CONTAINER(frame),0); gtk_container_add(GTK_CONTAINER(button), frame); gtk_window_set_default_size(GTK_WINDOW(win), win->allocation.width, NHEIGHT); gtk_container_add(GTK_CONTAINER(frame), body); if (click_cb) g_signal_connect( G_OBJECT(button), "clicked", click_cb, click_cb_data); w = begin_animation(win, body); g_free(context_text); w->parent = parent; w->parent_handler_id = !parent ? 0 : g_signal_connect_swapped( G_OBJECT(parent), "destroy", G_CALLBACK(gtk_widget_destroy), win); g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(destroy_win), w); return win; }
void gui_init(dt_lib_module_t *self) { unsigned int i; GtkWidget *container = gtk_vbox_new(FALSE, 5); GtkWidget *output_row = gtk_hbox_new(FALSE, 2); GtkWidget *output_options = gtk_vbox_new(FALSE, 5); GtkWidget *picker_subrow = gtk_hbox_new(FALSE, 2); GtkWidget *restrict_button; GtkWidget *samples_label = dtgtk_label_new(_("live samples"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT); GtkWidget *samples_options_row = gtk_hbox_new(FALSE, 2); // Initializing self data structure dt_lib_colorpicker_t *data = (dt_lib_colorpicker_t*)calloc(1, sizeof(dt_lib_colorpicker_t)); self->data = (void*)data; // Initializing proxy functions and data darktable.lib->proxy.colorpicker.module = self; darktable.lib->proxy.colorpicker.size = dt_conf_get_int("ui_last/colorpicker_size"); darktable.lib->proxy.colorpicker.display_samples = dt_conf_get_int("ui_last/colorpicker_display_samples"); darktable.lib->proxy.colorpicker.live_samples = NULL; darktable.lib->proxy.colorpicker.picked_color_rgb_mean = (uint8_t*)malloc(sizeof(uint8_t) * 3); darktable.lib->proxy.colorpicker.picked_color_rgb_min = (uint8_t*)malloc(sizeof(uint8_t) * 3); darktable.lib->proxy.colorpicker.picked_color_rgb_max = (uint8_t*)malloc(sizeof(uint8_t) * 3); darktable.lib->proxy.colorpicker.picked_color_lab_mean = (float*)malloc(sizeof(float) * 3); darktable.lib->proxy.colorpicker.picked_color_lab_min = (float*)malloc(sizeof(float) * 3); darktable.lib->proxy.colorpicker.picked_color_lab_max = (float*)malloc(sizeof(float) * 3); for(i = 0; i < 3; i++) darktable.lib->proxy.colorpicker.picked_color_rgb_mean[i] = darktable.lib->proxy.colorpicker.picked_color_rgb_min[i] = darktable.lib->proxy.colorpicker.picked_color_rgb_max[i] = 0; for(i = 0; i < 3; i++) darktable.lib->proxy.colorpicker.picked_color_lab_mean[i] = darktable.lib->proxy.colorpicker.picked_color_lab_min[i] = darktable.lib->proxy.colorpicker.picked_color_lab_max[i] = 0; darktable.lib->proxy.colorpicker.update_panel = _update_picker_output; darktable.lib->proxy.colorpicker.update_samples = _update_samples_output; darktable.lib->proxy.colorpicker.set_sample_area = _set_sample_area; darktable.lib->proxy.colorpicker.set_sample_point = _set_sample_point; // Setting up the GUI self->widget = container; gtk_box_pack_start(GTK_BOX(container), output_row, TRUE, TRUE, 0); // The output button data->output_button = dtgtk_button_new(NULL, CPF_STYLE_BOX); gtk_widget_set_size_request(data->output_button, DT_PIXEL_APPLY_DPI(100), DT_PIXEL_APPLY_DPI(100)); gtk_widget_set_sensitive(data->output_button, FALSE); gtk_box_pack_start(GTK_BOX(output_row), data->output_button, FALSE, FALSE, 0); // The picker button, output selectors and label gtk_box_pack_start(GTK_BOX(output_row), output_options, TRUE, TRUE, 0); data->size_selector = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->size_selector), _("point")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->size_selector), _("area")); gtk_combo_box_set_active(GTK_COMBO_BOX(data->size_selector), dt_conf_get_int("ui_last/colorpicker_size")); gtk_widget_set_size_request(data->size_selector, DT_PIXEL_APPLY_DPI(30), -1); gtk_box_pack_start(GTK_BOX(picker_subrow), data->size_selector, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->size_selector), "changed", G_CALLBACK(_size_changed), (gpointer)self); data->picker_button = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_BOX); gtk_widget_set_size_request(data->picker_button, DT_PIXEL_APPLY_DPI(50), -1); gtk_box_pack_start(GTK_BOX(picker_subrow), data->picker_button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(data->picker_button), "toggled", G_CALLBACK(_picker_button_toggled), self); gtk_box_pack_start(GTK_BOX(output_options), picker_subrow, TRUE, TRUE, 0); data->statistic_selector = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("mean")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("min")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("max")); gtk_combo_box_set_active(GTK_COMBO_BOX(data->statistic_selector), dt_conf_get_int("ui_last/colorpicker_mode")); gtk_widget_set_sensitive(data->statistic_selector, dt_conf_get_int("ui_last/colorpicker_size")); gtk_box_pack_start(GTK_BOX(output_options), data->statistic_selector, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->statistic_selector), "changed", G_CALLBACK(_statistic_changed), self); data->color_mode_selector = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->color_mode_selector), _("RGB")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->color_mode_selector), _("Lab")); gtk_combo_box_set_active(GTK_COMBO_BOX(data->color_mode_selector), dt_conf_get_int("ui_last/colorpicker_model")); gtk_box_pack_start(GTK_BOX(output_options), data->color_mode_selector, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->color_mode_selector), "changed", G_CALLBACK(_color_mode_changed), self); data->output_label = gtk_label_new(""); gtk_label_set_justify(GTK_LABEL(data->output_label), GTK_JUSTIFY_CENTER); gtk_widget_set_size_request(data->output_label, DT_PIXEL_APPLY_DPI(80), -1); gtk_box_pack_start(GTK_BOX(output_options), data->output_label, FALSE, FALSE, 0); restrict_button = gtk_check_button_new_with_label( _("restrict histogram to selection")); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(restrict_button), dt_conf_get_int("ui_last/colorpicker_restrict_histogram")); darktable.lib->proxy.colorpicker.restrict_histogram = dt_conf_get_int("ui_last/colorpicker_restrict_histogram"); gtk_box_pack_start(GTK_BOX(container), restrict_button, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(restrict_button), "toggled", G_CALLBACK(_restrict_histogram_changed), NULL); // Adding the live samples section gtk_box_pack_start(GTK_BOX(container), samples_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(container), samples_options_row, TRUE, TRUE, 0); data->samples_statistic_selector = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("mean")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("min")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("max")); gtk_combo_box_set_active(GTK_COMBO_BOX(data->samples_statistic_selector), dt_conf_get_int("ui_last/colorsamples_mode")); gtk_box_pack_start(GTK_BOX(samples_options_row), data->samples_statistic_selector, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->samples_statistic_selector), "changed", G_CALLBACK(_samples_statistic_changed), self); data->samples_mode_selector = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_mode_selector), _("RGB")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_mode_selector), _("Lab")); gtk_combo_box_set_active(GTK_COMBO_BOX(data->samples_mode_selector), dt_conf_get_int("ui_last/colorsamples_model")); gtk_box_pack_start(GTK_BOX(samples_options_row), data->samples_mode_selector, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->samples_mode_selector), "changed", G_CALLBACK(_samples_mode_changed), self); data->add_sample_button = gtk_button_new_with_label(_("add")); gtk_widget_set_sensitive(data->add_sample_button, FALSE); gtk_box_pack_start(GTK_BOX(samples_options_row), data->add_sample_button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(data->add_sample_button), "clicked", G_CALLBACK(_add_sample), self); data->samples_container = gtk_vbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(container), data->samples_container, TRUE, TRUE, 0); data->display_samples_check_box = gtk_check_button_new_with_label(_("display sample areas on image")); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(data->display_samples_check_box), dt_conf_get_int("ui_last/colorpicker_display_samples")); gtk_box_pack_start(GTK_BOX(container), data->display_samples_check_box, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->display_samples_check_box), "toggled", G_CALLBACK(_display_samples_changed), NULL); }
GtkWidget* create_step3_dbox (void) { GtkWidget *step3_dbox; GtkWidget *dialog_vbox3; GtkWidget *vbox1; GtkWidget *label10; GtkWidget *hseparator1; GtkWidget *vbox3; GtkWidget *label12; GtkWidget *label13; GtkWidget *label14; GtkWidget *label15; GtkWidget *label17; GtkWidget *hseparator2; GtkWidget *label11; GtkWidget *dialog_action_area3; GtkWidget *hbuttonbox3; GtkWidget *button4; GtkWidget *hbox4; GtkWidget *pixmap4; guint label7_key; GtkWidget *label7; GtkWidget *button5; GtkWidget *hbox5; GtkWidget *pixmap5; guint label8_key; GtkWidget *label8; GtkWidget *button6; GtkWidget *hbox6; GtkWidget *pixmap6; guint label9_key; GtkWidget *label9; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); step3_dbox = gtk_dialog_new (); gtk_widget_set_name (step3_dbox, "step3_dbox"); gtk_object_set_data (GTK_OBJECT (step3_dbox), "step3_dbox", step3_dbox); gtk_window_set_title (GTK_WINDOW (step3_dbox), _("GtkTiEmu startup")); gtk_window_set_modal (GTK_WINDOW (step3_dbox), TRUE); gtk_window_set_policy (GTK_WINDOW (step3_dbox), TRUE, TRUE, TRUE); dialog_vbox3 = GTK_DIALOG (step3_dbox)->vbox; gtk_widget_set_name (dialog_vbox3, "dialog_vbox3"); gtk_object_set_data (GTK_OBJECT (step3_dbox), "dialog_vbox3", dialog_vbox3); gtk_widget_show (dialog_vbox3); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_set_name (vbox1, "vbox1"); gtk_widget_ref (vbox1); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "vbox1", vbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox3), vbox1, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 5); label10 = gtk_label_new (_("GtkTiEmu is now set up and ready for use. Some tips on how to use the emulator:")); gtk_widget_set_name (label10, "label10"); gtk_widget_ref (label10); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "label10", label10, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label10); gtk_box_pack_start (GTK_BOX (vbox1), label10, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label10), TRUE); gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label10), 15, 5); hseparator1 = gtk_hseparator_new (); gtk_widget_set_name (hseparator1, "hseparator1"); gtk_widget_ref (hseparator1); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "hseparator1", hseparator1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hseparator1); gtk_box_pack_start (GTK_BOX (vbox1), hseparator1, TRUE, TRUE, 0); vbox3 = gtk_vbox_new (FALSE, 0); gtk_widget_set_name (vbox3, "vbox3"); gtk_widget_ref (vbox3); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "vbox3", vbox3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox3); gtk_box_pack_start (GTK_BOX (vbox1), vbox3, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox3), 5); label12 = gtk_label_new (_("* You have access to a popup menu by right-clicking in the emulator's window.")); gtk_widget_set_name (label12, "label12"); gtk_widget_ref (label12); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "label12", label12, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label12); gtk_box_pack_start (GTK_BOX (vbox3), label12, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label12), TRUE); gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label12), 5, 0); label13 = gtk_label_new (_("* To use keys, use mouse or keyboard")); gtk_widget_set_name (label13, "label13"); gtk_widget_ref (label13); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "label13", label13, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label13); gtk_box_pack_start (GTK_BOX (vbox3), label13, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label13), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label13), TRUE); gtk_misc_set_alignment (GTK_MISC (label13), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label13), 5, 0); label14 = gtk_label_new (_("* To change to a different calculator or ROM version, use an item of the ROM menu.")); gtk_widget_set_name (label14, "label14"); gtk_widget_ref (label14); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "label14", label14, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label14); gtk_box_pack_start (GTK_BOX (vbox3), label14, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label14), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label14), TRUE); gtk_misc_set_alignment (GTK_MISC (label14), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label14), 5, 0); label15 = gtk_label_new (_("* You can save the emulator state and config.")); gtk_widget_set_name (label15, "label15"); gtk_widget_ref (label15); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "label15", label15, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label15); gtk_box_pack_start (GTK_BOX (vbox3), label15, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label15), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label15), TRUE); gtk_misc_set_alignment (GTK_MISC (label15), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label15), 5, 0); label17 = gtk_label_new (_("* If your calculator screen is blank, use 'Ctrl' with '+/-' for adjusting contrast.")); gtk_widget_set_name (label17, "label17"); gtk_widget_ref (label17); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "label17", label17, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label17); gtk_box_pack_start (GTK_BOX (vbox3), label17, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label17), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label17), TRUE); gtk_misc_set_alignment (GTK_MISC (label17), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label17), 5, 0); hseparator2 = gtk_hseparator_new (); gtk_widget_set_name (hseparator2, "hseparator2"); gtk_widget_ref (hseparator2); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "hseparator2", hseparator2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hseparator2); gtk_box_pack_start (GTK_BOX (vbox1), hseparator2, TRUE, TRUE, 0); label11 = gtk_label_new (_("Click the 'Finish' button to start GtkTiEmu.")); gtk_widget_set_name (label11, "label11"); gtk_widget_ref (label11); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "label11", label11, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label11); gtk_box_pack_start (GTK_BOX (vbox1), label11, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label11), TRUE); gtk_misc_set_alignment (GTK_MISC (label11), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label11), 15, 5); dialog_action_area3 = GTK_DIALOG (step3_dbox)->action_area; gtk_widget_set_name (dialog_action_area3, "dialog_action_area3"); gtk_object_set_data (GTK_OBJECT (step3_dbox), "dialog_action_area3", dialog_action_area3); gtk_widget_show (dialog_action_area3); gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area3), 10); hbuttonbox3 = gtk_hbutton_box_new (); gtk_widget_set_name (hbuttonbox3, "hbuttonbox3"); gtk_widget_ref (hbuttonbox3); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "hbuttonbox3", hbuttonbox3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbuttonbox3); gtk_box_pack_start (GTK_BOX (dialog_action_area3), hbuttonbox3, TRUE, TRUE, 0); button4 = gtk_button_new (); gtk_widget_set_name (button4, "button4"); gtk_widget_ref (button4); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "button4", button4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button4); gtk_container_add (GTK_CONTAINER (hbuttonbox3), button4); GTK_WIDGET_SET_FLAGS (button4, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (button4, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE); hbox4 = gtk_hbox_new (FALSE, 0); gtk_widget_set_name (hbox4, "hbox4"); gtk_widget_ref (hbox4); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "hbox4", hbox4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox4); gtk_container_add (GTK_CONTAINER (button4), hbox4); pixmap4 = create_pixmap (step3_dbox, "yes.xpm"); gtk_widget_set_name (pixmap4, "pixmap4"); gtk_widget_ref (pixmap4); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "pixmap4", pixmap4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (pixmap4); gtk_box_pack_start (GTK_BOX (hbox4), pixmap4, TRUE, FALSE, 0); label7 = gtk_label_new (""); label7_key = gtk_label_parse_uline (GTK_LABEL (label7), _("< _Back")); gtk_widget_set_name (label7, "label7"); gtk_widget_ref (label7); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "label7", label7, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label7); gtk_box_pack_start (GTK_BOX (hbox4), label7, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label7), 5, 0); button5 = gtk_button_new (); gtk_widget_set_name (button5, "button5"); gtk_widget_ref (button5); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "button5", button5, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button5); gtk_container_add (GTK_CONTAINER (hbuttonbox3), button5); GTK_WIDGET_SET_FLAGS (button5, GTK_CAN_DEFAULT); hbox5 = gtk_hbox_new (FALSE, 0); gtk_widget_set_name (hbox5, "hbox5"); gtk_widget_ref (hbox5); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "hbox5", hbox5, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox5); gtk_container_add (GTK_CONTAINER (button5), hbox5); pixmap5 = create_pixmap (step3_dbox, "yes.xpm"); gtk_widget_set_name (pixmap5, "pixmap5"); gtk_widget_ref (pixmap5); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "pixmap5", pixmap5, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (pixmap5); gtk_box_pack_start (GTK_BOX (hbox5), pixmap5, TRUE, FALSE, 0); label8 = gtk_label_new (""); label8_key = gtk_label_parse_uline (GTK_LABEL (label8), _("_Finish")); gtk_widget_set_name (label8, "label8"); gtk_widget_ref (label8); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "label8", label8, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label8); gtk_box_pack_start (GTK_BOX (hbox5), label8, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label8), 5, 0); button6 = gtk_button_new (); gtk_widget_set_name (button6, "button6"); gtk_widget_ref (button6); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "button6", button6, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button6); gtk_container_add (GTK_CONTAINER (hbuttonbox3), button6); GTK_WIDGET_SET_FLAGS (button6, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (button6, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE); hbox6 = gtk_hbox_new (FALSE, 0); gtk_widget_set_name (hbox6, "hbox6"); gtk_widget_ref (hbox6); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "hbox6", hbox6, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox6); gtk_container_add (GTK_CONTAINER (button6), hbox6); pixmap6 = create_pixmap (step3_dbox, "no.xpm"); gtk_widget_set_name (pixmap6, "pixmap6"); gtk_widget_ref (pixmap6); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "pixmap6", pixmap6, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (pixmap6); gtk_box_pack_start (GTK_BOX (hbox6), pixmap6, TRUE, FALSE, 0); label9 = gtk_label_new (""); label9_key = gtk_label_parse_uline (GTK_LABEL (label9), _("_Cancel")); gtk_widget_set_name (label9, "label9"); gtk_widget_ref (label9); gtk_object_set_data_full (GTK_OBJECT (step3_dbox), "label9", label9, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label9); gtk_box_pack_start (GTK_BOX (hbox6), label9, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label9), 5, 0); gtk_signal_connect (GTK_OBJECT (button4), "clicked", GTK_SIGNAL_FUNC (step3_b1_button_clicked), step3_dbox); gtk_signal_connect (GTK_OBJECT (button5), "clicked", GTK_SIGNAL_FUNC (step3_b2_button_clicked), step3_dbox); gtk_signal_connect (GTK_OBJECT (button6), "clicked", GTK_SIGNAL_FUNC (step3_b3_button_clicked), step3_dbox); gtk_widget_add_accelerator (button4, "clicked", accel_group, label7_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); gtk_widget_add_accelerator (button5, "clicked", accel_group, label8_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); gtk_widget_add_accelerator (button6, "clicked", accel_group, label9_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); gtk_window_add_accel_group (GTK_WINDOW (step3_dbox), accel_group); return step3_dbox; }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *label3; GtkWidget *label4; GtkWidget *checkbuttonHQ; GtkWidget *checkbuttonShowMask; GtkObject *spinbuttonThresh_adj; GtkWidget *spinbuttonThresh; GtkObject *spinbuttonStrength_adj; GtkWidget *spinbuttonStrength; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("MSmooth settings")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); table1 = gtk_table_new (4, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), table1, TRUE, TRUE, 0); label1 = gtk_label_new (_("High Quality :")); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); label2 = gtk_label_new (_("Show Mask :")); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); label3 = gtk_label_new (_("Threshold :")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new (_("Filter Strength :")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); checkbuttonHQ = gtk_check_button_new_with_mnemonic (""); gtk_widget_show (checkbuttonHQ); gtk_table_attach (GTK_TABLE (table1), checkbuttonHQ, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); checkbuttonShowMask = gtk_check_button_new_with_mnemonic (""); gtk_widget_show (checkbuttonShowMask); gtk_table_attach (GTK_TABLE (table1), checkbuttonShowMask, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); spinbuttonThresh_adj = gtk_adjustment_new (1, 0, 100, 1, 10, 10); spinbuttonThresh = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonThresh_adj), 1, 0); gtk_widget_show (spinbuttonThresh); gtk_table_attach (GTK_TABLE (table1), spinbuttonThresh, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonThresh), TRUE); spinbuttonStrength_adj = gtk_adjustment_new (1, 0, 100, 1, 10, 10); spinbuttonStrength = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonStrength_adj), 1, 0); gtk_widget_show (spinbuttonStrength); gtk_table_attach (GTK_TABLE (table1), spinbuttonStrength, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonStrength), TRUE); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonHQ, "checkbuttonHQ"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonShowMask, "checkbuttonShowMask"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonThresh, "spinbuttonThresh"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonStrength, "spinbuttonStrength"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
GtkWidget* create_wait_dbox (void) { GtkWidget *wait_dbox; GtkWidget *dialog_vbox1; GtkWidget *vbox2; GtkWidget *label2; GtkWidget *hseparator3; GtkWidget *label16; GtkWidget *dialog_action_area1; GtkWidget *hbuttonbox1; GtkWidget *button1; GtkWidget *hbox1; GtkWidget *pixmap1; guint label1_key; GtkWidget *label1; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); wait_dbox = gtk_dialog_new (); gtk_widget_set_name (wait_dbox, "wait_dbox"); gtk_object_set_data (GTK_OBJECT (wait_dbox), "wait_dbox", wait_dbox); gtk_window_set_title (GTK_WINDOW (wait_dbox), _("Information")); gtk_window_set_modal (GTK_WINDOW (wait_dbox), TRUE); gtk_window_set_policy (GTK_WINDOW (wait_dbox), TRUE, TRUE, FALSE); dialog_vbox1 = GTK_DIALOG (wait_dbox)->vbox; gtk_widget_set_name (dialog_vbox1, "dialog_vbox1"); gtk_object_set_data (GTK_OBJECT (wait_dbox), "dialog_vbox1", dialog_vbox1); gtk_widget_show (dialog_vbox1); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_set_name (vbox2, "vbox2"); gtk_widget_ref (vbox2); gtk_object_set_data_full (GTK_OBJECT (wait_dbox), "vbox2", vbox2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox2, FALSE, FALSE, 0); label2 = gtk_label_new (_("The FLASH upgrade you have\nselected is being to be converted\ninto a 2MB ROM image.\nPlease wait...")); gtk_widget_set_name (label2, "label2"); gtk_widget_ref (label2); gtk_object_set_data_full (GTK_OBJECT (wait_dbox), "label2", label2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (vbox2), label2, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label2), TRUE); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label2), 5, 5); hseparator3 = gtk_hseparator_new (); gtk_widget_set_name (hseparator3, "hseparator3"); gtk_widget_ref (hseparator3); gtk_object_set_data_full (GTK_OBJECT (wait_dbox), "hseparator3", hseparator3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hseparator3); gtk_box_pack_start (GTK_BOX (vbox2), hseparator3, TRUE, TRUE, 0); label16 = gtk_label_new (_("Note also that the converted ROM\nimage will not have a boot block.")); gtk_widget_set_name (label16, "label16"); gtk_widget_ref (label16); gtk_object_set_data_full (GTK_OBJECT (wait_dbox), "label16", label16, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label16); gtk_box_pack_start (GTK_BOX (vbox2), label16, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label16), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label16), TRUE); gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label16), 5, 5); dialog_action_area1 = GTK_DIALOG (wait_dbox)->action_area; gtk_widget_set_name (dialog_action_area1, "dialog_action_area1"); gtk_object_set_data (GTK_OBJECT (wait_dbox), "dialog_action_area1", dialog_action_area1); gtk_widget_show (dialog_action_area1); gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10); hbuttonbox1 = gtk_hbutton_box_new (); gtk_widget_set_name (hbuttonbox1, "hbuttonbox1"); gtk_widget_ref (hbuttonbox1); gtk_object_set_data_full (GTK_OBJECT (wait_dbox), "hbuttonbox1", hbuttonbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbuttonbox1); gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE, 0); button1 = gtk_button_new (); gtk_widget_set_name (button1, "button1"); gtk_widget_ref (button1); gtk_object_set_data_full (GTK_OBJECT (wait_dbox), "button1", button1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button1); gtk_container_add (GTK_CONTAINER (hbuttonbox1), button1); GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (button1, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (button1, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_set_name (hbox1, "hbox1"); gtk_widget_ref (hbox1); gtk_object_set_data_full (GTK_OBJECT (wait_dbox), "hbox1", hbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (button1), hbox1); pixmap1 = create_pixmap (wait_dbox, "yes.xpm"); gtk_widget_set_name (pixmap1, "pixmap1"); gtk_widget_ref (pixmap1); gtk_object_set_data_full (GTK_OBJECT (wait_dbox), "pixmap1", pixmap1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (pixmap1); gtk_box_pack_start (GTK_BOX (hbox1), pixmap1, TRUE, FALSE, 0); label1 = gtk_label_new (""); label1_key = gtk_label_parse_uline (GTK_LABEL (label1), _("_OK")); gtk_widget_set_name (label1, "label1"); gtk_widget_ref (label1); gtk_object_set_data_full (GTK_OBJECT (wait_dbox), "label1", label1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, TRUE, 0); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label1), 5, 0); gtk_signal_connect (GTK_OBJECT (button1), "clicked", GTK_SIGNAL_FUNC (wait_ok_button_clicked), wait_dbox); gtk_widget_add_accelerator (button1, "clicked", accel_group, label1_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); gtk_window_add_accel_group (GTK_WINDOW (wait_dbox), accel_group); return wait_dbox; }
GtkWidget *create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *label1; GtkWidget *optionmenu1; GtkWidget *menu2; // GtkWidget *_48_khz1; GtkWidget *label2; GtkWidget *optionmenu2; GtkWidget *menu1; GtkWidget *stereo1; GtkWidget *joint_stereo1; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("Audio settings")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); label1 = gtk_label_new (_("Bitrate")); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (vbox1), label1, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); optionmenu1 = gtk_option_menu_new (); gtk_widget_show (optionmenu1); gtk_box_pack_start (GTK_BOX (vbox1), optionmenu1, FALSE, FALSE, 0); menu2 = gtk_menu_new (); /* _48_khz1 = gtk_menu_item_new_with_mnemonic (_("48 khz")); gtk_widget_show (_48_khz1); gtk_container_add (GTK_CONTAINER (menu2), _48_khz1); */ GtkWidget **fq=(GtkWidget **)malloc(sizeof(GtkWidget *)*NB_BITRATE); char string[100]; for(unsigned int i=0;i<NB_BITRATE;i++) { sprintf(string,"%d kbits",BTR[i]); fq[i]=gtk_menu_item_new_with_mnemonic (string); gtk_widget_show (fq[i]); gtk_container_add (GTK_CONTAINER (menu2), fq[i]); } gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), menu2); label2 = gtk_label_new (_("Mode (ignored for mono)")); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (vbox1), label2, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); optionmenu2 = gtk_option_menu_new (); gtk_widget_show (optionmenu2); gtk_box_pack_start (GTK_BOX (vbox1), optionmenu2, FALSE, FALSE, 0); menu1 = gtk_menu_new (); stereo1 = gtk_menu_item_new_with_mnemonic (_("Stereo")); gtk_widget_show (stereo1); gtk_container_add (GTK_CONTAINER (menu1), stereo1); joint_stereo1 = gtk_menu_item_new_with_mnemonic (_("Joint Stereo")); gtk_widget_show (joint_stereo1); gtk_container_add (GTK_CONTAINER (menu1), joint_stereo1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu2), menu1); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, optionmenu1, "optionmenu1"); GLADE_HOOKUP_OBJECT (dialog1, menu2, "menu2"); //GLADE_HOOKUP_OBJECT (dialog1, _48_khz1, "_48_khz1"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, optionmenu2, "optionmenu2"); GLADE_HOOKUP_OBJECT (dialog1, menu1, "menu1"); GLADE_HOOKUP_OBJECT (dialog1, stereo1, "stereo1"); GLADE_HOOKUP_OBJECT (dialog1, joint_stereo1, "joint_stereo1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
void gimp_tools_restore (Gimp *gimp) { GimpContainer *gimp_list; gchar *filename; GList *list; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); gimp_list = gimp_list_new (GIMP_TYPE_TOOL_INFO, FALSE); filename = gimp_personal_rc_file ("toolrc"); if (gimp->be_verbose) g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename)); if (gimp_config_deserialize_file (GIMP_CONFIG (gimp_list), filename, NULL, NULL)) { gint n = gimp_container_get_n_children (gimp->tool_info_list); gint i; gimp_list_reverse (GIMP_LIST (gimp_list)); for (list = GIMP_LIST (gimp_list)->list, i = 0; list; list = g_list_next (list), i++) { const gchar *name; GimpObject *object; name = gimp_object_get_name (list->data); object = gimp_container_get_child_by_name (gimp->tool_info_list, name); if (object) { g_object_set (object, "visible", GIMP_TOOL_INFO (list->data)->visible, NULL); gimp_container_reorder (gimp->tool_info_list, object, MIN (i, n - 1)); } } } g_free (filename); g_object_unref (gimp_list); for (list = gimp_get_tool_info_iter (gimp); list; list = g_list_next (list)) { GimpToolInfo *tool_info = GIMP_TOOL_INFO (list->data); /* get default values from prefs (see bug #120832) */ gimp_tool_options_reset (tool_info->tool_options); } if (! gimp_contexts_load (gimp, &error)) { gimp_message_literal (gimp, NULL, GIMP_MESSAGE_WARNING, error->message); g_clear_error (&error); } for (list = gimp_get_tool_info_iter (gimp); list; list = g_list_next (list)) { GimpToolInfo *tool_info = GIMP_TOOL_INFO (list->data); GimpToolOptionsGUIFunc options_gui_func; GtkWidget *options_gui; /* copy all context properties except those the tool actually * uses, because the subsequent deserialize() on the tool * options will only set the properties that were set to * non-default values at the time of saving, and we want to * keep these default values as if they have been saved. * (see bug #541586). */ gimp_context_copy_properties (gimp_get_user_context (gimp), GIMP_CONTEXT (tool_info->tool_options), GIMP_CONTEXT_ALL_PROPS_MASK &~ (tool_info->context_props | GIMP_CONTEXT_TOOL_MASK | GIMP_CONTEXT_PAINT_INFO_MASK)); gimp_tool_options_deserialize (tool_info->tool_options, NULL); options_gui_func = g_object_get_data (G_OBJECT (tool_info), "gimp-tool-options-gui-func"); if (options_gui_func) { options_gui = (* options_gui_func) (tool_info->tool_options); } else { GtkWidget *label; options_gui = gimp_tool_options_gui (tool_info->tool_options); label = gtk_label_new (_("This tool has\nno options.")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_box_pack_start (GTK_BOX (options_gui), label, FALSE, FALSE, 6); gtk_widget_show (label); } gimp_tools_set_tool_options_gui (tool_info->tool_options, g_object_ref_sink (options_gui)); } }
/** * Show a dialog to set wether we want the rows/columns lines, * the background color, the titles... * * \param operation GtkPrintOperation responsible of this job. * \param null Not used. * * \return A newly allocated widget. */ GtkWidget * print_transactions_list_layout_config ( GtkPrintOperation * operation, gpointer null ) { GtkWidget *check_button; GtkWidget *label; GtkWidget *hbox; GtkWidget *entry; GtkWidget *font_button_transactions; GtkWidget *font_button_title; gchar *fontname_transactions; gchar *fontname_title; GtkWidget *init_date_entry; GtkWidget *final_date_entry; GtkWidget *vbox; GtkWidget *paddingbox; GtkSizeGroup * size_group; size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); vbox = gtk_vbox_new ( FALSE, 6 ); gtk_container_set_border_width ( GTK_CONTAINER(vbox), 12 ); paddingbox = new_paddingbox_with_title ( vbox, FALSE, _("Layout") ); /* set up the title and dates, this is never saved, so ask each time */ /* title line */ hbox = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (paddingbox), hbox, FALSE, FALSE, 0); entry = gsb_automem_entry_new (&title_string, NULL, NULL); check_button = gsb_autofunc_checkbutton_new (_("Print a title: "), gsb_data_print_config_get_draw_title (), G_CALLBACK (sens_desensitive_pointeur), entry, G_CALLBACK (gsb_data_print_config_set_draw_title), 0); gtk_box_pack_start (GTK_BOX (hbox), check_button, FALSE, FALSE, 0); gtk_widget_set_sensitive (entry, gsb_data_print_config_get_draw_title ()); gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0); /* add the dates interval */ hbox = gtk_hbox_new (FALSE, 10); check_button = gsb_autofunc_checkbutton_new (_("Select dates interval: "), gsb_data_print_config_get_draw_interval_dates (), G_CALLBACK (sens_desensitive_pointeur), hbox, G_CALLBACK (gsb_data_print_config_set_draw_interval_dates), 0); gtk_box_pack_start (GTK_BOX (paddingbox), check_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (paddingbox), hbox, FALSE, FALSE, 0); label = gtk_label_new (_("Initial date : ")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); init_date_entry = gsb_calendar_entry_new (FALSE); if (draw_initial_date) gsb_calendar_entry_set_date (init_date_entry, draw_initial_date); gtk_box_pack_start (GTK_BOX (hbox), init_date_entry, FALSE, FALSE, 0); label = gtk_label_new (_("Final date : ")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); final_date_entry = gsb_calendar_entry_new (FALSE); if (draw_final_date) gsb_calendar_entry_set_date (final_date_entry, draw_final_date); gtk_box_pack_start (GTK_BOX (hbox), final_date_entry, FALSE, FALSE, 0); g_object_set_data ( G_OBJECT ( operation ), "init_date_entry", init_date_entry ); g_object_set_data ( G_OBJECT ( operation ), "final_date_entry", final_date_entry ); check_button = gsb_autofunc_checkbutton_new (_("Use value date"), gsb_data_print_config_get_draw_dates_are_value_dates (), NULL, NULL, G_CALLBACK (gsb_data_print_config_set_draw_dates_are_value_dates), 0); gtk_box_pack_start (GTK_BOX (hbox), check_button, FALSE, FALSE, 0); if (!gsb_data_print_config_get_draw_interval_dates ()) gtk_widget_set_sensitive (hbox, FALSE); /* set up all the checkbuttons */ check_button = gsb_autofunc_checkbutton_new (_("Draw the lines between transactions"), gsb_data_print_config_get_draw_lines (), NULL, NULL, G_CALLBACK (gsb_data_print_config_set_draw_lines), 0); gtk_box_pack_start (GTK_BOX (paddingbox), check_button, FALSE, FALSE, 0); check_button = gsb_autofunc_checkbutton_new (_("Draw the lines between the columns"), gsb_data_print_config_get_draw_column (), NULL, NULL, G_CALLBACK (gsb_data_print_config_set_draw_column), 0); gtk_box_pack_start (GTK_BOX (paddingbox), check_button, FALSE, FALSE, 0); check_button = gsb_autofunc_checkbutton_new (_("Fill the background as the transactions list"), gsb_data_print_config_get_draw_background (), NULL, NULL, G_CALLBACK (gsb_data_print_config_set_draw_background), 0); gtk_box_pack_start (GTK_BOX (paddingbox), check_button, FALSE, FALSE, 0); check_button = gsb_autofunc_checkbutton_new (_("Print the archives lines"), gsb_data_print_config_get_draw_archives (), NULL, NULL, G_CALLBACK (gsb_data_print_config_set_draw_archives), 0); gtk_box_pack_start (GTK_BOX (paddingbox), check_button, FALSE, FALSE, 0); check_button = gsb_autofunc_checkbutton_new (_("Print the names of the columns"), gsb_data_print_config_get_draw_columns_name (), NULL, NULL, G_CALLBACK (gsb_data_print_config_set_draw_columns_name), 0); gtk_box_pack_start (GTK_BOX (paddingbox), check_button, FALSE, FALSE, 0); paddingbox = new_paddingbox_with_title ( vbox, FALSE, _("Fonts") ); /* set up the font of the transactions, * by default use the font of the lists */ hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (paddingbox), hbox, FALSE, FALSE, 0); label = gtk_label_new (_("Transactions font")); gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT ); gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 0.5); gtk_size_group_add_widget ( size_group, label ); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); fontname_transactions = pango_font_description_to_string (gsb_data_print_config_get_font_transactions ()); font_button_transactions = gtk_font_button_new_with_font ( fontname_transactions ); gtk_font_button_set_use_font ( GTK_FONT_BUTTON(font_button_transactions), TRUE ); gtk_font_button_set_use_size ( GTK_FONT_BUTTON(font_button_transactions), TRUE ); gtk_font_button_set_title ( GTK_FONT_BUTTON(font_button_transactions), _("Choosing font") ); gtk_box_pack_start (GTK_BOX (hbox), font_button_transactions, TRUE, TRUE, 0); /* set up the font for the title */ hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (paddingbox), hbox, FALSE, FALSE, 0); label = gtk_label_new (_("Title font")); gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT ); gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 0.5); gtk_size_group_add_widget ( size_group, label ); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); fontname_title = pango_font_description_to_string (gsb_data_print_config_get_font_title ()); font_button_title = gtk_font_button_new_with_font ( fontname_title ); gtk_font_button_set_use_font ( GTK_FONT_BUTTON(font_button_title), TRUE ); gtk_font_button_set_use_size ( GTK_FONT_BUTTON(font_button_title), TRUE ); gtk_font_button_set_title ( GTK_FONT_BUTTON(font_button_title), _("Choosing font") ); gtk_box_pack_start (GTK_BOX (hbox), font_button_title, TRUE, TRUE, 0); /* save what we have done in all cases, so if we cancel and come back, our values * come back */ gsb_data_print_config_set_font_transaction (pango_font_description_from_string (fontname_transactions)); gsb_data_print_config_set_font_title (pango_font_description_from_string (fontname_title)); draw_initial_date = gsb_calendar_entry_get_date (init_date_entry); draw_final_date = gsb_calendar_entry_get_date (final_date_entry); g_object_set_data ( G_OBJECT(operation), "font_transaction_button", font_button_transactions ); g_object_set_data ( G_OBJECT(operation), "font_title_button", font_button_title ); gtk_widget_show_all ( vbox ); return vbox; }
GtkWidget *pref_start_grep() { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkObject *adj; GtkWidget *table; GtkAttachOptions xoption=0, yoption=0; LOG(LOG_DEBUG, "IN : pref_start_grep()"); vbox = gtk_vbox_new(FALSE,10); gtk_widget_set_size_request(vbox, 300, 200); xoption = GTK_SHRINK|GTK_FILL; yoption = GTK_SHRINK; table = gtk_table_new(3, 4, FALSE); gtk_box_pack_start (GTK_BOX(vbox) , table,FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE,10); gtk_container_set_border_width(GTK_CONTAINER(hbox), 2); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 1, 2, xoption, yoption, 10, 10); label = gtk_label_new(_("Additional Lines To Display")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); adj = gtk_adjustment_new( 5, //value 0, // lower 1000, //upper 1, // step increment 10,// page_increment, 0.0); spin_additional_line = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_additional_line), additional_lines); gtk_widget_set_size_request(spin_additional_line,60,20); gtk_table_attach(GTK_TABLE(table), spin_additional_line, 1, 2, 1, 2, xoption, yoption, 10, 10); gtk_widget_set_tooltip_text(spin_additional_line, _("In addition to matched line, additional lines will be shown in contents.")); hbox = gtk_hbox_new(FALSE,10); gtk_container_set_border_width(GTK_CONTAINER(hbox), 2); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 2, 3, xoption, yoption, 10, 10); label = gtk_label_new(_("Additional Chars To Display")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); adj = gtk_adjustment_new( 16, //value 1, // lower 100, //upper 1, // step increment 10,// page_increment, 0.0); spin_additional_char = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_additional_char), additional_chars); gtk_widget_set_size_request(spin_additional_char,60,20); gtk_table_attach(GTK_TABLE(table), spin_additional_char, 1, 2, 2, 3, xoption, yoption, 10, 10); gtk_widget_set_tooltip_text(spin_additional_char, _("When matched line is too long, several characters around keyword will be shown in heading.")); LOG(LOG_DEBUG, "OUT : pref_start_grep()"); return(vbox); }
bool wxStaticText::Create(wxWindow *parent, wxWindowID id, const wxString &label, const wxPoint &pos, const wxSize &size, long style, const wxString &name ) { m_needParent = TRUE; if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxStaticText creation failed") ); return FALSE; } // notice that we call the base class version which will just remove the // '&' characters from the string, but not set the label's text to it // because the label is not yet created and because SetLabel() has a side // effect of changing the control size which might not be desirable wxControl::SetLabel(label); m_widget = gtk_label_new( wxGTK_CONV( m_label ) ); GtkJustification justify; if ( style & wxALIGN_CENTER ) justify = GTK_JUSTIFY_CENTER; else if ( style & wxALIGN_RIGHT ) justify = GTK_JUSTIFY_RIGHT; else // wxALIGN_LEFT is 0 justify = GTK_JUSTIFY_LEFT; gtk_label_set_justify(GTK_LABEL(m_widget), justify); // GTK_JUSTIFY_LEFT is 0, RIGHT 1 and CENTER 2 static const float labelAlignments[] = { 0.0, 1.0, 0.5 }; gtk_misc_set_alignment(GTK_MISC(m_widget), labelAlignments[justify], 0.0); gtk_label_set_line_wrap( GTK_LABEL(m_widget), TRUE ); m_parent->DoAddChild( this ); PostCreation(size); // the bug below only happens with GTK 2 #ifdef __WXGTK20__ if ( justify != GTK_JUSTIFY_LEFT ) { // if we let GTK call wxgtk_window_size_request_callback the label // always shrinks to its minimal size for some reason and so no // alignment except the default left doesn't work (in fact it does, // but you don't see it) gtk_signal_disconnect_by_func ( GTK_OBJECT(m_widget), GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback), (gpointer) this ); } #endif // __WXGTK20__ return TRUE; }
/** * Creates the "Titles & Addresses" tab. This tab is mainly composed * of text entries and editables. * * \returns A newly allocated vbox */ GtkWidget *onglet_display_addresses ( void ) { GtkWidget *hbox, *vbox_pref, *scrolled_window, *label; GtkWidget *paddingbox; GtkWidget *entry; GtkWidget *radio, *radiogroup; vbox_pref = new_vbox_with_title_and_icon ( _("Addresses & titles"), "addresses.png" ); /* Account file title */ paddingbox = new_paddingbox_with_title ( vbox_pref, FALSE, _("Titles") ); /* It first creates the entry of title */ entry = gsb_automem_entry_new ( &titre_fichier, ( GCallback ) update_homepage_title, NULL ); /* Choice of title type */ hbox = gtk_hbox_new ( FALSE, 6 ); gtk_box_pack_start ( GTK_BOX ( paddingbox ), hbox, FALSE, FALSE, 0); radiogroup = gtk_radio_button_new_with_label ( NULL, _("Accounts file title") ); g_object_set_data ( G_OBJECT ( radiogroup ), "display", GINT_TO_POINTER ( GSB_ACCOUNTS_TITLE ) ); if ( conf.display_grisbi_title == GSB_ACCOUNTS_TITLE ) gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( radiogroup ), TRUE ); g_signal_connect ( G_OBJECT ( radiogroup ), "toggled", G_CALLBACK ( change_grisbi_title_type ), entry ); gtk_box_pack_start ( GTK_BOX( hbox ), radiogroup, FALSE, FALSE, 0 ); radio = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON ( radiogroup ), _("Account owner name") ); g_object_set_data ( G_OBJECT ( radio ), "display", GINT_TO_POINTER ( GSB_ACCOUNT_HOLDER ) ); if ( conf.display_grisbi_title == GSB_ACCOUNT_HOLDER ) gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( radio ), TRUE ); g_signal_connect ( G_OBJECT ( radio ), "toggled", G_CALLBACK ( change_grisbi_title_type ), entry ); gtk_box_pack_start ( GTK_BOX( hbox ), radio, FALSE, FALSE, 0 ); radio = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON ( radiogroup ), _("Filename") ); g_object_set_data ( G_OBJECT ( radio ), "display", GINT_TO_POINTER ( GSB_ACCOUNTS_FILE ) ); if ( conf.display_grisbi_title == GSB_ACCOUNTS_FILE ) gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( radio ), TRUE ); g_signal_connect ( G_OBJECT ( radio ), "toggled", G_CALLBACK ( change_grisbi_title_type ), entry ); gtk_box_pack_start ( GTK_BOX( hbox ), radio, FALSE, FALSE, 0 ); hbox = gtk_hbox_new ( FALSE, 6 ); gtk_box_pack_start ( GTK_BOX ( paddingbox ), hbox, FALSE, FALSE, 0); label = gtk_label_new ( _("Accounts file title: ") ); gtk_box_pack_start ( GTK_BOX ( hbox ), label, FALSE, FALSE, 0); if ( conf.display_grisbi_title == GSB_ACCOUNTS_TITLE ) gtk_widget_set_sensitive ( entry, TRUE); else gtk_widget_set_sensitive ( entry, FALSE); gtk_box_pack_start ( GTK_BOX ( hbox ), entry, TRUE, TRUE, 0); /* Addresses */ paddingbox = new_paddingbox_with_title ( vbox_pref, FALSE, _("Addresses") ); /* Common address */ label = gtk_label_new ( _("Common address: ") ); gtk_misc_set_alignment (GTK_MISC (label), 0, 1); gtk_label_set_justify ( GTK_LABEL(label), GTK_JUSTIFY_RIGHT ); gtk_box_pack_start ( GTK_BOX ( paddingbox ), label, TRUE, TRUE, 0); scrolled_window = gtk_scrolled_window_new ( NULL, NULL ); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW ( scrolled_window ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_box_pack_start ( GTK_BOX ( paddingbox ), scrolled_window, FALSE, FALSE, 0); gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_IN ); entry = gsb_automem_textview_new ( &adresse_commune, NULL, NULL ); gtk_container_add ( GTK_CONTAINER ( scrolled_window ), entry ); /* Secondary address */ /** \note This is not implemented yet */ label = gtk_label_new ( _("Secondary address: ") ); gtk_misc_set_alignment (GTK_MISC (label), 0, 1); gtk_label_set_justify ( GTK_LABEL(label), GTK_JUSTIFY_RIGHT ); gtk_box_pack_start ( GTK_BOX ( paddingbox ), label, TRUE, TRUE, 0); scrolled_window = gtk_scrolled_window_new ( NULL, NULL ); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW ( scrolled_window ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_IN ); gtk_box_pack_start ( GTK_BOX ( paddingbox ), scrolled_window, FALSE, FALSE, 0); entry = gsb_automem_textview_new ( &adresse_secondaire, NULL, NULL ); gtk_container_add ( GTK_CONTAINER ( scrolled_window ), entry ); if ( !gsb_data_account_get_accounts_amount () ) gtk_widget_set_sensitive ( vbox_pref, FALSE ); return ( vbox_pref ); }
/* Public VpnPasswordDialog methods */ GtkWidget * vpn_password_dialog_new (const char *title, const char *message, const char *password) { GtkWidget *dialog; VpnPasswordDialogPrivate *priv; GtkLabel *message_label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *main_vbox; GtkWidget *dialog_icon; GtkBox *content, *action_area; dialog = gtk_widget_new (VPN_TYPE_PASSWORD_DIALOG, NULL); if (!dialog) return NULL; priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog); gtk_window_set_title (GTK_WINDOW (dialog), title); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_dialog_add_buttons (GTK_DIALOG (dialog), _("_Cancel"), GTK_RESPONSE_CANCEL, _("_OK"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); content = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))); action_area = GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))); /* Setup the dialog */ #if !GTK_CHECK_VERSION (2,22,0) gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); #endif gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (content, 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width (GTK_CONTAINER (action_area), 5); gtk_box_set_spacing (action_area, 6); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); g_signal_connect (dialog, "show", G_CALLBACK (dialog_show_callback), dialog); g_signal_connect (dialog, "close", G_CALLBACK (dialog_close_callback), dialog); /* The table that holds the captions */ priv->table_alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->table = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (priv->table), 12); gtk_grid_set_row_spacing (GTK_GRID (priv->table), 6); gtk_container_add (GTK_CONTAINER (priv->table_alignment), priv->table); priv->password_entry = gtk_entry_new (); priv->password_entry_secondary = gtk_entry_new (); priv->show_passwords_checkbox = gtk_check_button_new_with_mnemonic (_("Sh_ow passwords")); /* We want to hold on to these during the table rearrangement */ g_object_ref_sink (priv->password_entry); g_object_ref_sink (priv->password_entry_secondary); g_object_ref_sink (priv->show_passwords_checkbox); gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), FALSE); gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry_secondary), FALSE); g_signal_connect_swapped (priv->password_entry, "activate", G_CALLBACK (gtk_window_activate_default), dialog); g_signal_connect_swapped (priv->password_entry_secondary, "activate", G_CALLBACK (gtk_window_activate_default), dialog); g_signal_connect (priv->show_passwords_checkbox, "toggled", G_CALLBACK (show_passwords_toggled_cb), dialog); add_table_rows (VPN_PASSWORD_DIALOG (dialog)); /* Adds some eye-candy to the dialog */ #if GTK_CHECK_VERSION (3,1,6) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); #else hbox = gtk_hbox_new (FALSE, 12); #endif gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); dialog_icon = gtk_image_new_from_icon_name (_("dialog-password"), GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (dialog_icon), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), dialog_icon, FALSE, FALSE, 0); /* Fills the vbox */ #if GTK_CHECK_VERSION (3,1,6) main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); #else main_vbox = gtk_vbox_new (FALSE, 18); #endif if (message) { message_label = GTK_LABEL (gtk_label_new (message)); gtk_label_set_justify (message_label, GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (message_label, TRUE); gtk_label_set_max_width_chars (message_label, 35); gtk_size_group_add_widget (priv->group, GTK_WIDGET (message_label)); gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label), FALSE, FALSE, 0); gtk_size_group_add_widget (priv->group, priv->table_alignment); } #if GTK_CHECK_VERSION (3,1,6) vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else vbox = gtk_vbox_new (FALSE, 6); #endif gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), priv->table_alignment, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0); gtk_box_pack_start (content, hbox, FALSE, FALSE, 0); gtk_widget_show_all (GTK_WIDGET (content)); vpn_password_dialog_set_password (VPN_PASSWORD_DIALOG (dialog), password); return GTK_WIDGET (dialog); }
static gboolean fontsel_directories_dialog (GtkWidget *parent, const gchar *message, gchar **path) { GtkWidget *dialog; GtkWidget *path_editor; GtkWidget *label; gchar *new_path = NULL; dialog = gimp_dialog_new (_("Configure Font Search Path"), "font-path", parent, GTK_DIALOG_DESTROY_WITH_PARENT, gimp_standard_help_func, "plug-in-freetype", GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); if (message) { label = gtk_label_new (message); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_misc_set_padding (GTK_MISC (label), 12, 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, FALSE, FALSE, 0); } path_editor = gimp_path_editor_new (_("Choose a folder"), *path); gtk_container_set_border_width (GTK_CONTAINER (path_editor), 12); gtk_widget_set_usize (GTK_WIDGET (path_editor), -1, 240); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), path_editor, TRUE, TRUE, 0); label = gtk_label_new (_("You may specify multiple folders here.")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_misc_set_padding (GTK_MISC (label), 12, 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, FALSE, FALSE, 0); gtk_widget_show_all (dialog); if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK) new_path = gimp_path_editor_get_path (GIMP_PATH_EDITOR (path_editor)); gtk_widget_destroy (dialog); if (new_path && (!*path || strcmp (*path, new_path) != 0 || strcmp (*path, DEFAULT_FONTPATH) == 0)) { g_free (*path); *path = new_path; gimp_gimprc_set (FONTPATH_TOKEN, *path); return TRUE; } return FALSE; }
static GtkWidget *create_dialog(void) { GtkWidget *dialog; GtkWidget *header_image; GtkWidget *header_label; GtkWidget *label_info; GtkWidget *codename_label; GtkWidget *builddate_label; GtkWidget *url_button; GtkWidget *cop_label; GtkWidget *label; GtkWidget *license_textview; GtkWidget *notebook; GtkWidget *box; GtkWidget *credits_scrollwin; GtkWidget *table; GtkWidget *license_scrollwin; GtkWidget *info_box; GtkWidget *header_hbox; GtkWidget *header_eventbox; GdkPixbuf *icon; GtkTextBuffer* tb; gchar *license_text = NULL; gchar buffer[512]; gchar buffer2[128]; guint i, row = 0; dialog = gtk_dialog_new(); /* configure dialog */ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window)); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany")); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL); /* create header */ header_eventbox = gtk_event_box_new(); gtk_widget_show(header_eventbox); header_hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4); gtk_widget_show(header_hbox); gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox); header_image = gtk_image_new(); gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0); header_label = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE); /* print the subversion revision generated by ./configure if it is available */ g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string()); gtk_label_set_markup(GTK_LABEL(header_label), buffer); gtk_widget_show(header_label); gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0); header_eventbox_style_set(header_eventbox); header_label_style_set(header_label); g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL); g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0); /* set image */ icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO); gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon); gtk_window_set_icon(GTK_WINDOW(dialog), icon); g_object_unref(icon); /* free our reference */ /* create notebook */ notebook = gtk_notebook_new(); gtk_widget_show(notebook); gtk_container_set_border_width(GTK_CONTAINER(notebook), 2); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0); /* create "Info" tab */ info_box = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(info_box), 6); gtk_widget_show(info_box); label_info = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(label_info), TRUE); gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE); g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE")); gtk_label_set_markup(GTK_LABEL(label_info), buffer); gtk_misc_set_padding(GTK_MISC(label_info), 2, 11); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0); /* Codename label */ codename_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE); gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME); gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8); gtk_widget_show(codename_label); gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0); /* build date label */ builddate_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE); g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__); g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2); gtk_label_set_markup(GTK_LABEL(builddate_label), buffer); gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2); gtk_widget_show(builddate_label); gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0); box = gtk_hbutton_box_new(); url_button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE); g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE); label = gtk_label_new(NULL); gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE); gtk_widget_show(label); gtk_container_add(GTK_CONTAINER(url_button), label); gtk_widget_show(url_button); gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0); gtk_widget_show(box); gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10); /* copyright label */ cop_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE); gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE); gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT); gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10); gtk_widget_show(cop_label); gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0); /*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */ label = gtk_label_new(_("Info")); gtk_widget_show(label); gtk_widget_show_all(info_box); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label); /* create "Credits" tab */ credits_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 10); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 10); row = 0; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < translators_len; i++) { ROW(translators[i][0], row, 0, 1, 4, 0); ROW(translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < prev_translators_len; i++) { ROW(prev_translators[i][0], row, 0, 1, 4, 0); ROW(prev_translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; g_snprintf(buffer, sizeof(buffer), _("Some of the many contributors (for a more detailed list, see the file %s):"), #ifdef G_OS_WIN32 "Thanks.txt" #else "THANKS" #endif ); label = geany_wrap_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; label = geany_wrap_label_new(contributors); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE); gtk_widget_show_all(table); label = gtk_label_new(_("Credits")); gtk_widget_show(label); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label); /* create "License" tab */ license_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); license_textview = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE); gtk_widget_show(license_textview); gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview); label = gtk_label_new(_("License")); gtk_widget_show(label); g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir); g_file_get_contents(buffer, &license_text, NULL, NULL); if (license_text == NULL) { license_text = g_strdup( _("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online.")); } tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview)); gtk_text_buffer_set_text(tb, license_text, -1); g_free(license_text); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label); gtk_widget_show_all(dialog); return dialog; }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ void gb_label_set_standard_properties (GtkWidget * widget, GbWidgetSetArgData * data, const char *label_p, const char *use_underline_p, const char *use_markup_p, const char *justify_p, const char *wrap_p, const char *selectable_p, const char *xalign_p, const char *yalign_p, const char *xpad_p, const char *ypad_p, const char *focus_target_p) { gchar *label, *justify, *accel_target; const gchar *label_text; gfloat xalign, yalign; gint xpad, ypad, i; gboolean wrap, selectable, set_alignment = FALSE, set_padding = FALSE; gboolean use_underline, use_markup; gboolean set_label = FALSE; use_underline = gb_widget_input_bool (data, use_underline_p); if (data->apply) gtk_label_set_use_underline (GTK_LABEL (widget), use_underline); use_markup = gb_widget_input_bool (data, use_markup_p); if (data->apply) { set_label = TRUE; gtk_object_set_data (GTK_OBJECT (widget), use_markup_p, GINT_TO_POINTER (use_markup)); } label = gb_widget_input_text (data, label_p); if (data->apply) { set_label = TRUE; label_text = label; } else { label_text = gtk_label_get_label (GTK_LABEL (widget)); } if (set_label) { gboolean prev_use_markup; use_markup = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), use_markup_p)); /* We try to parse the markup here, and if it isn't valid, we will turn use_markup off and show it as plain text. */ if (use_markup) { GError *error = NULL; gunichar accel_marker = 0; PangoAttrList *attrs = NULL; gunichar accel_char = 0; gchar *text = NULL; if (gtk_label_get_use_underline (GTK_LABEL (widget))) accel_marker = '_'; /* We check it is valid markup. If it isn't we will set "use_markup" to FALSE. Note that we don't need attrs, text, or accel_char but it seems to crash otherwise. */ if (!pango_parse_markup (label_text, -1, accel_marker, &attrs, &text, &accel_char, &error)) { use_markup = FALSE; g_error_free (error); } else { if (attrs) pango_attr_list_unref (attrs); g_free (text); } } /* If we are turning use_markup off, we want to do that before setting the text. If we are turning it on, we want to do it after. */ prev_use_markup = gtk_label_get_use_markup (GTK_LABEL (widget)); if (!use_markup && prev_use_markup) gtk_label_set_use_markup (GTK_LABEL (widget), use_markup); gtk_label_set_label (GTK_LABEL (widget), label_text); if (use_markup && !prev_use_markup) gtk_label_set_use_markup (GTK_LABEL (widget), use_markup); } if (data->action == GB_APPLYING) g_free (label); justify = gb_widget_input_choice (data, justify_p); if (data->apply) { for (i = 0; i < sizeof (GbJustifyValues) / sizeof (GbJustifyValues[0]); i++) { if (!strcmp (justify, GbJustifyChoices[i]) || !strcmp (justify, GbJustifySymbols[i])) { gtk_label_set_justify (GTK_LABEL (widget), GbJustifyValues[i]); break; } } } wrap = gb_widget_input_bool (data, wrap_p); if (data->apply) gtk_label_set_line_wrap (GTK_LABEL (widget), wrap); selectable = gb_widget_input_bool (data, selectable_p); if (data->apply) gtk_label_set_selectable (GTK_LABEL (widget), selectable); xalign = gb_widget_input_float (data, xalign_p); if (data->apply) set_alignment = TRUE; else xalign = GTK_MISC (widget)->xalign; yalign = gb_widget_input_float (data, yalign_p); if (data->apply) set_alignment = TRUE; else yalign = GTK_MISC (widget)->yalign; if (set_alignment) gtk_misc_set_alignment (GTK_MISC (widget), xalign, yalign); xpad = gb_widget_input_int (data, xpad_p); if (data->apply) set_padding = TRUE; else xpad = GTK_MISC (widget)->xpad; ypad = gb_widget_input_int (data, ypad_p); if (data->apply) set_padding = TRUE; else ypad = GTK_MISC (widget)->ypad; if (set_padding) gtk_misc_set_padding (GTK_MISC (widget), xpad, ypad); /* Labels not in buttons may have a focus target widget. */ accel_target = gb_widget_input_combo (data, focus_target_p); if (data->apply) { if (!gb_label_find_mnemonic_widget (widget)) { if (!strcmp (accel_target, _("Auto"))) accel_target = NULL; gtk_object_set_data_full (GTK_OBJECT (widget), focus_target_p, g_strdup (accel_target), accel_target ? g_free : NULL); } } }
GtkWidget * create_main_window(void) { GtkWidget *notebook1; GtkWidget *frame3; GtkWidget *frame4; GtkWidget *hbox1; GtkWidget *vbox1; GtkWidget *scrolledwindow1; GtkWidget *node_label1; GtkWidget *node_label2; GtkWidget *node_label3; GtkWidget *node_label4; GtkWidget *node_label7; GtkWidget *node_label8; GtkWidget *node_label9; GtkWidget *mid_frame; GtkWidget *mpr_frame; GtkWidget *hna_frame; GtkWidget *mid_scrolledwindow; GtkWidget *mpr_scrolledwindow; GtkWidget *hna_scrolledwindow; GtkWidget *Main; GtkWidget *label_routes; GtkWidget *hbox2; GtkWidget *frame2; GtkWidget *scrolledwindow4; GtkWidget *label17; GtkWidget *label18; GtkWidget *label19; GtkWidget *scrolledwindow3; GtkWidget *label13; GtkWidget *label14; GtkWidget *label15; GtkWidget *label16; GtkWidget *label_packets; //GtkWidget *empty_notebook_page2; GtkWidget *label3; GtkWidget *net_vbox; GtkWidget *pack_vbox; GtkWidget *pack_disp_vbox; GtkWidget *disp_frame; GtkWidget *route_frame; GtkWidget *route_stats_frame; GtkWidget *route_scrolledwindow; GtkWidget *route_label1; GtkWidget *route_label2; GtkWidget *route_label3; GtkWidget *route_label4; GtkWidget *route_hbox1; GtkWidget *traffic_label; GtkWidget *settings_label; GtkWidget *settings_hbox1; GtkWidget *about_hbox1; GtkWidget *about_label; GtkWidget *empty1; GdkPixmap *unik_logo_gdk; GtkWidget *unik_logo; /* *The main window */ main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_object_set_data(GTK_OBJECT(main_window), "main_window", main_window); gtk_window_set_title(GTK_WINDOW(main_window), (olsrd_version)); gtk_window_set_default_size(GTK_WINDOW(main_window), 600, 550); gtk_signal_connect(GTK_OBJECT(main_window), "destroy", GTK_SIGNAL_FUNC(gui_shutdown), //GTK_SIGNAL_FUNC(gtk_main_quit), NULL); gtk_window_set_position(GTK_WINDOW(main_window), GTK_WIN_POS_CENTER); /* Position window in center */ gtk_window_set_policy(GTK_WINDOW(main_window), FALSE, TRUE, TRUE); /* No user-resizing */ /* *Initialize the pixmaps */ unik_logo_gdk = gdk_pixmap_colormap_create_from_xpm_d(NULL, gtk_widget_get_colormap(main_window), &mask, NULL, (gchar **) logo_xpm); unik_logo = gtk_pixmap_new(unik_logo_gdk, mask); /* *The notebook */ notebook1 = gtk_notebook_new(); gtk_widget_ref(notebook1); gtk_object_set_data_full(GTK_OBJECT(main_window), "notebook1", notebook1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(notebook1); gtk_container_add(GTK_CONTAINER(main_window), notebook1); /* *The first vbox */ vbox1 = gtk_vbox_new(FALSE, 0); gtk_widget_ref(vbox1); gtk_object_set_data_full(GTK_OBJECT(main_window), "vbox1", vbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(vbox1); //gtk_box_pack_start (GTK_BOX (hbox1), vbox1, TRUE, TRUE, 1); gtk_container_add(GTK_CONTAINER(notebook1), vbox1); /* *The nodes frame */ frame3 = gtk_frame_new("Registered nodes:"); gtk_widget_ref(frame3); gtk_object_set_data_full(GTK_OBJECT(main_window), "frame3", frame3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(frame3); gtk_box_pack_start(GTK_BOX(vbox1), frame3, TRUE, TRUE, 0); gtk_widget_set_size_request(frame3, -1, 300); gtk_container_set_border_width(GTK_CONTAINER(frame3), 1); /* *The scrolled window to contain the node list */ scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_ref(scrolledwindow1); gtk_object_set_data_full(GTK_OBJECT(main_window), "scrolledwindow1", scrolledwindow1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(scrolledwindow1); gtk_container_add(GTK_CONTAINER(frame3), scrolledwindow1); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); //gtk_box_pack_start (GTK_BOX (frame3), scrolledwindow1, TRUE, TRUE, 0); //gtk_widget_set_usize (scrolledwindow1, -2, 332); /* *The node list */ node_list = gtk_clist_new(7); gtk_widget_ref(node_list); gtk_object_set_data_full(GTK_OBJECT(main_window), "node_list", node_list, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(node_list); gtk_container_add(GTK_CONTAINER(scrolledwindow1), node_list); gtk_clist_set_column_width(GTK_CLIST(node_list), 0, 150); /* IP */ //gtk_clist_set_column_justification(GTK_CLIST(node_list), 0, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(node_list), 1, 150); /* gateway */ //gtk_clist_set_column_justification(GTK_CLIST(node_list), 1, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(node_list), 2, 50); /* hopcount */ gtk_clist_set_column_justification(GTK_CLIST(node_list), 2, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(node_list), 3, 80); /* dev */ gtk_clist_set_column_justification(GTK_CLIST(node_list), 3, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(node_list), 4, 70); /* timer */ gtk_clist_set_column_justification(GTK_CLIST(node_list), 4, GTK_JUSTIFY_CENTER); //gtk_clist_set_column_width (GTK_CLIST (node_list), 7, 100); /* last about */ //gtk_clist_set_column_justification(GTK_CLIST(node_list), 7, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(node_list), 5, 40); /* MID */ gtk_clist_set_column_justification(GTK_CLIST(node_list), 5, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(node_list), 6, 40); /* HNA */ gtk_clist_set_column_justification(GTK_CLIST(node_list), 6, GTK_JUSTIFY_CENTER); gtk_clist_column_titles_show(GTK_CLIST(node_list)); /* *Row selection callback */ gtk_signal_connect(GTK_OBJECT(node_list), "select_row", GTK_SIGNAL_FUNC(selection_made), NULL); /* *Column selection callback */ gtk_signal_connect(GTK_OBJECT(node_list), "click_column", GTK_SIGNAL_FUNC(column_clicked_callback), NULL); node_label1 = gtk_label_new("Dest"); gtk_widget_ref(node_label1); gtk_object_set_data_full(GTK_OBJECT(main_window), "IP", node_label1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(node_label1); gtk_clist_set_column_widget(GTK_CLIST(node_list), 0, node_label1); node_label2 = gtk_label_new("Gateway"); gtk_widget_ref(node_label2); gtk_object_set_data_full(GTK_OBJECT(main_window), "hops", node_label2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(node_label2); gtk_clist_set_column_widget(GTK_CLIST(node_list), 1, node_label2); node_label3 = gtk_label_new("Metric"); gtk_widget_ref(node_label3); gtk_object_set_data_full(GTK_OBJECT(main_window), "info", node_label3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(node_label3); gtk_clist_set_column_widget(GTK_CLIST(node_list), 2, node_label3); node_label4 = gtk_label_new("Device"); gtk_widget_ref(node_label4); gtk_object_set_data_full(GTK_OBJECT(main_window), "Device", node_label4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(node_label4); gtk_clist_set_column_widget(GTK_CLIST(node_list), 3, node_label4); node_label7 = gtk_label_new("Timer"); gtk_widget_ref(node_label7); gtk_object_set_data_full(GTK_OBJECT(main_window), "LMF", node_label7, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(node_label7); gtk_clist_set_column_widget(GTK_CLIST(node_list), 4, node_label7); /* node_label8 = gtk_label_new ("LMA"); gtk_widget_ref (node_label8); gtk_object_set_data_full (GTK_OBJECT (main_window), "LMA", node_label8, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (node_label8); gtk_clist_set_column_widget (GTK_CLIST (node_list), 7, node_label8); */ node_label8 = gtk_label_new("MID"); gtk_widget_ref(node_label8); gtk_object_set_data_full(GTK_OBJECT(main_window), "MID", node_label8, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(node_label8); gtk_clist_set_column_widget(GTK_CLIST(node_list), 5, node_label8); node_label9 = gtk_label_new("HNA"); gtk_widget_ref(node_label9); gtk_object_set_data_full(GTK_OBJECT(main_window), "HNA", node_label9, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(node_label9); gtk_clist_set_column_widget(GTK_CLIST(node_list), 6, node_label9); gtk_clist_column_titles_active(GTK_CLIST(node_list)); gtk_widget_show_now(node_list); /* *Row selection callback */ gtk_signal_connect(GTK_OBJECT(node_list), "select_row", GTK_SIGNAL_FUNC(node_selection), NULL); /* *The first hbox */ hbox1 = gtk_hbox_new(FALSE, 0); gtk_widget_ref(hbox1); gtk_object_set_data_full(GTK_OBJECT(main_window), "hbox1", hbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, FALSE, 0); //gtk_container_add (GTK_CONTAINER (notebook1), hbox1); gtk_container_set_border_width(GTK_CONTAINER(hbox1), 4); gtk_widget_set_size_request(hbox1, -1, 200); /* *The net-info frame */ frame4 = gtk_frame_new("Info:"); gtk_widget_ref(frame4); gtk_object_set_data_full(GTK_OBJECT(main_window), "frame4", frame4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(frame4); gtk_box_pack_start(GTK_BOX(hbox1), frame4, TRUE, TRUE, 0); //gtk_widget_set_size_request(frame4, 200, -1); gtk_container_set_border_width(GTK_CONTAINER(frame4), 1); /* *The net-info hbox */ net_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_ref(net_vbox); gtk_object_set_data_full(GTK_OBJECT(main_window), "net_vbox", net_vbox, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(net_vbox); gtk_container_add(GTK_CONTAINER(frame4), net_vbox); /* *The net-info label field */ net_label = gtk_label_new(NULL); gtk_widget_ref(net_label); gtk_misc_set_alignment((GtkMisc *) net_label, 0, 0); //gtk_label_set_justify((GtkLabel *)net_label,GTK_JUSTIFY_LEFT); gtk_object_set_data_full(GTK_OBJECT(main_window), "net_label", net_label, (GtkDestroyNotify) gtk_widget_unref); //set_net_info("Not connected..."); gtk_widget_show(net_label); gtk_box_pack_start(GTK_BOX(net_vbox), net_label, TRUE, TRUE, 0); //gtk_container_add (GTK_CONTAINER (frame4), net_label); /* *The connect button */ connect_button = gtk_button_new_with_label("Connect to host"); gtk_widget_ref(connect_button); gtk_object_set_data_full(GTK_OBJECT(main_window), "connect_button", connect_button, (GtkDestroyNotify) gtk_widget_unref); /* Connect the "clicked" signal of the button to our callback */ gtk_signal_connect(GTK_OBJECT(connect_button), "clicked", GTK_SIGNAL_FUNC(connect_callback), NULL); gtk_widget_show(connect_button); gtk_box_pack_start(GTK_BOX(net_vbox), connect_button, FALSE, FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(connect_button), 5); /* *The node MPR info frame */ mpr_frame = gtk_frame_new("MPR:"); gtk_widget_ref(mpr_frame); gtk_object_set_data_full(GTK_OBJECT(main_window), "mpr_frame", mpr_frame, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(mpr_frame); gtk_box_pack_start(GTK_BOX(hbox1), mpr_frame, FALSE, FALSE, 0); //gtk_widget_set_size_request(mid_frame, 125, -1); gtk_container_set_border_width(GTK_CONTAINER(mpr_frame), 1); /* *The scrolledwindow to contain the MPR node info */ mpr_scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_ref(mpr_scrolledwindow); gtk_object_set_data_full(GTK_OBJECT(main_window), "mpr_scrolledwindow", mpr_scrolledwindow, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(mpr_scrolledwindow); gtk_container_add(GTK_CONTAINER(mpr_frame), mpr_scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(mpr_scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_set_border_width(GTK_CONTAINER(mpr_scrolledwindow), 3); /* *The node MID info frame */ mid_frame = gtk_frame_new("MID:"); gtk_widget_ref(mid_frame); gtk_object_set_data_full(GTK_OBJECT(main_window), "mid_frame", mid_frame, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(mid_frame); gtk_box_pack_start(GTK_BOX(hbox1), mid_frame, FALSE, FALSE, 0); //gtk_widget_set_size_request(mid_frame, 125, -1); gtk_container_set_border_width(GTK_CONTAINER(mid_frame), 1); /* *The scrolledwindow to contain the MID node info */ mid_scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_ref(mid_scrolledwindow); gtk_object_set_data_full(GTK_OBJECT(main_window), "mid_scrolledwindow", mid_scrolledwindow, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(mid_scrolledwindow); gtk_container_add(GTK_CONTAINER(mid_frame), mid_scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(mid_scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_set_border_width(GTK_CONTAINER(mid_scrolledwindow), 3); /* *The MPR list */ mpr_list = gtk_clist_new(1); gtk_widget_ref(mpr_list); gtk_object_set_data_full(GTK_OBJECT(main_window), "mpr_list", mpr_list, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(mpr_list); gtk_container_add(GTK_CONTAINER(mpr_scrolledwindow), mpr_list); gtk_clist_set_column_width(GTK_CLIST(mpr_list), 0, 120); /* IP */ gtk_clist_column_titles_hide(GTK_CLIST(mpr_list)); /* *The MID list */ mid_list = gtk_clist_new(1); gtk_widget_ref(mid_list); gtk_object_set_data_full(GTK_OBJECT(main_window), "mid_list", mid_list, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(mid_list); gtk_container_add(GTK_CONTAINER(mid_scrolledwindow), mid_list); gtk_clist_set_column_width(GTK_CLIST(mid_list), 0, 120); /* IP */ gtk_clist_column_titles_hide(GTK_CLIST(mid_list)); /* *The node HNA info frame */ hna_frame = gtk_frame_new("HNA:"); gtk_widget_ref(hna_frame); gtk_object_set_data_full(GTK_OBJECT(main_window), "hna_frame", hna_frame, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(hna_frame); gtk_box_pack_start(GTK_BOX(hbox1), hna_frame, FALSE, FALSE, 0); //gtk_widget_set_size_request(mid_frame, 125, -1); gtk_container_set_border_width(GTK_CONTAINER(hna_frame), 1); /* *The HNA scrolled window */ hna_scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_ref(hna_scrolledwindow); gtk_object_set_data_full(GTK_OBJECT(main_window), "hna_scrolledwindow", hna_scrolledwindow, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(hna_scrolledwindow); gtk_container_add(GTK_CONTAINER(hna_frame), hna_scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(hna_scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_set_border_width(GTK_CONTAINER(hna_scrolledwindow), 3); /* *The HNA list */ hna_list = gtk_clist_new(1); gtk_widget_ref(hna_list); gtk_object_set_data_full(GTK_OBJECT(main_window), "hna_list", hna_list, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(hna_list); gtk_container_add(GTK_CONTAINER(hna_scrolledwindow), hna_list); gtk_clist_set_column_width(GTK_CLIST(hna_list), 0, 120); /* IP */ gtk_clist_column_titles_hide(GTK_CLIST(hna_list)); /* *The "main" notebook page */ Main = gtk_label_new("Main"); gtk_widget_ref(Main); gtk_object_set_data_full(GTK_OBJECT(main_window), "Main", Main, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(Main); gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 0), Main); /* *The main hbox of the Packet page */ hbox2 = gtk_hbox_new(FALSE, 0); gtk_widget_ref(hbox2); gtk_object_set_data_full(GTK_OBJECT(main_window), "hbox2", hbox2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(hbox2); gtk_container_add(GTK_CONTAINER(notebook1), hbox2); /* *The packet hbox */ pack_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_ref(pack_vbox); gtk_object_set_data_full(GTK_OBJECT(main_window), "pack_vbox", pack_vbox, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(pack_vbox); gtk_box_pack_start(GTK_BOX(hbox2), pack_vbox, TRUE, TRUE, 0); /* *The packet frame */ frame2 = gtk_frame_new("Packet"); gtk_widget_ref(frame2); gtk_object_set_data_full(GTK_OBJECT(main_window), "frame2", frame2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(frame2); gtk_box_pack_start(GTK_BOX(pack_vbox), frame2, TRUE, TRUE, 0); /* Do not expand */ /* *Packet list scrolled window */ scrolledwindow4 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_ref(scrolledwindow4); gtk_object_set_data_full(GTK_OBJECT(main_window), "scrolledwindow4", scrolledwindow4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(scrolledwindow4); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow4), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(frame2), scrolledwindow4); /* *The packet list */ packet_list = gtk_clist_new(3); gtk_widget_ref(packet_list); gtk_object_set_data_full(GTK_OBJECT(main_window), "packet_list", packet_list, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(packet_list); gtk_container_add(GTK_CONTAINER(scrolledwindow4), packet_list); gtk_clist_set_column_width(GTK_CLIST(packet_list), 0, 80); /* Type */ gtk_clist_set_column_width(GTK_CLIST(packet_list), 1, 150); /* Origin IP */ gtk_clist_set_column_width(GTK_CLIST(packet_list), 2, 20); /* size */ gtk_clist_column_titles_show(GTK_CLIST(packet_list)); label17 = gtk_label_new("Type"); gtk_widget_ref(label17); gtk_object_set_data_full(GTK_OBJECT(main_window), "label17", label17, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(label17); gtk_clist_set_column_widget(GTK_CLIST(packet_list), 0, label17); label18 = gtk_label_new("Origin"); gtk_widget_ref(label18); gtk_object_set_data_full(GTK_OBJECT(main_window), "label18", label18, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(label18); gtk_clist_set_column_widget(GTK_CLIST(packet_list), 1, label18); label19 = gtk_label_new("Size"); gtk_widget_ref(label19); gtk_object_set_data_full(GTK_OBJECT(main_window), "label19", label19, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(label19); gtk_clist_set_column_widget(GTK_CLIST(packet_list), 2, label19); /* *Row selection callback */ gtk_signal_connect(GTK_OBJECT(packet_list), "select_row", GTK_SIGNAL_FUNC(packet_selection), NULL); /* *The packet button */ packet_button = gtk_button_new_with_label("Grab packets"); gtk_widget_ref(packet_button); gtk_object_set_data_full(GTK_OBJECT(main_window), "packet_button", packet_button, (GtkDestroyNotify) gtk_widget_unref); /* Connect the "clicked" signal of the button to our callback */ gtk_signal_connect(GTK_OBJECT(packet_button), "clicked", GTK_SIGNAL_FUNC(packet_callback), NULL); gtk_widget_show(packet_button); gtk_box_pack_start(GTK_BOX(pack_vbox), packet_button, FALSE, FALSE, 5); /* *The packet disp hbox */ pack_disp_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_ref(pack_disp_vbox); gtk_object_set_data_full(GTK_OBJECT(main_window), "pack_disp_vbox", pack_disp_vbox, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(pack_disp_vbox); gtk_box_pack_start(GTK_BOX(hbox2), pack_disp_vbox, TRUE, TRUE, 0); /* *The packet disp frame */ disp_frame = gtk_frame_new("Packet content"); gtk_widget_ref(disp_frame); gtk_object_set_data_full(GTK_OBJECT(main_window), "disp_frame", disp_frame, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(disp_frame); gtk_box_pack_start(GTK_BOX(pack_disp_vbox), disp_frame, TRUE, TRUE, 0); /* Do not expand */ /* *Scrolled window for the packet display *list */ scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_ref(scrolledwindow3); gtk_object_set_data_full(GTK_OBJECT(main_window), "scrolledwindow3", scrolledwindow3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(scrolledwindow3); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow3), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(disp_frame), scrolledwindow3); //gtk_box_pack_start (GTK_BOX (disp_frame), scrolledwindow3, TRUE, TRUE, 0); /* *The packet display list */ packet_content_list = gtk_clist_new(4); gtk_widget_ref(packet_content_list); gtk_object_set_data_full(GTK_OBJECT(main_window), "packet_content_list", packet_content_list, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(packet_content_list); gtk_container_add(GTK_CONTAINER(scrolledwindow3), packet_content_list); gtk_clist_set_column_width(GTK_CLIST(packet_content_list), 0, 70); /* 0-7 */ gtk_clist_set_column_justification(GTK_CLIST(packet_content_list), 0, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(packet_content_list), 1, 70); /* 8-15 */ gtk_clist_set_column_justification(GTK_CLIST(packet_content_list), 1, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(packet_content_list), 2, 70); /* 16-23 */ gtk_clist_set_column_justification(GTK_CLIST(packet_content_list), 2, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(packet_content_list), 3, 70); /* 24-31 */ gtk_clist_set_column_justification(GTK_CLIST(packet_content_list), 3, GTK_JUSTIFY_CENTER); gtk_clist_column_titles_show(GTK_CLIST(packet_content_list)); label13 = gtk_label_new("0 - 7"); gtk_widget_ref(label13); gtk_object_set_data_full(GTK_OBJECT(main_window), "label13", label13, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(label13); gtk_clist_set_column_widget(GTK_CLIST(packet_content_list), 0, label13); label14 = gtk_label_new("8 - 15"); gtk_widget_ref(label14); gtk_object_set_data_full(GTK_OBJECT(main_window), "label14", label14, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(label14); gtk_clist_set_column_widget(GTK_CLIST(packet_content_list), 1, label14); label15 = gtk_label_new("16 - 23"); gtk_widget_ref(label15); gtk_object_set_data_full(GTK_OBJECT(main_window), "label15", label15, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(label15); gtk_clist_set_column_widget(GTK_CLIST(packet_content_list), 2, label15); label16 = gtk_label_new("24 - 31"); gtk_widget_ref(label16); gtk_object_set_data_full(GTK_OBJECT(main_window), "label16", label16, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(label16); gtk_clist_set_column_widget(GTK_CLIST(packet_content_list), 3, label16); //gtk_clist_set_selection_mode(GTK_CLIST (packet_content_list), GTK_SELECTION_NONE); /* no selections */ /* *The packet button */ packet_disp_button = gtk_button_new_with_label("Display hex"); gtk_widget_ref(packet_disp_button); gtk_object_set_data_full(GTK_OBJECT(main_window), "packet_disp_button", packet_disp_button, (GtkDestroyNotify) gtk_widget_unref); /* Connect the "clicked" signal of the button to our callback */ gtk_signal_connect(GTK_OBJECT(packet_disp_button), "clicked", GTK_SIGNAL_FUNC(packet_disp_callback), NULL); gtk_widget_show(packet_disp_button); gtk_box_pack_start(GTK_BOX(pack_disp_vbox), packet_disp_button, FALSE, FALSE, 5); /* *The "packets" notebook */ label_packets = gtk_label_new("Packets"); gtk_widget_ref(label_packets); gtk_object_set_data_full(GTK_OBJECT(main_window), "label_packets", label_packets, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(label_packets); gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 1), label_packets); /* *The route hbox */ route_hbox1 = gtk_hbox_new(FALSE, 0); gtk_widget_ref(route_hbox1); gtk_object_set_data_full(GTK_OBJECT(main_window), "route_hbox1", route_hbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(route_hbox1); //gtk_box_pack_start (GTK_BOX (hbox1), vbox1, TRUE, TRUE, 1); gtk_container_add(GTK_CONTAINER(notebook1), route_hbox1); /* *The routes frame */ route_frame = gtk_frame_new("OLSR routes in kernel:"); gtk_widget_ref(route_frame); gtk_object_set_data_full(GTK_OBJECT(main_window), "route_frame", route_frame, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(route_frame); //gtk_container_add (GTK_CONTAINER (notebook1), route_frame); gtk_widget_set_size_request(route_frame, 200, -1); gtk_box_pack_start(GTK_BOX(route_hbox1), route_frame, TRUE, TRUE, 0); /* Do not expand */ /* *Scrolled window for the packet display *list */ route_scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_ref(route_scrolledwindow); gtk_object_set_data_full(GTK_OBJECT(main_window), "route_scrolledwindow", route_scrolledwindow, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(route_scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(route_scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(route_frame), route_scrolledwindow); //gtk_box_pack_start (GTK_BOX (route_frame), scrolledwindow3, TRUE, TRUE, 0); /* *The routes display list */ route_list = gtk_clist_new(4); gtk_widget_ref(route_list); gtk_object_set_data_full(GTK_OBJECT(main_window), "route_list", route_list, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(route_list); gtk_container_add(GTK_CONTAINER(route_scrolledwindow), route_list); gtk_clist_set_column_width(GTK_CLIST(route_list), 0, 120); /* dest */ //gtk_clist_set_column_justification(GTK_CLIST (route_list), 0, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(route_list), 1, 120); /* gw */ //gtk_clist_set_column_justification(GTK_CLIST (route_list), 1, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(route_list), 2, 50); /* weight */ gtk_clist_set_column_justification(GTK_CLIST(route_list), 2, GTK_JUSTIFY_CENTER); gtk_clist_set_column_width(GTK_CLIST(route_list), 3, 70); /* interface */ gtk_clist_set_column_justification(GTK_CLIST(route_list), 3, GTK_JUSTIFY_CENTER); gtk_clist_column_titles_show(GTK_CLIST(route_list)); route_label1 = gtk_label_new("Destination"); gtk_widget_ref(route_label1); gtk_object_set_data_full(GTK_OBJECT(main_window), "route_label1", route_label1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(route_label1); gtk_clist_set_column_widget(GTK_CLIST(route_list), 0, route_label1); route_label2 = gtk_label_new("Gateway"); gtk_widget_ref(route_label2); gtk_object_set_data_full(GTK_OBJECT(main_window), "route_label2", route_label2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(route_label2); gtk_clist_set_column_widget(GTK_CLIST(route_list), 1, route_label2); route_label3 = gtk_label_new("Weight"); gtk_widget_ref(route_label3); gtk_object_set_data_full(GTK_OBJECT(main_window), "route_label3", route_label3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(route_label3); gtk_clist_set_column_widget(GTK_CLIST(route_list), 2, route_label3); route_label4 = gtk_label_new("Interface"); gtk_widget_ref(route_label4); gtk_object_set_data_full(GTK_OBJECT(main_window), "route_label4", route_label4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(route_label4); gtk_clist_set_column_widget(GTK_CLIST(route_list), 3, route_label4); //gtk_clist_set_selection_mode(GTK_CLIST (route_list), GTK_SELECTION_NONE); /* no selections */ /* *The routes stats frame */ route_stats_frame = gtk_frame_new("Stats:"); gtk_widget_ref(route_stats_frame); gtk_object_set_data_full(GTK_OBJECT(main_window), "route_stats_frame", route_stats_frame, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(route_stats_frame); //gtk_container_add (GTK_CONTAINER (notebook1), route_frame); gtk_box_pack_start(GTK_BOX(route_hbox1), route_stats_frame, TRUE, TRUE, 1); /* *The "routes" notebook */ label_routes = gtk_label_new("Routes"); gtk_widget_ref(label_routes); gtk_object_set_data_full(GTK_OBJECT(main_window), "label_routes", label_routes, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(label_routes); gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 2), label_routes); empty1 = gtk_vbox_new(FALSE, 0); gtk_widget_show(empty1); gtk_container_add(GTK_CONTAINER(notebook1), empty1); /* *The "traffic" notebook */ traffic_label = gtk_label_new("Traffic"); gtk_widget_ref(traffic_label); gtk_object_set_data_full(GTK_OBJECT(main_window), "traffic_label", traffic_label, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(traffic_label); gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 3), traffic_label); /* *The settings hbox */ settings_hbox1 = gtk_hbox_new(FALSE, 0); gtk_widget_ref(settings_hbox1); gtk_object_set_data_full(GTK_OBJECT(main_window), "settings_hbox1", settings_hbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(settings_hbox1); //gtk_box_pack_start (GTK_BOX (hbox1), vbox1, TRUE, TRUE, 1); gtk_container_add(GTK_CONTAINER(notebook1), settings_hbox1); /* *The settings-info label field */ info_label = gtk_label_new(NULL); gtk_widget_ref(info_label); gtk_misc_set_alignment((GtkMisc *) info_label, 0, 0); //gtk_label_set_justify((GtkLabel *)net_label,GTK_JUSTIFY_LEFT); gtk_object_set_data_full(GTK_OBJECT(main_window), "info_label", info_label, (GtkDestroyNotify) gtk_widget_unref); //set_net_info("Not connected..."); gtk_widget_show(info_label); gtk_box_pack_start(GTK_BOX(settings_hbox1), info_label, TRUE, TRUE, 0); /* *The "settings" notebook */ settings_label = gtk_label_new("Settings"); gtk_widget_ref(settings_label); gtk_object_set_data_full(GTK_OBJECT(main_window), "settings_label", settings_label, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(settings_label); gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 4), settings_label); /* *The "about" hbox */ about_hbox1 = gtk_hbox_new(FALSE, 0); gtk_widget_ref(about_hbox1); gtk_object_set_data_full(GTK_OBJECT(main_window), "about_hbox1", about_hbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(about_hbox1); //gtk_box_pack_start (GTK_BOX (hbox1), vbox1, TRUE, TRUE, 1); gtk_container_add(GTK_CONTAINER(notebook1), about_hbox1); gtk_container_set_border_width(GTK_CONTAINER(about_hbox1), 10); /* *The about label field */ about_label = gtk_label_new(NULL); gtk_widget_ref(about_label); gtk_misc_set_alignment((GtkMisc *) about_label, 0, 0); gtk_label_set_justify((GtkLabel *) about_label, GTK_JUSTIFY_CENTER); gtk_object_set_data_full(GTK_OBJECT(main_window), "about_label", about_label, (GtkDestroyNotify) gtk_widget_unref); //set_net_info("Not connected..."); gtk_widget_show(about_label); gtk_box_pack_start(GTK_BOX(about_hbox1), unik_logo, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(about_hbox1), about_label, TRUE, TRUE, 0); gtk_widget_show(unik_logo); gtk_label_set_text((GtkLabel *) about_label, "OLSRD-GUI by Andreas Tonnesen ([email protected])"); /* *The "about" notebook */ label3 = gtk_label_new("About"); gtk_widget_ref(label3); gtk_object_set_data_full(GTK_OBJECT(main_window), "About", label3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(label3); gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 5), label3); return main_window; }
int main(int argc, char *argv[]) { int has_rc=0; GtkWidget *mainWin; GtkWidget *table; GtkWidget *menu_bar; GtkWidget *index_page; GtkWidget *button; GtkWidget *label, *box, *sbox, *pbox; GtkWidget *vseparator; GtkWidget *post_process_button; GtkStyle *style; GtkWidget *gpixmap; GdkPixmap *pixmap; GdkBitmap *bitmap; char title[256]; char *envhome; #ifdef ENABLE_NLS bindtextdomain (PACKAGE, PACKAGE_LOCALE_DIR); textdomain (PACKAGE); #endif signal(SIGSEGV, crash); #ifdef sun __progname = argv[0]; #endif Thumbnails.next = NULL; Images.next=NULL; /* Set the priority (taken from PhotoPC photopc.c) */ #ifdef linux if (geteuid() == 0) { struct sched_param sp; int rc,minp,maxp; minp=sched_get_priority_min(SCHED_FIFO); maxp=sched_get_priority_max(SCHED_FIFO); sp.sched_priority=minp+(maxp-minp)/2; if ((rc=sched_setscheduler(0,SCHED_FIFO,&sp)) == -1) fprintf(stderr,"failed to set priority\n"); } #endif filesel_cwd = (char *)malloc(sizeof(char)*1024); getcwd(filesel_cwd, 1024); strcat(filesel_cwd, "/"); /* Make sure there's a .gphoto directory in their home ---- */ envhome = getenv("HOME"); gphotoDir = (char *)malloc(sizeof(char)*(strlen(envhome)+9)); memset(gphotoDir, 0, sizeof(char)*(strlen(envhome)+9)); sprintf(gphotoDir, "%s/.gphoto", envhome); (void)mkdir(gphotoDir, 0744); /* Command line mode anyone? ----------------------------- */ if (argc > 1) { command_line_mode = 1; has_rc = load_config(); command_line(argc, argv); } else command_line_mode = 0; /* Check for DISPLAY. If not set, exit */ if (!getenv("DISPLAY")) { printf(N_("Error: $DISPLAY variable is not set\n")); printf(N_("Please run \"gphoto -h\" for command-line options.\n")); _exit(0); } fprintf(stdout, N_("gPhoto %s (%s)\n"), VERSION, __DATE__); fprintf(stdout, N_("Copyright (C) 1998-2000 Scott Fritzinger <*****@*****.**>\n\n")); fprintf(stdout, N_("Usage: gphoto [-h] [-c] [-n] [-s # filename] [-t # filename]\n")); fprintf(stdout, N_(" [-d #] [-p filename] [-l filename]\n")); gtk_init(&argc, &argv); #if 1 /* by fujisawa */ gdk_imlib_init(); #endif gtk_widget_push_visual(gdk_imlib_get_visual()); gtk_widget_push_colormap(gdk_imlib_get_colormap()); library_name = gtk_label_new(""); has_rc = load_config(); /* set up the main window -------------------------------- */ mainWin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_border_width(GTK_CONTAINER(mainWin), 0); sprintf(title, "gPhoto %s", VERSION); gtk_window_set_title(GTK_WINDOW(mainWin), title); gtk_signal_connect(GTK_OBJECT(mainWin), "delete_event", GTK_SIGNAL_FUNC(delete_event), NULL); gtk_widget_set_usize(mainWin, 730, 480); gtk_widget_realize(mainWin); /* set up the menu --------------------------------------- */ menu_bar = gtk_vbox_new(FALSE, 0); create_menu(menu_bar); gtk_widget_show_all(menu_bar); /* button bar -------------------------------------------- */ box = gtk_hbox_new(FALSE, 0); create_toolbar(box, mainWin); gtk_widget_show(box); gtk_container_border_width(GTK_CONTAINER(box), 5); /* accelerator keys--------------------------------------- */ gtk_accel_group_attach(mainag,GTK_OBJECT(mainWin)); /* Index Page notebook ----------------------------------- */ index_page = gtk_table_new(1,1,FALSE); gtk_widget_show(index_page); index_window = gtk_scrolled_window_new(NULL,NULL); index_vp=gtk_viewport_new(NULL,NULL); gtk_container_add(GTK_CONTAINER(index_window), index_vp); gtk_widget_show(index_vp); gtk_widget_show(index_window); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(index_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_table_attach_defaults(GTK_TABLE(index_page),index_window,0,1,0,1); notebook = gtk_notebook_new(); gtk_widget_show(notebook); gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE); label = gtk_label_new(N_("Image Index")); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), index_page, label); sbox = gtk_hbox_new(FALSE, 5); gtk_widget_show(sbox); status_bar = gtk_label_new(""); gtk_widget_show(status_bar); gtk_label_set_justify(GTK_LABEL(status_bar), GTK_JUSTIFY_LEFT); gtk_box_pack_start(GTK_BOX(sbox), status_bar, FALSE, FALSE, 0); update_status("Select \"Camera->Download Index->Thumbnails\" to begin."); progress = gtk_progress_bar_new(); gtk_widget_show(progress); gtk_box_pack_end(GTK_BOX(sbox), progress, FALSE, FALSE, 0); vseparator = gtk_vseparator_new(); gtk_widget_show(vseparator); gtk_box_pack_end(GTK_BOX(sbox), vseparator, FALSE, FALSE, 0); post_process = 0; post_process_button = gtk_button_new(); gtk_widget_show(post_process_button); gtk_button_set_relief(GTK_BUTTON(post_process_button),GTK_RELIEF_NONE); gtk_signal_connect (GTK_OBJECT(post_process_button), "clicked", GTK_SIGNAL_FUNC(post_process_change), mainWin); gtk_box_pack_end(GTK_BOX(sbox), post_process_button, FALSE, FALSE, 0); pbox = gtk_hbox_new(FALSE, 3); gtk_widget_show(pbox); gtk_container_add(GTK_CONTAINER(post_process_button), pbox); style = gtk_widget_get_style(mainWin); pixmap = gdk_pixmap_create_from_xpm_d(mainWin->window, &bitmap, &style->bg[GTK_STATE_NORMAL],(gchar **)post_processing_off_xpm); post_process_pixmap = gtk_pixmap_new(pixmap, bitmap); gtk_widget_show(post_process_pixmap); gtk_box_pack_start(GTK_BOX(pbox),post_process_pixmap,FALSE,FALSE,0); label = gtk_label_new("Post Process"); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(pbox),label,FALSE,FALSE,0); vseparator = gtk_vseparator_new(); gtk_widget_show(vseparator); gtk_box_pack_end(GTK_BOX(sbox), vseparator, FALSE, FALSE, 0); gtk_widget_show(library_name); /* gtk_widget_set_usize(library_name, 200, 16);*/ gtk_label_set_justify(GTK_LABEL(library_name), GTK_JUSTIFY_LEFT); button = gtk_button_new(); gtk_widget_show(button); gtk_button_set_relief(GTK_BUTTON(button),GTK_RELIEF_NONE); gtk_signal_connect_object(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(port_dialog), NULL); gtk_container_add(GTK_CONTAINER(button), library_name); gtk_box_pack_end(GTK_BOX(sbox), button, FALSE, FALSE, 0); pixmap = gdk_pixmap_create_from_xpm_d(mainWin->window, &bitmap, &style->bg[GTK_STATE_NORMAL], (gchar **)splash_xpm); gpixmap = gtk_pixmap_new(pixmap, bitmap); gtk_widget_show(gpixmap); /* Main window layout ------------------------------------ */ table =gtk_table_new(4,1,FALSE); gtk_container_add(GTK_CONTAINER(mainWin), table); gtk_widget_show(table); gtk_table_attach(GTK_TABLE(table),menu_bar, 0, 1, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0 , 0); gtk_table_attach(GTK_TABLE(table), box, 0, 1, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); gtk_table_attach_defaults(GTK_TABLE(table),notebook, 0, 1, 2, 3); gtk_table_attach(GTK_TABLE(table),sbox, 0, 1, 3, 4, GTK_FILL|GTK_EXPAND, GTK_FILL, 0 , 0); index_table = gtk_hbox_new(FALSE, 0); gtk_widget_show(index_table); gtk_container_add( GTK_CONTAINER(index_vp), index_table); gtk_box_pack_start(GTK_BOX(index_table), gpixmap, TRUE, FALSE, 0); /* If not command-line mode... --------------------------- */ gtk_widget_show(mainWin); if (!has_rc) { /* put anything here to do on the first run */ developer_dialog_create(); error_dialog( "Could not load config file.\n" "Resetting to defaults.\n" "Click on \"Select Port-Camera Model\n" "in the Configure menu to set your\n" "camera model and serial port\n"); } gtk_main(); return 0; }