void
vlog2file(int prepend_time, char *filename, char *format, va_list args)
{
FILE *fp;
time_t lt;
char buf[40];
lt = time(NULL);
*buf = '\0';
if ((fp = fopen(filename, "ab")) == NULL) {
fprintf(stderr, "Unable to open %s!\n", filename);
if (prepend_time)
fprintf(stderr, "%.16s: ", ctime(<));
vfprintf(stderr, format, args);
} else {
if (prepend_time) {
format_time(buf, 32, "%c", MUCK_LOCALTIME(lt));
fprintf(fp, "%.32s: ", buf);
}
vfprintf(fp, format, args);
fprintf(fp, "\n");
fclose(fp);
}
}
const char *
mfn_ftime(MFUNARGS)
{
time_t lt;
struct tm *tm;
if (argc == 3) {
lt = atol(argv[2]);
} else {
time(<);
}
if (argc > 1 && *argv[1]) {
int offval = atoi(argv[1]);
if (offval < 25 && offval > -25) {
lt += 3600 * offval;
} else {
lt -= offval;
}
lt += get_tz_offset();
}
#ifndef WIN32
tm = localtime(<);
#else
tm = uw32localtime(<);
#endif
format_time(buf, BUFFER_LEN - 1, argv[0], tm);
return buf;
}
char *
format_next_process(caddr_t handle, char *(*get_userid) ())
{
struct prpsinfo *pp;
struct handle *hp;
long cputime;
/* find and remember the next proc structure */
hp = (struct handle *) handle;
pp = *(hp->next_proc++);
hp->remaining--;
/* get the process cpu usage since startup */
cputime = pp->pr_time.tv_sec;
/* format this entry */
sprintf(fmt,
Proc_format,
pp->pr_pid,
pp->pr_pgrp,
(*get_userid) (pp->pr_uid),
format_prio(pp),
format_k(pagetok(pp->pr_size)),
format_k(pagetok(pp->pr_rssize)),
format_state(pp),
format_time(cputime),
clip_percent(weighted_cpu(pp)),
clip_percent(percent_cpu(pp)),
printable(pp->pr_fname));
/* return the result */
return (fmt);
}
void Device::print_readings(unsigned int num, std::string filename)
{
//char temp[128];
std::stringstream ss;
if(num == readings.size())
ss << " Printing all the " << num << " readings:" << std::endl;
else
ss << " Printing the latest " << num << " readings:" << std::endl;
if(filename.empty())
printf("%s", ss.str().c_str());
else
log(ss.str(), filename, true, false);
std::map<time_t,int>::iterator it = readings.end();
for(int i = 1; i < num+1; i++) {
char buff[20];
time_t time = 0;
if(it != readings.begin())
time = (--it)->first;
else
continue;
format_time(time, buff);
ss.str(std::string()); // clear the stream
ss << " " << buff << "\t" << get_reading(time) << std::endl;
if(filename.empty())
printf("%s", ss.str().c_str());
else
log(ss.str(), filename, true, false);
}
}
static void PrintResList(AttrList* ad)
{
// ad->fPrint(stdout);
char attrName[32], attrStartTime[32];
char name[128];
int StartTime;
const char* Fmt="%-30s %12s %12s\n";
printf(Fmt,"Resource Name"," Start Time"," Match Time");
printf(Fmt,"-------------"," ----------"," ----------");
int i;
for (i=1;;i++) {
sprintf( attrName , "Name%d", i );
sprintf( attrStartTime , "StartTime%d", i );
if( !ad->LookupString ( attrName, name, COUNTOF(name) ) ||
!ad->LookupInteger ( attrStartTime, StartTime))
break;
char* p=strrchr(name,'@');
*p='\0';
time_t Now=time(0)-StartTime;
printf(Fmt,name,format_date(StartTime),format_time(Now));
}
printf(Fmt,"-------------"," ------------"," ------------");
printf("Number of Resources Used: %d\n",i-1);
return;
}
int archinfo_show_mainhead(carchreader *ai, cdico *dicomainhead)
{
char buffer[256];
if (!ai || !dicomainhead)
{ errprintf("a parameter is null\n");
return -1;
}
printf("====================== archive information ======================\n");
printf( "Archive type: \t\t\t%s\n", (ai->archtype==ARCHTYPE_FILESYSTEMS)?"filesystems":"flat files");
if ((ai->archtype==ARCHTYPE_FILESYSTEMS))
printf("Filesystems count: \t%ld\n", (long)ai->fscount);
printf("Archive id: \t\t\t%.8x\n", (unsigned int)ai->archid);
printf("Archive file format: \t\t%s\n", ai->filefmt);
printf("Archive created with: \t\t%s\n", ai->creatver);
printf("Archive creation date: \t\t%s\n", format_time(buffer, sizeof(buffer), ai->creattime));
printf("Archive label: \t\t\t%s\n", ai->label);
if (ai->minfsaver > 0) // fsarchiver < 0.6.7 had no per-archive minfsaver version requirement
printf("Minimum fsarchiver version:\t%d.%d.%d.%d\n", (int)FSA_VERSION_GET_A(ai->minfsaver),
(int)FSA_VERSION_GET_B(ai->minfsaver), (int)FSA_VERSION_GET_C(ai->minfsaver), (int)FSA_VERSION_GET_D(ai->minfsaver));
printf("Compression level: \t\t%d (%s level %d)\n", ai->fsacomp, compalgostr(ai->compalgo), ai->complevel);
printf("Encryption algorithm: \t\t%s\n", cryptalgostr(ai->cryptalgo));
printf("\n");
meldungen_uebergeben(cryptalgostr(ai->cryptalgo),1);
return 0;
}
void SearchResults::addItem(int pos, bool progress)
{
int colPos[colCount];
getColPos(colPos);
int id = ListFrame::addItem(items[pos].data.name,
getApp()->getImageLibrary()->getListIndex("IconReplay"), pos);
if (colPos[colDate] >= 0 && items[pos].data.ftime)
setItemText(id, colPos[colDate], format_systime(items[pos].data.ftime, "%c"));
if (colPos[colSize] >= 0)
setItemText(id, colPos[colSize], String::format("%d KB", (items[pos].data.size + 1023) / 1024));
if (colPos[colName] >= 0)
setItemText(id, colPos[colName], items[pos].data.gameName);
if (colPos[colLineup] >= 0)
setItemText(id, colPos[colLineup], items[pos].data.lineup);
if (colPos[colLength] >= 0)
setItemText(id, colPos[colLength], format_time(items[pos].data.gameLength));
if (colPos[colMode] >= 0)
setItemText(id, colPos[colMode], items[pos].data.gameMode);
if (progress)
{
for (int i = 0; i < colCount; i++)
if (colPos[i] >= 0 && cfg.colWidth[i] < 0)
setColumnWidth(colPos[i], cfg.colWidth[i]);
}
}
int x_lockscreen(void)
{
set_user_status(ST_LOCKSCREEN);
screen_move(9, 0);
screen_clrtobot();
screen_move(9, 0);
prints("\033[1;37m"
"\n _ _____ ___ _ _ ___ ___ __"
"\n ( ) ( _ ) ( _`\\ ( ) ( ) ( _`\\ ( _`\\ | |"
"\n | | | ( ) | | ( (_) | |/'/' | (_(_) | | ) | | |"
"\n | | _ | | | | | | _ | , < | _)_ | | | ) | |"
"\n | |_( ) | (_) | | (_( ) | |\\`\\ | (_( ) | |_) | |==|"
"\n (____/' (_____) (____/' (_) (_) (____/' (____/' |__|\n"
//% "\n\033[1;36m屏幕已在\033[33m %s\033[36m 时被%s暂时锁住了...\033[m",
"\n\033[1;36m\xc6\xc1\xc4\xbb\xd2\xd1\xd4\xda\033[33m %s\033[36m \xca\xb1\xb1\xbb%s\xd4\xdd\xca\xb1\xcb\xf8\xd7\xa1\xc1\xcb...\033[m",
format_time(fb_time(), TIME_FORMAT_ZH), currentuser.userid);
char buf[PASSLEN + 1];
buf[0] = '\0';
while (*buf == '\0' || !passwd_check(currentuser.userid, buf)) {
screen_move(18, 0);
screen_clrtobot();
//% getdata(19, 0, "请输入您的密码以解锁: ", buf, PASSLEN, NOECHO, YEA);
getdata(19, 0, "\xc7\xeb\xca\xe4\xc8\xeb\xc4\xfa\xb5\xc4\xc3\xdc\xc2\xeb\xd2\xd4\xbd\xe2\xcb\xf8: ", buf, PASSLEN, NOECHO, YEA);
}
return FULLUPDATE;
}
/* todo: zrefaktoryzowac update_*table, bo moze wystarczy jedna funckcja? */
static void update_librarytable(AG_Event *event) {
AG_Table *tbl = AG_SELF();
if(libraryData) {
AG_TableBegin(tbl);
do {
if(libraryData->type == MPD_DATA_TYPE_SONG) {
if(libraryData->song->file &&
libraryData->song->title &&
libraryData->song->artist ) {
AG_TableAddRow(tbl, "%s:%s:%s:%s",
libraryData->song->artist,
libraryData->song->title,
format_time(libraryData->song->time),
libraryData->song->file);
}
}
libraryData = mpd_data_get_next(libraryData);
} while(libraryData);
AG_TableEnd(tbl);
}
}
int
open_log()
{
int flg = 0;
if (log_file && *log_file) {
if (!strcmp(log_file, tty_name)) {
logfp = stderr;
flg = -1;
}
else
logfp = fopen(log_file, "a");
if (logfp) {
fprintf(logfp, "%s%s log started\n",
format_time(), program_name);
fflush(logfp);
}
else
fprintf(stderr, "can't open \"%s\"\n", log_file);
}
else
logfp = NULL;
return flg;
}
static void update_playlisttable(AG_Event *event) {
AG_Table *tbl = AG_SELF();
if(playlistData) {
AG_TableBegin(tbl);
do {
if(playlistData->type == MPD_DATA_TYPE_SONG)
printf("%i, %s\n",
playlistData->song->id,
playlistData->song->title);
AG_TableAddRow(tbl, "%s:%s:%s:%i",
playlistData->song->artist,
playlistData->song->title,
format_time(playlistData->song->time),
playlistData->song->id);
playlistData = mpd_data_get_next(playlistData);
/*if(mpd_data_is_last(playlistData)) {
printf("last\n");
}*/
} while(playlistData);
AG_TableEnd(tbl);
}
}
static void
currently_playing_update_info (currently_playing_t *entry, xmmsv_t *value)
{
const gchar *noinfo_fields[] = { "playback_status", "playtime", "position"};
const gchar *time_fields[] = { "duration"};
xmmsv_t *info;
gint i;
info = xmmsv_propdict_to_dict (value, NULL);
enrich_mediainfo (info);
/* copy over fields that are not from metadata */
for (i = 0; i < G_N_ELEMENTS (noinfo_fields); i++) {
xmmsv_t *copy;
if (xmmsv_dict_get (entry->data, noinfo_fields[i], ©)) {
xmmsv_dict_set (info, noinfo_fields[i], copy);
}
}
/* pretty format time fields */
for (i = 0; i < G_N_ELEMENTS (time_fields); i++) {
gint32 tim;
if (xmmsv_dict_entry_get_int (info, time_fields[i], &tim)) {
gchar *p = format_time (tim, FALSE);
xmmsv_dict_set_string (info, time_fields[i], p);
g_free (p);
}
}
xmmsv_unref (entry->data);
entry->data = info;
}
String formatTip(int x, int y)
{
int level = 1;
while (level < 25 && ExpTable[level + 1] <= y)
level++;
return String::format("%s - %d", w3g ? w3g->formatTime(x) : format_time(x), level);
}
static int cmd_time(const char *args[])
{
uint64_t sec;
uint32_t nsec;
shw_pps_gen_get_time(&sec, &nsec);
if (args[2] && !strcasecmp(args[0], "set")) {
if (wrc_ptp_get_mode() != WRC_MODE_SLAVE) {
shw_pps_gen_set_time((uint64_t) atoi(args[1]),
atoi(args[2]), PPSG_SET_ALL);
return 0;
} else
return -EBUSY;
} else if (args[0] && !strcasecmp(args[0], "setsec")) {
if (wrc_ptp_get_mode() != WRC_MODE_SLAVE) {
shw_pps_gen_set_time((int64_t) atoi(args[1]), 0, PPSG_SET_SEC);
return 0;
}
} else if (args[0] && !strcasecmp(args[0], "setnsec")) {
if (wrc_ptp_get_mode() != WRC_MODE_SLAVE) {
shw_pps_gen_set_time(0, atoi(args[1]), PPSG_SET_NSEC);
return 0;
}
} else if (args[0] && !strcasecmp(args[0], "raw")) {
mprintf("%d %d\n", (uint32_t) sec, nsec);
return 0;
}
mprintf("%s +%d nanoseconds.\n", format_time(sec), nsec); /* fixme: clock freq is not always 125 MHz */
return 0;
}
static char *generate_content(const post_request_t *pr, const char *uname,
const char *nick, const char *ip, bool anony, size_t length)
{
UTF8_BUFFER(nick, NAMELEN);
convert_g2u(nick, utf8_nick);
char header[512];
snprintf(header, sizeof(header),
"发信人: %s (%s), 信区: %s\n标 题: %s\n发信站: %s (%s)\n\n",
uname, utf8_nick, pr->board->name, pr->title, BBSNAME_UTF8,
format_time(fb_time(), TIME_FORMAT_UTF8_ZH));
int header_len = strlen(header);
int content_len = length ? length : strlen(pr->content);
if (pr->convert_type != CONVERT_NONE)
content_len *= 2;
char signature[MAXSIGLINES * SIGNATURE_LINE_LEN + 5];
char utf8_signature[sizeof(signature) * 2 + 1];
if (!anony && pr->sig > 0) {
read_signature_legacy(uname, pr->sig, signature, sizeof(signature));
convert_g2u(signature, utf8_signature);
} else {
strlcpy(utf8_signature, "\n--", sizeof(utf8_signature));
}
int signature_len = strlen(utf8_signature);
char source[256] = { '\0' };
if (ip) {
char utf8_ip[80];
convert_g2u(ip, utf8_ip);
snprintf(source, sizeof(source), "\033[m\033[1;%2dm※ %s:·"BBSNAME_UTF8
" "BBSHOST"·%s[FROM: %s]\033[m\n", 31 + rand() % 7,
pr->crosspost ? "转载" : "来源", pr->web ? "HTTP " : "",
utf8_ip);
}
int source_len = strlen(source);
int total_len = header_len + content_len + signature_len + source_len + 2;
char *content = malloc(total_len);
memcpy(content, header, header_len);
if (pr->convert_type != CONVERT_NONE)
convert(pr->convert_type, pr->content, CONVERT_ALL,
content + header_len, total_len - header_len, NULL, NULL);
else
strlcpy(content + header_len, pr->content, total_len - header_len);
int len = strlen(content);
if (len < total_len)
memcpy(content + len, utf8_signature, total_len - len);
len += signature_len;
if (content[len - 1] != '\n' && len < total_len) {
content[len++] = '\n';
}
if (len < total_len)
memcpy(content + len, source, total_len - len);
content[len + source_len] = '\0';
return content;
}
void Destroy::exec(const Options &opts)
{
m_tag = opts.get_arg("tag");
if (m_tag.empty()) {
throw Exception("Tag must be specified");
}
std::string age_str = opts.get_arg("age");
if (age_str.empty()) {
throw Exception("Age must be specified");
}
system_clock::duration age_dur;
if (!parse_age(age_dur, age_str)) {
throw Exception("Invalid age format: " + age_str);
}
m_age = duration_cast<seconds>(age_dur).count();
m_recursive = opts.get("recursive");
m_defer = opts.get("defer");
m_dry_run = opts.get("dry_run");
m_verbose = opts.get_count("verbose");
system_clock::time_point now = system_clock::now();
m_now = duration_cast<seconds>(now.time_since_epoch()).count();
if (m_verbose) {
std::cout << format_time(now, "%Y.%m.%d %H:%M:%S", false)
<< " cleaning up\n"
<< " tag : " << m_tag << "\n"
<< " age : " << age_str << "\n";
}
m_datasets.clear();
for (auto &i : opts.ops()) {
find(i);
}
// Sort found datasets by timestamp.
m_datasets.sort([] (const Dataset &a, const Dataset &b) {
if (a.name < b.name)
return true;
if (a.name > b.name)
return false;
if (a.timestamp < b.timestamp)
return true;
return false;
});
for (auto &i : m_datasets) {
destroy(i.name);
}
if (m_verbose) {
std::cout << std::endl;
}
}
int
main(int argc, char **argv)
{
//time_transform();
format_time();
format_time_add();
return 0;
}
void print_date() {
// Current date/time based on current system
time_t now = time(0);
// Convert now to tm struct for local timezone
tm* localtm = localtime(&now);
std::cout << format_time(localtm) << ": ";
}
static void func_time(char *buf, int size, const procps_status_t *ps)
{
/* cumulative time [[dd-]hh:]mm:ss; here only mm:ss */
unsigned long mm;
mm = (ps->utime + ps->stime) / get_kernel_HZ();
format_time(buf, size, mm);
}
std::ostream &operator<<(std::ostream &os, const DateFormatter &rhs){
char str[256];
format_time(str, sizeof(str), rhs.time, true);
os <<'\'';
os <<str;
os <<'\'';
return os;
}
void StopWatch::start(const std::string& message) {
_initialized = true;
_start = clock();
_lap_start = _start;
logDebug("---> %s - [STARTED] %s\n", format_time(0).data(), message.data());
}
void StopWatch::stop(const std::string& message) {
if (_initialized) {
_end = clock();
clock_t diff = _end - _start;
logDebug("---> %s - [COMPLETED] %s\n", format_time(diff).data(), message.data());
}
}
static void func_etime(char *buf, int size, const procps_status_t *ps)
{
/* elapsed time [[dd-]hh:]mm:ss; here only mm:ss */
unsigned long mm;
mm = ps->start_time / get_kernel_HZ();
mm = G.seconds_since_boot - mm;
format_time(buf, size, mm);
}
static const char *
formatElapsedTime (int tm, AttrList *al , Formatter &)
{
int now;
if (al->LookupInteger(ATTR_LAST_HEARD_FROM , now)) {
return format_time(now - tm);
}
return "";
}
void CUplusTrace::Write(Trace_Level level, const char* fmt, ...)
{
if(m_ayslock1 == SEM_FAILED)
return;
char sv[64];
va_list vlist ;
va_start(vlist, fmt) ;
sem_wait(m_ayslock1);
sem_wait(&m_ayslock2);
m_file = fopen(m_filepath, "a+");
if(m_file)
{
if(level == Trace_Msg)
{
fprintf(m_file, "<MESSAGE>-[%s]: ", format_time(time(NULL), sv));
vfprintf(m_file, fmt, vlist);
fprintf(m_file, "\n");
fflush(m_file);
}
else if(level == Trace_Warning)
{
fprintf(m_file, "<WARNING>-[%s]: ", format_time(time(NULL), sv));
vfprintf(m_file, fmt, vlist);
fprintf(m_file, "\n");
fflush(m_file);
}
else if(level == Trace_Error)
{
fprintf(m_file, "< ERROR >-[%s]: ", format_time(time(NULL), sv));
vfprintf(m_file, fmt, vlist);
fprintf(m_file, "\n");
fflush(m_file);
}
fclose(m_file);
}
sem_post(m_ayslock1);
sem_post(&m_ayslock2);
va_end(vlist) ;
}
static void main_window_load(Window *window) {
// Create root layer
Layer *window_layer = window_get_root_layer(window);
GRect window_bounds = layer_get_bounds(window_layer);
// Create time TextLayer
s_time_layer = text_layer_create(GRect(0, 35, window_bounds.size.w, 44));
text_layer_set_background_color(s_time_layer, GColorClear);
text_layer_set_text_color(s_time_layer, GColorWhite);
text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter);
// Create date TextLayer
s_date_layer = text_layer_create(GRect(0, 82, window_bounds.size.w, 26));
text_layer_set_background_color(s_date_layer, GColorClear);
text_layer_set_text_color(s_date_layer, GColorWhite);
text_layer_set_text_alignment(s_date_layer, GTextAlignmentCenter);
text_layer_set_font(s_date_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));
// Create battery TextLayer
s_battery_layer = text_layer_create(GRect(window_bounds.size.w / 2, 0, (window_bounds.size.w / 2) - 2, 18));
text_layer_set_background_color(s_battery_layer, GColorClear);
text_layer_set_text_color(s_battery_layer, GColorWhite);
text_layer_set_text_alignment(s_battery_layer, GTextAlignmentRight);
text_layer_set_font(s_battery_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14));
// Create Pi time BitmapLayer
s_pi_bitmap = gbitmap_create_with_resource(RESOURCE_ID_PI_BACKGROUND);
s_pi_layer = bitmap_layer_create(GRect(0,17,144,150));
bitmap_layer_set_bitmap(s_pi_layer, s_pi_bitmap);
layer_set_hidden(bitmap_layer_get_layer(s_pi_layer), true);
// Create bluetooth BitmapLayer
s_bt_connected_bitmap = gbitmap_create_with_resource(RESOURCE_ID_BT_CONNECTED);
s_bt_disconnected_bitmap = gbitmap_create_with_resource(RESOURCE_ID_BT_DISCONNECTED);
s_bt_layer = bitmap_layer_create(GRect(3,3,12,11));
// Create bluetooth connected InverterLayer
s_inv_layer = inverter_layer_create(GRect(0,0,window_bounds.size.w,window_bounds.size.h));
// Initialize watch state
s_show_seconds_bool = true;
battery_handler(battery_state_service_peek());
bluetooth_handler(bluetooth_connection_service_peek());
format_time();
// Add all layers to the Window's root layer
layer_add_child(window_layer, text_layer_get_layer(s_time_layer));
layer_add_child(window_layer, text_layer_get_layer(s_battery_layer));
layer_add_child(window_layer, text_layer_get_layer(s_date_layer));
layer_add_child(window_layer, bitmap_layer_get_layer(s_bt_layer));
layer_add_child(window_layer, bitmap_layer_get_layer(s_pi_layer));
layer_add_child(window_layer, inverter_layer_get_layer(s_inv_layer));
}
static void update_time() {
// Get a tm structure
time_t temp = time(NULL);
struct tm *tick_time = localtime(&temp);
// Create a text buffers
static char buffer[] = "00:00:00";
static char date_buffer[16];
static char pi_start_buffer[] = "15:14:00";
static char pi_end_buffer[] = "15:15:00";
static char pi_cmp_buffer[] = "00:00:00";
// Check to see if it's time to hide the seconds
if (temp > s_hide_seconds_time_t) {
s_show_seconds_bool = false;
format_time();
}
// Detect Pi Time
strftime(pi_cmp_buffer, sizeof(pi_cmp_buffer), "%H:%M:%S", tick_time);
if(strcmp(pi_cmp_buffer, pi_start_buffer) == 0) {
layer_set_hidden(bitmap_layer_get_layer(s_pi_layer), false);
vibes_double_pulse();
}
if(strcmp(pi_cmp_buffer, pi_end_buffer) == 0) {
layer_set_hidden(bitmap_layer_get_layer(s_pi_layer), true);
}
// Write the current time into the buffer based on tap state
if(s_show_seconds_bool == true) {
if(clock_is_24h_style() == true) {
// Use 24 hour format
strftime(buffer, sizeof("00:00:00"), "%H:%M:%S", tick_time);
} else {
// Use 12 hour format
strftime(buffer, sizeof("00:00:00"), "%I:%M:%S", tick_time);
}
} else {
if(clock_is_24h_style() == true) {
// Use 24 hour format
strftime(buffer, sizeof("00:00"), "%H:%M", tick_time);
} else {
// Use 12 hour format
strftime(buffer, sizeof("00:00"), "%I:%M", tick_time);
}
}
// Display formatted time on the TextLayer
text_layer_set_text(s_time_layer, buffer);
// Parse date
strftime(date_buffer, sizeof(date_buffer), "%a %d %b", tick_time);
text_layer_set_text(s_date_layer, date_buffer);
}
extern void
load_dssw_times(DSSW *dssw, Tick start, Tick stop, Boolean set_no_time) {
char buf[10];
Props *p = (Props *)dssw->cal->properties;
DisplayType dt;
/*
* If start and stop times were specified, do the right thing to the
* dssw widget
*/
dt = get_int_prop(p, CP_DEFAULTDISP);
if (set_no_time == True){
strcpy(dssw->start_val.val, " ");
strcpy(dssw->stop_val.val, " ");
return;
}
if (start > 0) {
format_time(start, dt, buf);
if (dt == HOUR12) {
strncpy(dssw->start_val.val, buf, 5);
dssw->start_val.val[5] = '\0';
dssw->start_val.block = (buf[5] == 'a') ?
TIME_AM : TIME_PM;
} else {
strcpy(dssw->start_val.val, buf);
dssw->start_val.block = TIME_AM;
}
}
if (stop > 0) {
format_time(stop, dt, buf);
if (dt == HOUR12) {
strncpy(dssw->stop_val.val, buf, 5);
dssw->stop_val.val[5] = '\0';
dssw->stop_val.block = (buf[5] == 'a') ?
TIME_AM : TIME_PM;
} else {
strcpy(dssw->stop_val.val, buf);
dssw->stop_val.block = TIME_AM;
}
}
}
static void task_log_create(PTask pt, POptions po)
{
Action a = { pt->project_id, pt->id, 0 };
sprintf(a.message, "created task %d: %s (status: %s, priority: %s", pt->id, po->task.name, po->task.status, po->task.priority);
if (po->task.date > 0) sprintf(a.message + strlen(a.message), ", date: %s", format_date(po->task.date));
if (po->task.time > 0) sprintf(a.message + strlen(a.message), ", time: %s", format_time(po->task.time));
sprintf(a.message + strlen(a.message), ", project: %d)", pt->project_id);
pit_action(&a);
}
LINES comment::get_html(settings &S){
LINES returnval;
returnval.push_back("<li class=\"comment\">");
returnval.push_back("<p><strong>"+m_author+"</strong> ("+format_time(m_date,S.time_format,S.locale)+"):</p>");
for(LINES::const_iterator it=m_data.begin();it!=m_data.end();++it){
returnval.push_back(*it);
}
returnval.push_back("</li>");
return returnval;
}
