static gchar * generate_new_id (GoaDaemon *daemon) { static guint counter = 0; GDateTime *dt; gchar *ret; dt = g_date_time_new_now_local (); ret = g_strdup_printf ("account_%" G_GINT64_FORMAT "_%u", g_date_time_to_unix (dt), /* seconds since Epoch */ counter); /* avoids collisions */ g_date_time_unref (dt); counter++; return ret; }
static gchar * get_timestamp_str (void) { GDateTime *date; GDateTime *date_utc; gchar *date_str; date = g_date_time_new_now_local (); date_utc = g_date_time_to_utc (date); g_date_time_unref (date); date_str = g_date_time_format (date_utc, "%d/%b/%Y:%H:%M:%S %z"); g_date_time_unref (date_utc); return date_str; }
void mathg_my_timer_init (mathgMyTimer *self, gboolean b) { gboolean _tmp0_ = FALSE; GDateTime* _tmp1_ = NULL; GDateTime* _tmp2_ = NULL; GDateTime* _tmp3_ = NULL; memset (self, 0, sizeof (mathgMyTimer)); _tmp0_ = b; (*self).reset = _tmp0_; _tmp1_ = g_date_time_new_now_local (); _g_date_time_unref0 ((*self).stop); (*self).stop = _tmp1_; _tmp2_ = (*self).stop; _tmp3_ = _g_date_time_ref0 (_tmp2_); _g_date_time_unref0 ((*self).start); (*self).start = _tmp3_; }
void gsd_ldsm_show_empty_trash (void) { GFile *file; GDateTime *old; DeleteData *data; old = g_date_time_new_now_local (); file = g_file_new_for_uri ("trash:"); data = delete_data_new (file, NULL, old, TRUE, TRUE, 0); g_object_unref (file); g_date_time_unref (old); delete_recursively_by_age (data); delete_data_unref (data); }
void win_print(ProfWin *window, const char show_char, int pad_indent, GDateTime *timestamp, int flags, theme_item_t theme_item, const char *const from, const char *const message) { if (timestamp == NULL) { timestamp = g_date_time_new_now_local(); } else { g_date_time_ref(timestamp); } buffer_push(window->layout->buffer, show_char, pad_indent, timestamp, flags, theme_item, from, message, NULL); _win_print(window, show_char, pad_indent, timestamp, flags, theme_item, from, message, NULL); // TODO: cross-reference.. this should be replaced by a real event-based system inp_nonblocking(TRUE); g_date_time_unref(timestamp); }
/* Auxiliary methods */ static gboolean update_grid_scroll_position (GcalWeekView *self) { g_autoptr(GDateTime) week_start = NULL; g_autoptr(GDateTime) week_end = NULL; g_autoptr(GDateTime) now = NULL; GtkAdjustment *vadjustment; gdouble minutes, real_value; gdouble max, page, page_increment, value; /* While the scrolled window is not mapped, we keep waiting */ if (!gtk_widget_get_realized (self->scrolled_window) || !gtk_widget_get_mapped (self->scrolled_window)) { GCAL_RETURN (G_SOURCE_CONTINUE); } now = g_date_time_new_now_local (); week_start = get_start_of_week (self->date); week_end = get_end_of_week (self->date); /* Don't animate when not today */ if (datetime_compare_date (now, week_start) < 0 || datetime_compare_date (now, week_end) >= 0) GCAL_GOTO (out); vadjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (self->scrolled_window)); minutes = g_date_time_get_hour (now) * 60 + g_date_time_get_minute (now); page = gtk_adjustment_get_page_size (vadjustment); max = gtk_adjustment_get_upper (vadjustment); real_value = max / MINUTES_PER_DAY * minutes - (page / 2.0); page_increment = gtk_adjustment_get_page_increment (vadjustment); value = gtk_adjustment_get_value (vadjustment); gtk_adjustment_set_page_increment (vadjustment, real_value - value); g_signal_emit_by_name (self->scrolled_window, "scroll-child", GTK_SCROLL_PAGE_FORWARD, FALSE); gtk_adjustment_set_page_increment (vadjustment, page_increment); out: self->scroll_grid_timeout_id = 0; GCAL_RETURN (G_SOURCE_REMOVE); }
GSList * chat_log_get_previous(const gchar * const login, const gchar * const recipient) { GSList *history = NULL; GDateTime *now = g_date_time_new_now_local(); GDateTime *log_date = g_date_time_new(tz, g_date_time_get_year(session_started), g_date_time_get_month(session_started), g_date_time_get_day_of_month(session_started), g_date_time_get_hour(session_started), g_date_time_get_minute(session_started), g_date_time_get_second(session_started)); // get data from all logs from the day the session was started to today while (g_date_time_compare(log_date, now) != 1) { char *filename = _get_log_filename(recipient, login, log_date, FALSE); FILE *logp = fopen(filename, "r"); if (logp != NULL) { GString *header = g_string_new(""); g_string_append_printf(header, "%d/%d/%d:", g_date_time_get_day_of_month(log_date), g_date_time_get_month(log_date), g_date_time_get_year(log_date)); history = g_slist_append(history, header->str); g_string_free(header, FALSE); char *line; while ((line = prof_getline(logp)) != NULL) { history = g_slist_append(history, line); } fclose(logp); } free(filename); GDateTime *next = g_date_time_add_days(log_date, 1); g_date_time_unref(log_date); log_date = next; } g_date_time_unref(log_date); g_date_time_unref(now); return history; }
void win_show_contact(ProfWin *window, PContact contact) { const char *barejid = p_contact_barejid(contact); const char *name = p_contact_name(contact); const char *presence = p_contact_presence(contact); const char *status = p_contact_status(contact); GDateTime *last_activity = p_contact_last_activity(contact); win_print_time(window, '-'); win_presence_colour_on(window, presence); if (name != NULL) { wprintw(window->win, "%s", name); } else { wprintw(window->win, "%s", barejid); } wprintw(window->win, " is %s", presence); if (last_activity != NULL) { GDateTime *now = g_date_time_new_now_local(); GTimeSpan span = g_date_time_difference(now, last_activity); wprintw(window->win, ", idle "); int hours = span / G_TIME_SPAN_HOUR; span = span - hours * G_TIME_SPAN_HOUR; if (hours > 0) { wprintw(window->win, "%dh", hours); } int minutes = span / G_TIME_SPAN_MINUTE; span = span - minutes * G_TIME_SPAN_MINUTE; wprintw(window->win, "%dm", minutes); int seconds = span / G_TIME_SPAN_SECOND; wprintw(window->win, "%ds", seconds); } if (status != NULL) { wprintw(window->win, ", \"%s\"", p_contact_status(contact)); } wprintw(window->win, "\n"); win_presence_colour_off(window, presence); }
static void foreach_enum_trackers(gpointer data, gpointer user) { enum_trackers_state_t *state = user; GArray *str = g_array_new (FALSE, FALSE, sizeof (data)); g_array_append_vals(str, data, 5); fitbitd_tracker_t *tracker; GValue *val_serial; GValue *val_state; GValue *val_sync_age; GValue *val_tracker_id; GValue *val_user_id; guint tracker_state; guint sync_age; GDateTime *time_now; val_serial = g_array_index(str, GValue *, 0); val_state = g_array_index(str, GValue *, 1); val_sync_age = g_array_index(str, GValue *, 2); val_tracker_id = g_array_index(str, GValue *, 3); val_user_id = g_array_index(str, GValue *, 4); if (!val_serial || !val_state || !val_sync_age || !val_tracker_id || !val_user_id) { g_printerr("Missing tracker values\n"); return; } tracker = get_tracker(g_value_get_string(val_serial)); if (!tracker) { g_printerr("No tracker record\n"); return; } tracker_state = g_value_get_uint(val_state); tracker->sync_active = !!(tracker_state & (1 << 0)); sync_age = g_value_get_uint(val_sync_age); time_now = g_date_time_new_now_local(); if (tracker->sync_time) g_date_time_unref(tracker->sync_time); tracker->sync_time = g_date_time_add_seconds(time_now, -(gdouble)sync_age); g_date_time_unref(time_now); strncpy(tracker->id, g_value_get_string(val_tracker_id), sizeof(tracker->id)); strncpy(tracker->user_id, g_value_get_string(val_user_id), sizeof(tracker->user_id)); state->callback(tracker, state->user); }
void master_free(Master* master) { MAGIC_ASSERT(master); /* engine is now killed */ master->killed = TRUE; GDateTime* dt_now = g_date_time_new_now_local(); gchar* dt_format = g_date_time_format(dt_now, "%F %H:%M:%S"); message("Shadow v%s shut down cleanly at %s", SHADOW_VERSION, dt_format); g_date_time_unref(dt_now); g_free(dt_format); random_free(master->random); MAGIC_CLEAR(master); g_free(master); }
static char *formatLogMessage(const char *file, int line, ShovelerLogLevel level, const char *message) { const char *strippedLocation = strstr(file, logLocationPrefix); if(strippedLocation != NULL) { strippedLocation += strlen(logLocationPrefix); } else { strippedLocation = file; } GDateTime *now = g_date_time_new_now_local(); GString *result = g_string_new(""); g_string_append_printf(result, "[%02d:%02d:%02d] (%s:%s:%d) %s", g_date_time_get_hour(now), g_date_time_get_minute(now), g_date_time_get_second(now), getStaticLogLevelName(level), strippedLocation, line, message); g_date_time_unref(now); return g_string_free(result, false); }
void status_bar_resize(void) { int rows, cols; getmaxyx(stdscr, rows, cols); werase(status_bar); int bracket_attrs = theme_attrs(THEME_STATUS_BRACKET); mvwin(status_bar, rows-2, 0); wresize(status_bar, 1, cols); wbkgd(status_bar, theme_attrs(THEME_STATUS_TEXT)); wattron(status_bar, bracket_attrs); mvwprintw(status_bar, 0, cols - 34, _active); mvwprintw(status_bar, 0, cols - 34 + ((current - 1) * 3), bracket); wattroff(status_bar, bracket_attrs); if (message) { char *time_pref = prefs_get_string(PREF_TIME_STATUSBAR); gchar *date_fmt = NULL; if (g_strcmp0(time_pref, "off") == 0) { date_fmt = g_strdup(""); } else { date_fmt = g_date_time_format(last_time, time_pref); } assert(date_fmt != NULL); size_t len = strlen(date_fmt); g_free(date_fmt); if (g_strcmp0(time_pref, "off") != 0) { /* 01234567890123456 * [HH:MM] message */ mvwprintw(status_bar, 0, 5 + len, message); } else { mvwprintw(status_bar, 0, 1, message); } prefs_free_string(time_pref); } if (last_time) { g_date_time_unref(last_time); } last_time = g_date_time_new_now_local(); _status_bar_draw(); }
static void gp_log_handler(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data ) { char *color; char *level; GDateTime *dt; char *dateTime; int i; color = E_WHITE; level = " "; switch (log_level & G_LOG_LEVEL_MASK) { case G_LOG_LEVEL_WARNING: color = E_BR_YELLOW; level = "warn"; break; case G_LOG_LEVEL_ERROR: color = E_BR_RED; level = "err "; break; case G_LOG_LEVEL_CRITICAL: color = E_WONR; level = "crit"; break; case G_LOG_LEVEL_DEBUG: color = E_BR_GREEN; level = "dbg "; break; case G_LOG_LEVEL_INFO: color = E_WHITE; level = "info"; break; case G_LOG_LEVEL_MESSAGE: color = E_BR_CYAN; level = "msg "; break; default: color = E_WHITE; level="dflt"; break; } // date and time information dt = g_date_time_new_now_local(); dateTime = g_date_time_format(dt,"%Y-%m-%d %k:%M:%S"); // print to stdout if in verbose mode if ( gp_verbose ) { printf("%s [%s%s%s] %s",dateTime,color,level,E_END,message); } if (gp_logSize>gp_maxSize) { //g_see } // write to logfile if existing if (gpLogFile!=NULL) { i = fprintf(gpLogFile, "%s [%s] %s", dateTime, level, message); if (i>0) gp_logSize += i; } g_free(dateTime); return ; }
static void gcal_application_show_about (GSimpleAction *simple, GVariant *parameter, gpointer user_data) { GcalApplication *app = GCAL_APPLICATION (user_data); char *copyright; GDateTime *date; int created_year = 2012; const gchar *authors[] = { "Erick Pérez Castellanos <*****@*****.**>", NULL }; const gchar *artists[] = { "Reda Lazri <*****@*****.**>", NULL }; date = g_date_time_new_now_local (); if (g_date_time_get_year (date) == created_year) { copyright = g_strdup_printf (_("Copyright \xC2\xA9 %Id " "The Calendar authors"), created_year); } else { copyright = g_strdup_printf (_("Copyright \xC2\xA9 %Id\xE2\x80\x93%Id " "The Calendar authors"), created_year, g_date_time_get_year (date)); } gtk_show_about_dialog (GTK_WINDOW (app->priv->window), "program-name", "Calendar", "version", VERSION, "copyright", copyright, "license-type", GTK_LICENSE_GPL_3_0, "authors", authors, "artists", artists, "logo-icon-name", "x-office-calendar", NULL); g_free (copyright); g_date_time_unref (date); }
static void kms_rtp_sync_context_init_stats_file (KmsRtpSyncContext * self, const gchar * stats_file_suffix_name) { gchar *stats_file_name; GDateTime *datetime; gchar *date_str; if (stats_file_suffix_name == NULL) { return; } if (stats_files_dir == NULL) { return; } datetime = g_date_time_new_now_local (); date_str = g_date_time_format (datetime, "%Y%m%d%H%M%S"); g_date_time_unref (datetime); stats_file_name = g_strdup_printf ("%s/%s_%s.csv", stats_files_dir, date_str, stats_file_suffix_name); g_free (date_str); if (g_mkdir_with_parents (stats_files_dir, 0777) < 0) { GST_ERROR_OBJECT (self, "Directory '%s' for stats files cannot be created", stats_files_dir); goto end; } self->priv->stats_file = g_fopen (stats_file_name, "w+"); if (self->priv->stats_file == NULL) { GST_ERROR_OBJECT (self, "Stats file '%s' cannot be created", stats_file_name); } else { GST_INFO_OBJECT (self, "Stats file '%s' created", stats_file_name); g_fprintf (self->priv->stats_file, "ENTRY_TS,THREAD,SSRC,CLOCK_RATE,PTS_ORIG,PTS,DTS,EXT_RTP,SR_NTP_NS,SR_EXT_RTP\n"); } end: g_free (stats_file_name); }
static char * build_path (AsyncExistenceJob *job) { const gchar *base_path, *file_type; char *retval, *file_name, *origin; base_path = job->base_paths[job->type]; file_type = screenshot_config->file_type; if (base_path == NULL || base_path[0] == '\0') return NULL; if (job->screenshot_origin == NULL) { GDateTime *d; d = g_date_time_new_now_local (); origin = g_date_time_format (d, "%Y-%m-%d %H-%M-%S"); g_date_time_unref (d); } else origin = g_strdup (job->screenshot_origin); if (job->iteration == 0) { /* translators: this is the name of the file that gets made up * with the screenshot if the entire screen is taken */ file_name = g_strdup_printf (_("Screenshot from %s.%s"), origin, file_type); } else { /* translators: this is the name of the file that gets * made up with the screenshot if the entire screen is * taken */ file_name = g_strdup_printf (_("Screenshot from %s - %d.%s"), origin, job->iteration, file_type); } retval = g_build_filename (base_path, file_name, NULL); g_free (file_name); g_free (origin); return retval; }
void win_show_contact(ProfWin *window, PContact contact) { const char *barejid = p_contact_barejid(contact); const char *name = p_contact_name(contact); const char *presence = p_contact_presence(contact); const char *status = p_contact_status(contact); GDateTime *last_activity = p_contact_last_activity(contact); theme_item_t presence_colour = theme_main_presence_attrs(presence); if (name) { win_print(window, '-', 0, NULL, NO_EOL, presence_colour, "", name); } else { win_print(window, '-', 0, NULL, NO_EOL, presence_colour, "", barejid); } win_vprint(window, '-', 0, NULL, NO_DATE | NO_EOL, presence_colour, "", " is %s", presence); if (last_activity) { GDateTime *now = g_date_time_new_now_local(); GTimeSpan span = g_date_time_difference(now, last_activity); g_date_time_unref(now); int hours = span / G_TIME_SPAN_HOUR; span = span - hours * G_TIME_SPAN_HOUR; int minutes = span / G_TIME_SPAN_MINUTE; span = span - minutes * G_TIME_SPAN_MINUTE; int seconds = span / G_TIME_SPAN_SECOND; if (hours > 0) { win_vprint(window, '-', 0, NULL, NO_DATE | NO_EOL, presence_colour, "", ", idle %dh%dm%ds", hours, minutes, seconds); } else { win_vprint(window, '-', 0, NULL, NO_DATE | NO_EOL, presence_colour, "", ", idle %dm%ds", minutes, seconds); } } if (status) { win_vprint(window, '-', 0, NULL, NO_DATE | NO_EOL, presence_colour, "", ", \"%s\"", p_contact_status(contact)); } win_print(window, '-', 0, NULL, NO_DATE, presence_colour, "", ""); }
void engine_free(Engine* engine) { MAGIC_ASSERT(engine); /* engine is now killed */ engine->killed = TRUE; /* this launches delete on all the plugins and should be called before * the engine is marked "killed" and workers are destroyed. */ internetwork_free(engine->internet); /* we will never execute inside the plugin again */ engine->forceShadowContext = TRUE; if(engine->workerPool) { engine_teardownWorkerThreads(engine); } if(engine->masterEventQueue) { asyncpriorityqueue_free(engine->masterEventQueue); } registry_free(engine->registry); g_cond_free(engine->workersIdle); g_mutex_free(engine->engineIdle); GDateTime* dt_now = g_date_time_new_now_local(); gchar* dt_format = g_date_time_format(dt_now, "%F %H:%M:%S:%N"); message("clean engine shutdown at %s", dt_format); g_date_time_unref(dt_now); g_free(dt_format); for(int i = 0; i < engine->numCryptoThreadLocks; i++) { g_static_mutex_free(&(engine->cryptoThreadLocks[i])); } random_free(engine->random); g_mutex_free(engine->lock); MAGIC_CLEAR(engine); shadow_engine = NULL; g_free(engine); }
static void _pcapmain_log(GLogLevelFlags level, const gchar* functionName, const gchar* format, ...) { va_list vargs; va_start(vargs, format); GDateTime* dt = g_date_time_new_now_local(); GString* newformat = g_string_new(NULL); g_string_append_printf(newformat, "%04i-%02i-%02i %02i:%02i:%02i %"G_GINT64_FORMAT".%06i [%s] [%s] %s", g_date_time_get_year(dt), g_date_time_get_month(dt), g_date_time_get_day_of_month(dt), g_date_time_get_hour(dt), g_date_time_get_minute(dt), g_date_time_get_second(dt), g_date_time_to_unix(dt), g_date_time_get_microsecond(dt), _pcapmain_logLevelToString(level), functionName, format); g_logv(PCAP_LOG_DOMAIN, level, newformat->str, vargs); g_string_free(newformat, TRUE); g_date_time_unref(dt); va_end(vargs); }
char * cc_util_get_smart_date (GDateTime *date) { gchar *label; GDateTime *today, *local; GTimeSpan span; /* Set today date */ local = g_date_time_new_now_local (); today = g_date_time_new_local (g_date_time_get_year (local), g_date_time_get_month (local), g_date_time_get_day_of_month (local), 0, 0, 0); span = g_date_time_difference (today, date); if (span <= 0) { label = g_strdup (_("Today")); } else if (span <= G_TIME_SPAN_DAY) { label = g_strdup (_("Yesterday")); } else { if (g_date_time_get_year (date) == g_date_time_get_year (today)) { /* Translators: This is a date format string in the style of "Feb 24". */ label = g_date_time_format (date, _("%b %e")); } else { /* Translators: This is a date format string in the style of "Feb 24, 2013". */ label = g_date_time_format (date, _("%b %e, %Y")); } } g_date_time_unref (local); g_date_time_unref (today); return label; }
static gchar* plank_services_logger_get_time (void) { gchar* result = NULL; GDateTime* now = NULL; GDateTime* _tmp0_ = NULL; gint _tmp1_ = 0; gint _tmp2_ = 0; gint _tmp3_ = 0; gint _tmp4_ = 0; gchar* _tmp5_ = NULL; _tmp0_ = g_date_time_new_now_local (); now = _tmp0_; _tmp1_ = g_date_time_get_hour (now); _tmp2_ = g_date_time_get_minute (now); _tmp3_ = g_date_time_get_second (now); _tmp4_ = g_date_time_get_microsecond (now); _tmp5_ = g_strdup_printf ("%.2d:%.2d:%.2d.%.6d", _tmp1_, _tmp2_, _tmp3_, _tmp4_); result = _tmp5_; _g_date_time_unref0 (now); return result; }
void groupchat_log_chat(const gchar * const login, const gchar * const room, const gchar * const nick, const gchar * const msg) { gchar *room_copy = strdup(room); struct dated_chat_log *dated_log = g_hash_table_lookup(groupchat_logs, room_copy); // no log for room if (dated_log == NULL) { dated_log = _create_groupchat_log(room_copy, login); g_hash_table_insert(groupchat_logs, room_copy, dated_log); // log exists but needs rolling } else if (_log_roll_needed(dated_log)) { dated_log = _create_groupchat_log(room_copy, login); g_hash_table_replace(logs, room_copy, dated_log); } GDateTime *dt = g_date_time_new_now_local(); gchar *date_fmt = g_date_time_format(dt, "%H:%M:%S"); FILE *logp = fopen(dated_log->filename, "a"); g_chmod(dated_log->filename, S_IRUSR | S_IWUSR); if (logp) { if (strncmp(msg, "/me ", 4) == 0) { fprintf(logp, "%s - *%s %s\n", date_fmt, nick, msg + 4); } else { fprintf(logp, "%s - %s: %s\n", date_fmt, nick, msg); } fflush(logp); int result = fclose(logp); if (result == EOF) { log_error("Error closing file %s, errno = %d", dated_log->filename, errno); } } g_free(date_fmt); g_date_time_unref(dt); }
static gboolean on_visibility_notify(GtkWidget* widget, GdkEvent* event, gpointer data) { GDateTime* datetime = g_date_time_new_now_local(); if(!datetime) { gtk_menu_item_set_label(GTK_MENU_ITEM(greeter.ui.clock.date_widget), "[date]"); g_signal_handler_disconnect(greeter.ui.clock.date_widget, visibility_notify_id); return TRUE; } gchar* str = g_date_time_format(datetime, config.clock.date_format); gtk_menu_item_set_label(GTK_MENU_ITEM(greeter.ui.clock.date_widget), str); gtk_calendar_select_month(GTK_CALENDAR(greeter.ui.clock.calendar_widget), g_date_time_get_month(datetime) - 1, g_date_time_get_year(datetime)); gtk_calendar_select_day(GTK_CALENDAR(greeter.ui.clock.calendar_widget), g_date_time_get_day_of_month(datetime)); g_free(str); g_date_time_unref(datetime); return TRUE; }
void CalendarDatePrivate::initYearView() { GtkWidget* swipebox = NULL; int row = 0; int col = 0; int rowCount = 3; int colCount = 4; char buffer[32]; GDateTime* nowDate = g_date_time_new_now_local(); int nowYear = g_date_time_get_year(nowDate); int selectedYear = m_selectedYear; int cellWidth = MAIN_BOX_DEFAULT_WIDTH / colCount; int cellHeight = MAIN_BOX_DEFAULT_WIDTH / rowCount; int beginYear = ((int)selectedYear / 10) * 10 - 1; int endYear = ((int)selectedYear / 10 + 1) * 10; int iterYear = beginYear; m_swipeBox[VIEWTYPE_YEAR] = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); swipebox = m_swipeBox[VIEWTYPE_YEAR]; gtk_fixed_put(GTK_FIXED(m_mainBox), GTK_WIDGET(m_swipeBox[VIEWTYPE_YEAR]), 0, 0); gtk_widget_set_name(GTK_WIDGET(swipebox), "calendar-table"); g_snprintf(buffer, sizeof(buffer), "%d-%d", beginYear, endYear); gtk_button_set_label(GTK_BUTTON(m_viewTypeSwitch), buffer); for (row = 0; row < rowCount; ++row) { GtkWidget* yearLayout = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); for (col = 0; col < colCount; ++col) { int index = row * colCount + col; iterYear = beginYear + index; g_snprintf(buffer, sizeof(buffer), "%d", iterYear); m_yearItem[index] = new CalendarItem(ITEMTYPE_YEAR, iterYear); m_yearItem[index]->setOnClickedListener(this); m_yearItem[index]->setSize(cellWidth, cellHeight); m_yearItem[index]->setParent(GTK_WIDGET(yearLayout)); } gtk_box_pack_start(GTK_BOX(swipebox), GTK_WIDGET(yearLayout), TRUE, TRUE, 0); } }
void tools_write_resolver_configuration (const gchar * const *nameservers, const gchar *domain, const gchar * const *searches) { gchar *comment = NULL; GString * resolv_conf; GDateTime *now; gchar *_now = NULL; GError *error; now = g_date_time_new_now_local (); _now = g_date_time_format (now, "%F %T"); g_date_time_unref (now); comment = g_strdup_printf (_("# Created by Loom: %s\n"), _now); g_free (_now); resolv_conf = g_string_new (comment); g_free (comment); if (domain != NULL) g_string_printf (resolv_conf, "domain %s\n", domain); if (searches != NULL) { g_string_printf (resolv_conf, "search"); for (guint i = 0; searches[i] != NULL; i++) g_string_printf (resolv_conf, " %s", searches[i]); g_string_printf (resolv_conf, "\n"); } if (nameservers != NULL) { for (guint i = 0; nameservers[i] != NULL; i++) g_string_printf (resolv_conf, "nameserver %s\n", nameservers[i]); } g_file_set_contents ("/etc/resolv.conf", resolv_conf->str, -1, &error); g_string_free (resolv_conf, TRUE); }
static void action_about_nemo_callback (GtkAction *action, gpointer user_data) { const gchar *license[] = { N_("Nemo is free software; you can redistribute it and/or modify " "it under the terms of the GNU General Public License as published by " "the Free Software Foundation; either version 2 of the License, or " "(at your option) any later version."), N_("Nemo is distributed in the hope that it will be useful, " "but WITHOUT ANY WARRANTY; without even the implied warranty of " "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the " "GNU General Public License for more details."), N_("You should have received a copy of the GNU General Public License " "along with Nemo; if not, write to the Free Software Foundation, Inc., " "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA") }; gchar *license_trans, *copyright_str; GDateTime *date; license_trans = g_strjoin ("\n\n", _(license[0]), _(license[1]), _(license[2]), NULL); date = g_date_time_new_now_local (); gtk_show_about_dialog (GTK_WINDOW (user_data), "program-name", _("Nemo"), "version", VERSION, "comments", _("Nemo lets you organize " "files and folders, both on " "your computer and online."), "license", license_trans, "wrap-license", TRUE, "logo-icon-name", "folder", NULL); g_free (license_trans); g_free (copyright_str); g_date_time_unref (date); }
static void log_func (GstDebugCategory *category, GstDebugLevel level, const gchar *file, const gchar *function, gint line, GObject *object, GstDebugMessage *message, gpointer user_data) { Log *log = (Log *)user_data; GDateTime *datetime; gchar *date; const gchar *cat; if (level > gst_debug_category_get_threshold (category)) { return; } cat = gst_debug_category_get_name (category); datetime = g_date_time_new_now_local (); if (g_strcmp0 (cat, "access") == 0) { date = g_date_time_format (datetime, "%b/%d/%Y:%H:%M:%S %z"); fprintf (log->access_hd, gst_debug_message_get (message), date); g_free (date); fflush (log->access_hd); } else { date = g_date_time_format (datetime, "%b %d %H:%M:%S"); fprintf (log->log_hd, "%s.%d %s" CAT_FMT "%s\n", date, g_date_time_get_microsecond (datetime), gst_debug_level_get_name (level), cat, file, line, gst_debug_message_get (message)); g_free (date); fflush (log->log_hd); } g_date_time_unref (datetime); }
static gboolean redisplay_clock (gpointer data) { GSource *source; GDateTime *now, *expiry; now = g_date_time_new_now_local (); g_print ("%02d:%02d\n", g_date_time_get_hour (now), g_date_time_get_minute (now)); expiry = g_date_time_add_seconds (now, 60 - g_date_time_get_second (now)); source = g_date_time_source_new (expiry, TRUE); g_source_set_callback (source, redisplay_clock, NULL, NULL); g_source_attach (source, NULL); g_source_unref (source); g_date_time_unref (expiry); g_date_time_unref (now); return FALSE; }
static void export_button_clicked(GtkButton *button, gpointer user_data) { GDateTime *now = g_date_time_new_now_local(); char *export_filename = g_date_time_format(now, "darktable_tags_%F_%R.txt"); char *last_dirname = dt_conf_get_string("plugins/lighttable/tagging/last_import_export_location"); if(!last_dirname || !*last_dirname) { g_free(last_dirname); last_dirname = g_strdup(g_get_home_dir()); } GtkWidget *win = dt_ui_main_window(darktable.gui->ui); GtkWidget *filechooser = gtk_file_chooser_dialog_new(_("Select file to export to"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_SAVE, _("_cancel"), GTK_RESPONSE_CANCEL, _("_export"), GTK_RESPONSE_ACCEPT, (char *)NULL); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(filechooser), TRUE); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_dirname); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(filechooser), export_filename); if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT) { char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser)); char *dirname = g_path_get_dirname(filename); dt_conf_set_string("plugins/lighttable/tagging/last_import_export_location", dirname); ssize_t count = dt_tag_export(filename); if(count < 0) dt_control_log(_("error exporting tags")); else dt_control_log(_("%zd tags exported"), count); g_free(filename); g_free(dirname); } g_date_time_unref(now); g_free(last_dirname); g_free(export_filename); gtk_widget_destroy(filechooser); }
void um_history_dialog_show (UmHistoryDialog *um, GtkWindow *parent) { GDateTime *temp, *local; /* Set the first day of this week */ local = g_date_time_new_now_local (); temp = g_date_time_new_local (g_date_time_get_year (local), g_date_time_get_month (local), g_date_time_get_day_of_month (local), 0, 0, 0); um->week = g_date_time_add_days (temp, 1 - g_date_time_get_day_of_week (temp)); um->current_week = g_date_time_ref (um->week); g_date_time_unref (local); g_date_time_unref (temp); show_week (um); gtk_window_set_transient_for (GTK_WINDOW (um->dialog), parent); gtk_window_present (GTK_WINDOW (um->dialog)); }