JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkCalendar_gtk_1calendar_1set_1display_1options
(
JNIEnv* env,
jclass cls,
jlong _self,
jint _flags
)
{
GtkCalendar* self;
GtkCalendarDisplayOptions flags;
// convert parameter self
self = (GtkCalendar*) _self;
// convert parameter flags
flags = (GtkCalendarDisplayOptions) _flags;
// call function
gtk_calendar_set_display_options(self, flags);
// cleanup parameter self
// cleanup parameter flags
}
/* Display a window containing the standard calendar widget. */
static GtkWidget * dclock_create_calendar(DClockPlugin * dc)
{
/* Create a new window. */
GtkWindow * window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_skip_taskbar_hint(window, TRUE);
gtk_window_set_skip_pager_hint(window, TRUE);
gtk_window_set_default_size(window, 180, 180);
gtk_window_set_decorated(window, FALSE);
gtk_window_set_resizable(window, FALSE);
gtk_window_stick(window);
gtk_container_set_border_width(GTK_CONTAINER(window), 0);
GtkWidget * viewport = gtk_viewport_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(window), viewport);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_OUT);
gtk_widget_show(viewport);
/* Create a vertical box as a child of the window. */
GtkWidget * box = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(viewport), GTK_WIDGET(box));
/* Create a standard calendar widget as a child of the vertical box. */
GtkWidget * calendar = gtk_calendar_new();
gtk_calendar_set_display_options(
GTK_CALENDAR(calendar),
GTK_CALENDAR_SHOW_WEEK_NUMBERS | GTK_CALENDAR_SHOW_DAY_NAMES | GTK_CALENDAR_SHOW_HEADING);
gtk_box_pack_start(GTK_BOX(box), calendar, TRUE, TRUE, 0);
/* Connect signals. */
g_signal_connect(G_OBJECT(window), "map", G_CALLBACK(dclock_popup_map), dc);
/* Return the widget. */
return GTK_WIDGET(window);
}
static VALUE
rg_set_display_options(VALUE self, VALUE flags)
{
gtk_calendar_set_display_options(_SELF(self),
RVAL2GFLAGS(flags,
GTK_TYPE_CALENDAR_DISPLAY_OPTIONS));
return self;
}
static GtkWidget* create_simple_calendar_item(GtkWidget** calendar_out)
{
GtkWidget* menu_item = gtk_menu_item_new();
GtkWidget* calendar = *calendar_out = gtk_calendar_new();
gtk_calendar_set_display_options(GTK_CALENDAR(calendar),
GTK_CALENDAR_SHOW_HEADING | GTK_CALENDAR_NO_MONTH_CHANGE |
GTK_CALENDAR_SHOW_DAY_NAMES | GTK_CALENDAR_SHOW_DETAILS);
gtk_widget_set_sensitive(menu_item, FALSE);
gtk_container_add(GTK_CONTAINER(menu_item), calendar);
return menu_item;
}
static void
calendar_set_flags (CalendarData *calendar)
{
gint options = 0, i;
for (i = 0; i < G_N_ELEMENTS (calendar->settings); i++)
if (calendar->settings[i])
options=options + (1 << i);
if (calendar->window)
gtk_calendar_set_display_options (GTK_CALENDAR (calendar->window), options);
}
int
clip_GTK_CALENDARSETDISPLAYOPTIONS(ClipMachine * ClipMachineMemory)
{
C_widget *ccal = _fetch_cw_arg(ClipMachineMemory);
GtkCalendarDisplayOptions opt = _clip_parni(ClipMachineMemory, 2);
CHECKCWID(ccal, GTK_IS_CALENDAR);
CHECKARG(2, NUMERIC_type_of_ClipVarType);
gtk_calendar_set_display_options(GTK_CALENDAR(ccal->widget), opt);
return 0;
err:
return 1;
}
/** \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 void
create_children (GNCDateEdit *gde)
{
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *arrow;
GtkTreeStore *store;
GtkCellRenderer *cell;
/* Create the text entry area. */
gde->date_entry = gtk_entry_new ();
gtk_entry_set_width_chars (GTK_ENTRY (gde->date_entry), 11);
gtk_box_pack_start (GTK_BOX (gde), gde->date_entry, TRUE, TRUE, 0);
gtk_widget_show (GTK_WIDGET(gde->date_entry));
g_signal_connect (G_OBJECT (gde->date_entry), "key-press-event",
G_CALLBACK (key_press_entry), gde);
g_signal_connect (G_OBJECT (gde->date_entry), "focus-out-event",
G_CALLBACK (date_focus_out_event), gde);
/* Create the popup button. */
gde->date_button = gtk_toggle_button_new ();
g_signal_connect (gde->date_button, "button-press-event",
G_CALLBACK(gnc_date_edit_button_pressed), gde);
g_signal_connect (G_OBJECT (gde->date_button), "toggled",
G_CALLBACK (gnc_date_edit_button_toggled), gde);
gtk_box_pack_start (GTK_BOX (gde), gde->date_button, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_container_add (GTK_CONTAINER (gde->date_button), hbox);
gtk_widget_show (GTK_WIDGET(hbox));
/* Calendar label, only shown if the date editor has a time field */
gde->cal_label = gtk_label_new (_("Calendar"));
gnc_label_set_alignment (gde->cal_label, 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), gde->cal_label, TRUE, TRUE, 0);
if (gde->flags & GNC_DATE_EDIT_SHOW_TIME)
gtk_widget_show (GTK_WIDGET(gde->cal_label));
/* Graphic for the popup button. */
arrow = gtk_image_new_from_icon_name ("go-down", GTK_ICON_SIZE_BUTTON);
g_signal_connect (G_OBJECT (arrow), "draw",
G_CALLBACK (gnc_draw_arrow_cb), GINT_TO_POINTER(1));
gtk_box_pack_start (GTK_BOX (hbox), arrow, TRUE, FALSE, 0);
gtk_widget_show (GTK_WIDGET(arrow));
gtk_widget_show (GTK_WIDGET(gde->date_button));
/* Time entry controls. */
gde->time_entry = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY(gde->time_entry), 12);
gtk_widget_set_size_request (GTK_WIDGET(gde->time_entry), 88, -1);
gtk_box_pack_start (GTK_BOX (gde), gde->time_entry, TRUE, TRUE, 0);
store = gtk_tree_store_new(1, G_TYPE_STRING);
gde->time_combo = GTK_WIDGET(gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)));
g_object_unref(store);
/* Create cell renderer. */
cell = gtk_cell_renderer_text_new();
/* Pack it to the combo box. */
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( gde->time_combo ), cell, TRUE );
/* Connect renderer to data source */
gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( gde->time_combo ), cell, "text", 0, NULL );
g_signal_connect (G_OBJECT (gde->time_combo), "changed",
G_CALLBACK (set_time), gde);
gtk_box_pack_start (GTK_BOX (gde), gde->time_combo, FALSE, FALSE, 0);
/* We do not create the popup menu with the hour range until we are
* realized, so that it uses the values that the user might supply in a
* future call to gnc_date_edit_set_popup_range
*/
g_signal_connect (G_OBJECT (gde), "realize",
G_CALLBACK (fill_time_combo), gde);
if (gde->flags & GNC_DATE_EDIT_SHOW_TIME)
{
gtk_widget_show (GTK_WIDGET(gde->time_entry));
gtk_widget_show (GTK_WIDGET(gde->time_combo));
}
gde->cal_popup = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_name (gde->cal_popup, "gnc-date-edit-popup-window");
gtk_window_set_type_hint (GTK_WINDOW (gde->cal_popup),
GDK_WINDOW_TYPE_HINT_COMBO);
gtk_widget_set_events (GTK_WIDGET(gde->cal_popup),
gtk_widget_get_events (GTK_WIDGET(gde->cal_popup)) |
GDK_KEY_PRESS_MASK);
g_signal_connect (gde->cal_popup, "delete-event",
G_CALLBACK(delete_popup), gde);
g_signal_connect (gde->cal_popup, "key-press-event",
G_CALLBACK(key_press_popup), gde);
g_signal_connect (gde->cal_popup, "button-press-event",
G_CALLBACK(gnc_date_edit_button_pressed), gde);
g_signal_connect (gde->cal_popup, "button-release-event",
G_CALLBACK(gnc_date_edit_button_released), gde);
gtk_window_set_resizable (GTK_WINDOW (gde->cal_popup), FALSE);
gtk_window_set_screen (GTK_WINDOW (gde->cal_popup),
gtk_widget_get_screen (GTK_WIDGET (gde)));
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (gde->cal_popup), frame);
gtk_widget_show (GTK_WIDGET(frame));
gde->calendar = gtk_calendar_new ();
gtk_calendar_set_display_options
(GTK_CALENDAR (gde->calendar),
(GTK_CALENDAR_SHOW_DAY_NAMES
| GTK_CALENDAR_SHOW_HEADING));
g_signal_connect (gde->calendar, "button-release-event",
G_CALLBACK(gnc_date_edit_button_released), gde);
g_signal_connect (G_OBJECT (gde->calendar), "day-selected",
G_CALLBACK (day_selected), gde);
g_signal_connect (G_OBJECT (gde->calendar),
"day-selected-double-click",
G_CALLBACK (day_selected_double_click), gde);
gtk_container_add (GTK_CONTAINER (frame), gde->calendar);
gtk_widget_show (GTK_WIDGET(gde->calendar));
}
