nxweek.cxx

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

					(temp_appt->y + temp_appt->h))) {
				    l_mark_appt = temp_appt;
				    break;
				}
				temp_appt = temp_appt->prev_appt;
			    }
			    if (l_mark_appt) {	// can't go left either which one ends first?
				if ((l_mark_appt->y + l_mark_appt->h) >
				    (r_mark_appt->y + r_mark_appt->h)) {
				    mark_appt = r_mark_appt;
				    left = 0;
				} else {
				    mark_appt = l_mark_appt;
				    left = 1;
				}
			    }
			}
		    }
		    if (l_mark_appt && r_mark_appt) {	// deterine which has bigger overlay
			int l_size = 0;
			int r_size = 0;

			r_size = Overlap(r_mark_appt);
			l_size = Overlap(l_mark_appt);

			if (r_size < l_size) {
			    left = 0;
			    mark_appt = r_mark_appt;
			} else if (r_size > l_size) {
			    mark_appt = l_mark_appt;
			    left = 1;
			} else
			    left = temp_left;
		    }

		    DPRINT("IN DOUBLE\n");
		    if (mark_appt && (temp_left != left)) {	// went the other way on top of another
			DPRINT("other way on top\n");
			if (left)
			    p_CurAppt->overlay = LEFT;
			else {
			    p_CurAppt->overlay = RIGHT;
			}
		    } else if (!mark_appt && (temp_left != left)) {	// went the other way alone
			DPRINT("other way alone\n");
			if (left)
			    p_CurAppt->overlay = LEFT;
			else {
			    p_CurAppt->overlay = RIGHT;
			}
		    } else if (!mark_appt && (left == temp_left)) {	// same way alone
			DPRINT("same alone\n");
			if (left)
			    p_CurAppt->overlay = LEFT;
			else {
			    p_CurAppt->overlay = RIGHT;
			}
		    } else {	// went the same way on top
			DPRINT("same on top\n");
			if (left)
			    p_CurAppt->overlay = LEFT;
			else {
			    p_CurAppt->overlay = RIGHT;
			}
		    }
		    GetOverlapDim(p_CurAppt, NULL);
		    break;
		} else {	// single overlay
		    GetOverlapDim(p_CurAppt, p_PrevAppt);
		    break;
		}
	    }
	    p_PrevAppt = p_PrevAppt->prev_appt;
	}
	if (single) {
	    DPRINT("GetOverlap: setting single appt overlay dim\n");
	    GetOverlapDim(NULL, p_CurAppt);
	}
	p_CurAppt = p_CurAppt->next_appt;
    }

}

void
WeekGrid::GetAppointments()
{
    int rec_array[255];
    int idx = 0;
    int jdx = 0;
    int numRecs = db->NumRecs(db_name);
    int recCount = 0;
    bool ret = false;
    appt *p_Appt = NULL;
    time_t start_time;
    time_t end_time;
    int wday = 0;
    tm *tt = NULL;
    NxTodo *note = new NxTodo;
    NxSchedule *pThis = (NxSchedule *) (NxApp::Instance());


    for (idx = 0; idx < 255; idx++)
	rec_array[idx] = -1;

    db->Select(db_name, rec_array, 255);

    idx = -1;

    //if(date_sunday != date_mark || numRecs != num_recs) { 
    memset(appt_array, 0, sizeof(appt_array));
    if (first_appt) {
	free_appts(first_appt);
	first_appt = NULL;
    }
    for (idx = 0; idx < 255; idx++) {
	if (-1 != rec_array[idx]) {
	    for (jdx = 0; jdx < 7; jdx++) {
		pThis->ExtractRecord(note, rec_array[idx]);
		ret = pThis->IsForToday(note, date_sunday + (jdx * 86400),
					date_sunday + ((jdx + 1) * 86400) -
					1);
		if (ret) {
		    tt = localtime(&note->startTime);
		    wday = tt->tm_wday;
		    start_time = note->startTime + ((jdx - wday) * 86400);
		    end_time = note->endTime + ((jdx - wday) * 86400);
		    MakeAppt(p_Appt, rec_array[idx], start_time, end_time);
		}
		if (recCount < numRecs && ret) {
		    p_Appt = appt_alloc();
		}
	    }
	    recCount++;
	}
    }
    date_mark = date_sunday;
    num_recs = numRecs;
    GetOverlap();

    note = NULL;
    delete note;
    //}
}

