Back to index

indicator-datetime  12.10.0
Classes | Defines | Typedefs | Enumerations | Functions | Variables
indicator-datetime.c File Reference
#include <locale.h>
#include <langinfo.h>
#include <string.h>
#include <time.h>
#include <glib.h>
#include <glib/gprintf.h>
#include <glib-object.h>
#include <glib/gi18n-lib.h>
#include <gio/gio.h>
#include <libindicator/indicator.h>
#include <libindicator/indicator-object.h>
#include <libindicator/indicator-service-manager.h>
#include <libdbusmenu-gtk/menu.h>
#include <libido/libido.h>
#include <libdbusmenu-gtk/menuitem.h>
#include "utils.h"
#include "dbus-shared.h"
#include "settings-shared.h"

Go to the source code of this file.

Classes

struct  _IndicatorDatetimeClass
struct  _IndicatorDatetime
struct  _IndicatorDatetimePrivate
struct  _indicator_item_t
struct  _strftime_type_t

Defines

#define INDICATOR_DATETIME_TYPE   (indicator_datetime_get_type ())
#define INDICATOR_DATETIME(obj)   (G_TYPE_CHECK_INSTANCE_CAST ((obj), INDICATOR_DATETIME_TYPE, IndicatorDatetime))
#define INDICATOR_DATETIME_CLASS(klass)   (G_TYPE_CHECK_CLASS_CAST ((klass), INDICATOR_DATETIME_TYPE, IndicatorDatetimeClass))
#define IS_INDICATOR_DATETIME(obj)   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INDICATOR_DATETIME_TYPE))
#define IS_INDICATOR_DATETIME_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), INDICATOR_DATETIME_TYPE))
#define INDICATOR_DATETIME_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), INDICATOR_DATETIME_TYPE, IndicatorDatetimeClass))
#define PROP_SHOW_CLOCK_S   "show-clock"
#define PROP_TIME_FORMAT_S   "time-format"
#define PROP_SHOW_SECONDS_S   "show-seconds"
#define PROP_SHOW_DAY_S   "show-day"
#define PROP_SHOW_DATE_S   "show-date"
#define PROP_CUSTOM_TIME_FORMAT_S   "custom-time-format"
#define PROP_SHOW_WEEK_NUMBERS_S   "show-week-numbers"
#define PROP_SHOW_CALENDAR_S   "show-calendar"
#define FAT_NUMBER   8

Typedefs

typedef struct _IndicatorDatetime
typedef struct _IndicatorDatetimeClass
typedef struct _IndicatorDatetimePrivate
typedef struct _indicator_item_t
typedef struct _strftime_type_t

Enumerations

enum  {
  PROP_0, PROP_SHOW_CLOCK, PROP_TIME_FORMAT, PROP_SHOW_SECONDS,
  PROP_SHOW_DAY, PROP_SHOW_DATE, PROP_CUSTOM_TIME_FORMAT, PROP_SHOW_WEEK_NUMBERS,
  PROP_SHOW_CALENDAR
}
enum  {
  STRFTIME_MASK_NONE = 0, STRFTIME_MASK_SECONDS = 1 << 0, STRFTIME_MASK_AMPM = 1 << 1, STRFTIME_MASK_WEEK = 1 << 2,
  STRFTIME_MASK_DAY = 1 << 3, STRFTIME_MASK_MONTH = 1 << 4, STRFTIME_MASK_YEAR = 1 << 5, STRFTIME_MASK_ALL = (STRFTIME_MASK_SECONDS | STRFTIME_MASK_AMPM | STRFTIME_MASK_WEEK | STRFTIME_MASK_DAY | STRFTIME_MASK_MONTH | STRFTIME_MASK_YEAR)
}

Functions

GType indicator_datetime_get_type (void)
static void menu_visible_notfy_cb (GtkWidget *menu, G_GNUC_UNUSED GParamSpec *pspec, gpointer user_data)
static void indicator_datetime_init (IndicatorDatetime *self)
static void service_proxy_cb (GObject *object, GAsyncResult *res, gpointer user_data)
static void indicator_datetime_dispose (GObject *object)
static void indicator_datetime_finalize (GObject *object)
static gboolean bind_enum_get (GValue *value, GVariant *variant, gpointer user_data)
static void timezone_update_all_labels (IndicatorDatetime *self)
static void set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
static gboolean idle_measure (gpointer data)
static void update_accessible_description (IndicatorDatetime *io)
static void set_label_to_time_in_zone (IndicatorDatetime *self, GtkLabel *label, GTimeZone *tz, const gchar *format, GDateTime **datetime)
static void update_label (IndicatorDatetime *io, GDateTime **datetime)
static void update_time (IndicatorDatetime *self)
static void receive_signal (GDBusProxy *proxy, gchar *sender_name, gchar *signal_name, GVariant *parameters, gpointer user_data)
gboolean timer_func (gpointer user_data)
static void setup_timer (IndicatorDatetime *self, GDateTime *datetime)
static gint measure_string (GtkStyle *style, PangoContext *context, const gchar *string)
static gint generate_strftime_bitmask (const char *time_str)
static void build_timeval_array (GArray *timevals, gint mask)
static void guess_label_size (IndicatorDatetime *self)
static void style_changed (GtkWidget *widget, GtkStyle *oldstyle, gpointer data)
static void update_text_gravity (GtkWidget *widget, GdkScreen *previous_screen, gpointer data)
static gchar * generate_format_string_now (IndicatorDatetime *self)
static void timezone_update_labels (indicator_item_t *mi_data)
static void indicator_prop_change_cb (DbusmenuMenuitem *mi, gchar *prop, GVariant *value, indicator_item_t *mi_data)
static void calendar_prop_change_cb (DbusmenuMenuitem *mi, gchar *prop, GVariant *value, IdoCalendarMenuItem *mi_data)
static gboolean new_appointment_item (DbusmenuMenuitem *newitem, DbusmenuMenuitem *parent, DbusmenuClient *client, gpointer user_data)
static void month_changed_cb (IdoCalendarMenuItem *ido, gpointer user_data)
static void day_selected_cb (IdoCalendarMenuItem *ido, gpointer user_data)
static void day_selected_double_click_cb (IdoCalendarMenuItem *ido, gpointer user_data)
static gboolean new_calendar_item (DbusmenuMenuitem *newitem, DbusmenuMenuitem *parent, DbusmenuClient *client, gpointer user_data)
static void timezone_toggled_cb (GtkCheckMenuItem *checkmenuitem, DbusmenuMenuitem *dbusitem)
static void timezone_destroyed_cb (indicator_item_t *mi_data, DbusmenuMenuitem *dbusitem)
static gboolean new_timezone_item (DbusmenuMenuitem *newitem, DbusmenuMenuitem *parent, DbusmenuClient *client, gpointer user_data)
static GtkLabel * get_label (IndicatorObject *io)
static GtkMenu * get_menu (IndicatorObject *io)
static const gchar * get_accessible_desc (IndicatorObject *io)
static const gchar * get_name_hint (IndicatorObject *io)

Variables

static const strftime_type_t strftime_type []

Class Documentation

struct _IndicatorDatetimeClass

Definition at line 64 of file indicator-datetime.c.

Class Members
IndicatorObjectClass parent_class
struct _IndicatorDatetime

Definition at line 68 of file indicator-datetime.c.

Class Members
IndicatorObject parent
IndicatorDatetimePrivate * priv
struct _IndicatorDatetimePrivate

Definition at line 73 of file indicator-datetime.c.

Class Members
gboolean custom_show_seconds
gchar * custom_string
guint idle_measure
IdoCalendarMenuItem * ido_calendar
GtkSizeGroup * indicator_right_group
GtkLabel * label
gint max_width
DbusmenuGtkMenu * menu
GDBusProxy * service_proxy
GCancellable * service_proxy_cancel
GSettings * settings
gboolean show_calendar
gboolean show_clock
gboolean show_date
gboolean show_day
gboolean show_seconds
gboolean show_week_numbers
IndicatorServiceManager * sm
gint time_mode
gchar * time_string
guint timer
GList * timezone_items
gint week_start
struct _indicator_item_t

