axes.cpp

Linux/windows 环境下跨平台开发程序

			break;
		case SIZE_AXIS_TICKS:
			sizAxTick = value;
			break;
		case SIZE_TICK_ANGLE:
			tick_angle = value;
			break;
			}
		if(Ticks && NumTicks) for(i = 0; i < NumTicks; i++) 
			if(Ticks[i]) Ticks[i]->SetSize(select, value);
		break;
	default:
		return false;
		}
	return true;
}

bool
Axis::SetColor(int select, DWORD col)
{
	int i;

	switch(select & 0xfff) {
	case COL_AXIS:
		if(colAxis == col) return true;
		if(select & UNDO_STORESET){
			Undo.ValDword(this, &colAxis, UNDO_CONTINUE);
			Undo.ValDword(this, &tlbdef.ColTxt, UNDO_CONTINUE);
			}
		colAxis = col;
		if (axis && (axis->flags & AXIS_ANGULAR) || (axis->flags & AXIS_RADIAL)) {
			GridLine.color = colAxis;
			}
		if(Ticks && NumTicks) for(i = 0; i < NumTicks; i++)
			if(Ticks[i]) Ticks[i]->SetColor(select, colAxis);
		if(axisLabel) axisLabel->SetColor((select & UNDO_STORESET) ? 
			COL_TEXT | UNDO_STORESET : COL_TEXT, col);
		tlbdef.ColTxt = col;
		return true;
	case COL_BG:
		if(Ticks && NumTicks) for(i = 0; i < NumTicks; i++)
			if(Ticks[i]) Ticks[i]->SetColor(select, col);
		if(axisLabel) axisLabel->SetColor(select, col);
		return true;
		}
	return false;
}