bool WeekGrid::MakeAppt(appt * p_Appt, int recno, time_t start_time,
			time_t end_time)
{
    appt *
	temp_appt =
	NULL;
    appt
	swap_appt;

    memset(&swap_appt, 0, sizeof(swap_appt));
    swap_appt.recno = recno;
    swap_appt.start_time = start_time;
    swap_appt.end_time = end_time;
    swap_appt.overlay = SINGLE;
    if (!first_appt) {
	first_appt = appt_alloc();
	memcpy(first_appt, &swap_appt, sizeof(swap_appt));
	GetApptDim(first_appt);
	return true;
    }
    memcpy(p_Appt, &swap_appt, sizeof(swap_appt));
    GetApptDim(p_Appt);
    temp_appt = first_appt;
    while (temp_appt) {
	if (temp_appt->start_time >= p_Appt->start_time) {
	    if (temp_appt->prev_appt)
		temp_appt->prev_appt->next_appt = p_Appt;
	    p_Appt->prev_appt = temp_appt->prev_appt;
	    p_Appt->next_appt = temp_appt;
	    temp_appt->prev_appt = p_Appt;
	    if (temp_appt == first_appt) {
		first_appt = p_Appt;
	    }
	    break;
	}
	if (!temp_appt->next_appt) {	// insert here at end
	    p_Appt->prev_appt = temp_appt;
	    temp_appt->next_appt = p_Appt;
	    break;
	}
	temp_appt = temp_appt->next_appt;
    }
    return true;
}

bool WeekGrid::IsForWeek(time_t start_time, time_t end_time)
{
    time_t
	date_sat =
	date_sunday + (7 * 86400) -
	1;

    DPRINT("date_sunday [%ld] date_sat [%ld]\n", date_sunday, date_sat);

    if (start_time >= date_sunday && start_time <= date_sat)
	return true;
    else if (end_time <= date_sat && end_time >= date_sunday)
	return true;
    else
	return false;
}


void
WeekGrid::GetApptDim(appt * p_Appt)
{
    time_t new_time = p_Appt->start_time;
    int hour;
    int min;
    int wday;
    double h;
    double y;
    char buf[16];
    tm *tt = localtime(&new_time);

    p_Appt->x = (b_width * tt->tm_wday);

    hour = tt->tm_hour;
    min = tt->tm_min;
    wday = tt->tm_wday;

    y = (wday * day_pix) + (hour * 3600) * pix_ratio + (min * 60) * pix_ratio;
    sprintf(buf, "%.0f", y);
    p_Appt->y = strtol(buf, NULL, 10);

    new_time = p_Appt->end_time;
    tt = localtime(&new_time);

    hour = tt->tm_hour;
    min = tt->tm_min;
    wday = tt->tm_wday;

    h = (wday * day_pix) + (hour * 3600) * pix_ratio + (min * 60) * pix_ratio;
    h = h - p_Appt->y;
    sprintf(buf, "%.0f", h);
    p_Appt->h = strtol(buf, NULL, 10);
    DPRINT("p_Appt->y [%f] p_Appt->h [%f]\n", p_Appt->y, p_Appt->h);
}

appt *
appt_alloc(void)
{
    appt *p_appt;

    p_appt = (appt *) malloc(sizeof(appt));
    memset(p_appt, 0, sizeof(appt));
    return p_appt;
}

void
free_appts(appt * app)
{
    appt *swap_appt;

    DPRINT("FREEING APPTS\n");
    while (app) {
	swap_appt = app;
	app = app->next_appt;
	DPRINT("FREEING [%d]\n", swap_appt->recno);
	free(swap_appt);
	swap_appt = NULL;
    }
}

double
WeekGrid::GetOffSet(double val)
{
    int num = (int) (val / day_pix);
    double close = num * day_pix;
    double rem = val - close;

    return rem;
}

int
WeekGrid::GetGridVal()
{
    int dy = 0;

    switch (scroll_count) {
    case 0:
	dy = 0;
	break;
    case 1:
	dy = 4 * b_height;
	break;
    case 2:
	dy = 6 * b_height;
	break;
    default:
	dy = 0;
    }
    return dy;
}

void
WeekGrid::DrawAppointments()
{
    int dy = 0;

    if (NULL == db)
	return;

    GetAppointments();
    dy = GetGridVal();
    DrawOverlaps(dy);
    DrawRects(dy);
}

