gint orage_days_between(struct tm *t1, struct tm *t2)
{
GDate *g_t1, *g_t2;
gint dd;
g_t1 = g_date_new_dmy(t1->tm_mday, t1->tm_mon, t1->tm_year);
g_t2 = g_date_new_dmy(t2->tm_mday, t2->tm_mon, t2->tm_year);
dd = g_date_days_between(g_t1, g_t2);
g_date_free(g_t1);
g_date_free(g_t2);
return(dd);
}
/* GTODO_NO_DUE_DATE = no due date */
gint32 gtodo_todo_item_check_due(GTodoItem *item)
{
GDate *today;
int i;
if(item->due == NULL) return GTODO_NO_DUE_DATE;
today = g_date_new();
g_date_set_time_t(today, time(NULL));
i = g_date_days_between(item->due,today);
g_date_free(today);
return i;
}
time_t
mrp_time2_get_epoch (MrpTime *t)
{
GDate date;
time_t epoch;
g_date_set_dmy (&date, 1, 1, 1970);
epoch = SECS_IN_DAY * g_date_days_between (&date, &t->date);
epoch += t->hour * SECS_IN_HOUR + t->min * SECS_IN_MIN + t->sec;
return epoch;
}
static int get_date_offset( GtkCalendar* calendar )
{
/* FIXME: I think we need a better implementation for this */
GDate* date;
GDate* today;
int y, m, d, offset;
time_t timeval = time(NULL);
struct tm* lt = localtime( &timeval );
gtk_calendar_get_date( calendar, &y, &m, &d );
date = g_date_new_dmy( d, m, y );
today = g_date_new_dmy( lt->tm_mday, lt->tm_mon, lt->tm_year+1900 );
offset = g_date_days_between( date, today );
g_date_free(date);
g_date_free(today);
return ABS(offset);
}
/* This is the only real algorithm related to recurrences. It goes:
Step 1) Go forward one period from the reference date.
Step 2) Back up to align to the phase of the start date.
*/
void
recurrenceNextInstance(const Recurrence *r, const GDate *ref, GDate *next)
{
PeriodType pt;
const GDate *start;
guint mult;
WeekendAdjust wadj;
g_return_if_fail(r);
g_return_if_fail(ref);
g_return_if_fail(g_date_valid(&r->start));
g_return_if_fail(g_date_valid(ref));
/* If the ref date comes before the start date then the next
occurrence is always the start date, and we're done. */
start = &r->start;
if (g_date_compare(ref, start) < 0)
{
g_date_set_julian(next, g_date_get_julian(start));
return;
}
g_date_set_julian(next, g_date_get_julian(ref)); /* start at refDate */
/* Step 1: move FORWARD one period, passing exactly one occurrence. */
mult = r->mult;
pt = r->ptype;
wadj = r->wadj;
switch (pt)
{
case PERIOD_YEAR:
mult *= 12;
/* fall through */
case PERIOD_MONTH:
case PERIOD_NTH_WEEKDAY:
case PERIOD_LAST_WEEKDAY:
case PERIOD_END_OF_MONTH:
/* Takes care of short months. */
if (r->wadj == WEEKEND_ADJ_BACK &&
(pt == PERIOD_YEAR || pt == PERIOD_MONTH || pt == PERIOD_END_OF_MONTH) &&
(g_date_get_weekday(next) == G_DATE_SATURDAY || g_date_get_weekday(next) == G_DATE_SUNDAY))
{
/* Allows the following Friday-based calculations to proceed if 'next'
is between Friday and the target day. */
g_date_subtract_days(next, g_date_get_weekday(next) == G_DATE_SATURDAY ? 1 : 2);
}
if (r->wadj == WEEKEND_ADJ_BACK &&
(pt == PERIOD_YEAR || pt == PERIOD_MONTH || pt == PERIOD_END_OF_MONTH) &&
g_date_get_weekday(next) == G_DATE_FRIDAY)
{
GDate tmp_sat;
GDate tmp_sun;
g_date_set_julian(&tmp_sat, g_date_get_julian(next));
g_date_set_julian(&tmp_sun, g_date_get_julian(next));
g_date_add_days(&tmp_sat, 1);
g_date_add_days(&tmp_sun, 2);
if (pt == PERIOD_END_OF_MONTH)
{
if (g_date_is_last_of_month(next) ||
g_date_is_last_of_month(&tmp_sat) ||
g_date_is_last_of_month(&tmp_sun))
g_date_add_months(next, mult);
else
/* one fewer month fwd because of the occurrence in this month */
g_date_add_months(next, mult - 1);
}
else
{
if (g_date_get_day(&tmp_sat) == g_date_get_day(start))
{
g_date_add_days(next, 1);
g_date_add_months(next, mult);
}
else if (g_date_get_day(&tmp_sun) == g_date_get_day(start))
{
g_date_add_days(next, 2);
g_date_add_months(next, mult);
}
else if (g_date_get_day(next) >= g_date_get_day(start))
{
g_date_add_months(next, mult);
}
else if (g_date_is_last_of_month(next))
{
g_date_add_months(next, mult);
}
else if (g_date_is_last_of_month(&tmp_sat))
{
g_date_add_days(next, 1);
g_date_add_months(next, mult);
}
else if (g_date_is_last_of_month(&tmp_sun))
{
g_date_add_days(next, 2);
g_date_add_months(next, mult);
}
else
{
/* one fewer month fwd because of the occurrence in this month */
g_date_add_months(next, mult - 1);
}
}
}
else if ( g_date_is_last_of_month(next) ||
((pt == PERIOD_MONTH || pt == PERIOD_YEAR) &&
g_date_get_day(next) >= g_date_get_day(start)) ||
((pt == PERIOD_NTH_WEEKDAY || pt == PERIOD_LAST_WEEKDAY) &&
nth_weekday_compare(start, next, pt) <= 0) )
g_date_add_months(next, mult);
else
/* one fewer month fwd because of the occurrence in this month */
g_date_add_months(next, mult - 1);
break;
case PERIOD_WEEK:
mult *= 7;
/* fall through */
case PERIOD_DAY:
g_date_add_days(next, mult);
break;
case PERIOD_ONCE:
g_date_clear(next, 1); /* We already caught the case where ref is */
return; /* earlier than start, so this is invalid. */
default:
PERR("Invalid period type");
break;
}
/* Step 2: Back up to align to the base phase. To ensure forward
progress, we never subtract as much as we added (x % mult < mult). */
switch (pt)
{
case PERIOD_YEAR:
case PERIOD_MONTH:
case PERIOD_NTH_WEEKDAY:
case PERIOD_LAST_WEEKDAY:
case PERIOD_END_OF_MONTH:
{
guint dim, n_months;
n_months = 12 * (g_date_get_year(next) - g_date_get_year(start)) +
(g_date_get_month(next) - g_date_get_month(start));
g_date_subtract_months(next, n_months % mult);
/* Ok, now we're in the right month, so we just have to align
the day in one of the three possible ways. */
dim = g_date_get_days_in_month(g_date_get_month(next),
g_date_get_year(next));
if (pt == PERIOD_LAST_WEEKDAY || pt == PERIOD_NTH_WEEKDAY)
{
gint wdresult = nth_weekday_compare(start, next, pt);
if (wdresult < 0)
{
wdresult = -wdresult;
g_date_subtract_days(next, wdresult);
}
else
g_date_add_days(next, wdresult);
}
else if (pt == PERIOD_END_OF_MONTH || g_date_get_day(start) >= dim)
g_date_set_day(next, dim); /* last day in the month */
else
g_date_set_day(next, g_date_get_day(start)); /*same day as start*/
/* Adjust for dates on the weekend. */
if (pt == PERIOD_YEAR || pt == PERIOD_MONTH || pt == PERIOD_END_OF_MONTH)
{
if (g_date_get_weekday(next) == G_DATE_SATURDAY || g_date_get_weekday(next) == G_DATE_SUNDAY)
{
switch (wadj)
{
case WEEKEND_ADJ_BACK:
g_date_subtract_days(next, g_date_get_weekday(next) == G_DATE_SATURDAY ? 1 : 2);
break;
case WEEKEND_ADJ_FORWARD:
g_date_add_days(next, g_date_get_weekday(next) == G_DATE_SATURDAY ? 2 : 1);
break;
case WEEKEND_ADJ_NONE:
default:
break;
}
}
}
}
break;
case PERIOD_WEEK:
case PERIOD_DAY:
g_date_subtract_days(next, g_date_days_between(start, next) % mult);
break;
default:
PERR("Invalid period type");
break;
}
}
gboolean cd_clock_update_with_time (GldiModuleInstance *myApplet)
{
CD_APPLET_ENTER;
//\________________ On recupere l'heure courante.
time_t epoch = (time_t) time (NULL);
_get_current_time (epoch, myApplet);
//\________________ On change la date si necessaire.
int iWidth, iHeight;
CD_APPLET_GET_MY_ICON_EXTENT (&iWidth, &iHeight);
gboolean bNewDate = (myData.currentTime.tm_mday != myData.iLastCheckedDay || myData.currentTime.tm_mon != myData.iLastCheckedMonth || myData.currentTime.tm_year != myData.iLastCheckedYear);
if (bNewDate)
{
strftime (s_cDateBuffer, CD_CLOCK_DATE_BUFFER_LENGTH, "%a %d %b", &myData.currentTime);
myData.iLastCheckedDay = myData.currentTime.tm_mday;
myData.iLastCheckedMonth = myData.currentTime.tm_mon;
myData.iLastCheckedYear = myData.currentTime.tm_year;
}
if (CD_APPLET_MY_CONTAINER_IS_OPENGL && myConfig.bOldStyle && myConfig.iShowDate == CAIRO_DOCK_INFO_ON_ICON)
{
if (bNewDate || myData.iDateTexture == 0)
{
if (myData.iDateTexture != 0)
_cairo_dock_delete_texture (myData.iDateTexture);
double fScale = (double) iWidth / (double) myData.DimensionData.width;
GldiTextDescription labelDescription;
memset (&labelDescription, 0, sizeof (GldiTextDescription));
gldi_text_description_set_font (&labelDescription, (gchar*)"Sans 8"); // casted and then set to null
labelDescription.fColorStart.rgba.red = myConfig.fDateColor[0];
labelDescription.fColorStart.rgba.green = myConfig.fDateColor[1];
labelDescription.fColorStart.rgba.blue = myConfig.fDateColor[2];
labelDescription.fColorStart.rgba.alpha = 1.;
labelDescription.bNoDecorations = TRUE;
cairo_surface_t *pDateSurface = cairo_dock_create_surface_from_text_full (s_cDateBuffer,
&labelDescription,
fScale,
iWidth,
&myData.iDateWidth, &myData.iDateHeight);
//g_print ("date : %dx%d\n", myData.iDateWidth, myData.iDateHeight);
myData.iDateTexture = cairo_dock_create_texture_from_surface (pDateSurface);
cairo_surface_destroy (pDateSurface);
labelDescription.cFont = NULL;
gldi_text_description_reset (&labelDescription);
}
}
if (bNewDate && myConfig.iShowDate == CAIRO_DOCK_INFO_ON_LABEL)
{
CD_APPLET_SET_NAME_FOR_MY_ICON (s_cDateBuffer);
}
//\________________ On dessine avec cette heure.
myData.iSmoothAnimationStep = 0;
if (myConfig.bOldStyle)
{
if (CD_APPLET_MY_CONTAINER_IS_OPENGL)
cd_clock_render_analogic_to_texture (myApplet, iWidth, iHeight, &myData.currentTime, 0.);
else
cd_clock_draw_analogic (myApplet, iWidth, iHeight, &myData.currentTime);
}
else
{
cd_clock_draw_text (myApplet, iWidth, iHeight, &myData.currentTime);
///if (CD_APPLET_MY_CONTAINER_IS_OPENGL) // on ne sait pas bien dessiner du texte, donc on le fait en cairo, et on transfere tout sur notre texture.
/// cairo_dock_update_icon_texture (myIcon);
}
///CD_APPLET_REDRAW_MY_ICON;
//\________________ On teste les alarmes et les taches.
if (!myConfig.bShowSeconds || myData.currentTime.tm_min != myData.iLastCheckedMinute) // un g_timeout de 1min ne s'effectue pas forcement a exectement 1 minute d'intervalle, et donc pourrait "sauter" la minute de l'alarme, d'ou le test sur bShowSeconds dans le cas ou l'applet ne verifie que chaque minute.
{
myData.iLastCheckedMinute = myData.currentTime.tm_min;
// les alarmes.
CDClockAlarm *pAlarm;
guint i;
for (i = 0; i < myConfig.pAlarms->len; i ++)
{
pAlarm = g_ptr_array_index (myConfig.pAlarms, i);
if (myData.currentTime.tm_hour == pAlarm->iHour && myData.currentTime.tm_min == pAlarm->iMinute)
{
gboolean bShowAlarm = FALSE, bRemoveAlarm = FALSE;
if (pAlarm->iDayOfWeek > 0)
{
if (pAlarm->iDayOfWeek == 1)
bShowAlarm = TRUE;
else if (pAlarm->iDayOfWeek - 1 == myData.currentTime.tm_wday)
bShowAlarm = TRUE;
else if (myData.currentTime.tm_wday == 0 || myData.currentTime.tm_wday == 6) // week-end
{
if (pAlarm->iDayOfWeek == 9)
bShowAlarm = TRUE;
}
else if (pAlarm->iDayOfWeek == 8)
bShowAlarm = TRUE;
}
else if (pAlarm->iDayOfMonth > 0)
bShowAlarm = (pAlarm->iDayOfMonth - 1 == myData.currentTime.tm_mday);
else // c'est une alarme qui ne se repete pas.
{
bShowAlarm = TRUE;
bRemoveAlarm = TRUE;
}
if (bShowAlarm)
{
cd_message ("Dring ! %s", pAlarm->cMessage);
gldi_dialog_show_temporary (pAlarm->cMessage, myIcon, myContainer, 60e3);
if (pAlarm->cCommand != NULL)
{
if (myData.iAlarmPID > 0)
{
kill (myData.iAlarmPID, 1);
myData.iAlarmPID = 0;
}
GError *erreur = NULL;
gchar **argv = g_strsplit (pAlarm->cCommand, " ", -1);
g_spawn_async (NULL,
argv,
NULL,
0,
NULL,
NULL,
&myData.iAlarmPID,
&erreur);
if (erreur != NULL)
{
cd_warning ("clock : when trying to execute '%s' : %s", pAlarm->cCommand, erreur->message);
g_error_free (erreur);
myData.iAlarmPID = 0;
}
g_strfreev (argv);
cd_message (" --> child_pid : %d", myData.iAlarmPID);
}
}
if (bRemoveAlarm)
{
cd_message ("Cette alarme ne sera pas repetee");
g_ptr_array_remove_index (myConfig.pAlarms, i);
cd_clock_free_alarm (pAlarm);
/// A FAIRE : effacer l'heure dans le fichier de conf pour cette alarme.
}
}
}
// display missed tasks.
if (!myData.bTaskCheckedOnce)
{
myData.bTaskCheckedOnce = TRUE;
myData.pMissedTasks = cd_clock_get_missed_tasks (myApplet);
}
if (myData.pMissedTasks != NULL) // so if the dialog was closed before we could acknowledge all the tasks, it will re-open.
{
CDClockTask *pTask = myData.pMissedTasks->data;
gchar *cMessage = _make_missed_task_message (pTask, myApplet);
CairoDialogAttr attr;
memset (&attr, 0, sizeof (CairoDialogAttr));
attr.cText = cMessage;
attr.bUseMarkup = TRUE;
attr.cImageFilePath = (gchar *)MY_APPLET_SHARE_DATA_DIR"/icon-task.png";
const gchar *cButtonsImage[3] = {"ok", NULL, NULL};
if (myData.pMissedTasks->next != NULL)
{
cButtonsImage[0] = "cancel";
cButtonsImage[1] = "next.png";
}
attr.cButtonsImage = cButtonsImage;
attr.pActionFunc = (CairoDockActionOnAnswerFunc)_on_next_missed_task;
attr.pUserData = myApplet;
attr.pFreeDataFunc = NULL;
attr.iTimeLength = 0;
attr.pIcon = myIcon;
attr.pContainer = myContainer;
gldi_dialog_new (&attr);
g_free (cMessage);
}
// display next task.
if (myData.pNextTask != NULL)
{
//g_print ("next task : %s\n", myData.pNextTask->cTitle);
struct tm st;
st.tm_min = myData.pNextTask->iMinute;
st.tm_hour = myData.pNextTask->iHour;
st.tm_mday = myData.pNextTask->iDay;
st.tm_mon = myData.pNextTask->iMonth;
st.tm_year = myData.pNextTask->iYear - 1900;
st.tm_sec = 0;
st.tm_isdst = myData.currentTime.tm_isdst;
time_t t = mktime (&st);
//g_print ("time : %ld, task : %ld\n", epoch, t);
if (t < epoch) // la tache est depassee.
{
// acknowledge this task
myData.pNextTask->bAcknowledged = TRUE;
myData.pBackend->update_task (myData.pNextTask, myApplet);
// look for next task.
myData.pNextTask = cd_clock_get_next_scheduled_task (myApplet);
}
else if (t < epoch + 15*60 && t >= epoch)
{
if (t < epoch + 60)
{
if (! myData.pNextTask->bFirstWarning)
{
//g_print ("first warning\n");
myData.pNextTask->bFirstWarning = TRUE;
gchar *cText = g_strdup_printf ("%s\n<b>%s</b>\n %s\n\n%s",
D_("It's time for the following task:"),
myData.pNextTask->cTitle?myData.pNextTask->cTitle:D_("No title"),
myData.pNextTask->cText?myData.pNextTask->cText:"",
D_("Repeat this message every:"));
_task_warning (myData.pNextTask, cText);
g_free (cText);
}
}
else if (! myData.pNextTask->b15mnWarning)
{
//g_print ("15 mn warning\n");
myData.pNextTask->b15mnWarning = TRUE;
gchar *cText = g_strdup_printf ("%s\n<b>%s</b>\n %s",
D_("This task will begin in 15 minutes:"),
myData.pNextTask->cTitle?myData.pNextTask->cTitle:D_("No title"),
myData.pNextTask->cText?myData.pNextTask->cText:"");
CairoDialogAttr attr;
memset (&attr, 0, sizeof (CairoDialogAttr));
attr.cText = (gchar *)cText;
attr.cImageFilePath = (gchar *)MY_APPLET_SHARE_DATA_DIR"/icon-task.png";
attr.iTimeLength = 60e3;
attr.bUseMarkup = TRUE;
attr.pIcon = myIcon;
attr.pContainer = myContainer;
gldi_dialog_new (&attr);
CD_APPLET_DEMANDS_ATTENTION (NULL, 60);
}
}
// display next anniversary if it is scheduled in less than 1 day, because anniversary require time to prepare.
if (myData.pNextAnniversary != NULL)
{
if (!myData.pNextAnniversary->b1DayWarning && ! myData.pNextAnniversary->bFirstWarning && ! myData.pNextAnniversary->b15mnWarning)
{
GDate* pCurrentDate = g_date_new_dmy (myData.currentTime.tm_mday, myData.currentTime.tm_mon + 1, myData.currentTime.tm_year+1900);
GDate* pAnnivDate = g_date_new_dmy (myData.pNextAnniversary->iDay, myData.pNextAnniversary->iMonth + 1, myData.currentTime.tm_year+1900);
gint iDaysToNextAnniversary = g_date_days_between (pCurrentDate, pAnnivDate);
if (iDaysToNextAnniversary >= 0 && iDaysToNextAnniversary <= 1)
{
myData.pNextAnniversary->b1DayWarning = TRUE;
gchar *cText = g_strdup_printf ("%s\n<b>%s</b>\n %s\n\n%s",
iDaysToNextAnniversary == 0 ? D_("Today is the following anniversary:") : D_("Tomorrow is the following anniversary:"),
myData.pNextTask->cTitle?myData.pNextTask->cTitle:D_("No title"),
myData.pNextTask->cText?myData.pNextTask->cText:"",
D_("Repeat this message every:"));
_task_warning (myData.pNextTask, cText);
g_free (cText);
myData.pNextAnniversary = cd_clock_get_next_anniversary (myApplet);
}
g_date_free (pCurrentDate);
g_date_free (pAnnivDate);
}
}
}
}
CD_APPLET_LEAVE(TRUE);
}
void
contacts_create_birthdays_window (GUI *appGUI)
{
GtkWidget *vbox1;
GtkWidget *hseparator;
GtkWidget *hbuttonbox;
GtkWidget *close_button;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkWidget *scrolledwindow;
gint i, n, id, age;
guint32 date;
gchar *text, buffer[BUFFER_SIZE], buff[BUFFER_SIZE];
GtkTreeIter iter, n_iter;
GDate *cdate_birthday, *cdate_current;
guint b_day, b_month, b_year;
guint c_day, c_month, c_year;
gboolean flag, leap;
cdate_birthday = g_date_new ();
g_return_if_fail (cdate_birthday != NULL);
cdate_current = g_date_new ();
g_return_if_fail (cdate_current != NULL);
i = n = 0;
while (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (appGUI->cnt->contacts_list_store), &iter, NULL, i++)) {
gtk_tree_model_get (GTK_TREE_MODEL (appGUI->cnt->contacts_list_store), &iter, COLUMN_BIRTH_DAY_DATE, &date, -1);
if (date) n++;
}
if (n == 0) {
gui_create_dialog (GTK_MESSAGE_INFO, _("No birthdays defined"), GTK_WINDOW (appGUI->main_window));
return;
}
appGUI->cnt->birthdays_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (appGUI->cnt->birthdays_window), _("Birthdays list"));
gtk_window_set_position (GTK_WINDOW (appGUI->cnt->birthdays_window), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_default_size (GTK_WINDOW (appGUI->cnt->birthdays_window),
config.contacts_birthdays_win_w, config.contacts_birthdays_win_h);
gtk_window_set_modal (GTK_WINDOW (appGUI->cnt->birthdays_window), TRUE);
g_signal_connect (G_OBJECT (appGUI->cnt->birthdays_window), "delete_event",
G_CALLBACK (birthdays_window_close_cb), appGUI);
gtk_window_set_transient_for (GTK_WINDOW (appGUI->cnt->birthdays_window), GTK_WINDOW (appGUI->main_window));
gtk_container_set_border_width (GTK_CONTAINER (appGUI->cnt->birthdays_window), 8);
g_signal_connect (G_OBJECT (appGUI->cnt->birthdays_window), "key_press_event",
G_CALLBACK (birthdays_key_press_cb), appGUI);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (appGUI->cnt->birthdays_window), vbox1);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow);
gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->cnt->birthdays_list_store = gtk_list_store_new (BIRTHDAYS_NUM_COLUMNS,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING,
G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
appGUI->cnt->birthdays_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (appGUI->cnt->birthdays_list_store));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (appGUI->cnt->birthdays_list), config.contacts_rules_hint);
gtk_widget_show (appGUI->cnt->birthdays_list);
GTK_WIDGET_SET_FLAGS (appGUI->cnt->birthdays_list, GTK_CAN_DEFAULT);
gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->cnt->birthdays_list);
appGUI->cnt->birthdays_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->cnt->birthdays_list));
g_signal_connect (G_OBJECT (appGUI->cnt->birthdays_list), "button_press_event",
G_CALLBACK (birthdays_list_dbclick_cb), appGUI);
/* create columns */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "xpad", 8, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", B_COLUMN_NAME, NULL);
gtk_tree_view_column_set_visible (column, TRUE);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (appGUI->cnt->birthdays_list), column);
gtk_tree_view_column_set_sort_column_id (column, B_COLUMN_NAME);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Days to birthday"), renderer, "text", B_COLUMN_DAYS_NUM, NULL);
gtk_tree_view_column_set_visible (column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (appGUI->cnt->birthdays_list), column);
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "xalign", 1.0, NULL);
g_object_set (G_OBJECT (renderer), "xpad", 8, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Days to birthday"), renderer, "text", B_COLUMN_DAYS, NULL);
gtk_tree_view_column_set_visible (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (appGUI->cnt->birthdays_list), column);
gtk_tree_view_column_set_sort_column_id (column, B_COLUMN_DAYS_NUM);
g_signal_emit_by_name (column, "clicked");
column = gtk_tree_view_column_new_with_attributes (_("Age"), renderer, "text", B_COLUMN_AGE, NULL);
gtk_tree_view_column_set_visible (column, config.visible_age_column);
gtk_tree_view_append_column (GTK_TREE_VIEW (appGUI->cnt->birthdays_list), column);
gtk_tree_view_column_set_sort_column_id (column, B_COLUMN_AGE);
column = gtk_tree_view_column_new_with_attributes (_("Birthday date"), renderer, "text", B_COLUMN_DATE, NULL);
gtk_tree_view_column_set_visible (column, config.visible_birthday_date_column);
gtk_tree_view_append_column (GTK_TREE_VIEW (appGUI->cnt->birthdays_list), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Zodiac sign"), renderer, "text", B_COLUMN_ZODIAC, NULL);
gtk_tree_view_column_set_visible (column, config.visible_zodiac_sign_column);
gtk_tree_view_append_column (GTK_TREE_VIEW (appGUI->cnt->birthdays_list), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("ID", renderer, "text", B_COLUMN_ID, NULL);
gtk_tree_view_column_set_visible (column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (appGUI->cnt->birthdays_list), column);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (appGUI->cnt->birthdays_list), FALSE);
i = 0;
g_date_set_julian (cdate_current, utl_get_current_julian ());
c_day = g_date_get_day (cdate_current);
c_month = g_date_get_month (cdate_current);
c_year = g_date_get_year (cdate_current);
while (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (appGUI->cnt->contacts_list_store), &iter, NULL, i++)) {
gtk_tree_model_get (GTK_TREE_MODEL (appGUI->cnt->contacts_list_store), &iter, COLUMN_BIRTH_DAY_DATE, &date, -1);
if (g_date_valid_julian (date)) {
/* calculate age */
g_date_set_julian (cdate_birthday, date);
b_day = g_date_get_day (cdate_birthday);
b_month = g_date_get_month (cdate_birthday);
b_year = g_date_get_year (cdate_birthday);
age = (gint) c_year - b_year;
if (b_month < c_month || (b_month == c_month && b_day < c_day)) age++;
if (age < 1) continue;
/* name */
flag = FALSE;
g_snprintf (buff, BUFFER_SIZE, "(%s)", _("None"));
gtk_tree_model_get (GTK_TREE_MODEL (appGUI->cnt->contacts_list_store), &iter, COLUMN_LAST_NAME, &text, -1);
if (text != NULL) {
flag = TRUE;
if (strcmp (text, buff) == 0) {
text[0] = '\0';
flag = FALSE;
}
g_strlcpy (buffer, text, BUFFER_SIZE);
g_free (text);
}
gtk_tree_model_get (GTK_TREE_MODEL (appGUI->cnt->contacts_list_store), &iter, COLUMN_FIRST_NAME, &text, -1);
if (text != NULL) {
if (strcmp (text, buff) == 0) {
text[0] = '\0';
}
if (flag == TRUE) {
g_strlcat (buffer, " ", BUFFER_SIZE);
g_strlcat (buffer, text, BUFFER_SIZE);
} else {
g_strlcpy (buffer, text, BUFFER_SIZE);
}
g_free (text);
}
gtk_tree_model_get (GTK_TREE_MODEL (appGUI->cnt->contacts_list_store), &iter, COLUMN_ID, &id, -1);
gtk_list_store_append (appGUI->cnt->birthdays_list_store, &n_iter);
gtk_list_store_set (appGUI->cnt->birthdays_list_store, &n_iter,
B_COLUMN_ID, id, B_COLUMN_NAME, buffer, B_COLUMN_AGE, age, -1);
/* calculate days to birthday */
b_year = c_year;
if ((b_month < c_month) || (b_month == c_month && b_day < c_day)) b_year++;
leap = FALSE;
if (g_date_valid_dmy (b_day, b_month, b_year) == FALSE) {
g_date_set_day (cdate_birthday, b_day - 1);
leap = TRUE;
}
g_date_set_year (cdate_birthday, b_year);
date = g_date_days_between (cdate_current, cdate_birthday);
if (date == 0) {
g_snprintf (buffer, BUFFER_SIZE, "%s", _("today"));
} else {
g_snprintf (buffer, BUFFER_SIZE, leap ? "%d + 1" : "%d", date);
}
g_date_strftime (buff, BUFFER_SIZE, "%A, ", cdate_birthday);
g_strlcat (buff, julian_to_str (g_date_get_julian (cdate_birthday), config.date_format), BUFFER_SIZE);
gtk_list_store_set (appGUI->cnt->birthdays_list_store, &n_iter,
B_COLUMN_DAYS_NUM, date, B_COLUMN_DAYS, buffer,
B_COLUMN_DATE, buff, B_COLUMN_ZODIAC, utl_get_zodiac_name (b_day, b_month), -1);
}
}
g_date_free (cdate_birthday);
g_date_free (cdate_current);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);
hbuttonbox = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox), 4);
if (config.default_stock_icons) {
close_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
} else {
close_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_CLOSE);
}
gtk_widget_show (close_button);
g_signal_connect (close_button, "clicked", G_CALLBACK (button_birthdays_window_close_cb), appGUI);
gtk_container_add (GTK_CONTAINER (hbuttonbox), close_button);
gtk_widget_show (appGUI->cnt->birthdays_window);
gtk_widget_grab_focus (close_button);
}
static struct stats_record *process_file(struct stats_iter *iter,
struct stats_file *temp_file,
struct stats_record *cur,
GDate *date_change_step_size,
int account_period_offset)
{
struct stats_record *home, *roaming;
struct stats_record *next;
home = NULL;
roaming = NULL;
if (!cur)
cur = get_next_record(iter);
next = get_next_record(iter);
while (next) {
GDate date_cur;
GDate date_next;
int append;
append = FALSE;
if (cur->roaming)
roaming = cur;
else
home = cur;
g_date_set_time_t(&date_cur, cur->ts);
g_date_set_time_t(&date_next, next->ts);
if (g_date_compare(&date_cur, date_change_step_size) < 0) {
/* month period size */
GDateDay day_cur, day_next;
GDateMonth month_cur, month_next;
month_cur = g_date_get_month(&date_cur);
month_next = g_date_get_month(&date_next);
day_cur = g_date_get_day(&date_cur);
day_next = g_date_get_day(&date_next);
if (day_cur == day_next && month_cur != month_next)
append = TRUE;
else if (day_cur < account_period_offset
&& day_next >= account_period_offset)
append = TRUE;
} else {
/* day period size */
if (g_date_days_between(&date_cur, &date_next) > 0)
append = TRUE;
}
if (append) {
if (home) {
append_record(temp_file, home);
home = NULL;
}
if (roaming) {
append_record(temp_file, roaming);
roaming = NULL;
}
}
cur = next;
next = get_next_record(iter);
}
return cur;
}
static void
load_chain (PatrolDialogWindow *self, PatrolDialogRecord *r,
guint idx, GtkWidget *container)
{
/* build tree model */
GtkTreeStore *tree_store = gtk_tree_store_new(COLS_NUM, G_TYPE_STRING,
G_TYPE_BOOLEAN, G_TYPE_INT,
G_TYPE_POINTER, G_TYPE_POINTER);
GtkTreeIter *parent = NULL, iter;
gint i, num_certs = gcr_certificate_chain_get_length(r->chain);
GcrCertificate *cert = NULL;
for (i = num_certs - 1; i >= 0; i--) {
cert = gcr_certificate_chain_get_certificate(r->chain, i);
gchar *label = gcr_certificate_get_subject_name(cert);
gtk_tree_store_append(tree_store, &iter, parent);
gtk_tree_store_set(tree_store, &iter,
COL_NAME, label,
COL_PIN, i == r->pin_level,
COL_PIN_LEVEL, i,
COL_CERT, cert,
COL_REC, r,
-1);
parent = &iter;
g_free(label);
}
/* set hierarchy title */
GtkWidget *title_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(container), title_box, FALSE, FALSE, 0);
gchar *text, *str;
GtkWidget *label = gtk_label_new(NULL);
GtkWidget *value;
if (idx == 0) {
switch (self->pv->result) {
case PATROL_VERIFY_NEW:
case PATROL_VERIFY_CHANGE:
text = g_strdup_printf("<b>%s</b>", _("New Certificate"));
break;
case PATROL_VERIFY_REJECT:
text = g_strdup_printf("<b>%s</b>", _("Rejected Certificate"));
break;
default:
text = g_strdup_printf("<b>%s</b>", _("Selected Certificate"));
break;
}
} else {
text = g_strdup_printf("<b>%s #%d</b>", _("Stored Certificate"), idx);
gtk_widget_set_margin_bottom(GTK_WIDGET(label), 2);
}
gtk_label_set_markup(GTK_LABEL(label), text);
g_free(text);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_box_pack_start(GTK_BOX(title_box), label, FALSE, FALSE, 0);
GtkWidget *grid = gtk_grid_new();
gtk_widget_set_margin_left(GTK_WIDGET(grid), 5);
gtk_box_pack_start(GTK_BOX(title_box), grid, FALSE, FALSE, 0);
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), _("Seen: "));
str = g_strdup_printf("%" G_GINT64_FORMAT, r->rec.count_seen);
text = g_strdup_printf(g_dngettext(textdomain(NULL),
"%s time", "%s times",
r->rec.count_seen), str);
g_free(str);
value = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(value), text);
g_free(text);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(value), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid), value, 1, 0, 1, 1);
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), _("First seen: "));
GDateTime *dtime = g_date_time_new_from_unix_local(r->rec.first_seen);
text = g_date_time_format(dtime, "%c");
g_date_time_unref(dtime);
value = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(value), text);
g_free(text);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(value), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid), value, 1, 1, 1, 1);
if (r->rec.first_seen != r->rec.last_seen) {
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), _("Last seen: "));
dtime = g_date_time_new_from_unix_local(r->rec.last_seen);
text = g_date_time_format(dtime, "%c");
g_date_time_unref(dtime);
value = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(value), text);
g_free(text);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(value), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(grid), value, 1, 2, 1, 1);
}
if (cert) {
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), _("Validity: "));
GDate *expiry = gcr_certificate_get_expiry_date(cert);
GDate *now = g_date_new();
g_date_set_time_t(now, time(NULL));
gint diff = g_date_days_between(now, expiry);
g_date_free(now);
g_date_free(expiry);
if (diff > 0) {
text = g_strdup_printf(g_dngettext(textdomain(NULL),
"Certificate is valid for %d more day",
"Certificate is valid for %d more days",
diff), diff);
} else if (diff < 0) {
diff = abs(diff);
text = g_strdup_printf(g_dngettext(textdomain(NULL),
"Certificate <b>expired</b> %d day ago",
"Certificate <b>expired</b> %d days ago",
diff), diff);
} else {
text = g_strdup_printf("Certificate expires today");
}
value = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(value), text);
g_free(text);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(value), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(grid), value, 1, 3, 1, 1);
}
gtk_widget_show_all(title_box);
/* build tree view */
GtkWidget *tree_view;
tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_store));
gtk_tree_view_expand_all(GTK_TREE_VIEW(tree_view));
gtk_box_pack_start(GTK_BOX(container), tree_view, FALSE, FALSE, 0);
gtk_widget_show(tree_view);
g_signal_connect(tree_view, "focus-in-event",
G_CALLBACK(on_tree_view_focus), self);
g_signal_connect(self->pv->renderer, "data-changed",
G_CALLBACK(on_cert_changed), tree_view);
GtkTreeSelection *tree_sel
= gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
g_signal_connect(tree_sel, "changed",
G_CALLBACK(on_tree_selection_changed), self);
if (idx == 0) // new chain
gtk_tree_selection_select_iter(tree_sel, &iter);
/* first column */
GtkCellRenderer *tree_renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn *tree_column
= gtk_tree_view_column_new_with_attributes(_("Certificate Hierarchy"),
tree_renderer, "text",
COL_NAME, NULL);
gtk_tree_view_column_set_expand (tree_column, TRUE);
gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), tree_column, -1);
/* second column */
GtkCellRenderer *toggle_renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(toggle_renderer, "toggled",
G_CALLBACK(on_radio_toggled), tree_store);
gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(toggle_renderer),
TRUE);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree_view), -1,
_("Pin"), toggle_renderer,
"active", COL_PIN, NULL);
g_object_unref(tree_store);
}
gboolean
e_reap_trash_directory_sync (GFile *trash_directory,
gint expiry_in_days,
GCancellable *cancellable,
GError **error)
{
GFileEnumerator *file_enumerator;
GQueue directories = G_QUEUE_INIT;
GFile *reaping_directory;
GFileInfo *file_info;
const gchar *attributes;
gboolean success = TRUE;
GError *local_error = NULL;
g_return_val_if_fail (G_IS_FILE (trash_directory), FALSE);
g_return_val_if_fail (expiry_in_days > 0, FALSE);
reaping_directory = g_file_get_child (
trash_directory, REAPING_DIRECTORY_NAME);
attributes =
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_TIME_MODIFIED;
file_enumerator = g_file_enumerate_children (
trash_directory, attributes,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
cancellable, error);
if (file_enumerator == NULL)
return FALSE;
file_info = g_file_enumerator_next_file (
file_enumerator, cancellable, &local_error);
while (file_info != NULL) {
GFileType file_type;
GTimeVal mtime;
GDate *date_now;
GDate *date_mtime;
const gchar *name;
gboolean reap_it;
gint days_old;
name = g_file_info_get_name (file_info);
file_type = g_file_info_get_file_type (file_info);
g_file_info_get_modification_time (file_info, &mtime);
/* Calculate how many days ago the file was modified. */
date_now = g_date_new ();
g_date_set_time_t (date_now, time (NULL));
date_mtime = g_date_new ();
g_date_set_time_val (date_mtime, &mtime);
days_old = g_date_days_between (date_mtime, date_now);
g_date_free (date_mtime);
g_date_free (date_now);
reap_it =
(file_type == G_FILE_TYPE_DIRECTORY) &&
(days_old >= expiry_in_days);
if (reap_it) {
GFile *child;
child = g_file_get_child (trash_directory, name);
/* If we find an unfinished reaping directory, put
* it on the head of the queue so we reap it first. */
if (g_file_equal (child, reaping_directory))
g_queue_push_head (&directories, child);
else
g_queue_push_tail (&directories, child);
}
g_object_unref (file_info);
file_info = g_file_enumerator_next_file (
file_enumerator, cancellable, &local_error);
}
if (local_error != NULL) {
g_propagate_error (error, local_error);
success = FALSE;
}
g_object_unref (file_enumerator);
/* Now delete the directories we've queued up. */
while (success && !g_queue_is_empty (&directories)) {
GFile *directory;
directory = g_queue_pop_head (&directories);
/* First we rename the directory to prevent it
* from being recovered while being deleted. */
if (!g_file_equal (directory, reaping_directory))
success = g_file_move (
directory, reaping_directory,
G_FILE_COPY_NONE, cancellable,
NULL, NULL, error);
if (success)
success = e_file_recursive_delete_sync (
reaping_directory, cancellable, error);
g_object_unref (directory);
}
/* Flush the queue in case we aborted on an error. */
while (!g_queue_is_empty (&directories))
g_object_unref (g_queue_pop_head (&directories));
g_object_unref (reaping_directory);
return success;
}