Definition at line 123 of file indicator-datetime.c.

Class Members
GtkWidget * gmi
GtkWidget * icon
GtkWidget * label
DbusmenuMenuitem * mi
GtkWidget * right
IndicatorDatetime * self
struct _strftime_type_t

Definition at line 884 of file indicator-datetime.c.

Class Members
char character
gint mask

Define Documentation

#define FAT_NUMBER   8

Definition at line 928 of file indicator-datetime.c.

#define INDICATOR_DATETIME (   obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), INDICATOR_DATETIME_TYPE, IndicatorDatetime))

Definition at line 54 of file indicator-datetime.c.

#define INDICATOR_DATETIME_CLASS (   klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), INDICATOR_DATETIME_TYPE, IndicatorDatetimeClass))

Definition at line 55 of file indicator-datetime.c.

#define INDICATOR_DATETIME_GET_CLASS (   obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), INDICATOR_DATETIME_TYPE, IndicatorDatetimeClass))

Definition at line 58 of file indicator-datetime.c.

Definition at line 53 of file indicator-datetime.c.

#define IS_INDICATOR_DATETIME (   obj)    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INDICATOR_DATETIME_TYPE))

Definition at line 56 of file indicator-datetime.c.

#define IS_INDICATOR_DATETIME_CLASS (   klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), INDICATOR_DATETIME_TYPE))

Definition at line 57 of file indicator-datetime.c.

#define PROP_CUSTOM_TIME_FORMAT_S   "custom-time-format"

Definition at line 137 of file indicator-datetime.c.

#define PROP_SHOW_CALENDAR_S   "show-calendar"

Definition at line 139 of file indicator-datetime.c.

#define PROP_SHOW_CLOCK_S   "show-clock"

Definition at line 132 of file indicator-datetime.c.

#define PROP_SHOW_DATE_S   "show-date"

Definition at line 136 of file indicator-datetime.c.

#define PROP_SHOW_DAY_S   "show-day"

Definition at line 135 of file indicator-datetime.c.

#define PROP_SHOW_SECONDS_S   "show-seconds"

Definition at line 134 of file indicator-datetime.c.

#define PROP_SHOW_WEEK_NUMBERS_S   "show-week-numbers"

Definition at line 138 of file indicator-datetime.c.

#define PROP_TIME_FORMAT_S   "time-format"

Definition at line 133 of file indicator-datetime.c.


Typedef Documentation

typedef struct _indicator_item_t

Definition at line 122 of file indicator-datetime.c.

typedef struct _IndicatorDatetime

Definition at line 60 of file indicator-datetime.c.

typedef struct _IndicatorDatetimeClass

Definition at line 61 of file indicator-datetime.c.

typedef struct _IndicatorDatetimePrivate

Definition at line 62 of file indicator-datetime.c.

typedef struct _strftime_type_t

Definition at line 883 of file indicator-datetime.c.


Enumeration Type Documentation

anonymous enum
Enumerator:
PROP_0 
PROP_SHOW_CLOCK 
PROP_TIME_FORMAT 
PROP_SHOW_SECONDS 
PROP_SHOW_DAY 
PROP_SHOW_DATE 
PROP_CUSTOM_TIME_FORMAT 
PROP_SHOW_WEEK_NUMBERS 
PROP_SHOW_CALENDAR 

Definition at line 110 of file indicator-datetime.c.

anonymous enum
Enumerator:
STRFTIME_MASK_NONE 
STRFTIME_MASK_SECONDS 
STRFTIME_MASK_AMPM 
STRFTIME_MASK_WEEK 
STRFTIME_MASK_DAY 
STRFTIME_MASK_MONTH 
STRFTIME_MASK_YEAR 
STRFTIME_MASK_ALL 

Definition at line 141 of file indicator-datetime.c.

     {
       STRFTIME_MASK_NONE    = 0,      /* Hours or minutes as we always test those */
       STRFTIME_MASK_SECONDS = 1 << 0, /* Seconds count */
       STRFTIME_MASK_AMPM    = 1 << 1, /* AM/PM counts */
       STRFTIME_MASK_WEEK    = 1 << 2, /* Day of the week maters (Sat, Sun, etc.) */
       STRFTIME_MASK_DAY     = 1 << 3, /* Day of the month counts (Feb 1st) */
       STRFTIME_MASK_MONTH   = 1 << 4, /* Which month matters */
       STRFTIME_MASK_YEAR    = 1 << 5, /* Which year matters */
       /* Last entry, combines all previous */
       STRFTIME_MASK_ALL     = (STRFTIME_MASK_SECONDS | STRFTIME_MASK_AMPM | STRFTIME_MASK_WEEK | STRFTIME_MASK_DAY | STRFTIME_MASK_MONTH | STRFTIME_MASK_YEAR)
};

Function Documentation

static gboolean bind_enum_get ( GValue *  value,
GVariant *  variant,
gpointer  user_data 
) [static]

Definition at line 473 of file indicator-datetime.c.

{
       const gchar * str = g_variant_get_string(variant, NULL);
       gint output = 0;

       if (g_strcmp0(str, "locale-default") == 0) {
              output = SETTINGS_TIME_LOCALE;
       } else if (g_strcmp0(str, "12-hour") == 0) {
              output = SETTINGS_TIME_12_HOUR;
       } else if (g_strcmp0(str, "24-hour") == 0) {
              output = SETTINGS_TIME_24_HOUR;
       } else if (g_strcmp0(str, "custom") == 0) {
              output = SETTINGS_TIME_CUSTOM;
       } else {
              return FALSE;
       }

       g_value_set_int(value, output);
       return TRUE;
}

Here is the caller graph for this function:

static void build_timeval_array ( GArray *  timevals,
gint  mask 
) [static]

Definition at line 971 of file indicator-datetime.c.

{
       struct tm mytm = {0};

       /* Sun 12/28/8888 00:00 */
       mytm.tm_hour = 0;
       mytm.tm_mday = 28;
       mytm.tm_mon = 11;
       mytm.tm_year = 8888 - 1900;
       mytm.tm_wday = 0;
       mytm.tm_yday = 363;
       g_array_append_val(timevals, mytm);

       if (mask & STRFTIME_MASK_AMPM) {
              /* Sun 12/28/8888 12:00 */
              mytm.tm_hour = 12;
              g_array_append_val(timevals, mytm);
       }

       /* NOTE: Ignoring year 8888 should handle it */

       if (mask & STRFTIME_MASK_MONTH) {
              gint oldlen = timevals->len;
              gint i, j;
              for (i = 0; i < oldlen; i++) {
                     for (j = 0; j < 11; j++) {
                            struct tm localval = g_array_index(timevals, struct tm, i);
                            localval.tm_mon = j;
                            /* Not sure if I need to adjust yday & wday, hope not */
                            g_array_append_val(timevals, localval);
                     }
              }
       }

       /* Doing these together as it seems like just slightly more
          coverage on the numerical days, but worth it. */
       if (mask & (STRFTIME_MASK_WEEK | STRFTIME_MASK_DAY)) {
              gint oldlen = timevals->len;
              gint i, j;
              for (i = 0; i < oldlen; i++) {
                     for (j = 22; j < 28; j++) {
                            struct tm localval = g_array_index(timevals, struct tm, i);

                            gint diff = 28 - j;

                            localval.tm_mday = j;
                            localval.tm_wday = localval.tm_wday - diff;
                            if (localval.tm_wday < 0) {
                                   localval.tm_wday += 7;
                            }
                            localval.tm_yday = localval.tm_yday - diff;

                            g_array_append_val(timevals, localval);
                     }
              }
       }

       return;
}

Here is the caller graph for this function:

