nxrepeat.cxx

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

    pThis->resetUi(REPEAT_MONTHLY);
    pThis->every_box->label("Month(s)");
    pThis->no_repeat->value(0);
    pThis->day_repeat->value(0);
    pThis->week_repeat->value(0);
    pThis->month_repeat->value(1);
    pThis->year_repeat->value(0);
    pThis->setMonthValue();
    pThis->repeatShow_ui();
    pThis->month_day->show();
    pThis->month_date->show();
    pThis->month_box->show();
    pThis->every_input->do_callback();
}

void
NxSchedule::repeatYearButton_callback(Fl_Widget * w, void *l)
{
    NxSchedule *pThis = (NxSchedule *) l;

    pThis->resetUi(REPEAT_YEARLY);
    pThis->every_box->label("Year(s)");
    pThis->no_repeat->value(0);
    pThis->day_repeat->value(0);
    pThis->week_repeat->value(0);
    pThis->month_repeat->value(0);
    pThis->year_repeat->value(1);
    pThis->repeatShow_ui();
    pThis->every_input->do_callback();
}

void
NxSchedule::getRepeatData()
{
    NxTodo *n = m_pCurrentItem;
    static char date_buf[30];
    static char repeat_num[4];

    memset(date_buf, 0, sizeof(date_buf));

    if (0 >= n->repeatFlag_3) {
	end_list->label("No End Date");
	repeatDate = 0;
	every_input->value("1");
    } else {
	strftime(date_buf, 29, "%a %m/%d/%Y", localtime(&n->repeatFlag_3));
	repeatDate = n->repeatFlag_3;
	end_list->label(date_buf);
	if (n->repeatFlag_2 > 99)
	    n->repeatFlag_2 = 99;
	if (n->repeatFlag_2 < 0)
	    n->repeatFlag_2 = 0;
	sprintf(repeat_num, "%d", n->repeatFlag_2);
	every_input->value(repeat_num);
    }

    switch (n->repeatFlag_1) {
    case REPEAT_NONE:
	repeatDate = 0;
	end_list->label("No End Date");
	no_repeat->do_callback();
	break;
    case REPEAT_DAILY:
	day_repeat->do_callback();
	break;
    case REPEAT_WEEKLY:
	week_repeat->do_callback();
	break;
    case REPEAT_MONTHLY:
	month_repeat->do_callback();
	break;
    case REPEAT_YEARLY:
	year_repeat->do_callback();
	break;
    default:
	break;
    }

}

void
NxSchedule::setWeekValue()
{
    long val = m_pCurrentItem->repeatWkMonFlag;
    time_t today = m_pCurrentItem->startTime;	//time(0);
    tm *tt = localtime(&today);

    for (int idx = 0; idx < 7; idx++)
	m_WeekButtons[idx]->value(0);

    if (0 == val) {
	m_WeekButtons[tt->tm_wday]->value(1);
	return;
    }

    if (REPEAT_WEEK_SUNDAY & val)
	m_WeekButtons[0]->value(1);
    if (REPEAT_WEEK_MONDAY & val)
	m_WeekButtons[1]->value(1);
    if (REPEAT_WEEK_TUESDAY & val)
	m_WeekButtons[2]->value(1);
    if (REPEAT_WEEK_WEDNESDAY & val)
	m_WeekButtons[3]->value(1);
    if (REPEAT_WEEK_THURSDAY & val)
	m_WeekButtons[4]->value(1);
    if (REPEAT_WEEK_FRIDAY & val)
	m_WeekButtons[5]->value(1);
    if (REPEAT_WEEK_SATURDAY & val)
	m_WeekButtons[6]->value(1);
}

void
NxSchedule::setMonthValue()
{
    long val = m_pCurrentItem->repeatWkMonFlag;

    if (0 == val) {
	month_date->value(1);
	month_day->value(0);
	return;
    }

    if (REPEAT_MONTH_DAY & val) {
	month_date->value(0);
	month_day->value(1);
    } else {
	month_day->value(0);
	month_date->value(1);
    }
}

long
NxSchedule::getWeekValue()
{
    long val = 0;

    for (int idx = 0; idx < 7; idx++) {
	if (m_WeekButtons[idx]->value()) {
	    switch (idx) {
	    case 0:
		val |= REPEAT_WEEK_SUNDAY;
		break;
	    case 1:
		val |= REPEAT_WEEK_MONDAY;
		break;
	    case 2:
		val |= REPEAT_WEEK_TUESDAY;
		break;
	    case 3:
		val |= REPEAT_WEEK_WEDNESDAY;
		break;
	    case 4:
		val |= REPEAT_WEEK_THURSDAY;
		break;
	    case 5:
		val |= REPEAT_WEEK_FRIDAY;
		break;
	    case 6:
		val |= REPEAT_WEEK_SATURDAY;
		break;
	    default:
		break;
	    }
	}
    }
    return val;
}