void
Axis::DoPlot(anyOutput *o)
{
	lfPOINT fp1, fp2;
	fPOINT3D loc, cu1, cu2, rc;
	double tmp, dx, dy;
	int i, j, ix, iy;
	fRECT scaleRC;
	AxisDEF tmp_axis;

	if(!o || !parent) return;
	if(mo)DelBitmapClass(mo);		mo = 0L;
	if(l_segs){
		for (i = 0; i < nl_segs; i++) if(l_segs[i]) delete(l_segs[i]);
		free(l_segs);		l_segs = 0L;		nl_segs = 0;
		}
	dx = parent->GetSize(SIZE_GRECT_LEFT);	dy = parent->GetSize(SIZE_GRECT_TOP);
	if(!type) {
		if(fabs(axis->loc[1].fx - axis->loc[0].fx) > 
			fabs(axis->loc[1].fy - axis->loc[0].fy)) {
			if((axis->flags) & AXIS_3D){
				if(fabs(axis->loc[1].fz - axis->loc[0].fz) > 
					fabs(axis->loc[1].fx - axis->loc[0].fx)) type = 3;
				else type = 1;
				}
			else type = 1;
			}
		else {
			if((axis->flags) & AXIS_3D){
				if(fabs(axis->loc[1].fz - axis->loc[0].fz) > 
					fabs(axis->loc[1].fy - axis->loc[0].fy)) type = 3;
				else type = 2;
				}
			else type = 2;
			}
		}
	//find default type for grid lines
	if(!gl_type){
		if(axis->flags & AXIS_3D) {
			switch(type) {
			case 1:		gl_type = 0x30;			break;
			case 2:		gl_type = 0x0c;			break;
			case 3:		gl_type = 0x03;			break;
			default:	gl_type = 0x26;			break;
				}
			}
		else {
			gl_type = type == 2 ? DL_LEFT | DL_RIGHT : DL_TOP | DL_BOTTOM;
			}
		}
	if(!Ticks && (axis->flags & 0x03) != AXIS_NOTICKS)CreateTicks();
	if(axis->owner == this && !scaleOut) scaleOut = new anyOutput();
	if(scaleOut) {
		// set scaling information in scaleOut
		scaleOut->hres = o->hres;			scaleOut->vres = o->vres;
		scaleOut->VPscale = o->VPscale;
		scaleOut->VPorg.fx = o->VPorg.fx;	scaleOut->VPorg.fy = o->VPorg.fy;
		memcpy(&tmp_axis, axis, sizeof(AxisDEF));
		tmp_axis.loc[0].fx += dx;		tmp_axis.loc[1].fx += dx;
		tmp_axis.loc[0].fy += dy;		tmp_axis.loc[1].fy += dy;
		if(parent->Id == GO_PLOT3D && (axis->flags & AXIS_3D)) {
			//set 3D information in scaleOut
			cu1.fx = axis->loc[0].fx +dx;	cu1.fy = axis->loc[0].fy +dy;
			cu1.fz = axis->loc[0].fz;		cu2.fx = axis->loc[1].fx +dx;
			cu2.fy = axis->loc[1].fy +dy;	cu2.fz = axis->loc[1].fz;
			rc.fx = parent->GetSize(SIZE_XCENTER) +dx;
			rc.fy = parent->GetSize(SIZE_YCENTER) +dy;
			rc.fz = parent->GetSize(SIZE_ZCENTER);
			scaleOut->SetSpace(&cu1, &cu2, defs.cUnits, ((Plot3D*)parent)->RotDef, &rc, 
				&tmp_axis, &tmp_axis, &tmp_axis);
			}
		else {
			// set axis and rectangle in scaleOut
			scaleRC.Xmin = scaleRC.Xmax = dx;
			scaleRC.Ymin = scaleRC.Ymax = dy;
			scaleRC.Xmin += axis->loc[0].fx;		scaleRC.Ymin += axis->loc[1].fy;
			scaleRC.Xmax += axis->loc[1].fx;		scaleRC.Ymax += axis->loc[0].fy;
			scaleOut->SetRect(scaleRC, o->units, &tmp_axis, &tmp_axis);
			}
		}
	axline.width = sizAxLine;
	axline.patlength = 1.0;
	axline.color = colAxis;
	axline.pattern = 0L;		//solid line, no pattern
	o->SetLine(&axline);
	if(axis->flags & AXIS_ANGULAR) {
		pts[1].x = i = o->un2ix(axis->Radius);		pts[1].y = j = o->un2iy(axis->Radius);
		pts[0].x = ix = o->co2ix(axis->Center.fx + dx);
		pts[0].y = iy = o->co2iy(axis->Center.fy + dy);
		o->oCircle(ix-i, iy-j, ix+i, iy+j);
		if(Ticks && NumTicks) for(i = 0; i < NumTicks; i++) 
			if(Ticks[i]) Ticks[i]->DoPlot(0.0, 1.0, o);
		rDims.left = ix-i;	rDims.right = ix +i;
		rDims.top = iy -i;	rDims.bottom = iy+i;
		IncrementMinMaxRect(&rDims, o->un2ix(axline.width*4.0));
		return;
		}
	if(axis->flags & AXIS_3D){
		loc.fx= axis->loc[0].fx;	loc.fy= axis->loc[0].fy;	loc.fz = axis->loc[0].fz;	
		o->cvec2ivec(&loc, &flim[0]);
		loc.fx= axis->loc[1].fx;	loc.fy= axis->loc[1].fy;	loc.fz = axis->loc[1].fz;	
		o->cvec2ivec(&loc, &flim[1]);
		}
	else {
		flim[0].fz = flim[1].fz = 0.0;
		if(parent) switch(axis->flags & 0x70) {
		case AXIS_USER:				//leave unchanged
			fp1.fx = axis->loc[0].fx;		fp1.fy = axis->loc[0].fy;
			fp2.fx = axis->loc[1].fx;		fp2.fy = axis->loc[1].fy;
			break;
		case AXIS_LEFT:
			if(axis->flags & AXIS_X_DATA) {
				axis->loc[0].fx = axis->loc[1].fx =	fp1.fx = fp2.fx = 
					parent->GetSize(SIZE_BOUNDS_LEFT);
				}
			else {
				axis->loc[0].fx = axis->loc[1].fx =	fp1.fx = fp2.fx = 
					parent->GetSize(SIZE_DRECT_LEFT);
				}
			if(axis->flags & AXIS_Y_DATA) {
				fp1.fy = parent->GetSize(SIZE_BOUNDS_BOTTOM);
				fp2.fy = parent->GetSize(SIZE_BOUNDS_TOP);
				}
			else {
				fp1.fy = parent->GetSize(SIZE_DRECT_TOP);
				fp2.fy = parent->GetSize(SIZE_DRECT_BOTTOM);
				}
			break;
		case AXIS_RIGHT:
			if(axis->flags & AXIS_X_DATA) {
				axis->loc[0].fx = axis->loc[1].fx = fp1.fx = fp2.fx = 
					parent->GetSize(SIZE_BOUNDS_RIGHT);
				}
			else {
				axis->loc[0].fx = axis->loc[1].fx =	fp1.fx = fp2.fx = 
					parent->GetSize(SIZE_DRECT_RIGHT);
				}
			if(axis->flags & AXIS_Y_DATA) {
				fp1.fy = parent->GetSize(SIZE_BOUNDS_BOTTOM);
				fp2.fy = parent->GetSize(SIZE_BOUNDS_TOP);
				}
			else {
				fp1.fy = parent->GetSize(SIZE_DRECT_TOP);
				fp2.fy = parent->GetSize(SIZE_DRECT_BOTTOM);
				}
			break;
		case AXIS_TOP:
			if(axis->flags & AXIS_Y_DATA) {
				axis->loc[0].fy = axis->loc[1].fy = fp1.fy = fp2.fy = 
					parent->GetSize(SIZE_BOUNDS_TOP);
				}
			else {
				axis->loc[0].fy = axis->loc[1].fy = fp1.fy = fp2.fy = 
					parent->GetSize(SIZE_DRECT_TOP);
				}
			if(axis->flags & AXIS_X_DATA) {
				fp1.fx = parent->GetSize(SIZE_BOUNDS_LEFT);
				fp2.fx = parent->GetSize(SIZE_BOUNDS_RIGHT);
				}
			else {
				fp1.fx = parent->GetSize(SIZE_DRECT_LEFT);
				fp2.fx = parent->GetSize(SIZE_DRECT_RIGHT);
				}
			break;
		case AXIS_BOTTOM:
			if(axis->flags & AXIS_Y_DATA) {
				axis->loc[0].fy = axis->loc[1].fy = fp1.fy = fp2.fy =
					parent->GetSize(SIZE_BOUNDS_BOTTOM);
				}
			else {
				axis->loc[0].fy = axis->loc[1].fy = fp1.fy = fp2.fy = 
					parent->GetSize(SIZE_DRECT_BOTTOM);
				}
			if(axis->flags & AXIS_X_DATA) {
				fp1.fx = parent->GetSize(SIZE_BOUNDS_LEFT);
				fp2.fx = parent->GetSize(SIZE_BOUNDS_RIGHT);
				}
			else {
				fp1.fx = parent->GetSize(SIZE_DRECT_LEFT);
				fp2.fx = parent->GetSize(SIZE_DRECT_RIGHT);
				}
			break;
			}
		if(axis->flags & AXIS_X_DATA) {
			flim[0].fx = o->fx2fix(fp1.fx);		flim[1].fx = o->fx2fix(fp2.fx);
			}
		else {
			flim[0].fx = o->co2fix(fp1.fx + dx);	flim[1].fx = o->co2fix(fp2.fx + dx);
			axis->loc[0].fx = fp1.fx;	axis->loc[1].fx = fp2.fx;
			}
		if(axis->flags & AXIS_Y_DATA) {
			flim[0].fy = o->fy2fiy(fp1.fy);		flim[1].fy = o->fy2fiy(fp2.fy);
			}
		else {
			flim[0].fy = o->co2fiy(fp1.fy + dy);	flim[1].fy = o->co2fiy(fp2.fy + dy);
			axis->loc[0].fy = fp1.fy;	axis->loc[1].fy = fp2.fy;
			}
		}
	pts[0].x = iround(flim[0].fx);		pts[1].x = iround(flim[1].fx);
	pts[0].y = iround(flim[0].fy);		pts[1].y = iround(flim[1].fy);
	pts3D[0].x = pts[0].x;				pts3D[1].x = pts[1].x;
	pts3D[0].y = pts[0].y;				pts3D[1].y = pts[1].y;
	pts3D[0].z = iround(flim[0].fz);	pts3D[1].z = iround(flim[1].fz);
	SetMinMaxRect(&rDims, pts[0].x, pts[0].y, pts[1].x, pts[1].y);
	IncrementMinMaxRect(&rDims, 3);
	//calculate sine and cosine for ticks in any direction of axis
	si = flim[1].fy - flim[0].fy;
	tmp = (flim[1].fx - flim[0].fx);
	si = fabs(si) > 0.0001 ? si/sqrt(si*si + tmp*tmp) : 0.0;
	csi = flim[1].fx - flim[0].fx;
	tmp = (flim[1].fy - flim[0].fy);
	csi = fabs(csi) > 0.0001 ? csi/sqrt(csi*csi + tmp*tmp) : 0.0;
	//draw axis line
	if(axis->breaks && axis->nBreaks)DrawBreaks(o);
	else if((axis->flags) & AXIS_3D){
		if(!(l_segs = (line_segment**)calloc(1, sizeof(line_segment*))))return;
		l_segs[0] = new line_segment(this, data, &axline, &pts3D[0], &pts3D[1]);
		nl_segs = 1;
		if(l_segs[0])l_segs[0]->DoPlot(o);
		}
	else o->oSolidLine(pts);
	//now execute the draw routine of label and every tick
	if(axisLabel){
		if(axis->flags & AXIS_3D) axisLabel->SetSize(SIZE_ZPOS, (pts3D[0].z + pts3D[1].z)>>1); 
		axisLabel->DoPlot(o);
		}
	if(Ticks && NumTicks) for(i = 0; i < NumTicks; i++) 
		if(Ticks[i]) Ticks[i]->DoPlot(si, csi, o);
}

