bool wxSpinCtrlGTKBase::Create(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos, const wxSize& size,
long style,
double min, double max, double initial, double inc,
const wxString& name)
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxSpinCtrlGTKBase creation failed") );
return false;
}
m_widget = gtk_spin_button_new_with_range(min, max, inc);
g_object_ref(m_widget);
gtk_spin_button_set_value( GTK_SPIN_BUTTON(m_widget), initial);
gfloat align;
if ( HasFlag(wxALIGN_RIGHT) )
align = 1.0;
else if ( HasFlag(wxALIGN_CENTRE) )
align = 0.5;
else
align = 0.0;
gtk_entry_set_alignment(GTK_ENTRY(m_widget), align);
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON(m_widget),
(int)(m_windowStyle & wxSP_WRAP) );
g_signal_connect_after(m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
g_signal_connect_after(m_widget, "changed", G_CALLBACK(gtk_changed), this);
m_parent->DoAddChild( this );
PostCreation(size);
if (!value.empty())
{
SetValue(value);
}
return true;
}
static GtkWidget *
grid_attach_spin_button_with_label (GtkWidget *grid, const gchar* text_label, gint left, gint top)
{
GtkWidget *label;
GtkWidget *spin_button;
label = gtk_label_new_with_mnemonic (text_label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
spin_button = gtk_spin_button_new_with_range (0, 100, 0.01);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spin_button), 2);
gtk_entry_set_width_chars (GTK_ENTRY (spin_button), 6);
gtk_grid_attach (GTK_GRID (grid), label, left, top, 1, 1);
gtk_grid_attach_next_to (GTK_GRID (grid), spin_button, label, GTK_POS_RIGHT, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
return spin_button;
}
static GtkWidget *create_spinbutton(GtkWidget *vbox, const char *name, double min, double max, double incr)
{
GtkWidget *frame, *hbox, *button;
frame = gtk_frame_new(name);
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 3);
gtk_container_add(GTK_CONTAINER(frame), hbox);
button = gtk_spin_button_new_with_range(min, max, incr);
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 0);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
return button;
}
void create_select_time(GtkWidget *frame,IS_SELECT *is_select)
{
GtkWidget *hbox;
GtkWidget *spin;
GtkWidget *label;
hbox=gtk_hbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(frame),hbox);
spin=gtk_spin_button_new_with_range(0,60,TRUE);
gtk_box_pack_start(GTK_BOX(hbox),spin,FALSE,FALSE,0);
label=gtk_label_new("Seconds");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(spin),"value_changed",
G_CALLBACK(set_timeout),is_select);
gtk_widget_show_all(frame);
}
// Create a spin button and label
static GtkWidget *labeled_spin_new(const gchar *text, double spin_from,
double spin_to, double spin_set,
GtkWidget **spin, GCallback func)
{
GtkWidget *hbox, *label;
hbox = gtk_hbox_new(FALSE, 4);
label = gtk_label_new(text);
gtk_misc_set_alignment(GTK_MISC(label), 1., 0.5);
*spin = gtk_spin_button_new_with_range(spin_from, spin_to, 1.);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(*spin), spin_set);
if (func)
g_signal_connect(*spin, "value-changed", G_CALLBACK(func),
NULL);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), *spin, FALSE, FALSE, 0);
return hbox;
}
static void
test_spin_button_arrows (void)
{
GtkWidget *window = gtk_test_create_simple_window ("Test Window", "Test: test_spin_button_arrows");
GtkWidget *spinner = gtk_spin_button_new_with_range (0, 100, 5);
gboolean simsuccess;
double oldval, newval;
gtk_container_add (GTK_CONTAINER (GTK_BIN (window)->child), spinner);
gtk_widget_show (spinner);
gtk_widget_show_now (window);
gtk_test_slider_set_perc (spinner, 0);
/* check initial spinner value */
oldval = gtk_test_slider_get_value (spinner);
g_assert (oldval == 0);
/* check simple increment */
simsuccess = gtk_test_spin_button_click (GTK_SPIN_BUTTON (spinner), 1, TRUE);
g_assert (simsuccess == TRUE);
while (gtk_events_pending ()) /* let spin button timeout/idle handlers update */
gtk_main_iteration ();
newval = gtk_test_slider_get_value (spinner);
g_assert (newval > oldval);
/* check maximum warp */
simsuccess = gtk_test_spin_button_click (GTK_SPIN_BUTTON (spinner), 3, TRUE);
g_assert (simsuccess == TRUE);
while (gtk_events_pending ()) /* let spin button timeout/idle handlers update */
gtk_main_iteration ();
oldval = gtk_test_slider_get_value (spinner);
g_assert (oldval == 100);
/* check simple decrement */
oldval = gtk_test_slider_get_value (spinner);
simsuccess = gtk_test_spin_button_click (GTK_SPIN_BUTTON (spinner), 1, FALSE);
g_assert (simsuccess == TRUE);
while (gtk_events_pending ()) /* let spin button timeout/idle handlers update */
gtk_main_iteration ();
newval = gtk_test_slider_get_value (spinner);
g_assert (newval < oldval);
/* check minimum warp */
simsuccess = gtk_test_spin_button_click (GTK_SPIN_BUTTON (spinner), 3, FALSE);
g_assert (simsuccess == TRUE);
while (gtk_events_pending ()) /* let spin button timeout/idle handlers update */
gtk_main_iteration ();
oldval = gtk_test_slider_get_value (spinner);
g_assert (oldval == 0);
}
static struct gopt *gopt_new_str_val(struct gopt_job_view *gjv,
struct fio_option *o,
unsigned long long *p, unsigned int idx)
{
struct gopt_str_val *g;
const gchar *postfix[] = { "B", "KB", "MB", "GB", "PB", "TB", "" };
GtkWidget *label;
int i;
g = calloc(1, sizeof(*g));
g->gopt.box = gtk_hbox_new(FALSE, 3);
if (!o->lname)
label = gtk_label_new(o->name);
else
label = gtk_label_new(o->lname);
gopt_mark_index(gjv, &g->gopt, idx, GOPT_STR_VAL);
g->spin = gtk_spin_button_new_with_range(0.0, 1023.0, 1.0);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(g->spin), GTK_UPDATE_IF_VALID);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->spin), 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(g->spin), 1);
gtk_box_pack_start(GTK_BOX(g->gopt.box), g->spin, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(g->spin), "wrapped", G_CALLBACK(gopt_str_val_spin_wrapped), g);
g_signal_connect(G_OBJECT(g->spin), "changed", G_CALLBACK(gopt_str_val_changed), g);
g->combo = gtk_combo_box_text_new();
i = 0;
while (strlen(postfix[i])) {
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(g->combo), postfix[i]);
i++;
}
g->maxindex = i - 1;
gtk_combo_box_set_active(GTK_COMBO_BOX(g->combo), 0);
gtk_box_pack_start(GTK_BOX(g->gopt.box), g->combo, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(g->gopt.box), label, FALSE, FALSE, 3);
if (p)
gopt_str_val_set_val(g, *p);
g_signal_connect(G_OBJECT(g->combo), "changed", G_CALLBACK(gopt_str_val_changed), g);
g_signal_connect(G_OBJECT(g->gopt.box), "destroy", G_CALLBACK(gopt_str_val_destroy), g);
return &g->gopt;
}
static GtkContainer *
mh_get_setup_page( XfceMailwatchMailbox *mailbox )
{
XfceMailwatchMHMailbox *mh = XFCE_MAILWATCH_MH_MAILBOX( mailbox );
GtkWidget *vbox, *hbox;
GtkWidget *label, *spinner;
vbox = gtk_vbox_new( FALSE, BORDER );
gtk_widget_show( vbox );
hbox = gtk_hbox_new( FALSE, BORDER );
gtk_widget_show( hbox );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
label = gtk_label_new( _( "The configuration of this plugin is read from\n"
"the default mh maildir profile file ~/.mh_profile" ) );
gtk_widget_show( label );
gtk_box_pack_start( GTK_BOX( hbox ), label, FALSE, FALSE, 0 );
hbox = gtk_hbox_new( FALSE, BORDER );
gtk_widget_show( hbox );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
label = gtk_label_new_with_mnemonic( _( "_Interval:" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 );
gtk_box_pack_start( GTK_BOX( hbox ), label, FALSE, FALSE, 0 );
spinner = gtk_spin_button_new_with_range( 1.0, 1440.0, 1.0 );
gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( spinner ), TRUE );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( spinner ), FALSE );
gtk_spin_button_set_value( GTK_SPIN_BUTTON( spinner ), mh->timeout / 60 );
gtk_widget_show( spinner );
gtk_box_pack_start( GTK_BOX( hbox ), spinner, FALSE, FALSE, 0 );
g_signal_connect( G_OBJECT( spinner ), "value-changed",
G_CALLBACK( mh_timeout_changed_cb ), mh );
gtk_label_set_mnemonic_widget( GTK_LABEL( label ), spinner );
label = gtk_label_new( _( "minute(s)." ) );
gtk_widget_show( label );
gtk_box_pack_start( GTK_BOX( hbox ), label, FALSE, FALSE, 0 );
return ( GTK_CONTAINER( vbox ) );
}
static void
gog_polynom_reg_curve_populate_editor (GogRegCurve *reg_curve, gpointer table)
{
GtkWidget *l, *w;
GogLinRegCurve *lin = GOG_LIN_REG_CURVE (reg_curve);
((GogRegCurveClass*) gog_polynom_reg_curve_parent_klass)->populate_editor (reg_curve, table);
l = gtk_label_new (_("Order:"));
gtk_misc_set_alignment (GTK_MISC (l), 0., 0.5);
gtk_label_set_justify (GTK_LABEL (l), GTK_JUSTIFY_LEFT);
gtk_widget_show (l);
gtk_grid_attach_next_to (table, l, NULL, GTK_POS_BOTTOM, 1, 1);
w = gtk_spin_button_new_with_range (2, 10, 1);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (w), 0);
gtk_widget_show (w);
gtk_grid_attach_next_to (table, w, l, GTK_POS_RIGHT, 1, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), lin->dims);
g_signal_connect (G_OBJECT (w), "value-changed", G_CALLBACK (order_changed_cb), lin);
}
GtkWidget *
gconf_edit_int(gconf_block *b, xconf *xc, int min, int max)
{
gint i = 0;
GtkWidget *w;
xconf_get_int(xc, &i);
xconf_set_int(xc, i);
w = gtk_spin_button_new_with_range((gdouble) min, (gdouble) max, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), (gdouble) i);
g_signal_connect(G_OBJECT(w), "value-changed",
G_CALLBACK(gconf_edit_int_cb), xc);
if (b && b->cb)
{
g_signal_connect_swapped(G_OBJECT(w), "value-changed",
G_CALLBACK(b->cb), b);
}
return w;
}
static GtkWidget* property_item_int_real_create_widget (PropertyItem* base) {
PropertyItemInt * self;
GtkWidget* result = NULL;
gint _tmp0_;
gint _tmp1_;
GtkSpinButton* _tmp2_;
GtkSpinButton* _tmp3_;
GtkSpinButton* intSpinButton;
gint _tmp4_;
self = (PropertyItemInt*) base;
_tmp0_ = G_MININT;
_tmp1_ = G_MAXINT;
_tmp2_ = (GtkSpinButton*) gtk_spin_button_new_with_range ((gdouble) _tmp0_, (gdouble) _tmp1_, (gdouble) 1);
_tmp3_ = g_object_ref_sink (_tmp2_);
intSpinButton = _tmp3_;
_tmp4_ = self->data;
gtk_spin_button_set_value (intSpinButton, (gdouble) _tmp4_);
result = (GtkWidget*) intSpinButton;
return result;
}
static GtkWidget* property_item_double_real_create_widget (PropertyItem* base) {
PropertyItemDouble * self;
GtkWidget* result = NULL;
gdouble _tmp0_;
gdouble _tmp1_;
GtkSpinButton* _tmp2_;
GtkSpinButton* _tmp3_;
GtkSpinButton* doubleSpinButton;
gdouble _tmp4_;
self = (PropertyItemDouble*) base;
_tmp0_ = DBL_MIN;
_tmp1_ = DBL_MAX;
_tmp2_ = (GtkSpinButton*) gtk_spin_button_new_with_range (_tmp0_, _tmp1_, (gdouble) 1);
_tmp3_ = g_object_ref_sink (_tmp2_);
doubleSpinButton = _tmp3_;
_tmp4_ = self->data;
gtk_spin_button_set_value (doubleSpinButton, _tmp4_);
result = (GtkWidget*) doubleSpinButton;
return result;
}
void QuerySidesDialog::populateWindow()
{
// Create the vbox containing the notebook and the buttons
GtkWidget* dialogVBox = gtk_vbox_new(FALSE, 6);
// Create the spin button
_entry = gtk_spin_button_new_with_range(_numSidesMin, _numSidesMax, 1);
GtkWidget* entryRow = gtk_hbox_new(FALSE, 6);
GtkWidget* label = gtkutil::LeftAlignedLabel(_("Number of sides: "));
gtk_box_pack_start(GTK_BOX(entryRow), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(entryRow), _entry, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(dialogVBox), entryRow, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(dialogVBox), createButtons(), FALSE, FALSE, 0);
// Add vbox to dialog window
gtk_container_add(GTK_CONTAINER(getWindow()), dialogVBox);
}
static GtkWidget* property_item_double_real_create_widget (PropertyItem* base) {
PropertyItemDouble * self;
GtkWidget* result = NULL;
GtkSpinButton* doubleSpinButton = NULL;
gdouble _tmp0_ = 0.0;
gdouble _tmp1_ = 0.0;
GtkSpinButton* _tmp2_ = NULL;
gdouble _tmp3_ = 0.0;
self = (PropertyItemDouble*) base;
_tmp0_ = self->priv->min;
_tmp1_ = self->priv->max;
_tmp2_ = (GtkSpinButton*) gtk_spin_button_new_with_range (_tmp0_, _tmp1_, (gdouble) 1);
g_object_ref_sink (_tmp2_);
doubleSpinButton = _tmp2_;
_tmp3_ = self->data;
gtk_spin_button_set_value (doubleSpinButton, _tmp3_);
gtk_spin_button_set_digits (doubleSpinButton, (guint) 10);
gtk_spin_button_set_snap_to_ticks (doubleSpinButton, FALSE);
result = (GtkWidget*) doubleSpinButton;
return result;
}
/**
* g_paste_settings_ui_panel_add_range_setting:
* @self: a #GPasteSettingsUiPanel instance
* @label: the label to display
* @value: the deafault value
* @min: the minimal authorized value
* @max: the maximal authorized value
* @step: the step between proposed values
* @on_value_changed: (closure user_data) (scope notified): the callback to call when the value changes
*
* Add a new boolean settings to the current pane
*
* Returns: (transfer none): the #GtkSpinButton we just added
*/
G_PASTE_VISIBLE GtkSpinButton *
g_paste_settings_ui_panel_add_range_setting (GPasteSettingsUiPanel *self,
const gchar *label,
gdouble value,
gdouble min,
gdouble max,
gdouble step,
GPasteRangeCallback on_value_changed,
gpointer user_data)
{
GtkLabel *button_label = g_paste_settings_ui_panel_add_label (self, label);
GtkWidget *button = gtk_spin_button_new_with_range (min, max, step);
GtkSpinButton *b = GTK_SPIN_BUTTON (button);
CALLBACK_DATA_DEFAULT (button)
gtk_spin_button_set_value (b, value);
_data->signal = g_signal_connect (button, "value-changed", G_CALLBACK (range_wrapper), data);
gtk_grid_attach_next_to (GTK_GRID (self), button, GTK_WIDGET (button_label), GTK_POS_RIGHT, 1, 1);
return b;
}
void diaElemUInteger::setMe(void *dialog, void *opaque,uint32_t line)
{
GtkWidget *widget;
GtkWidget *label;
label = gtk_label_new_with_mnemonic (paramTitle);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show(label);
gtk_table_attach (GTK_TABLE (opaque), label, 0, 1, line, line+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
uint32_t val=*(uint32_t *)param;
widget = gtk_spin_button_new_with_range(min,max,1);
gtk_entry_set_activates_default (GTK_ENTRY(widget), TRUE);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON(widget),TRUE);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON(widget),0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(widget),val);
gtk_widget_show (widget);
gtk_table_attach (GTK_TABLE (opaque), widget, 1, 2, line, line+1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL(label), widget);
myWidget=(void *)widget;
if(tip)
{
GtkTooltips *tooltips= gtk_tooltips_new ();
gtk_tooltips_set_tip (tooltips, widget, tip, NULL);
}
if(readOnly)
gtk_widget_set_sensitive(widget,0);
}
NedInsertBlockDialog::NedInsertBlockDialog(GtkWindow *parent) {
GtkWidget *dialog;
GtkWidget *lab;
GtkWidget *hbox;
dialog = gtk_dialog_new_with_buttons(_("Insert blocks"), 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 (CloseCallBack), (void *) this);
m_block_spin_box = gtk_spin_button_new_with_range (1.0, 20.0, 1.0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(m_block_spin_box), 1.0);
lab = gtk_label_new(_("block count:"));
hbox = gtk_hbox_new(FALSE, 8);
gtk_box_pack_start(GTK_BOX(hbox), lab, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), m_block_spin_box, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), hbox);
gtk_widget_show_all (dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
}
//タブ幅を設定する
void set_tab_width(void)
{
GtkWidget *tab_dialog = gtk_dialog_new_with_buttons("タブ", GTK_WINDOW(main_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
GtkWidget *tab_hbox = gtk_hbox_new(FALSE, 2);
GtkWidget *tab_label = gtk_label_new("新しいタブの幅 : ");
GtkWidget *tab_button = gtk_spin_button_new_with_range(1, 31, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab_button), state & width_mask);
gtk_box_pack_start(GTK_BOX(tab_hbox), tab_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(tab_hbox), tab_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(tab_dialog)->vbox), tab_hbox, FALSE, FALSE, 0);
gtk_entry_set_activates_default(GTK_ENTRY(tab_button), TRUE);
gtk_dialog_set_default_response(GTK_DIALOG(tab_dialog), GTK_RESPONSE_OK);
gtk_widget_show_all(tab_dialog);
if (gtk_dialog_run(GTK_DIALOG(tab_dialog)) == GTK_RESPONSE_OK) {
state &= ~width_mask;
state |= gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(tab_button));
gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(view), state & width_mask);
}
gtk_widget_destroy(tab_dialog);
}
static void renumber_dialog(GtkWidget *w, gpointer data)
{
int result;
struct dive *dive;
GtkWidget *dialog, *frame, *button, *vbox;
dialog = gtk_dialog_new_with_buttons("Renumber",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
frame = gtk_frame_new("New starting number");
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
button = gtk_spin_button_new_with_range(1, 50000, 1);
gtk_container_add(GTK_CONTAINER(frame), button);
/*
* Do we have a number for the first dive already? Use that
* as the default.
*/
dive = get_dive(0);
if (dive && dive->number)
gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), dive->number);
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT) {
int nr = gtk_spin_button_get_value(GTK_SPIN_BUTTON(button));
renumber_dives(nr);
repaint_dive();
}
gtk_widget_destroy(dialog);
}
bool wxSpinButton::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
m_needParent = true;
wxSize new_size = size,
sizeBest = DoGetBestSize();
new_size.x = sizeBest.x; // override width always
if (new_size.y == -1)
new_size.y = sizeBest.y;
if (!PreCreation( parent, pos, new_size ) ||
!CreateBase( parent, id, pos, new_size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxSpinButton creation failed") );
return false;
}
m_pos = 0;
m_widget = gtk_spin_button_new_with_range(0, 100, 1);
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON(m_widget),
(int)(m_windowStyle & wxSP_WRAP) );
g_signal_connect_after(
m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
m_parent->DoAddChild( this );
PostCreation(new_size);
return true;
}
static void facq_baf_view_dialog_constructed(GObject *self)
{
FacqBAFViewDialog *dialog = FACQ_BAF_VIEW_DIALOG(self);
GtkWidget *vbox = NULL, *table = NULL, *widget = NULL;
dialog->priv->dialog =
gtk_dialog_new_with_buttons(_("Page preferences"),
GTK_WINDOW(dialog->priv->top_window),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,GTK_RESPONSE_OK,NULL);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog->priv->dialog));
table = gtk_table_new(1,3,FALSE);
widget = gtk_label_new(_("Time per page:"));
gtk_label_set_justify(GTK_LABEL(widget),GTK_JUSTIFY_LEFT);
gtk_table_attach_defaults(GTK_TABLE(table),widget,0,1,0,1);
widget = gtk_spin_button_new_with_range(5,86400,1);
gtk_entry_set_icon_from_stock(GTK_ENTRY(widget),GTK_ENTRY_ICON_PRIMARY,GTK_STOCK_CLEAR);
gtk_spin_button_set_increments(GTK_SPIN_BUTTON(widget),1,10);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(widget),0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),10);
g_signal_connect(GTK_ENTRY(widget),"icon-press",
G_CALLBACK(clear_icon_callback),dialog);
dialog->priv->spin_button = widget;
gtk_table_attach_defaults(GTK_TABLE(table),widget,0,1,1,2);
widget = gtk_label_new(_(" seconds"));
gtk_label_set_justify(GTK_LABEL(widget),GTK_JUSTIFY_LEFT);
gtk_table_attach_defaults(GTK_TABLE(table),widget,0,1,2,3);
gtk_widget_show_all(table);
gtk_container_add(GTK_CONTAINER(vbox),table);
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE arg1, arg2, arg3;
GtkAdjustment *adj = NULL;
gfloat climb_rate;
gint digits;
GtkWidget *widget;
rb_scan_args(argc, argv, "03", &arg1, &arg2, &arg3);
if (NIL_P(arg1) || RVAL2GTYPE(arg1) == GTK_TYPE_ADJUSTMENT){
if (!NIL_P(arg1)) adj = GTK_ADJUSTMENT(RVAL2GOBJ(arg1));
climb_rate = (NIL_P(arg2))? 0.0: NUM2DBL(arg2);
digits = (NIL_P(arg3))? 0: NUM2UINT(arg3);
widget = gtk_spin_button_new(adj, climb_rate, digits);
} else {
widget = gtk_spin_button_new_with_range(NUM2DBL(arg1),
NUM2DBL(arg2), NUM2DBL(arg3));
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
bool wxSpinCtrl::Create(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos, const wxSize& size,
long style,
int min, int max, int initial,
const wxString& name)
{
m_needParent = true;
m_acceptsFocus = true;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxSpinCtrl creation failed") );
return false;
}
m_widget = gtk_spin_button_new_with_range(min, max, 1);
gtk_spin_button_set_value( GTK_SPIN_BUTTON(m_widget), initial);
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON(m_widget),
(int)(m_windowStyle & wxSP_WRAP) );
g_signal_connect_after(m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
g_signal_connect_after(m_widget, "changed", G_CALLBACK(gtk_changed), this);
m_parent->DoAddChild( this );
PostCreation(size);
if (!value.empty())
{
SetValue(value);
}
return true;
}
static GtkWidget *
relativeTimeCriteriaCreateWidget (gboolean *constrain)
{
GtkBox *box;
GtkWidget *timeSpin;
GtkWidget *timeOption;
box = GTK_BOX (gtk_hbox_new (FALSE, 6));
timeSpin = gtk_spin_button_new_with_range (1.0, G_MAXINT, 1.0);
gtk_box_pack_start (box, timeSpin, TRUE, TRUE, 0);
timeOption = create_time_unit_option_menu (time_unit_options, G_N_ELEMENTS (time_unit_options));
gtk_combo_box_set_active (GTK_COMBO_BOX (timeOption), time_unit_options_default);
gtk_box_pack_start (box, timeOption, TRUE, TRUE, 0);
g_signal_connect_object (timeOption, "changed",
G_CALLBACK (update_time_unit_limits),
timeSpin, 0);
gtk_widget_show_all (GTK_WIDGET (box));
return GTK_WIDGET (box);
}
static void mixer_configure (void)
{
if (config_win)
{
gtk_window_present ((GtkWindow *) config_win);
return;
}
config_win = gtk_dialog_new_with_buttons (_("Channel Mixer Settings"), 0, 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
gtk_window_set_resizable ((GtkWindow *) config_win, 0);
GtkWidget * vbox = gtk_dialog_get_content_area ((GtkDialog *) config_win);
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, 0, 0, 0);
GtkWidget * label = gtk_label_new (_("Output channels:"));
gtk_box_pack_start ((GtkBox *) hbox, label, 0, 0, 0);
GtkWidget * spin = gtk_spin_button_new_with_range (1, MAX_CHANNELS, 1);
gtk_spin_button_set_value ((GtkSpinButton *) spin, mixer_channels);
gtk_box_pack_start ((GtkBox *) hbox, spin, 0, 0, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, 0, 0, 0);
label = gtk_label_new (_("Changes take effect at the next song change."));
gtk_box_pack_start ((GtkBox *) hbox, label, 0, 0, 0);
g_signal_connect (config_win, "response", (GCallback) gtk_widget_destroy, 0);
g_signal_connect (config_win, "destroy", (GCallback) gtk_widget_destroyed, & config_win);
g_signal_connect (spin, "value-changed", (GCallback) spin_changed, & mixer_channels);
gtk_widget_show_all (config_win);
}
void diaElemFloat::setMe(void *dialog, void *opaque,uint32_t line)
{
GtkWidget *widget;
GtkObject *adj;
GtkWidget *label;
label = gtk_label_new_with_mnemonic (paramTitle);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show(label);
gtk_table_attach (GTK_TABLE (opaque), label, 0, 1, line, line+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
ELEM_TYPE_FLOAT val=*(ELEM_TYPE_FLOAT *)param;
widget = gtk_spin_button_new_with_range(min,max,0.1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON(widget),TRUE);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON(widget),3);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(widget),*(ELEM_TYPE_FLOAT *)param);
gtk_widget_show (widget);
gtk_table_attach (GTK_TABLE (opaque), widget, 1, 2, line, line+1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL(label), widget);
myWidget=(void *)widget;
if(tip)
{
GtkTooltips *tooltips= gtk_tooltips_new ();
gtk_tooltips_set_tip (tooltips, widget, tip, NULL);
}
}
bool wxSpinButton::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
if (!PreCreation(parent, pos, size) ||
!CreateBase(parent, id, pos, size, style, wxDefaultValidator, name))
{
wxFAIL_MSG( wxT("wxSpinButton creation failed") );
return false;
}
m_pos = 0;
m_widget = gtk_spin_button_new_with_range(0, 100, 1);
g_object_ref(m_widget);
gtk_entry_set_width_chars(GTK_ENTRY(m_widget), 0);
#if GTK_CHECK_VERSION(3,12,0)
if (gtk_check_version(3,12,0) == NULL)
gtk_entry_set_max_width_chars(GTK_ENTRY(m_widget), 0);
#endif
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON(m_widget),
(int)(m_windowStyle & wxSP_WRAP) );
g_signal_connect_after(
m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
static void on_insert_numbers_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED
gpointer gdata)
{
InsertNumbersDialog d;
GtkWidget *vbox, *label, *upper, *space, *button;
GtkGrid *grid;
GtkComboBoxText *combo;
const char *case_tip = _("For base 11 and above");
gchar *base_text;
gint result;
d.dialog = gtk_dialog_new_with_buttons(_("Insert Numbers"),
GTK_WINDOW(geany->main_widgets->window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
vbox = ui_dialog_vbox_new(GTK_DIALOG(d.dialog));
gtk_box_set_spacing(GTK_BOX(vbox), 9);
#if GTK_CHECK_VERSION(3, 0, 0)
grid = GTK_GRID(gtk_grid_new());
#else
grid = GTK_TABLE(gtk_table_new(3, 6, FALSE));
#endif
gtk_grid_set_row_spacing(grid, 6);
gtk_grid_set_column_spacing(grid, 6);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(grid), TRUE, TRUE, 0);
label = gtk_label_new_with_mnemonic(_("_Start:"));
gtk_grid_attach(grid, label, 0, 0, 1, 1);
d.start = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1);
set_entry(d.start, RANGE_LEN, label, RANGE_TOOLTIP);
gtk_grid_attach(grid, d.start, 1, 0, 2, 1);
label = gtk_label_new_with_mnemonic(_("S_tep:"));
gtk_grid_attach(grid, label, 3, 0, 1, 1);
d.step = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1);
set_entry(d.step, RANGE_LEN, label, RANGE_TOOLTIP);
gtk_grid_attach(grid, d.step, 4, 0, 2, 1);
label = gtk_label_new_with_mnemonic(_("_Base:"));
gtk_grid_attach(grid, label, 0, 1, 1, 1),
combo = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new_with_entry());
d.base = gtk_bin_get_child(GTK_BIN(combo));
set_entry(d.base, 2, label, "2..36");
g_signal_connect(d.base, "insert-text", G_CALLBACK(on_base_insert_text), NULL);
gtk_combo_box_text_append_text(combo, "2");
gtk_combo_box_text_append_text(combo, "8");
gtk_combo_box_text_append_text(combo, "10");
gtk_combo_box_text_append_text(combo, "16");
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_grid_attach(grid, GTK_WIDGET(combo), 1, 1, 2, 1);
gtk_widget_set_hexpand(GTK_WIDGET(combo), TRUE);
#else
gtk_table_attach(grid, GTK_WIDGET(combo), 1, 3, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0);
#endif
label = gtk_label_new(_("Letters:"));
gtk_widget_set_tooltip_text(label, case_tip);
gtk_grid_attach(grid, label, 3, 1, 1, 1);
upper = gtk_radio_button_new_with_mnemonic(NULL, _("_Upper"));
gtk_widget_set_tooltip_text(upper, case_tip);
gtk_grid_attach(grid, upper, 4, 1, 1, 1);
d.lower = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(upper));
gtk_widget_set_tooltip_text(label, case_tip);
label = gtk_label_new_with_mnemonic(_("_Lower"));
gtk_widget_set_tooltip_text(label, case_tip);
gtk_container_add(GTK_CONTAINER(d.lower), label);
gtk_grid_attach(grid, d.lower, 5, 1, 1, 1);
d.prefix = gtk_check_button_new_with_mnemonic(_("Base _prefix"));
gtk_widget_set_tooltip_text(d.prefix,
_("0 for octal, 0x for hex, + for positive decimal"));
gtk_grid_attach(grid, d.prefix, 1, 2, 2, 1);
label = gtk_label_new(_("Padding:"));
gtk_grid_attach(grid, label, 3, 2, 1, 1);
space = gtk_radio_button_new_with_mnemonic(NULL, _("Sp_ace"));
gtk_grid_attach(grid, space, 4, 2, 1, 1);
d.zero = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(space));
label = gtk_label_new_with_mnemonic(_("_Zero"));
gtk_container_add(GTK_CONTAINER(d.zero), label);
gtk_grid_attach(grid, d.zero, 5, 2, 1, 1);
button = gtk_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect(button, "clicked", G_CALLBACK(on_insert_numbers_ok_clicked), &d);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(d.dialog))), button,
TRUE, TRUE, 0);
#if GTK_CHECK_VERSION(2, 18, 0)
gtk_widget_set_can_default(button, TRUE);
#else
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
#endif
gtk_widget_grab_default(button);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.start), start_value);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.step), step_value);
base_text = g_strdup_printf("%d", base_value);
gtk_entry_set_text(GTK_ENTRY(d.base), base_text);
g_free(base_text);
gtk_button_clicked(GTK_BUTTON(lower_case ? d.lower : upper));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d.prefix), base_prefix);
gtk_button_clicked(GTK_BUTTON(pad_zeros ? d.zero : space));
gtk_widget_show_all(d.dialog);
result = gtk_dialog_run(GTK_DIALOG(d.dialog));
if (result == GTK_RESPONSE_ACCEPT)
{
if (can_insert_numbers())
{
if (end_line - start_line < 1000)
{
/* quick version */
gtk_widget_hide(d.dialog);
insert_numbers(NULL);
}
else
{
gboolean cancel = FALSE;
gtk_widget_set_sensitive(GTK_WIDGET(grid), FALSE);
gtk_widget_set_sensitive(button, FALSE);
update_display();
g_signal_connect(d.dialog, "response",
G_CALLBACK(on_insert_numbers_response), &cancel);
insert_numbers(&cancel);
}
}
else
plugin_beep(); /* reloaded or something */
}
gtk_widget_destroy(d.dialog);
}
static void ug_proxy_form_std_init (UgProxyForm* pform)
{
GtkGrid* grid;
GtkWidget* widget;
GtkWidget* hbox;
pform->changed.host = FALSE;
pform->changed.port = FALSE;
pform->changed.user = FALSE;
pform->changed.password = FALSE;
pform->std = gtk_grid_new ();
grid = (GtkGrid*) pform->std;
// host label & entry
widget = gtk_label_new_with_mnemonic (_("Host:"));
pform->host = gtk_entry_new ();
gtk_entry_set_width_chars (GTK_ENTRY (pform->host), 8);
gtk_entry_set_activates_default (GTK_ENTRY (pform->host), TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), pform->host);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
g_object_set (pform->host, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 0, 0, 1, 1);
gtk_grid_attach (grid, pform->host, 1, 0, 1, 1);
// port label & entry
widget = gtk_label_new_with_mnemonic (_("Port:"));
pform->port = gtk_spin_button_new_with_range (0.0, 65535.0, 1.0);
gtk_entry_set_width_chars (GTK_ENTRY (pform->port), 5);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), pform->port);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), pform->port, FALSE, FALSE, 0);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
g_object_set (hbox, "margin", 1, NULL);
gtk_grid_attach (grid, widget, 0, 1, 1, 1);
gtk_grid_attach (grid, hbox, 1, 1, 1, 1);
// center separator
widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
g_object_set (widget, "margin", 1, NULL);
gtk_grid_attach (grid, widget, 2, 0, 1, 2);
// user label & entry
widget = gtk_label_new_with_mnemonic (_("User:"******"margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
g_object_set (pform->user, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 3, 0, 1, 1);
gtk_grid_attach (grid, pform->user, 4, 0, 1, 1);
// password label & entry
widget = gtk_label_new_with_mnemonic (_("Password:"******"margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
g_object_set (pform->password, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 3, 1, 1, 1);
gtk_grid_attach (grid, pform->password, 4, 1, 1, 1);
g_signal_connect (GTK_EDITABLE (pform->user), "changed",
G_CALLBACK (on_entry_std_changed), pform);
g_signal_connect (GTK_EDITABLE (pform->password), "changed",
G_CALLBACK (on_entry_std_changed), pform);
g_signal_connect (GTK_EDITABLE (pform->host), "changed",
G_CALLBACK (on_entry_std_changed), pform);
g_signal_connect (GTK_EDITABLE (pform->port), "changed",
G_CALLBACK (on_entry_std_changed), pform);
gtk_widget_show_all (pform->std);
}
void
grg_pref_dialog (GtkWidget * parent)
{
GtkWidget *prefs, *notebook, *tab1, *tab2, *tab3;
GtkWidget *frame1, *frame2, *frame3;
GtkWidget *crypt_box, *hash_box, *comp_box;
GtkWidget *frame_font;
GtkWidget *frame_file, *but_file, *box_file, *but_file_clear;
GtkWidget *frame_save, *box_save;
GtkWidget *frame_misc, *box_misc;
GtkWidget *frame_xpire, *box_xpire, *xpire_lbl;
GtkWidget *frame_passes, *box_passes, *lbl_passes;
GtkWidget *frame_clip, *box_clip;
gint response;
PangoFontDescription *fdesc;
if (active_flag)
return;
prefs = gtk_dialog_new_with_buttons (_("Preferences"),
GTK_WINDOW (parent),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_APPLY,
GTK_RESPONSE_APPLY,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, NULL);
//first page: algorithms
tab1 = gtk_table_new (3, 2, FALSE);
frame1 = gtk_frame_new (_("Encryption"));
gtk_table_attach_defaults (GTK_TABLE (tab1), frame1, 0, 1, 0, 3);
crypt_box = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame1), crypt_box);
NEW_RADIO_BUTTON (rij1_but, NULL, modify_crypto, GRG_AES,
"AES (Rijndael 128)", crypt_box);
NEW_RADIO_BUTTON (ser_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_SERPENT, "Serpent", crypt_box);
NEW_RADIO_BUTTON (twof_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_TWOFISH, "Twofish", crypt_box);
NEW_RADIO_BUTTON (cast_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_CAST_256, "Cast 256", crypt_box);
NEW_RADIO_BUTTON (safer_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_SAFERPLUS, "Safer+", crypt_box);
NEW_RADIO_BUTTON (loki_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_LOKI97, "Loki97", crypt_box);
NEW_RADIO_BUTTON (tdes_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_3DES, "3-DES", crypt_box);
NEW_RADIO_BUTTON (rij2_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_RIJNDAEL_256, "Rijndael 256",
crypt_box);
NEW_ROW_SEPARATOR (crypt_box);
NEW_LABEL (crypto_block_lbl, crypt_box, "");
NEW_LABEL (crypto_key_lbl, crypt_box, "");
update_crypto_label ();
frame2 = gtk_frame_new (_("Hashing"));
gtk_table_attach_defaults (GTK_TABLE (tab1), frame2, 1, 2, 0, 1);
hash_box = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame2), hash_box);
NEW_RADIO_BUTTON (sha_but, NULL, modify_hash, GRG_SHA1, "SHA1",
hash_box);
NEW_RADIO_BUTTON (ripe_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(sha_but)), modify_hash,
GRG_RIPEMD_160, "RIPEMD 160", hash_box);
frame3 = gtk_frame_new (_("Compression"));
gtk_table_attach_defaults (GTK_TABLE (tab1), frame3, 1, 2, 1, 2);
comp_box = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame3), comp_box);
NEW_RADIO_BUTTON (zlib_but, NULL, modify_comp, GRG_ZLIB, "ZLib",
comp_box);
NEW_RADIO_BUTTON (bz_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(zlib_but)),
modify_comp, GRG_BZIP, "BZip2", comp_box);
NEW_ROW_SEPARATOR (comp_box);
NEW_RADIO_BUTTON (r0_but, NULL, modify_ratio, GRG_LVL_NONE, _("None"),
comp_box);
NEW_RADIO_BUTTON (r3_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(r0_but)), modify_ratio,
GRG_LVL_FAST, _("Fast"), comp_box);
NEW_RADIO_BUTTON (r6_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(r0_but)), modify_ratio,
GRG_LVL_GOOD, _("Good"), comp_box);
NEW_RADIO_BUTTON (r9_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(r0_but)), modify_ratio,
GRG_LVL_BEST, _("Best"), comp_box);
notebook = gtk_notebook_new ();
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab1,
gtk_label_new (_("Algorithms")));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (prefs)->vbox), notebook,
TRUE, TRUE, GRG_PAD);
//second page: General options
tab2 = gtk_vbox_new (FALSE, GRG_PAD);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab2,
gtk_label_new (_("General options")));
frame_font = gtk_frame_new (_("Editor font"));
gtk_box_pack_start (GTK_BOX (tab2), frame_font, FALSE, TRUE, 1);
but_font =
gtk_button_new_with_label (_
("Click to change the editor font"));
gtk_container_add (GTK_CONTAINER (frame_font), but_font);
fdesc = pango_font_description_from_string (grg_prefs_editor_font);
gtk_widget_modify_font (but_font, fdesc);
g_free (fdesc);
g_signal_connect (G_OBJECT (but_font), "clicked",
G_CALLBACK (modify_font), prefs);
frame_misc = gtk_frame_new (_("Decorations"));
gtk_box_pack_start (GTK_BOX (tab2), frame_misc, FALSE, TRUE, 1);
box_misc = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_misc), box_misc);
NEW_ROW_SEPARATOR (tab2);
splash_check = gtk_check_button_new_with_label (_("Splash screen"));
g_signal_connect (G_OBJECT (splash_check), "toggled",
G_CALLBACK (modify_splash), NULL);
gtk_box_pack_start (GTK_BOX (box_misc), splash_check, FALSE, TRUE, 1);
frame_file = gtk_frame_new (_("File to open at startup"));
gtk_box_pack_start (GTK_BOX (tab2), frame_file, FALSE, TRUE, 1);
box_file = gtk_hbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_file), box_file);
file_entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (box_file), file_entry, FALSE, TRUE, 1);
but_file = gtk_button_new_from_stock (GTK_STOCK_OPEN);
gtk_box_pack_start (GTK_BOX (box_file), but_file, FALSE, TRUE, 1);
g_signal_connect (G_OBJECT (but_file), "clicked",
G_CALLBACK (meta_open_startup_file),
(gpointer) prefs);
but_file_clear = gtk_button_new_from_stock (GTK_STOCK_CLEAR);
gtk_box_pack_start (GTK_BOX (box_file), but_file_clear, FALSE, TRUE,
1);
g_signal_connect (G_OBJECT (but_file_clear), "clicked",
G_CALLBACK (clear_file), NULL);
frame_save = gtk_frame_new (_("File saving"));
gtk_box_pack_start (GTK_BOX (tab2), frame_save, FALSE, TRUE, 1);
box_save = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_save), box_save);
bak_check =
gtk_check_button_new_with_label (_("Make backups of files"));
g_signal_connect (G_OBJECT (bak_check), "toggled",
G_CALLBACK (modify_bak), NULL);
gtk_box_pack_start (GTK_BOX (box_save), bak_check, FALSE, TRUE, 1);
over_check =
gtk_check_button_new_with_label (_
("Ask when overwriting files"));
g_signal_connect (G_OBJECT (over_check), "toggled",
G_CALLBACK (modify_over), NULL);
gtk_box_pack_start (GTK_BOX (box_save), over_check, FALSE, TRUE, 1);
//third page: Security
tab3 = gtk_vbox_new (FALSE, GRG_PAD);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab3,
gtk_label_new (_("Security")));
frame_xpire = gtk_frame_new (_("Password expiration"));
gtk_box_pack_start (GTK_BOX (tab3), frame_xpire, FALSE, TRUE, 1);
box_xpire = gtk_hbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_xpire), box_xpire);
xpire_check =
gtk_check_button_new_with_label (_("Password expires in"));
xpire_spin =
gtk_spin_button_new_with_range (EXP_TIME_MIN, EXP_TIME_MAX,
1);
xpire_lbl = gtk_label_new (_("days"));
g_signal_connect (G_OBJECT (xpire_check), "toggled",
G_CALLBACK (modify_xpire), xpire_spin);
g_signal_connect (G_OBJECT (xpire_spin), "value-changed",
G_CALLBACK (modify_xpin), xpire_check);
gtk_box_pack_start (GTK_BOX (box_xpire), xpire_check, FALSE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_xpire), xpire_spin, FALSE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_xpire), xpire_lbl, FALSE, TRUE, 1);
//this means "passes in wiping a file", not "wipe the passes" :)
frame_passes = gtk_frame_new (_("Wipe passes"));
gtk_box_pack_start (GTK_BOX (tab3), frame_passes, FALSE, TRUE, 1);
box_passes = gtk_hbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_passes), box_passes);
lbl_passes = gtk_label_new (_("Number of overwritings with random\n"
"data, when wiping a file:"));
gtk_box_pack_start (GTK_BOX (box_passes), lbl_passes, FALSE, TRUE, 1);
passes_spin =
gtk_spin_button_new_with_range (WIPE_PASSES_MIN,
WIPE_PASSES_MAX, 1);
gtk_box_pack_start (GTK_BOX (box_passes), passes_spin, FALSE, TRUE,
1);
g_signal_connect (G_OBJECT (passes_spin), "value-changed",
G_CALLBACK (modify_passes), NULL);
frame_clip = gtk_frame_new (_("Clipboard"));
gtk_box_pack_start (GTK_BOX (tab3), frame_clip, FALSE, TRUE, 1);
box_clip = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_clip), box_clip);
cclip_check =
gtk_check_button_new_with_label (_
("Clear clipboard on closing file"));
g_signal_connect (G_OBJECT (cclip_check), "toggled",
G_CALLBACK (modify_cclip), NULL);
gtk_box_pack_start (GTK_BOX (box_clip), cclip_check, FALSE, TRUE, 1);
qclip_check =
gtk_check_button_new_with_label (_
("Clear clipboard on exit"));
g_signal_connect (G_OBJECT (qclip_check), "toggled",
G_CALLBACK (modify_qclip), NULL);
gtk_box_pack_start (GTK_BOX (box_clip), qclip_check, FALSE, TRUE, 1);
//end of last tab
active_flag = TRUE;
reset_values (prefs);
update_buttons ();
gtk_widget_show_all (prefs);
while (TRUE)
{
gboolean exit = TRUE;
response = gtk_dialog_run (GTK_DIALOG (prefs));
switch (response)
{
case GTK_RESPONSE_OK:
apply_values ();
break;
case GTK_RESPONSE_APPLY:
apply_values ();
exit = FALSE;
break;
case GTK_RESPONSE_CANCEL:
default:
break;
}
if (exit)
{
gtk_widget_destroy (prefs);
active_flag = FALSE;
break;
}
}
}