static void calendar_prop_change_cb ( DbusmenuMenuitem *  mi,
gchar *  prop,
GVariant *  value,
IdoCalendarMenuItem *  mi_data 
) [static]

Definition at line 1180 of file indicator-datetime.c.

{
       g_debug("Changing calendar property: %s", prop);
       if (!g_strcmp0(prop, CALENDAR_MENUITEM_PROP_MARKS)) {
              ido_calendar_menu_item_clear_marks (IDO_CALENDAR_MENU_ITEM (mi_data));

              if (value != NULL) {
                     GVariantIter *iter;
                     gint day;

                     g_debug("\tMarks: %s", g_variant_print(value, FALSE));

                     g_variant_get (value, "ai", &iter);
                     while (g_variant_iter_loop (iter, "i", &day)) {
                            ido_calendar_menu_item_mark_day (IDO_CALENDAR_MENU_ITEM (mi_data), day);
                     }
                     g_variant_iter_free (iter);
              } else {
                     g_debug("\tMarks: <cleared>");
              }
       }
       return;
}

Here is the caller graph for this function:

static void day_selected_cb ( IdoCalendarMenuItem *  ido,
gpointer  user_data 
) [static]

Definition at line 1307 of file indicator-datetime.c.

{
       guint d,m,y;
       DbusmenuMenuitem * item = DBUSMENU_MENUITEM (user_data);
       ido_calendar_menu_item_get_date(ido, &y, &m, &d);
       struct tm date = {0};
       date.tm_mday = d;
       date.tm_mon = m;
       date.tm_year = y - 1900;
       guint selecteddate = (guint)mktime(&date);
       g_debug("Got day selected signal: %s", asctime(&date));
       GVariant *variant = g_variant_new_uint32(selecteddate);
       guint timestamp = (guint)time(NULL);
       dbusmenu_menuitem_handle_event(DBUSMENU_MENUITEM(item), "day-selected", variant, timestamp);
}

Here is the caller graph for this function:

static void day_selected_double_click_cb ( IdoCalendarMenuItem *  ido,
gpointer  user_data 
) [static]

Definition at line 1325 of file indicator-datetime.c.

{
       guint d,m,y;
       DbusmenuMenuitem * item = DBUSMENU_MENUITEM (user_data);
       ido_calendar_menu_item_get_date(ido, &y, &m, &d);
       struct tm date = {0};
       date.tm_mday = d;
       date.tm_mon = m;
       date.tm_year = y - 1900;
       guint selecteddate = (guint)mktime(&date);
       g_debug("Got day selected double click signal: %s", asctime(&date));
       GVariant *variant = g_variant_new_uint32(selecteddate);
       guint timestamp = (guint)time(NULL);
       dbusmenu_menuitem_handle_event(DBUSMENU_MENUITEM(item), "day-selected-double-click", variant, timestamp);
}

Here is the caller graph for this function:

static gchar* generate_format_string_now ( IndicatorDatetime *  self) [static]

Definition at line 1105 of file indicator-datetime.c.

{
       if (self->priv->time_mode == SETTINGS_TIME_CUSTOM) {
              return g_strdup(self->priv->custom_string);
       }
       else {
              return generate_format_string_full(self->priv->show_day,
                                                 self->priv->show_date);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gint generate_strftime_bitmask ( const char *  time_str) [static]

Definition at line 934 of file indicator-datetime.c.

{
       gint retval = 0;
       glong strlength = g_utf8_strlen(time_str, -1);
       gint i;
       g_debug("Evaluating bitmask for '%s'", time_str);

       for (i = 0; i < strlength; i++) {
              if (time_str[i] == '%' && i + 1 < strlength) {
                     gchar evalchar = time_str[i + 1];

                     /* If we're using alternate formats we need to skip those characters */
                     if (evalchar == 'E' || evalchar == 'O') {
                            if (i + 2 < strlength) {
                                   evalchar = time_str[i + 2];
                            } else {
                                   continue;
                            }
                     }

                     /* Let's look at that character in the table */
                     int j;
                     for (j = 0; strftime_type[j].character != 0; j++) {
                            if (strftime_type[j].character == evalchar) {
                                   retval |= strftime_type[j].mask;
                                   break;
                            }
                     }
              }
       }

       return retval;
}

Here is the caller graph for this function:

static const gchar* get_accessible_desc ( IndicatorObject *  io) [static]

Definition at line 1499 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(io);
       const gchar * name;

       if (self->priv->label != NULL) {
              name = gtk_label_get_text(self->priv->label);
              return name;
       }
       return NULL;
}

Here is the caller graph for this function:

static GtkLabel* get_label ( IndicatorObject *  io) [static]

Definition at line 1467 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(io);

       /* If there's not a label, we'll build ourselves one */
       if (self->priv->label == NULL) {
              self->priv->label = GTK_LABEL(gtk_label_new("Time"));
              gtk_label_set_justify (GTK_LABEL(self->priv->label), GTK_JUSTIFY_CENTER);
              g_object_ref(G_OBJECT(self->priv->label));
              g_signal_connect(G_OBJECT(self->priv->label), "style-set", G_CALLBACK(style_changed), self);
              g_signal_connect(G_OBJECT(self->priv->label), "screen-changed", G_CALLBACK(update_text_gravity), self);
              guess_label_size(self);
              update_label(self, NULL);
              gtk_widget_set_visible(GTK_WIDGET (self->priv->label), self->priv->show_clock);
       }

       if (self->priv->timer == 0) {
              setup_timer(self, NULL);
       }

       return self->priv->label;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static GtkMenu* get_menu ( IndicatorObject *  io) [static]

Definition at line 1491 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(io);

       return GTK_MENU(self->priv->menu);
}

Here is the caller graph for this function:

static const gchar* get_name_hint ( IndicatorObject *  io) [static]

Definition at line 1512 of file indicator-datetime.c.

{
       return PACKAGE_NAME;
}

Here is the caller graph for this function:

static void get_property ( GObject *  object,
guint  prop_id,
GValue *  value,
GParamSpec *  pspec 
) [static]

Definition at line 630 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(object);

       switch(prop_id) {
       case PROP_SHOW_CLOCK:
              g_value_set_boolean(value, self->priv->show_clock);
              break;
       case PROP_TIME_FORMAT:
              g_value_set_int(value, self->priv->time_mode);
              break;
       case PROP_SHOW_SECONDS:
              g_value_set_boolean(value, self->priv->show_seconds);
              break;
       case PROP_SHOW_DAY:
              g_value_set_boolean(value, self->priv->show_day);
              break;
       case PROP_SHOW_DATE:
              g_value_set_boolean(value, self->priv->show_date);
              break;
       case PROP_CUSTOM_TIME_FORMAT:
              g_value_set_string(value, self->priv->custom_string);
              break;
       case PROP_SHOW_WEEK_NUMBERS:
              g_value_set_boolean(value, self->priv->show_week_numbers);
              break;
       case PROP_SHOW_CALENDAR:
              g_value_set_boolean(value, self->priv->show_calendar);
              break;
       default:
              G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
              return;
       }

       return;
}

Here is the caller graph for this function:

static void guess_label_size ( IndicatorDatetime *  self) [static]

Definition at line 1034 of file indicator-datetime.c.