long
NxSchedule::getMonthValue()
{

    if (month_date->value())
	return REPEAT_MONTH_DATE;
    else
	return REPEAT_MONTH_DAY;
}

long
NxSchedule::getRepeatValue()
{
    if (no_repeat->value())
	return REPEAT_NONE;
    else if (day_repeat->value())
	return REPEAT_DAILY;
    else if (week_repeat->value())
	return REPEAT_WEEKLY;
    else if (month_repeat->value())
	return REPEAT_MONTHLY;
    else if (year_repeat->value())
	return REPEAT_YEARLY;
    else
	return REPEAT_NONE;
}

void
NxSchedule::wordValue(int val, char *th_val)
{
    char val_buf[8];
    int len;
    char num_char;

    sprintf(val_buf, "%d", val);
    len = strlen(val_buf);

    if (11 <= val && 13 >= val) {
	sprintf(th_val, "%dth", val);
	return;
    }

    num_char = val_buf[len - 1];

    switch (num_char) {
    case '1':
	sprintf(th_val, "%dst", val);
	return;
    case '2':
	sprintf(th_val, "%dnd", val);
	return;
    case '3':
	sprintf(th_val, "%drd", val);
	return;
    default:
	sprintf(th_val, "%dth", val);
	return;
    }
}

void
NxSchedule::repeatEveryInput_callback(Fl_Widget * w, void *l)
{
    NxSchedule *pThis = (NxSchedule *) l;
    long repeat_val = pThis->getRepeatValue();
    int sing_flag = 0;
    int dbl_flag = 0;
    int th_flag = 0;
    static char message_buf[100];
    char repeat_str[6];
    int len = 0;
    char val_buf[8];
    char num_buf[4];
    char num_char;
    int num_val = 0;

    if (0 == strcmp("", pThis->every_input->value()) ||
	(0 == strcmp("1", pThis->every_input->value())) ||
	(0 == strcmp("0", pThis->every_input->value())) ||
	(0 == strcmp("00", pThis->every_input->value()))) {
	sing_flag = 1;
	strcpy(repeat_str, "");
    }

    if (0 == strcmp("2", pThis->every_input->value())) {
	dbl_flag = 1;
	strcpy(repeat_str, "other");
    }

    strcpy(val_buf, pThis->every_input->value());
    len = strlen(val_buf);

    if (len > 1) {
	memset(num_buf, 0, sizeof(num_buf));
	strcpy(num_buf, val_buf);
	num_val = atoi(num_buf);
	if (11 <= num_val && 13 >= num_val) {
	    th_flag = 1;
	    sprintf(repeat_str, "%dth", num_val);
	}
    }

    if (!sing_flag && !dbl_flag && !th_flag) {
	num_char = val_buf[len - 1];

	num_val = atoi(pThis->every_input->value());

	switch (num_char) {
	case '1':
	    sprintf(repeat_str, "%dst", num_val);
	    break;
	case '2':
	    sprintf(repeat_str, "%dnd", num_val);
	    break;
	case '3':
	    sprintf(repeat_str, "%drd", num_val);
	    break;
	default:
	    sprintf(repeat_str, "%dth", num_val);
	    break;
	}
    }

    tm *tt;
    switch (repeat_val) {
    case REPEAT_NONE:
	sprintf(message_buf, "No Repeat");
	break;
    case REPEAT_DAILY:
	sprintf(message_buf, "Every %s day", repeat_str);
	break;
    case REPEAT_WEEKLY:
	pThis->formatWeekMsg(message_buf, repeat_str);
	break;
    case REPEAT_MONTHLY:
	pThis->formatMonthMsg(message_buf, repeat_str);
	break;
    case REPEAT_YEARLY:
	tt = localtime(&(pThis->m_CurrentDay));
	strftime(message_buf, 99, "%b ", tt);
	pThis->wordValue(tt->tm_mday, val_buf);
	strcat(message_buf, val_buf);
	strcat(message_buf, " Every ");
	strcat(message_buf, repeat_str);
	strcat(message_buf, " year");
	break;
    default:
	sprintf(message_buf, "Need to handle case %s", repeat_str);
	break;
    }
    pThis->repeat_output->label(message_buf);
    //      pThis->repeat_output->hide();
    //      pThis->repeat_output->show();
}

