static void
show_week_label (UmHistoryDialog *um)
{
gchar *label, *from, *to;
GDateTime *date;
GTimeSpan span;
span = g_date_time_difference (um->current_week, um->week);
if (span == 0) {
label = g_strdup (_("This Week"));
}
else if (span == G_TIME_SPAN_DAY * 7) {
label = g_strdup (_("Last Week"));
}
else {
date = g_date_time_add_days (um->week, 6);
from = g_date_time_format (um->week, "%b %e");
if (g_date_time_get_year (um->week) == g_date_time_get_year (um->current_week)) {
to = g_date_time_format (date, "%b %e");
}
else {
to = g_date_time_format (date, "%b %e, %Y");
}
label = g_strconcat (from, " - ", to, NULL);
g_date_time_unref (date);
g_free (from);
g_free (to);
}
gtk_label_set_label (GTK_LABEL (get_widget (um, "week-label")), label);
g_free (label);
}
GSList *
chat_log_get_previous(const gchar * const login, const gchar * const recipient,
GSList *history)
{
GTimeZone *tz = g_time_zone_new_local();
GDateTime *now = g_date_time_new_now_local();
GDateTime *log_date = g_date_time_new(tz,
g_date_time_get_year(session_started),
g_date_time_get_month(session_started),
g_date_time_get_day_of_month(session_started),
g_date_time_get_hour(session_started),
g_date_time_get_minute(session_started),
g_date_time_get_second(session_started));
// get data from all logs from the day the session was started to today
while (g_date_time_compare(log_date, now) != 1) {
char *filename = _get_log_filename(recipient, login, log_date, FALSE);
FILE *logp = fopen(filename, "r");
char *line;
if (logp != NULL) {
GString *gs_header = g_string_new("");
g_string_append_printf(gs_header, "%d/%d/%d:",
g_date_time_get_day_of_month(log_date),
g_date_time_get_month(log_date),
g_date_time_get_year(log_date));
char *header = strdup(gs_header->str);
history = g_slist_append(history, header);
g_string_free(gs_header, TRUE);
while ((line = prof_getline(logp)) != NULL) {
history = g_slist_append(history, line);
}
fclose(logp);
}
free(filename);
GDateTime *next = g_date_time_add_days(log_date, 1);
g_date_time_unref(log_date);
log_date = g_date_time_ref(next);
}
g_time_zone_unref(tz);
return history;
}
/**
* gst_date_time_get_year:
* @datetime: a #GstDateTime
*
* Returns the year of this #GstDateTime
* Call gst_date_time_has_year() before, to avoid warnings.
*
* Return value: The year of this #GstDateTime
*/
gint
gst_date_time_get_year (const GstDateTime * datetime)
{
g_return_val_if_fail (datetime != NULL, 0);
return g_date_time_get_year (datetime->datetime);
}
void
print_is_leap_year (void)
{
/* Print a message to stdio letting user know if the current year is
a leap year. */
GTimeZone *tz;
GDateTime *dt;
GDateYear theYear;
tz = (GTimeZone *)g_time_zone_new_local();
dt = (GDateTime *)g_date_time_new_now(tz);
theYear = g_date_time_get_year(dt);
if (g_date_is_leap_year(theYear)) {
g_print("This year (%d) is a leap year.\n", theYear);
} else {
g_print("This year (%d) is not a leap year.\n", theYear);
}
g_date_time_unref(dt);
g_time_zone_unref(tz);
}
static void _tgenmain_log(GLogLevelFlags level, const gchar* fileName, const gint lineNum, const gchar* functionName, const gchar* format, ...) {
if(level > tgenLogFilterLevel) {
return;
}
va_list vargs;
va_start(vargs, format);
gchar* fileStr = fileName ? g_path_get_basename(fileName) : g_strdup("n/a");
const gchar* functionStr = functionName ? functionName : "n/a";
GDateTime* dt = g_date_time_new_now_local();
GString* newformat = g_string_new(NULL);
g_string_append_printf(newformat, "%04i-%02i-%02i %02i:%02i:%02i %"G_GINT64_FORMAT".%06i [%s] [%s:%i] [%s] %s",
g_date_time_get_year(dt), g_date_time_get_month(dt), g_date_time_get_day_of_month(dt),
g_date_time_get_hour(dt), g_date_time_get_minute(dt), g_date_time_get_second(dt),
g_date_time_to_unix(dt), g_date_time_get_microsecond(dt),
_tgenmain_logLevelToString(level), fileStr, lineNum, functionName, format);
gchar* message = g_strdup_vprintf(newformat->str, vargs);
g_print("%s\n", message);
g_free(message);
g_string_free(newformat, TRUE);
g_date_time_unref(dt);
g_free(fileStr);
va_end(vargs);
}
void CalendarDatePrivate::updateYearView(gboolean isForceLoad, GTimeSpan changed) {
if (NULL == m_swipeBox[VIEWTYPE_YEAR]) {
initYearView();
}
int row = 0;
int col = 0;
int rowCount = 3;
int colCount = 4;
char buffer[32];
int selectedYear = m_selectedYear;
int cellWidth = MAIN_BOX_DEFAULT_WIDTH / colCount;
int cellHeight = MAIN_BOX_DEFAULT_WIDTH / rowCount;
GDateTime* nowDate = g_date_time_new_now_local();
int nowYear = g_date_time_get_year(nowDate);
int beginYear = ((int)selectedYear / 10) * 10 - 1;
int endYear = ((int)selectedYear / 10 + 1) * 10;
int iterYear = beginYear;
m_viewType = VIEWTYPE_YEAR;
g_snprintf(buffer, sizeof(buffer), "%d-%d", beginYear, endYear);
gtk_button_set_label(GTK_BUTTON(m_viewTypeSwitch), buffer);
for (row = 0; row < rowCount; ++row) {
for (col = 0; col < colCount; ++col) {
int index = row * colCount + col;
iterYear = beginYear + index;
if (NULL != m_yearItem[index]) {
m_yearItem[index]->addStyleClass("calendar-year-base");
m_yearItem[index]->addStyleClass("calendar-year");
if (nowYear == iterYear) {
m_yearItem[index]->removeStyleClass("calendar-other-x-year");
m_yearItem[index]->addStyleClass("calendar-current-year");
} else if (((int)(iterYear / 10)) != ((int)(selectedYear / 10))) {
m_yearItem[index]->removeStyleClass("calendar-current-year");
m_yearItem[index]->addStyleClass("calendar-other-x-year");
}
m_yearItem[index]->setValue(iterYear);
}
}
}
if (NULL != m_swipeBox[VIEWTYPE_MONTH]) {
gtk_widget_hide(m_swipeBox[VIEWTYPE_MONTH]);
}
if (NULL != m_swipeBox[VIEWTYPE_YEAR]) {
gtk_widget_show_all(m_swipeBox[VIEWTYPE_YEAR]);
}
if (NULL != m_swipeBox[VIEWTYPE_DAY]) {
gtk_widget_hide(m_swipeBox[VIEWTYPE_DAY]);
}
apply_css(GTK_WIDGET(m_actor), m_provider);
}
void
print_days_until_birthday (void)
{
/*Calculate how many days there are between now and my
birthday. (If you get something out of this glib-cookbook then
feel free to send me a present after that many days go by. ;) */
GTimeZone *tz;
GDateTime *now;
GDateTime *bday;
GTimeSpan diff;
tz = (GTimeZone *)g_time_zone_new_local();
now = (GDateTime *)g_date_time_new_now(tz);
bday = (GDateTime *)g_date_time_new(tz, g_date_time_get_year(now) + 1, 6, 25, 0, 0, 0);
diff = g_date_time_difference(bday, now);
g_print("There are %ld days until Jamil's birthday.\n",
diff / G_TIME_SPAN_DAY);
g_date_time_unref(now);
g_date_time_unref(bday);
g_time_zone_unref(tz);
}
static void today_clicked (GtkWidget *cal)
{
GDateTime *now = g_date_time_new_now_local ();
gtk_calendar_select_month ( GTK_CALENDAR(cal), g_date_time_get_month(now)-1, g_date_time_get_year(now) );
gtk_calendar_select_day ( GTK_CALENDAR(cal), g_date_time_get_day_of_month(now) );
g_date_time_unref ( now );
}
static guint
calculate_seconds_until_next_minute (void)
{
guint seconds;
GTimeSpan diff;
GDateTime * now;
GDateTime * next;
GDateTime * start_of_next;
now = g_date_time_new_now_local ();
next = g_date_time_add_minutes (now, 1);
start_of_next = g_date_time_new_local (g_date_time_get_year (next),
g_date_time_get_month (next),
g_date_time_get_day_of_month (next),
g_date_time_get_hour (next),
g_date_time_get_minute (next),
1);
diff = g_date_time_difference (start_of_next, now);
seconds = (diff + (G_TIME_SPAN_SECOND - 1)) / G_TIME_SPAN_SECOND;
/* cleanup */
g_date_time_unref (start_of_next);
g_date_time_unref (next);
g_date_time_unref (now);
return seconds;
}
static gboolean
win32_in_dst (GDateTime *date, TIME_ZONE_INFORMATION *tzinfo)
{
guint year, month, day;
SYSTEMTIME *std, *dlt;
if (tzinfo == NULL || tzinfo->StandardDate.wMonth == 0)
return FALSE;
year = g_date_time_get_year (date);
month = g_date_time_get_month (date);
day = g_date_time_get_day_of_month (date);
std = &(tzinfo->StandardDate);
dlt = &(tzinfo->DaylightDate);
if (std->wMonth < dlt->wMonth)
{
if ((month > dlt->wMonth || month < std->wMonth) ||
(month == dlt->wMonth && day > dlt->wDay) ||
(month == std->wMonth && day < std->wDay))
return TRUE;
}
else
{
if ((month > dlt->wMonth && month < std->wMonth) ||
(month == dlt->wMonth && day > dlt->wDay) ||
(month == std->wMonth && day < std->wDay))
return TRUE;
}
return FALSE;
}
gchar*
balde_datetime_logging(GDateTime *dt)
{
return g_strdup_printf("%02d/%s/%04d %02d:%02d:%02d",
g_date_time_get_day_of_month(dt), months[g_date_time_get_month(dt) - 1],
g_date_time_get_year(dt), g_date_time_get_hour(dt),
g_date_time_get_minute(dt), g_date_time_get_second(dt));
}
static void
gcal_application_show_about (GSimpleAction *simple,
GVariant *parameter,
gpointer user_data)
{
GcalApplication *app = GCAL_APPLICATION (user_data);
char *copyright;
GDateTime *date;
int created_year = 2012;
const gchar *authors[] = {
"Erick Pérez Castellanos <*****@*****.**>",
NULL
};
const gchar *artists[] = {
"Reda Lazri <*****@*****.**>",
NULL
};
date = g_date_time_new_now_local ();
if (g_date_time_get_year (date) == created_year)
{
copyright = g_strdup_printf (_("Copyright \xC2\xA9 %Id "
"The Calendar authors"),
created_year);
}
else
{
copyright = g_strdup_printf (_("Copyright \xC2\xA9 %Id\xE2\x80\x93%Id "
"The Calendar authors"),
created_year, g_date_time_get_year (date));
}
gtk_show_about_dialog (GTK_WINDOW (app->priv->window),
"program-name", "Calendar",
"version", VERSION,
"copyright", copyright,
"license-type", GTK_LICENSE_GPL_3_0,
"authors", authors,
"artists", artists,
"logo-icon-name", "x-office-calendar",
NULL);
g_free (copyright);
g_date_time_unref (date);
}
gchar*
balde_datetime_rfc5322(GDateTime *dt)
{
// datetime must be utc
return g_strdup_printf("%s, %02d %s %04d %02d:%02d:%02d GMT",
days[g_date_time_get_day_of_week(dt) - 1],
g_date_time_get_day_of_month(dt), months[g_date_time_get_month(dt) - 1],
g_date_time_get_year(dt), g_date_time_get_hour(dt),
g_date_time_get_minute(dt), g_date_time_get_second(dt));
}
char *
cc_util_get_smart_date (GDateTime *date)
{
gchar *label;
GDateTime *today, *local;
GTimeSpan span;
/* Set today date */
local = g_date_time_new_now_local ();
today = g_date_time_new_local (g_date_time_get_year (local),
g_date_time_get_month (local),
g_date_time_get_day_of_month (local),
0, 0, 0);
span = g_date_time_difference (today, date);
if (span <= 0)
{
label = g_strdup (_("Today"));
}
else if (span <= G_TIME_SPAN_DAY)
{
label = g_strdup (_("Yesterday"));
}
else
{
if (g_date_time_get_year (date) == g_date_time_get_year (today))
{
/* Translators: This is a date format string in the style of "Feb 24". */
label = g_date_time_format (date, _("%b %e"));
}
else
{
/* Translators: This is a date format string in the style of "Feb 24, 2013". */
label = g_date_time_format (date, _("%b %e, %Y"));
}
}
g_date_time_unref (local);
g_date_time_unref (today);
return label;
}
gint
datetime_compare_date (GDateTime *dt1,
GDateTime *dt2)
{
if (!dt1 && !dt2)
return 0;
else if (!dt1)
return -1;
else if (!dt2)
return 1;
if (g_date_time_get_year (dt1) != g_date_time_get_year (dt2))
return g_date_time_get_year (dt1) - g_date_time_get_year (dt2);
if (g_date_time_get_month (dt1) != g_date_time_get_month (dt2))
return g_date_time_get_month (dt1) - g_date_time_get_month (dt2);
if (g_date_time_get_day_of_month (dt1) != g_date_time_get_day_of_month (dt2))
return g_date_time_get_day_of_month (dt1) - g_date_time_get_day_of_month (dt2);
return 0;
}
void
gcal_time_selector_set_time (GcalTimeSelector *selector,
GDateTime *time)
{
g_return_if_fail (GCAL_IS_TIME_SELECTOR (selector));
if (selector->time != time)
{
gint hour, minute;
g_clear_pointer (&selector->time, g_date_time_unref);
selector->time = g_date_time_new_local (g_date_time_get_year (time),
g_date_time_get_month (time),
g_date_time_get_day_of_month (time),
g_date_time_get_hour (time),
g_date_time_get_minute (time),
0);
/* Update the spinners */
g_signal_handlers_block_by_func (selector->hour_adjustment, update_time, selector);
g_signal_handlers_block_by_func (selector->minute_adjustment, update_time, selector);
hour = g_date_time_get_hour (time);
minute = g_date_time_get_minute (time);
if (!selector->format_24h)
{
g_signal_handlers_block_by_func (selector->period_combo, update_time, selector);
gtk_combo_box_set_active (GTK_COMBO_BOX (selector->period_combo), hour >= 12);
hour = hour % 12;
hour = (hour == 0)? 12 : hour;
g_signal_handlers_unblock_by_func (selector->period_combo, update_time, selector);
}
gtk_adjustment_set_value (selector->hour_adjustment, hour);
gtk_adjustment_set_value (selector->minute_adjustment, minute);
update_label (selector);
g_signal_handlers_unblock_by_func (selector->hour_adjustment, update_time, selector);
g_signal_handlers_unblock_by_func (selector->minute_adjustment, update_time, selector);
g_object_notify (G_OBJECT (selector), "time");
}
}
static void _pcapmain_log(GLogLevelFlags level, const gchar* functionName, const gchar* format, ...) {
va_list vargs;
va_start(vargs, format);
GDateTime* dt = g_date_time_new_now_local();
GString* newformat = g_string_new(NULL);
g_string_append_printf(newformat, "%04i-%02i-%02i %02i:%02i:%02i %"G_GINT64_FORMAT".%06i [%s] [%s] %s",
g_date_time_get_year(dt), g_date_time_get_month(dt), g_date_time_get_day_of_month(dt),
g_date_time_get_hour(dt), g_date_time_get_minute(dt), g_date_time_get_second(dt),
g_date_time_to_unix(dt), g_date_time_get_microsecond(dt),
_pcapmain_logLevelToString(level), functionName, format);
g_logv(PCAP_LOG_DOMAIN, level, newformat->str, vargs);
g_string_free(newformat, TRUE);
g_date_time_unref(dt);
va_end(vargs);
}
static gboolean on_visibility_notify(GtkWidget* widget,
GdkEvent* event,
gpointer data)
{
GDateTime* datetime = g_date_time_new_now_local();
if(!datetime)
{
gtk_menu_item_set_label(GTK_MENU_ITEM(greeter.ui.clock.date_widget), "[date]");
g_signal_handler_disconnect(greeter.ui.clock.date_widget, visibility_notify_id);
return TRUE;
}
gchar* str = g_date_time_format(datetime, config.clock.date_format);
gtk_menu_item_set_label(GTK_MENU_ITEM(greeter.ui.clock.date_widget), str);
gtk_calendar_select_month(GTK_CALENDAR(greeter.ui.clock.calendar_widget),
g_date_time_get_month(datetime) - 1,
g_date_time_get_year(datetime));
gtk_calendar_select_day(GTK_CALENDAR(greeter.ui.clock.calendar_widget), g_date_time_get_day_of_month(datetime));
g_free(str);
g_date_time_unref(datetime);
return TRUE;
}
void CalendarDatePrivate::initYearView() {
GtkWidget* swipebox = NULL;
int row = 0;
int col = 0;
int rowCount = 3;
int colCount = 4;
char buffer[32];
GDateTime* nowDate = g_date_time_new_now_local();
int nowYear = g_date_time_get_year(nowDate);
int selectedYear = m_selectedYear;
int cellWidth = MAIN_BOX_DEFAULT_WIDTH / colCount;
int cellHeight = MAIN_BOX_DEFAULT_WIDTH / rowCount;
int beginYear = ((int)selectedYear / 10) * 10 - 1;
int endYear = ((int)selectedYear / 10 + 1) * 10;
int iterYear = beginYear;
m_swipeBox[VIEWTYPE_YEAR] = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
swipebox = m_swipeBox[VIEWTYPE_YEAR];
gtk_fixed_put(GTK_FIXED(m_mainBox), GTK_WIDGET(m_swipeBox[VIEWTYPE_YEAR]), 0, 0);
gtk_widget_set_name(GTK_WIDGET(swipebox), "calendar-table");
g_snprintf(buffer, sizeof(buffer), "%d-%d", beginYear, endYear);
gtk_button_set_label(GTK_BUTTON(m_viewTypeSwitch), buffer);
for (row = 0; row < rowCount; ++row) {
GtkWidget* yearLayout = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
for (col = 0; col < colCount; ++col) {
int index = row * colCount + col;
iterYear = beginYear + index;
g_snprintf(buffer, sizeof(buffer), "%d", iterYear);
m_yearItem[index] = new CalendarItem(ITEMTYPE_YEAR, iterYear);
m_yearItem[index]->setOnClickedListener(this);
m_yearItem[index]->setSize(cellWidth, cellHeight);
m_yearItem[index]->setParent(GTK_WIDGET(yearLayout));
}
gtk_box_pack_start(GTK_BOX(swipebox), GTK_WIDGET(yearLayout), TRUE, TRUE, 0);
}
}
static void
change_time (CcDateTimePanel *panel)
{
CcDateTimePanelPrivate *priv = panel->priv;
guint h, m;
GDateTime *old_date;
old_date = priv->date;
h = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (W ("h_spinbutton")));
m = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (W ("m_spinbutton")));
if (priv->clock_format == G_DESKTOP_CLOCK_FORMAT_12H)
{
gboolean is_pm_time;
GtkWidget *visible_child;
visible_child = gtk_stack_get_visible_child (GTK_STACK (priv->am_pm_stack));
if (visible_child == priv->pm_label)
is_pm_time = TRUE;
else
is_pm_time = FALSE;
if (h == 12)
h = 0;
if (is_pm_time)
h += 12;
}
priv->date = g_date_time_new_local (g_date_time_get_year (old_date),
g_date_time_get_month (old_date),
g_date_time_get_day_of_month (old_date),
h, m,
g_date_time_get_second (old_date));
g_date_time_unref (old_date);
update_time (panel);
queue_set_datetime (panel);
}
icaltimetype*
datetime_to_icaltime (GDateTime *dt)
{
icaltimetype *idt;
if (!dt)
return NULL;
idt = g_new0 (icaltimetype, 1);
idt->year = g_date_time_get_year (dt);
idt->month = g_date_time_get_month (dt);
idt->day = g_date_time_get_day_of_month (dt);
idt->hour = g_date_time_get_hour (dt);
idt->minute = g_date_time_get_minute (dt);
idt->second = g_date_time_get_seconds (dt);
idt->is_date = (idt->hour == 0 &&
idt->minute == 0 &&
idt->second == 0);
return idt;
}
void
um_history_dialog_show (UmHistoryDialog *um,
GtkWindow *parent)
{
GDateTime *temp, *local;
/* Set the first day of this week */
local = g_date_time_new_now_local ();
temp = g_date_time_new_local (g_date_time_get_year (local),
g_date_time_get_month (local),
g_date_time_get_day_of_month (local),
0, 0, 0);
um->week = g_date_time_add_days (temp, 1 - g_date_time_get_day_of_week (temp));
um->current_week = g_date_time_ref (um->week);
g_date_time_unref (local);
g_date_time_unref (temp);
show_week (um);
gtk_window_set_transient_for (GTK_WINDOW (um->dialog), parent);
gtk_window_present (GTK_WINDOW (um->dialog));
}
static void
update_time (GcalTimeSelector *selector)
{
GDateTime *now, *new_time;
gint hour, minute;
/* Retrieve current time */
hour = (gint) gtk_adjustment_get_value (selector->hour_adjustment);
minute = (gint) gtk_adjustment_get_value (selector->minute_adjustment);
if (!selector->format_24h)
{
hour = hour % 12;
if (gtk_combo_box_get_active (GTK_COMBO_BOX (selector->period_combo)) == PM)
{
g_signal_handlers_block_by_func (selector->period_combo, update_time, selector);
gtk_combo_box_set_active (GTK_COMBO_BOX (selector->period_combo), hour >= 12);
hour += 12;
g_signal_handlers_unblock_by_func (selector->period_combo, update_time, selector);
}
}
now = g_date_time_new_now_local ();
new_time = g_date_time_new_local (g_date_time_get_year (now),
g_date_time_get_month (now),
g_date_time_get_day_of_month (now),
hour, minute, 0);
/* Set the new time */
gcal_time_selector_set_time (selector, new_time);
g_clear_pointer (&new_time, g_date_time_unref);
g_clear_pointer (&now, g_date_time_unref);
}
BerValue *
gda_ldap_attr_g_value_to_value (LdapConnectionData *cdata, const GValue *cvalue)
{
BerValue *bv;
if (!cvalue)
return NULL;
bv = g_new (struct berval, 1);
if (G_VALUE_TYPE (cvalue) == G_TYPE_STRING) {
const gchar *cstr;
cstr = g_value_get_string (cvalue);
bv->bv_val = g_strdup (cstr);
bv->bv_len = strlen (cstr);
}
else if (G_VALUE_TYPE (cvalue) == G_TYPE_DATE_TIME) {
GDateTime *ts;
gchar *str;
ts = g_value_get_boxed (cvalue);
if (g_date_time_get_second (ts) == (gint) g_date_time_get_seconds (ts)) {
if (g_date_time_get_utc_offset (ts) == 0)
str = g_strdup_printf ("%04d-%02d-%02dT%02d:%02d:%02d",
g_date_time_get_year (ts),
g_date_time_get_month (ts),
g_date_time_get_day_of_month (ts),
g_date_time_get_hour (ts),
g_date_time_get_minute (ts),
g_date_time_get_second (ts));
else {
str = g_strdup_printf ("%04d-%02d-%02dT%02d:%02d:%02d",
g_date_time_get_year (ts),
g_date_time_get_month (ts),
g_date_time_get_day_of_month (ts),
g_date_time_get_hour (ts),
g_date_time_get_minute (ts),
g_date_time_get_second (ts));
TO_IMPLEMENT;
}
}
else {
if (g_date_time_get_utc_offset (ts) == 0)
str = g_strdup_printf ("%04d-%02d-%02dT%02d:%02d:%02d,%lu",
g_date_time_get_year (ts),
g_date_time_get_month (ts),
g_date_time_get_day_of_month (ts),
g_date_time_get_hour (ts),
g_date_time_get_minute (ts),
g_date_time_get_second (ts),
(gulong) ((g_date_time_get_seconds (ts) - g_date_time_get_second (ts)) * 1000000.0));
else {
str = g_strdup_printf ("%04d-%02d-%02dT%02d:%02d:%02d,%lu",
g_date_time_get_year (ts),
g_date_time_get_month (ts),
g_date_time_get_day_of_month (ts),
g_date_time_get_hour (ts),
g_date_time_get_minute (ts),
g_date_time_get_second (ts),
(gulong) ((g_date_time_get_seconds (ts) - g_date_time_get_second (ts)) * 1000000.0));
TO_IMPLEMENT;
}
}
bv->bv_val = str;
bv->bv_len = strlen (str);
}
else if (G_VALUE_TYPE (cvalue) == G_TYPE_DATE) {
GDate *date;
gchar *str;
date = (GDate*) g_value_get_boxed (cvalue);
str = g_strdup_printf ("%04d-%02d-%02d", g_date_get_year (date), g_date_get_month (date),
g_date_get_day (date));
bv->bv_val = str;
bv->bv_len = strlen (str);
}
else if (G_VALUE_TYPE (cvalue) == GDA_TYPE_NULL) {
bv->bv_val = NULL;
bv->bv_len = 0;
}
else if (G_VALUE_TYPE (cvalue) == GDA_TYPE_BINARY) {
TO_IMPLEMENT;
}
else if (G_VALUE_TYPE (cvalue) == GDA_TYPE_BLOB) {
TO_IMPLEMENT;
}
else {
gchar *str;
str = gda_value_stringify (cvalue);
bv->bv_val = str;
bv->bv_len = strlen (str);
}
return bv;
}
gint
gst_date_time_get_year (const GstDateTime * datetime)
{
return g_date_time_get_year (datetime->datetime);
}
static gint
g_calendar_gregorian_real_get_year (GCalendar *calendar, /* IN */
GDateTime *datetime) /* IN */
{
return g_date_time_get_year (datetime);
}
static void
set_time (GstRTSPTime * time, GstRTSPTime2 * time2, GstRTSPRangeUnit unit,
GstClockTime clock_time)
{
memset (time, 0, sizeof (GstRTSPTime));
memset (time2, 0, sizeof (GstRTSPTime2));
if (clock_time == GST_CLOCK_TIME_NONE) {
time->type = GST_RTSP_TIME_END;
return;
}
switch (unit) {
case GST_RTSP_RANGE_SMPTE:
case GST_RTSP_RANGE_SMPTE_30_DROP:
{
time->seconds = (guint64) (clock_time / GST_SECOND);
time2->frames = 30003 * (clock_time % GST_SECOND) /
(gdouble) (1001 * GST_SECOND);
time->type = GST_RTSP_TIME_FRAMES;
g_assert (time2->frames < 30);
break;
}
case GST_RTSP_RANGE_SMPTE_25:
{
time->seconds = (guint64) (clock_time / GST_SECOND);
time2->frames = (25 * (clock_time % GST_SECOND)) / (gdouble) GST_SECOND;
time->type = GST_RTSP_TIME_FRAMES;
g_assert (time2->frames < 25);
break;
}
case GST_RTSP_RANGE_NPT:
{
time->seconds = (gdouble) clock_time / (gdouble) GST_SECOND;
time->type = GST_RTSP_TIME_SECONDS;
break;
}
case GST_RTSP_RANGE_CLOCK:
{
GDateTime *bt, *datetime;
GstClockTime subsecond = clock_time % GST_SECOND;
bt = g_date_time_new_utc (1900, 1, 1, 0, 0, 0.0);
datetime = g_date_time_add_seconds (bt, clock_time / GST_SECOND);
time2->year = g_date_time_get_year (datetime);
time2->month = g_date_time_get_month (datetime);
time2->day = g_date_time_get_day_of_month (datetime);
time->seconds = g_date_time_get_hour (datetime) * 60 * 60;
time->seconds += g_date_time_get_minute (datetime) * 60;
time->seconds += g_date_time_get_seconds (datetime);
time->seconds += (gdouble) subsecond / (gdouble) GST_SECOND;
time->type = GST_RTSP_TIME_UTC;
g_date_time_unref (bt);
g_date_time_unref (datetime);
break;
}
}
if (time->seconds < 0.000000001)
time->seconds = 0;
if (time2->frames < 0.000000001)
time2->frames = 0;
}
static void
cc_date_time_panel_init (CcDateTimePanel *self)
{
CcDateTimePanelPrivate *priv;
gchar *objects[] = { "datetime-panel", "region-liststore", "city-liststore",
"month-liststore", "city-modelfilter", "city-modelsort", NULL };
char *buttons[] = { "hour_up_button", "hour_down_button", "min_up_button",
"min_down_button", "ampm_up_button", "ampm_down_button" };
GtkWidget *widget;
GtkAdjustment *adjustment;
GError *err = NULL;
GtkTreeModelFilter *city_modelfilter;
GtkTreeModelSort *city_modelsort;
guint i, num_days;
gboolean using_ntp;
gboolean can_use_ntp;
int ret;
DateEndianess endianess;
GError *error;
priv = self->priv = DATE_TIME_PANEL_PRIVATE (self);
priv->cancellable = g_cancellable_new ();
error = NULL;
priv->dtm = date_time_mechanism_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
"org.gnome.SettingsDaemon.DateTimeMechanism",
"/",
priv->cancellable,
&error);
if (priv->dtm == NULL) {
g_warning ("could not get proxy for DateTimeMechanism: %s", error->message);
g_error_free (error);
}
priv->builder = gtk_builder_new ();
ret = gtk_builder_add_objects_from_file (priv->builder, DATADIR"/datetime.ui",
objects, &err);
if (ret == 0)
{
g_warning ("Could not load ui: %s", err ? err->message : "No reason");
if (err)
g_error_free (err);
return;
}
/* set up network time button */
error = NULL;
using_ntp = can_use_ntp = FALSE;
if (!date_time_mechanism_call_get_using_ntp_sync (priv->dtm,
&can_use_ntp,
&using_ntp,
priv->cancellable,
&error))
{
g_warning ("Failed to get using ntp: %s", error->message);
g_error_free (error);
}
gtk_switch_set_active (GTK_SWITCH (W("network_time_switch")), using_ntp);
update_widget_state_for_ntp (self, using_ntp);
g_signal_connect (W("network_time_switch"), "notify::active",
G_CALLBACK (change_ntp), self);
/* set up time editing widgets */
for (i = 0; i < G_N_ELEMENTS (buttons); i++)
{
g_signal_connect (W(buttons[i]), "clicked",
G_CALLBACK (change_time), self);
}
/* set up date editing widgets */
priv->date = g_date_time_new_now_local ();
endianess = date_endian_get_default (FALSE);
reorder_date_widget (endianess, priv);
/* Force the direction for the time, so that the time
* is presented correctly for RTL languages */
gtk_widget_set_direction (W("table2"), GTK_TEXT_DIR_LTR);
gtk_combo_box_set_active (GTK_COMBO_BOX (W ("month-combobox")),
g_date_time_get_month (priv->date) - 1);
g_signal_connect (G_OBJECT (W("month-combobox")), "changed",
G_CALLBACK (month_year_changed), self);
num_days = g_date_get_days_in_month (g_date_time_get_month (priv->date),
g_date_time_get_year (priv->date));
adjustment = (GtkAdjustment*) gtk_adjustment_new (g_date_time_get_day_of_month (priv->date), 1,
num_days + 1, 1, 10, 1);
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (W ("day-spinbutton")),
adjustment);
g_signal_connect (G_OBJECT (W("day-spinbutton")), "value-changed",
G_CALLBACK (day_changed), self);
adjustment = (GtkAdjustment*) gtk_adjustment_new (g_date_time_get_year (priv->date),
G_MINDOUBLE, G_MAXDOUBLE, 1,
10, 1);
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (W ("year-spinbutton")),
adjustment);
g_signal_connect (G_OBJECT (W("year-spinbutton")), "value-changed",
G_CALLBACK (month_year_changed), self);
/* set up timezone map */
priv->map = widget = (GtkWidget *) cc_timezone_map_new ();
gtk_widget_show (widget);
gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (priv->builder,
"aspectmap")),
widget);
gtk_container_add (GTK_CONTAINER (self),
GTK_WIDGET (gtk_builder_get_object (priv->builder,
"datetime-panel")));
/* setup the time itself */
priv->clock_tracker = g_object_new (GNOME_TYPE_WALL_CLOCK, NULL);
g_signal_connect (priv->clock_tracker, "notify::clock", G_CALLBACK (on_clock_changed), self);
priv->settings = g_settings_new (CLOCK_SCHEMA);
clock_settings_changed_cb (priv->settings, CLOCK_FORMAT_KEY, self);
g_signal_connect (priv->settings, "changed::" CLOCK_FORMAT_KEY,
G_CALLBACK (clock_settings_changed_cb), self);
g_signal_connect (W("24h_button"), "notify::active",
G_CALLBACK (change_clock_settings), self);
update_time (self);
priv->locations = (GtkTreeModel*) gtk_builder_get_object (priv->builder,
"region-liststore");
load_regions_model (GTK_LIST_STORE (priv->locations),
GTK_LIST_STORE (gtk_builder_get_object (priv->builder,
"city-liststore")));
city_modelfilter = GTK_TREE_MODEL_FILTER (gtk_builder_get_object (priv->builder, "city-modelfilter"));
widget = (GtkWidget*) gtk_builder_get_object (priv->builder,
"region_combobox");
city_modelsort = GTK_TREE_MODEL_SORT (gtk_builder_get_object (priv->builder, "city-modelsort"));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (city_modelsort), CITY_COL_CITY_TRANSLATED,
GTK_SORT_ASCENDING);
gtk_tree_model_filter_set_visible_func (city_modelfilter,
(GtkTreeModelFilterVisibleFunc) city_model_filter_func,
widget,
NULL);
/* After the initial setup, so we can be sure that
* the model is filled up */
date_time_mechanism_call_get_timezone (priv->dtm,
priv->cancellable,
get_timezone_cb,
self);
/* add the lock button */
priv->permission = polkit_permission_new_sync ("org.gnome.settingsdaemon.datetimemechanism.configure", NULL, NULL, NULL);
if (priv->permission == NULL)
{
g_warning ("Your system does not have the '%s' PolicyKit files installed. Please check your installation",
"org.gnome.settingsdaemon.datetimemechanism.configure");
return;
}
g_signal_connect (priv->permission, "notify",
G_CALLBACK (on_permission_changed), self);
on_permission_changed (priv->permission, NULL, self);
}
static void
resolve_video (ResolveData *resolve_data,
GrlKeyID key,
resolution_flags_t flags)
{
gchar *title, *showname, *display_name;
GDateTime *date;
gint season, episode;
GrlData *data = GRL_DATA (resolve_data->rs->media);
resolution_flags_t miss_flags = 0, fill_flags;
GRL_DEBUG ("%s",__FUNCTION__);
resolve_data_start_operation (resolve_data, "video");
if (!(flags & (FLAG_VIDEO_TITLE |
FLAG_VIDEO_SHOWNAME |
FLAG_VIDEO_DATE |
FLAG_VIDEO_SEASON |
FLAG_VIDEO_EPISODE |
FLAG_VIDEO_EPISODE_TITLE))) {
resolve_data_finish_operation (resolve_data, "video", NULL);
return;
}
if (grl_data_has_key (data, GRL_METADATA_KEY_TITLE)) {
if (grl_data_get_boolean (data, GRL_METADATA_KEY_TITLE_FROM_FILENAME)) {
miss_flags = FLAG_VIDEO_TITLE;
} else
miss_flags = 0;
} else {
miss_flags = FLAG_VIDEO_TITLE;
}
miss_flags |= grl_data_has_key (data, GRL_METADATA_KEY_SHOW) ?
0 : FLAG_VIDEO_SHOWNAME;
miss_flags |= grl_data_has_key (data, GRL_METADATA_KEY_PUBLICATION_DATE) ?
0 : FLAG_VIDEO_DATE;
miss_flags |= grl_data_has_key (data, GRL_METADATA_KEY_SEASON) ?
0 : FLAG_VIDEO_SEASON;
miss_flags |= grl_data_has_key (data, GRL_METADATA_KEY_EPISODE) ?
0 : FLAG_VIDEO_EPISODE;
miss_flags |= grl_data_has_key (data, GRL_METADATA_KEY_EPISODE_TITLE) ?
0 : FLAG_VIDEO_EPISODE_TITLE;
fill_flags = flags & miss_flags;
if (!fill_flags) {
resolve_data_finish_operation (resolve_data, "video", NULL);
return;
}
if (key == GRL_METADATA_KEY_URL) {
GFile *file;
file = g_file_new_for_uri (grl_media_get_url (resolve_data->rs->media));
display_name = g_file_get_basename (file);
g_object_unref (file);
} else {
display_name = g_strdup (grl_media_get_title (resolve_data->rs->media));
}
video_guess_values_from_display_name (display_name,
&title, &showname, &date,
&season, &episode);
g_free (display_name);
GRL_DEBUG ("\tfound title=%s/showname=%s/year=%i/season=%i/episode=%i",
title, showname,
date != NULL ? g_date_time_get_year (date) : 0,
season, episode);
if (showname) {
if (fill_flags & FLAG_VIDEO_SHOWNAME) {
grl_data_set_string (data, GRL_METADATA_KEY_SHOW, showname);
}
g_free (showname);
if (fill_flags & FLAG_VIDEO_EPISODE_TITLE &&
title != NULL) {
grl_data_set_string (data, GRL_METADATA_KEY_EPISODE_TITLE, title);
}
} else {
/* As this is just a guess, don't erase already provided values,
* unless GRL_METADATA_KEY_TITLE_FROM_FILENAME is set */
if (grl_data_get_boolean (data, GRL_METADATA_KEY_TITLE_FROM_FILENAME)) {
if (fill_flags & FLAG_VIDEO_TITLE) {
grl_data_set_string (data, GRL_METADATA_KEY_TITLE, title);
}
}
}
g_free (title);
if (date) {
if (fill_flags & FLAG_VIDEO_DATE) {
grl_data_set_boxed (data, GRL_METADATA_KEY_PUBLICATION_DATE, date);
}
g_date_time_unref (date);
}
if (season && (fill_flags & FLAG_VIDEO_SEASON)) {
grl_data_set_int (data, GRL_METADATA_KEY_SEASON, season);
}
if (episode && (fill_flags & FLAG_VIDEO_EPISODE)) {
grl_data_set_int (data, GRL_METADATA_KEY_EPISODE, episode);
}
resolve_data_finish_operation (resolve_data, "video", NULL);
}
/**
* vik_datetime_edit_dialog:
* @parent: The parent window
* @title: The title to use for the dialog
* @initial_time: The inital date/time to be shown
* @tz: The #GTimeZone this dialog will operate in
*
* Returns: A time selected by the user via this dialog
* Even though a time of zero is notionally valid - consider it unlikely to be actually wanted!
* Thus if the time is zero then the dialog was cancelled or somehow an invalid date was encountered.
*/
time_t vik_datetime_edit_dialog ( GtkWindow *parent, const gchar *title, time_t initial_time, GTimeZone *tz )
{
g_return_val_if_fail ( tz, 0 );
GtkWidget *dialog = gtk_dialog_new_with_buttons ( title,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL );
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
#endif
GtkWidget *label;
GtkWidget *cal = gtk_calendar_new ();
// Set according to the given date/time + timezone for display
GDateTime *gdt_in = g_date_time_new_from_unix_utc ( (gint64)initial_time );
GDateTime *gdt_tz = g_date_time_to_timezone ( gdt_in, tz );
g_date_time_unref ( gdt_in );
gtk_calendar_select_month ( GTK_CALENDAR(cal), g_date_time_get_month(gdt_tz)-1, g_date_time_get_year (gdt_tz) );
gtk_calendar_select_day ( GTK_CALENDAR(cal), g_date_time_get_day_of_month(gdt_tz) );
GtkWidget *hbox_time = gtk_hbox_new ( FALSE, 1 );
label = gtk_label_new ( g_date_time_get_timezone_abbreviation(gdt_tz) );
gtk_box_pack_start ( GTK_BOX(hbox_time), label, FALSE, FALSE, 5 );
GtkWidget *sb_hours = gtk_spin_button_new_with_range ( 0.0, 23.0, 1.0 );
gtk_box_pack_start ( GTK_BOX(hbox_time), sb_hours, FALSE, FALSE, 0 );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(sb_hours), g_date_time_get_hour(gdt_tz) );
g_signal_connect ( sb_hours, "output", G_CALLBACK(on_output), NULL );
label = gtk_label_new ( ":" );
gtk_box_pack_start ( GTK_BOX(hbox_time), label, FALSE, FALSE, 0 );
GtkWidget *sb_minutes = gtk_spin_button_new_with_range ( 0.0, 59.0, 1.0 );
gtk_box_pack_start ( GTK_BOX(hbox_time), sb_minutes, FALSE, FALSE, 0);
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(sb_minutes), g_date_time_get_minute(gdt_tz) );
g_signal_connect ( sb_minutes, "output", G_CALLBACK(on_output), NULL );
label = gtk_label_new ( ":" );
gtk_box_pack_start(GTK_BOX(hbox_time), label, FALSE, FALSE, 0);
GtkWidget *sb_seconds = gtk_spin_button_new_with_range ( 0.0, 59.0, 1.0 );
gtk_box_pack_start ( GTK_BOX(hbox_time), sb_seconds, FALSE, FALSE, 0 );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(sb_seconds), g_date_time_get_second(gdt_tz) );
g_signal_connect ( sb_seconds, "output", G_CALLBACK(on_output), NULL );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), cal, FALSE, FALSE, 0 );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), hbox_time, FALSE, FALSE, 5 );
if ( response_w )
gtk_widget_grab_focus ( response_w );
g_date_time_unref ( gdt_tz );
gtk_widget_show_all ( dialog );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
gtk_widget_destroy ( dialog );
return 0;
}
// Read values
guint year = 0;
guint month = 0;
guint day = 0;
guint hours = 0;
guint minutes = 0;
guint seconds = 0;
gtk_calendar_get_date ( GTK_CALENDAR(cal), &year, &month, &day );
hours = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(sb_hours) );
minutes = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(sb_minutes) );
seconds = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(sb_seconds) );
gtk_widget_destroy(dialog);
time_t ans = initial_time;
GDateTime *gdt_ans = g_date_time_new ( tz, year, month+1, day, hours, minutes, (gdouble)seconds );
if ( gdt_ans ) {
ans = g_date_time_to_unix ( gdt_ans );
g_date_time_unref ( gdt_ans );
}
return ans;
}
