static GtkWidget *build_status_bar(void)
{
GtkWidget *vsep;
app_bar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(app_bar), TRUE);
gtk_widget_show(app_bar);
vp_target_status = gtk_label_new("");
gtk_widget_show(vp_target_status);
gtk_box_pack_start(GTK_BOX(app_bar), vp_target_status, FALSE, TRUE,
0);
vsep = gtk_vseparator_new();
gtk_widget_show(vsep);
gtk_box_pack_start(GTK_BOX(app_bar), vsep, FALSE, TRUE, 0);
/* Network status: offline */
net_status = gtk_label_new(_("Offline"));
gtk_widget_show(net_status);
gtk_box_pack_start(GTK_BOX(app_bar), net_status, FALSE, TRUE, 0);
vsep = gtk_vseparator_new();
gtk_widget_show(vsep);
gtk_box_pack_start(GTK_BOX(app_bar), vsep, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(app_bar),
player_build_turn_area(), FALSE, TRUE, 0);
/* Initial text in status bar */
gui_set_instructions(_("Welcome to Pioneers!"));
return app_bar;
}
static void ryostklconfig_effect_selector_init(RyostklconfigEffectSelector *effect_selector) {
RyostklconfigEffectSelectorPrivate *priv = RYOSTKLCONFIG_EFFECT_SELECTOR_GET_PRIVATE(effect_selector);
effect_selector->priv = priv;
priv->off = GTK_TOGGLE_BUTTON(gtk_radio_button_new_with_label(NULL, _("Off")));
priv->fade = GTK_TOGGLE_BUTTON(gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(priv->off), _("Fade FX")));
priv->ripple = GTK_TOGGLE_BUTTON(gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(priv->fade), _("Ripple FX")));
priv->delay_time = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(RYOSTKL_LIGHT_LAYER_EFFECT_TIME_MIN, RYOSTKL_LIGHT_LAYER_EFFECT_TIME_MAX, 1.0));
priv->fade_time = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(RYOSTKL_LIGHT_LAYER_EFFECT_TIME_MIN, RYOSTKL_LIGHT_LAYER_EFFECT_TIME_MAX, 1.0));
g_signal_connect(G_OBJECT(priv->off), "toggled", G_CALLBACK(effect_cb), effect_selector);
g_signal_connect(G_OBJECT(priv->fade), "toggled", G_CALLBACK(effect_cb), effect_selector);
g_signal_connect(G_OBJECT(priv->ripple), "toggled", G_CALLBACK(effect_cb), effect_selector);
priv->delay_handler_id = g_signal_connect(G_OBJECT(priv->delay_time), "value-changed", G_CALLBACK(time_cb), effect_selector);
priv->fade_handler_id = g_signal_connect(G_OBJECT(priv->fade_time), "value-changed", G_CALLBACK(time_cb), effect_selector);
gtk_box_pack_start(GTK_BOX(effect_selector), GTK_WIDGET(priv->off), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), gtk_vseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), GTK_WIDGET(priv->fade), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), gtk_label_new(_("Delay")), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), GTK_WIDGET(priv->delay_time), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), gtk_label_new(_("Fade")), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), GTK_WIDGET(priv->fade_time), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), gtk_vseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(effect_selector), GTK_WIDGET(priv->ripple), TRUE, FALSE, 0);
}
/*! \brief Initialize GschemBottomWidget instance
*
* \param [in,out] view the gschem page view
*/
static void
gschem_bottom_widget_init (GschemBottomWidget *widget)
{
GtkWidget *separator;
g_return_if_fail (widget != NULL);
widget->left_button_label = gtk_label_new (NULL);
gtk_misc_set_padding (GTK_MISC (widget->left_button_label), LABEL_XPAD, LABEL_YPAD);
gtk_box_pack_start (GTK_BOX (widget), widget->left_button_label, FALSE, FALSE, 0);
separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (widget), separator, FALSE, FALSE, 0);
widget->middle_button_label = gtk_label_new (NULL);
gtk_misc_set_padding (GTK_MISC (widget->middle_button_label), LABEL_XPAD, LABEL_YPAD);
gtk_box_pack_start (GTK_BOX (widget), widget->middle_button_label, FALSE, FALSE, 0);
separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (widget), separator, FALSE, FALSE, 0);
widget->right_button_label = gtk_label_new (NULL);
gtk_misc_set_padding (GTK_MISC (widget->right_button_label), LABEL_XPAD, LABEL_YPAD);
gtk_box_pack_start (GTK_BOX (widget), widget->right_button_label, FALSE, FALSE, 0);
separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (widget), separator, FALSE, FALSE, 0);
widget->grid_label = gtk_label_new (NULL);
gtk_misc_set_padding (GTK_MISC (widget->grid_label), LABEL_XPAD, LABEL_YPAD);
gtk_box_pack_start (GTK_BOX (widget), widget->grid_label, FALSE, FALSE, 0);
separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (widget), separator, FALSE, FALSE, 0);
widget->status_label = gtk_label_new (NULL);
gtk_misc_set_padding (GTK_MISC (widget->status_label), LABEL_XPAD, LABEL_YPAD);
gtk_box_pack_end (GTK_BOX (widget), widget->status_label, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget),
"notify::grid-mode",
G_CALLBACK (update_grid_label),
NULL);
g_signal_connect (G_OBJECT (widget),
"notify::grid-size",
G_CALLBACK (update_grid_label),
NULL);
g_signal_connect (G_OBJECT (widget),
"notify::snap-mode",
G_CALLBACK (update_grid_label),
NULL);
g_signal_connect (G_OBJECT (widget),
"notify::snap-size",
G_CALLBACK (update_grid_label),
NULL);
}
static GtkWidget *
gtk_font_button_create_inside (GtkFontButton *font_button)
{
GtkWidget *widget;
gtk_widget_push_composite_child ();
widget = gtk_hbox_new (FALSE, 0);
font_button->priv->font_label = gtk_label_new (_("Font"));
gtk_label_set_justify (GTK_LABEL (font_button->priv->font_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start (GTK_BOX (widget), font_button->priv->font_label, TRUE, TRUE, 5);
if (font_button->priv->show_size)
{
gtk_box_pack_start (GTK_BOX (widget), gtk_vseparator_new (), FALSE, FALSE, 0);
font_button->priv->size_label = gtk_label_new ("14");
gtk_box_pack_start (GTK_BOX (widget), font_button->priv->size_label, FALSE, FALSE, 5);
}
gtk_widget_show_all (widget);
gtk_widget_pop_composite_child ();
return widget;
}
static void add_button (MMConversation *mmconv)
{
PurpleConversation *conv = mmconv->conv;
GtkWidget *button, *image, *sep;
gchar *file_path;
button = gtk_toggle_button_new();
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(music_button_toggled), mmconv);
file_path = g_build_filename(DATADIR, "pixmaps", "purple", "buttons",
"music.png", NULL);
image = gtk_image_new_from_file(file_path);
g_free(file_path);
gtk_container_add((GtkContainer *)button, image);
sep = gtk_vseparator_new();
mmconv->seperator = sep;
mmconv->button = button;
gtk_widget_show(sep);
gtk_widget_show(image);
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(PIDGIN_CONVERSATION(conv)->toolbar), sep, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(PIDGIN_CONVERSATION(conv)->toolbar), button, FALSE, FALSE, 0);
}
GtkWidget *
gtk_separator_new( GtkOrientation orientation )
{
return ( orientation == GTK_ORIENTATION_HORIZONTAL )?
gtk_hseparator_new() :
gtk_vseparator_new();
}
static GtkWidget *viewer_vsep(GtkWidget *box)
{
GtkWidget *vsep = gtk_vseparator_new();
gtk_widget_show(vsep);
gtk_box_pack_start(GTK_BOX(box), vsep, FALSE, FALSE, 5);
return vsep;
}
static void
attach_to_conv(PurpleConversation *conv, gpointer null)
{
PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv);
GtkWidget *box, *sep, *counter, *menus;
GtkIMHtml *imhtml;
box = gtkconv->toolbar;
imhtml = GTK_IMHTML(gtkconv->imhtml);
/* Disable widgets that decorate or add link to composing text
* because Twitter cannot receive marked up string. For lean-view
* and wide-view, see pidgin/gtkimhtmltoolbar.c.
*/
menus = g_object_get_data(G_OBJECT(box), "lean-view");
if(menus) {
gtk_widget_set_sensitive(GTK_WIDGET(menus), FALSE);
}
menus = g_object_get_data(G_OBJECT(box), "wide-view");
if(menus) {
gtk_widget_set_sensitive(GTK_WIDGET(menus), FALSE);
}
purple_conversation_set_features(
gtkconv->active_conv,
purple_conversation_get_features(gtkconv->active_conv) &
~PURPLE_CONNECTION_HTML);
/* check if the counter is enabled */
if(!purple_prefs_get_bool(OPT_COUNTER))
return;
/* get counter object */
counter = g_object_get_data(G_OBJECT(box), PLUGIN_ID "-counter");
g_return_if_fail(counter == NULL);
/* make counter object */
counter = gtk_label_new(NULL);
gtk_widget_set_name(counter, "counter_label");
gtk_label_set_text(GTK_LABEL(counter), "0");
gtk_box_pack_end(GTK_BOX(box), counter, FALSE, FALSE, 0);
gtk_widget_show_all(counter);
g_object_set_data(G_OBJECT(box), PLUGIN_ID "-counter", counter);
/* make separator object */
sep = gtk_vseparator_new();
gtk_box_pack_end(GTK_BOX(box), sep, FALSE, FALSE, 0);
gtk_widget_show_all(sep);
g_object_set_data(G_OBJECT(box), PLUGIN_ID "-sep", sep);
/* connect to signals */
g_signal_connect(G_OBJECT(gtkconv->entry_buffer), "insert_text",
G_CALLBACK(insert_text_cb), conv);
g_signal_connect(G_OBJECT(gtkconv->entry_buffer), "delete_range",
G_CALLBACK(delete_text_cb), conv);
/* redraw window */
gtk_widget_queue_draw(pidgin_conv_get_window(gtkconv)->window);
}
GtkWidget *
gtk_separator_new (GtkOrientation orientation)
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
return gtk_hseparator_new ();
else
return gtk_vseparator_new ();
}
void lamixer_volbox_show(VolBox *volumebox, snd_mixer_elem_t *elem, GtkWidget *mixerbox)
{
long rangevalue_left,rangevalue_right;
int mute, *bCols;
if (volumebox->type == 1) {
snd_mixer_selem_get_playback_volume (elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue_left);
bCols = &pCols;
}
else if (volumebox->type == 2) {
snd_mixer_selem_get_capture_volume (elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue_left);
bCols = &cCols;
}
volumebox->curval = rangevalue_left;
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->vollabel, *bCols-1, *bCols, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_range_set_value(GTK_RANGE(volumebox->volbar), rangevalue_left);
gtk_box_pack_start(GTK_BOX(volumebox->volbarbox), volumebox->volbar, TRUE, TRUE, 0);
volumebox->hsignalid = g_signal_connect(G_OBJECT(volumebox->volbar), "value-changed", G_CALLBACK(lamixer_volbox_changed), volumebox);
if (volumebox->rvolbar != NULL) {
if (volumebox->type == 1) {
snd_mixer_selem_get_playback_volume (elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue_right);
}
else if (volumebox->type == 2) {
snd_mixer_selem_get_capture_volume (elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue_right);
}
volumebox->rcurval = rangevalue_right;
gtk_box_pack_start(GTK_BOX(volumebox->volbarbox), volumebox->rvolbar, TRUE, TRUE, 0);
gtk_range_set_value(GTK_RANGE(volumebox->rvolbar), rangevalue_right);
volumebox->hsignalidr = g_signal_connect(G_OBJECT(volumebox->rvolbar), "value-changed", G_CALLBACK(lamixer_volboxr_changed), volumebox);
}
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->volbarbox, *bCols-1, *bCols, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
if (volumebox->lockswitch != NULL) {
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->lockswitch, *bCols-1, *bCols, 2, 3, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(volumebox->lockswitch), TRUE);
}
if (volumebox->muteswitch != NULL) {
snd_mixer_selem_get_playback_switch (elem, SND_MIXER_SCHN_FRONT_LEFT, &mute);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(volumebox->muteswitch), !mute);
volumebox->hmutesignalid = g_signal_connect(G_OBJECT(volumebox->muteswitch), "toggled", G_CALLBACK(lamixer_muteswitch_changed), elem);
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->muteswitch, *bCols-1, *bCols, 3, 4, GTK_SHRINK, GTK_SHRINK, 0, 0);
}
gtk_table_resize(GTK_TABLE(mixerbox), mRows, ++(*bCols));
gtk_table_attach(GTK_TABLE(mixerbox), gtk_vseparator_new (), *bCols-1, *bCols, 0, 5, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 4, 0);
gtk_table_resize(GTK_TABLE(mixerbox), mRows, ++(*bCols));
}
static GdkPixbuf *
new_separator_pixbuf (void)
{
GtkWidget *separator;
GdkPixbuf *pixbuf;
separator = gtk_vseparator_new ();
pixbuf = new_pixbuf_from_widget (separator);
return pixbuf;
}
void philips_cfg_separator ( GtkWidget *table, int horv, gint left, gint right, gint top, gint bottom )
{
GtkWidget *separator;
if ( horv == 0 ) /* horizontal */
separator = gtk_hseparator_new();
else
separator = gtk_vseparator_new();
gtk_widget_show ( separator );
gtk_table_attach_defaults ( GTK_TABLE(table), separator, left, right, top, bottom );
}
static void create_entry(PROC_T *p){
p->hbox=gtk_hbox_new(FALSE,0);
char lb[12];
snprintf(lb,12," %5d",p->pid);
struct tm *tim=localtime(&(p->status.timstart));
char stime[80];
strftime(stime,80,"[%a %k:%M:%S]",tim);
p->entry_start=new_label(stime,WIDTH_START,0.5);
p->entry_pid=new_label(lb,WIDTH_PID,1);
p->entry_path=new_label(p->path,WIDTH_PATH,1);
gtk_label_set_selectable(GTK_LABEL(p->entry_path), TRUE);
gtk_label_set_ellipsize(GTK_LABEL(p->entry_path),PANGO_ELLIPSIZE_START);
#if GTK_MAJOR_VERSION>=3 || GTK_MINOR_VERSION >= 12
gtk_widget_set_tooltip_text(p->entry_path, p->path);
#endif
p->entry_errlo=new_label("Lo (nm)",WIDTH_ERRLO,1);
p->entry_errhi=new_label("Hi (nm)",WIDTH_ERRHI,1);
gtk_label_set_max_width_chars(GTK_LABEL(p->entry_errlo),WIDTH_ERRLO);
gtk_label_set_max_width_chars(GTK_LABEL(p->entry_errhi),WIDTH_ERRHI);
p->entry_iseed=new_entry("seed",WIDTH_ISEED,0.5);
p->entry_timing=new_entry("Timing",WIDTH_TIMING,1);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_start,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_pid,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_path,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_errlo,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_errhi,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_iseed,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_timing,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
change_button(p, GTK_STOCK_PREFERENCES, (void*)kill_job_event);
gtk_box_pack_start(GTK_BOX(p->hbox),p->btn,FALSE,FALSE,0);
p->vbox=gtk_vbox_new(FALSE,0);
if(nproc[p->hid]==1){
gtk_box_pack_start(GTK_BOX(p->vbox),gtk_hseparator_new(),FALSE,FALSE,0);
}
gtk_box_pack_start(GTK_BOX(p->vbox),p->hbox,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->vbox),gtk_hseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(pages[p->hid]),p->vbox,FALSE,FALSE,0);
/*gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook),p->hid); */
gtk_widget_show_all(p->vbox);
}
/* functions */
static Separator * _separator_init(PanelAppletHelper * helper,
GtkWidget ** widget)
{
Separator * separator;
GtkWidget * ret;
if((separator = malloc(sizeof(*separator))) == NULL)
return NULL;
separator->helper = helper;
ret = gtk_vseparator_new();
gtk_widget_show(ret);
*widget = ret;
return separator;
}
static void
_new_page (OlPlayerChooser *window,
const char *page_name)
{
OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window);
OlPlayerChooserPage *page = g_new (OlPlayerChooserPage, 1);
page->page_button = GTK_TOGGLE_BUTTON (gtk_radio_button_new_with_label (priv->page_button_group,
page_name));
priv->page_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (page->page_button));
gtk_toggle_button_set_mode (page->page_button, FALSE);
gtk_button_set_relief (GTK_BUTTON (page->page_button), GTK_RELIEF_NONE);
page->chooser = OL_APP_CHOOSER_WIDGET (ol_app_chooser_widget_new ());
gtk_widget_show (GTK_WIDGET (page->chooser));
page->panel = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL));
gtk_scrolled_window_add_with_viewport (page->panel, GTK_WIDGET (page->chooser));
GtkViewport *viewport = GTK_VIEWPORT (gtk_bin_get_child (GTK_BIN (page->panel)));
gtk_viewport_set_shadow_type (viewport, GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (page->panel,
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
g_signal_connect (page->page_button,
"toggled",
G_CALLBACK (_page_button_toggled),
page);
g_signal_connect (page->chooser,
"app-activate",
G_CALLBACK (_app_activate_cb),
window);
_page_button_toggled (page->page_button, page);
if (priv->pages->len > 0)
gtk_box_pack_start (priv->page_button_panel,
gtk_vseparator_new (),
FALSE,
FALSE,
5);
gtk_box_pack_start (priv->page_button_panel,
GTK_WIDGET (page->page_button),
FALSE, /* expand */
FALSE, /* fill */
0); /* padding */
gtk_box_pack_start (priv->chooser_panel,
GTK_WIDGET (page->panel),
TRUE, /* expand */
TRUE, /* fill */
0); /* padding */
g_ptr_array_add (priv->pages, page);
}
static void ryosconfig_key_illumination_selector_init(RyosconfigKeyIlluminationSelector *illumination_selector) {
RyosconfigKeyIlluminationSelectorPrivate *priv = RYOSCONFIG_KEY_ILLUMINATION_SELECTOR_GET_PRIVATE(illumination_selector);
illumination_selector->priv = priv;
priv->on = GTK_TOGGLE_BUTTON(gtk_check_button_new_with_label(_("On/Off")));
priv->blink = GTK_TOGGLE_BUTTON(gtk_check_button_new_with_label(_("Blinking")));
gtk_widget_set_tooltip_text(GTK_WIDGET(priv->blink), _("Blink only works when layer effect is off."));
priv->on_handler_id = g_signal_connect(G_OBJECT(priv->on), "toggled", G_CALLBACK(on_cb), illumination_selector);
priv->blink_handler_id = g_signal_connect(G_OBJECT(priv->blink), "toggled", G_CALLBACK(blink_cb), illumination_selector);
gtk_box_pack_start(GTK_BOX(illumination_selector), GTK_WIDGET(priv->on), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(illumination_selector), gtk_vseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(illumination_selector), GTK_WIDGET(priv->blink), TRUE, FALSE, 0);
}
GtkWidget *
glade_sheet_editor_new (GladeWidgetAdaptor *adaptor, GladeEditable *embed)
{
GladeSheetEditor *view_editor;
GtkWidget *vbox, *separator;
gchar *str;
g_return_val_if_fail (GLADE_IS_WIDGET_ADAPTOR (adaptor), NULL);
g_return_val_if_fail (GLADE_IS_EDITABLE (embed), NULL);
view_editor = g_object_new (GLADE_TYPE_SHEET_EDITOR, NULL);
view_editor->embed = GTK_WIDGET (embed);
/* Pack the parent on the left... */
gtk_box_pack_start (GTK_BOX (view_editor), GTK_WIDGET (embed), TRUE, TRUE, 8);
separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (view_editor), separator, FALSE, FALSE, 0);
/* ...and the vbox with datastore/label on the right */
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (view_editor), vbox, TRUE, TRUE, 8);
str = g_strdup_printf ("<b>%s</b>", _("XXX Choose a Data Model and define some\n"
"columns in the data store first"));
view_editor->no_model_message = gtk_label_new (str);
gtk_label_set_use_markup (GTK_LABEL (view_editor->no_model_message), TRUE);
gtk_label_set_justify (GTK_LABEL (view_editor->no_model_message), GTK_JUSTIFY_CENTER);
g_free (str);
gtk_box_pack_start (GTK_BOX (vbox), view_editor->no_model_message, TRUE, TRUE, 0);
view_editor->embed_list_store = (GtkWidget *) glade_widget_adaptor_create_editable(
glade_widget_adaptor_get_by_type (GTK_TYPE_LIST_STORE), GLADE_PAGE_GENERAL);
glade_editable_set_show_name (GLADE_EDITABLE (view_editor->embed_list_store), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), view_editor->embed_list_store, TRUE, TRUE, 0);
view_editor->embed_tree_store = (GtkWidget *)glade_widget_adaptor_create_editable(
glade_widget_adaptor_get_by_type (GTK_TYPE_TREE_STORE), GLADE_PAGE_GENERAL);
glade_editable_set_show_name (GLADE_EDITABLE (view_editor->embed_tree_store), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), view_editor->embed_tree_store, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (view_editor));
return GTK_WIDGET (view_editor);
}
void layout_engine_colors(GtkWidget * vbox)
{
GtkWidget * hbox;
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
#else
hbox = gtk_hbox_new(FALSE, 2);
#endif
gtk_box_pack_startC(vbox, hbox, TRUE, TRUE, 0);
my_engine_settings(hbox, TRUE);
#if GTK_CHECK_VERSION(3, 2, 0)
gtk_box_pack_startC(hbox, gtk_separator_new (GTK_ORIENTATION_VERTICAL), FALSE, FALSE, 0);
#else
gtk_box_pack_startC(hbox, gtk_vseparator_new(), FALSE, FALSE, 0);
#endif
my_engine_settings(hbox, FALSE);
}
static void
gctt_init (GncCombott *combott)
{
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *arrow;
GtkWidget *button;
GtkWidget *sep;
GncCombottPrivate *priv = GNC_COMBOTT_GET_PRIVATE (combott);
priv->active = 0;
priv->text_col = 0;
priv->tip_col = 1;
hbox = gtk_hbox_new(FALSE, 0);
arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
gtk_box_pack_end (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
sep = gtk_vseparator_new();
gtk_box_pack_end (GTK_BOX (hbox), sep, FALSE, FALSE, 0);
label = gtk_label_new(NULL);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
priv->label = label;
button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(button), GTK_WIDGET(hbox));
priv->button = button;
gtk_container_add(GTK_CONTAINER(combott), GTK_WIDGET(button));
g_signal_connect (button, "event",
G_CALLBACK (button_press_cb), combott);
gtk_widget_set_has_tooltip (GTK_WIDGET(combott), TRUE);
g_signal_connect(G_OBJECT(combott), "query-tooltip",
G_CALLBACK(which_tooltip_cb), combott);
g_signal_connect(G_OBJECT(combott), "size-allocate",
G_CALLBACK(button_getsize_cb), combott);
gtk_widget_show(GTK_WIDGET(priv->button));
}
static void
append_menu_item (GtkMenu * menu,
gchar const* category,
gchar const* icon_name,
gchar const* window_title)
{
static GtkSizeGroup* categories = NULL;
GtkWidget* widget = gtk_menu_item_new ();
GtkWidget* hbox = gtk_hbox_new (FALSE, 6);
if (!categories)
{
categories = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
}
GtkWidget* category_label = gtk_label_new (category);
gtk_misc_set_alignment (GTK_MISC (category_label), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), category_label,
FALSE, FALSE, 0);
gtk_size_group_add_widget (categories, category_label);
gtk_box_pack_start (GTK_BOX (hbox), gtk_vseparator_new (),
FALSE, FALSE, 0);
if (icon_name)
{
GtkWidget* icon = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (hbox), icon,
FALSE, FALSE, 0);
}
category_label = gtk_label_new (window_title);
gtk_box_pack_start (GTK_BOX (hbox), category_label,
FALSE, FALSE, 0);
gtk_widget_show_all (hbox);
gtk_container_add (GTK_CONTAINER (widget), hbox);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), widget);
}
void
fileops_page_create (GtkNotebook *nb)
{
GtkWidget *hbox, *vbox, *thing;
static const char *labels1[] = {
N_("Load Module"),
N_("Save Module"),
N_("Render WAV"),
N_("Save Song"),
N_("Load Sample"),
N_("Save Sample"),
N_("Load Instrument"),
N_("Save Instrument"),
NULL
};
hbox = gtk_hbox_new(FALSE, 4);
gtk_container_border_width(GTK_CONTAINER(hbox), 10);
gtk_notebook_append_page(nb, hbox, gtk_label_new(_("File")));
gtk_widget_show(hbox);
vbox = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show(vbox);
make_radio_group((const char**)labels1, vbox, typeradio, FALSE, FALSE, typeradio_changed);
#if USE_SNDFILE == 0 && defined (NO_AUDIOFILE)
gtk_widget_set_sensitive(typeradio[DIALOG_SAVE_MOD_AS_WAV], FALSE);
gtk_widget_set_sensitive(typeradio[DIALOG_LOAD_SAMPLE], FALSE);
gtk_widget_set_sensitive(typeradio[DIALOG_SAVE_SAMPLE], FALSE);
#endif
thing = gtk_vseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), thing, FALSE, FALSE, 0);
gtk_widget_show(thing);
rightbox = vbox = gtk_vbox_new(TRUE, 2);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show(vbox);
typeradio_changed();
}
int main(int argc, char *argv[]) {
GtkWidget *window = NULL, *hbox = NULL;
alsa_mixer_t mixer = {0};
char *card = NULL, *str = NULL;
card = getenv("ALSA_CARD");
if(card == NULL || strlen(card) <= 0)
card = "default";
if(alsa_mixer_init(&mixer, card) < 0) {
DEBUG("alsa mixer init failure!\nPlease make sure export ALSA_CARD env correctly.");
return -1;
}
gtk_init(&argc, &argv);
hbox = gtk_hbox_new(FALSE, 0);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "AlSA Audio Mixer");
gtk_container_set_border_width(GTK_CONTAINER(window), 12);
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(close_main_window), NULL);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_container_add(GTK_CONTAINER(window), hbox);
alsa_mixer_add_io_watch(&mixer);
am_create_playback_mixer(hbox, &mixer);
str = getenv("GTK_ALSA_MIXER_DISABLE_MIC");
if(!str || strcmp(str, "yes") != 0) {
gtk_box_pack_start(GTK_BOX(hbox), gtk_vseparator_new(), FALSE, TRUE, 12);
am_create_capture_mixer(hbox, &mixer);
}
gtk_widget_show_all(window);
gtk_main();
alsa_mixer_term(&mixer);
return 0;
}
bool wxStaticLine::Create( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
m_needParent = TRUE;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxStaticLine creation failed") );
return FALSE;
}
if ( IsVertical() )
{
m_widget = gtk_vseparator_new();
if (size.x == -1)
{
wxSize new_size( size );
new_size.x = 4;
SetSize( new_size );
}
}
else
{
m_widget = gtk_hseparator_new();
if (size.y == -1)
{
wxSize new_size( size );
new_size.y = 4;
SetSize( new_size );
}
}
m_parent->DoAddChild( this );
PostCreation(size);
return TRUE;
}
static void
init_candidate_items(void)
{
int i;
GtkWidget *vbox, *hbox;
GdkPixbuf *pixbuf = NULL;
gchar *vs_file = NULL;
GdkColor separator_color = { 0, 0xA000, 0xA000, 0xA000 };
vs_file = locate_img_file(VS_IMAGE);
if (vs_file)
pixbuf = gdk_pixbuf_new_from_file(vs_file, NULL);
g_free(vs_file);
for (i = 0; i < MAX_POP_WIN_ITEMS; i++) {
if (pixbuf) {
candidate_items[i].separator = gtk_image_new_from_pixbuf(pixbuf);
} else {
candidate_items[i].separator = gtk_vseparator_new();
gtk_widget_modify_bg(candidate_items[i].separator, GTK_STATE_NORMAL, &separator_color);
}
vbox = gtk_vbox_new(FALSE, 0);
candidate_items[i].widget = vbox;
hbox = gtk_hbox_new(FALSE, 0);
candidate_items[i].dummy_width_widget = hbox;
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
candidate_items[i].label = gtk_button_new();
gtk_box_pack_start(GTK_BOX(vbox), candidate_items[i].label, TRUE, TRUE, 0);
gtk_button_set_relief(GTK_BUTTON(candidate_items[i].label), GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(candidate_items[i].label), "clicked",
G_CALLBACK(candidate_item_clicked_cb), &candidate_items[i]);
}
if (pixbuf)
g_object_unref(pixbuf);
}
/* functions */
static Separator * _separator_init(PanelAppletHelper * helper,
GtkWidget ** widget)
{
Separator * separator;
GtkOrientation orientation;
if((separator = malloc(sizeof(*separator))) == NULL)
{
error_set("%s: %s", applet.name, strerror(errno));
return NULL;
}
separator->helper = helper;
orientation = panel_window_get_orientation(helper->window);
#if GTK_CHECK_VERSION(3, 0, 0)
separator->widget = gtk_separator_new(orientation);
#else
separator->widget = (orientation == GTK_ORIENTATION_HORIZONTAL)
? gtk_vseparator_new() : gtk_hseparator_new();
#endif
gtk_widget_show(separator->widget);
*widget = separator->widget;
return separator;
}
GtkWidget *
add_separator (GtkWidget * box, gint fill, gint pad)
{
GtkWidget *sep;
if (GTK_IS_HBOX (box))
{
sep = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (box), sep, fill, TRUE, pad);
}
else if (GTK_IS_VBOX (box))
{
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box), sep, fill, TRUE, pad);
}
else
{
return NULL;
}
gtk_widget_show (sep);
return sep;
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkVSeparator_gtk_1vseparator_1new
(
JNIEnv* env,
jclass cls
)
{
GtkWidget* result;
jlong _result;
// call function
result = gtk_vseparator_new();
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, TRUE);
}
// and finally
return _result;
}
void gcb_main()
{
GtkWidget *hbox,*vbox;
int i;
#if 1
if (gcb_enabled==old_gcb_enabled && gcb_position==old_gcb_position && gcb_position_x==old_gcb_position_x
&& gcb_position_y==old_gcb_position_y)
return;
#endif
old_gcb_enabled = gcb_enabled;
old_gcb_position = gcb_position;
old_gcb_position_x = gcb_position_x;
old_gcb_position_y = gcb_position_y;
if (mainwin) {
gtk_widget_destroy(mainwin);
mainwin = NULL;
}
#if 0
if (button_bar_tips)
gtk_widget_destroy(button_bar_tips);
#endif
if (hist_window) {
gtk_widget_destroy(hist_window);
hist_window = NULL;
}
if (!gcb_enabled)
return;
// printf("gcb_position:%d\n", gcb_position);
static char geo[][2]={{0,0},{'+','-'},{'+','+'},{'-','-'},{'-','+'}};
g_free(geomstr);
geomstr = g_strdup_printf("%c%d%c%d",
geo[gcb_position][0], gcb_position_x, geo[gcb_position][1], gcb_position_y);
dbg("geomstr %s\n", geomstr);
if (!buttonArr) {
buttonArr=(GtkWidget**)g_malloc(gcb_button_n * sizeof(GtkWidget *));
buttonStr=(gchar**)g_malloc0(gcb_button_n * sizeof(gchar *));
}
if (!hist_strArr) {
hist_strArr=(gchar**)g_malloc0(gcb_history_n * sizeof(gchar *));
hist_buttonArr=(GtkWidget**)g_malloc(gcb_history_n * sizeof(GtkWidget *));
}
mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(mainwin), FALSE);
gtk_window_set_decorated(GTK_WINDOW(mainwin),FALSE);
gtk_window_set_focus_on_map (GTK_WINDOW(mainwin), FALSE);
hist_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(hist_window), FALSE);
char icon_path[40];
sys_icon_fname("gcb.png", icon_path);
GtkWidget *win_icon=gtk_image_new_from_file(icon_path);
gtk_window_set_icon(GTK_WINDOW(mainwin),
gtk_image_get_pixbuf(GTK_IMAGE(win_icon)));
gtk_window_set_icon(GTK_WINDOW(hist_window),
gtk_image_get_pixbuf(GTK_IMAGE(win_icon)));
// Under gnome 2.0, the mainwin is not fixed if decorated, annoying
gtk_window_set_decorated(GTK_WINDOW(hist_window),FALSE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(hist_window),TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(hist_window),TRUE);
gtk_window_set_title (GTK_WINDOW (hist_window),"gcb history");
gtk_window_set_title (GTK_WINDOW(mainwin), "gcb: gtk copy-paste buffer");
gtk_window_stick(GTK_WINDOW(mainwin));
// g_signal_connect(G_OBJECT (mainwin),"destroy", G_CALLBACK (do_exit), NULL);
g_signal_connect(G_OBJECT (hist_window),"delete_event",
G_CALLBACK (delete_hist_win), NULL);
g_signal_connect(G_OBJECT (hist_window),"focus-out-event",
G_CALLBACK (hist_focus_out_callback), NULL);
#if !GTK_CHECK_VERSION(2,12,0)
button_bar_tips = gtk_tooltips_new ();
#endif
hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER(mainwin), hbox);
gtk_window_parse_geometry(GTK_WINDOW(mainwin),geomstr);
for(i=0;i<gcb_button_n;i++) {
buttonArr[i] = gtk_button_new_with_label ("---");
// gtk_container_set_border_width(GTK_CONTAINER(buttonArr[i]),0);
gtk_box_pack_start (GTK_BOX(hbox), buttonArr[i], TRUE, TRUE, FALSE);
gtk_widget_show (buttonArr[i]);
g_signal_connect (G_OBJECT (buttonArr[i]), "button-press-event",
G_CALLBACK (get_mouse_button), (gpointer) buttonArr[i]);
#if 0
g_signal_connect (G_OBJECT (buttonArr[i]), "key-press-event",
G_CALLBACK (key_press_event), NULL);
#endif
#if 1
g_signal_connect (G_OBJECT (buttonArr[i]), "scroll-event",
G_CALLBACK (gcb_button_scroll_event), NULL);
#endif
}
vbox = gtk_vbox_new (FALSE, 1);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER(hist_window), vbox);
for(i=0;i<gcb_history_n;i++) {
hist_buttonArr[i] = gtk_button_new_with_label ("---");
gtk_container_set_border_width(GTK_CONTAINER(hist_buttonArr[i]),0);
gtk_box_pack_start (GTK_BOX(vbox), hist_buttonArr[i], TRUE, TRUE, FALSE);
gtk_widget_show (hist_buttonArr[i]);
g_signal_connect (G_OBJECT (hist_buttonArr[i]), "button-press-event",
G_CALLBACK (hist_get_mouse_button), (gpointer) hist_buttonArr[i]);
#if 1
g_signal_connect (G_OBJECT (hist_buttonArr[i]), "key-press-event",
G_CALLBACK (hist_key_press_event), NULL);
#endif
}
#if 1
// need this because on win32 scoll is not recieved if win is not focused.
gtk_box_pack_start (GTK_BOX (hbox), gtk_vseparator_new(), FALSE, FALSE, 0);
GtkWidget *eve_arrow = gtk_event_box_new();
gtk_event_box_set_visible_window (GTK_EVENT_BOX(eve_arrow), FALSE);
gtk_box_pack_start (GTK_BOX(hbox), eve_arrow, FALSE, FALSE, FALSE);
g_signal_connect(G_OBJECT(eve_arrow),"button-press-event", G_CALLBACK(mouse_button_callback), NULL);
gtk_container_add(GTK_CONTAINER(eve_arrow), gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN));
#endif
gtk_widget_show_all(hbox);
gtk_widget_show (vbox);
gtk_widget_show (mainwin);
pclipboard_prim = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
pclipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
set_snoop_button(buttonArr[0]);
get_selection(pclipboard);
get_selection(pclipboard_prim);
gtk_container_set_border_width(GTK_CONTAINER(hbox),0);
gtk_container_set_border_width(GTK_CONTAINER(mainwin),0);
gtk_window_parse_geometry(GTK_WINDOW(mainwin),geomstr);
#if GTK_CHECK_VERSION(2,6,0)
g_signal_connect(pclipboard, "owner-change", G_CALLBACK (cb_owner_change), NULL);
g_signal_connect(pclipboard_prim, "owner-change", G_CALLBACK (cb_owner_change), NULL);
#endif
}
/**
* Create a vbox that contains all controls used to display
* information related to current reconciliation.
*
* \return A newly-allocated frame containing the reconcile widget
*/
GtkWidget *gsb_reconcile_create_box ( void )
{
GtkWidget *frame, *label, *table, *vbox, *hbox, *button, *separator;
frame = gtk_frame_new ( NULL );
vbox = gtk_vbox_new ( FALSE, 3 );
gtk_container_set_border_width ( GTK_CONTAINER ( vbox ), 3 );
gtk_container_add ( GTK_CONTAINER ( frame ), vbox );
/* the title of the frame */
label = gtk_label_new ( NULL );
gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
gtk_misc_set_alignment ( GTK_MISC (label), 0.0, 0.0 );
gtk_frame_set_label_widget ( GTK_FRAME(frame), label);
/* number of reconcile */
hbox = gtk_hbox_new ( FALSE, 5 );
gtk_box_pack_start ( GTK_BOX ( vbox ), hbox, FALSE, FALSE, 0);
label = gtk_label_new ( _("Reconciliation reference: ") );
gtk_box_pack_start ( GTK_BOX ( hbox ), label, FALSE, FALSE, 0);
reconcile_number_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text ( GTK_WIDGET (reconcile_number_entry),
_("If reconciliation reference ends in a digit, it is "
"automatically incremented at each reconciliation.\n"
"You can let it empty if you don't want to keep a trace of "
"the reconciliation.") );
gtk_box_pack_start ( GTK_BOX ( hbox ), reconcile_number_entry, TRUE, TRUE, 0);
separator = gtk_hseparator_new();
gtk_box_pack_start ( GTK_BOX ( vbox ), separator, FALSE, FALSE, 0);
/* under the reconcile number, we have a table */
table = gtk_table_new ( 3, 5, FALSE );
gtk_table_set_row_spacings ( GTK_TABLE ( table ), 3 );
gtk_box_pack_start ( GTK_BOX ( vbox ), table, FALSE, FALSE, 0);
separator = gtk_hseparator_new();
gtk_table_attach_defaults ( GTK_TABLE ( table ), separator, 0, 3, 1, 2 );
separator = gtk_hseparator_new();
gtk_table_attach_defaults ( GTK_TABLE ( table ), separator, 0, 3, 3, 4 );
separator = gtk_vseparator_new ();
gtk_table_attach_defaults ( GTK_TABLE ( table ), separator, 1, 2, 0, 5 );
label = gtk_label_new ( _("Date") );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 0, 1, 0, 1);
label = gtk_label_new ( _("Balance") );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 2, 3, 0, 1);
reconcile_last_date_label = gtk_label_new ( NULL );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_last_date_label,
0, 1, 2, 3 );
/* set the old balance,
* an entry the first time, will be unsensitive after */
reconcile_initial_balance_entry = gtk_entry_new ( );
gtk_widget_set_size_request ( reconcile_initial_balance_entry, 50, -1 );
g_signal_connect ( G_OBJECT ( reconcile_initial_balance_entry ),
"changed",
G_CALLBACK (gsb_reconcile_update_amounts),
NULL );
g_signal_connect ( G_OBJECT ( reconcile_initial_balance_entry ),
"focus-out-event",
G_CALLBACK ( gsb_reconcile_entry_lose_focus ),
NULL );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_initial_balance_entry,
2, 3, 2, 3 );
/* make the new date entry */
reconcile_new_date_entry = gsb_calendar_entry_new (TRUE);
gtk_widget_set_size_request ( reconcile_new_date_entry, 50, -1 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_new_date_entry,
0, 1, 4, 5 );
/* set the new balance */
reconcile_final_balance_entry = gtk_entry_new ();
gtk_widget_set_size_request ( reconcile_final_balance_entry, 50, -1 );
g_signal_connect ( G_OBJECT ( reconcile_final_balance_entry ),
"changed",
G_CALLBACK (gsb_reconcile_update_amounts),
NULL );
g_signal_connect ( G_OBJECT ( reconcile_final_balance_entry ),
"focus-out-event",
G_CALLBACK ( gsb_reconcile_entry_lose_focus ),
NULL );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_final_balance_entry,
2, 3, 4, 5 );
separator = gtk_hseparator_new();
gtk_box_pack_start ( GTK_BOX ( vbox ), separator, FALSE, FALSE, 0);
/* 2nd table under that, with the balances labels */
table = gtk_table_new ( 5, 2, FALSE );
gtk_table_set_row_spacings ( GTK_TABLE ( table ), 5 );
gtk_box_pack_start ( GTK_BOX ( vbox ), table, FALSE, FALSE, 0);
label = gtk_label_new ( _("Initial balance: ") );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 0, 1, 0, 1);
reconcile_initial_balance_label = gtk_label_new ( NULL );
gtk_misc_set_alignment ( GTK_MISC ( reconcile_initial_balance_label ), 1, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_initial_balance_label, 1, 2, 0, 1);
label = gtk_label_new ( _("Final balance: ") );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 0, 1, 1, 2);
reconcile_final_balance_label = gtk_label_new ( NULL );
gtk_misc_set_alignment ( GTK_MISC ( reconcile_final_balance_label ), 1, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_final_balance_label, 1, 2, 1, 2);
label = gtk_label_new ( _("Checking: ") );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 0, 1, 2, 3);
reconcile_marked_balance_label = gtk_label_new ( NULL );
gtk_misc_set_alignment ( GTK_MISC ( reconcile_marked_balance_label ), 1, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_marked_balance_label, 1, 2, 2, 3);
separator = gtk_hseparator_new();
gtk_table_attach_defaults ( GTK_TABLE ( table ), separator, 0, 2, 3, 4);
label = gtk_label_new ( _("Variance: ") );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 0, 1, 4, 5);
reconcile_variation_balance_label = gtk_label_new ( NULL );
gtk_misc_set_alignment ( GTK_MISC ( reconcile_variation_balance_label ), 1, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_variation_balance_label, 1, 2, 4, 5);
/* set the button to sort with the method of paymen */
separator = gtk_hseparator_new();
gtk_box_pack_start ( GTK_BOX ( vbox ), separator, FALSE, FALSE, 0);
hbox = gtk_hbox_new ( TRUE, 3 );
gtk_box_pack_start ( GTK_BOX ( vbox ), hbox, FALSE, FALSE, 0);
reconcile_sort_list_button = gtk_check_button_new_with_label (_("Sort by method of payment"));
gtk_button_set_relief ( GTK_BUTTON (reconcile_sort_list_button), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (reconcile_sort_list_button), "clicked",
G_CALLBACK (gsb_reconcile_list_button_clicked), NULL );
gtk_box_pack_start ( GTK_BOX ( hbox ), reconcile_sort_list_button, FALSE, FALSE, 0);
/* make the buttons */
hbox = gtk_hbox_new ( TRUE, 3 );
gtk_box_pack_end ( GTK_BOX ( vbox ), hbox, FALSE, FALSE, 0);
button = gtk_button_new_from_stock ( GTK_STOCK_CANCEL );
gtk_button_set_relief ( GTK_BUTTON ( button), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (button), "clicked",
G_CALLBACK (gsb_reconcile_cancel), NULL );
gtk_box_pack_start ( GTK_BOX ( hbox ), button, FALSE, FALSE, 0);
reconcile_ok_button = gtk_button_new_from_stock ( GTK_STOCK_OK );
gtk_button_set_relief ( GTK_BUTTON ( reconcile_ok_button), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT ( reconcile_ok_button ), "clicked",
G_CALLBACK (gsb_reconcile_finish_reconciliation), NULL );
gtk_box_pack_start ( GTK_BOX ( hbox ), reconcile_ok_button, FALSE, FALSE, 0);
separator = gtk_hseparator_new();
gtk_box_pack_end ( GTK_BOX ( vbox ), separator, FALSE, FALSE, 0);
gtk_widget_show_all ( frame );
return ( frame );
}
void
SetupUI::create_main_ui ()
{
GtkWidget *hpaned1;
GtkWidget *scrolledwindow1;
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *frame1;
GtkWidget *hbox1;
GtkWidget *ok_button;
GtkWidget *exit_button;
GtkWidget *vseparator1;
GdkPixbuf *icon;
GtkCellRenderer *module_list_cell;
GtkTreeViewColumn *module_list_column;
// Create main window.
m_main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (m_main_window), _("SCIM Input Method Setup"));
gtk_window_set_position (GTK_WINDOW (m_main_window), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (m_main_window), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (m_main_window), TRUE);
gtk_window_set_resizable (GTK_WINDOW (m_main_window), TRUE);
// Set the window icon
icon = gdk_pixbuf_new_from_file (SCIM_TRADEMARK_ICON_FILE, NULL);
if (icon) {
gtk_window_set_icon (GTK_WINDOW (m_main_window), icon);
g_object_unref (icon);
}
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (m_main_window), vbox1);
// Create paned window.
hpaned1 = gtk_hpaned_new ();
gtk_widget_show (hpaned1);
gtk_box_pack_start (GTK_BOX (vbox1), hpaned1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hpaned1), 4);
// Create statusbar.
m_status_bar = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (m_status_bar), TRUE);
gtk_widget_show (m_status_bar);
gtk_box_pack_start (GTK_BOX (vbox1), m_status_bar, FALSE, FALSE, 0);
// Create scrollwindow for module list.
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow1);
gtk_paned_pack1 (GTK_PANED (hpaned1), scrolledwindow1, FALSE, FALSE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1),
GTK_SHADOW_ETCHED_IN);
// Create module list view.
m_module_list_view = gtk_tree_view_new ();
gtk_widget_show (m_module_list_view);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), m_module_list_view);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (m_module_list_view), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (m_module_list_view), FALSE);
// Get module list selection.
m_module_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_module_list_view));
gtk_tree_selection_set_mode (m_module_list_selection, GTK_SELECTION_BROWSE);
// Create module list column.
module_list_cell = gtk_cell_renderer_text_new ();
module_list_column = gtk_tree_view_column_new_with_attributes (
NULL, module_list_cell, "text", MODULE_LIST_LABEL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (m_module_list_view), module_list_column);
// Create vbox for work area and button area.
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_paned_pack2 (GTK_PANED (hpaned1), vbox2, TRUE, FALSE);
// Create frame for work area.
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox2), frame1, TRUE, TRUE, 0);
m_work_area = gtk_vbox_new (FALSE, 0);
gtk_widget_show (m_work_area);
gtk_container_add (GTK_CONTAINER (frame1), m_work_area);
// Create hbox for button area.
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_end (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 8);
ok_button = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (ok_button);
gtk_box_pack_end (GTK_BOX (hbox1), ok_button, FALSE, FALSE, 4);
exit_button = gtk_button_new_from_stock ("gtk-quit");
gtk_widget_show (exit_button);
gtk_box_pack_end (GTK_BOX (hbox1), exit_button, FALSE, FALSE, 4);
vseparator1 = gtk_vseparator_new ();
gtk_widget_show (vseparator1);
gtk_box_pack_end (GTK_BOX (hbox1), vseparator1, FALSE, FALSE, 4);
m_apply_button = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_show (m_apply_button);
gtk_box_pack_end (GTK_BOX (hbox1), m_apply_button, FALSE, FALSE, 4);
GTK_WIDGET_SET_FLAGS (m_apply_button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive (m_apply_button, FALSE);
m_restore_button = gtk_button_new_from_stock ("gtk-revert-to-saved");
gtk_widget_show (m_restore_button);
gtk_box_pack_end (GTK_BOX (hbox1), m_restore_button, FALSE, FALSE, 4);
gtk_widget_set_sensitive (m_restore_button, FALSE);
g_signal_connect ((gpointer) ok_button, "clicked",
G_CALLBACK (SetupUI::ok_button_clicked_callback),
this);
g_signal_connect ((gpointer) exit_button, "clicked",
G_CALLBACK (SetupUI::exit_button_clicked_callback),
this);
g_signal_connect ((gpointer) m_apply_button, "clicked",
G_CALLBACK (SetupUI::apply_button_clicked_callback),
this);
g_signal_connect ((gpointer) m_restore_button, "clicked",
G_CALLBACK (SetupUI::restore_button_clicked_callback),
this);
g_signal_connect (G_OBJECT (m_main_window), "delete_event",
G_CALLBACK (main_window_delete_callback),
this);
g_signal_connect (G_OBJECT (m_module_list_selection), "changed",
G_CALLBACK (module_list_selection_changed_callback),
this);
gtk_widget_grab_default (m_apply_button);
}