void
WeekGrid::DrawOverlaps(int dy)
{
    int col = 0;
    int row = 0;
    double h_val = 0;
    double dec = 0;
    int last_val = 0;
    int low_val;
    int hi_val;
    int H;
    int start_row = 0;
    double y_val;
    int Y;
    int X;
    int x_off;
    int next_val;
    int width;
    double rem = 0;
    int offset = 0;

    // go low
    for (col = 0; col <= 6; col++) {
	for (row = 0; row <= 287; row++) {
	    if (0 == (appt_array[col][row] & APPT_MASK)) {
		last_val = 0;
		h_val = 0;
		continue;
	    } else {
		low_val = appt_array[col][row] & APPT_MASK;
		next_val = low_val;
		h_val = 1;
		start_row = row;
		H = Y = 0;
		while ((next_val == low_val) && (row <= 287)) {
		    DPRINT("h_val [%f]\n", h_val);
		    h_val++;
		    row++;
		    next_val = appt_array[col][row] & APPT_MASK;
		}

		width = b_width / 2 - 4;
		X = (col * b_width);
		x_off = X + width;

		y_val = (5 * start_row) * 60 * pix_ratio;
		Y = (int) y_val;
		dec = y_val - Y;
		if (dec > .5)
		    y_val++;
		Y = (int) y_val;

		h_val = (5 * h_val) * 60 * pix_ratio;
		H = (int) h_val;
		dec = h_val - H;
		if (dec > .5)
		    h_val++;
		H = (int) h_val;

		DPRINT("Y [%d] x_off [%d] w [%d] H [%d]\n", Y, x_off, width,
		       H);
		DPRINT("dy [%d]\n", dy);
		if (dy > Y - 2) {
		    DPRINT("HERE\n");
		    if ((Y + H) > dy) {
			DPRINT("H big\n");
			H = (Y + H) - dy;
			Y = 0;
		    } else
			H = 0;
		} else {
		    DPRINT("Y [%d] H [%d]\n", Y, H);
		    // correct Y

		    rem = GetOffSet((double) Y);
		    offset = Y;
		    Y = (int) rem - dy;
		    if (offset >= (dy + (int) (6.5 * b_height)))
			H = 0;
		    else if ((offset + H) <= dy)
			H = 0;
		    else if ((offset + H) > (dy + (int) (6.5 * b_height))) {
			H = (int) (6.5 * b_height) - Y;
		    }

		    if (H > (int) (6.5 * b_height))
			H = (int) (6.5 * b_height);

		}

		switch (low_val) {
		case 0:
		    break;
		case 1:
		    fl_color(FL_LIGHT3);
		    break;
		case 2:
		    fl_color(FL_LIGHT1);
		    break;
		case 3:
		    fl_color(FL_DARK1);
		    break;
		case 4:
		    fl_color(FL_DARK3);
		    break;
		default:
		    fl_color(FL_LIGHT3);
		    break;
		}
		DPRINT("Y [%d] x_off [%d] w [%d] H [%d]\n", Y, x_off, width,
		       H);
		if (H > 0 && low_val)
		    fl_rectf(x_off + 4 + x(), Y + y(), width, H - 1);
	    }
	}
    }

    // go high
    for (col = 0; col <= 6; col++) {
	for (row = 0; row <= 287; row++) {
	    if (0 == (appt_array[col][row] >> 4)) {
		last_val = 0;
		h_val = 0;
		continue;
	    } else {
		hi_val = appt_array[col][row] >> 4;
		next_val = hi_val;
		h_val = 1;
		start_row = row;
		while ((next_val == hi_val) && (row <= 287)) {
		    h_val++;
		    row++;
		    next_val = appt_array[col][row] >> 4;
		}

		width = b_width / 2 - 4;
		X = (col * b_width);
		x_off = X;

		y_val = (5 * start_row) * 60 * pix_ratio;
		Y = (int) y_val;
		dec = y_val - Y;
		if (dec > .5)
		    y_val++;
		Y = (int) y_val;

		h_val = (5 * h_val) * 60 * pix_ratio;
		H = (int) h_val;
		dec = h_val - H;
		if (dec > .5)
		    h_val++;
		H = (int) h_val;

		if (dy > Y - 2) {
		    if ((Y + H) > dy) {
			H = (Y + H) - dy;
			Y = 0;
		    } else
			H = 0;
		} else {
		    rem = GetOffSet((double) Y);
		    offset = Y;
		    Y = (int) rem - dy;
		    if (offset >= (dy + (int) (6.5 * b_height)))
			H = 0;
		    else if ((offset + H) <= dy)
			H = 0;
		    else if ((offset + H + 2) > (dy + (int) (6.5 * b_height))) {
			H = (int) (6.5 * b_height) - Y;
		    }

		    if (H > (int) (6.5 * b_height))
			H = (int) (6.5 * b_height);

		}

		switch (hi_val) {
		case 0:
		    break;
		case 1:
		    fl_color(FL_LIGHT3);
		    break;
		case 2:
		    fl_color(FL_LIGHT1);
		    break;