static void
gtk_message_row_update (GtkMessageRow *row)
{
GtkMessageRowPrivate *priv = row->priv;
GDateTime *t;
char *s;
gtk_label_set_text (priv->source_name, priv->message->sender_name);
gtk_label_set_text (priv->source_nick, priv->message->sender_nick);
gtk_label_set_text (priv->content_label, priv->message->message);
t = g_date_time_new_from_unix_utc (priv->message->time);
s = g_date_time_format (t, "%e %b %y");
gtk_label_set_text (priv->short_time_label, s);
g_free (s);
s = g_date_time_format (t, "%X - %e %b %Y");
gtk_label_set_text (priv->detailed_time_label, s);
g_free (s);
g_date_time_unref (t);
gtk_widget_set_visible (GTK_WIDGET(priv->n_favorites_label),
priv->message->n_favorites != 0);
s = g_strdup_printf ("<b>%d</b>\nFavorites", priv->message->n_favorites);
gtk_label_set_markup (priv->n_favorites_label, s);
g_free (s);
gtk_widget_set_visible (GTK_WIDGET(priv->n_reshares_label),
priv->message->n_reshares != 0);
s = g_strdup_printf ("<b>%d</b>\nReshares", priv->message->n_reshares);
gtk_label_set_markup (priv->n_reshares_label, s);
g_free (s);
gtk_widget_set_visible (GTK_WIDGET (priv->resent_box), priv->message->resent_by != NULL);
if (priv->message->resent_by)
gtk_button_set_label (GTK_BUTTON (priv->resent_by_button), priv->message->resent_by);
if (strcmp (priv->message->sender_nick, "@GTKtoolkit") == 0)
{
gtk_image_set_from_icon_name (priv->avatar_image, "gtk3-demo");
gtk_image_set_icon_size (priv->avatar_image, GTK_ICON_SIZE_LARGE);
}
else
gtk_image_set_from_pixbuf (priv->avatar_image, avatar_pixbuf_other);
}
static gchar *
format_timestamp (guint64 timestamp,
GError **error)
{
GDateTime *dt;
gchar *str;
dt = g_date_time_new_from_unix_utc (timestamp);
if (dt == NULL)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Invalid timestamp: %" G_GUINT64_FORMAT, timestamp);
return NULL;
}
str = g_date_time_format (dt, "%Y-%m-%d %H:%M:%S +0000");
g_date_time_unref (dt);
return str;
}
static void
update_last_used (CEPageDetails *page, NMConnection *connection)
{
gchar *last_used = NULL;
GDateTime *now = NULL;
GDateTime *then = NULL;
gint days;
GTimeSpan diff;
guint64 timestamp;
NMSettingConnection *s_con;
s_con = nm_connection_get_setting_connection (connection);
if (s_con == NULL)
goto out;
timestamp = nm_setting_connection_get_timestamp (s_con);
if (timestamp == 0) {
last_used = g_strdup (_("Never"));
goto out;
}
/* calculate the amount of time that has elapsed */
now = g_date_time_new_now_utc ();
then = g_date_time_new_from_unix_utc (timestamp);
diff = g_date_time_difference (now, then);
days = diff / G_TIME_SPAN_DAY;
if (days == 0)
last_used = g_strdup (_("Today"));
else if (days == 1)
last_used = g_strdup (_("Yesterday"));
else
last_used = g_strdup_printf (ngettext ("%i day ago", "%i days ago", days), days);
out:
panel_set_device_widget_details (CE_PAGE (page)->builder, "last_used", last_used);
if (now != NULL)
g_date_time_unref (now);
if (then != NULL)
g_date_time_unref (then);
g_free (last_used);
}
static gchar *
get_last_used_string (NMConnection *connection)
{
gchar *last_used = NULL;
GDateTime *now = NULL;
GDateTime *then = NULL;
gint days;
GTimeSpan diff;
guint64 timestamp;
NMSettingConnection *s_con;
s_con = nm_connection_get_setting_connection (connection);
if (s_con == NULL)
goto out;
timestamp = nm_setting_connection_get_timestamp (s_con);
if (timestamp == 0) {
last_used = g_strdup (_("never"));
goto out;
}
/* calculate the amount of time that has elapsed */
now = g_date_time_new_now_utc ();
then = g_date_time_new_from_unix_utc (timestamp);
diff = g_date_time_difference (now, then);
days = diff / G_TIME_SPAN_DAY;
if (days == 0)
last_used = g_strdup (_("today"));
else if (days == 1)
last_used = g_strdup (_("yesterday"));
else
last_used = g_strdup_printf (ngettext ("%i day ago", "%i days ago", days), days);
out:
if (now != NULL)
g_date_time_unref (now);
if (then != NULL)
g_date_time_unref (then);
return last_used;
}
gchar *
empathy_time_to_string_relative (gint64 t)
{
GDateTime *now, *then;
gint seconds;
GTimeSpan delta;
gchar *result;
now = g_date_time_new_now_utc ();
then = g_date_time_new_from_unix_utc (t);
delta = g_date_time_difference (now, then);
seconds = delta / G_TIME_SPAN_SECOND;
if (seconds > 0)
result = empathy_duration_to_string (seconds);
else
result = g_strdup (_("in the future"));
g_date_time_unref (now);
g_date_time_unref (then);
return result;
}
static void
message_cb (TpMessage *message)
{
TpContact *sender = tp_signalled_message_get_sender (message);
GDateTime *received = g_date_time_new_from_unix_utc (
tp_message_get_received_timestamp (message));
gchar *timestamp = g_date_time_format (received, "%Y-%m-%d %H:%M:%S");
const gchar *sender_identifier = tp_contact_get_identifier (sender);
const gchar *sender_alias = tp_contact_get_alias (sender);
if (!writer.first) {
g_print ("\n\n");
} else {
writer.first = 0;
}
printf ("Message-Token: %s\n", tp_message_get_token (message));
printf ("From: \"%s\" <%s>\n", sender_alias, sender_identifier);
printf ("Date: %s\n\n", timestamp);
g_free (timestamp);
unsigned int parts = tp_message_count_parts (message);
for (unsigned int i = 1; i < parts; i++) {
const GHashTable *part = tp_message_peek (message, i);
const gchar *content_type = g_value_get_string (
g_hash_table_lookup ((GHashTable*)part, "content-type"));
const gchar *content = g_value_get_string (
g_hash_table_lookup ((GHashTable*)part, "content"));
if (verbose) {
printf ("- #%d %s\n", i, content_type);
}
printf ("%s\n", content);
}
}
/**
* gl_util_timestamp_to_display:
* @microsecs: number of microseconds since the Unix epoch in UTC
* @now: the time to compare with
* @format: clock format (12 or 24 hour)
*
* Return a human readable time, corresponding to @microsecs, using an
* appropriate @format after comparing it to @now and discarding unnecessary
* elements (for example, return only time if the date is today).
*
* Returns: a newly-allocated human readable string which represents @microsecs
*/
gchar *
gl_util_timestamp_to_display (guint64 microsecs,
GDateTime *now,
GlUtilClockFormat format,
gboolean show_second)
{
GDateTime *datetime;
GDateTime *local;
gchar *time = NULL;
datetime = g_date_time_new_from_unix_utc (microsecs / G_TIME_SPAN_SECOND);
if (datetime == NULL)
{
g_warning ("Error converting timestamp to time value");
goto out;
}
local = g_date_time_to_local (datetime);
switch (format)
{
case GL_UTIL_CLOCK_FORMAT_12HR:
switch (compare_timestamps (local, now))
{
case GL_UTIL_TIMESTAMPS_SAME_DAY:
if (show_second)
{
/* Translators: timestamp format for events on the
* current day, showing the time with seconds in
* 12-hour format. */
time = g_date_time_format (local, _("%l:%M:%S %p"));
}
else
{
/* Translators: timestamp format for events on the
* current day, showing the time without seconds in
* 12-hour format. */
time = g_date_time_format (local, _("%l:%M %p"));
}
break;
case GL_UTIL_TIMESTAMPS_SAME_YEAR:
if (show_second)
{
time = g_date_time_format (local,
/* Translators: timestamp format for events in
* the current year, showing the abbreviated
* month name, day of the month and the time
* with seconds in 12-hour format. */
_("%b %e %l:%M:%S %p"));
}
else
{
/* Translators: timestamp format for events in the
* current year, showing the abbreviated month name,
* day of the month and the time without seconds in
* 12-hour format. */
time = g_date_time_format (local, _("%b %e %l:%M %p"));
}
break;
case GL_UTIL_TIMESTAMPS_DIFFERENT_YEAR:
if (show_second)
{
time = g_date_time_format (local,
/* Translators: timestamp format for events in
* a different year, showing the abbreviated
* month name, day of the month, year and the
* time with seconds in 12-hour format. */
_("%b %e %Y %l:%M:%S %p"));
}
else
{
time = g_date_time_format (local,
/* Translators: timestamp format for events in
* a different year, showing the abbreviated
* month name day of the month, year and the
* time without seconds in 12-hour format. */
_("%b %e %Y %l:%M %p"));
}
break;
default:
g_assert_not_reached ();
}
break;
case GL_UTIL_CLOCK_FORMAT_24HR:
switch (compare_timestamps (local, now))
{
case GL_UTIL_TIMESTAMPS_SAME_DAY:
if (show_second)
{
/* Translators: timestamp format for events on the
* current day, showing the time with seconds in
* 24-hour format. */
time = g_date_time_format (local, _("%H:%M:%S"));
}
else
{
/* Translators: timestamp format for events on the
* current day, showing the time without seconds in
* 24-hour format. */
time = g_date_time_format (local, _("%H:%M"));
}
break;
case GL_UTIL_TIMESTAMPS_SAME_YEAR:
if (show_second)
{
/* Translators: timestamp format for events in the
* current year, showing the abbreviated month name,
* day of the month and the time with seconds in
* 24-hour format. */
time = g_date_time_format (local, _("%b %e %H:%M:%S"));
}
else
{
/* Translators: timestamp format for events in the
* current year, showing the abbreviated month name,
* day of the month and the time without seconds in
* 24-hour format. */
time = g_date_time_format (local, _("%b %e %H:%M"));
}
break;
case GL_UTIL_TIMESTAMPS_DIFFERENT_YEAR:
if (show_second)
{
time = g_date_time_format (local,
/* Translators: timestamp format for events in
* a different year, showing the abbreviated
* month name, day of the month, year and the
* time with seconds in 24-hour format. */
_("%b %e %Y %H:%M:%S"));
}
else
{
/* Translators: timestamp format for events in a
* different year, showing the abbreviated month name,
* day of the month, year and the time without seconds
* in 24-hour format. */
time = g_date_time_format (local, _("%b %e %Y %H:%M"));
}
break;
default:
g_assert_not_reached ();
}
break;
default:
g_assert_not_reached ();
}
g_date_time_unref (datetime);
g_date_time_unref (local);
if (time == NULL)
{
g_warning ("Error converting datetime to string");
}
out:
return time;
}
static AsReview *
gs_plugin_odrs_parse_review_object (GsPlugin *plugin, JsonObject *item)
{
AsReview *rev = as_review_new ();
/* date */
if (json_object_has_member (item, "date_created")) {
gint64 timestamp;
g_autoptr(GDateTime) dt = NULL;
timestamp = json_object_get_int_member (item, "date_created");
dt = g_date_time_new_from_unix_utc (timestamp);
as_review_set_date (rev, dt);
}
/* assemble review */
if (json_object_has_member (item, "rating"))
as_review_set_rating (rev, (gint) json_object_get_int_member (item, "rating"));
if (json_object_has_member (item, "score")) {
as_review_set_priority (rev, (gint) json_object_get_int_member (item, "score"));
} else if (json_object_has_member (item, "karma_up") &&
json_object_has_member (item, "karma_down")) {
gdouble ku = (gdouble) json_object_get_int_member (item, "karma_up");
gdouble kd = (gdouble) json_object_get_int_member (item, "karma_down");
gdouble wilson = 0.f;
/* from http://www.evanmiller.org/how-not-to-sort-by-average-rating.html */
if (ku > 0 || kd > 0) {
wilson = ((ku + 1.9208) / (ku + kd) -
1.96 * sqrt ((ku * kd) / (ku + kd) + 0.9604) /
(ku + kd)) / (1 + 3.8416 / (ku + kd));
wilson *= 100.f;
}
as_review_set_priority (rev, (gint) wilson);
}
if (json_object_has_member (item, "user_hash"))
as_review_set_reviewer_id (rev, json_object_get_string_member (item, "user_hash"));
if (json_object_has_member (item, "user_display"))
as_review_set_reviewer_name (rev, json_object_get_string_member (item, "user_display"));
if (json_object_has_member (item, "summary"))
as_review_set_summary (rev, json_object_get_string_member (item, "summary"));
if (json_object_has_member (item, "description"))
as_review_set_description (rev, json_object_get_string_member (item, "description"));
if (json_object_has_member (item, "version"))
as_review_set_version (rev, json_object_get_string_member (item, "version"));
/* add extra metadata for the plugin */
if (json_object_has_member (item, "user_skey")) {
as_review_add_metadata (rev, "user_skey",
json_object_get_string_member (item, "user_skey"));
}
if (json_object_has_member (item, "app_id")) {
as_review_add_metadata (rev, "app_id",
json_object_get_string_member (item, "app_id"));
}
if (json_object_has_member (item, "review_id")) {
g_autofree gchar *review_id = NULL;
review_id = g_strdup_printf ("%" G_GINT64_FORMAT,
json_object_get_int_member (item, "review_id"));
as_review_set_id (rev, review_id);
}
/* don't allow multiple votes */
if (json_object_has_member (item, "vote_id"))
as_review_add_flags (rev, AS_REVIEW_FLAG_VOTED);
return rev;
}
GstDateTime *
gst_date_time_new_from_unix_epoch_utc (gint64 secs)
{
return
gst_date_time_new_from_gdatetime (g_date_time_new_from_unix_utc (secs));
}
/**
* vik_datetime_edit_dialog:
* @parent: The parent window
* @title: The title to use for the dialog
* @initial_time: The inital date/time to be shown
* @tz: The #GTimeZone this dialog will operate in
*
* Returns: A time selected by the user via this dialog
* Even though a time of zero is notionally valid - consider it unlikely to be actually wanted!
* Thus if the time is zero then the dialog was cancelled or somehow an invalid date was encountered.
*/
time_t vik_datetime_edit_dialog ( GtkWindow *parent, const gchar *title, time_t initial_time, GTimeZone *tz )
{
g_return_val_if_fail ( tz, 0 );
GtkWidget *dialog = gtk_dialog_new_with_buttons ( title,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL );
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
#endif
GtkWidget *label;
GtkWidget *cal = gtk_calendar_new ();
// Set according to the given date/time + timezone for display
GDateTime *gdt_in = g_date_time_new_from_unix_utc ( (gint64)initial_time );
GDateTime *gdt_tz = g_date_time_to_timezone ( gdt_in, tz );
g_date_time_unref ( gdt_in );
gtk_calendar_select_month ( GTK_CALENDAR(cal), g_date_time_get_month(gdt_tz)-1, g_date_time_get_year (gdt_tz) );
gtk_calendar_select_day ( GTK_CALENDAR(cal), g_date_time_get_day_of_month(gdt_tz) );
GtkWidget *hbox_time = gtk_hbox_new ( FALSE, 1 );
label = gtk_label_new ( g_date_time_get_timezone_abbreviation(gdt_tz) );
gtk_box_pack_start ( GTK_BOX(hbox_time), label, FALSE, FALSE, 5 );
GtkWidget *sb_hours = gtk_spin_button_new_with_range ( 0.0, 23.0, 1.0 );
gtk_box_pack_start ( GTK_BOX(hbox_time), sb_hours, FALSE, FALSE, 0 );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(sb_hours), g_date_time_get_hour(gdt_tz) );
g_signal_connect ( sb_hours, "output", G_CALLBACK(on_output), NULL );
label = gtk_label_new ( ":" );
gtk_box_pack_start ( GTK_BOX(hbox_time), label, FALSE, FALSE, 0 );
GtkWidget *sb_minutes = gtk_spin_button_new_with_range ( 0.0, 59.0, 1.0 );
gtk_box_pack_start ( GTK_BOX(hbox_time), sb_minutes, FALSE, FALSE, 0);
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(sb_minutes), g_date_time_get_minute(gdt_tz) );
g_signal_connect ( sb_minutes, "output", G_CALLBACK(on_output), NULL );
label = gtk_label_new ( ":" );
gtk_box_pack_start(GTK_BOX(hbox_time), label, FALSE, FALSE, 0);
GtkWidget *sb_seconds = gtk_spin_button_new_with_range ( 0.0, 59.0, 1.0 );
gtk_box_pack_start ( GTK_BOX(hbox_time), sb_seconds, FALSE, FALSE, 0 );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(sb_seconds), g_date_time_get_second(gdt_tz) );
g_signal_connect ( sb_seconds, "output", G_CALLBACK(on_output), NULL );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), cal, FALSE, FALSE, 0 );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), hbox_time, FALSE, FALSE, 5 );
if ( response_w )
gtk_widget_grab_focus ( response_w );
g_date_time_unref ( gdt_tz );
gtk_widget_show_all ( dialog );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
gtk_widget_destroy ( dialog );
return 0;
}
// Read values
guint year = 0;
guint month = 0;
guint day = 0;
guint hours = 0;
guint minutes = 0;
guint seconds = 0;
gtk_calendar_get_date ( GTK_CALENDAR(cal), &year, &month, &day );
hours = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(sb_hours) );
minutes = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(sb_minutes) );
seconds = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(sb_seconds) );
gtk_widget_destroy(dialog);
time_t ans = initial_time;
GDateTime *gdt_ans = g_date_time_new ( tz, year, month+1, day, hours, minutes, (gdouble)seconds );
if ( gdt_ans ) {
ans = g_date_time_to_unix ( gdt_ans );
g_date_time_unref ( gdt_ans );
}
return ans;
}
void
rpmhdrs_diff_prnt_block (gboolean changelogs, struct RpmHeadersDiff *diff)
{
int num = 0;
g_assert (diff->hs_mod_old->len == diff->hs_mod_new->len);
if (diff->hs_mod_old->len)
{
gboolean done = FALSE;
for (num = 0; num < diff->hs_mod_new->len; ++num)
{
Header ho = diff->hs_mod_old->pdata[num];
Header hn = diff->hs_mod_new->pdata[num];
struct rpmtd_s ochanges_date_s;
_cleanup_rpmtddata_ rpmtd ochanges_date = NULL;
struct rpmtd_s ochanges_name_s;
_cleanup_rpmtddata_ rpmtd ochanges_name = NULL;
struct rpmtd_s ochanges_text_s;
_cleanup_rpmtddata_ rpmtd ochanges_text = NULL;
struct rpmtd_s nchanges_date_s;
_cleanup_rpmtddata_ rpmtd nchanges_date = NULL;
struct rpmtd_s nchanges_name_s;
_cleanup_rpmtddata_ rpmtd nchanges_name = NULL;
struct rpmtd_s nchanges_text_s;
_cleanup_rpmtddata_ rpmtd nchanges_text = NULL;
int ocnum = 0;
int ncnum = 0;
uint64_t ochange_date = 0;
const char *ochange_name = NULL;
const char *ochange_text = NULL;
uint64_t nchange_date = 0;
const char *nchange_name = NULL;
const char *nchange_text = NULL;
g_assert (!header_name_cmp (ho, hn));
if (rpmVersionCompare (ho, hn) > 0)
continue;
if (!done)
{
done = TRUE;
g_print ("Upgraded:\n");
}
printf (" ");
pkg_print (hn);
if (!changelogs)
continue;
/* Load the old %changelog entries */
ochanges_date = &ochanges_date_s;
headerGet (ho, RPMTAG_CHANGELOGTIME, ochanges_date, HEADERGET_MINMEM);
ochanges_name = &ochanges_name_s;
headerGet (ho, RPMTAG_CHANGELOGNAME, ochanges_name, HEADERGET_MINMEM);
ochanges_text = &ochanges_text_s;
headerGet (ho, RPMTAG_CHANGELOGTEXT, ochanges_text, HEADERGET_MINMEM);
ocnum = rpmtdCount (ochanges_date);
if (!ocnum)
continue;
/* Load the new %changelog entries */
nchanges_date = &nchanges_date_s;
headerGet (hn, RPMTAG_CHANGELOGTIME, nchanges_date, HEADERGET_MINMEM);
nchanges_name = &nchanges_name_s;
headerGet (hn, RPMTAG_CHANGELOGNAME, nchanges_name, HEADERGET_MINMEM);
nchanges_text = &nchanges_text_s;
headerGet (hn, RPMTAG_CHANGELOGTEXT, nchanges_text, HEADERGET_MINMEM);
ncnum = rpmtdCount (nchanges_date);
if (!ncnum)
continue;
/* Load the latest old %changelog entry. */
ochange_date = rpmtdGetNumber (ochanges_date);
ochange_name = rpmtdGetString (ochanges_name);
ochange_text = rpmtdGetString (ochanges_text);
while (ncnum > 0)
{
GDateTime *dt = NULL;
g_autofree char *date_time_str = NULL;
/* Load next new %changelog entry, starting at the newest. */
rpmtdNext (nchanges_date);
rpmtdNext (nchanges_name);
rpmtdNext (nchanges_text);
nchange_date = rpmtdGetNumber (nchanges_date);
nchange_name = rpmtdGetString (nchanges_name);
nchange_text = rpmtdGetString (nchanges_text);
/* If we are now older than, or match, the latest old %changelog
* then we are done. */
if (ochange_date > nchange_date)
break;
if ((ochange_date == nchange_date) &&
g_str_equal (ochange_name, nchange_name) &&
g_str_equal (ochange_text, nchange_text))
break;
/* Otherwise, print. */
dt = g_date_time_new_from_unix_utc (nchange_date);
date_time_str = g_date_time_format (dt, "%a %b %d %Y");
g_date_time_unref (dt);
printf ("* %s %s\n%s\n\n", date_time_str, nchange_name,
nchange_text);
--ncnum;
}
}
done = FALSE;
for (num = 0; num < diff->hs_mod_new->len; ++num)
{
Header ho = diff->hs_mod_old->pdata[num];
Header hn = diff->hs_mod_new->pdata[num];
g_assert (!header_name_cmp (ho, hn));
if (rpmVersionCompare (ho, hn) < 0)
continue;
if (!done)
{
done = TRUE;
g_print ("Downgraded:\n");
}
printf (" ");
pkg_print (hn);
}
}
if (diff->hs_del->len)
{
g_print ("Removed:\n");
for (num = 0; num < diff->hs_del->len; ++num)
{
Header hd = diff->hs_del->pdata[num];
printf (" ");
pkg_print (hd);
}
}
if (diff->hs_add->len)
{
g_print ("Added:\n");
for (num = 0; num < diff->hs_add->len; ++num)
{
Header ha = diff->hs_add->pdata[num];
printf (" ");
pkg_print (ha);
}
}
rpmhdrs_diff_free (diff);
}
// this is a poor man's mock of g_date_time_new_now_utc :)
GDateTime*
g_date_time_new_now_utc(void)
{
return g_date_time_new_from_unix_utc(1234567890);
}
static void
add_location_app (CcPrivacyPanel *self,
const gchar *app_id,
gboolean enabled,
gint64 last_used)
{
CcPrivacyPanelPrivate *priv = self->priv;
GDesktopAppInfo *app_info;
char *desktop_id;
GtkWidget *box, *row, *w;
GIcon *icon;
GDateTime *t;
char *last_used_str;
LocationAppStateData *data;
w = g_hash_table_lookup (priv->location_app_switches, app_id);
if (w != NULL)
{
gtk_switch_set_active (GTK_SWITCH (w), enabled);
return;
}
desktop_id = g_strdup_printf ("%s.desktop", app_id);
app_info = g_desktop_app_info_new (desktop_id);
g_free (desktop_id);
if (app_info == NULL)
return;
row = gtk_list_box_row_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_margin_start (box, 12);
gtk_widget_set_margin_end (box, 6);
gtk_widget_set_margin_top (box, 12);
gtk_widget_set_margin_bottom (box, 12);
gtk_container_add (GTK_CONTAINER (row), box);
gtk_widget_set_hexpand (box, TRUE);
gtk_container_add (GTK_CONTAINER (priv->location_apps_list_box), row);
icon = g_app_info_get_icon (G_APP_INFO (app_info));
w = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_widget_set_halign (w, GTK_ALIGN_CENTER);
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_size_group_add_widget (priv->location_icon_size_group, w);
gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 0);
w = gtk_label_new (g_app_info_get_name (G_APP_INFO (app_info)));
gtk_widget_set_margin_start (w, 12);
gtk_widget_set_margin_end (w, 12);
gtk_widget_set_halign (w, GTK_ALIGN_START);
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_label_set_xalign (GTK_LABEL (w), 0);
gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 0);
t = g_date_time_new_from_unix_utc (last_used);
last_used_str = cc_util_get_smart_date (t);
w = gtk_label_new (last_used_str);
g_free (last_used_str);
gtk_style_context_add_class (gtk_widget_get_style_context (w), "dim-label");
gtk_widget_set_margin_start (w, 12);
gtk_widget_set_margin_end (w, 12);
gtk_widget_set_halign (w, GTK_ALIGN_END);
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (box), w, TRUE, TRUE, 0);
w = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (w), enabled);
gtk_widget_set_halign (w, GTK_ALIGN_END);
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 0);
g_settings_bind (priv->location_settings, LOCATION_ENABLED,
w, "sensitive",
G_SETTINGS_BIND_DEFAULT);
g_hash_table_insert (priv->location_app_switches,
g_strdup (app_id),
g_object_ref (w));
data = g_slice_new (LocationAppStateData);
data->self = self;
data->app_id = g_strdup (app_id);
data->widget = w;
data->changing_state = FALSE;
g_signal_connect_data (G_OBJECT (w),
"state-set",
G_CALLBACK (on_location_app_state_set),
data,
(GClosureNotify) location_app_state_data_free,
0);
gtk_widget_show_all (row);
}
static void
test_parser (GMimeParser *parser, GMimeStream *mbox, GMimeStream *summary)
{
gint64 message_begin, message_end, headers_begin, headers_end;
GMimeFormatOptions *format = g_mime_format_options_get_default ();
InternetAddressList *list;
GMimeMessage *message;
char *marker, *buf;
const char *subject;
GMimeObject *body;
GDateTime *date;
int nmsg = 0;
while (!g_mime_parser_eos (parser)) {
message_begin = g_mime_parser_tell (parser);
if (!(message = g_mime_parser_construct_message (parser, NULL)))
throw (exception_new ("failed to parse message #%d", nmsg));
message_end = g_mime_parser_tell (parser);
headers_begin = g_mime_parser_get_headers_begin (parser);
headers_end = g_mime_parser_get_headers_end (parser);
g_mime_stream_printf (summary, "message offsets: %" G_GINT64_FORMAT ", %" G_GINT64_FORMAT "\n",
message_begin, message_end);
g_mime_stream_printf (summary, "header offsets: %" G_GINT64_FORMAT ", %" G_GINT64_FORMAT "\n",
headers_begin, headers_end);
marker = g_mime_parser_get_mbox_marker (parser);
g_mime_stream_printf (summary, "%s\n", marker);
if ((list = g_mime_message_get_from (message)) != NULL &&
internet_address_list_length (list) > 0) {
buf = internet_address_list_to_string (list, format, FALSE);
g_mime_stream_printf (summary, "From: %s\n", buf);
g_free (buf);
}
if ((list = g_mime_message_get_addresses (message, GMIME_ADDRESS_TYPE_TO)) != NULL &&
internet_address_list_length (list) > 0) {
buf = internet_address_list_to_string (list, format, FALSE);
g_mime_stream_printf (summary, "To: %s\n", buf);
g_free (buf);
}
if (!(subject = g_mime_message_get_subject (message)))
subject = "";
g_mime_stream_printf (summary, "Subject: %s\n", subject);
if (!(date = g_mime_message_get_date (message))) {
date = g_date_time_new_from_unix_utc (0);
} else {
g_date_time_ref (date);
}
buf = g_mime_utils_header_format_date (date);
g_mime_stream_printf (summary, "Date: %s\n", buf);
g_date_time_unref (date);
g_free (buf);
body = g_mime_message_get_mime_part (message);
print_mime_struct (summary, body, 0);
g_mime_stream_write (summary, "\n", 1);
if (mbox) {
if (nmsg > 0)
g_mime_stream_write (mbox, "\n", 1);
g_mime_stream_printf (mbox, "%s\n", marker);
g_mime_object_write_to_stream ((GMimeObject *) message, format, mbox);
}
g_object_unref (message);
g_free (marker);
nmsg++;
}
}
static void
cleaner_task_handler (GTask *task, gpointer source_object,
gpointer task_data, GCancellable *cancellable)
{
HevFileboxCleaner *self = HEV_FILEBOX_CLEANER (source_object);
HevFileboxCleanerPrivate *priv = HEV_FILEBOX_CLEANER_GET_PRIVATE (self);
gchar *fp_path = NULL, *fm_path = NULL;
GFile *file = NULL;
GFileEnumerator *file_enumerator = NULL;
GFileInfo *file_info = NULL;
g_debug ("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
fp_path = g_key_file_get_string (priv->config, "Module", "FilePoolPath", NULL);
fm_path = g_key_file_get_string (priv->config, "Module", "FileMetaPath", NULL);
/* enumerate file pool */
file = g_file_new_for_path (fp_path);
file_enumerator = g_file_enumerate_children (file,
G_FILE_ATTRIBUTE_STANDARD_NAME","G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
while (file_info = g_file_enumerator_next_file (file_enumerator, NULL, NULL)) {
if (G_FILE_TYPE_REGULAR == g_file_info_get_file_type (file_info)) {
gchar *meta_path = NULL;
GKeyFile *meta = NULL;
meta_path = g_build_filename (fm_path, g_file_info_get_name (file_info), NULL);
meta = g_key_file_new ();
if (g_key_file_load_from_file (meta, meta_path, G_KEY_FILE_NONE, NULL)) {
gint64 exp = 0;
GDateTime *now_date = NULL, *exp_date = NULL;
exp = g_key_file_get_int64 (meta, "Meta", "ExpDate", NULL);
now_date = g_date_time_new_now_utc ();
exp_date = g_date_time_new_from_unix_utc (exp);
/* compare date */
if (1 == g_date_time_compare (now_date, exp_date)) {
gchar *file_path = NULL;
file_path = g_build_filename (fp_path,
g_file_info_get_name (file_info), NULL);
/* delete file and it's meta */
g_unlink ((const gchar *) file_path);
g_unlink ((const gchar *) meta_path);
g_free (file_path);
}
g_date_time_unref (now_date);
g_date_time_unref (exp_date);
}
g_key_file_unref (meta);
g_free (meta_path);
}
g_object_unref (file_info);
}
g_object_unref (file_enumerator);
g_object_unref (file);
g_free (fp_path);
g_free (fm_path);
g_task_return_boolean (task, TRUE);
}
int
rpmostree_builtin_status (int argc,
char **argv,
GCancellable *cancellable,
GError **error)
{
int exit_status = EXIT_FAILURE;
GOptionContext *context = g_option_context_new ("- Get the version of the booted system");
glnx_unref_object RPMOSTreeOS *os_proxy = NULL;
glnx_unref_object RPMOSTreeSysroot *sysroot_proxy = NULL;
g_autoptr(GVariant) booted_deployment = NULL;
g_autoptr(GVariant) deployments = NULL;
g_autoptr(GVariant) booted_signatures = NULL;
g_autoptr(GPtrArray) deployment_dicts = NULL;
GVariantIter iter;
GVariant *child;
g_autofree gchar *booted_id = NULL;
const guint CSUM_DISP_LEN = 10; /* number of checksum characters to display */
guint i, n;
guint max_timestamp_len = 19; /* length of timestamp "YYYY-MM-DD HH:MM:SS" */
guint max_id_len = CSUM_DISP_LEN; /* length of checksum ID */
guint max_osname_len = 0; /* maximum length of osname - determined in code */
guint max_refspec_len = 0; /* maximum length of refspec - determined in code */
guint max_version_len = 0; /* maximum length of version - determined in code */
guint buffer = 5; /* minimum space between end of one entry and new column */
if (!rpmostree_option_context_parse (context,
option_entries,
&argc, &argv,
RPM_OSTREE_BUILTIN_FLAG_NONE,
cancellable,
&sysroot_proxy,
error))
goto out;
if (!rpmostree_load_os_proxy (sysroot_proxy, NULL,
cancellable, &os_proxy, error))
goto out;
booted_deployment = rpmostree_os_dup_booted_deployment (os_proxy);
if (booted_deployment)
{
GVariantDict dict;
g_variant_dict_init (&dict, booted_deployment);
g_variant_dict_lookup (&dict, "id", "s", &booted_id);
booted_signatures = g_variant_dict_lookup_value (&dict, "signatures",
G_VARIANT_TYPE ("av"));
g_variant_dict_clear (&dict);
}
deployment_dicts = g_ptr_array_new_with_free_func ((GDestroyNotify) g_variant_dict_unref);
deployments = rpmostree_sysroot_dup_deployments (sysroot_proxy);
g_variant_iter_init (&iter, deployments);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
GVariantDict *dict = g_variant_dict_new (child);
/* Takes ownership of the dictionary */
g_ptr_array_add (deployment_dicts, dict);
/* find lengths for use in column output */
if (!opt_pretty)
{
gchar *origin_refspec = NULL; /* borrowed */
gchar *os_name = NULL; /* borrowed */
gchar *version_string = NULL; /* borrowed */
/* osname should always be present. */
if (g_variant_dict_lookup (dict, "osname", "&s", &os_name))
max_osname_len = MAX (max_osname_len, strlen (os_name));
else
{
const char *id = NULL;
g_variant_dict_lookup (dict, "id", "&s", &id);
g_critical ("Deployment '%s' missing osname", id != NULL ? id : "?");
}
if (g_variant_dict_lookup (dict, "version", "&s", &version_string))
max_version_len = MAX (max_version_len, strlen (version_string));
if (g_variant_dict_lookup (dict, "origin", "&s", &origin_refspec))
max_refspec_len = MAX (max_refspec_len, strlen (origin_refspec));
}
g_variant_unref (child);
}
if (!opt_pretty)
{
/* print column headers */
g_print (" %-*s", max_timestamp_len+buffer,"TIMESTAMP (UTC)");
if (max_version_len)
g_print ("%-*s", max_version_len+buffer,"VERSION");
g_print ("%-*s%-*s%-*s\n",
max_id_len+buffer, "ID",
max_osname_len+buffer, "OSNAME",
max_refspec_len+buffer, "REFSPEC");
}
/* header for "pretty" row output */
else
printchar ("=", 60);
n = deployment_dicts->len;
/* print entries for each deployment */
for (i = 0; i < n; i++)
{
GVariantDict *dict;
g_autoptr(GDateTime) timestamp = NULL;
g_autofree char *timestamp_string = NULL;
g_autofree gchar *truncated_csum = NULL;
g_autoptr(GVariant) signatures = NULL;
gchar *id = NULL; /* borrowed */
gchar *origin_refspec = NULL; /* borrowed */
gchar *os_name = NULL; /* borrowed */
gchar *version_string = NULL; /* borrowed */
gchar *checksum = NULL; /* borrowed */
guint64 t = 0;
gint serial;
gboolean is_booted = FALSE;
dict = g_ptr_array_index (deployment_dicts, i);
g_variant_dict_lookup (dict, "id", "&s", &id);
g_variant_dict_lookup (dict, "osname", "&s", &os_name);
g_variant_dict_lookup (dict, "serial", "i", &serial);
g_variant_dict_lookup (dict, "checksum", "s", &checksum);
g_variant_dict_lookup (dict, "version", "s", &version_string);
g_variant_dict_lookup (dict, "timestamp", "t", &t);
g_variant_dict_lookup (dict, "origin", "s", &origin_refspec);
signatures = g_variant_dict_lookup_value (dict, "signatures",
G_VARIANT_TYPE ("av"));
is_booted = g_strcmp0 (booted_id, id) == 0;
timestamp = g_date_time_new_from_unix_utc (t);
if (timestamp != NULL)
timestamp_string = g_date_time_format (timestamp, "%Y-%m-%d %T");
else
timestamp_string = g_strdup_printf ("(invalid)");
/* truncate checksum */
truncated_csum = g_strndup (checksum, CSUM_DISP_LEN);
/* print deployment info column */
if (!opt_pretty)
{
g_print ("%c %-*s",
is_booted ? '*' : ' ',
max_timestamp_len+buffer, timestamp_string);
if (max_version_len)
g_print ("%-*s",
max_version_len+buffer, version_string ? version_string : "");
g_print ("%-*s%-*s%-*s\n",
max_id_len+buffer, truncated_csum,
max_osname_len+buffer, os_name,
max_refspec_len+buffer, origin_refspec);
}
/* print "pretty" row info */
else
{
guint tab = 11;
char *title = NULL;
if (i==0)
title = "DEFAULT ON BOOT";
else if (is_booted || n <= 2)
title = "NON-DEFAULT ROLLBACK TARGET";
else
title = "NON-DEFAULT DEPLOYMENT";
g_print (" %c %s\n",
is_booted ? '*' : ' ',
title);
printchar ("-", 40);
if (version_string)
g_print (" %-*s%-*s\n", tab, "version", tab, version_string);
g_print (" %-*s%-*s\n %-*s%-*s.%d\n %-*s%-*s\n %-*s%-*s\n",
tab, "timestamp", tab, timestamp_string,
tab, "id", tab, checksum, serial,
tab, "osname", tab, os_name,
tab, "refspec", tab, origin_refspec);
if (signatures != NULL)
rpmostree_print_signatures (signatures, " GPG: ");
printchar ("=", 60);
}
}
/* Print any signatures for the booted deployment, but only in NON-pretty
* mode. We save this for the end to preserve the tabular formatting for
* deployments. */
if (!opt_pretty && booted_signatures != NULL)
{
guint n_sigs = g_variant_n_children (booted_signatures);
if (n_sigs > 0)
{
/* XXX If we ever add internationalization, use ngettext() here. */
g_print ("\nGPG: Found %u signature%s on the booted deployment (*):\n",
n_sigs, n_sigs == 1 ? "" : "s");
rpmostree_print_signatures (booted_signatures, " ");
}
}
exit_status = EXIT_SUCCESS;
out:
/* Does nothing if using the message bus. */
rpmostree_cleanup_peer ();
return exit_status;
}