void
Axis::DoMark(anyOutput *o, bool mark)
{
	LineDEF mrkLine;
	int x1, y1, x2, y2;
	double minw = defs.GetSize(SIZE_DATA_LINE);

	if(axis->flags & AXIS_ANGULAR) {
		if(mark) {
			memcpy(&mrc, &rDims, sizeof(RECT));
			IncrementMinMaxRect(&mrc, 6 + o->un2ix(axline.width));
			mo = GetRectBitmap(&mrc, o);
			memcpy(&mrkLine, &axline, sizeof(LineDEF));
			mrkLine.width = axline.width < minw ? minw * 3.0 : axline.width *3.0;;
			x1 = o->co2ix(axis->Center.fx) - o->un2ix(axis->Radius);
			y1 = o->co2iy(axis->Center.fy) - o->un2iy(axis->Radius);
			x2 = o->co2ix(axis->Center.fx) + o->un2ix(axis->Radius);
			y2 = o->co2iy(axis->Center.fy) + o->un2iy(axis->Radius);
			o->SetLine(&mrkLine);
			o->oArc(x1, y1, x2, y2, 4);
			mrkLine.color ^= 0x00ffffffL;
			mrkLine.width = axline.width;
			o->SetLine(&mrkLine);
			o->oArc(x1, y1, x2, y2, 4);
			o->UpdateRect(&mrc, false);
			}
		else RestoreRectBitmap(&mo, &mrc, o);
		return;
		}
	if(mark){
		memcpy(&mrc, &rDims, sizeof(RECT));
		IncrementMinMaxRect(&mrc, 6 + o->un2ix(axline.width));
		mo = GetRectBitmap(&mrc, o);
		InvertLine(pts, 2, &axline, &rDims, o, mark);
		}
	else RestoreRectBitmap(&mo, &mrc, o);
}

