static void
awn_ua_alignment_offset_change(GObject *object,GParamSpec *param_spec,gpointer user_data)
{
AwnUAAlignment * self = user_data;
gint offset;
gint position;
AwnUAAlignmentPrivate *priv = AWN_UA_ALIGNMENT_GET_PRIVATE (self);
g_object_get ( priv->applet_manager,
"offset",&offset,
"position",&position,
NULL);
switch (position)
{
case GTK_POS_TOP:
gtk_alignment_set_padding (GTK_ALIGNMENT(self), offset, 0, 0, 0);
break;
case GTK_POS_BOTTOM:
gtk_alignment_set_padding (GTK_ALIGNMENT(self), 0, offset, 0, 0);
break;
case GTK_POS_LEFT:
gtk_alignment_set_padding (GTK_ALIGNMENT(self), 0, 0, offset, 0);
break;
case GTK_POS_RIGHT:
gtk_alignment_set_padding (GTK_ALIGNMENT(self), 0, 0, 0, offset);
break;
default:
g_warning ("%s: recieved invalid position %d",__func__,position);
}
}
static void
nsp_window_cmd_add_feed(GtkButton *button, gpointer user_data)
{
NspApp *app = nsp_app_get();
GtkDialog *dialog = (GtkDialog*)gtk_dialog_new();
GtkWidget *dialog_content = gtk_dialog_get_content_area(dialog);
GtkWidget *input_area = gtk_entry_new();
GtkWidget *alignment = NULL;
GtkWidget *label = gtk_label_new(NULL);
gtk_label_set_markup (GTK_LABEL (label), "<b>Feed Source</b>\n<small>Enter the URL of the feed.</small>");
alignment = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 5, 5, 5, 5);
gtk_container_add (GTK_CONTAINER (alignment), label);
gtk_box_pack_start (GTK_BOX (dialog_content), alignment, FALSE, FALSE, 0);
alignment = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 5, 5, 5);
gtk_widget_set_size_request(input_area, 250, -1);
gtk_container_add (GTK_CONTAINER (alignment), input_area);
gtk_box_pack_start (GTK_BOX (dialog_content), alignment, FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(dialog_content));
gtk_dialog_add_buttons(dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_ADD, GTK_RESPONSE_OK, NULL);
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
if (gtk_dialog_run(dialog) == GTK_RESPONSE_OK && app->window->on_feeds_add != NULL) {
nsp_jobs_queue(app->jobs, nsp_job_new(app->window->on_feeds_add, (void*)gtk_entry_get_text(GTK_ENTRY(input_area))));
}
gtk_widget_destroy(GTK_WIDGET(dialog));
}
static GtkWidget *create_config_main_page(GtkWidget *dialog,
GtkWidget *notebook,
IIJmioIndicatorOption *option)
{
GtkWidget *align, *frame, *frame_align;
GtkWidget *page;
GtkWidget *vbox, *hbox;
GtkWidget *label;
GtkWidget *text;
GtkWidget *rest_coupon;
label = gtk_label_new(_("Access Token:"));
text = gtk_entry_new();
option->widgets.access_token = text;
hbox = gtk_hbox_new(FALSE, INDICATOR_BOX_SPACE);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), text, TRUE, TRUE, 0);
align = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(align),
INDICATOR_BOX_SPACE,
INDICATOR_BOX_SPACE,
INDICATOR_BOX_SPACE,
INDICATOR_BOX_SPACE);
frame = gtk_frame_new(_("IIJmio Access Token"));
frame_align = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(frame_align),
INDICATOR_BOX_SPACE,
INDICATOR_BOX_SPACE,
INDICATOR_BOX_SPACE,
INDICATOR_BOX_SPACE);
gtk_container_add(GTK_CONTAINER(frame_align), hbox);
gtk_container_add(GTK_CONTAINER(frame), frame_align);
gtk_container_add(GTK_CONTAINER(align), frame);
vbox = gtk_vbox_new(FALSE, INDICATOR_BOX_SPACE);
gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 0);
rest_coupon = gtk_button_new_with_label(_("Check rest coupon"));
g_signal_connect(G_OBJECT(rest_coupon), "clicked",
G_CALLBACK(indicator_rest_coupon_cb), option);
gtk_box_pack_start(GTK_BOX(vbox), rest_coupon, FALSE, FALSE, 0);
return vbox;
}
static void
add_table_rows (GnomeTwoPasswordDialog *password_dialog)
{
int row;
GtkWidget *table;
int offset;
if (password_dialog->details->anon_support_on) {
offset = 12;
}
else {
offset = 0;
}
gtk_alignment_set_padding (GTK_ALIGNMENT (password_dialog->details->table_alignment),
0, 0, offset, 0);
table = password_dialog->details->table;
/* This will not kill the entries, since they are ref:ed */
gtk_container_foreach (GTK_CONTAINER (table),
(GtkCallback)remove_child, table);
row = 0;
if (password_dialog->details->show_username)
add_row (table, row++, _("_Username:"******"_Domain:"), password_dialog->details->domain_entry);
if (password_dialog->details->show_password)
add_row (table, row++, _("_Password:"), password_dialog->details->password_entry);
if (password_dialog->details->show_password_secondary)
add_row (table, row++, password_dialog->details->secondary_password_label,
password_dialog->details->password_entry_secondary);
gtk_widget_show_all (table);
}
static void device_added_cb(SpiceUsbDeviceManager *manager,
SpiceUsbDevice *device, gpointer user_data)
{
SpiceUsbDeviceWidget *self = SPICE_USB_DEVICE_WIDGET(user_data);
SpiceUsbDeviceWidgetPrivate *priv = self->priv;
GtkWidget *align, *check;
gchar *desc;
desc = spice_usb_device_get_description(device,
priv->device_format_string);
check = gtk_check_button_new_with_label(desc);
g_free(desc);
if (spice_usb_device_manager_is_device_connected(priv->manager,
device))
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
g_object_set_data_full(
G_OBJECT(check), "usb-device",
g_boxed_copy(spice_usb_device_get_type(), device),
checkbox_usb_device_destroy_notify);
g_signal_connect(G_OBJECT(check), "clicked",
G_CALLBACK(checkbox_clicked_cb), self);
align = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align), 0, 0, 12, 0);
gtk_container_add(GTK_CONTAINER(align), check);
gtk_box_pack_end(GTK_BOX(self), align, FALSE, FALSE, 0);
spice_usb_device_widget_update_status(self);
gtk_widget_show_all(align);
}
static void
spice_usb_device_widget_show_info_bar(SpiceUsbDeviceWidget *self,
const gchar *message,
GtkMessageType message_type,
const gchar *stock_icon_id)
{
SpiceUsbDeviceWidgetPrivate *priv = self->priv;
GtkWidget *info_bar, *content_area, *hbox, *widget;
spice_usb_device_widget_hide_info_bar(self);
info_bar = gtk_info_bar_new();
gtk_info_bar_set_message_type(GTK_INFO_BAR(info_bar), message_type);
content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_bar));
#if GTK_CHECK_VERSION(3,0,0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);
#else
hbox = gtk_hbox_new(FALSE, 12);
#endif
gtk_container_add(GTK_CONTAINER(content_area), hbox);
widget = gtk_image_new_from_stock(stock_icon_id,
GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
widget = gtk_label_new(message);
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
priv->info_bar = gtk_alignment_new(0.0, 0.0, 1.0, 0.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(priv->info_bar), 0, 0, 12, 0);
gtk_container_add(GTK_CONTAINER(priv->info_bar), info_bar);
gtk_box_pack_start(GTK_BOX(self), priv->info_bar, FALSE, FALSE, 0);
gtk_widget_show_all(priv->info_bar);
}
//
// widget layout
// background
// |--alignment
// |--finishLabel
//
static GtkWidget *create_sort_finish_widget(void)
{
GtkWidget *background;
GtkWidget *alignment;
GtkWidget *finishLabel;
// background
background = gtk_event_box_new();
gtk_widget_set_name(background, "sort_finish_background");
gtk_widget_set_size_request(background, SORT_WND_FINISH_BK_WIDTH, SORT_WND_FINISH_BK_HEIGHT);
// alignment
alignment = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
SORT_WND_TOP_PADDING, SORT_WND_BOTTOM_PADDING,
SORT_WND_LEFT_PADDING, SORT_WND_RIGHT_PADDING);
gtk_container_add(GTK_CONTAINER(background), alignment);
// finishLabel
finishLabel = gtk_label_new("");
gtk_widget_set_name(finishLabel, "sort_wnd_text_bold");
gtk_misc_set_alignment(GTK_MISC(finishLabel), 0.0, 0.5);
gtk_widget_set_size_request(finishLabel,
(SORT_WND_FINISH_BK_WIDTH - SORT_WND_LEFT_PADDING - SORT_WND_RIGHT_PADDING),
(SORT_WND_FINISH_BK_HEIGHT - SORT_WND_TOP_PADDING - SORT_WND_BOTTOM_PADDING));
gtk_label_set_ellipsize(GTK_LABEL(finishLabel), PANGO_ELLIPSIZE_END);
gtk_label_set_justify(GTK_LABEL(finishLabel), GTK_JUSTIFY_LEFT);
gtk_container_add(GTK_CONTAINER(alignment), finishLabel);
// global variables
g_sort_wnd.finishLabel = finishLabel;
// show widgets
gtk_widget_show_all(background);
// return
return background;
}
static void _slider_init (GtkDarktableSlider *slider)
{
slider->is_dragging=FALSE;
slider->is_sensibility_key_pressed=FALSE;
slider->entry=gtk_entry_new();
gtk_widget_add_events (GTK_WIDGET (slider),
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK |
GDK_POINTER_MOTION_MASK);
GtkWidget *hbox=gtk_hbox_new(TRUE,0);
slider->hbox = GTK_HBOX(hbox);
GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, DTGTK_SLIDER_BORDER_WIDTH*2, DTGTK_SLIDER_ADJUST_BUTTON_WIDTH+DTGTK_SLIDER_BORDER_WIDTH*2);
gtk_container_add(GTK_CONTAINER(alignment), slider->entry);
gtk_box_pack_start(GTK_BOX(hbox),alignment,TRUE,TRUE,0);
gtk_container_add(GTK_CONTAINER(slider),hbox);
gtk_entry_set_has_frame (GTK_ENTRY(slider->entry), FALSE);
gtk_entry_set_alignment (GTK_ENTRY(slider->entry), 1.0);
g_signal_connect (G_OBJECT (slider->entry), "key-press-event", G_CALLBACK(_slider_entry_key_event), (gpointer)slider);
dt_gui_key_accel_block_on_focus_connect (slider->entry);
}
static GtkWidget *
account_assistant_build_import_page (EmpathyAccountAssistant *self)
{
GtkWidget *main_vbox, *w, *import;
EmpathyImportWidget *iw;
EmpathyAccountAssistantPriv *priv = GET_PRIV (self);
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
w = gtk_label_new (_("Select the accounts you want to import:"));
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
gtk_widget_show (w);
gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 6);
w = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (w), 0, 0, 12, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
/* NOTE: this is hardcoded as we support pidgin only */
iw = empathy_import_widget_new (EMPATHY_IMPORT_APPLICATION_PIDGIN);
import = empathy_import_widget_get_widget (iw);
gtk_container_add (GTK_CONTAINER (w), import);
gtk_widget_show (import);
priv->iw = iw;
gtk_widget_show (main_vbox);
return main_vbox;
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), -1, 200);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
GtkWidget *frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(window), frame);
GtkWidget *label1 = gtk_label_new("<b>Common Frame</b>");
gtk_label_set_use_markup(GTK_LABEL(label1), TRUE);
gtk_frame_set_label_widget(GTK_FRAME(frame), label1);
GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 5, 0, 12, 0);
gtk_container_add(GTK_CONTAINER(frame), alignment);
GtkWidget *label2 = gtk_label_new("Label inside a Common Frame");
gtk_container_add(GTK_CONTAINER(alignment), label2);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void init_title (WindowckPlugin *wckp)
{
set_title_colors(wckp);
resize_title(wckp);
gtk_label_set_ellipsize(wckp->title, PANGO_ELLIPSIZE_END);
if (wckp->prefs->size_mode != SHRINK)
gtk_misc_set_alignment(GTK_MISC(wckp->title), wckp->prefs->title_alignment / 10.0, 0.5);
/* get the xfwm4 chanel */
wckp->wm_channel = wck_properties_get_channel (G_OBJECT (wckp->plugin), "xfwm4");
/* try to set title settings from the xfwm4 theme */
if (wckp->wm_channel && wckp->prefs->sync_wm_font)
{
apply_wm_settings (wckp);
g_signal_connect (wckp->wm_channel, "property-changed", G_CALLBACK (on_xfwm_channel_property_changed), wckp);
}
gtk_alignment_set_padding(GTK_ALIGNMENT(wckp->alignment), ICON_PADDING, ICON_PADDING, wckp->prefs->title_padding, wckp->prefs->title_padding);
gtk_box_set_spacing (GTK_BOX(wckp->hvbox), wckp->prefs->title_padding);
/* get the xsettings chanel to update the gtk theme */
wckp->x_channel = wck_properties_get_channel (G_OBJECT (wckp->plugin), "xsettings");
if (wckp->x_channel)
g_signal_connect (wckp->x_channel, "property-changed", G_CALLBACK (on_x_chanel_property_changed), wckp);
}
void
html_diag_finish(Thtml_diag * dg, GCallback ok_func)
{
GtkWidget *align, *hbox;
align = gtk_alignment_new(0.5, 1.0, 1.0, 0.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align), 12, 0, 0, 0);
#if GTK_CHECK_VERSION(3,0,0)
hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
hbox = gtk_hbutton_box_new();
#endif
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), 12);
gtk_container_add(GTK_CONTAINER(align), hbox);
dg->obut = bf_stock_ok_button(ok_func, dg);
dg->cbut = bf_stock_cancel_button(G_CALLBACK(html_diag_cancel_clicked_cb), dg);
gtk_box_pack_start(GTK_BOX(hbox), dg->cbut, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), dg->obut, FALSE, FALSE, 0);
gtk_window_set_default(GTK_WINDOW(dg->dialog), dg->obut);
gtk_box_pack_start(GTK_BOX(dg->vbox), align, FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(dg->dialog));
}
static void
pack_in_frame (GtkWidget *box,
GtkWidget *content,
const char *text)
{
GtkWidget *frame, *alignment, *label;
char *markup;
markup = g_markup_printf_escaped ("<b>%s</b>", text);
label = gtk_label_new (markup);
g_free (markup);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
frame = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (frame), label, FALSE, FALSE, 0);
alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment),
0, 0, 12, 0);
gtk_box_pack_start (GTK_BOX (frame), alignment, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (alignment), content);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
gtk_widget_show_all (frame);
#ifndef HAVE_HILDON
games_atk_util_add_atk_relation (label, frame, ATK_RELATION_LABEL_FOR);
games_atk_util_add_atk_relation (frame, label, ATK_RELATION_LABELLED_BY);
#endif /* !HAVE_HILDON */
}
GtkWidget *
notebook_create_widget (GtkWidget * dlg)
{
GtkWidget *w;
GSList *tab;
/* get shared memory */
tabs = get_tabs (options.common_data.key, TRUE);
if (!tabs)
exit (-1);
/* create widget */
w = notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (w), options.notebook_data.pos);
gtk_container_set_border_width (GTK_CONTAINER (w), 5);
/* add tabs */
for (tab = options.notebook_data.tabs; tab; tab = tab->next)
{
GtkWidget *a, *s;
a = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (a),
options.notebook_data.borders, options.notebook_data.borders,
options.notebook_data.borders, options.notebook_data.borders);
s = gtk_socket_new ();
gtk_container_add (GTK_CONTAINER (a), s);
g_object_set_data (G_OBJECT (a), "socket", s);
gtk_notebook_append_page (GTK_NOTEBOOK (w), a, get_label ((gchar *) tab->data, 0));
}
return w;
}
static void
gnc_period_select_set_date_common (GncPeriodSelect *period, const GDate *date)
{
GncPeriodSelectPrivate *priv;
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
if (date)
{
if (priv->date_base)
g_date_free(priv->date_base);
priv->date_base = g_date_new_dmy(g_date_get_day(date),
g_date_get_month(date),
g_date_get_year(date));
if (priv->date_label == NULL)
{
priv->date_align = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(priv->date_align), 0, 0, 6, 0);
gtk_box_pack_start(GTK_BOX(period), priv->date_align, TRUE, TRUE, 0);
priv->date_label = gtk_label_new("");
gtk_container_add(GTK_CONTAINER(priv->date_align), priv->date_label);
gtk_widget_show_all(priv->date_align);
}
gnc_period_sample_update_date_label(period);
return;
}
if (priv->date_base)
{
g_date_free(priv->date_base);
priv->date_base = NULL;
gtk_widget_destroy(priv->date_align);
priv->date_align = NULL;
priv->date_label = NULL;
}
}
EaseDialogProgress* ease_dialog_progress_construct_with_image (GType object_type, const char* title, gboolean cancellable, double max, GtkWindow* modal, GtkImage* image) {
#line 190 "ease-dialog-progress.c"
EaseDialogProgress * self;
GObject* _tmp0_;
GtkHBox* hbox;
GtkAlignment* align;
#line 77 "ease-dialog-progress.vala"
g_return_val_if_fail (title != NULL, NULL);
#line 77 "ease-dialog-progress.vala"
g_return_val_if_fail (image != NULL, NULL);
#line 80 "ease-dialog-progress.vala"
self = (EaseDialogProgress*) ease_dialog_progress_construct (object_type, title, cancellable, max, modal);
#line 83 "ease-dialog-progress.vala"
hbox = _g_object_ref0 ((_tmp0_ = gtk_builder_get_object (self->priv->builder, "hbox"), GTK_IS_HBOX (_tmp0_) ? ((GtkHBox*) _tmp0_) : NULL));
#line 84 "ease-dialog-progress.vala"
align = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new (0.5f, 0.5f, (float) 0, (float) 0));
#line 85 "ease-dialog-progress.vala"
gtk_alignment_set_padding (align, (guint) 0, (guint) 0, (guint) 4, (guint) 4);
#line 86 "ease-dialog-progress.vala"
gtk_container_add ((GtkContainer*) align, (GtkWidget*) image);
#line 87 "ease-dialog-progress.vala"
gtk_widget_show ((GtkWidget*) align);
#line 88 "ease-dialog-progress.vala"
gtk_widget_show ((GtkWidget*) image);
#line 89 "ease-dialog-progress.vala"
gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
#line 215 "ease-dialog-progress.c"
_g_object_unref0 (align);
_g_object_unref0 (hbox);
return self;
}
static void
_lib_geotagging_show_offset_window(GtkWidget *widget, dt_lib_module_t *self)
{
dt_lib_geotagging_t *d = self->data;
gint x, y;
gint px, py, center_w, center_h, window_w, window_h;
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkWidget *center = dt_ui_center(darktable.gui->ui);
gdk_window_get_origin(gtk_widget_get_window(center), &px, &py);
center_w = gdk_window_get_width(gtk_widget_get_window(center));
center_h = gdk_window_get_height(gtk_widget_get_window(center));
d->floating_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_can_focus(d->floating_window, TRUE);
gtk_window_set_decorated(GTK_WINDOW(d->floating_window), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(d->floating_window), GDK_WINDOW_TYPE_HINT_POPUP_MENU);
gtk_window_set_transient_for(GTK_WINDOW(d->floating_window), GTK_WINDOW(window));
gtk_window_set_opacity(GTK_WINDOW(d->floating_window), 0.8);
gtk_window_set_modal(GTK_WINDOW(d->floating_window), TRUE);
GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 5, 5, 5);
GtkWidget *vbox = gtk_vbox_new(TRUE, 5);
gtk_container_add(GTK_CONTAINER(alignment), vbox);
d->floating_window_entry = gtk_entry_new();
gtk_widget_add_events(d->floating_window_entry, GDK_FOCUS_CHANGE_MASK);
g_signal_connect_swapped(d->floating_window, "focus-out-event", G_CALLBACK(gtk_widget_destroy), d->floating_window);
g_object_set(G_OBJECT(d->floating_window_entry), "tooltip-text", _("enter the time shown on the selected picture\nformat: hh:mm:ss"), (char *)NULL);
gtk_editable_select_region(GTK_EDITABLE(d->floating_window_entry), 0, -1);
gtk_box_pack_start(GTK_BOX(vbox), d->floating_window_entry, TRUE, TRUE, 0);
g_signal_connect(d->floating_window_entry, "key-press-event", G_CALLBACK(_lib_geotagging_floating_key_press), self);
GtkWidget *hbox = gtk_hbox_new(TRUE, 5);
GtkWidget *cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
GtkWidget *ok_button = gtk_button_new_from_stock(GTK_STOCK_OK);
gtk_box_pack_start(GTK_BOX(hbox), cancel_button, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 0);
g_signal_connect_swapped(G_OBJECT(cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), d->floating_window);
g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(_lib_geotagging_calculate_offset_callback), self);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(d->floating_window), alignment);
gtk_widget_show_all(d->floating_window);
gtk_widget_grab_focus(d->floating_window_entry);
window_w = gdk_window_get_width(gtk_widget_get_window(d->floating_window));
window_h = gdk_window_get_height(gtk_widget_get_window(d->floating_window));
x = px + 0.5*(center_w-window_w);
y = py + center_h - 20 - window_h;
gtk_window_move(GTK_WINDOW(d->floating_window), x, y);
gtk_window_present(GTK_WINDOW(d->floating_window));
}
static void
bisho_pane_init (BishoPane *pane)
{
GtkWidget *align, *banner_content;
gtk_box_set_spacing (GTK_BOX (pane), 8);
pane->description = mux_label_new ();
gtk_widget_show (pane->description);
gtk_box_pack_start (GTK_BOX (pane), pane->description, FALSE, FALSE, 0);
align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_widget_show (align);
pane->banner = gtk_info_bar_new ();
gtk_container_add (GTK_CONTAINER (align), pane->banner);
gtk_box_pack_start (GTK_BOX (pane), align, FALSE, FALSE, 0);
pane->banner_label = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (pane->banner_label), TRUE);
gtk_widget_show (pane->banner_label);
banner_content = gtk_info_bar_get_content_area (GTK_INFO_BAR (pane->banner));
gtk_container_add (GTK_CONTAINER (banner_content), pane->banner_label);
align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 32, 0);
gtk_widget_show (align);
pane->user_box = gtk_hbox_new (FALSE, 0);
pane->user_icon = gtk_image_new ();
gtk_widget_show (pane->user_icon);
gtk_box_pack_start (GTK_BOX (pane->user_box), pane->user_icon, FALSE, FALSE, 8);
pane->user_name = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (pane->user_box), pane->user_name, TRUE, TRUE, 8);
gtk_container_add (GTK_CONTAINER (align), pane->user_box);
gtk_box_pack_start (GTK_BOX (pane), align, FALSE, FALSE, 0);
pane->content = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (pane->content), 0, 0, 64, 64);
gtk_widget_show (pane->content);
gtk_box_pack_start (GTK_BOX (pane), pane->content, TRUE, TRUE, 0);
pane->disclaimer = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (pane->disclaimer), 0.0, 0.5);
gtk_misc_set_padding (GTK_MISC (pane->disclaimer), 6, 6);
gtk_widget_show (pane->disclaimer);
gtk_box_pack_start (GTK_BOX (pane), pane->disclaimer, FALSE, TRUE, 0);
}
static VALUE
rg_set_padding(VALUE self, VALUE top, VALUE bottom, VALUE left, VALUE right)
{
gtk_alignment_set_padding(RVAL2GTKALIGNMENT(self),
NUM2UINT(top), NUM2UINT(bottom),
NUM2UINT(left), NUM2UINT(right));
return self;
}
void show_subjects(GtkWidget* button, GtkWidget **data) {
GtkWidget *content, *subjects, *credits, *grades, *calculate_button, *calculate;
gchar *grade_list[] = { "S","A","B","C","D","E","U" };
gint p,i;
Dep = gtk_combo_box_get_active(GTK_COMBO_BOX(data[0]));
Sem = gtk_combo_box_get_active(GTK_COMBO_BOX(data[1])) ;
subjects_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(subjects_window),20);
gtk_window_set_modal(GTK_WINDOW(subjects_window), TRUE);
gtk_window_set_position(GTK_WINDOW(subjects_window),GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(subjects_window),"Choose Your Grade in each Subject: ");
gtk_window_set_resizable(GTK_WINDOW(subjects_window),FALSE);
content = gtk_table_new(2,3,FALSE);
gtk_table_set_col_spacings(GTK_TABLE(content),12);
gtk_table_set_col_spacings(GTK_TABLE(content),12);
subjects = gtk_vbox_new(FALSE,0);
gtk_box_set_spacing(GTK_BOX(subjects),4);
gtk_box_pack_start(GTK_BOX(subjects),gtk_label_new("Subject"), TRUE, TRUE, 10);
credits = gtk_vbox_new(FALSE,0);
gtk_box_set_spacing(GTK_BOX(credits),4);
gtk_box_pack_start(GTK_BOX(credits),gtk_label_new("Credits"), TRUE, TRUE, 10);
grades = gtk_vbox_new(FALSE,0);
gtk_box_set_spacing(GTK_BOX(grades),0);
gtk_box_pack_start(GTK_BOX(grades),gtk_label_new("Grade"), TRUE, TRUE, 16.5);
for(p = 0; p<no_of_papers[Dep][Sem]; p++) {
gtk_box_pack_start(GTK_BOX(subjects), gtk_label_new(list[Dep][Sem][p].paper), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(credits),
gtk_label_new(g_strdup_printf("%d",list[Dep][Sem][p].points)), TRUE, TRUE, 0);
grade[p] = gtk_combo_box_text_new();
for(i=0;i<7;i++)
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(grade[p]), grade_list[i]);
gtk_combo_box_set_active(GTK_COMBO_BOX(grade[p]),0);
gtk_box_pack_start( GTK_BOX(grades), grade[p], TRUE, TRUE, 3);
}
gtk_table_attach(GTK_TABLE(content),subjects,0,1,0,1,GTK_FILL,GTK_FILL,5,5);
gtk_table_attach(GTK_TABLE(content),credits,1,2,0,1,GTK_FILL,GTK_FILL,0,0);
gtk_table_attach(GTK_TABLE(content),grades,2,3,0,1,GTK_FILL,GTK_FILL,0,0);
calculate_button = gtk_button_new_with_label("Calculate GPA");
g_signal_connect(calculate_button,"clicked",G_CALLBACK(calculate_run),NULL);
calculate = gtk_alignment_new(1,1,0,0);
gtk_container_add(GTK_CONTAINER(calculate),calculate_button);
gtk_alignment_set_padding(GTK_ALIGNMENT(calculate),10,5,5,5);
gtk_table_attach(GTK_TABLE(content), calculate,0,3,1,2,GTK_FILL,GTK_FILL,0,0 );
gtk_container_add(GTK_CONTAINER(subjects_window),content);
gtk_widget_show_all(subjects_window);
}
GtkWidget *
slab_section_new_with_markup (const gchar * title_markup, SlabStyle style)
{
SlabSection *section;
GtkWidget *align;
gchar * widget_theming_name;
section = g_object_new (SLAB_SECTION_TYPE, NULL);
gtk_box_set_homogeneous (GTK_BOX (section), FALSE);
gtk_box_set_spacing (GTK_BOX (section), 0);
section->style = style;
section->selected = FALSE;
align = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
switch (style)
{
case Style1:
gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 0, 0);
widget_theming_name = "slab_section_style1";
break;
case Style2:
gtk_alignment_set_padding (GTK_ALIGNMENT (align), SLAB_TOP_PADDING,
SLAB_BOTTOM_PADDING, SLAB_LEFT_PADDING, 0);
widget_theming_name = "slab_section_style2";
break;
default:
g_assert_not_reached ();
}
gtk_box_pack_start (GTK_BOX (section), align, TRUE, TRUE, 0);
section->childbox = GTK_BOX (gtk_vbox_new (FALSE, 10));
gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (section->childbox));
section->title = gtk_label_new (title_markup);
gtk_label_set_use_markup (GTK_LABEL (section->title), TRUE);
gtk_misc_set_alignment (GTK_MISC (section->title), 0.0, 0.5);
gtk_widget_set_name (GTK_WIDGET (section), widget_theming_name);
g_signal_connect (G_OBJECT (section), "style-set", G_CALLBACK (slab_section_style_set),
NULL);
gtk_box_pack_start (section->childbox, section->title, FALSE, FALSE, 0);
return GTK_WIDGET (section);
}
/*
* Modify padding of the content area of the GtkDialog
* so it is aligned with the action area.
*/
static void
update_alignment_padding (GtkWidget *widget,
GtkAllocation *allocation,
gpointer user_data)
{
PpOptionsDialog *dialog = (PpOptionsDialog*) user_data;
GtkAllocation allocation1, allocation2;
GtkWidget *action_area;
GtkWidget *content_area;
gint offset_left, offset_right;
guint padding_left, padding_right,
padding_top, padding_bottom;
action_area = (GtkWidget*)
gtk_builder_get_object (dialog->builder, "dialog-action-area1");
gtk_widget_get_allocation (action_area, &allocation2);
content_area = (GtkWidget*)
gtk_builder_get_object (dialog->builder, "content-alignment");
gtk_widget_get_allocation (content_area, &allocation1);
offset_left = allocation2.x - allocation1.x;
offset_right = (allocation1.x + allocation1.width) -
(allocation2.x + allocation2.width);
gtk_alignment_get_padding (GTK_ALIGNMENT (content_area),
&padding_top, &padding_bottom,
&padding_left, &padding_right);
if (allocation1.x >= 0 && allocation2.x >= 0)
{
if (offset_left > 0 && offset_left != padding_left)
gtk_alignment_set_padding (GTK_ALIGNMENT (content_area),
padding_top, padding_bottom,
offset_left, padding_right);
gtk_alignment_get_padding (GTK_ALIGNMENT (content_area),
&padding_top, &padding_bottom,
&padding_left, &padding_right);
if (offset_right > 0 && offset_right != padding_right)
gtk_alignment_set_padding (GTK_ALIGNMENT (content_area),
padding_top, padding_bottom,
padding_left, offset_right);
}
}
GtkWidget *resource_build_panel(void)
{
GtkWidget *table;
GtkWidget *label;
GtkWidget *alignment;
GtkWidget *total;
PangoLayout *layout;
gint width_00, height_00;
table = gtk_table_new(4, 2, TRUE);
gtk_widget_show(table);
gtk_table_set_col_spacings(GTK_TABLE(table), 5);
alignment = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 3, 3);
gtk_widget_show(alignment);
gtk_table_attach_defaults(GTK_TABLE(table), alignment, 0, 2, 0, 1);
label = gtk_label_new(NULL);
/* Caption for overview of the resources of the player */
gtk_label_set_markup(GTK_LABEL(label), _("<b>Resources</b>"));
gtk_widget_show(label);
gtk_container_add(GTK_CONTAINER(alignment), label);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
create_resource_image(GTK_TABLE(table), BRICK_RESOURCE, 0, 1);
create_resource_image(GTK_TABLE(table), GRAIN_RESOURCE, 0, 2);
create_resource_image(GTK_TABLE(table), ORE_RESOURCE, 0, 3);
create_resource_image(GTK_TABLE(table), WOOL_RESOURCE, 1, 1);
create_resource_image(GTK_TABLE(table), LUMBER_RESOURCE, 1, 2);
total = gtk_hbox_new(FALSE, 0);
gtk_widget_show(total);
/* Label */
label = gtk_label_new(_("Total"));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(total), label, TRUE, TRUE, 3);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
asset_total_label = label = gtk_label_new("-");
/* Measure the size of '00' to avoid resizing problems */
layout = gtk_widget_create_pango_layout(label, "00");
pango_layout_get_pixel_size(layout, &width_00, &height_00);
g_object_unref(layout);
gtk_widget_set_size_request(label, width_00, height_00);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(total), label, TRUE, TRUE, 3);
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), total, 1, 2, 3, 4,
(GtkAttachOptions) GTK_EXPAND | GTK_FILL,
(GtkAttachOptions) GTK_FILL, 3, 0);
return table;
}
static void
empathy_presence_chooser_init (EmpathyPresenceChooser *chooser)
{
GtkWidget *arrow;
GtkWidget *alignment;
EmpathyPresenceChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser,
EMPATHY_TYPE_PRESENCE_CHOOSER, EmpathyPresenceChooserPriv);
chooser->priv = priv;
gtk_button_set_relief (GTK_BUTTON (chooser), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (chooser), FALSE);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (chooser), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 1, 0);
priv->hbox = gtk_hbox_new (FALSE, 1);
gtk_widget_show (priv->hbox);
gtk_container_add (GTK_CONTAINER (alignment), priv->hbox);
priv->image = gtk_image_new ();
gtk_widget_show (priv->image);
gtk_box_pack_start (GTK_BOX (priv->hbox), priv->image, FALSE, TRUE, 0);
priv->label = gtk_label_new (NULL);
gtk_widget_show (priv->label);
gtk_box_pack_start (GTK_BOX (priv->hbox), priv->label, TRUE, TRUE, 0);
gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment (GTK_MISC (priv->label), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (priv->label), 4, 1);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_box_pack_start (GTK_BOX (priv->hbox), alignment, FALSE, FALSE, 0);
arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
gtk_widget_show (arrow);
gtk_container_add (GTK_CONTAINER (alignment), arrow);
g_signal_connect (chooser, "toggled",
G_CALLBACK (presence_chooser_toggled_cb),
NULL);
g_signal_connect (chooser, "button-press-event",
G_CALLBACK (presence_chooser_button_press_event_cb),
NULL);
g_signal_connect (chooser, "scroll-event",
G_CALLBACK (presence_chooser_scroll_event_cb),
NULL);
priv->idle = empathy_idle_dup_singleton ();
presence_chooser_presence_changed_cb (chooser);
g_signal_connect_swapped (priv->idle, "notify",
G_CALLBACK (presence_chooser_presence_changed_cb),
chooser);
}
static void
gtk_tooltip_init (GtkTooltip *tooltip)
{
tooltip->timeout_id = 0;
tooltip->browse_mode_timeout_id = 0;
tooltip->browse_mode_enabled = FALSE;
tooltip->keyboard_mode_enabled = FALSE;
tooltip->current_window = NULL;
tooltip->keyboard_widget = NULL;
tooltip->tooltip_widget = NULL;
tooltip->toplevel_window = NULL;
tooltip->last_window = NULL;
tooltip->window = g_object_ref (gtk_window_new (GTK_WINDOW_POPUP));
gtk_window_set_type_hint (GTK_WINDOW (tooltip->window),
GDK_WINDOW_TYPE_HINT_TOOLTIP);
gtk_widget_set_app_paintable (tooltip->window, TRUE);
gtk_window_set_resizable (GTK_WINDOW (tooltip->window), FALSE);
gtk_widget_set_name (tooltip->window, "gtk-tooltip");
g_signal_connect (tooltip->window, "hide",
G_CALLBACK (gtk_tooltip_window_hide), tooltip);
tooltip->alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (tooltip->alignment),
tooltip->window->style->ythickness,
tooltip->window->style->ythickness,
tooltip->window->style->xthickness,
tooltip->window->style->xthickness);
gtk_container_add (GTK_CONTAINER (tooltip->window), tooltip->alignment);
gtk_widget_show (tooltip->alignment);
g_signal_connect_swapped (tooltip->window, "style-set",
G_CALLBACK (gtk_tooltip_window_style_set), tooltip);
g_signal_connect_swapped (tooltip->window, "expose-event",
G_CALLBACK (gtk_tooltip_paint_window), tooltip);
tooltip->box = gtk_hbox_new (FALSE, tooltip->window->style->xthickness);
gtk_container_add (GTK_CONTAINER (tooltip->alignment), tooltip->box);
gtk_widget_show (tooltip->box);
tooltip->image = gtk_image_new ();
gtk_box_pack_start (GTK_BOX (tooltip->box), tooltip->image,
FALSE, FALSE, 0);
tooltip->label = gtk_label_new ("");
gtk_label_set_line_wrap (GTK_LABEL (tooltip->label), TRUE);
gtk_box_pack_start (GTK_BOX (tooltip->box), tooltip->label,
FALSE, FALSE, 0);
tooltip->custom_widget = NULL;
}
GtkWidget *create_config_main_page(GtkWidget *notebook, GKeyFile *pkey)
{
GtkWidget *vbox;
GtkWidget *startup_align;
GtkWidget *startup_frm;
GtkWidget *startup_frm_align;
GtkWidget *general_lbl;
debug_print("create_config_main_page\n");
if (notebook == NULL){
return NULL;
}
/* startup */
if (pkey!=NULL){
}
vbox = gtk_vbox_new(FALSE, 0);
/**/
startup_align = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(startup_align), ALIGN_TOP, ALIGN_BOTTOM, ALIGN_LEFT, ALIGN_RIGHT);
startup_frm = gtk_frame_new(_("Startup Option"));
startup_frm_align = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(startup_frm_align), ALIGN_TOP, ALIGN_BOTTOM, ALIGN_LEFT, ALIGN_RIGHT);
g_opt.startup = gtk_check_button_new_with_label(_("Enable plugin on startup."));
gtk_container_add(GTK_CONTAINER(startup_frm_align), g_opt.startup);
gtk_container_add(GTK_CONTAINER(startup_frm), startup_frm_align);
gtk_container_add(GTK_CONTAINER(startup_align), startup_frm);
gtk_widget_show(g_opt.startup);
/**/
gtk_box_pack_start(GTK_BOX(vbox), startup_align, FALSE, FALSE, 0);
general_lbl = gtk_label_new(_("General"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, general_lbl);
gtk_widget_show_all(notebook);
return NULL;
}
GtkWidget *
create_throbber_dialog (const gchar *title,
GtkWidget **label)
{
GtkWidget *dialog;
GtkWidget *status_label;
GtkWidget *hbox, *throbber;
GtkWidget *main_box, *main_alignment;
dialog = gtk_dialog_new_with_buttons (title,
NULL,
GTK_DIALOG_NO_SEPARATOR,
NULL);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 0);
gtk_window_set_deletable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (dialog), "gtk-info");
/* Create the main alignment for the dialog */
main_alignment = gtk_alignment_new (0, 0, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (main_alignment), 0, 0, 6, 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_alignment, TRUE, TRUE, 0);
/* Create the main box for the dialog */
main_box = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (main_box), 12);
gtk_container_add (GTK_CONTAINER (main_alignment), main_box);
/* Top horizontal box for the throbber */
hbox= gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
gtk_container_add (GTK_CONTAINER (main_box), hbox);
/* Add the throbber */
throbber = katze_throbber_new ();
katze_throbber_set_animated (KATZE_THROBBER (throbber), TRUE);
gtk_box_pack_end (GTK_BOX (hbox), throbber, FALSE, FALSE, 0);
/* Status label*/
status_label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (status_label),
_("<span weight=\"bold\" stretch=\"semiexpanded\">"
"Status</span>"));
gtk_misc_set_alignment (GTK_MISC (status_label), 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), status_label, FALSE, FALSE, 0);
/* Information label */
*label = gtk_label_new ("");
gtk_container_add (GTK_CONTAINER (main_box), *label);
gtk_widget_show_all (GTK_DIALOG(dialog)->vbox);
return dialog;
}
void playlist3_new_header(void)
{
GtkWidget *hbox10 = GTK_WIDGET(gtk_builder_get_object(pl3_xml, "hbox10"));
if (hbox10)
{
GtkWidget *hbox = gtk_hbox_new(FALSE, 6);
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
// expand in width, align in middle
GtkAlignment *title_header_top_alignment = gtk_alignment_new(0,0.5,1.0,0);
// set a 3 px top/bottom border (looks better then 6)
gtk_alignment_set_padding(title_header_top_alignment, 3,3,0,0);
// set minimum width 300 pixels.
gtk_widget_set_size_request(title_header_top_alignment, 300, -1);
/** Title */
header_labels[0] = (GtkWidget *)gmpc_clicklabel_new("");
gmpc_clicklabel_font_size(GMPC_CLICKLABEL(header_labels[0]), 12);
gmpc_clicklabel_set_do_bold(GMPC_CLICKLABEL(header_labels[0]), TRUE);
gmpc_clicklabel_set_ellipsize(GMPC_CLICKLABEL(header_labels[0]), PANGO_ELLIPSIZE_END);
header_labels[1] = gtk_label_new(_("By"));
/** Artist */
header_labels[2] = (GtkWidget *)gmpc_clicklabel_new("");
gmpc_clicklabel_set_ellipsize(GMPC_CLICKLABEL(header_labels[2]), PANGO_ELLIPSIZE_NONE);
header_labels[3] = gtk_label_new(_("From"));
/** Albumr */
header_labels[4] = (GtkWidget *)gmpc_clicklabel_new("");
gmpc_clicklabel_set_ellipsize(GMPC_CLICKLABEL(header_labels[4]), PANGO_ELLIPSIZE_END);
gtk_box_pack_start(GTK_BOX(vbox), header_labels[0], FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), header_labels[1], FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), header_labels[2], FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), header_labels[3], FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), header_labels[4], TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(header_labels[0]), "clicked", G_CALLBACK(playlist3_header_song), NULL);
g_signal_connect(G_OBJECT(header_labels[2]), "clicked", G_CALLBACK(playlist3_header_artist), NULL);
g_signal_connect(G_OBJECT(header_labels[4]), "clicked", G_CALLBACK(playlist3_header_album), NULL);
gtk_container_add(GTK_CONTAINER(title_header_top_alignment), vbox);
gtk_box_pack_start(GTK_BOX(hbox10), title_header_top_alignment, TRUE, TRUE, 0);
gtk_widget_show_all(hbox10);
g_signal_connect(G_OBJECT(hbox10), "style-set", G_CALLBACK(playlist3_header_update_style), NULL);
playlist3_header_update_style(hbox10, NULL, NULL);
}
}
static void
aw_window_vadjustment_changed_cb (GtkAdjustment *adjustment,
GtkAlignment *alignment)
{
int left_margin = HILDON_MARGIN_DEFAULT;
int right_margin = HILDON_MARGIN_DEFAULT;
if (adjustment->upper > adjustment->page_size)
right_margin = 0;
gtk_alignment_set_padding (alignment, 0, 0, left_margin, right_margin);
}
int
main (int argc, char **argv)
{
GtkWidget *window, *vbox, *frame, *swtch, *swtch2, *toggle, *vbox2;
gboolean is_active = FALSE;
gtk_init (&argc, &argv);
if (argc > 1)
is_active = atoi (argv[1]);
g_debug ("setting switch to '%d'", is_active);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 320, 240);
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (window), vbox);
frame = mx_gtk_frame_new ();
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 10);
gtk_frame_set_label (GTK_FRAME (frame), "Frame Title");
vbox2 = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 10);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
swtch = mx_gtk_light_switch_new ();
mx_gtk_light_switch_set_active (MX_GTK_LIGHT_SWITCH (swtch), is_active);
gtk_container_add (GTK_CONTAINER (vbox2), swtch);
swtch2 = mx_gtk_light_switch_new ();
gtk_widget_set_sensitive (swtch2, FALSE);
mx_gtk_light_switch_set_active (MX_GTK_LIGHT_SWITCH (swtch2), is_active);
gtk_container_add (GTK_CONTAINER (vbox2), swtch2);
frame = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (frame), 10, 10, 10, 10);
gtk_container_add (GTK_CONTAINER (vbox), frame);
toggle = gtk_toggle_button_new_with_label ("Toggle");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), is_active);
gtk_container_add (GTK_CONTAINER (frame), toggle);
g_signal_connect (toggle, "toggled", G_CALLBACK (_toggle_cb), swtch);
gtk_widget_show_all (window);
g_signal_connect (window, "delete-event", gtk_main_quit, NULL);
gtk_main ();
return 0;
}