{
       /* This is during startup. */
       if (self->priv->label == NULL) return;

       GtkStyle * style = gtk_widget_get_style(GTK_WIDGET(self->priv->label));
       PangoContext * context = gtk_widget_get_pango_context(GTK_WIDGET(self->priv->label));
       gint * max_width = &(self->priv->max_width);
       gint posibilitymask = generate_strftime_bitmask(self->priv->time_string);

       /* Reset max width */
       *max_width = 0;

       /* Build the array of possibilities that we want to test */
       GArray * timevals = g_array_new(FALSE, TRUE, sizeof(struct tm));
       build_timeval_array(timevals, posibilitymask);

       g_debug("Checking against %d possible times", timevals->len);
       gint check_time;
       for (check_time = 0; check_time < timevals->len; check_time++) {
              struct tm * timeval = &g_array_index(timevals, struct tm, check_time);
              GDateTime * dt = g_date_time_new_local(timeval->tm_year, timeval->tm_mon, timeval->tm_mday, timeval->tm_hour, timeval->tm_min, timeval->tm_sec);
              gchar * timestr = g_date_time_format(dt, self->priv->time_string);

              gint length = measure_string(style, context, timestr);

              g_free(timestr);
              g_date_time_unref(dt);

              if (length > *max_width) {
                     *max_width = length;
              }
       }

       g_array_free(timevals, TRUE);

       gtk_widget_set_size_request(GTK_WIDGET(self->priv->label), self->priv->max_width, -1);
       g_debug("Guessing max time width: %d", self->priv->max_width);

       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean idle_measure ( gpointer  data) [static]

Definition at line 670 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(data);
       self->priv->idle_measure = 0;

       GtkAllocation allocation;
       gtk_widget_get_allocation(GTK_WIDGET(self->priv->label), &allocation);

       if (allocation.width > self->priv->max_width) {
              if (self->priv->max_width != 0) {
                     g_warning("Guessed wrong.  We thought the max would be %d but we're now at %d", self->priv->max_width, allocation.width);
              }
              self->priv->max_width = allocation.width;
              gtk_widget_set_size_request(GTK_WIDGET(self->priv->label), self->priv->max_width, -1);
       }

       return FALSE;
}

Here is the caller graph for this function:

static void indicator_datetime_dispose ( GObject *  object) [static]

Definition at line 424 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(object);
       IndicatorDatetimePrivate * priv = self->priv;

       if (priv->timer != 0) {
              g_source_remove(priv->timer);
              priv->timer = 0;
       }

       if (priv->idle_measure != 0) {
              g_source_remove(priv->idle_measure);
              priv->idle_measure = 0;
       }

       g_clear_object (&priv->label);
       g_clear_object (&priv->menu);
       g_clear_object (&priv->sm);
       g_clear_object (&priv->settings);
       g_clear_object (&priv->service_proxy);
       g_clear_object (&priv->indicator_right_group);
       g_clear_object (&priv->ido_calendar);
       g_clear_object (&priv->service_proxy_cancel);

       G_OBJECT_CLASS (indicator_datetime_parent_class)->dispose (object);
       return;
}

Here is the caller graph for this function:

static void indicator_datetime_finalize ( GObject *  object) [static]

Definition at line 453 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(object);

       if (self->priv->time_string != NULL) {
              g_free(self->priv->time_string);
              self->priv->time_string = NULL;
       }

       if (self->priv->custom_string != NULL) {
              g_free(self->priv->custom_string);
              self->priv->custom_string = NULL;
       }

       G_OBJECT_CLASS (indicator_datetime_parent_class)->finalize (object);
       return;
}

Here is the caller graph for this function:

GType indicator_datetime_get_type ( void  )

Definition at line 153 of file indicator-datetime.c.

