Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
0
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;
}
Ejemplo n.º 3
0
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_;
}
Ejemplo n.º 4
0
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);
}
Ejemplo n.º 5
0
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);
}
Ejemplo n.º 6
0
/* 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);
}
Ejemplo n.º 7
0
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;
}
Ejemplo n.º 8
0
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);
}
Ejemplo n.º 9
0
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);
}
Ejemplo n.º 10
0
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);
}
Ejemplo n.º 11
0
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);
}
Ejemplo n.º 12
0
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();
}
Ejemplo n.º 13
0
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 ;
}
Ejemplo n.º 14
0
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);
}
Ejemplo n.º 15
0
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;
}
Ejemplo n.º 17
0
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, "", "");
}
Ejemplo n.º 18
0
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);
}
Ejemplo n.º 20
0
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;
}
Ejemplo n.º 21
0
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;
}
Ejemplo n.º 22
0
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;
}
Ejemplo n.º 24
0
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);
    }
}
Ejemplo n.º 25
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);
}
Ejemplo n.º 26
0
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);
}
Ejemplo n.º 27
0
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);
}
Ejemplo n.º 28
0
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;
}
Ejemplo n.º 29
0
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));
}