bool
Axis::Command(int cmd, void *tmpl, anyOutput *o)
{
	MouseEvent *mev;
	GraphObj **tmpPlots;
	void *sv_ptr;
	int i;

	switch (cmd) {
	case CMD_HIDE_MARK:
		if(!tmpl || !o) return false;
		if(tmpl == (void*)axisLabel){
			axisLabel->DoMark(o, false);
			return true;
			}
		if(Ticks && NumTicks) for(i = 0; i < NumTicks; i++) {
			if(Ticks[i]) {
				if(tmpl == (void*)Ticks[i]) {
					Ticks[i]->DoMark(o, false);
					return true;
					}	
				else if(Ticks[i]->Command(cmd, tmpl, o)) return true;
				}
			}
		if(axisLabel && axisLabel->Id == GO_MLABEL) 
			if(axisLabel->Command(cmd, tmpl, o)) return true;
		return false;
	case CMD_SET_DATAOBJ:
		Id = GO_AXIS;
		data = (DataObj*)tmpl;
		if(Ticks) for(i = 0; i< NumTicks; i++) if(Ticks[i]) Ticks[i]->Command(cmd, tmpl, o);
		if(axisLabel) axisLabel->Command(cmd, tmpl, o);
	case CMD_TICK_TYPE:
		if(cmd == CMD_TICK_TYPE){
			if(tmpl) tick_type = *((int*)tmpl);
			else return false;
			}
	case CMD_SET_TICKSTYLE:
		if(cmd == CMD_SET_TICKSTYLE){
			axis->flags &= ~0x07;		axis->flags |= (*((DWORD*)tmpl) & 0x07);
			}
	case CMD_SET_GRIDTYPE:
		if(cmd == CMD_SET_GRIDTYPE && tmpl && *((int*)tmpl)) {
			gl_type = *((int*)tmpl);
			}
	case CMD_TLB_TXTDEF:			//do all ticks
		if(Ticks) for(i = 0; i< NumTicks; i++) if(Ticks[i]) Ticks[i]->Command(cmd, tmpl, o);
		if(cmd == CMD_TLB_TXTDEF && tmpl) {
			memcpy(&tlbdef, tmpl, sizeof(TextDEF));
			tlbdef.text = 0L;
			}
		return true;
	case CMD_SET_GRIDLINE:
		if(tmpl) memcpy(&GridLine, tmpl, sizeof(LineDEF));
		if(Ticks) for(i = 0; i< NumTicks; i++) if(Ticks[i]) Ticks[i]->Command(cmd, tmpl, o);
		return true;
	case CMD_GET_GRIDLINE:
		if(tmpl) memcpy(tmpl, &GridLine, sizeof(LineDEF));
		return true;
	case CMD_MOUSE_EVENT:
		mev = (MouseEvent *) tmpl;
		switch (mev->Action) {
		case MOUSE_LBUP:
			if(axis->flags & AXIS_ANGULAR) {
				i = (mev->x - pts[0].x) * (mev->x - pts[0].x) + 
					(mev->y - pts[0].y) * (mev->y - pts[0].y);
				i = isqr(i) - pts[1].x;
				if(i < 4 && i > -4){
					o->ShowMark(this, MRK_GODRAW);
					return true;
					}
				}
			else if(IsInRect(&rDims, mev->x, mev->y) && !CurrGO && 
				IsCloseToLine(&pts[0], &pts[1], mev->x, mev->y)) {
				o->ShowMark(this, MRK_GODRAW);
				return true;
				}
			break;
			}
		if(axisLabel && axisLabel->Command(cmd, tmpl, o)) return true;
		if(Ticks) for(i = 0; i < NumTicks; i++)
			if(Ticks[i] && Ticks[i]->Command(cmd, tmpl, o)) return true;
		return false;
	case CMD_SET_AXDEF:
		if(axis = (AxisDEF*)tmpl) {
			if(axis && axis->owner == (void*)this) {
				if(axis->breaks) free(axis->breaks);
				free(axis);
				}
			if(Ticks) for(i = 0; i < NumTicks; i++)
				if(Ticks[i]) {
					Ticks[i]->Command(cmd, tmpl, o);
					Ticks[i]->Command(CMD_SET_GRIDTYPE, (void*) &gl_type, 0L);
					Ticks[i]->Command(CMD_TLB_TXTDEF, &tlbdef, 0L);
					if(axis->flags & AXIS_GRIDLINE) Ticks[i]->Command(CMD_SET_GRIDLINE, &GridLine, 0L);
					Ticks[i]->SetSize(SIZE_TICK_ANGLE, tick_angle);
					Ticks[i]->SetSize(SIZE_AXIS_TICKS, sizAxTick);
					Ticks[i]->SetSize(SIZE_LB_XDIST, tlbdist.fx);
					Ticks[i]->SetSize(SIZE_LB_YDIST, tlbdist.fy);
					Ticks[i]->Command(CMD_TICK_TYPE, &tick_type, 0L);
					}
			return true;
			}
		return false;
	case CMD_CAN_DELETE:
		if(axis->owner == (void*)this) return true;
		return false;
	case CMD_DROP_LABEL:
		if(axisLabel)DeleteGO(axisLabel);
		if(axisLabel = (Label*)tmpl) {
			axisLabel->parent = this;
			}
		return true;
	case CMD_DELOBJ:
		o->HideMark();
		if(!tmpl || !parent) return false;
		if(DeleteGOL((GraphObj***) &Ticks, NumTicks, (GraphObj *)tmpl, o)) 
			return parent->Command(CMD_REDRAW, 0L, o);
		if(tmpl == (void*)axisLabel) {
			Undo.DeleteGO((GraphObj**)(&axisLabel), 0L, o);
			return parent->Command(CMD_REDRAW, 0L, o);
			}