{
       GObjectClass *object_class = G_OBJECT_CLASS (klass);

       g_type_class_add_private (klass, sizeof (IndicatorDatetimePrivate));

       object_class->dispose = indicator_datetime_dispose;
       object_class->finalize = indicator_datetime_finalize;

       object_class->set_property = set_property;
       object_class->get_property = get_property;

       IndicatorObjectClass * io_class = INDICATOR_OBJECT_CLASS(klass);

       io_class->get_label = get_label;
       io_class->get_menu  = get_menu;
       io_class->get_accessible_desc = get_accessible_desc;
       io_class->get_name_hint = get_name_hint;

       g_object_class_install_property (object_class,
                                        PROP_SHOW_CLOCK,
                                        g_param_spec_boolean(PROP_SHOW_CLOCK_S,
                                                             "Whether to show the clock in the menu bar.",
                                                             "Shows indicator-datetime in the shell's menu bar.",
                                                             TRUE, /* default */
                                                             G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
       g_object_class_install_property (object_class,
                                        PROP_TIME_FORMAT,
                                        g_param_spec_int(PROP_TIME_FORMAT_S,
                                                         "A choice of which format should be used on the panel",
                                                         "Chooses between letting the locale choose the time, 12-hour time, 24-time or using the custom string passed to g_date_time_format().",
                                                         SETTINGS_TIME_LOCALE, /* min */
                                                         SETTINGS_TIME_CUSTOM, /* max */
                                                         SETTINGS_TIME_LOCALE, /* default */
                                                         G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
       g_object_class_install_property (object_class,
                                        PROP_SHOW_SECONDS,
                                        g_param_spec_boolean(PROP_SHOW_SECONDS_S,
                                                             "Whether to show seconds in the indicator.",
                                                             "Shows seconds along with the time in the indicator.  Also effects refresh interval.",
                                                             FALSE, /* default */
                                                             G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
       g_object_class_install_property (object_class,
                                        PROP_SHOW_DAY,
                                        g_param_spec_boolean(PROP_SHOW_DAY_S,
                                                             "Whether to show the day of the week in the indicator.",
                                                             "Shows the day of the week along with the time in the indicator.",
                                                             FALSE, /* default */
                                                             G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
       g_object_class_install_property (object_class,
                                        PROP_SHOW_DATE,
                                        g_param_spec_boolean(PROP_SHOW_DATE_S,
                                                             "Whether to show the day and month in the indicator.",
                                                             "Shows the day and month along with the time in the indicator.",
                                                             FALSE, /* default */
                                                             G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
       g_object_class_install_property (object_class,
                                        PROP_CUSTOM_TIME_FORMAT,
                                        g_param_spec_string(PROP_CUSTOM_TIME_FORMAT_S,
                                                            "The format that is used to show the time on the panel.",
                                                            "A format string in the form used to pass to g_date_time_format() to make a string for displaying on the panel.",
                                                            DEFAULT_TIME_FORMAT,
                                                            G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

       g_object_class_install_property (object_class,
                                        PROP_SHOW_WEEK_NUMBERS,
                                        g_param_spec_boolean(PROP_SHOW_WEEK_NUMBERS_S,
                                                             "Whether to show the week numbers in the calendar.",
                                                             "Shows the week numbers in the monthly calendar in indicator-datetime's menu.",
                                                             FALSE, /* default */
                                                             G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
       g_object_class_install_property (object_class,
                                        PROP_SHOW_CALENDAR,
                                        g_param_spec_boolean(PROP_SHOW_CALENDAR_S,
                                                             "Whether to show the calendar.",
                                                             "Shows the monthly calendar in indicator-datetime's menu.",
                                                             TRUE, /* default */
                                                             G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
       return;
}

Here is the call graph for this function:

static void indicator_datetime_init ( IndicatorDatetime *  self) [static]

Definition at line 290 of file indicator-datetime.c.

{
       self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
                                                  INDICATOR_DATETIME_TYPE,
                                                  IndicatorDatetimePrivate);

       self->priv->label = NULL;
       self->priv->timer = 0;

       self->priv->idle_measure = 0;
       self->priv->max_width = 0;

       self->priv->show_clock = TRUE;
       self->priv->time_mode = SETTINGS_TIME_LOCALE;
       self->priv->show_seconds = FALSE;
       self->priv->show_date = FALSE;
       self->priv->show_day = FALSE;
       self->priv->custom_string = g_strdup(DEFAULT_TIME_FORMAT);
       self->priv->custom_show_seconds = FALSE;

       self->priv->time_string = generate_format_string_now(self);

       self->priv->service_proxy = NULL;

       self->priv->sm = NULL;
       self->priv->menu = NULL;

       self->priv->settings = g_settings_new(SETTINGS_INTERFACE);
       if (self->priv->settings != NULL) {
              g_settings_bind(self->priv->settings,
                              SETTINGS_SHOW_CLOCK_S,
                              self,
                              PROP_SHOW_CLOCK_S,
                              G_SETTINGS_BIND_GET);
              g_settings_bind_with_mapping(self->priv->settings,
                              SETTINGS_TIME_FORMAT_S,
                              self,
                              PROP_TIME_FORMAT_S,
                              G_SETTINGS_BIND_GET,
                              bind_enum_get,
                              NULL, NULL, NULL); /* set mapping, userdata and destroy func */
              g_settings_bind(self->priv->settings,
                              SETTINGS_SHOW_SECONDS_S,
                              self,
                              PROP_SHOW_SECONDS_S,
                              G_SETTINGS_BIND_GET);
              g_settings_bind(self->priv->settings,
                              SETTINGS_SHOW_DAY_S,
                              self,
                              PROP_SHOW_DAY_S,
                              G_SETTINGS_BIND_GET);
              g_settings_bind(self->priv->settings,
                              SETTINGS_SHOW_DATE_S,
                              self,
                              PROP_SHOW_DATE_S,
                              G_SETTINGS_BIND_GET);
              g_settings_bind(self->priv->settings,
                              SETTINGS_CUSTOM_TIME_FORMAT_S,
                              self,
                              PROP_CUSTOM_TIME_FORMAT_S,
                              G_SETTINGS_BIND_GET);
              g_settings_bind(self->priv->settings,
                              SETTINGS_SHOW_WEEK_NUMBERS_S,
                              self,
                              PROP_SHOW_WEEK_NUMBERS_S,
                              G_SETTINGS_BIND_GET);
              g_settings_bind(self->priv->settings,
                              SETTINGS_SHOW_CALENDAR_S,
                              self,
                              PROP_SHOW_CALENDAR_S,
                              G_SETTINGS_BIND_GET);
       } else {
              g_warning("Unable to get settings for '" SETTINGS_INTERFACE "'");
       }

       self->priv->sm = indicator_service_manager_new_version(SERVICE_NAME, SERVICE_VERSION);
       self->priv->indicator_right_group = GTK_SIZE_GROUP(gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL));

       self->priv->menu = dbusmenu_gtkmenu_new(SERVICE_NAME, MENU_OBJ);

       g_signal_connect(self->priv->menu, "notify::visible", G_CALLBACK(menu_visible_notfy_cb), self);
       
       DbusmenuGtkClient *client = dbusmenu_gtkmenu_get_client(self->priv->menu);
       dbusmenu_client_add_type_handler_full(DBUSMENU_CLIENT(client), DBUSMENU_CALENDAR_MENUITEM_TYPE, new_calendar_item, self, NULL);
       dbusmenu_client_add_type_handler_full(DBUSMENU_CLIENT(client), APPOINTMENT_MENUITEM_TYPE, new_appointment_item, self, NULL);
       dbusmenu_client_add_type_handler_full(DBUSMENU_CLIENT(client), TIMEZONE_MENUITEM_TYPE, new_timezone_item, self, NULL);

       self->priv->service_proxy_cancel = g_cancellable_new();

       g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
                                G_DBUS_PROXY_FLAGS_NONE,
                                NULL,
                                SERVICE_NAME,
                                SERVICE_OBJ,
                                SERVICE_IFACE,
                                self->priv->service_proxy_cancel,
                                service_proxy_cb,
                                  self);

       return;
}

Here is the call graph for this function:

static void indicator_prop_change_cb ( DbusmenuMenuitem *  mi,
gchar *  prop,
GVariant *  value,
indicator_item_t *  mi_data 
) [static]

Definition at line 1133 of file indicator-datetime.c.

{
       if (!g_strcmp0(prop, APPOINTMENT_MENUITEM_PROP_LABEL)) {
              /* Set the main label */
              gtk_label_set_text(GTK_LABEL(mi_data->label), g_variant_get_string(value, NULL));
       } else if (!g_strcmp0(prop, APPOINTMENT_MENUITEM_PROP_RIGHT)) {
              /* Set the right label */
              gtk_label_set_text(GTK_LABEL(mi_data->right), g_variant_get_string(value, NULL));
       } else if (!g_strcmp0(prop, APPOINTMENT_MENUITEM_PROP_ICON)) {
              /* We don't use the value here, which is probably less efficient, 
                 but it's easier to use the easy function.  And since th value
                 is already cached, shouldn't be a big deal really.  */
              GdkPixbuf * pixbuf = dbusmenu_menuitem_property_get_image(mi, APPOINTMENT_MENUITEM_PROP_ICON);
              if (pixbuf != NULL) {
                     /* If we've got a pixbuf we need to make sure it's of a reasonable
                        size to fit in the menu.  If not, rescale it. */
                     GdkPixbuf * resized_pixbuf;
                     gint width, height;
                     gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &width, &height);
                     if (gdk_pixbuf_get_width(pixbuf) > width ||
                                   gdk_pixbuf_get_height(pixbuf) > height) {
                            g_debug("Resizing icon from %dx%d to %dx%d", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf), width, height);
                            resized_pixbuf = gdk_pixbuf_scale_simple(pixbuf,
                                                                     width,
                                                                     height,
                                                                     GDK_INTERP_BILINEAR);
                     } else {
                            g_debug("Happy with icon sized %dx%d", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf));
                            resized_pixbuf = pixbuf;
                     }
                     gtk_image_set_from_pixbuf(GTK_IMAGE(mi_data->icon), resized_pixbuf);
                     /* The other pixbuf should be free'd by the dbusmenu. */
                     if (resized_pixbuf != pixbuf) {
                            g_object_unref(resized_pixbuf);
                     }
              }
       } else if (!g_strcmp0(prop, TIMEZONE_MENUITEM_PROP_ZONE)) {
              timezone_update_labels(mi_data);
       } else if (!g_strcmp0(prop, TIMEZONE_MENUITEM_PROP_NAME)) {
              timezone_update_labels(mi_data);
       } else if (!g_strcmp0(prop, TIMEZONE_MENUITEM_PROP_RADIO)) {
              gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi_data->gmi), g_variant_get_boolean(value));
       }
       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gint measure_string ( GtkStyle *  style,
PangoContext *  context,
const gchar *  string 
) [static]

Definition at line 864 of file indicator-datetime.c.

{
       PangoLayout * layout = pango_layout_new(context);

       if (pango_parse_markup(string, -1, 0, NULL, NULL, NULL, NULL))
              pango_layout_set_markup(layout, string, -1);
       else
              pango_layout_set_text(layout, string, -1);

       pango_layout_set_font_description(layout, style->font_desc);

       gint width;
       pango_layout_get_pixel_size(layout, &width, NULL);
       g_object_unref(layout);
       return width;
}

Here is the caller graph for this function:

static void menu_visible_notfy_cb ( GtkWidget *  menu,
G_GNUC_UNUSED GParamSpec *  pspec,
gpointer  user_data 
) [static]

Definition at line 268 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(user_data);
       GDateTime *datetime;
       gint y, m, d;

       g_debug("notify visible signal received");

       datetime = g_date_time_new_now_local ();
       g_date_time_get_ymd (datetime, &y, &m, &d);
       g_date_time_unref (datetime);

       // Set the calendar to todays date
       ido_calendar_menu_item_set_date (self->priv->ido_calendar, y, m-1, d);

       // Make sure the day-selected signal is sent so the menu updates - may duplicate
       /*GVariant *variant = g_variant_new_uint32((guint)curtime);
       guint timestamp = (guint)time(NULL);
       dbusmenu_menuitem_handle_event(DBUSMENU_MENUITEM(self->priv->ido_calendar), "day-selected", variant, timestamp);*/
}

Here is the caller graph for this function:

static void month_changed_cb ( IdoCalendarMenuItem *  ido,
gpointer  user_data 
) [static]

Definition at line 1289 of file indicator-datetime.c.

{
       guint d,m,y;
       DbusmenuMenuitem * item = DBUSMENU_MENUITEM (user_data);
       ido_calendar_menu_item_get_date(ido, &y, &m, &d);
       struct tm date = {0};
       date.tm_mday = d;
       date.tm_mon = m;
       date.tm_year = y - 1900;
       guint selecteddate = (guint)mktime(&date);
       g_debug("Got month changed signal: %s", asctime(&date));
       GVariant *variant = g_variant_new_uint32(selecteddate);
       guint timestamp = (guint)time(NULL);
       dbusmenu_menuitem_handle_event(DBUSMENU_MENUITEM(item), "month-changed", variant, timestamp);
}

Here is the caller graph for this function:

static gboolean new_appointment_item ( DbusmenuMenuitem *  newitem,
DbusmenuMenuitem *  parent,
DbusmenuClient *  client,
gpointer  user_data 
) [static]

Definition at line 1211 of file indicator-datetime.c.

{
       g_return_val_if_fail(DBUSMENU_IS_MENUITEM(newitem), FALSE);
       g_return_val_if_fail(DBUSMENU_IS_GTKCLIENT(client), FALSE);
       g_return_val_if_fail(IS_INDICATOR_DATETIME(user_data), FALSE);
       /* Note: not checking parent, it's reasonable for it to be NULL */
       IndicatorDatetime * self = INDICATOR_DATETIME(user_data);

       indicator_item_t * mi_data = g_new0(indicator_item_t, 1);

       mi_data->gmi = gtk_menu_item_new();

       GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);

       /* Icon, probably someone's face or avatar on an IM */
       mi_data->icon = gtk_image_new();
       GdkPixbuf * pixbuf = dbusmenu_menuitem_property_get_image(newitem, APPOINTMENT_MENUITEM_PROP_ICON);

       if (pixbuf != NULL) {
              /* If we've got a pixbuf we need to make sure it's of a reasonable
                 size to fit in the menu.  If not, rescale it. */
              GdkPixbuf * resized_pixbuf;
              gint width, height;
              gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &width, &height);
              if (gdk_pixbuf_get_width(pixbuf) > width ||
                      gdk_pixbuf_get_height(pixbuf) > height) {
                     g_debug("Resizing icon from %dx%d to %dx%d", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf), width, height);
                     resized_pixbuf = gdk_pixbuf_scale_simple(pixbuf,
                                                              width,
                                                              height,
                                                              GDK_INTERP_BILINEAR);
              } else {
                     g_debug("Happy with icon sized %dx%d", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf));
                     resized_pixbuf = pixbuf;
              }
  
              gtk_image_set_from_pixbuf(GTK_IMAGE(mi_data->icon), resized_pixbuf);

              /* The other pixbuf should be free'd by the dbusmenu. */
              if (resized_pixbuf != pixbuf) {
                     g_object_unref(resized_pixbuf);
              }
       }
       gtk_misc_set_alignment(GTK_MISC(mi_data->icon), 0.0, 0.5);
       gtk_box_pack_start(GTK_BOX(hbox), mi_data->icon, FALSE, FALSE, 0);
       gtk_widget_show(mi_data->icon);

       /* Label, probably a username, chat room or mailbox name */
       mi_data->label = gtk_label_new(dbusmenu_menuitem_property_get(newitem, APPOINTMENT_MENUITEM_PROP_LABEL));
       gtk_misc_set_alignment(GTK_MISC(mi_data->label), 0.0, 0.5);
       
       GtkStyle * style = gtk_widget_get_style(GTK_WIDGET(mi_data->label));
       PangoContext * context = gtk_widget_get_pango_context(GTK_WIDGET(mi_data->label));
       gint length = measure_string(style, context, "MMMMMMMMMMMMMMM"); // 15 char wide string max
       gtk_widget_set_size_request(GTK_WIDGET(mi_data->label), length, -1); // Set the min size in pixels
       
       gtk_label_set_ellipsize(GTK_LABEL(mi_data->label), PANGO_ELLIPSIZE_END);
       gtk_box_pack_start(GTK_BOX(hbox), mi_data->label, TRUE, TRUE, 0);
       gtk_widget_show(mi_data->label);

       /* Usually either the time or the count on the individual
          item. */
       mi_data->right = gtk_label_new(dbusmenu_menuitem_property_get(newitem, APPOINTMENT_MENUITEM_PROP_RIGHT));
       gtk_size_group_add_widget(self->priv->indicator_right_group, mi_data->right);
       gtk_misc_set_alignment(GTK_MISC(mi_data->right), 1.0, 0.5);
       gtk_box_pack_start(GTK_BOX(hbox), mi_data->right, FALSE, FALSE, 0);
       gtk_widget_show(mi_data->right);

       gtk_container_add(GTK_CONTAINER(mi_data->gmi), hbox);
       gtk_widget_show(hbox);

       dbusmenu_gtkclient_newitem_base(DBUSMENU_GTKCLIENT(client), newitem, GTK_MENU_ITEM(mi_data->gmi), parent);

       g_signal_connect(G_OBJECT(newitem), DBUSMENU_MENUITEM_SIGNAL_PROPERTY_CHANGED, G_CALLBACK(indicator_prop_change_cb), mi_data);
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean new_calendar_item ( DbusmenuMenuitem *  newitem,
DbusmenuMenuitem *  parent,
DbusmenuClient *  client,
gpointer  user_data 
) [static]

Definition at line 1343 of file indicator-datetime.c.

{
       g_debug("New calendar item");
       g_return_val_if_fail(DBUSMENU_IS_MENUITEM(newitem), FALSE);
       g_return_val_if_fail(DBUSMENU_IS_GTKCLIENT(client), FALSE);
       g_return_val_if_fail(IS_INDICATOR_DATETIME(user_data), FALSE);
       /* Note: not checking parent, it's reasonable for it to be NULL */

       IndicatorDatetime *self = INDICATOR_DATETIME(user_data);

       IdoCalendarMenuItem *ido = IDO_CALENDAR_MENU_ITEM (ido_calendar_menu_item_new ());
       self->priv->ido_calendar = ido;
       
       GtkCalendarDisplayOptions flags = ido_calendar_menu_item_get_display_options (self->priv->ido_calendar);
       if (self->priv->show_week_numbers == TRUE)
              flags |= GTK_CALENDAR_SHOW_WEEK_NUMBERS;
       else
              flags &= ~GTK_CALENDAR_SHOW_WEEK_NUMBERS;
       ido_calendar_menu_item_set_display_options (self->priv->ido_calendar, flags);

       gtk_widget_set_visible (GTK_WIDGET (self->priv->ido_calendar), self->priv->show_calendar);

       dbusmenu_gtkclient_newitem_base(DBUSMENU_GTKCLIENT(client), newitem, GTK_MENU_ITEM(ido), parent);

       g_signal_connect_after(ido, "month-changed", G_CALLBACK(month_changed_cb), (gpointer)newitem);
       g_signal_connect_after(ido, "day-selected", G_CALLBACK(day_selected_cb), (gpointer)newitem);
       g_signal_connect_after(ido, "day-selected-double-click", G_CALLBACK(day_selected_double_click_cb), (gpointer)newitem);

       g_signal_connect(G_OBJECT(newitem), DBUSMENU_MENUITEM_SIGNAL_PROPERTY_CHANGED, G_CALLBACK(calendar_prop_change_cb), ido);

       /* Run the current values through prop changed */
       GVariant * propval = NULL;

       propval = dbusmenu_menuitem_property_get_variant(newitem, CALENDAR_MENUITEM_PROP_MARKS);
       if (propval != NULL) {
              calendar_prop_change_cb(newitem, CALENDAR_MENUITEM_PROP_MARKS, propval, ido);
       }

       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean new_timezone_item ( DbusmenuMenuitem *  newitem,
DbusmenuMenuitem *  parent,
DbusmenuClient *  client,
gpointer  user_data 
) [static]

Definition at line 1408 of file indicator-datetime.c.

{
       g_return_val_if_fail(DBUSMENU_IS_MENUITEM(newitem), FALSE);
       g_return_val_if_fail(DBUSMENU_IS_GTKCLIENT(client), FALSE);
       g_return_val_if_fail(IS_INDICATOR_DATETIME(user_data), FALSE);
       /* Note: not checking parent, it's reasonable for it to be NULL */

       IndicatorDatetime * self = INDICATOR_DATETIME(user_data);
       IndicatorDatetimePrivate *priv = self->priv;

       // Menu item with a radio button and a right aligned time
       indicator_item_t * mi_data = g_new0(indicator_item_t, 1);

       priv->timezone_items = g_list_prepend(priv->timezone_items, mi_data);

       mi_data->self = self;
       mi_data->mi = newitem;
       mi_data->gmi = gtk_check_menu_item_new();

       gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(mi_data->gmi), TRUE);
       gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi_data->gmi),
              dbusmenu_menuitem_property_get_bool(newitem, TIMEZONE_MENUITEM_PROP_RADIO));

       GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);

       /* Label, probably a username, chat room or mailbox name */
       mi_data->label = gtk_label_new("");
       gtk_misc_set_alignment(GTK_MISC(mi_data->label), 0.0, 0.5);
       gtk_box_pack_start(GTK_BOX(hbox), mi_data->label, TRUE, TRUE, 0);
       gtk_widget_show(mi_data->label);

       /* Usually either the time or the count on the individual
          item. */
       mi_data->right = gtk_label_new("");
       gtk_size_group_add_widget(self->priv->indicator_right_group, mi_data->right);
       gtk_misc_set_alignment(GTK_MISC(mi_data->right), 1.0, 0.5);
       gtk_box_pack_start(GTK_BOX(hbox), mi_data->right, FALSE, FALSE, 0);
       gtk_widget_show(mi_data->right);

       timezone_update_labels(mi_data);

       gtk_container_add(GTK_CONTAINER(mi_data->gmi), hbox);
       gtk_widget_show(hbox);

       dbusmenu_gtkclient_newitem_base(DBUSMENU_GTKCLIENT(client), newitem, GTK_MENU_ITEM(mi_data->gmi), parent);

       g_signal_connect(G_OBJECT(mi_data->gmi), "toggled", G_CALLBACK(timezone_toggled_cb), newitem);
       g_signal_connect(G_OBJECT(newitem), DBUSMENU_MENUITEM_SIGNAL_PROPERTY_CHANGED, G_CALLBACK(indicator_prop_change_cb), mi_data);
       g_object_weak_ref(G_OBJECT(newitem), (GWeakNotify)timezone_destroyed_cb, mi_data);

       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void receive_signal ( GDBusProxy *  proxy,
gchar *  sender_name,
gchar *  signal_name,
GVariant *  parameters,
gpointer  user_data 
) [static]

Definition at line 801 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(user_data);

       if (g_strcmp0(signal_name, "UpdateTime") == 0) {
              update_time(self);
       }

       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void service_proxy_cb ( GObject *  object,
GAsyncResult *  res,
gpointer  user_data 
) [static]

Definition at line 396 of file indicator-datetime.c.

{
       GError * error = NULL;

       IndicatorDatetime * self = INDICATOR_DATETIME(user_data);
       g_return_if_fail(self != NULL);
       IndicatorDatetimePrivate * priv = self->priv;

       GDBusProxy * proxy = g_dbus_proxy_new_for_bus_finish(res, &error);

       g_clear_object (&priv->service_proxy_cancel);

       if (error != NULL) {
              g_warning("Could not grab DBus proxy for %s: %s", SERVICE_NAME, error->message);
              g_error_free(error);
              return;
       }

       /* Okay, we're good to grab the proxy at this point, we're
       sure that it's ours. */
       priv->service_proxy = proxy;

       g_signal_connect(proxy, "g-signal", G_CALLBACK(receive_signal), self);

       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void set_label_to_time_in_zone ( IndicatorDatetime *  self,
GtkLabel *  label,
GTimeZone *  tz,
const gchar *  format,
GDateTime **  datetime 
) [static]

Definition at line 711 of file indicator-datetime.c.

{
       gboolean unref_tz = FALSE;
       if (tz == NULL) {
              gchar * zone = read_timezone ();
              if (zone == NULL)
                     return;
              tz = g_time_zone_new(zone);
              unref_tz = TRUE;
              g_free (zone);
       }

       GDateTime * datetime_now;
       datetime_now = g_date_time_new_now(tz);

       gchar * timestr;
       if (format == NULL) {
              gchar * format_for_time = generate_format_string_at_time(datetime_now);
              timestr = g_date_time_format(datetime_now, format_for_time);
              g_free(format_for_time);
       }
       else {
              timestr = g_date_time_format(datetime_now, format);
              if (timestr == NULL) {
                     g_warning ("The custom date format is not valid, check the\n"
                                "g_date_time_format() documentation for the supported\n"
                                "format specifiers ");
                     timestr = g_strdup ("Date format not supported");
              }
       }

       gboolean use_markup = FALSE;
       if (pango_parse_markup(timestr, -1, 0, NULL, NULL, NULL, NULL))
              use_markup = TRUE;

       if (use_markup)
              gtk_label_set_markup(label, timestr);
       else
              gtk_label_set_text(label, timestr);

       g_free(timestr);

       if (datetime)
              *datetime = datetime_now;
       else
              g_date_time_unref(datetime_now);

       if (unref_tz)
              g_time_zone_unref(tz);

       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void set_property ( GObject *  object,
guint  prop_id,
const GValue *  value,
GParamSpec *  pspec 
) [static]

Definition at line 504 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(object);
       gboolean update = FALSE;

       switch(prop_id) {
       case PROP_SHOW_CLOCK: {
              if (g_value_get_boolean(value) != self->priv->show_clock) {
                     self->priv->show_clock = g_value_get_boolean(value);
                     if (self->priv->label != NULL) {
                            gtk_widget_set_visible (GTK_WIDGET (self->priv->label), self->priv->show_clock);
                     }
              }
              break;
       }
       case PROP_TIME_FORMAT: {
              gint newval = g_value_get_int(value);
              if (newval != self->priv->time_mode) {
                     update = TRUE;
                     self->priv->time_mode = newval;
                     setup_timer(self, NULL);                  
              }
              break;
       }
       case PROP_SHOW_SECONDS: {
              if (g_value_get_boolean(value) != self->priv->show_seconds) {
                     self->priv->show_seconds = !self->priv->show_seconds;
                     if (self->priv->time_mode != SETTINGS_TIME_CUSTOM) {
                            update = TRUE;
                            setup_timer(self, NULL);
                     }
              }
              break;
       }
       case PROP_SHOW_DAY: {
              if (g_value_get_boolean(value) != self->priv->show_day) {
                     self->priv->show_day = !self->priv->show_day;
                     if (self->priv->time_mode != SETTINGS_TIME_CUSTOM) {
                            update = TRUE;
                     }
              }
              break;
       }
       case PROP_SHOW_DATE: {
              if (g_value_get_boolean(value) != self->priv->show_date) {
                     self->priv->show_date = !self->priv->show_date;
                     if (self->priv->time_mode != SETTINGS_TIME_CUSTOM) {
                            update = TRUE;
                     }
              }
              break;
       }
       case PROP_CUSTOM_TIME_FORMAT: {
              const gchar * newstr = g_value_get_string(value);
              if (g_strcmp0(newstr, self->priv->custom_string) != 0) {
                     if (self->priv->custom_string != NULL) {
                            g_free(self->priv->custom_string);
                            self->priv->custom_string = NULL;
                     }
                     self->priv->custom_string = g_strdup(newstr);
                     gint time_mask = generate_strftime_bitmask(newstr);
                     self->priv->custom_show_seconds = (time_mask & STRFTIME_MASK_SECONDS);
                     if (self->priv->time_mode == SETTINGS_TIME_CUSTOM) {
                            update = TRUE;
                            setup_timer(self, NULL);
                     }
              }
              break;
       }
       case PROP_SHOW_WEEK_NUMBERS: {
              if (g_value_get_boolean(value) != self->priv->show_week_numbers) {
                     GtkCalendarDisplayOptions flags = ido_calendar_menu_item_get_display_options (self->priv->ido_calendar);
                     if (g_value_get_boolean(value) == TRUE)
                            flags |= GTK_CALENDAR_SHOW_WEEK_NUMBERS;
                     else
                            flags &= ~GTK_CALENDAR_SHOW_WEEK_NUMBERS;
                     ido_calendar_menu_item_set_display_options (self->priv->ido_calendar, flags);
                     self->priv->show_week_numbers = g_value_get_boolean(value);
              }
              break;
       }
       case PROP_SHOW_CALENDAR: {
              if (g_value_get_boolean(value) != self->priv->show_calendar) {
                     self->priv->show_calendar = g_value_get_boolean(value);
                     if (self->priv->ido_calendar != NULL) {
                            gtk_widget_set_visible (GTK_WIDGET (self->priv->ido_calendar), self->priv->show_calendar);
                     }
              }
              break;
       } 
       default: {
              G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
              return;
       }
       }

       if (!update) {
              return;
       }

       /* Get the new format string */
       gchar * newformat = generate_format_string_now(self);

       /* check to ensure the format really changed */
       if (g_strcmp0(self->priv->time_string, newformat) == 0) {
              g_free(newformat);
              return;
       }

       /* Okay now process the change */
       if (self->priv->time_string != NULL) {
              g_free(self->priv->time_string);
              self->priv->time_string = NULL;
       }
       self->priv->time_string = newformat;

       /* And update everything */
       update_label(self, NULL);
       timezone_update_all_labels(self);
       guess_label_size(self);

       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void setup_timer ( IndicatorDatetime *  self,
GDateTime *  datetime 
) [static]

Definition at line 831 of file indicator-datetime.c.

{
       gboolean unref = FALSE;

       if (self->priv->timer != 0) {
              g_source_remove(self->priv->timer);
              self->priv->timer = 0;
       }
       
       if (self->priv->show_seconds ||
              (self->priv->time_mode == SETTINGS_TIME_CUSTOM && self->priv->custom_show_seconds)) {
              self->priv->timer = g_timeout_add_full(G_PRIORITY_HIGH, 999, timer_func, self, NULL);
       } else {
              if (datetime == NULL) {
                     datetime = g_date_time_new_now_local();
                     unref = TRUE;
              }

              /* Plus 2 so we're just after the minute, don't want to be early. */
              gint seconds = (gint)g_date_time_get_seconds(datetime);
              self->priv->timer = g_timeout_add_seconds(60 - seconds + 2, timer_func, self);

              if (unref) {
                     g_date_time_unref(datetime);
              }
       }

       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void style_changed ( GtkWidget *  widget,
GtkStyle *  oldstyle,
gpointer  data 
) [static]

Definition at line 1079 of file indicator-datetime.c.

{
       g_debug("New style for time label");
       IndicatorDatetime * self = INDICATOR_DATETIME(data);
       guess_label_size(self);
       update_label(self, NULL);
       timezone_update_all_labels(self);
       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean timer_func ( gpointer  user_data)

Definition at line 815 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(user_data);
       self->priv->timer = 0;
       GDateTime * dt = NULL;
       update_label(self, &dt);
       timezone_update_all_labels(self);
       if (dt != NULL) {
              setup_timer(self, dt);
              g_date_time_unref(dt);
  }
       return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void timezone_destroyed_cb ( indicator_item_t *  mi_data,
DbusmenuMenuitem *  dbusitem 
) [static]

Definition at line 1397 of file indicator-datetime.c.

{
       IndicatorDatetime *self = INDICATOR_DATETIME (mi_data->self);
       IndicatorDatetimePrivate *priv = self->priv;

       priv->timezone_items = g_list_remove(priv->timezone_items, mi_data);
       g_signal_handlers_disconnect_by_func(G_OBJECT(mi_data->gmi), G_CALLBACK(timezone_toggled_cb), dbusitem);
       g_free(mi_data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void timezone_toggled_cb ( GtkCheckMenuItem *  checkmenuitem,
DbusmenuMenuitem *  dbusitem 
) [static]

Definition at line 1388 of file indicator-datetime.c.

{
       /* Make sure that the displayed radio-active setting is always 
          consistent with the dbus menuitem */
       gtk_check_menu_item_set_active(checkmenuitem,
              dbusmenu_menuitem_property_get_bool(dbusitem, TIMEZONE_MENUITEM_PROP_RADIO));
}

Here is the caller graph for this function:

static void timezone_update_all_labels ( IndicatorDatetime *  self) [static]

Definition at line 495 of file indicator-datetime.c.

{
       IndicatorDatetimePrivate *priv = self->priv;

       g_list_foreach(priv->timezone_items, (GFunc)timezone_update_labels, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void timezone_update_labels ( indicator_item_t *  mi_data) [static]

Definition at line 1117 of file indicator-datetime.c.

{
       const gchar * zone = dbusmenu_menuitem_property_get(mi_data->mi, TIMEZONE_MENUITEM_PROP_ZONE);
       const gchar * name = dbusmenu_menuitem_property_get(mi_data->mi, TIMEZONE_MENUITEM_PROP_NAME);

       gtk_label_set_text(GTK_LABEL(mi_data->label), name);

       /* Show current time in that zone on the right */
       GTimeZone * tz = g_time_zone_new(zone);
       set_label_to_time_in_zone(mi_data->self, GTK_LABEL(mi_data->right), tz, NULL, NULL);
       g_time_zone_unref(tz);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void update_accessible_description ( IndicatorDatetime *  io) [static]

Definition at line 691 of file indicator-datetime.c.

{
       GList * entries = indicator_object_get_entries(INDICATOR_OBJECT(io));
       IndicatorObjectEntry * entry = (IndicatorObjectEntry *)entries->data;

       entry->accessible_desc = get_accessible_desc(INDICATOR_OBJECT(io));

       g_signal_emit(G_OBJECT(io),
                     INDICATOR_OBJECT_SIGNAL_ACCESSIBLE_DESC_UPDATE_ID,
                     0,
                     entry,
                     TRUE);

       g_list_free(entries);

       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void update_label ( IndicatorDatetime *  io,
GDateTime **  datetime 
) [static]

Definition at line 768 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(io);

       if (self->priv->label == NULL) return;

       set_label_to_time_in_zone(self, self->priv->label, NULL, self->priv->time_string, datetime);

       if (self->priv->idle_measure == 0) {
              self->priv->idle_measure = g_idle_add(idle_measure, io);
       }

       update_accessible_description(io);

       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void update_text_gravity ( GtkWidget *  widget,
GdkScreen *  previous_screen,
gpointer  data 
) [static]

Definition at line 1091 of file indicator-datetime.c.

{
       IndicatorDatetime * self = INDICATOR_DATETIME(data);
       if (self->priv->label == NULL) return;

       PangoLayout  *layout;
       PangoContext *context;

       layout = gtk_label_get_layout (GTK_LABEL(self->priv->label));
       context = pango_layout_get_context(layout);
       pango_context_set_base_gravity(context, PANGO_GRAVITY_AUTO);
}

Here is the caller graph for this function:

static void update_time ( IndicatorDatetime *  self) [static]

Definition at line 787 of file indicator-datetime.c.

{
       GDateTime * dt = NULL;
       update_label(self, &dt);
       timezone_update_all_labels(self);
       if (dt != NULL) {
              setup_timer(self, dt);
              g_date_time_unref(dt);
  }
       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

const strftime_type_t strftime_type[] [static]

Definition at line 893 of file indicator-datetime.c.