int
NxSchedule::getMonthDayRepeat(time_t date)
{
    tm *tt = localtime(&date);
    int month = tt->tm_mon;
    int count = 0;

    while (month == tt->tm_mon) {
	count++;
	tt->tm_mday = tt->tm_mday - 7;
	mktime(tt);
    }
    return count;
}

void
NxSchedule::formatMonthMsg(char *msg, char *repeat_str)
{
    long val = 0;
    static char date[30];
    char day_val[8];
    tm *tt = localtime(&m_CurrentDay);
    int week_repeat = 0;

    val = getMonthValue();

    if (REPEAT_MONTH_DATE & val) {
	wordValue(tt->tm_mday, day_val);
	sprintf(msg, "The %s of every %s month", day_val, repeat_str);
    } else {
	strftime(date, 29, "%A", tt);
	week_repeat = getMonthDayRepeat(m_CurrentDay);
	wordValue(week_repeat, day_val);
	sprintf(msg, "The %s %s of every %s month", day_val, date,
		repeat_str);
    }
}

void
NxSchedule::formatWeekMsg(char *msg, char *repeat_str)
{
    int count = 0;
    int day_count = 0;
    int idx = 0;
    long val = 0;

    for (idx = 0; idx < 7; idx++) {
	if (m_WeekButtons[idx]->value())
	    count++;
    }

    if (1 == count) {
	val = getWeekValue();
	if (REPEAT_WEEK_SUNDAY & val)
	    sprintf(msg, "Every %s week on Sunday", repeat_str);
	if (REPEAT_WEEK_MONDAY & val)
	    sprintf(msg, "Every %s week on Monday", repeat_str);
	if (REPEAT_WEEK_TUESDAY & val)
	    sprintf(msg, "Every %s week on Tuesday", repeat_str);
	if (REPEAT_WEEK_WEDNESDAY & val)
	    sprintf(msg, "Every %s week on Wednesday", repeat_str);
	if (REPEAT_WEEK_THURSDAY & val)
	    sprintf(msg, "Every %s week on Thursday", repeat_str);
	if (REPEAT_WEEK_FRIDAY & val)
	    sprintf(msg, "Every %s week on Friday", repeat_str);
	if (REPEAT_WEEK_SATURDAY & val)
	    sprintf(msg, "Every %s week on Friday", repeat_str);
    } else {
	sprintf(msg, "Every %s week on", repeat_str);
	day_count = 0;
	for (idx = 0; idx < 7; idx++) {
	    if (m_WeekButtons[idx]->value()) {
		day_count++;
		if (0 != day_count) {
		    if (count > 2 && day_count > 1)
			strcat(msg, ", ");
		    if (count == day_count)
			strcat(msg, " and");
		}
		switch (idx) {
		case 0:
		    strcat(msg, " Sun");
		    break;
		case 1:
		    strcat(msg, " Mon");
		    break;
		case 2:
		    strcat(msg, " Tue");
		    break;
		case 3:
		    strcat(msg, " Wed");
		    break;
		case 4:
		    strcat(msg, " Thur");
		    break;
		case 5:
		    strcat(msg, " Fri");
		    break;
		case 6:
		    strcat(msg, " Sat");
		    break;
		default:
		    break;
		}
	    }
	}
    }

    int width = (int) fl_width(msg);

    if (width > repeat_output->w()) {

	int len = strlen(msg);
	idx = 0;

	while (width > repeat_output->w() - 5) {

	    char test[100];

	    idx++;
	    memset(test, 0, sizeof(test));
	    strncpy(test, msg, len - idx);
	    width = (int) fl_width(test);
	}

	while (!isspace(msg[len - idx])) {
	    idx++;
	}
	msg[len - idx] = '\n';
    }
}

void
NxSchedule::weekDay_callback(Fl_Widget * w, void *l)
{
    NxSchedule *pThis = (NxSchedule *) l;
    tm *tt = localtime(&pThis->m_CurrentDay);

    if (0 == pThis->getWeekValue()) {
	pThis->m_WeekButtons[tt->tm_wday]->value(1);
    }
    every_input->do_callback();
}

void
NxSchedule::monthDayDate_callback(Fl_Widget * w, void *l)
{
    NxSchedule *pThis = (NxSchedule *) l;

    if (w == pThis->month_date) {
	pThis->month_date->value(1);
	pThis->month_day->value(0);
    } else {
	pThis->month_day->value(1);
	pThis->month_date->value(0);
    }

    every_input->do_callback();
}