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);
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
gimp_rotate_tool_dialog (GimpTransformTool *tr_tool)
{
GimpRotateTool *rotate = GIMP_ROTATE_TOOL (tr_tool);
GtkWidget *table;
GtkWidget *button;
GtkWidget *scale;
GtkAdjustment *adj;
table = gtk_table_new (4, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 6);
gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (tr_tool->gui)), table,
FALSE, FALSE, 0);
gtk_widget_show (table);
rotate->angle_adj = (GtkAdjustment *)
gtk_adjustment_new (0, -180, 180, 0.1, 15, 0);
button = gtk_spin_button_new (rotate->angle_adj, 1.0, 2);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (button), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (button), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (button), SB_WIDTH);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Angle:"),
0.0, 0.5, button, 1, TRUE);
rotate->angle_spin_button = button;
g_signal_connect (rotate->angle_adj, "value-changed",
G_CALLBACK (rotate_angle_changed),
tr_tool);
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, rotate->angle_adj);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_widget_show (scale);
adj = (GtkAdjustment *) gtk_adjustment_new (0, -1, 1, 1, 10, 0);
button = gtk_spin_button_new (adj, 1.0, 2);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (button), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (button), SB_WIDTH);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("Center _X:"),
0.0, 0.5, button, 1, TRUE);
rotate->sizeentry = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a",
TRUE, TRUE, FALSE, SB_WIDTH,
GIMP_SIZE_ENTRY_UPDATE_SIZE);
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (rotate->sizeentry),
GTK_SPIN_BUTTON (button), NULL);
gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (rotate->sizeentry), 2);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("Center _Y:"),
0.0, 0.5, rotate->sizeentry, 1, TRUE);
g_signal_connect (rotate->sizeentry, "value-changed",
G_CALLBACK (rotate_center_changed),
tr_tool);
}
/* Sets a spin button's value to the lower limit when
* it's upper limit is reached, and vice versa. */
int
clip_GTK_SPINBUTTONSETWRAP(ClipMachine * ClipMachineMemory)
{
C_widget *cspb = _fetch_cw_arg(ClipMachineMemory);
gboolean wrap = BOOL_OPTION(ClipMachineMemory, 2, TRUE);
CHECKCWID(cspb, GTK_IS_SPIN_BUTTON);
CHECKOPT(2, LOGICAL_type_of_ClipVarType);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(cspb->widget), wrap);
return 0;
err:
return 1;
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_spin_button_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gfloat climb_rate;
gint digits, policy_value = GTK_UPDATE_ALWAYS, i;
gchar *policy;
gboolean numeric, snap, wrap;
GtkAdjustment *adj;
climb_rate = gb_widget_input_float (data, ClimbRate);
/* No set function for this */
if (data->apply)
GTK_SPIN_BUTTON (widget)->climb_rate = climb_rate;
digits = gb_widget_input_int (data, Digits);
if (data->apply)
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (widget), digits);
numeric = gb_widget_input_bool (data, Numeric);
if (data->apply)
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (widget), numeric);
snap = gb_widget_input_bool (data, Snap);
if (data->apply)
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (widget), snap);
policy = gb_widget_input_choice (data, Policy);
for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i++)
{
if (!strcmp (policy, GbPolicyChoices[i])
|| !strcmp (policy, GbPolicySymbols[i]))
{
policy_value = GbPolicyValues[i];
break;
}
}
if (data->apply)
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (widget), policy_value);
wrap = gb_widget_input_bool (data, Wrap);
if (data->apply)
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (widget), wrap);
adj = GTK_SPIN_BUTTON (widget)->adjustment;
if (gb_widget_input_adjustment (data, Values, adj, "adjustment"))
{
gtk_signal_emit_by_name (GTK_OBJECT (adj), "value_changed");
}
}
GtkWidget *make_new_spinner(char *label, int val, int min, int max,
int step, GtkWidget *box) {
GtkWidget *vbox = NULL, *ret;
GtkAdjustment *adj;
if (label != NULL) {
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), gtk_label_new(label), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), vbox, FALSE, FALSE, 0);
}
adj = GTK_ADJUSTMENT(gtk_adjustment_new(val, min, max, 1, step, 0));
ret = gtk_spin_button_new(adj, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(ret), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(ret), TRUE);
gtk_box_pack_start(GTK_BOX(label ? vbox : box), ret, FALSE, FALSE, 0);
return ret;
}
static void
linewidth_create_dialog()
{
GtkWidget *hbox;
GtkWidget *label;
GtkAdjustment *adj;
linewidth_dialog = gtk_dialog_new_with_buttons(
_("Line width"), GTK_WINDOW(interface_get_toolbox_shell()),
0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG(linewidth_dialog), GTK_RESPONSE_OK);
gtk_window_set_role (GTK_WINDOW (linewidth_dialog), "linewidth_window");
gtk_window_set_resizable (GTK_WINDOW (linewidth_dialog), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (linewidth_dialog), 2);
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Line width:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
adj = (GtkAdjustment *) gtk_adjustment_new(0.1, 0.00, 10.0, 0.01, 0.05, 0.0);
linewidth_button = gtk_spin_button_new(adj, attributes_get_default_linewidth(), 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(linewidth_button), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(linewidth_button), TRUE);
gtk_box_pack_start(GTK_BOX (hbox), linewidth_button, TRUE, TRUE, 0);
gtk_widget_show (linewidth_button);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG (linewidth_dialog)->vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (linewidth_button);
g_signal_connect(G_OBJECT (linewidth_dialog), "response",
G_CALLBACK (linewidth_dialog_respond), NULL);
g_signal_connect_after(G_OBJECT (linewidth_button), "activate",
G_CALLBACK (linewidth_dialog_ok), NULL);
g_signal_connect (GTK_OBJECT (linewidth_dialog), "delete_event",
G_CALLBACK(gtk_widget_hide), NULL);
g_signal_connect (GTK_OBJECT (linewidth_dialog), "destroy",
G_CALLBACK(dialog_destroyed), &linewidth_dialog);
persistence_register_window (GTK_WINDOW (linewidth_dialog));
}
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 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 ) );
}
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("wxXX creation failed") );
return false;
}
m_oldPos = 0.0;
m_adjust = (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 100.0, 1.0, 5.0, 0.0);
m_widget = gtk_spin_button_new( m_adjust, 0, 0 );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON(m_widget),
(int)(m_windowStyle & wxSP_WRAP) );
gtk_signal_connect( GTK_OBJECT (m_adjust),
"value_changed",
(GtkSignalFunc) gtk_spinbutt_callback,
(gpointer) this );
m_parent->DoAddChild( this );
PostCreation(new_size);
return true;
}
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;
}
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;
}
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_oldPos = initial;
m_adjust = (GtkAdjustment*) gtk_adjustment_new( initial, min, max, 1.0, 5.0, 0.0);
m_widget = gtk_spin_button_new( m_adjust, 1, 0 );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON(m_widget),
(int)(m_windowStyle & wxSP_WRAP) );
GtkEnableEvents();
m_parent->DoAddChild( this );
PostCreation(size);
SetValue( value );
return TRUE;
}
void showSetupWindow(struct Context *context) {
GtkWidget *browseb, *cancelButton, *applyButton, *quitButton, *check, *erasetoggle,
*whitetoggle, *dumpcheck, *sortrtoggle;
GtkWidget *dumptifcheck, *dumpjpgcheck;
GtkWidget *vbox_main, *hbox_main, *vbox, *hbox1, *hbox2, *hbox3, *vboxright,
*vboxmostright, *vboxleft, *hboxcube;
GtkWidget *vboxcubel, *vboxcuber, *vboxcuberm, *hboxxc, *vboxxcl, *vboxxcr,
*hboxssize, *hboxsleep, *hboxd, *vbox_header;
GtkWidget *hbox_cube, *hboxsc, *scoltoggle;
GtkWidget *file_label, *column_label, *ff_label, *cxyz_label, *separator;
GtkWidget *cube_label, *x_label, *y_label, *z_label, *xcol_label,
*ycol_label, *zcol_label, *tcol_label, *ssize_label;
GtkWidget *ssx_label, *ssy_label, *sleep_label, *d_label, *header,
*col_label, *misc_label, *draw_label, *empty_label;
GtkWidget *hboxtd;
GSList *group;
setupConfig.mode = context->config->mode;
setupConfig.erasePreviousFrame = context->config->erasePreviousFrame;
setupConfig.backgroundWhite = context->config->backgroundWhite;
setupConfig.colorset = context->config->colorset;
setupConfig.inputFormatXYZ = context->config->inputFormatXYZ;
setupConfig.sort = context->config->sort;
setupConfig.vary = context->config->vary;
setupConfig.dumpnum = context->config->dumpnum;
setupConfig.tifjpg = context->config->tifjpg;
setupConfig.dumpnum = context->config->dumpnum;
setupConfig.useTypesForColoring = context->config->useTypesForColoring;
usedump = FALSE;
usescol = FALSE;
setupwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (setupwin), "gdpc Setup");
gtk_container_set_border_width(GTK_CONTAINER (setupwin), 5);
g_signal_connect(G_OBJECT (setupwin), "destroy", G_CALLBACK (destroy),
&setupwin);
/* Create boxes for layout. */
vbox_main = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
vbox_header = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
hbox_main = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 30);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3);
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 30);
hbox3 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 30);
hboxssize = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
hboxd = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
hboxsc = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
hbox_cube = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3);
hboxcube = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3);
vboxcubel = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
vboxcuber = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
vboxcuberm = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
hboxxc = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
vboxxcl = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
vboxxcr = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
hboxsleep = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
hboxtd = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
vboxleft = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
vboxright = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
vboxmostright = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
gtk_container_add(GTK_CONTAINER (setupwin), vbox_main);
gtk_box_pack_start(GTK_BOX (vbox_main), vbox_header, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (vbox_main), hbox_main, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (vbox_main), hbox3, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox_main), vbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox_main), vboxmostright, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (vbox), hbox1, FALSE, FALSE, 0);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX (vbox), separator, FALSE, TRUE, 3);
gtk_box_pack_start(GTK_BOX (vbox), hbox2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox2), vboxleft, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox2), vboxright, FALSE, FALSE, 0);
header = gtk_label_new(" Setup ");
gtk_box_pack_start(GTK_BOX (vbox_header), header, FALSE, TRUE, 0);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX (vbox_header), separator, FALSE, TRUE, 3);
file_label = gtk_label_new("Input file : ");
file_entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(file_entry), 160);
g_signal_connect(G_OBJECT (file_entry), "changed", G_CALLBACK (filechange),
G_OBJECT (setupwin));
if (context->config->file != NULL) {
gtk_entry_set_text(GTK_ENTRY (file_entry), context->config->file);
}
gtk_widget_set_tooltip_text(file_entry, inputfilett);
browseb = gtk_button_new_with_mnemonic("_Browse");
g_signal_connect(G_OBJECT (browseb), "clicked", G_CALLBACK (filebrowser),
G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (hbox1), file_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox1), file_entry, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (hbox1), browseb, FALSE, FALSE, 0);
ssize_label = gtk_label_new("Drawingboard size [pixels]");
ssx_label = gtk_label_new(" X : ");
ssy_label = gtk_label_new(" Y : ");
adjssizex = (GtkAdjustment *) gtk_adjustment_new(context->config->absxsize, 0.0,
3000.0, 10.0, 5.0, 0.0);
adjssizey = (GtkAdjustment *) gtk_adjustment_new(context->config->absysize, 0.0,
3000.0, 10.0, 5.0, 0.0);
ssxspinner = gtk_spin_button_new(adjssizex, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (ssxspinner), FALSE);
ssyspinner = gtk_spin_button_new(adjssizey, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (ssyspinner), FALSE);
gtk_box_pack_start(GTK_BOX (vboxleft), ssize_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (hboxssize), ssx_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (hboxssize), ssxspinner, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (hboxssize), ssy_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (hboxssize), ssyspinner, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxleft), hboxssize, TRUE, TRUE, 0);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX (vboxleft), separator, FALSE, TRUE, 3);
cxyz_label = gtk_label_new("Simulation box size");
gtk_box_pack_start(GTK_BOX (vboxleft), cxyz_label, TRUE, TRUE, 3);
gtk_box_pack_start(GTK_BOX (vboxleft), hbox_cube, TRUE, TRUE, 3);
gtk_box_pack_start(GTK_BOX (vboxleft), hboxcube, TRUE, TRUE, 3);
gtk_box_pack_start(GTK_BOX (hboxcube), vboxcubel, TRUE, TRUE, 3);
gtk_box_pack_start(GTK_BOX (hboxcube), vboxcuber, TRUE, TRUE, 3);
gtk_box_pack_start(GTK_BOX (hboxcube), vboxcuberm, TRUE, TRUE, 3);
cube_label = gtk_label_new("Cube : ");
adjcube = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 10000.0, 1.0, 5.0,
0.0);
cubespinner = gtk_spin_button_new(adjcube, 0, 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (cubespinner), FALSE);
// gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (cubespinner),
// GTK_SHADOW_OUT);
gtk_box_pack_start(GTK_BOX (hbox_cube), cube_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (hbox_cube), cubespinner, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(cubespinner, cubett);
x_label = gtk_label_new("X : ");
if (context->config->xmin == 65535.0) {
adjx = (GtkAdjustment *) gtk_adjustment_new(0.0, -10000.0, 0.0, 1.0,
5.0, 0.0);
adjx2 = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 10000.0, 1.0,
5.0, 0.0);
} else {
adjx = (GtkAdjustment *) gtk_adjustment_new(context->config->xmin, -10000.0,
context->config->xmax, 1.0, 5.0, 0.0);
adjx2 = (GtkAdjustment *) gtk_adjustment_new(context->config->xmax, context->config->xmin,
10000.0, 1.0, 5.0, 0.0);
}
xspinner = gtk_spin_button_new(adjx, 0, 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (xspinner), FALSE);
g_signal_connect(G_OBJECT (adjx), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
x2spinner = gtk_spin_button_new(adjx2, 0, 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (x2spinner), FALSE);
g_signal_connect(G_OBJECT (adjx2), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxcubel), x_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxcuber), xspinner, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxcuberm), x2spinner, TRUE, TRUE, 0);
y_label = gtk_label_new("Y : ");
if (context->config->ymin == 65535.0) {
adjy = (GtkAdjustment *) gtk_adjustment_new(0.0, -10000.0, 0.0, 1.0,
5.0, 0.0);
adjy2 = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 10000.0, 1.0,
5.0, 0.0);
} else {
adjy = (GtkAdjustment *) gtk_adjustment_new(context->config->ymin, -10000.0,
context->config->ymax, 1.0, 5.0, 0.0);
adjy2 = (GtkAdjustment *) gtk_adjustment_new(context->config->ymax, context->config->ymin,
10000.0, 1.0, 5.0, 0.0);
}
yspinner = gtk_spin_button_new(adjy, 0, 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (yspinner), FALSE);
g_signal_connect(G_OBJECT (adjy), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
y2spinner = gtk_spin_button_new(adjy2, 0, 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (y2spinner), FALSE);
g_signal_connect(G_OBJECT (adjy2), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxcubel), y_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxcuber), yspinner, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxcuberm), y2spinner, TRUE, TRUE, 0);
z_label = gtk_label_new("Z : ");
if (context->config->zmin == 65535.0) {
adjz = (GtkAdjustment *) gtk_adjustment_new(0.0, -10000.0, 0.0, 1.0,
5.0, 0.0);
adjz2 = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 10000.0, 1.0,
5.0, 0.0);
} else {
adjz = (GtkAdjustment *) gtk_adjustment_new(context->config->zmin, -10000.0,
context->config->zmax, 1.0, 5.0, 0.0);
adjz2 = (GtkAdjustment *) gtk_adjustment_new(context->config->zmax, context->config->zmin,
10000.0, 1.0, 5.0, 0.0);
}
zspinner = gtk_spin_button_new(adjz, 0, 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (zspinner), FALSE);
g_signal_connect(G_OBJECT (adjz), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
z2spinner = gtk_spin_button_new(adjz2, 0, 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (z2spinner), FALSE);
g_signal_connect(G_OBJECT (adjz2), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxcubel), z_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxcuber), zspinner, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxcuberm), z2spinner, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(xspinner, mintt);
gtk_widget_set_tooltip_text(yspinner, mintt);
gtk_widget_set_tooltip_text(zspinner, mintt);
gtk_widget_set_tooltip_text(x2spinner, maxtt);
gtk_widget_set_tooltip_text(y2spinner, maxtt);
gtk_widget_set_tooltip_text(z2spinner, maxtt);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX (vboxleft), separator, FALSE, TRUE, 3);
column_label = gtk_label_new("Input data column representations");
gtk_box_pack_start(GTK_BOX (vboxleft), column_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxleft), hboxxc, TRUE, TRUE, 3);
gtk_box_pack_start(GTK_BOX (hboxxc), vboxxcl, TRUE, TRUE, 3);
gtk_box_pack_start(GTK_BOX (hboxxc), vboxxcr, TRUE, TRUE, 3);
xcol_label = gtk_label_new("X column : ");
adjxc = (GtkAdjustment *) gtk_adjustment_new(context->config->xcolumn, 1.0, 100.0,
1.0, 5.0, 0.0);
xcspinner = gtk_spin_button_new(adjxc, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (xcspinner), FALSE);
gtk_box_pack_start(GTK_BOX (vboxxcl), xcol_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxxcr), xcspinner, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(xcspinner, xcoltt);
ycol_label = gtk_label_new("Y column : ");
adjyc = (GtkAdjustment *) gtk_adjustment_new(context->config->ycolumn, 1.0, 100.0,
1.0, 5.0, 0.0);
ycspinner = gtk_spin_button_new(adjyc, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (ycspinner), FALSE);
gtk_box_pack_start(GTK_BOX (vboxxcl), ycol_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxxcr), ycspinner, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(ycspinner, ycoltt);
zcol_label = gtk_label_new("Z column : ");
adjzc = (GtkAdjustment *) gtk_adjustment_new(context->config->zcolumn, 1.0, 100.0,
1.0, 5.0, 0.0);
zcspinner = gtk_spin_button_new(adjzc, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (zcspinner), FALSE);
gtk_box_pack_start(GTK_BOX (vboxxcl), zcol_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxxcr), zcspinner, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(zcspinner, zcoltt);
tcol_label = gtk_label_new("t column : ");
adjtc = (GtkAdjustment *) gtk_adjustment_new(context->config->tcolumn, 1.0, 100.0,
1.0, 5.0, 0.0);
tcspinner = gtk_spin_button_new(adjtc, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (tcspinner), FALSE);
gtk_box_pack_start(GTK_BOX (vboxxcl), tcol_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxxcr), tcspinner, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(tcspinner, tcoltt);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX (vboxleft), separator, FALSE, TRUE, 3);
timedel_entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(timedel_entry), 160);
gtk_entry_set_text(GTK_ENTRY (timedel_entry), context->config->timedelim);
timedel_label = gtk_label_new("Time unit : ");
gtk_box_pack_start(GTK_BOX (hboxtd), timedel_label, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (hboxtd), timedel_entry, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxleft), hboxtd, FALSE, TRUE, 0);
if (!context->config->inputFormatXYZ) {
gtk_widget_set_sensitive(timedel_entry, FALSE);
gtk_widget_set_sensitive(timedel_label, FALSE);
} else {
gtk_widget_set_sensitive(timedel_entry, TRUE);
gtk_widget_set_sensitive(timedel_label, TRUE);
}
gtk_widget_set_tooltip_text(timedel_entry, timedeltt);
ff_label = gtk_label_new("Input file format");
gtk_box_pack_start(GTK_BOX (vboxright), ff_label, TRUE, TRUE, 0);
usetypescheck = gtk_check_button_new_with_label(" Use coloring by type");
check = gtk_radio_button_new_with_label(NULL, "XYZ file format");
gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "clicked", G_CALLBACK (toggle_checkxyz),
G_OBJECT (setupwin));
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check));
if (context->config->inputFormatXYZ) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
}
check = gtk_radio_button_new_with_label(group, "Arbitrary file format");
gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "clicked", G_CALLBACK (toggle_checkaff),
G_OBJECT (setupwin));
if (!context->config->inputFormatXYZ) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
}
g_signal_connect(G_OBJECT (usetypescheck), "toggled",
G_CALLBACK (toggle_usetypes), G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxright), usetypescheck, TRUE, TRUE, 0);
if (context->config->useTypesForColoring)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (usetypescheck), TRUE);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (usetypescheck), FALSE);
gtk_widget_set_tooltip_text(usetypescheck, coltypett);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX (vboxright), separator, FALSE, TRUE, 3);
draw_label = gtk_label_new(" Drawing options ");
gtk_box_pack_start(GTK_BOX (vboxright), draw_label, TRUE, TRUE, 0);
d_label = gtk_label_new("Size of drawn polygons :");
adjd = (GtkAdjustment *) gtk_adjustment_new(context->config->radius, 1.0, 100.0, 1.0,
5.0, 0.0);
dspinner = gtk_spin_button_new(adjd, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (dspinner), FALSE);
gtk_box_pack_start(GTK_BOX (hboxd), d_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (hboxd), dspinner, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxright), hboxd, TRUE, TRUE, 0);
check = gtk_radio_button_new_with_label(NULL, "Draw as rectangles");
gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkm0),
G_OBJECT (setupwin));
if (context->config->mode == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check));
check = gtk_radio_button_new_with_label(group, "Draw as circles");
gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkm1),
G_OBJECT (setupwin));
if (context->config->mode == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check));
check = gtk_radio_button_new_with_label(group, "Draw as rendered balls");
gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkm2),
G_OBJECT (setupwin));
if (context->config->mode == 2)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
empty_label = gtk_label_new(" ");
gtk_box_pack_start(GTK_BOX (vboxright), empty_label, TRUE, TRUE, 0);
check = gtk_radio_button_new_with_label(NULL, "Dont vary size with z");
gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkv0),
G_OBJECT (setupwin));
if (context->config->vary == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check));
check = gtk_radio_button_new_with_label(group,
"Vary size with z, decreasing");
gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkv1),
G_OBJECT (setupwin));
if (context->config->vary == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check));
check = gtk_radio_button_new_with_label(group,
"Vary size with z, increasing");
gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkv2),
G_OBJECT (setupwin));
if (context->config->vary == 2)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX (vboxright), separator, FALSE, TRUE, 3);
scoltoggle = gtk_check_button_new_with_label(
"Only use inputlines with string :");
g_signal_connect(G_OBJECT (scoltoggle), "toggled", G_CALLBACK (toggle_scol),
G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxright), scoltoggle, TRUE, TRUE, 0);
scol_entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(scol_entry), 60);
g_signal_connect(G_OBJECT (scol_entry), "changed", G_CALLBACK (filechange),
G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxright), scol_entry, TRUE, TRUE, 0);
scol_label = gtk_label_new(" in column ");
adjscol = (GtkAdjustment *) gtk_adjustment_new(1.0, 1.0, 100.0, 1.0, 5.0,
0.0);
scolspinner = gtk_spin_button_new(adjscol, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (scolspinner), FALSE);
gtk_box_pack_start(GTK_BOX (hboxsc), scol_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (hboxsc), scolspinner, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxright), hboxsc, TRUE, TRUE, 0);
gtk_widget_set_sensitive(scol_label, FALSE);
gtk_widget_set_sensitive(scol_entry, FALSE);
gtk_widget_set_sensitive(scolspinner, FALSE);
col_label = gtk_label_new(" Color settings ");
gtk_box_pack_start(GTK_BOX (vboxmostright), col_label, TRUE, TRUE, 0);
check = gtk_radio_button_new_with_label(NULL, "Use default colors");
gtk_box_pack_start(GTK_BOX (vboxmostright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkc0),
G_OBJECT (setupwin));
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check));
if (context->config->colorset == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
check = gtk_radio_button_new_with_label(group, "Use inverted colors");
gtk_box_pack_start(GTK_BOX (vboxmostright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkc1),
G_OBJECT (setupwin));
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check));
if (context->config->colorset == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
check = gtk_radio_button_new_with_label(group, "Use cold colors");
gtk_box_pack_start(GTK_BOX (vboxmostright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkc2),
G_OBJECT (setupwin));
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check));
if (context->config->colorset == 2)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
check = gtk_radio_button_new_with_label(group, "Use cold colors 2");
gtk_box_pack_start(GTK_BOX (vboxmostright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkc3),
G_OBJECT (setupwin));
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check));
if (context->config->colorset == 3)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
check = gtk_radio_button_new_with_label(group, "Use greyscale colors");
gtk_box_pack_start(GTK_BOX (vboxmostright), check, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkc4),
G_OBJECT (setupwin));
if (context->config->colorset == 4)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX (vboxmostright), separator, FALSE, TRUE, 3);
misc_label = gtk_label_new("Misc. settings");
gtk_box_pack_start(GTK_BOX (vboxmostright), misc_label, TRUE, TRUE, 0);
erasetoggle = gtk_check_button_new_with_label(
" Erase before drawing next frame");
g_signal_connect(G_OBJECT (erasetoggle), "toggled",
G_CALLBACK (toggle_erase), G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxmostright), erasetoggle, TRUE, TRUE, 0);
if (context->config->erasePreviousFrame)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (erasetoggle), TRUE);
whitetoggle = gtk_check_button_new_with_label(
" Use white as backgroundcolor");
g_signal_connect(G_OBJECT (whitetoggle), "toggled",
G_CALLBACK (toggle_white), G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxmostright), whitetoggle, TRUE, TRUE, 0);
if (context->config->backgroundWhite)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (whitetoggle), TRUE);
sortrtoggle = gtk_check_button_new_with_label(" Reverse sorting");
g_signal_connect(G_OBJECT (sortrtoggle), "toggled",
G_CALLBACK (toggle_sortr), G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxmostright), sortrtoggle, TRUE, TRUE, 0);
if (context->config->sort == 2)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (sortrtoggle), TRUE);
sleep_label = gtk_label_new("Delay between frames [s] : ");
adjsleep = (GtkAdjustment *) gtk_adjustment_new((context->config->interval / 1000.0),
0.0, 100.0, 0.1, 5.0, 0.0);
sleepspinner = gtk_spin_button_new(adjsleep, 0, 1);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (sleepspinner), FALSE);
gtk_box_pack_start(GTK_BOX (hboxsleep), sleep_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (hboxsleep), sleepspinner, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vboxmostright), hboxsleep, TRUE, TRUE, 0);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX (vboxmostright), separator, FALSE, TRUE, 3);
dump_label = gtk_label_new(" Dumped pictures name (no extension) : ");
dump_entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(dump_entry), 60);
gtk_widget_set_sensitive(dump_label, FALSE);
gtk_widget_set_sensitive(dump_entry, FALSE);
dtcheck = gtk_radio_button_new_with_label(NULL, " Add frame time");
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (dtcheck));
gtk_widget_set_sensitive(dtcheck, FALSE);
dncheck = gtk_radio_button_new_with_label(group, " Add frame number");
gtk_widget_set_sensitive(dncheck, FALSE);
okButton = gtk_button_new_from_stock(GTK_STOCK_OK);
dumpcheck = gtk_radio_button_new_with_label(NULL, " Do not dump images");
gtk_box_pack_start(GTK_BOX (vboxmostright), dumpcheck, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (dumpcheck), "toggled",
G_CALLBACK (toggle_checkdump), G_OBJECT (setupwin));
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (dumpcheck));
if (strlen(context->config->dumpname) == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dumpcheck), TRUE);
dumptifcheck = gtk_radio_button_new_with_label(group,
" Dump a .png of each frame");
gtk_box_pack_start(GTK_BOX (vboxmostright), dumptifcheck, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (dumptifcheck), "toggled",
G_CALLBACK (toggle_checkdumptif), G_OBJECT (setupwin));
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (dumptifcheck));
if (strlen(context->config->dumpname) > 0 && context->config->tifjpg) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dumptifcheck), TRUE);
gtk_entry_set_text(GTK_ENTRY (dump_entry), context->config->dumpname);
}
dumpjpgcheck = gtk_radio_button_new_with_label(group,
" Dump a .jpg of each frame");
gtk_box_pack_start(GTK_BOX (vboxmostright), dumpjpgcheck, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (dumpjpgcheck), "toggled",
G_CALLBACK (toggle_checkdumpjpg), G_OBJECT (setupwin));
if (strlen(context->config->dumpname) > 0 && !context->config->tifjpg) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dumpjpgcheck), TRUE);
}
gtk_box_pack_start(GTK_BOX (vboxmostright), dump_label, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (dump_entry), "changed", G_CALLBACK (filechange),
G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxmostright), dump_entry, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (dtcheck), "toggled", G_CALLBACK (toggle_checkdt),
G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxmostright), dtcheck, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT (dncheck), "toggled", G_CALLBACK (toggle_checkdn),
G_OBJECT (setupwin));
gtk_box_pack_start(GTK_BOX (vboxmostright), dncheck, TRUE, TRUE, 0);
if (setupConfig.dumpnum)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dncheck), TRUE);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dtcheck), TRUE);
g_signal_connect(G_OBJECT (okButton), "clicked", G_CALLBACK (okeyPressed),
(gpointer) context);
gtk_box_pack_start(GTK_BOX (hbox3), okButton, TRUE, TRUE, 0);
if (!context->StartedAlready)
gtk_widget_set_sensitive(okButton, FALSE);
cancelButton = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect(G_OBJECT (cancelButton), "clicked", G_CALLBACK (cancelPressed),
(gpointer) context);
gtk_box_pack_start(GTK_BOX (hbox3), cancelButton, TRUE, TRUE, 0);
if (!context->StartedAlready)
gtk_widget_set_sensitive(cancelButton, FALSE);
applyButton = gtk_button_new_from_stock(GTK_STOCK_APPLY);
g_signal_connect(G_OBJECT (applyButton), "clicked", G_CALLBACK (applyPressed),
(gpointer) context);
gtk_box_pack_start(GTK_BOX (hbox3), applyButton, TRUE, TRUE, 0);
if (!context->StartedAlready)
gtk_widget_set_sensitive(applyButton, FALSE);
quitButton = gtk_button_new_from_stock(GTK_STOCK_QUIT);
g_signal_connect(G_OBJECT (quitButton), "clicked", G_CALLBACK (quitPressed),
(gpointer) context);
gtk_box_pack_start(GTK_BOX (hbox3), quitButton, TRUE, TRUE, 0);
gtk_widget_show_all(setupwin);
}
/** \brief Create and initialise time controller widgets.
* \param module The parent GtkSatModule
*
*/
void tmg_create (GtkSatModule *mod)
{
GtkWidget *vbox, *hbox, *table;
GtkWidget *image;
GtkWidget *label;
gchar *title;
gchar *buff;
/* make sure controller is not already active */
if (mod->tmgActive) {
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: Time Controller for %s is already active"),
__FUNCTION__, mod->name);
/* try to make window visible in case it is covered
by something else */
gtk_window_present (GTK_WINDOW (mod->tmgWin));
return;
}
/* create hbox containing the controls
the controls are implemented as radiobuttons in order
to inherit the mutual exclusion behaviour
*/
hbox = gtk_hbox_new (FALSE, 0);
/* FWD */
mod->tmgFwd = gtk_radio_button_new (NULL);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgFwd), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mod->tmgFwd), TRUE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_FORWARD, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgFwd), image);
gtk_widget_set_tooltip_text (mod->tmgFwd, _("Play forward"));
g_signal_connect (mod->tmgFwd, "toggled", G_CALLBACK (tmg_fwd), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgFwd, FALSE, FALSE, 0);
/* STOP */
mod->tmgStop = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (mod->tmgFwd));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgStop), FALSE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgStop), image);
gtk_widget_set_tooltip_text (mod->tmgStop, _("Stop"));
g_signal_connect (mod->tmgStop, "toggled", G_CALLBACK (tmg_stop), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgStop, FALSE, FALSE, 0);
/* BWD */
mod->tmgBwd = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (mod->tmgFwd));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgBwd), FALSE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_REWIND, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgBwd), image);
gtk_widget_set_tooltip_text (mod->tmgBwd, _("Play backwards"));
g_signal_connect (mod->tmgBwd, "toggled", G_CALLBACK (tmg_bwd), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgBwd, FALSE, FALSE, 0);
/* reset time */
mod->tmgReset = gtk_button_new_with_label (_("Reset"));
gtk_widget_set_tooltip_text (mod->tmgReset, _("Reset to current date and time"));
g_signal_connect (mod->tmgReset, "clicked", G_CALLBACK (tmg_reset), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgReset, FALSE, FALSE, 10);
/* status label */
mod->tmgState = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (mod->tmgState), 0.0, 0.5);
gtk_label_set_markup (GTK_LABEL (mod->tmgState), _("<b>Real-Time</b>"));
gtk_box_pack_start (GTK_BOX (hbox), mod->tmgState, TRUE, TRUE, 10);
/* create table containing the date and time widgets */
table = gtk_table_new (5, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 0);
mod->tmgCal = gtk_calendar_new ();
gtk_calendar_set_display_options (GTK_CALENDAR (mod->tmgCal),
GTK_CALENDAR_SHOW_HEADING |
GTK_CALENDAR_SHOW_DAY_NAMES |
GTK_CALENDAR_WEEK_START_MONDAY);
g_signal_connect (mod->tmgCal, "day-selected",
G_CALLBACK (tmg_time_set), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgCal,
0, 1, 0, 5, GTK_SHRINK, GTK_SHRINK,
0, 0);
/* Time controllers.
Note that the controllers for hours, minutes, and seconds have ranges;
however, they can wrap around their limits in order to ensure a smooth
and continuous control of the time
*/
/* hour */
label = gtk_label_new (_(" Hour:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgHour = gtk_spin_button_new_with_range (0, 23, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgHour), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgHour),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgHour), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgHour), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgHour), 2);
gtk_widget_set_tooltip_text (mod->tmgHour,
_("Use this control to set the hour"));
g_signal_connect (mod->tmgHour, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgHour, "wrapped", G_CALLBACK (tmg_hour_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgHour,
2, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* minutes */
label = gtk_label_new (_(" Min:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgMin = gtk_spin_button_new_with_range (0, 59, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgMin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgMin),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgMin), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgMin), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMin), 2);
gtk_widget_set_tooltip_text (mod->tmgMin,
_("Use this control to set the minutes"));
g_signal_connect (mod->tmgMin, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgMin, "wrapped", G_CALLBACK (tmg_min_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgMin,
2, 3, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* seconds */
label = gtk_label_new (_(" Sec:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgSec = gtk_spin_button_new_with_range (0, 59, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgSec), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgSec),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgSec), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgSec), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgSec), 2);
gtk_widget_set_tooltip_text (mod->tmgSec,
_("Use this control to set the seconds"));
g_signal_connect (mod->tmgSec, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgSec, "wrapped", G_CALLBACK (tmg_sec_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgSec,
2, 3, 2, 3, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* milliseconds */
label = gtk_label_new (_(" Msec:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 3, 4, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgMsec = gtk_spin_button_new_with_range (0, 999, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgMsec), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgMsec),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgMsec), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgMsec), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMsec), 2);
gtk_widget_set_tooltip_text (mod->tmgMsec,
_("Use this control to set the milliseconds"));
g_signal_connect (mod->tmgMsec, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgMsec, "wrapped", G_CALLBACK (tmg_msec_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgMsec,
2, 3, 3, 4, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* time throttle */
label = gtk_label_new (_("Throttle:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 4, 5, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgFactor = gtk_spin_button_new_with_range (1, 100, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgFactor), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgFactor),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgFactor), 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgFactor), 1);
gtk_widget_set_tooltip_text (mod->tmgFactor,
_("Time throttle / compression factor"));
g_signal_connect (mod->tmgFactor, "value-changed",
G_CALLBACK (tmg_throttle), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgFactor,
2, 3, 4, 5, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* add slider */
mod->tmgSlider = gtk_hscale_new_with_range (-0.1, +0.1, 0.0001); // +/- 2.5 hr
/*gtk_widget_set_tooltip_text (mod->tmgSlider,
_("Drag the slider to change the time up to +/- 2.5 hours.\n"\
"Resolution is ~ 8 seconds."));*/
gtk_scale_set_draw_value (GTK_SCALE (mod->tmgSlider), FALSE);
gtk_range_set_value (GTK_RANGE (mod->tmgSlider), 0.0);
g_signal_connect (mod->tmgSlider, "value-changed",
G_CALLBACK (slider_moved), mod);
/* create the vertical box */
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), mod->tmgSlider, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* create main window */
mod->tmgWin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
title = g_strconcat (_("Time Controller"), " / ", mod->name, NULL);
gtk_window_set_title (GTK_WINDOW (mod->tmgWin), title);
g_free (title);
gtk_window_set_transient_for (GTK_WINDOW (mod->tmgWin),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (mod))));
g_signal_connect (G_OBJECT (mod->tmgWin), "delete_event",
G_CALLBACK (tmg_delete), mod);
g_signal_connect (G_OBJECT (mod->tmgWin), "destroy",
G_CALLBACK (tmg_destroy), mod);
/* window icon */
buff = icon_file_name ("gpredict-clock.png");
gtk_window_set_icon_from_file (GTK_WINDOW (mod->tmgWin), buff, NULL);
g_free (buff);
gtk_container_add (GTK_CONTAINER (mod->tmgWin), vbox);
gtk_widget_show_all (mod->tmgWin);
mod->tmgActive = TRUE;
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: Time Controller for %s launched"),
__FUNCTION__, mod->name);
}
static GtkContainer *
maildir_get_setup_page( XfceMailwatchMailbox *mailbox )
{
XfceMailwatchMaildirMailbox *maildir = XFCE_MAILWATCH_MAILDIR_MAILBOX( mailbox );
GtkWidget *vbox, *hbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *spin;
GtkSizeGroup *sg;
DBG( "-->>" );
vbox = gtk_vbox_new( FALSE, BORDER / 2 );
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 );
sg = gtk_size_group_new( GTK_SIZE_GROUP_HORIZONTAL );
label = gtk_label_new_with_mnemonic( _( "Maildir _Path:" ) );
gtk_widget_show( label );
gtk_box_pack_start( GTK_BOX( hbox ), label, FALSE, FALSE, 0 );
gtk_size_group_add_widget( sg, label );
button = gtk_file_chooser_button_new( _("Select Maildir Folder"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
g_mutex_lock( maildir->mutex );
if ( maildir->path ) {
gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( button ), maildir->path );
}
g_mutex_unlock( maildir->mutex );
gtk_widget_show( button );
gtk_box_pack_start( GTK_BOX( hbox ), button, TRUE, TRUE, 0 );
g_signal_connect( G_OBJECT( button ), "file-set",
G_CALLBACK( maildir_folder_set_cb ), maildir );
gtk_label_set_mnemonic_widget( GTK_LABEL( label ), button );
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 );
gtk_size_group_add_widget( sg, label );
spin = gtk_spin_button_new_with_range( 1.0, 1440.0, 1.0 );
gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( spin ), TRUE );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( spin ), FALSE );
gtk_spin_button_set_value( GTK_SPIN_BUTTON( spin ), maildir->interval / 60 );
gtk_widget_show( spin );
gtk_box_pack_start( GTK_BOX( hbox ), spin, FALSE, FALSE, 0 );
g_signal_connect( G_OBJECT( spin ), "value-changed",
G_CALLBACK( maildir_interval_changed_cb ), maildir );
gtk_label_set_mnemonic_widget( GTK_LABEL( label ), spin );
label = gtk_label_new( _( "minute(s)." ) );
gtk_widget_show( label );
gtk_box_pack_start( GTK_BOX( hbox ), label, FALSE, FALSE, 0 );
DBG( "<<--" );
return ( GTK_CONTAINER( vbox ) );
}
/**
* Initialize preferences page
*/
void alarm_construct (GtkWidget *container)
{
GtkWidget *action_label, *time_label, *action_combo;
GtkWidget *countdown_label, *separator, *separator2;
/* Preferences page is now visible and thus active */
prefs_active = TRUE;
enable_alarm = gtk_check_button_new_with_mnemonic (_("_Enable alarm"));
/* Set enabled/disable toggle depending on if timer is already running! */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enable_alarm), (timer_on) ? TRUE : FALSE);
/* Set up the alarm time spinners */
time_label = gtk_label_new (_("Time:"));
time_hours_spinner = gtk_spin_button_new_with_range (0, 23, 1.0);
time_minutes_spinner = gtk_spin_button_new_with_range (0, 59, 1.0);
time_seconds_spinner = gtk_spin_button_new_with_range (0, 59, 1.0);
guint time_hours_stored = cfg_get_single_value_as_int_with_default
(config, "alarm-plugin", "time_hours", 0);
/* If the hours are stored then assume the minutes and seconds are also. */
gtk_spin_button_set_value (GTK_SPIN_BUTTON (time_hours_spinner), time_hours_stored);
gchar *str = g_strdup_printf ("%02d", (gint) time_hours_stored);
gtk_entry_set_text (GTK_ENTRY (time_hours_spinner), str);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (time_minutes_spinner),
cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "time_minutes", 0));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (time_seconds_spinner),
cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "time_seconds", 0));
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (time_hours_spinner), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (time_minutes_spinner), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (time_seconds_spinner), TRUE);
separator = gtk_label_new (":");
separator2 = gtk_label_new (":");
action_label = gtk_label_new (_("Action:"));
action_combo = gtk_combo_box_new_text ();
alarm_pref_table = gtk_table_new (2, 2, FALSE);
alarm_pref_vbox = gtk_vbox_new (FALSE,6);
/*
* Hard-coded possible actions for once alarm deadline hit
* TODO: Allow customized actions?
*/
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Play/Pause"));
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Stop"));
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Close (& Stop)"));
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Close only"));
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Shutdown"));
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Toggle random"));
gtk_combo_box_set_active (GTK_COMBO_BOX (action_combo),
cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "action-id", 0));
/* Label to show remaining time */
countdown_label = gtk_label_new (_("Time left:"));
countdown = gtk_label_new ("--");
/* Attach widgets */
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), time_label, 0, 1, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), time_hours_spinner, 1, 2, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), separator, 2, 3, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), time_minutes_spinner, 3, 4, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), separator2, 4, 5, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), time_seconds_spinner, 5, 6, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), action_label, 0, 1, 1, 2);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), action_combo, 1, 2, 1, 2);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), countdown_label, 0, 1, 2, 3);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), countdown, 1, 2, 2, 3);
/* Connect signals */
g_signal_connect (G_OBJECT (time_hours_spinner), "value-changed", G_CALLBACK (on_spin_value_changed), NULL);
g_signal_connect (G_OBJECT (time_minutes_spinner), "value-changed", G_CALLBACK (on_spin_value_changed), NULL);
g_signal_connect (G_OBJECT (time_seconds_spinner), "value-changed", G_CALLBACK (on_spin_value_changed), NULL);
/* Check that we're running gtk+ for supported gtk_spin_button 'wrapped' functionality */
#if (GTK_MINOR_VERSION >= 20)
g_signal_connect (G_OBJECT (time_hours_spinner), "wrapped", G_CALLBACK (on_spin_value_wrapped), NULL);
g_signal_connect (G_OBJECT (time_minutes_spinner), "wrapped", G_CALLBACK (on_spin_value_wrapped), NULL);
g_signal_connect (G_OBJECT (time_seconds_spinner), "wrapped", G_CALLBACK (on_spin_value_wrapped), NULL);
#endif
g_signal_connect (G_OBJECT (action_combo), "changed", G_CALLBACK (on_action_value_changed), NULL);
g_signal_connect (G_OBJECT (enable_alarm), "toggled", G_CALLBACK (on_enable_toggle), NULL);
gtk_box_pack_start (GTK_BOX (alarm_pref_vbox), enable_alarm, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (alarm_pref_vbox), alarm_pref_table, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (container), alarm_pref_vbox);
gtk_widget_show_all (container);
}
static void init_control_page(GuiInfo *gui, GtkNotebook *window_notebook) {
GtkWidget *controlhbox;
GtkWidget *controlvbox1;
GtkWidget *controlvbox2;
GtkWidget *controltablabel;
GtkWidget *bat_speed_label;
GtkWidget *bat_speed_hbox;
GtkObject *bat_speed_adjustment;
GtkWidget *bat_speed_sbutton;
GtkWidget *method_frame;
GtkWidget *method_vbox;
GtkWidget *method_mouse_radio;
GtkWidget *method_keyboard_radio;
GtkWidget *keyb_frame;
GtkWidget *keyb_vbox;
GtkWidget *keyb_left_hbox;
GtkWidget *keyb_left_label;
GtkWidget *keyb_left_entry;
GtkWidget *keyb_right_hbox;
GtkWidget *keyb_right_label;
GtkWidget *keyb_right_entry;
GtkWidget *keyb_fire1_hbox;
GtkWidget *keyb_fire1_label;
GtkWidget *keyb_fire1_entry;
GtkWidget *keyb_fire2_hbox;
GtkWidget *keyb_fire2_label;
GtkWidget *keyb_fire2_entry;
/* Init the vbox */
controlhbox = gtk_hbox_new(TRUE, GNOME_PAD);
controlvbox1 = gtk_vbox_new(TRUE, GNOME_PAD);
controlvbox2 = gtk_vbox_new(TRUE, GNOME_PAD);
controltablabel = gtk_label_new(_("Control"));
gtk_box_pack_start(GTK_BOX(controlhbox), controlvbox1, TRUE, TRUE, GNOME_PAD);
gtk_box_pack_start(GTK_BOX(controlhbox), controlvbox2, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(controlhbox);
gtk_widget_show(controlvbox1);
gtk_widget_show(controlvbox2);
/* Method Frame and Radio Buttons */
method_frame = gtk_frame_new(_("Method"));
gtk_frame_set_shadow_type(GTK_FRAME(method_frame), GTK_SHADOW_ETCHED_IN);
method_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(method_frame), method_vbox);
method_keyboard_radio = gtk_radio_button_new_with_label(NULL, _("Keyboard"));
method_mouse_radio = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(method_keyboard_radio), _("Mouse"));
gtk_box_pack_start_defaults(GTK_BOX(method_vbox),
method_keyboard_radio);
gtk_box_pack_start_defaults(GTK_BOX(method_vbox),
method_mouse_radio);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(method_mouse_radio),
newflags->mouse_control);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(method_keyboard_radio),
newflags->keyboard_control);
gtk_box_pack_start(GTK_BOX(controlvbox1), method_frame, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(method_frame);
gtk_widget_show(method_vbox);
gtk_widget_show(method_keyboard_radio);
gtk_widget_show(method_mouse_radio);
g_signal_connect(GTK_OBJECT(method_keyboard_radio), "toggled",
GTK_SIGNAL_FUNC(cb_ctrl_key), NULL);
g_signal_connect(GTK_OBJECT(method_mouse_radio), "toggled",
GTK_SIGNAL_FUNC(cb_ctrl_mouse), NULL);
/* Bat speed */
bat_speed_label = gtk_label_new(_("Bat speed: "));
bat_speed_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
bat_speed_adjustment = gtk_adjustment_new((gfloat) newflags->bat_speed,
(gfloat) MIN_BATSPEED, (gfloat) MAX_BATSPEED,
1.0, 5.0, 1.0);
bat_speed_sbutton = gtk_spin_button_new(
GTK_ADJUSTMENT(bat_speed_adjustment), 1.0, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(bat_speed_sbutton), 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(bat_speed_sbutton), FALSE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(bat_speed_sbutton), TRUE);
gtk_box_pack_start_defaults(GTK_BOX(bat_speed_hbox), bat_speed_label);
gtk_box_pack_start_defaults(GTK_BOX(bat_speed_hbox), bat_speed_sbutton);
gtk_box_pack_start(GTK_BOX(controlvbox1), bat_speed_hbox, TRUE, FALSE, GNOME_PAD);
gtk_widget_show(bat_speed_label);
gtk_widget_show(bat_speed_hbox);
gtk_widget_show(bat_speed_sbutton);
g_signal_connect(GTK_OBJECT(bat_speed_adjustment), "value_changed",
GTK_SIGNAL_FUNC(cb_bat_speed), bat_speed_sbutton);
/* Keybindings Frame */
keyb_frame = gtk_frame_new(_("Keybindings"));
gtk_frame_set_shadow_type(GTK_FRAME(keyb_frame), GTK_SHADOW_ETCHED_IN);
keyb_vbox = gtk_vbox_new(TRUE, GNOME_PAD);
gtk_container_add(GTK_CONTAINER(keyb_frame), keyb_vbox);
gtk_box_pack_start(GTK_BOX(controlvbox2), keyb_frame, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(keyb_vbox);
gtk_widget_show(keyb_frame);
/* KB: Left */
keyb_left_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
keyb_left_label = gtk_label_new(_("Left:"));
gtk_misc_set_alignment(GTK_MISC(keyb_left_label), 0.0, 0.5);
keyb_left_entry = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(keyb_left_entry), FALSE);
gtk_entry_set_text(GTK_ENTRY(keyb_left_entry),
gdk_keyval_name(newflags->left_key));
gtk_box_pack_start_defaults(GTK_BOX(keyb_left_hbox), keyb_left_label);
gtk_box_pack_start_defaults(GTK_BOX(keyb_left_hbox), keyb_left_entry);
gtk_box_pack_start(GTK_BOX(keyb_vbox), keyb_left_hbox, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(keyb_left_label);
gtk_widget_show(keyb_left_entry);
gtk_widget_show(keyb_left_hbox);
g_signal_connect(GTK_OBJECT(keyb_left_entry), "key_press_event",
GTK_SIGNAL_FUNC(cb_key_left), NULL);
/* KB: Right */
keyb_right_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
keyb_right_label = gtk_label_new(_("Right:"));
gtk_misc_set_alignment(GTK_MISC(keyb_right_label), 0.0, 0.5);
keyb_right_entry = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(keyb_right_entry), FALSE);
gtk_entry_set_text(GTK_ENTRY(keyb_right_entry),
gdk_keyval_name(newflags->right_key));
gtk_box_pack_start_defaults(GTK_BOX(keyb_right_hbox), keyb_right_label);
gtk_box_pack_start_defaults(GTK_BOX(keyb_right_hbox), keyb_right_entry);
gtk_box_pack_start(GTK_BOX(keyb_vbox), keyb_right_hbox, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(keyb_right_label);
gtk_widget_show(keyb_right_entry);
gtk_widget_show(keyb_right_hbox);
g_signal_connect(GTK_OBJECT(keyb_right_entry), "key_press_event",
GTK_SIGNAL_FUNC(cb_key_right), NULL);
/* KB: Fire1 */
keyb_fire1_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
keyb_fire1_label = gtk_label_new(_("Fire One:"));
gtk_misc_set_alignment(GTK_MISC(keyb_fire1_label), 0.0, 0.5);
keyb_fire1_entry = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(keyb_fire1_entry), FALSE);
gtk_entry_set_text(GTK_ENTRY(keyb_fire1_entry),
gdk_keyval_name(newflags->fire1_key));
gtk_box_pack_start_defaults(GTK_BOX(keyb_fire1_hbox), keyb_fire1_label);
gtk_box_pack_start_defaults(GTK_BOX(keyb_fire1_hbox), keyb_fire1_entry);
gtk_box_pack_start(GTK_BOX(keyb_vbox), keyb_fire1_hbox, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(keyb_fire1_label);
gtk_widget_show(keyb_fire1_entry);
gtk_widget_show(keyb_fire1_hbox);
g_signal_connect(GTK_OBJECT(keyb_fire1_entry), "key_press_event",
GTK_SIGNAL_FUNC(cb_key_fire1), NULL);
/* KB: Fire2 */
keyb_fire2_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
keyb_fire2_label = gtk_label_new(_("Fire Two:"));
gtk_misc_set_alignment(GTK_MISC(keyb_fire2_label), 0.0, 0.5);
keyb_fire2_entry = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(keyb_fire2_entry), FALSE);
gtk_entry_set_text(GTK_ENTRY(keyb_fire2_entry),
gdk_keyval_name(newflags->fire2_key));
gtk_box_pack_start_defaults(GTK_BOX(keyb_fire2_hbox), keyb_fire2_label);
gtk_box_pack_start_defaults(GTK_BOX(keyb_fire2_hbox), keyb_fire2_entry);
gtk_box_pack_start(GTK_BOX(keyb_vbox), keyb_fire2_hbox, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(keyb_fire2_label);
gtk_widget_show(keyb_fire2_entry);
gtk_widget_show(keyb_fire2_hbox);
g_signal_connect(GTK_OBJECT(keyb_fire2_entry), "key_press_event",
GTK_SIGNAL_FUNC(cb_key_fire2), NULL);
/* Add it to the dialog */
gtk_notebook_append_page(GTK_NOTEBOOK(window_notebook),
controlhbox, controltablabel);
}
GtkWidget *
gimp_prop_widget_new_from_pspec (GObject *config,
GParamSpec *pspec,
GimpContext *context,
GimpCreatePickerFunc create_picker_func,
gpointer picker_creator,
const gchar **label)
{
GtkWidget *widget = NULL;
g_return_val_if_fail (G_IS_OBJECT (config), NULL);
g_return_val_if_fail (pspec != NULL, NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (label != NULL, NULL);
*label = NULL;
if (GEGL_IS_PARAM_SPEC_SEED (pspec))
{
GtkAdjustment *adj;
GtkWidget *spin;
GtkWidget *button;
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
spin = gimp_prop_spin_button_new (config, pspec->name,
1.0, 10.0, 0);
gtk_box_pack_start (GTK_BOX (widget), spin, TRUE, TRUE, 0);
gtk_widget_show (spin);
button = gtk_button_new_with_label (_("New Seed"));
gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0);
gtk_widget_show (button);
adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_prop_widget_new_seed_clicked),
adj);
*label = g_param_spec_get_nick (pspec);
}
else if (G_IS_PARAM_SPEC_INT (pspec) ||
G_IS_PARAM_SPEC_UINT (pspec) ||
G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec))
{
gdouble lower;
gdouble upper;
gdouble step;
gdouble page;
gint digits;
if (GEGL_IS_PARAM_SPEC_DOUBLE (pspec))
{
GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (pspec);
lower = gspec->ui_minimum;
upper = gspec->ui_maximum;
step = gspec->ui_step_small;
page = gspec->ui_step_big;
digits = gspec->ui_digits;
}
else if (GEGL_IS_PARAM_SPEC_INT (pspec))
{
GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (pspec);
lower = gspec->ui_minimum;
upper = gspec->ui_maximum;
step = gspec->ui_step_small;
page = gspec->ui_step_big;
digits = 0;
}
else
{
gdouble value;
_gimp_prop_widgets_get_numeric_values (config, pspec,
&value, &lower, &upper,
G_STRFUNC);
if ((upper - lower <= 1.0) &&
(G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec)))
{
step = 0.01;
page = 0.1;
digits = 4;
}
else if ((upper - lower <= 10.0) &&
(G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec)))
{
step = 0.1;
page = 1.0;
digits = 3;
}
else
{
step = 1.0;
page = 10.0;
digits = (G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec)) ? 2 : 0;
}
}
widget = gimp_prop_spin_scale_new (config, pspec->name, NULL,
step, page, digits);
if (HAS_KEY (pspec, "unit", "degree") &&
(upper - lower) == 360.0)
{
GtkWidget *hbox;
GtkWidget *dial;
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (widget), TRUE);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
dial = gimp_prop_angle_dial_new (config, pspec->name);
gtk_box_pack_start (GTK_BOX (hbox), dial, FALSE, FALSE, 0);
gtk_widget_show (dial);
widget = hbox;
}
else if (HAS_KEY (pspec, "unit", "kelvin"))
{
GtkWidget *hbox;
GtkWidget *button;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
button = gimp_prop_kelvin_presets_new (config, pspec->name);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
widget = hbox;
}
}
else if (G_IS_PARAM_SPEC_STRING (pspec))
{
static GQuark multiline_quark = 0;
if (! multiline_quark)
multiline_quark = g_quark_from_static_string ("multiline");
if (GIMP_IS_PARAM_SPEC_CONFIG_PATH (pspec))
{
widget =
gimp_prop_file_chooser_button_new (config, pspec->name,
g_param_spec_get_nick (pspec),
GTK_FILE_CHOOSER_ACTION_OPEN);
}
else if (g_param_spec_get_qdata (pspec, multiline_quark))
{
GtkTextBuffer *buffer;
GtkWidget *view;
buffer = gimp_prop_text_buffer_new (config, pspec->name, -1);
view = gtk_text_view_new_with_buffer (buffer);
g_object_unref (buffer);
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (widget), view);
gtk_widget_show (view);
}
else
{
widget = gimp_prop_entry_new (config, pspec->name, -1);
}
*label = g_param_spec_get_nick (pspec);
}
else if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
{
widget = gimp_prop_check_button_new (config, pspec->name,
g_param_spec_get_nick (pspec));
}
else if (G_IS_PARAM_SPEC_ENUM (pspec))
{
widget = gimp_prop_enum_combo_box_new (config, pspec->name, 0, 0);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (widget),
g_param_spec_get_nick (pspec));
}
else if (GIMP_IS_PARAM_SPEC_RGB (pspec))
{
GtkWidget *button;
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
button = gimp_prop_color_button_new (config, pspec->name,
g_param_spec_get_nick (pspec),
128, 24,
GIMP_COLOR_AREA_SMALL_CHECKS);
gimp_color_button_set_update (GIMP_COLOR_BUTTON (button), TRUE);
gimp_color_panel_set_context (GIMP_COLOR_PANEL (button), context);
gtk_box_pack_start (GTK_BOX (widget), button, TRUE, TRUE, 0);
gtk_widget_show (button);
if (create_picker_func)
{
button = create_picker_func (picker_creator,
pspec->name,
GIMP_STOCK_COLOR_PICKER_GRAY,
_("Pick color from the image"));
gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0);
gtk_widget_show (button);
}
*label = g_param_spec_get_nick (pspec);
}
else
{
g_warning ("%s: not supported: %s (%s)\n", G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (pspec)), pspec->name);
}
return widget;
}
static GtkWidget *
arc_get_properties(Arc *arc)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *color;
GtkWidget *linestyle;
GtkWidget *arrow;
GtkWidget *line_width;
GtkWidget *align;
GtkAdjustment *adj;
if (arc_properties_dialog == NULL) {
arc_properties_dialog = g_new(ArcPropertiesDialog, 1);
vbox = gtk_vbox_new(FALSE, 5);
arc_properties_dialog->vbox = vbox;
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Line width:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
adj = (GtkAdjustment *) gtk_adjustment_new(0.1, 0.00, 10.0, 0.01, 0.0, 0.0);
line_width = gtk_spin_button_new(adj, 1.0, 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(line_width), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(line_width), TRUE);
arc_properties_dialog->line_width = GTK_SPIN_BUTTON(line_width);
gtk_box_pack_start(GTK_BOX (hbox), line_width, TRUE, TRUE, 0);
gtk_widget_show (line_width);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Color:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
color = dia_color_selector_new();
arc_properties_dialog->color = DIACOLORSELECTOR(color);
gtk_box_pack_start (GTK_BOX (hbox), color, TRUE, TRUE, 0);
gtk_widget_show (color);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Line style:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
linestyle = dia_line_style_selector_new();
arc_properties_dialog->line_style = DIALINESTYLESELECTOR(linestyle);
gtk_box_pack_start (GTK_BOX (hbox), linestyle, TRUE, TRUE, 0);
gtk_widget_show (linestyle);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Start arrow:"));
align = gtk_alignment_new(0.0,0.0,0.0,0.0);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, TRUE, 0);
gtk_widget_show (label);
gtk_widget_show(align);
arrow = dia_arrow_selector_new();
arc_properties_dialog->start_arrow = DIAARROWSELECTOR(arrow);
gtk_box_pack_start (GTK_BOX (hbox), arrow, TRUE, TRUE, 0);
gtk_widget_show (arrow);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("End arrow:"));
align = gtk_alignment_new(0.0,0.0,0.0,0.0);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, TRUE, 0);
gtk_widget_show (label);
gtk_widget_show(align);
arrow = dia_arrow_selector_new();
arc_properties_dialog->end_arrow = DIAARROWSELECTOR(arrow);
gtk_box_pack_start (GTK_BOX (hbox), arrow, TRUE, TRUE, 0);
gtk_widget_show (arrow);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
}
gtk_spin_button_set_value(arc_properties_dialog->line_width, arc->line_width);
dia_color_selector_set_color(arc_properties_dialog->color, &arc->arc_color);
dia_line_style_selector_set_linestyle(arc_properties_dialog->line_style,
arc->line_style, arc->dashlength);
dia_arrow_selector_set_arrow(arc_properties_dialog->start_arrow,
arc->start_arrow);
dia_arrow_selector_set_arrow(arc_properties_dialog->end_arrow,
arc->end_arrow);
return arc_properties_dialog->vbox;
}
/* Initialise the "game" section of the preferences box */
void init_game_page(GuiInfo *gui, GtkNotebook *window_notebook) {
GtkWidget *gametablabel;
GtkWidget *gamehbox;
GtkWidget *gamevbox1;
GtkWidget *gamevbox2;
GtkWidget *bounce_entropy_label;
GtkWidget *bounce_entropy_hbox;
GtkObject *bounce_entropy_adjustment;
GtkWidget *bounce_entropy_sbutton;
GtkWidget *hide_pointer_check;
GtkWidget *pause_frame;
GtkWidget *pause_vbox;
GtkWidget *pause_on_pointer_check;
GtkWidget *pause_on_focus_check;
GtkWidget *pause_on_pref_check;
static LevelFrame lf;
GList *levelfiles;
GtkWidget *difficulty_frame;
GtkWidget *difficulty_vbox;
GtkWidget *difficulty_easy_radio;
GtkWidget *difficulty_medium_radio;
GtkWidget *difficulty_hard_radio;
GtkTreeSelection *level_list_selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/* Reset levelframe */
memset(&lf, 0, sizeof(lf));
/* Vbox and Tablabel - Constructor */
gametablabel = gtk_label_new(_("Game"));
gamehbox = gtk_hbox_new(FALSE, GNOME_PAD);
gamevbox1 = gtk_vbox_new(FALSE, GNOME_PAD);
gamevbox2 = gtk_vbox_new(FALSE, GNOME_PAD);
/* Vbox and Tablabel - Packing */
gtk_box_pack_start(GTK_BOX(gamehbox), gamevbox1, TRUE, TRUE, GNOME_PAD);
gtk_box_pack_start(GTK_BOX(gamehbox), gamevbox2, TRUE, TRUE, GNOME_PAD);
/* Vbox and Tablabel - Show */
gtk_widget_show(gametablabel);
gtk_widget_show(gamehbox);
gtk_widget_show(gamevbox1);
gtk_widget_show(gamevbox2);
/* Level Frame - Constructor */
lf.game = gui->game;
lf.frame = gtk_frame_new(_("Levels"));
lf.vbox = gtk_vbox_new(FALSE, 0);
lf.level_list_store = gtk_list_store_new(1, G_TYPE_STRING);
lf.level_list_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(
GTK_TREE_MODEL(lf.level_list_store)));
//lf.warning_label = gtk_label_new(_("Levels cannot be added or removed\nwhile the game is running."));
lf.button_hbox = gtk_hbox_new(TRUE, 0);
lf.level_list_hbox = gtk_hbox_new(TRUE, 0);
lf.add_button = gtk_button_new_with_label(_("Add"));
lf.remove_button = gtk_button_new_with_label(_("Remove"));
lf.game = gui->game;
lf.level_list_scrollpane = gtk_scrolled_window_new(NULL, NULL);
lf.level_list_selection = NULL;
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("",
renderer, "text", 0, NULL);
gtk_tree_view_append_column(lf.level_list_view, column);
/* Level Frame - Settings */
level_list_selection = gtk_tree_view_get_selection(lf.level_list_view);
gtk_tree_selection_set_mode(level_list_selection, GTK_SELECTION_SINGLE);
gtk_frame_set_shadow_type(GTK_FRAME(lf.frame), GTK_SHADOW_ETCHED_IN);
//gtk_clist_set_shadow_type(GTK_CLIST(lf.clist), GTK_SHADOW_ETCHED_IN);
//gtk_clist_set_column_width(GTK_CLIST(lf.clist), 0, 200);
levelfiles = leveldata_titlelist();
populate_level_list(&lf, levelfiles);
g_list_free(levelfiles);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (lf.level_list_scrollpane), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_tree_view_set_headers_visible(lf.level_list_view, FALSE);
/* Level Frame - Signals */
g_signal_connect(G_OBJECT(level_list_selection), "changed", G_CALLBACK(cb_level_list_changed), (gpointer) &lf);
/*
g_signal_connect_object(GTK_OBJECT(lf.add_button), "clicked", GTK_SIGNAL_FUNC(cb_level_add), (gpointer) &lf, 0);
g_signal_connect_object(GTK_OBJECT(lf.remove_button), "clicked", GTK_SIGNAL_FUNC(cb_level_remove), (gpointer) &lf, 0);
*/
g_signal_connect(GTK_OBJECT(lf.add_button), "clicked", GTK_SIGNAL_FUNC(cb_level_add), (gpointer) &lf);
g_signal_connect(GTK_OBJECT(lf.remove_button), "clicked", GTK_SIGNAL_FUNC(cb_level_remove), (gpointer) &lf);
/* Level Frame - Sensitivity */
if(gui->game->state != STATE_STOPPED) {
gtk_widget_set_sensitive(GTK_WIDGET(lf.add_button), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lf.level_list_view), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lf.level_list_scrollpane), FALSE);
}
gtk_widget_set_sensitive(GTK_WIDGET(lf.remove_button), FALSE);
/* Level Frame - Packing */
gtk_box_pack_start(GTK_BOX(gamevbox1), lf.frame, TRUE, TRUE, GNOME_PAD);
gtk_container_add(GTK_CONTAINER(lf.frame), lf.vbox);
//gtk_box_pack_start_defaults(GTK_BOX(lf.vbox), lf.warning_label);
gtk_box_pack_start(GTK_BOX(lf.vbox), lf.level_list_hbox, TRUE, TRUE, GNOME_PAD);
gtk_box_pack_start(GTK_BOX(lf.vbox), lf.button_hbox, FALSE, FALSE, GNOME_PAD);
gtk_container_add(GTK_CONTAINER(lf.level_list_scrollpane), GTK_WIDGET(lf.level_list_view));
gtk_box_pack_start(GTK_BOX(lf.level_list_hbox), lf.level_list_scrollpane, TRUE, TRUE, GNOME_PAD);
gtk_box_pack_start(GTK_BOX(lf.button_hbox), lf.add_button, TRUE, TRUE, GNOME_PAD);
gtk_box_pack_start(GTK_BOX(lf.button_hbox), lf.remove_button, TRUE, TRUE, GNOME_PAD);
/* Level Frame - Show */
gtk_widget_show(lf.frame);
gtk_widget_show(lf.vbox);
gtk_widget_show(GTK_WIDGET(lf.level_list_view));
//gtk_widget_show(lf.warning_label);
gtk_widget_show(lf.button_hbox);
gtk_widget_show(lf.level_list_hbox);
gtk_widget_show(lf.level_list_scrollpane);
gtk_widget_show(lf.add_button);
gtk_widget_show(lf.remove_button);
/* Difficulty frame and radio buttons - Constructor */
if(gui->game->state == STATE_STOPPED)
difficulty_frame = gtk_frame_new(_("Difficulty"));
else
difficulty_frame = gtk_frame_new(_("Difficulty (next game)"));
difficulty_vbox = gtk_vbox_new(FALSE, 0);
difficulty_easy_radio = gtk_radio_button_new_with_label(NULL,
_("Easy"));
difficulty_medium_radio = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(difficulty_easy_radio), _("Medium"));
difficulty_hard_radio = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(difficulty_easy_radio), _("Hard"));
/* Difficulty frame and radio buttons - Settings/Defaults */
gtk_frame_set_shadow_type(GTK_FRAME(difficulty_frame), GTK_SHADOW_ETCHED_IN);
switch(newflags->next_game_difficulty) {
case DIFFICULTY_EASY :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(difficulty_easy_radio), TRUE);
break;
case DIFFICULTY_MEDIUM :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(difficulty_medium_radio), TRUE);
break;
case DIFFICULTY_HARD :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(difficulty_hard_radio), TRUE);
break;
default :
g_assert_not_reached();
}
/* Difficulty frame and radio buttons - Signals */
g_signal_connect(GTK_OBJECT(difficulty_easy_radio), "toggled",
GTK_SIGNAL_FUNC(cb_diff), (gpointer) DIFFICULTY_EASY);
g_signal_connect(GTK_OBJECT(difficulty_medium_radio), "toggled",
GTK_SIGNAL_FUNC(cb_diff), (gpointer) DIFFICULTY_MEDIUM);
g_signal_connect(GTK_OBJECT(difficulty_hard_radio), "toggled",
GTK_SIGNAL_FUNC(cb_diff), (gpointer) DIFFICULTY_HARD);
/* Difficulty frame and radio buttons - Packing */
gtk_box_pack_start_defaults(GTK_BOX(difficulty_vbox),
difficulty_easy_radio);
gtk_box_pack_start_defaults(GTK_BOX(difficulty_vbox),
difficulty_medium_radio);
gtk_box_pack_start_defaults(GTK_BOX(difficulty_vbox),
difficulty_hard_radio);
gtk_container_add(GTK_CONTAINER(difficulty_frame), difficulty_vbox);
gtk_box_pack_start(GTK_BOX(gamevbox2), difficulty_frame, TRUE, TRUE, GNOME_PAD);
/* Difficulty frame and radio buttons - Show */
gtk_widget_show(difficulty_frame);
gtk_widget_show(difficulty_vbox);
gtk_widget_show(difficulty_easy_radio);
gtk_widget_show(difficulty_medium_radio);
gtk_widget_show(difficulty_hard_radio);
/* Automatic Pause Frame - Constructor */
pause_frame = gtk_frame_new(_("Automatic Pause"));
pause_vbox = gtk_vbox_new(FALSE, 0);
pause_on_focus_check = gtk_check_button_new_with_label(_("When we lose keyboard focus"));
pause_on_pointer_check = gtk_check_button_new_with_label(_("When the mouse pointer leaves the play window"));
pause_on_pref_check = gtk_check_button_new_with_label(_("When the preferences dialog is active"));
/* Automatic Pause Frame - Settings */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pause_on_focus_check), newflags->pause_on_focus);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pause_on_pref_check), newflags->pause_on_pref);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pause_on_pointer_check), newflags->pause_on_pointer);
/* Automatic Pause Frame - Signals */
g_signal_connect(GTK_OBJECT(pause_on_focus_check), "toggled", GTK_SIGNAL_FUNC(cb_checkbox_toggled), &newflags->pause_on_focus);
g_signal_connect(GTK_OBJECT(pause_on_pointer_check), "toggled", GTK_SIGNAL_FUNC(cb_checkbox_toggled), &newflags->pause_on_pointer);
g_signal_connect(GTK_OBJECT(pause_on_pref_check), "toggled", GTK_SIGNAL_FUNC(cb_checkbox_toggled), &newflags->pause_on_pref);
/* Automatic Pause Frame - Packing */
gtk_box_pack_start_defaults(GTK_BOX(pause_vbox), pause_on_focus_check);
gtk_box_pack_start_defaults(GTK_BOX(pause_vbox), pause_on_pointer_check);
gtk_box_pack_start_defaults(GTK_BOX(pause_vbox), pause_on_pref_check);
gtk_container_add(GTK_CONTAINER(pause_frame), pause_vbox);
gtk_box_pack_start(GTK_BOX(gamevbox2), pause_frame, TRUE, FALSE, GNOME_PAD);
/* Automatic Pause Frame - Show */
gtk_widget_show(pause_frame);
gtk_widget_show(pause_vbox);
gtk_widget_show(pause_on_pointer_check);
gtk_widget_show(pause_on_focus_check);
gtk_widget_show(pause_on_pref_check);
/* Hide pointer */
hide_pointer_check = gtk_check_button_new_with_label(
_("Hide the pointer"));
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(hide_pointer_check),
newflags->hide_pointer);
gtk_box_pack_start(GTK_BOX(gamevbox2), hide_pointer_check,
TRUE, FALSE, GNOME_PAD);
gtk_widget_show(hide_pointer_check);
g_signal_connect(GTK_OBJECT(hide_pointer_check), "toggled",
GTK_SIGNAL_FUNC(cb_checkbox_toggled),
&newflags->hide_pointer);
/* Bounce Entropy - Constructor */
bounce_entropy_label = gtk_label_new(_("Bounce Entropy (Experimental): "));
bounce_entropy_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
bounce_entropy_adjustment = gtk_adjustment_new((gfloat)
newflags->bounce_entropy, (gfloat) MIN_BOUNCE_ENTROPY,
(gfloat) MAX_BOUNCE_ENTROPY, 1.0, 5.0, 1.0);
bounce_entropy_sbutton = gtk_spin_button_new(
GTK_ADJUSTMENT(bounce_entropy_adjustment), 1.0, 0);
/* Bounce Entropy - Settings */
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(bounce_entropy_sbutton), 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(bounce_entropy_sbutton),
FALSE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(bounce_entropy_sbutton),
TRUE);
/* Bounce Entropy - Signals */
g_signal_connect(GTK_OBJECT(bounce_entropy_adjustment),
"value_changed", GTK_SIGNAL_FUNC(cb_bounce_entropy),
bounce_entropy_sbutton);
/* Bounce Entropy - Packing */
gtk_box_pack_start_defaults(GTK_BOX(bounce_entropy_hbox),
bounce_entropy_label);
gtk_box_pack_start_defaults(GTK_BOX(bounce_entropy_hbox),
bounce_entropy_sbutton);
gtk_box_pack_start(GTK_BOX(gamevbox2), bounce_entropy_hbox, TRUE,
FALSE, GNOME_PAD);
/* Bounce Entropy - Show */
gtk_widget_show(bounce_entropy_label);
gtk_widget_show(bounce_entropy_hbox);
gtk_widget_show(bounce_entropy_sbutton);
/* Add the game vbox to the dialog */
gtk_notebook_append_page(GTK_NOTEBOOK(window_notebook),
gamehbox, gametablabel);
}
int main (int argc, char *argv[]) {
GError *error_parsearg = NULL;
GOptionContext *context;
GtkWidget *window, *vbox, *hbox2;
GtkAdjustment *sadj, *madj, *hadj;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
gtk_init (&argc, &argv);
notify_init ("Gtimer");
ca_context_create (&sound);
context = g_option_context_new (_("- a simple countdown timer"));
g_option_context_add_main_entries (context, entries, NULL);
#ifdef ENABLE_NLS
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
#endif
if (!g_option_context_parse (context, &argc, &argv, &error_parsearg)) {
g_fprintf (stderr, "%s\n", error_parsearg->message);
exit(1);
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_spacing (GTK_BOX (hbox2), 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
timer_display = gtk_label_new (NULL);
reset_display();
sadj = gtk_adjustment_new (0, 0, 60, 1, 1, 0);
madj = gtk_adjustment_new (0, 0, 60, 1, 1, 0);
hadj = gtk_adjustment_new (0, 0, 24, 1, 1, 0);
spin_seconds = gtk_spin_button_new (sadj, 1, 0);
spin_minutes = gtk_spin_button_new (madj, 1, 0);
spin_hours = gtk_spin_button_new (hadj, 1, 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spin_seconds), TRUE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_seconds), seconds);
g_object_set (spin_seconds, "shadow-type", GTK_SHADOW_IN, NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spin_minutes), TRUE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_minutes), minutes);
g_object_set (spin_minutes, "shadow-type", GTK_SHADOW_IN, NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spin_hours), TRUE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_hours), hours);
g_object_set (spin_hours, "shadow-type", GTK_SHADOW_IN, NULL);
entry = gtk_entry_new();
gtk_entry_set_text (GTK_ENTRY (entry), entry_text);
button_timer = gtk_button_new();
gtk_button_set_label (GTK_BUTTON (button_timer), _("Start"));
button_reset = gtk_button_new_with_label (_("Reset"));
gtk_widget_set_sensitive (button_reset, FALSE);
gtk_box_pack_start (GTK_BOX (hbox1), spin_hours, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox1), spin_minutes, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox1), spin_seconds, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), timer_display, FALSE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (hbox2), button_timer, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox2), button_reset, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (vbox), hbox1);
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, TRUE, 5);
gtk_container_add (GTK_CONTAINER (vbox), hbox2);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Gtimer");
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show_all (window);
g_timeout_add_seconds (1, (GSourceFunc) timer_function, NULL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (button_timer, "clicked", G_CALLBACK (on_timer_button_clicked), NULL);
g_signal_connect (button_reset, "clicked", G_CALLBACK (on_reset_button_clicked), NULL);
gtk_main();
notify_uninit();
ca_context_destroy (sound);
g_option_context_free (context);
return 0;
}
/** \brief Create and initialise widgets for the radios tab.
*
* The widgets must be preloaded with values from config. If a config value
* is NULL, sensible default values, eg. those from defaults.h should
* be laoded.
*/
GtkWidget *sat_pref_conditions_create ()
{
GtkWidget *table;
GtkWidget *label;
GtkWidget *vbox;
dirty = FALSE;
reset = FALSE;
table = gtk_table_new (14, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
/* minimum elevation */
label = gtk_label_new (_("Minimum elevation"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 0, 1,
GTK_FILL,
GTK_SHRINK,
0, 0);
minel = gtk_spin_button_new_with_range (1, 90, 1);
gtk_widget_set_tooltip_text (minel,
_("Elevation threshold for passes.\n"\
"Passes with maximum elevation below this limit "\
"will be omitted"));
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (minel), 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (minel), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (minel), FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (minel),
sat_cfg_get_int (SAT_CFG_INT_PRED_MIN_EL));
g_signal_connect (G_OBJECT (minel), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), minel,
1, 2, 0, 1,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[deg]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
2, 3, 0, 1,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* separator */
gtk_table_attach (GTK_TABLE (table),
gtk_hseparator_new (),
0, 3, 1, 2,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Multiple Passes:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 2, 3,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* number of passes */
label = gtk_label_new (_("Number of passes to predict"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 3, 4,
GTK_FILL,
GTK_SHRINK,
0, 0);
numpass = gtk_spin_button_new_with_range (5, 50, 1);
gtk_widget_set_tooltip_text (numpass,
_("The maximum number of passes to predict."));
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (numpass), 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (numpass), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (numpass), FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (numpass),
sat_cfg_get_int (SAT_CFG_INT_PRED_NUM_PASS));
g_signal_connect (G_OBJECT (numpass), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), numpass,
1, 2, 3, 4,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* lookahead */
label = gtk_label_new (_("Passes should occur within"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 4, 5,
GTK_FILL,
GTK_SHRINK,
0, 0);
lookahead = gtk_spin_button_new_with_range (1, 14, 1);
gtk_widget_set_tooltip_text (lookahead,
_("Only passes that occur within the specified "\
"number of days will be shown."));
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (lookahead), 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (lookahead), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (lookahead), FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (lookahead),
sat_cfg_get_int (SAT_CFG_INT_PRED_LOOK_AHEAD));
g_signal_connect (G_OBJECT (lookahead), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), lookahead,
1, 2, 4, 5,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[days]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
2, 3, 4, 5,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* separator */
gtk_table_attach (GTK_TABLE (table),
gtk_hseparator_new (),
0, 3, 5, 6,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Pass Details:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 6, 7,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* time resolution */
label = gtk_label_new (_("Time resolution"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 7, 8,
GTK_FILL,
GTK_SHRINK,
0, 0);
res = gtk_spin_button_new_with_range (1, 600, 1);
gtk_widget_set_tooltip_text (res,
_("Gpredict will try to show the pass details "\
"with the specified time resolution."));
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (res), 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (res), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (res), FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (res),
sat_cfg_get_int (SAT_CFG_INT_PRED_RESOLUTION));
g_signal_connect (G_OBJECT (res), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), res,
1, 2, 7, 8,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[sec]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
2, 3, 7, 8,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* number of entries */
label = gtk_label_new (_("Number of entries"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 8, 9,
GTK_FILL,
GTK_SHRINK,
0, 0);
nument = gtk_spin_button_new_with_range (10, 200, 1);
gtk_widget_set_tooltip_text (nument,
_("Gpredict will try to keep the number of rows " \
"in the detailed prediction within this limit."));
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (nument), 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (nument), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (nument), FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (nument),
sat_cfg_get_int (SAT_CFG_INT_PRED_NUM_ENTRIES));
g_signal_connect (G_OBJECT (nument), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), nument,
1, 2, 8, 9,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* separator */
gtk_table_attach (GTK_TABLE (table),
gtk_hseparator_new (),
0, 3, 9, 10,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* satellite visibility */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Satellite Visibility:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 10, 11,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* twilight threshold */
label = gtk_label_new (_("Twilight threshold"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 11, 12,
GTK_FILL,
GTK_SHRINK,
0, 0);
twspin = gtk_spin_button_new_with_range (-18, 0, 1);
gtk_widget_set_tooltip_text (twspin,
_("Satellites are only considered visible if the elevation "\
"of the Sun is below the specified threshold.\n"\
" \342\200\242 Astronomical: -18\302\260 to -12\302\260\n"\
" \342\200\242 Nautical: -12\302\260 to -6\302\260\n"\
" \342\200\242 Civil: -6\302\260 to 0\302\260"));
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (twspin), 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (twspin), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (twspin), FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (twspin),
sat_cfg_get_int (SAT_CFG_INT_PRED_TWILIGHT_THLD));
g_signal_connect (G_OBJECT (twspin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), twspin,
1, 2, 11, 12,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[deg]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
2, 3, 11, 12,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* separator */
gtk_table_attach (GTK_TABLE (table),
gtk_hseparator_new (),
0, 3, 12, 13,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* T0 for predictions */
tzero = gtk_check_button_new_with_label (_("Always use real time for pass predictions"));
gtk_widget_set_tooltip_text (tzero,
_("Check this box if you want Gpredict to always use "\
"the current (real) time as starting time when predicting "\
"future satellite passes.\n\n"\
"If you leave the box unchecked and the time controller is "\
"active, Gpredict will use the time from the time controller "\
"as starting time for predicting satellite passes."));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tzero),
sat_cfg_get_bool (SAT_CFG_BOOL_PRED_USE_REAL_T0));
g_signal_connect (G_OBJECT (tzero), "toggled",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), tzero, 0, 3, 13, 14,
GTK_FILL | GTK_EXPAND, GTK_SHRINK,
0, 0);
/* create vertical box */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 20);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
/* create RESET button */
create_reset_button (GTK_BOX (vbox));
return vbox;
}
/** \brief Create and initialise widgets for the sky-at-glance tab.
*
* The widgets must be preloaded with values from config. If a config value
* is NULL, sensible default values, eg. those from defaults.h should
* be laoded.
*/
GtkWidget *sat_pref_sky_at_glance_create ()
{
GtkWidget *table;
GtkWidget *label;
GtkWidget *vbox;
GdkColor col;
guint rgb; /* 0xRRGGBB encoded colour */
guint y;
dirty = FALSE;
reset = FALSE;
table = gtk_table_new (16, 5, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Time:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 0, 1,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* number of hours */
label = gtk_label_new (_("Find and show passes that occur within"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 1, 2,
GTK_FILL,
GTK_SHRINK,
0, 0);
timesp = gtk_spin_button_new_with_range (1, 24, 1);
gtk_widget_set_tooltip_text (timesp,
_("The passes shown on the Sky at a Glance chart\n"\
"will begin within this number of hours."));
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (timesp), 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (timesp), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (timesp), FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (timesp),
sat_cfg_get_int (SAT_CFG_INT_SKYATGL_TIME));
g_signal_connect (G_OBJECT (timesp), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), timesp,
1, 2, 1, 2,
GTK_SHRINK, GTK_SHRINK,
0, 0);
label = gtk_label_new (_("hours"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
2, 3, 1, 2,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* separator */
gtk_table_attach (GTK_TABLE (table),
gtk_hseparator_new (),
0, 5, 2, 3,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
y = 3;
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Colours:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y, y+1,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* colour 1 */
label = gtk_label_new (_("Colour for satellite 1: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y+1, y+2,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col1 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col1), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col1), _("Select colour 1"));
gtk_table_attach (GTK_TABLE (table), col1,
1, 2, y+1, y+2,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text ( col1,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_01);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col1), &col);
g_signal_connect (col1, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 2 */
label = gtk_label_new (_("Colour for satellite 2: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y+2, y+3,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col2 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col2), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col1), _("Select colour 2"));
gtk_table_attach (GTK_TABLE (table), col2,
1, 2, y+2, y+3,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text ( col2,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_02);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col2), &col);
g_signal_connect (col2, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 3 */
label = gtk_label_new (_("Colour for satellite 3: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y+3, y+4,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col3 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col3), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col3), _("Select colour 3"));
gtk_table_attach (GTK_TABLE (table), col3,
1, 2, y+3, y+4,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col3,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_03);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col3), &col);
g_signal_connect (col3, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 4 */
label = gtk_label_new (_("Colour for satellite 4: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y+4, y+5,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col4 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col4), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col4), _("Select colour 4"));
gtk_table_attach (GTK_TABLE (table), col4,
1, 2, y+4, y+5,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col4,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_04);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col4), &col);
g_signal_connect (col4, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 5 */
label = gtk_label_new (_("Colour for satellite 5: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y+5, y+6,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col5 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col5), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col5), _("Select colour 5"));
gtk_table_attach (GTK_TABLE (table), col5,
1, 2, y+5, y+6,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col5,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_05);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col5), &col);
g_signal_connect (col5, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 6 */
label = gtk_label_new (_("Colour for satellite 6: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
3, 4, y+1, y+2,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col6 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col6), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col6), _("Select colour 6"));
gtk_table_attach (GTK_TABLE (table), col6,
4, 5, y+1, y+2,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col6,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_06);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col6), &col);
g_signal_connect (col6, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 7 */
label = gtk_label_new (_("Colour for satellite 7: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
3, 4, y+2, y+3,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col7 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col7), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col7), _("Select colour 7"));
gtk_table_attach (GTK_TABLE (table), col7,
4, 5, y+2, y+3,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col7,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_07);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col7), &col);
g_signal_connect (col7, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 8 */
label = gtk_label_new (_("Colour for satellite 8: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
3, 4, y+3, y+4,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col8 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col8), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col8), _("Select colour 8"));
gtk_table_attach (GTK_TABLE (table), col8,
4, 5, y+3, y+4,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col8,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_08);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col8), &col);
g_signal_connect (col8, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 9 */
label = gtk_label_new (_("Colour for satellite 9: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
3, 4, y+4, y+5,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col9 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col9), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col9), _("Select colour 9"));
gtk_table_attach (GTK_TABLE (table), col9,
4, 5, y+4, y+5,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col9,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_09);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col9), &col);
g_signal_connect (col9, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 10 */
label = gtk_label_new (_("Colour for satellite 10: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
3, 4, y+5, y+6,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col10 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col10), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col10), _("Select colour 10"));
gtk_table_attach (GTK_TABLE (table), col10,
4, 5, y+5, y+6,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col10,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_10);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col10), &col);
g_signal_connect (col10, "color-set", G_CALLBACK (colour_changed), NULL);
/* create vertical box */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 20);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
/* create RESET button */
create_reset_button (GTK_BOX (vbox));
return vbox;
}
GtkWidget* create_SurfaceInspector( void ){
GtkWidget *label;
GtkObject *adjustment;
GtkWidget *table1;
GtkWidget *table2;
GtkWidget *frame1;
GtkWidget *frame2;
GtkWidget *vbox1;
GtkWidget *hbox1;
SurfaceInspector = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_container_set_border_width( GTK_CONTAINER( SurfaceInspector ), 4 );
gtk_window_set_title( GTK_WINDOW( SurfaceInspector ), "Surface Inspector" );
SetWinPos_from_Prefs( SurfaceInspector );
vbox1 = gtk_vbox_new( FALSE, 5 );
gtk_widget_show( vbox1 );
gtk_container_add( GTK_CONTAINER( SurfaceInspector ), vbox1 );
hbox1 = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox1 );
gtk_container_add( GTK_CONTAINER( vbox1 ), hbox1 );
gtk_container_set_border_width( GTK_CONTAINER( hbox1 ), 4 );
label = gtk_label_new( "Texture: " );
gtk_widget_show( label );
gtk_box_pack_start( GTK_BOX( hbox1 ), label, FALSE, FALSE, 0 );
gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 );
texture_combo = gtk_combo_new();
g_object_set_data( G_OBJECT( GTK_COMBO( texture_combo )->popwin ),
"KeepMeAround", texture_combo );
gtk_combo_disable_activate( (GtkCombo*) texture_combo );
gtk_widget_show( texture_combo );
gtk_box_pack_start( GTK_BOX( hbox1 ), texture_combo, TRUE, TRUE, 0 );
texture_combo_entry = GTK_COMBO( texture_combo )->entry;
gtk_widget_show( texture_combo_entry );
gtk_entry_set_max_length( GTK_ENTRY( texture_combo_entry ), 1024 );
frame1 = gtk_frame_new( "Surface" );
gtk_widget_show( frame1 );
gtk_container_add( GTK_CONTAINER( vbox1 ), frame1 );
table1 = gtk_table_new( 7, 3, FALSE );
gtk_widget_show( table1 );
gtk_table_set_col_spacings( GTK_TABLE( table1 ), 5 );
gtk_table_set_row_spacings( GTK_TABLE( table1 ), 5 );
gtk_container_set_border_width( GTK_CONTAINER( table1 ), 5 );
gtk_container_add( GTK_CONTAINER( frame1 ), table1 );
label = gtk_label_new( "Step" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 2, 3, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
label = gtk_label_new( "Value" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 1, 2, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_misc_set_alignment( GTK_MISC( label ), 0.5, 1 );
label = gtk_label_new( "Horizontal shift: " );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 0, 1, 1, 2,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( GTK_FILL ), 0, 0 );
label = gtk_label_new( "Vertical shift: " );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 0, 1, 2, 3,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( GTK_FILL ), 0, 0 );
label = gtk_label_new( "Horizontal scale: " );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 0, 1, 3, 4,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( GTK_FILL ), 0, 0 );
label = gtk_label_new( "Vertical scale: " );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 0, 1, 4, 5,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( GTK_FILL ), 0, 0 );
label = gtk_label_new( "Rotate: " );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 0, 1, 5, 6,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( GTK_FILL ), 0, 0 );
// Value Spins
adjustment = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 0.0 );
hshift_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 2 );
gtk_widget_show( hshift_value_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), hshift_value_spinbutton, 1, 2, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hshift_value_spinbutton ), GTK_UPDATE_IF_VALID );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hshift_value_spinbutton ), TRUE );
adjustment = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 0.0 );
vshift_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 2 );
gtk_widget_show( vshift_value_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), vshift_value_spinbutton, 1, 2, 2, 3,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vshift_value_spinbutton ), GTK_UPDATE_IF_VALID );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( vshift_value_spinbutton ), TRUE );
adjustment = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 0.0 );
hscale_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 4 );
gtk_widget_show( hscale_value_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), hscale_value_spinbutton, 1, 2, 3, 4,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hscale_value_spinbutton ), GTK_UPDATE_IF_VALID );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hscale_value_spinbutton ), TRUE );
adjustment = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 0.0 );
vscale_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 4 );
gtk_widget_show( vscale_value_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), vscale_value_spinbutton, 1, 2, 4, 5,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vscale_value_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 0.0, -360.0, 360.0, 1.0, 10.0, 0.0 );
rotate_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 0 );
gtk_widget_show( rotate_value_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), rotate_value_spinbutton, 1, 2, 5, 6,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( rotate_value_spinbutton ), GTK_UPDATE_IF_VALID );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( rotate_value_spinbutton ), TRUE );
// Step Spins
adjustment = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 0.0 );
hshift_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 2 );
gtk_widget_show( hshift_step_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), hshift_step_spinbutton, 2, 3, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hshift_step_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 0.0 );
vshift_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 2 );
gtk_widget_show( vshift_step_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), vshift_step_spinbutton, 2, 3, 2, 3,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vshift_step_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 0.0 );
hscale_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 4 );
gtk_widget_show( hscale_step_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), hscale_step_spinbutton, 2, 3, 3, 4,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hscale_step_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 0.0 );
vscale_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 4 );
gtk_widget_show( vscale_step_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), vscale_step_spinbutton, 2, 3, 4, 5,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vscale_step_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 0.0, -360.0, 360.0, 1.0, 10.0, 0.0 );
rotate_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 2 );
gtk_widget_show( rotate_step_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), rotate_step_spinbutton, 2, 3, 5, 6,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( rotate_step_spinbutton ), GTK_UPDATE_IF_VALID );
match_grid_button = gtk_button_new_with_mnemonic( "Match Grid" );
gtk_widget_show( match_grid_button );
gtk_table_attach( GTK_TABLE( table1 ), match_grid_button, 2, 3, 6, 7,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
frame2 = gtk_frame_new( "Tools" );
gtk_widget_show( frame2 );
gtk_container_add( GTK_CONTAINER( vbox1 ), frame2 );
table2 = gtk_table_new( 2, 4, TRUE );
gtk_widget_show( table2 );
gtk_table_set_col_spacings( GTK_TABLE( table2), 5 );
gtk_table_set_row_spacings( GTK_TABLE( table2 ), 0 );
gtk_container_set_border_width( GTK_CONTAINER( table2 ), 5 );
gtk_container_add( GTK_CONTAINER( frame2 ), table2 );
label = gtk_label_new( "Height" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table2 ), label, 3, 4, 0, 1,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
label = gtk_label_new( "Width" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table2 ), label, 2, 3, 0, 1,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
label = gtk_label_new( "Brush" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table2 ), label, 0, 2, 0, 1,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
adjustment = gtk_adjustment_new( 1, 1, 32, 1, 10, 0 );
fit_height_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 0 );
gtk_widget_show( fit_height_spinbutton );
gtk_table_attach( GTK_TABLE( table2 ), fit_height_spinbutton, 3, 4, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( fit_height_spinbutton ), TRUE );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( fit_height_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 1, 1, 32, 1, 10, 0 );
fit_width_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 0 );
gtk_widget_show( fit_width_spinbutton );
gtk_table_attach( GTK_TABLE( table2 ), fit_width_spinbutton, 2, 3, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( fit_width_spinbutton ), TRUE );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( fit_width_spinbutton ), GTK_UPDATE_IF_VALID );
fit_button = gtk_button_new_with_mnemonic( "Fit" );
gtk_widget_show( fit_button );
gtk_table_attach( GTK_TABLE( table2 ), fit_button, 1, 2, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
axial_button = gtk_button_new_with_mnemonic( "Axial" );
gtk_widget_show( axial_button );
gtk_table_attach( GTK_TABLE( table2 ), axial_button, 0, 1, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
// Add the SURF_ and CONTENTS_ flags frame
create_SurfaceFlagsFrame( vbox1 );
g_signal_connect( (gpointer) SurfaceInspector,
"delete_event",
G_CALLBACK( delete_event_callback ),
NULL );
g_signal_connect( (gpointer) SurfaceInspector, "destroy",
G_CALLBACK( gtk_widget_destroy ),
NULL );
g_signal_connect( (gpointer) SurfaceInspector, "key_press_event",
G_CALLBACK( surface_inspector_key_press_event ),
NULL );
g_signal_connect( (gpointer) texture_combo_entry, "key_press_event",
G_CALLBACK( on_texture_combo_entry_key_press_event ),
NULL );
g_signal_connect( (gpointer) texture_combo_entry, "activate",
G_CALLBACK( on_texture_combo_entry_activate ),
NULL );
g_signal_connect( (gpointer) hshift_value_spinbutton, "value_changed",
G_CALLBACK( on_hshift_value_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) vshift_value_spinbutton, "value_changed",
G_CALLBACK( on_vshift_value_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) hscale_value_spinbutton, "value_changed",
G_CALLBACK( on_hscale_value_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) vscale_value_spinbutton, "value_changed",
G_CALLBACK( on_vscale_value_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) rotate_value_spinbutton, "value_changed",
G_CALLBACK( on_rotate_value_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) hshift_step_spinbutton, "value_changed",
G_CALLBACK( on_hshift_step_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) vshift_step_spinbutton, "value_changed",
G_CALLBACK( on_vshift_step_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) hscale_step_spinbutton, "value_changed",
G_CALLBACK( on_hscale_step_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) vscale_step_spinbutton, "value_changed",
G_CALLBACK( on_vscale_step_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) rotate_step_spinbutton, "value_changed",
G_CALLBACK( on_rotate_step_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) match_grid_button, "clicked",
G_CALLBACK( on_match_grid_button_clicked ),
NULL );
g_signal_connect( (gpointer) fit_width_spinbutton, "value_changed",
G_CALLBACK( on_fit_width_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) fit_height_spinbutton, "value_changed",
G_CALLBACK( on_fit_height_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) fit_button, "clicked",
G_CALLBACK( on_fit_button_clicked ),
NULL );
g_signal_connect( (gpointer) axial_button, "clicked",
G_CALLBACK( on_axial_button_clicked ),
NULL );
return SurfaceInspector;
}
GtkWidget *AP_UnixDialog_Lists::_constructWindowContents (void)
{
GtkWidget *vbox2;
GtkWidget *hbox2;
GtkWidget *vbox4;
GtkWidget *table1;
GtkWidget *style_om;
GtkWidget *type_om;
GtkWidget *type_lb;
GtkWidget *style_lb;
GtkWidget *customized_cb;
GtkWidget *frame1;
GtkWidget *table2;
GtkComboBox *font_om;
GtkListStore *font_om_menu;
GtkWidget *format_en;
GtkWidget *decimal_en;
GtkAdjustment *start_sb_adj;
GtkWidget *start_sb;
GtkAdjustment *text_align_sb_adj;
GtkWidget *text_align_sb;
GtkAdjustment *label_align_sb_adj;
GtkWidget *label_align_sb;
GtkWidget *format_lb;
GtkWidget *font_lb;
GtkWidget *delimiter_lb;
GtkWidget *start_at_lb;
GtkWidget *text_align_lb;
GtkWidget *label_align_lb;
GtkWidget *vbox3;
GtkWidget *preview_lb;
GtkWidget *hbox1;
GSList *action_group = NULL;
GtkWidget *start_list_rb;
GtkWidget *apply_list_rb;
GtkWidget *resume_list_rb;
GtkWidget *preview_area;
GtkWidget *preview_frame;
const XAP_StringSet * pSS = m_pApp->getStringSet();
UT_UTF8String s;
GtkWidget * wNoteBook = NULL;
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox2);
if(!isModal())
{
// Note Book creation
wNoteBook = gtk_notebook_new ();
gtk_widget_show(wNoteBook);
// Container for the lists
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageProperties,s);
GtkWidget * lbPageLists = gtk_label_new(s.utf8_str());
gtk_widget_show(lbPageLists);
gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),vbox2,lbPageLists);
m_iPageLists = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),vbox2);
// Container for Text Folding
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageFolding,s);
GtkWidget * lbPageFolding = gtk_label_new(s.utf8_str());
GtkWidget * wFoldingTable = gtk_table_new(6,3,FALSE);
gtk_widget_show(lbPageFolding);
gtk_widget_show(wFoldingTable);
gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),wFoldingTable,lbPageFolding);
m_iPageFold = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),wFoldingTable);
// Left Spacing Here
GtkWidget * lbLeftSpacer = gtk_label_new("");
gtk_misc_set_padding(GTK_MISC(lbLeftSpacer),8,0);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbLeftSpacer,0,1,0,6,GTK_SHRINK,GTK_FILL,0,0);
gtk_widget_show(lbLeftSpacer);
// Bold markup
GtkWidget * lbFoldHeading = gtk_label_new("<b>%s</b>");
gtk_label_set_use_markup(GTK_LABEL(lbFoldHeading),TRUE);
localizeLabelMarkup(lbFoldHeading,pSS,AP_STRING_ID_DLG_Lists_FoldingLevelexp);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbFoldHeading,1,3,0,1,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(lbFoldHeading);
// Mid Left Spacing Here
GtkWidget * lbMidLeftSpacer = gtk_label_new("");
gtk_misc_set_padding(GTK_MISC(lbMidLeftSpacer),8,0);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbMidLeftSpacer,1,2,1,6,GTK_SHRINK,GTK_FILL,0,0);
gtk_widget_show(lbMidLeftSpacer);
m_vecFoldCheck.clear();
m_vecFoldID.clear();
UT_uint32 ID =0;
// RadioButtons
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel0,s);
GtkWidget * wF = gtk_radio_button_new_with_label(NULL, s.utf8_str());
GSList *wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"0");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,1,2,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel1,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"1");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,2,3,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel2,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"2");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,3,4,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel3,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"3");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,4,5,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel4,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"4");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,5,6,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
gtk_widget_show(wFoldingTable);
gtk_notebook_set_current_page(GTK_NOTEBOOK(wNoteBook),m_iPageLists);
}
// List Page
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 8);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
vbox4 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_widget_show (vbox4);
gtk_box_pack_start (GTK_BOX (hbox2), vbox4, FALSE, TRUE, 0);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox4), table1, FALSE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table1), 4);
style_om = gtk_combo_box_text_new();
gtk_widget_show (style_om);
gtk_table_attach (GTK_TABLE (table1), style_om, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
m_wListStyleNone_menu = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_INT);
_fillNoneStyleMenu(m_wListStyleNone_menu.obj());
m_wListStyleNumbered_menu = gtk_list_store_new (2, G_TYPE_STRING,
G_TYPE_INT);
_fillNumberedStyleMenu(m_wListStyleNumbered_menu.obj());
m_wListStyleBulleted_menu = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_INT);
_fillBulletedStyleMenu(m_wListStyleBulleted_menu.obj());
// This is the default list. Change if the list style changes
//
m_wListStyle_menu = m_wListStyleNumbered_menu;
gtk_combo_box_set_model(GTK_COMBO_BOX (style_om),
GTK_TREE_MODEL(m_wListStyleNumbered_menu.obj()));
type_om = gtk_combo_box_text_new();
gtk_widget_show (type_om);
gtk_table_attach (GTK_TABLE (table1), type_om, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_none,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_bullet,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_numbered,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
gtk_combo_box_set_active(GTK_COMBO_BOX(type_om), 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type,s);
type_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (type_lb);
gtk_table_attach (GTK_TABLE (table1), type_lb, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (type_lb), 0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Style,s);
style_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (style_lb);
gtk_table_attach (GTK_TABLE (table1), style_lb, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (style_lb), 0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_SetDefault,s);
customized_cb = gtk_dialog_add_button (GTK_DIALOG(m_wMainWindow), s.utf8_str(), BUTTON_RESET);
gtk_widget_show (customized_cb);
/* todo
gtk_table_attach (GTK_TABLE (table1), customized_cb, 0, 2, 2, 3,
(GtkAttachOptions) (GTK_SHRINK),
(GtkAttachOptions) (0), 0, 0);
*/
frame1 = gtk_frame_new (NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame1), GTK_SHADOW_NONE);
//gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox4), frame1, TRUE, TRUE, 0);
table2 = gtk_table_new (6, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame1), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 4);
gtk_widget_set_sensitive (table2, TRUE);
gtk_table_set_row_spacings (GTK_TABLE (table2), 4);
gtk_table_set_col_spacings (GTK_TABLE (table2), 4);
font_om_menu = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
_fillFontMenu(font_om_menu);
font_om = GTK_COMBO_BOX(gtk_combo_box_new());
gtk_combo_box_set_model(font_om, GTK_TREE_MODEL(font_om_menu));
gtk_widget_show (GTK_WIDGET(font_om));
gtk_table_attach (GTK_TABLE (table2), GTK_WIDGET(font_om), 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
format_en = gtk_entry_new ();
gtk_entry_set_max_length(GTK_ENTRY(format_en), 20);
gtk_widget_show (format_en);
gtk_table_attach (GTK_TABLE (table2), format_en, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_text (GTK_ENTRY (format_en), "%L");
decimal_en = gtk_entry_new ();
gtk_widget_show (decimal_en);
gtk_table_attach (GTK_TABLE (table2), decimal_en, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_text (GTK_ENTRY (format_en), "");
start_sb_adj = (GtkAdjustment*)gtk_adjustment_new (1, 0, G_MAXINT32, 1, 10, 10);
start_sb = gtk_spin_button_new (GTK_ADJUSTMENT (start_sb_adj), 1, 0);
gtk_widget_show (start_sb);
gtk_table_attach (GTK_TABLE (table2), start_sb, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
text_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0.25, 0, 10, 0.01, 0.2, 1);
text_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (text_align_sb_adj), 0.05, 2);
gtk_widget_show (text_align_sb);
gtk_table_attach (GTK_TABLE (table2), text_align_sb, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (text_align_sb), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (text_align_sb), TRUE);
label_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0, 0, 10, 0.01, 0.2, 1);
label_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (label_align_sb_adj), 0.05, 2);
gtk_widget_show (label_align_sb);
gtk_table_attach (GTK_TABLE (table2), label_align_sb, 1, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (label_align_sb), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (label_align_sb), TRUE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Format,s);
format_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (format_lb);
gtk_table_attach (GTK_TABLE (table2), format_lb, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (format_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Font,s);
font_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (font_lb);
gtk_table_attach (GTK_TABLE (table2), font_lb, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (font_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_DelimiterString,s);
delimiter_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (delimiter_lb);
gtk_table_attach (GTK_TABLE (table2), delimiter_lb, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (delimiter_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start,s);
start_at_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (start_at_lb);
gtk_table_attach (GTK_TABLE (table2), start_at_lb, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (start_at_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Align,s);
text_align_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (text_align_lb);
gtk_table_attach (GTK_TABLE (table2), text_align_lb, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (text_align_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Indent,s);
label_align_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (label_align_lb);
gtk_table_attach (GTK_TABLE (table2), label_align_lb, 0, 1, 5, 6,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_align_lb), 0.0, 0.5);
vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (hbox2), vbox3, TRUE, TRUE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Preview,s);
preview_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (preview_lb);
gtk_box_pack_start (GTK_BOX (vbox3), preview_lb, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (preview_lb), 0.0, 0.5);
preview_frame = gtk_frame_new (NULL);
gtk_widget_show (preview_frame);
gtk_box_pack_start (GTK_BOX (vbox3), preview_frame, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (preview_frame), 3);
gtk_frame_set_shadow_type (GTK_FRAME (preview_frame), GTK_SHADOW_NONE);
preview_area = createDrawingArea ();
gtk_widget_set_size_request (preview_area,180,225);
gtk_widget_show (preview_area);
gtk_container_add (GTK_CONTAINER (preview_frame), preview_area);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
if(!isModal())
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start_New,s);
start_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (start_list_rb));
if(!isModal())
gtk_widget_show (start_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), start_list_rb, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (start_list_rb), TRUE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Apply_Current,s);
apply_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (apply_list_rb));
if(!isModal())
gtk_widget_show (apply_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), apply_list_rb, FALSE, FALSE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Resume,s);
resume_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (resume_list_rb));
if(!isModal())
gtk_widget_show (resume_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), resume_list_rb, FALSE, FALSE, 0);
// Save useful widgets in member variables
if(isModal())
{
m_wContents = vbox2;
}
else
{
m_wContents = wNoteBook;
}
m_wStartNewList = start_list_rb;
m_wStartNew_label = gtk_bin_get_child(GTK_BIN(start_list_rb));
m_wApplyCurrent = apply_list_rb;
m_wStartSubList = resume_list_rb;
m_wStartSub_label = gtk_bin_get_child(GTK_BIN(resume_list_rb));
m_wRadioGroup = action_group;
m_wPreviewArea = preview_area;
m_wDelimEntry = format_en;
m_oAlignList_adj = text_align_sb_adj;
m_wAlignListSpin = text_align_sb;
m_oIndentAlign_adj = label_align_sb_adj;
m_wIndentAlignSpin = label_align_sb;
m_wDecimalEntry = decimal_en;
m_oStartSpin_adj = start_sb_adj;
m_wStartSpin = start_sb;
m_wFontOptions = font_om;
m_wFontOptions_menu = font_om_menu;
m_wCustomFrame = frame1;
m_wCustomLabel = customized_cb;
m_wCustomTable = table2;
m_wListStyleBox = GTK_COMBO_BOX(style_om);
m_wListTypeBox = GTK_COMBO_BOX(type_om);
m_wListType_menu = m_wListStyleNumbered_menu;
// Start by hiding the Custom frame
//
// gtk_widget_hide(m_wCustomFrame);
gtk_widget_show(m_wCustomFrame);
setbisCustomized(false);
return m_wContents;
}
static GtkContainer *
mbox_get_setup_page( XfceMailwatchMailbox *mailbox )
{
XfceMailwatchMboxMailbox *mbox = XFCE_MAILWATCH_MBOX_MAILBOX( mailbox );
GtkWidget *vbox, *hbox;
GtkWidget *label;
GtkWidget *button, *spinner;
GtkSizeGroup *sg;
vbox = gtk_vbox_new( FALSE, BORDER / 2 );
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 );
sg = gtk_size_group_new( GTK_SIZE_GROUP_HORIZONTAL );
label = gtk_label_new_with_mnemonic( _( "Mbox _Filename:" ) );
gtk_widget_show( label );
gtk_box_pack_start( GTK_BOX( hbox ), label, FALSE, FALSE, 0 );
gtk_size_group_add_widget( GTK_SIZE_GROUP( sg ), label );
button = gtk_file_chooser_button_new( _("Select mbox file"),
GTK_FILE_CHOOSER_ACTION_OPEN );
g_mutex_lock( mbox->settings_mutex );
if ( mbox->fn ) {
gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( button ), mbox->fn );
}
g_mutex_unlock( mbox->settings_mutex );
gtk_widget_show( button );
gtk_box_pack_start( GTK_BOX( hbox ), button, TRUE, TRUE, 0 );
g_signal_connect( G_OBJECT( button ), "file-set",
G_CALLBACK( mbox_file_set_cb ), mbox );
gtk_label_set_mnemonic_widget( GTK_LABEL( label ), button );
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 );
gtk_size_group_add_widget( GTK_SIZE_GROUP( sg ), label );
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 ), mbox->interval / 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( mbox_interval_changed_cb ), mbox );
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 ) );
}
void ui_common_study_preferences_widgets(GtkWidget * packing_table,
gint table_row,
GtkWidget ** proi_width_spin,
GnomeCanvasItem ** proi_item,
#ifdef AMIDE_LIBGNOMECANVAS_AA
GtkWidget ** proi_transparency_spin,
#else
GtkWidget ** pline_style_menu,
GtkWidget ** pfill_roi_button,
#endif
GtkWidget ** playout_button1,
GtkWidget ** playout_button2,
GtkWidget ** ppanel_layout_button1,
GtkWidget ** ppanel_layout_button2,
GtkWidget ** ppanel_layout_button3,
GtkWidget ** pmaintain_size_button,
GtkWidget ** ptarget_size_spin) {
GtkWidget * label;
GtkObject * adjustment;
GtkWidget * roi_canvas;
GnomeCanvasPoints * roi_line_points;
GtkWidget * image;
GtkWidget * hseparator;
#ifndef AMIDE_LIBGNOMECANVAS_AA
GdkLineStyle i_line_style;
#endif
/* widgets to change the roi's size */
label = gtk_label_new(_("ROI Width (pixels)"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
adjustment = gtk_adjustment_new(AMITK_PREFERENCES_MIN_ROI_WIDTH,
AMITK_PREFERENCES_MIN_ROI_WIDTH,
AMITK_PREFERENCES_MAX_ROI_WIDTH,1.0, 1.0, 0.0);
*proi_width_spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1.0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(*proi_width_spin),FALSE);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(*proi_width_spin), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*proi_width_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(*proi_width_spin), GTK_UPDATE_ALWAYS);
gtk_table_attach(GTK_TABLE(packing_table), *proi_width_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*proi_width_spin);
/* a little canvas indicator thingie to show the user who the new preferences will look */
#ifdef AMIDE_LIBGNOMECANVAS_AA
roi_canvas = gnome_canvas_new_aa();
#else
roi_canvas = gnome_canvas_new();
#endif
gtk_widget_set_size_request(roi_canvas, 100, 100);
gnome_canvas_set_scroll_region(GNOME_CANVAS(roi_canvas), 0.0, 0.0, 100.0, 100.0);
gtk_table_attach(GTK_TABLE(packing_table), roi_canvas, 2,3,table_row,table_row+2,
GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(roi_canvas);
/* the box */
roi_line_points = gnome_canvas_points_new(5);
roi_line_points->coords[0] = 25.0; /* x1 */
roi_line_points->coords[1] = 25.0; /* y1 */
roi_line_points->coords[2] = 75.0; /* x2 */
roi_line_points->coords[3] = 25.0; /* y2 */
roi_line_points->coords[4] = 75.0; /* x3 */
roi_line_points->coords[5] = 75.0; /* y3 */
roi_line_points->coords[6] = 25.0; /* x4 */
roi_line_points->coords[7] = 75.0; /* y4 */
roi_line_points->coords[8] = 25.0; /* x4 */
roi_line_points->coords[9] = 25.0; /* y4 */
*proi_item = gnome_canvas_item_new(gnome_canvas_root(GNOME_CANVAS(roi_canvas)),
#ifdef AMIDE_LIBGNOMECANVAS_AA
gnome_canvas_polygon_get_type(),
#else
gnome_canvas_line_get_type(),
#endif
"points", roi_line_points,
NULL);
gnome_canvas_points_unref(roi_line_points);
table_row++;
#ifdef AMIDE_LIBGNOMECANVAS_AA
/* widget to change the transparency level */
/* only works for anti-aliased canvases */
/* widgets to change the roi's size */
label = gtk_label_new(_("ROI Transparency"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0, 1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*proi_transparency_spin = gtk_spin_button_new_with_range(0.0,1.0,AMITK_PREFERENCES_DEFAULT_CANVAS_ROI_TRANSPARENCY);
gtk_spin_button_set_increments(GTK_SPIN_BUTTON(*proi_transparency_spin),0.1,0.1);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*proi_transparency_spin),FALSE);
gtk_table_attach(GTK_TABLE(packing_table), *proi_transparency_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*proi_transparency_spin);
table_row++;
#else
/* widgets to change the roi's line style */
/* Anti-aliased canvas doesn't yet support this */
/* also need to remove #ifndef for relevant lines in amitk_canvas_object.c and other locations */
label = gtk_label_new(_("ROI Line Style:"));
gtk_table_attach(GTK_TABLE(packing_table), label, 0,1,
table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pline_style_menu = gtk_combo_box_new_text();
for (i_line_style=0; i_line_style<=GDK_LINE_DOUBLE_DASH; i_line_style++)
gtk_combo_box_append_text(GTK_COMBO_BOX(*pline_style_menu),
line_style_names[i_line_style]);
gtk_widget_set_size_request (*pline_style_menu, 125, -1);
gtk_table_attach(GTK_TABLE(packing_table), *pline_style_menu, 1,2,
table_row,table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pline_style_menu);
table_row++;
/* do we want to fill in isocontour roi's */
label = gtk_label_new(_("Draw Isocontours/Freehands Filled:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pfill_roi_button = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(packing_table), *pfill_roi_button,
1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pfill_roi_button);
table_row++;
#endif
hseparator = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(packing_table), hseparator,
0, 3, table_row, table_row+1,
GTK_FILL, 0, X_PADDING, Y_PADDING);
table_row++;
gtk_widget_show(hseparator);
label = gtk_label_new(_("Canvas Layout:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
/* the radio buttons */
*playout_button1 = gtk_radio_button_new(NULL);
image = gtk_image_new_from_stock("amide_icon_layout_linear",GTK_ICON_SIZE_DIALOG);
gtk_button_set_image(GTK_BUTTON(*playout_button1), image);
gtk_table_attach(GTK_TABLE(packing_table), *playout_button1,
1,2, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*playout_button1), "layout", GINT_TO_POINTER(AMITK_LAYOUT_LINEAR));
gtk_widget_show(*playout_button1);
*playout_button2 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*playout_button2),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*playout_button1)));
image = gtk_image_new_from_stock("amide_icon_layout_orthogonal",GTK_ICON_SIZE_DIALOG);
gtk_button_set_image(GTK_BUTTON(*playout_button2), image);
gtk_table_attach(GTK_TABLE(packing_table), *playout_button2, 2,3, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*playout_button2), "layout", GINT_TO_POINTER(AMITK_LAYOUT_ORTHOGONAL));
gtk_widget_show(*playout_button2);
table_row++;
label = gtk_label_new(_("Multiple Canvases Layout:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
/* the radio buttons */
*ppanel_layout_button1 = gtk_radio_button_new(NULL);
image = gtk_image_new_from_stock("amide_icon_panels_mixed", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button1), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button1,
1,2, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button1), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_MIXED));
gtk_widget_show(*ppanel_layout_button1);
*ppanel_layout_button2 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*ppanel_layout_button2),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*ppanel_layout_button1)));
image = gtk_image_new_from_stock("amide_icon_panels_linear_x", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button2), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button2,
2,3, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button2), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_LINEAR_X));
gtk_widget_show(*ppanel_layout_button2);
*ppanel_layout_button3 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*ppanel_layout_button3),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*ppanel_layout_button1)));
image = gtk_image_new_from_stock("amide_icon_panels_linear_y", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button3), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button3,
3,4, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button3), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_LINEAR_Y));
gtk_widget_show(*ppanel_layout_button3);
table_row++;
/* do we want the size of the canvas to not resize */
label = gtk_label_new(_("Maintain view size constant:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pmaintain_size_button = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(packing_table), *pmaintain_size_button,
1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pmaintain_size_button);
table_row++;
/* widgets to change the amount of empty space in the center of the target */
label = gtk_label_new(_("Target Empty Area (pixels)"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
adjustment = gtk_adjustment_new(AMITK_PREFERENCES_MIN_TARGET_EMPTY_AREA,
AMITK_PREFERENCES_MIN_TARGET_EMPTY_AREA,
AMITK_PREFERENCES_MAX_TARGET_EMPTY_AREA, 1.0, 1.0, 0.0);
*ptarget_size_spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1.0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(*ptarget_size_spin),FALSE);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(*ptarget_size_spin), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*ptarget_size_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(*ptarget_size_spin), GTK_UPDATE_ALWAYS);
gtk_table_attach(GTK_TABLE(packing_table), *ptarget_size_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*ptarget_size_spin);
return;
}
int main(int argc, char **argv)
{
GtkWidget *window;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkWidget *spinner2;
GtkWidget *spinner;
GtkWidget *button;
GtkWidget *label;
GtkWidget *val_label;
GtkAdjustment *adj;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_window_set_title(GTK_WINDOW(window), "Spin Button");
main_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 10);
gtk_container_add(GTK_CONTAINER(window), main_vbox);
frame = gtk_frame_new("Not accelerated");
gtk_box_pack_start(GTK_BOX(main_vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_container_add(GTK_CONTAINER(frame), vbox );
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new("Day :");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox2), label, FALSE, TRUE, 0);
adj = (GtkAdjustment *)gtk_adjustment_new(1.0, 1.0, 31.0, 1.0, 5.0, 0.0);
spinner = gtk_spin_button_new(adj, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spinner), TRUE);
gtk_box_pack_start(GTK_BOX(vbox2), spinner, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new("Month :");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox2), label, FALSE, TRUE, 0);
adj = (GtkAdjustment *)gtk_adjustment_new(1.0, 1.0, 12.0, 1.0, 5.0, 0.0);
spinner = gtk_spin_button_new(adj, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spinner), TRUE);
gtk_box_pack_start(GTK_BOX(vbox2), spinner, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new("Year :");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox2), label, FALSE, TRUE, 0);
adj = (GtkAdjustment *)gtk_adjustment_new(1998.0, 0.0, 2100.0, 1.0, 100.0, 0.0);
spinner = gtk_spin_button_new(adj, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spinner), TRUE);
gtk_widget_set_size_request(spinner, 70, -1);
gtk_box_pack_start(GTK_BOX(vbox2), spinner, FALSE, TRUE, 0);
frame = gtk_frame_new("Accelerated");
gtk_box_pack_start(GTK_BOX(main_vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_container_add(GTK_CONTAINER(frame), vbox );
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new("Value :");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox2), label, FALSE, TRUE, 0);
adj = (GtkAdjustment *)gtk_adjustment_new(0.0, -10000.0, 10000.0, 0.5, 100.0, 0.0);
spinner1 = gtk_spin_button_new(adj, 1.0, 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spinner1), TRUE);
gtk_widget_set_size_request(spinner1, 100, -1);
gtk_box_pack_start(GTK_BOX(vbox2), spinner1, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new("Digits :");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox2), label, FALSE, TRUE, 0);
adj = (GtkAdjustment *)gtk_adjustment_new(2, 1, 5, 1, 1, 0);
spinner2 = gtk_spin_button_new(adj, 0.0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spinner2), TRUE);
g_signal_connect(G_OBJECT(adj), "value_changed", G_CALLBACK(change_digits), spinner2);
gtk_box_pack_start(GTK_BOX(vbox2), spinner2, FALSE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
button = gtk_check_button_new_with_label("Snap to 0.5-ticks");
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(toggle_snap), spinner1);
gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
button = gtk_check_button_new_with_label("Numeric only input mode");
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(toggle_numeric), spinner1);
gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
val_label = gtk_label_new("");
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5 );
button = gtk_button_new_with_label("Value as Int");
g_object_set_data(G_OBJECT(button), "user_data", val_label);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(get_value), GINT_TO_POINTER(1));
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5);
button = gtk_button_new_with_label("Value as Float");
g_object_set_data(G_OBJECT(button), "user_data", val_label);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(get_value), GINT_TO_POINTER(2));
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(vbox), val_label, TRUE, TRUE, 0);
gtk_label_set_text(GTK_LABEL(val_label), "0");
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label("Close");
g_signal_connect_swapped(G_OBJECT(button), "clicked", G_CALLBACK(gtk_widget_destroy), window);
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static GtkWidget *
image_get_properties(Image *image)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *color;
GtkWidget *checkbox;
GtkWidget *linestyle;
GtkWidget *file;
GtkWidget *border_width;
GtkAdjustment *adj;
if (image_properties_dialog == NULL) {
image_properties_dialog = g_new(ImagePropertiesDialog, 1);
vbox = gtk_vbox_new(FALSE, 5);
image_properties_dialog->vbox = vbox;
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Image file:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
file = dia_file_selector_new();
image_properties_dialog->file = DIAFILESELECTOR(file);
gtk_box_pack_start (GTK_BOX (hbox), file, TRUE, TRUE, 0);
gtk_widget_show (file);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 5);
checkbox = gtk_check_button_new_with_label(_("Keep aspect ratio"));
image_properties_dialog->keep_aspect = GTK_TOGGLE_BUTTON( checkbox );
gtk_widget_show(checkbox);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX (hbox), checkbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 5);
checkbox = gtk_check_button_new_with_label(_("Show border"));
image_properties_dialog->draw_border = GTK_TOGGLE_BUTTON( checkbox );
gtk_widget_show(checkbox);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX (hbox), checkbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Border width:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
adj = (GtkAdjustment *) gtk_adjustment_new(0.1, 0.00, 10.0, 0.01, 0.0, 0.0);
border_width = gtk_spin_button_new(adj, 1.0, 2);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(border_width), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(border_width), TRUE);
image_properties_dialog->border_width = GTK_SPIN_BUTTON(border_width);
gtk_box_pack_start(GTK_BOX (hbox), border_width, TRUE, TRUE, 0);
gtk_widget_show (border_width);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Foreground color:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
color = dia_color_selector_new();
image_properties_dialog->fg_color = DIACOLORSELECTOR(color);
gtk_box_pack_start (GTK_BOX (hbox), color, TRUE, TRUE, 0);
gtk_widget_show (color);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Line style:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
linestyle = dia_line_style_selector_new();
image_properties_dialog->line_style = DIALINESTYLESELECTOR(linestyle);
gtk_box_pack_start (GTK_BOX (hbox), linestyle, TRUE, TRUE, 0);
gtk_widget_show (linestyle);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
}
image_properties_dialog->image = image;
gtk_spin_button_set_value(image_properties_dialog->border_width,
image->border_width);
dia_color_selector_set_color(image_properties_dialog->fg_color,
&image->border_color);
dia_file_selector_set_file(image_properties_dialog->file, image->file);
dia_line_style_selector_set_linestyle(image_properties_dialog->line_style,
image->line_style, 1.0);
gtk_toggle_button_set_active(image_properties_dialog->draw_border, image->draw_border);
gtk_toggle_button_set_active(image_properties_dialog->keep_aspect, image->keep_aspect);
return image_properties_dialog->vbox;
}
