GtkWidget *load_gtk_widget()
{
/* Creation de la zone de saisie */
GtkWidget *pVBox = gtk_vbox_new(FALSE, 5);
GtkWidget *pLabelInfo=gtk_label_new(NULL);
/* On utilise les balises */
gtk_label_set_markup(GTK_LABEL(pLabelInfo), _("<span face=\"Courier New\"><b>Installing GRUB bootloader</b></span>"));
gtk_box_pack_start(GTK_BOX(pVBox), pLabelInfo, FALSE, FALSE, 6);
GtkWidget *pLabel = gtk_label_new(_("Choose install type :"));
gtk_box_pack_start(GTK_BOX(pVBox), pLabel, FALSE, FALSE, 5);
/* Creation du premier bouton radio */
pRadio1 = gtk_radio_button_new_with_label(NULL, _("MBR - Install to Master Boot Record"));
gtk_box_pack_start(GTK_BOX (pVBox), pRadio1, FALSE, FALSE, 0);
/* Ajout du deuxieme */
GtkWidget *pRadio2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (pRadio1), _("Floppy - Install to a formatted floppy in /dev/fd0"));
gtk_box_pack_start(GTK_BOX (pVBox), pRadio2, FALSE, FALSE, 0);
/* Ajout du troisieme */
GtkWidget *pRadio3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (pRadio1), _("Root - Install to superblock (do NOT use with XFS)"));
gtk_box_pack_start(GTK_BOX (pVBox), pRadio3, FALSE, FALSE, 0);
GtkWidget *pRadio4 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (pRadio1), _("Skip - Skip the installation of GRUB."));
gtk_box_pack_start(GTK_BOX (pVBox), pRadio4, FALSE, FALSE, 0);
return pVBox;
}
/**
* Create a vbox containing widgets allowing to change aspects of
* toolbar buttons.
*
* \return A newly created vbox.
*/
GtkWidget *tab_display_toolbar ( void )
{
GtkWidget * vbox_pref, * paddingbox, * radio, * radiogroup;
GtkWidget *vbox;
GtkWidget *button;
vbox_pref = new_vbox_with_title_and_icon ( _("Toolbars"), "toolbar.png" );
paddingbox = new_paddingbox_with_title ( vbox_pref, FALSE,
_("Display toolbar buttons as") );
radiogroup = radio = gtk_radio_button_new_with_label ( NULL, _("Text") );
g_object_set_data ( G_OBJECT(radio), "display", GINT_TO_POINTER(GSB_BUTTON_TEXT) );
gtk_box_pack_start ( GTK_BOX(paddingbox), radio, FALSE, FALSE, 0 );
if ( etat.display_toolbar == GSB_BUTTON_TEXT )
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (radio), TRUE );
g_signal_connect ( G_OBJECT(radio), "toggled",
G_CALLBACK(change_toolbar_display_mode), NULL );
radio = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON(radiogroup),
_("Icons") );
g_object_set_data ( G_OBJECT(radio), "display", GINT_TO_POINTER(GSB_BUTTON_ICON) );
gtk_box_pack_start ( GTK_BOX(paddingbox), radio, FALSE, FALSE, 0 );
if ( etat.display_toolbar == GSB_BUTTON_ICON )
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (radio), TRUE );
g_signal_connect ( G_OBJECT(radio), "toggled",
G_CALLBACK(change_toolbar_display_mode), NULL );
radio = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON(radiogroup),
_("Both") );
g_object_set_data ( G_OBJECT(radio), "display", GINT_TO_POINTER(GSB_BUTTON_BOTH) );
gtk_box_pack_start ( GTK_BOX(paddingbox), radio, FALSE, FALSE, 0 );
if ( etat.display_toolbar == GSB_BUTTON_BOTH )
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (radio), TRUE );
g_signal_connect ( G_OBJECT(radio), "toggled",
G_CALLBACK(change_toolbar_display_mode), NULL );
gtk_widget_show_all ( vbox_pref );
if ( !gsb_data_account_get_accounts_amount () )
gtk_widget_set_sensitive ( vbox_pref, FALSE );
gtk_box_pack_start ( GTK_BOX ( vbox_pref ),
gsb_automem_checkbutton_new ( _("Display headings bar"),
&(etat.show_headings_bar),
G_CALLBACK (preferences_switch_headings_bar), NULL ),
FALSE, FALSE, 0 );
vbox = new_vbox_with_title_and_icon ( _("Navigation pane"), "organization.png" );
gtk_box_pack_start ( GTK_BOX ( vbox_pref ), vbox, TRUE, TRUE, 0 );
button = gsb_automem_checkbutton_new (_("Add mouse scrolling support on the navigation pane"),
&conf.active_scrolling_left_pane,
G_CALLBACK ( preferences_active_mouse_scrolling_left_pane ),
NULL);
gtk_box_pack_start ( GTK_BOX ( vbox ), button, FALSE, FALSE, 5 );
return ( vbox_pref );
}
int main( int argc, char **argv ) {
gtk_init( &argc, &argv );
GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW( window ), "Radio Button" );
gtk_widget_set_size_request( window, 320, 240 );
gtk_container_set_border_width( GTK_CONTAINER( window ), 20 );
/*
* you have to group them into one radio button. otherwise they will work
* individually.
*/
GtkWidget *chief = gtk_radio_button_new_with_label( NULL, "I am the Chief" );
GtkWidget *staff1 = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON( chief ), "I am staff 1" );
GtkWidget *staff2 = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON( chief ), "I am staff 2" );
GtkWidget *staff3 = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON( chief ), "I am staff 3" );
GtkWidget *close = gtk_button_new_from_stock( GTK_STOCK_CLOSE );
g_signal_connect( G_OBJECT( close ), "clicked", G_CALLBACK( gtk_main_quit ), NULL );
g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( gtk_main_quit ), NULL );
GtkWidget *vbox = gtk_vbox_new( TRUE, 10 );
gtk_box_pack_start( GTK_BOX( vbox ), chief, FALSE, FALSE, 10 );
gtk_box_pack_start( GTK_BOX( vbox ), staff1, FALSE, FALSE, 10 );
gtk_box_pack_start( GTK_BOX( vbox ), staff2, FALSE, FALSE, 10 );
gtk_box_pack_start( GTK_BOX( vbox ), staff3, FALSE, FALSE, 10 );
gtk_box_pack_start( GTK_BOX( vbox ), close, FALSE, FALSE, 10 );
gtk_container_add( GTK_CONTAINER( window ), vbox );
gtk_widget_show_all( window );
gtk_main();
return 0;
}
static void add_radios_color_flow(GtkBox *parent, KoneplusLightEffectsFrame *frame) {
KoneplusLightEffectsFramePrivate *priv = frame->priv;
GtkWidget *radio;
radio = gtk_radio_button_new_with_label(NULL, _("Flow direction right"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(KONEPLUS_PROFILE_SETTINGS_COLOR_FLOW_EFFECT_RIGHT));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Flow direction left"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(KONEPLUS_PROFILE_SETTINGS_COLOR_FLOW_EFFECT_LEFT));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Flow direction down"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(KONEPLUS_PROFILE_SETTINGS_COLOR_FLOW_EFFECT_DOWN));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Flow direction up"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(KONEPLUS_PROFILE_SETTINGS_COLOR_FLOW_EFFECT_UP));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("All lights simultaneously"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(KONEPLUS_PROFILE_SETTINGS_COLOR_FLOW_EFFECT_SIMULTANEOUSLY));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("No color flow"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(KONEPLUS_PROFILE_SETTINGS_COLOR_FLOW_EFFECT_OFF));
priv->radios_color_flow = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
g_slist_foreach(priv->radios_color_flow, pack_radio_button, parent);
}
static void ryostklconfig_effect_selector_init(RyostklconfigEffectSelector *effect_selector) {
RyostklconfigEffectSelectorPrivate *priv = RYOSTKLCONFIG_EFFECT_SELECTOR_GET_PRIVATE(effect_selector);
effect_selector->priv = priv;
priv->off = GTK_TOGGLE_BUTTON(gtk_radio_button_new_with_label(NULL, _("Off")));
priv->fade = GTK_TOGGLE_BUTTON(gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(priv->off), _("Fade FX")));
priv->ripple = GTK_TOGGLE_BUTTON(gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(priv->fade), _("Ripple FX")));
priv->delay_time = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(RYOSTKL_LIGHT_LAYER_EFFECT_TIME_MIN, RYOSTKL_LIGHT_LAYER_EFFECT_TIME_MAX, 1.0));
priv->fade_time = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(RYOSTKL_LIGHT_LAYER_EFFECT_TIME_MIN, RYOSTKL_LIGHT_LAYER_EFFECT_TIME_MAX, 1.0));
g_signal_connect(G_OBJECT(priv->off), "toggled", G_CALLBACK(effect_cb), effect_selector);
g_signal_connect(G_OBJECT(priv->fade), "toggled", G_CALLBACK(effect_cb), effect_selector);
g_signal_connect(G_OBJECT(priv->ripple), "toggled", G_CALLBACK(effect_cb), effect_selector);
priv->delay_handler_id = g_signal_connect(G_OBJECT(priv->delay_time), "value-changed", G_CALLBACK(time_cb), effect_selector);
priv->fade_handler_id = g_signal_connect(G_OBJECT(priv->fade_time), "value-changed", G_CALLBACK(time_cb), effect_selector);
gtk_box_pack_start(GTK_BOX(effect_selector), GTK_WIDGET(priv->off), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), gtk_vseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), GTK_WIDGET(priv->fade), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), gtk_label_new(_("Delay")), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), GTK_WIDGET(priv->delay_time), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), gtk_label_new(_("Fade")), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), GTK_WIDGET(priv->fade_time), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), gtk_vseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), GTK_WIDGET(priv->ripple), TRUE, FALSE, 0);
}
gboolean a_dialog_time_threshold ( GtkWindow *parent, gchar *title_text, gchar *label_text, guint *thr )
{
GtkWidget *dialog = gtk_dialog_new_with_buttons (title_text,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
GtkWidget *table, *t1, *t2, *t3, *t4, *spin, *label;
GtkWidget *pass_along[1];
table = gtk_table_new ( 4, 2, FALSE );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), table, TRUE, TRUE, 0 );
label = gtk_label_new (label_text);
t1 = gtk_radio_button_new_with_label ( NULL, _("1 min") );
t2 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON(t1), _("1 hour") );
t3 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON(t2), _("1 day") );
t4 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON(t3), _("Custom (in minutes):") );
pass_along[0] = t4;
spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( *thr, 0, 65536, 1, 5, 0 ), 1, 0 );
gtk_table_attach_defaults ( GTK_TABLE(table), label, 0, 2, 0, 1 );
gtk_table_attach_defaults ( GTK_TABLE(table), t1, 0, 1, 1, 2 );
gtk_table_attach_defaults ( GTK_TABLE(table), t2, 0, 1, 2, 3 );
gtk_table_attach_defaults ( GTK_TABLE(table), t3, 0, 1, 3, 4 );
gtk_table_attach_defaults ( GTK_TABLE(table), t4, 0, 1, 4, 5 );
gtk_table_attach_defaults ( GTK_TABLE(table), spin, 1, 2, 4, 5 );
gtk_widget_show_all ( table );
g_signal_connect ( G_OBJECT(spin), "grab-focus", G_CALLBACK(split_spin_focused), pass_along );
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT )
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(t1))) {
*thr = 1;
} else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(t2))) {
*thr = 60;
} else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(t3))) {
*thr = 60 * 24;
} else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(t4))) {
*thr = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(spin) );
}
gtk_widget_destroy ( dialog );
return TRUE;
}
gtk_widget_destroy ( dialog );
return FALSE;
}
static void
add_follow_fields( GtkWidget *outer,
t_ctxt *ctxt)
/*
* Add the fields specific to the at_msg action type which is used to
* display a message to the user
*/
{
GtkWidget *vbox; /* Follow-on mode box */
GtkWidget *none; /* Temp for button none */
GtkWidget *imm; /* Temp for button immediate */
GtkWidget *chain; /* Temp for button chain */
t_usr_ctxt *usr;
usr = ctxt->usr;
vbox = add_frame(outer, "Follow-on mode");
gtk_container_set_border_width(GTK_CONTAINER(vbox), PAD);
none = gtk_radio_button_new_with_label(NULL, "None");
gtk_widget_set_tooltip_text(none,
"This cue will wait for an explicit trigger");
imm = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(none), "Immediate");
gtk_widget_set_tooltip_text(imm,
"Start immediately after the preceeding cue (+ delay)");
chain = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(none), "Chain");
gtk_widget_set_tooltip_text(chain,
"Start after the preceeding cue has completed (+ delay)");
switch(usr->cue->follow) /* Set appropriate button */
{
case fo_immediate:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(imm), TRUE);
break;
case fo_chain:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chain), TRUE);
break;
default:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(none), TRUE);
}
gtk_box_pack_start(GTK_BOX(vbox), none, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), imm, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), chain, FALSE, FALSE, 0);
usr->fld_none = none;
usr->fld_immediate = imm;
usr->fld_chain = chain;
} /* add_follow_fields() */
static void xtp_build_config_dialog_frame(const gchar *title, XtpDialogWidgets *dw, gboolean use_enabled, gboolean is_enabled)
{
dw->frm = gtk_frame_new(title);
dw->box = gtk_vbox_new(FALSE, 0);
if(!is_enabled)
{
gtk_widget_set_sensitive(dw->frm, FALSE);
}
if(use_enabled)
{
dw->chk_ebl = gtk_check_button_new_with_label("Enabled ");
}
dw->btn_exec = gtk_radio_button_new_with_label(NULL, "Execute Command");
dw->btn_file = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(dw->btn_exec),
"Read From File");
dw->btn_stat = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(dw->btn_exec),
"Static Text");
dw->lbl_entry = gtk_label_new("Text: ");
dw->txt_entry = gtk_entry_new();
dw->box_entry = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(dw->box_entry), dw->lbl_entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(dw->box_entry), dw->txt_entry, TRUE , TRUE , 0);
dw->chk_upd = gtk_check_button_new_with_label("Update ");
dw->box_upd = gtk_hbox_new(FALSE, 0);
dw->spn_upd = gtk_spin_button_new_with_range(0.0, 31556926.0, 0.01);
dw->lbl_upd = gtk_label_new(" seconds");
gtk_box_pack_start(GTK_BOX(dw->box_upd), dw->chk_upd, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(dw->box_upd), dw->spn_upd, TRUE , TRUE , 0);
gtk_box_pack_start(GTK_BOX(dw->box_upd), dw->lbl_upd, FALSE, FALSE, 0);
if(use_enabled)
{
gtk_box_pack_start(GTK_BOX(dw->box), dw->chk_ebl, FALSE, FALSE, 0);
}
gtk_box_pack_start(GTK_BOX(dw->box), dw->btn_exec , FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(dw->box), dw->btn_file , FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(dw->box), dw->btn_stat , FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(dw->box), dw->box_entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(dw->box), dw->box_upd , FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(dw->box), BORDER - 2);
gtk_container_add(GTK_CONTAINER(dw->frm), dw->box);
}
void OnRotation(GtkWidget* widget, gpointer data) {
(void) data;
(void) widget;
/* Creation de la boite de dialogue */
/* 1 bouton Valider */
/* 1 bouton Annuler */
GtkWidget* pBoite = gtk_dialog_new_with_buttons("Rotation", NULL,
GTK_DIALOG_MODAL,
GTK_STOCK_OK,GTK_RESPONSE_OK,
GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,
NULL);
// Creation des boutons radio
GtkWidget *pRadio90 = gtk_radio_button_new_with_label(NULL, "90°"),
*pRadio180 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (pRadio90),"180°"),
*pRadio270 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (pRadio90),"270°");
/* Insertion de la zone de saisie dans la boite de dialogue */
/* Rappel : paramètre 1 de gtk_box_pack_start de type GtkBox */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pRadio90, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pRadio180, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pRadio270, TRUE, FALSE, 0);
/* Affichage des elements de la boite de dialogue */
gtk_widget_show_all(GTK_DIALOG(pBoite)->vbox);
/* On lance la boite de dialogue et on recupere la reponse */
if (gtk_dialog_run(GTK_DIALOG(pBoite)) == GTK_RESPONSE_OK) {
int angle = 270;
/* Recuperation de la liste des boutons */
GSList *pList = gtk_radio_button_get_group(GTK_RADIO_BUTTON(pRadio90));
/* Parcours de la liste */
while(pList) {
/* Le bouton est il selectionne */
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pList->data))) {
// rotation
pile_new_image(rotation(cur_image, angle));
}
/* NON -> on passe au bouton suivant */
angle -= 90;
pList = g_slist_next(pList);
}
}
/* Destruction de la boite de dialogue */
gtk_widget_destroy(pBoite);
}
GtkWidget *vik_radio_group_new ( GList *options )
{
VikRadioGroup *vrg;
GtkWidget *t;
gchar *label;
GList *option = options;
if ( ! options )
return NULL;
vrg = VIK_RADIO_GROUP ( g_object_new ( VIK_RADIO_GROUP_TYPE, NULL ) );
label = g_list_nth_data(options, 0);
t = gtk_radio_button_new_with_label ( NULL, label );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(t), TRUE );
gtk_box_pack_start ( GTK_BOX(vrg), t, FALSE, FALSE, 0 );
vrg->radios = g_slist_append ( NULL, t );
vrg->options_count = 1;
while ( ( option = g_list_next(option) ) != NULL )
{
label = option->data;
t = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON(vrg->radios->data), label );
vrg->radios = g_slist_append( vrg->radios, t );
gtk_box_pack_start ( GTK_BOX(vrg), GTK_WIDGET(t), FALSE, FALSE, 0 );
vrg->options_count++;
}
return GTK_WIDGET(vrg);
}
static void configure()
{
GtkWidget *window = gtk_dialog_new_with_buttons(_("WordNet configuration"), GTK_WINDOW(plugin_info->pluginwin), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
#if GTK_MAJOR_VERSION >= 3
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
#else
GtkWidget *vbox = gtk_vbox_new(false, 5);
#endif
GtkWidget *graphic_button = gtk_radio_button_new_with_label(NULL, _("Graphic mode."));
gtk_box_pack_start(GTK_BOX(vbox), graphic_button, false, false, 0);
GtkWidget *text_button = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(graphic_button), _("Text mode."));
gtk_box_pack_start(GTK_BOX(vbox), text_button, false, false, 0);
if (text_or_graphic_mode) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(text_button), true);
} else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(graphic_button), true);
}
gtk_widget_show_all(vbox);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG(window))), vbox);
gtk_dialog_run(GTK_DIALOG(window));
gboolean new_text_or_graphic_mode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(text_button));
if (new_text_or_graphic_mode != text_or_graphic_mode) {
text_or_graphic_mode = new_text_or_graphic_mode;
save_conf_file();
}
gtk_widget_destroy (window);
}
static GtkWidget *make_scaling_radio_button(CtkDisplayDeviceDfp
*ctk_display_device_dfp,
GtkWidget *vbox,
GtkWidget *prev_radio,
char *label,
gint value)
{
GtkWidget *radio;
if (prev_radio) {
radio = gtk_radio_button_new_with_label_from_widget
(GTK_RADIO_BUTTON(prev_radio), label);
} else {
radio = gtk_radio_button_new_with_label(NULL, label);
}
gtk_box_pack_start(GTK_BOX(vbox), radio, FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(radio), "scaling_value",
GINT_TO_POINTER(value));
g_signal_connect(G_OBJECT(radio), "toggled",
G_CALLBACK(dfp_scaling_changed),
(gpointer) ctk_display_device_dfp);
ctk_display_device_dfp->scaling_method_buttons[value -1] = radio;
return radio;
} /* make_scaling_radio_button() */
static void create_radio(GtkWidget *vbox, const char *name, ...)
{
va_list args;
GtkRadioButton *group = NULL;
GtkWidget *box, *label;
box = gtk_hbox_new(TRUE, 10);
gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 0);
label = gtk_label_new(name);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
va_start(args, name);
for (;;) {
int enabled;
const char *name;
GtkWidget *button;
void *callback_fn;
name = va_arg(args, char *);
if (!name)
break;
callback_fn = va_arg(args, void *);
enabled = va_arg(args, int);
button = gtk_radio_button_new_with_label_from_widget(group, name);
group = GTK_RADIO_BUTTON(button);
gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), enabled);
g_signal_connect(button, "toggled", G_CALLBACK(callback_fn), NULL);
}
va_end(args);
}
int
x_create_radio (Dlg_head *h, widget_data parent, WRadio *r)
{
GtkWidget *w, *vbox;
int i;
vbox = gtk_vbox_new (0, 0);
for (i = 0; i < r->count; i++){
char *text = remove_hotkey (_(r->texts [i]));
if (i == 0){
w = gtk_radio_button_new_with_label (NULL, text);
r->first_gtk_radio = w;
} else
w = gtk_radio_button_new_with_label_from_widget (r->first_gtk_radio, text);
g_free (text);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (w), (i == r->sel));
gtk_signal_connect (GTK_OBJECT (w), "toggled", GTK_SIGNAL_FUNC (radio_toggle), r);
gtk_object_set_data (GTK_OBJECT (w), "index", (void *) (i+1));
gtk_box_pack_start_defaults (GTK_BOX (vbox), w);
}
gtk_widget_show_all (vbox);
r->widget.wdata = (widget_data) vbox;
return 1;
}
static void configure()
{
GtkWidget *window = gtk_dialog_new_with_buttons(_("Dict.cn configuration"), GTK_WINDOW(plugin_info->pluginwin), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
GtkWidget *vbox = gtk_vbox_new(false, 5);
GtkWidget *xml_button = gtk_radio_button_new_with_label(NULL, _("Query by XML API."));
gtk_box_pack_start(GTK_BOX(vbox), xml_button, false, false, 0);
GtkWidget *html_button = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(xml_button), _("Query by HTML API."));
gtk_box_pack_start(GTK_BOX(vbox), html_button, false, false, 0);
if (use_html_or_xml) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(html_button), true);
} else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(xml_button), true);
}
gtk_widget_show_all(vbox);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(window)->vbox), vbox);
gtk_dialog_run(GTK_DIALOG(window));
gboolean new_use_html_or_xml = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(html_button));
if (new_use_html_or_xml != use_html_or_xml) {
use_html_or_xml = new_use_html_or_xml;
const char *tmp;
if (use_html_or_xml) {
tmp = "true";
} else {
tmp = "false";
}
gchar *data = g_strdup_printf("[dictdotcn]\nuse_html_or_xml=%s\n", tmp);
std::string res = get_cfg_filename();
g_file_set_contents(res.c_str(), data, -1, NULL);
g_free(data);
}
gtk_widget_destroy (window);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkCheckboxPeer_nativeCreate
(JNIEnv *env, jobject obj, jobject group, jboolean state)
{
GtkWidget *button;
/* Create global reference and save it for future use */
NSA_SET_GLOBAL_REF (env, obj);
gdk_threads_enter ();
if (group == NULL)
button = gtk_check_button_new_with_label ("");
else
{
void *native_group = NSA_GET_PTR (env, group);
button = gtk_radio_button_new_with_label_from_widget (native_group, "");
if (native_group == NULL)
{
/* Set the native group so we can use the correct value the
next time around. FIXME: this doesn't work! */
NSA_SET_PTR (env, group, button);
}
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), state);
gdk_threads_leave ();
NSA_SET_PTR (env, obj, button);
}
static GtkWidget *xv_sync_to_display_radio_button_add(CtkXVideo *ctk_xvideo,
GtkWidget *prev_radio,
char *label,
gint value,
int index)
{
GtkWidget *radio;
if (prev_radio) {
radio = gtk_radio_button_new_with_label_from_widget
(GTK_RADIO_BUTTON(prev_radio), label);
} else {
radio = gtk_radio_button_new_with_label(NULL, label);
}
gtk_box_pack_start(GTK_BOX(ctk_xvideo->xv_sync_to_display_button_box),
radio, FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(radio), "xv_sync_to_display",
GINT_TO_POINTER(value));
g_signal_connect(G_OBJECT(radio), "toggled",
G_CALLBACK(xv_sync_to_display_changed),
(gpointer) ctk_xvideo);
ctk_xvideo->xv_sync_to_display_buttons[index] = radio;
return radio;
} /* xv_sync_to_display_radio_button_add() */
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkCheckboxPeer_create
(JNIEnv *env, jobject obj, jobject group)
{
GtkWidget *button;
NSA_SET_GLOBAL_REF (env, obj);
gdk_threads_enter ();
if (group == NULL)
button = gtk_check_button_new_with_label ("");
else
{
void *native_group = NSA_GET_PTR (env, group);
button = gtk_radio_button_new_with_label_from_widget (native_group, "");
if (native_group == NULL)
{
/* Set the native group so we can use the correct value the
next time around. FIXME: this doesn't work! */
NSA_SET_PTR (env, group, button);
}
}
gdk_threads_leave ();
NSA_SET_PTR (env, obj, button);
}
GtkWidget *vik_radio_group_new_static ( const gchar **options )
{
VikRadioGroup *vrg;
GtkWidget *t;
if ( ! *options )
return NULL;
vrg = VIK_RADIO_GROUP ( g_object_new ( VIK_RADIO_GROUP_TYPE, NULL ) );
t = gtk_radio_button_new_with_label ( NULL, options[0] );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(t), TRUE );
gtk_box_pack_start ( GTK_BOX(vrg), t, FALSE, FALSE, 0 );
vrg->radios = g_slist_append ( NULL, t );
vrg->options_count = 1;
for ( options++ ; *options ; options++ )
{
t = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON(vrg->radios->data), *options );
vrg->radios = g_slist_append( vrg->radios, t );
gtk_box_pack_start ( GTK_BOX(vrg), GTK_WIDGET(t), FALSE, FALSE, 0 );
vrg->options_count++;
}
return GTK_WIDGET(vrg);
}
static gboolean
rw_preferences_dialog_setup_skins_page(GtkNotebook *nb, COption *parent)
{
GtkWidget *vbox, *vbox1, *label, *radio=NULL;
vbox = gtk_vbox_new(false,18);
label=gtk_label_new(_("Choose the skin.You need to restart the program\nto get effect.\n\nSkin:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, .5);
gtk_box_pack_start(GTK_BOX(vbox),label,false,false,0);
vbox1 = gtk_vbox_new(false,6);
gchar *ab;
if (!(rw_cfg_read_string (usercfgfile, "reciteword", "skin", &ab)))
ab=g_strdup("bdc");
GDir *dp;
gchar *filename;
filename = g_build_filename(reciteword_data_dir, "skins", NULL);
dp = g_dir_open(filename,0,NULL);
g_free(filename);
if (dp)
{
const gchar *item;
gchar *fullname;
while ((item = g_dir_read_name(dp)) != NULL)
{
fullname = g_build_filename(reciteword_data_dir, "skins", item, NULL);
if (g_file_test(fullname,G_FILE_TEST_IS_DIR))
{
g_free(fullname);
fullname = g_build_filename(reciteword_data_dir, "skins", item, "skin.inf", NULL);
if (g_file_test(fullname,G_FILE_TEST_EXISTS))
{
if (!radio) // first radio button.
radio = gtk_radio_button_new_with_label(NULL,item);
else
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (radio),item);
g_object_set_data_full(G_OBJECT(radio),"skin_dir",g_strdup(item),g_free);
gtk_box_pack_start(GTK_BOX(vbox1),radio,false,false,0);
if (strcmp(ab,item)==0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio),true);
g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (on_setup_skins_radio_toggled), NULL);
}
g_free(fullname);
}
else
g_free(fullname);
}
g_dir_close(dp);
}
g_free(ab);
gtk_box_pack_start(GTK_BOX(vbox),vbox1,false,false,0);
gtk_notebook_append_page(nb,vbox,NULL);
return true;
}
static void luaconfig_light_frame_init(LuaconfigLightFrame *frame) {
LuaconfigLightFramePrivate *priv = LUACONFIG_LIGHT_FRAME_GET_PRIVATE(frame);
GtkWidget *vbox;
GtkWidget *radio;
frame->priv = priv;
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
radio = gtk_radio_button_new_with_label_from_widget(NULL, _("Off"));
g_object_set_data(G_OBJECT(radio), light_key, GUINT_TO_POINTER(LUA_RMP_LIGHT_OFF));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Breathing"));
g_object_set_data(G_OBJECT(radio), light_key, GUINT_TO_POINTER(LUA_RMP_LIGHT_BREATHING));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Fully lighted"));
g_object_set_data(G_OBJECT(radio), light_key, GUINT_TO_POINTER(LUA_RMP_LIGHT_FULLY_LIGHTED));
priv->radios = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
g_slist_foreach(priv->radios, pack_radio_button, vbox);
}
static void add_radios_light_effect(GtkBox *parent, NythLightEffectsFrame *frame) {
NythLightEffectsFramePrivate *priv = frame->priv;
GtkWidget *radio;
radio = gtk_radio_button_new_with_label(NULL, _("Heartbeat"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_LIGHT_EFFECT_HEARTBEAT));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Breathing"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_LIGHT_EFFECT_BREATHING));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Blinking"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_LIGHT_EFFECT_BLINKING));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Fully lighted"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_LIGHT_EFFECT_FULLY_LIGHTED));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("All lights off"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_LIGHT_EFFECT_ALL_OFF));
priv->radios_light_effect = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
g_slist_foreach(priv->radios_light_effect, pack_radio_button, parent);
}
static GtkWidget*
create_button(VALUE group, VALUE label, VALUE use_underline)
{
GtkWidget* widget = NULL;
if (TYPE(label) == T_STRING){
if (NIL_P(use_underline) || RVAL2CBOOL(use_underline)){
widget = gtk_radio_button_new_with_mnemonic_from_widget(_GROUP(group), RVAL2CSTR(label));
} else {
widget = gtk_radio_button_new_with_label_from_widget(_GROUP(group), RVAL2CSTR(label));
}
} else if (TYPE(label) == T_SYMBOL){
widget = gtk_radio_button_new_with_label_from_widget(_GROUP(group), rb_id2name(SYM2ID(label)));
gtk_button_set_use_stock(GTK_BUTTON(widget), TRUE);
} else if (NIL_P(label)){
widget = gtk_radio_button_new_from_widget(_GROUP(group));
} else {
rb_raise(rb_eArgError, "invalid argument %s (expect Symbol(Gtk::Stock constants) or String)",
rb_class2name(CLASS_OF(label)));
}
return widget;
}
static void remmina_file_editor_create_resolution(RemminaFileEditor* gfe, const RemminaProtocolSetting* setting,
GtkWidget* table, gint row)
{
GtkWidget* widget;
GtkWidget* hbox;
const gchar* resolution;
widget = gtk_label_new(_("Resolution"));
gtk_widget_show(widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), widget, 0, 1, row, row + 1, GTK_FILL, 0, 0, 0);
widget = gtk_radio_button_new_with_label(NULL, setting->opt1 ? _("Use window size") : _("Use client resolution"));
gtk_widget_show(widget);
gtk_table_attach_defaults(GTK_TABLE(table), widget, 1, 2, row, row + 1);
gfe->priv->resolution_auto_radio = widget;
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
gtk_table_attach_defaults(GTK_TABLE(table), hbox, 1, 2, row + 1, row + 2);
widget = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(gfe->priv->resolution_auto_radio), _("Custom"));
gtk_widget_show(widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
gfe->priv->resolution_custom_radio = widget;
resolution = remmina_file_get_string(gfe->priv->remmina_file, "resolution");
widget = remmina_public_create_combo_text_d(remmina_pref.resolutions, resolution, NULL);
gtk_widget_show(widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gfe->priv->resolution_custom_combo = widget;
widget = gtk_button_new_with_label("...");
gtk_widget_show(widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_browse_resolution), gfe);
g_signal_connect(G_OBJECT(gfe->priv->resolution_custom_radio), "toggled",
G_CALLBACK(remmina_file_editor_button_on_toggled), gfe->priv->resolution_custom_combo);
if (!resolution || strchr(resolution, 'x') == NULL)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gfe->priv->resolution_auto_radio), TRUE);
gtk_widget_set_sensitive(gfe->priv->resolution_custom_combo, FALSE);
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gfe->priv->resolution_custom_radio), TRUE);
}
}
GtkWidget *init_search_widget(GtkWidget *parent_window) {
GtkWidget *widget;
GtkWidget *entry, *button, *hbox, *radio_group[4];
gint i;
const gchar *type[4] = { "Artist", "Album", "Title", "Filename" };
GList *argument_list = NULL;
widget = gtk_vbox_new(FALSE, 2);
entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entry), "");
gtk_box_pack_start(GTK_BOX(widget), entry,FALSE,FALSE,0);
hbox = gtk_hbox_new(TRUE, 2);
for(i = 0; i < 4; i++) {
if(i == 0) {
radio_group[i] = gtk_radio_button_new_with_label(
NULL,
type[i]
);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_group[i]), TRUE);
}
else {
radio_group[i] = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(radio_group[0]),
type[i]
);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_group[i]), FALSE);
}
g_signal_connect(G_OBJECT(radio_group[i]), "toggled",
G_CALLBACK(mark_type), (gpointer) i);
gtk_box_pack_start_defaults(GTK_BOX(hbox), radio_group[i]);
}
gtk_box_pack_start(GTK_BOX(widget), hbox,FALSE,FALSE, 0);
button = gtk_button_new_with_label("Search");
/* pack relevant widgets (box and entry) for mpd_search()*/
argument_list = g_list_append(argument_list, entry);
argument_list = g_list_append(argument_list, widget);
argument_list = g_list_append(argument_list, parent_window);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(mpd_search), argument_list);
g_signal_connect(G_OBJECT(entry), "activate",
G_CALLBACK(mpd_search), argument_list);
gtk_box_pack_start(GTK_BOX(widget), button,FALSE,FALSE,0);
return widget;
}
int main (int argc,
char *argv[])
{
GtkWidget *window, *vbox, *radio1, *radio2, *radio3, *radio4;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Radio Buttons");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
/* Create three radio buttons where the second two join radio1's group. */
radio1 = gtk_radio_button_new_with_label (NULL, "I want to be clicked!");
radio2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1),
"Click me instead!");
radio3 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1),
"No! Click me!");
/* Note: The radio button you create the new widget from does not matter as
* long as it it already a member of the group! */
radio4 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio3),
"No! Click me instead!");
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (vbox), radio1, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), radio2, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), radio3, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), radio4, FALSE, FALSE, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
NedKeysigDialog::NedKeysigDialog(GtkWindow *parent, int key_signature_number) :
m_state(false), m_key_signature_number(key_signature_number) {
int i;
GtkWidget *dialog;
GtkWidget *key_frame;
GtkWidget *key_frame_left_vbox;
GtkWidget *key_frame_right_vbox;
GtkWidget *radio_hbox;
GtkWidget *adjust_frame;
dialog = gtk_dialog_new_with_buttons(_("New keysignature"), parent, (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
g_signal_connect(dialog, "response", G_CALLBACK (OnClose), (void *) this);
key_frame = gtk_frame_new(_("key"));
radio_hbox = gtk_hbox_new(FALSE, 2);
key_frame_left_vbox = gtk_vbox_new(FALSE, 2);
key_frame_right_vbox = gtk_vbox_new(FALSE, 2);
m_sig_radio_buttons[0] = gtk_radio_button_new_with_label (NULL, gettext(NedStaffContextDialog::m_keyTab[0]));
gtk_box_pack_start (GTK_BOX (key_frame_left_vbox), m_sig_radio_buttons[0], FALSE, FALSE, 0);
for (i = -5; i < 7; i++) {
m_sig_radio_buttons[i+6] = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (m_sig_radio_buttons[0]), gettext(NedStaffContextDialog::m_keyTab[i+6]));
if (i < 0) {
gtk_box_pack_start (GTK_BOX (key_frame_left_vbox), m_sig_radio_buttons[i+6], FALSE, FALSE, 0);
}
else {
gtk_box_pack_start (GTK_BOX (key_frame_right_vbox), m_sig_radio_buttons[i+6], FALSE, FALSE, 0);
}
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_sig_radio_buttons[m_key_signature_number+6]), TRUE);
gtk_box_pack_start (GTK_BOX (radio_hbox), key_frame_left_vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (radio_hbox), key_frame_right_vbox, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER(key_frame), radio_hbox);
adjust_frame = gtk_frame_new(_("adjust"));
m_adjust_check_box = gtk_check_button_new_with_label(_("adjust notes"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_adjust_check_box), TRUE);
gtk_container_add (GTK_CONTAINER(adjust_frame), m_adjust_check_box);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), key_frame);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), adjust_frame);
gtk_widget_show_all (dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
}
// TODO: some quality/compression stuff in case "off" is selected
void gui_init(dt_imageio_module_format_t *self)
{
dt_imageio_j2k_gui_t *gui = (dt_imageio_j2k_gui_t *)malloc(sizeof(dt_imageio_j2k_gui_t));
self->gui_data = (void *)gui;
self->widget = gtk_vbox_new(TRUE, 5);
GtkWidget *hbox = gtk_hbox_new(TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox, TRUE, TRUE, 0);
int format_last = dt_conf_get_int("plugins/imageio/format/j2k/format");
int preset_last = dt_conf_get_int("plugins/imageio/format/j2k/preset");
int quality_last = dt_conf_get_int("plugins/imageio/format/j2k/quality");
GtkWidget *radiobutton = gtk_radio_button_new_with_label(NULL, _("jp2"));
gui->jp2 = GTK_TOGGLE_BUTTON(radiobutton);
gtk_box_pack_start(GTK_BOX(hbox), radiobutton, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(radiobutton), "toggled", G_CALLBACK(radiobutton_changed), (gpointer)JP2_CFMT);
if(format_last == JP2_CFMT) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton), TRUE);
radiobutton = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radiobutton), _("j2k"));
gui->j2k = GTK_TOGGLE_BUTTON(radiobutton);
gtk_box_pack_start(GTK_BOX(hbox), radiobutton, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(radiobutton), "toggled", G_CALLBACK(radiobutton_changed), (gpointer)J2K_CFMT);
if(format_last == J2K_CFMT) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton), TRUE);
gui->quality = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 1, 100, 1, 97, 0));
dtgtk_slider_set_label(gui->quality,_("quality"));
dtgtk_slider_set_default_value(gui->quality, 97);
if(quality_last > 0 && quality_last <= 100)
dtgtk_slider_set_value(gui->quality, quality_last);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(gui->quality), TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (gui->quality), "value-changed", G_CALLBACK (quality_changed), (gpointer)0);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox, TRUE, TRUE, 0);
GtkWidget *label = gtk_label_new(_("dcp mode"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
GtkWidget *combo = gtk_combo_box_new_text();
gui->preset = GTK_COMBO_BOX(combo);
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("off"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("cinema2k, 24fps"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("cinema2k, 48fps"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("cinema4k, 24fps"));
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), preset_last);
gtk_box_pack_start(GTK_BOX(hbox), combo, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(combobox_changed), NULL);
// TODO: options for "off"
}
static gboolean
vfo_press_event_cb (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
if((int)event->x < (my_width/2)) {
lock_cb(NULL,NULL);
} else {
GtkWidget *dialog=gtk_dialog_new_with_buttons("Step",GTK_WINDOW(parent_window),GTK_DIALOG_DESTROY_WITH_PARENT,NULL,NULL);
GtkWidget *content=gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget *grid=gtk_grid_new();
gtk_grid_set_column_homogeneous(GTK_GRID(grid),TRUE);
gtk_grid_set_row_homogeneous(GTK_GRID(grid),TRUE);
GtkWidget *step_rb=NULL;
int i=0;
while(steps[i]!=0) {
if(i==0) {
step_rb=gtk_radio_button_new_with_label(NULL,step_labels[i]);
} else {
step_rb=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(step_rb),step_labels[i]);
}
gtk_widget_override_font(step_rb, pango_font_description_from_string("FreeMono 18"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (step_rb), steps[i]==step);
gtk_widget_show(step_rb);
gtk_grid_attach(GTK_GRID(grid),step_rb,i%5,i/5,1,1);
g_signal_connect(step_rb,"pressed",G_CALLBACK(vfo_step_select_cb),(gpointer *)i);
i++;
}
gtk_container_add(GTK_CONTAINER(content),grid);
GtkWidget *close_button=gtk_dialog_add_button(GTK_DIALOG(dialog),"Close",GTK_RESPONSE_OK);
gtk_widget_override_font(close_button, pango_font_description_from_string("FreeMono 18"));
gtk_widget_show_all(dialog);
g_signal_connect_swapped (dialog,
"response",
G_CALLBACK (gtk_widget_destroy),
dialog);
int result=gtk_dialog_run(GTK_DIALOG(dialog));
}
return TRUE;
}
// TODO: some quality/compression stuff?
void gui_init (dt_imageio_module_format_t *self)
{
dt_imageio_tiff_gui_t *gui = (dt_imageio_tiff_gui_t *)malloc(sizeof(dt_imageio_tiff_gui_t));
self->gui_data = (void *)gui;
int bpp = dt_conf_get_int("plugins/imageio/format/tiff/bpp");
self->widget = gtk_hbox_new(TRUE, 5);
GtkWidget *radiobutton = gtk_radio_button_new_with_label(NULL, _("8-bit"));
gui->b8 = GTK_TOGGLE_BUTTON(radiobutton);
gtk_box_pack_start(GTK_BOX(self->widget), radiobutton, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(radiobutton), "toggled", G_CALLBACK(radiobutton_changed), (gpointer)8);
if(bpp < 12) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton), TRUE);
radiobutton = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radiobutton), _("16-bit"));
gui->b16 = GTK_TOGGLE_BUTTON(radiobutton);
gtk_box_pack_start(GTK_BOX(self->widget), radiobutton, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(radiobutton), "toggled", G_CALLBACK(radiobutton_changed), (gpointer)16);
if(bpp >= 12) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton), TRUE);
}
