rlplot.h

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

	FitFunc(GraphObj *par, DataObj *d);
	FitFunc(int src);
	~FitFunc();
	bool SetSize(int select, double value);
	bool SetColor(int select, DWORD col);
	void DoPlot(anyOutput *o);
	bool Command(int cmd, void *tmpl, anyOutput *o);
	bool PropertyDlg();
	void RegGO(void *n);
	bool FileIO(int rw);

private:
	double x1, x2, xstep, conv, chi2;
	char *ssXref, *ssYref;
	long nPoints;
	int maxiter;
	LineDEF Line;
	Symbol **Symbols;
	char *cmdxy, *parxy;
	Function *dl;
};

class GridLine:public GraphObj{
public:
	DWORD flags;
	long ncpts;
	POINT pts[6], *cpts;
	LineDEF LineDef;
	POINT3D *gl1, *gl2, *gl3;
	line_segment **ls;
	bool bModified;
	anyOutput *mo;
	RECT mrc;

	GridLine(GraphObj *par, DataObj *d, int type, DWORD df);
	GridLine(int src);
	~GridLine();
	virtual void DoPlot(anyOutput *o);
	virtual void DoMark(anyOutput *o, bool mark);
	virtual bool Command(int cmd, void *tmpl, anyOutput *o);
	bool PropertyDlg();
	bool FileIO(int rw);
};

class GridLine3D:public GridLine {
public:
	GridLine3D(GraphObj *par, DataObj *d, int type, DWORD df);
	GridLine3D(int src);
	~GridLine3D();
	void DoPlot(anyOutput *o);
	void DoMark(anyOutput *o, bool mark);
	bool Command(int cmd, void *tmpl, anyOutput *o);
};

class GridRadial:public GridLine {
public:
	GridRadial(GraphObj *par, DataObj *d, int type, DWORD df);
	GridRadial(int src);
	~GridRadial();
	void DoPlot(anyOutput *o);
	void DoMark(anyOutput *o, bool mark);
	bool Command(int cmd, void *tmpl, anyOutput *o);
};

class Tick:public GraphObj{
public:
	Tick(GraphObj *par, DataObj *d, double val, DWORD Flags);
	Tick(int src);
	~Tick();
	double GetSize(int select);
	bool SetSize(int select, double value);
	bool SetColor(int select, DWORD col);
	void DoMark(anyOutput *o, bool mark);
	bool Command(int cmd, void *tmpl, anyOutput *o);
	bool PropertyDlg();
	void RegGO(void *n);
	bool FileIO(int rw);

	void DoPlot(double six, double csx, anyOutput *o);
	
private:
	double value, size, fix, fiy, fiz, lsi, lcsi, angle, lbx, lby;
	bool bModified;
	anyOutput *mo;
	RECT mrc;
	int gl_type;
	GridLine *Grid;
	Label *label;
	DWORD flags;
	POINT pts[2];
	line_segment *ls;
};

class Axis:public GraphObj{
public:
	AxisDEF *axis;
	LineDEF axline;

	Axis(GraphObj *par, DataObj *d, AxisDEF *ax, DWORD flags);
	Axis(int src);
	~Axis();
	double GetSize(int select);
	bool SetSize(int select, double value);
	DWORD GetColor(int select);
	bool SetColor(int select, DWORD col);
	void DoPlot(anyOutput *o);
	void DoMark(anyOutput *o, bool mark);
	bool Command(int cmd, void *tmpl, anyOutput *o);
	bool PropertyDlg();
	void RegGO(void *n);
	bool FileIO(int rw);

	AxisDEF *GetAxis() {return axis;};
	bool GetValuePos(double val, double *fix, double *fiy, double *fiz, anyOutput *o);
	void TickFile(char *name);
	void BreakSymbol(POINT3D *p1, double dsi, double dcsi, bool connect, anyOutput *o);
	void DrawBreaks(anyOutput *o);

private:
	double sizAxLine, sizAxTick, sizAxTickLabel;
	double si, csi;
	double brksymsize, brkgap, tick_angle;
	int brksym, nl_segs, gl_type, tick_type;
	bool bModified;
	DWORD colAxis;
	LineDEF GridLine;
	Tick **Ticks;
	GraphObj *axisLabel;
	long NumTicks;
	POINT pts[2];
	POINT3D pts3D[2];
	fPOINT3D flim[2];
	lfPOINT lbdist, tlbdist;
	TextDEF tlbdef;
	anyOutput *drawOut, *scaleOut;
	line_segment **l_segs;
	char *ssMATval, *ssMATlbl, *ssMITval; 
	anyOutput *mo;
	RECT mrc;

	void SetTick(long idx, double val, DWORD flags, char *txt);
	void CreateTicks();
	void ManuTicks(double sa, double st, int n, DWORD flags);
	void UpdateTicks();
	bool ssTicks();

};

class Plot3D:public Plot{
	typedef struct {
		double Zmin, Zmax;
		GraphObj *go;
		}obj_desc;
public:
	long nPlots, nAxes;
	Axis **Axes;
	GraphObj **plots;
	double *RotDef;
	fPOINT3D cub1, cub2, rotC;

	Plot3D(GraphObj *par, DataObj *d, DWORD flags);
	Plot3D(int src);
	~Plot3D();
	double GetSize(int select);
	bool SetColor(int select, DWORD col);
	void DoPlot(anyOutput *o);
	void DoMark(anyOutput *o, bool mark);
	virtual bool Command(int cmd, void *tmpl, anyOutput *o);
	virtual bool PropertyDlg();
	virtual void RegGO(void *n);
	virtual bool FileIO(int rw);

	void * ObjThere(int x, int y);
	void Track(POINT *p, anyOutput *o);
	void CreateAxes();
	void DoAutoscale();
	void CalcRotation(double dx, double dy, anyOutput *o, bool accept);
	bool AcceptObj(GraphObj *go);
	void SortObj();
	bool Rotate(double dx, double dy, double dz, anyOutput *o, bool accept);

private:
	long nObs, nmaxObs;
	DWORD crea_flags;
	Drag3D *drag;
	fPOINT3D cu1, cu2, rc;
	obj_desc **dispObs;

	bool AddPlot(int family);
};

class Chart25D:public Plot3D {
public:
	Chart25D(GraphObj *par, DataObj *d, DWORD flags);
	~Chart25D();
	bool PropertyDlg();

private:
	fPOINT3D dspm;
};

class Ribbon25D:public Plot3D {
public:
	Ribbon25D(GraphObj *par, DataObj *d, DWORD flags);
	~Ribbon25D();
	bool PropertyDlg();

private:
	fPOINT3D dspm;
};

class BubblePlot3D:public Plot3D {
public:
	BubblePlot3D(GraphObj *par, DataObj *d);
	~BubblePlot3D();
	bool PropertyDlg();
};

class Func3D:public Plot3D {
public:
	Func3D(GraphObj *par, DataObj *d);
	Func3D(int src);
	~Func3D();
	bool Command(int cmd, void *tmpl, anyOutput *o);
	bool PropertyDlg();
	void RegGO(void *n);
	bool FileIO(int rw);

private:
	bool Update();

	double x1, x2, xstep, z1, z2, zstep;
	int g_idx;
	LineDEF Line;
	FillDEF Fill;
	char *param, *cmdxy;
	DataObj *gda;
	Grid3D  *gob;
};

class Graph:public GraphObj{
public:
	long NumPlots;
	int ToolMode, units, nscp;
	anyOutput *Disp, *CurrDisp;
	fRECT GRect, DRect, Bounds;
	bool OwnDisp, bModified;
	fRECT CurrRect;
	GraphObj **Plots;
	DWORD ColBG, ColAX;
	GraphObj **Sc_Plots;
	Axis **Axes;
	char *filename;

	Graph(GraphObj *par, DataObj *d, anyOutput *o);
	Graph(int src);
	~Graph();
	double GetSize(int select);
	bool SetSize(int select, double value);
	DWORD GetColor(int select);
	virtual void DoPlot(anyOutput *o);
	virtual bool Command(int cmd, void *tmpl, anyOutput *o);
	bool PropertyDlg();
	void RegGO(void *n);
	virtual bool FileIO(int rw);

private:
	int NumAxes, AxisTempl, tickstyle, zoom_level;
	RECT rcDim, rcUpd, rc_mrk;
	DWORD ColDR, ColGR, ColGRL;
	AxisDEF x_axis, y_axis;
	FrmRect *frm_g, *frm_d;
	bool dirty;
	POINT *tl_pts;
	long tl_nPts;
	ZoomDEF *zoom_def;

	bool AddPlot(int family);
	void DoAutoscale();
	void CreateAxes(int templ);
	bool ExecTool(MouseEvent *mev);
	bool Configure();
	bool AddAxis();
	bool MoveObj(int cmd, GraphObj *g); 
	bool DoZoom(char *z);
};

class Page:public Graph{
public:
	Page(GraphObj *par, DataObj *d);
	Page(int src);
	void DoPlot(anyOutput *o);
	bool Command(int cmd, void *tmpl, anyOutput *o);
	void RegGO(void *n);
	bool FileIO(int rw);

private:
	LineDEF LineDef;
	FillDEF FillDef;

	bool Configure();
};

class ObjTree:public GraphObj {
public:
	ObjTree(GraphObj *par, DataObj *d, GraphObj *root);
	~ObjTree();
	void DoPlot(anyOutput *o);
	bool Command(int cmd, void *tmpl, anyOutput *o);

	anyOutput *CreateBitmap(int *w, int *h, anyOutput *tmpl);
	int count_lines(){ return count;};
	char *get_name(int line);
	int get_vis(int line);
	bool set_vis(int line, bool vis);
	GraphObj *get_obj(int line);

private:
	GraphObj **list, *base;
	int count, maxcount;
	TextDEF TextDef;
};

class notary{
public:
	notary();
	~notary();
	unsigned long RegisterGO(GraphObj *go);
	void AddRegGO(GraphObj *go);
	bool PushGO(unsigned long id, GraphObj *go);
	GraphObj *PopGO(unsigned long id);
	void FreeStack();

private:
	unsigned long NextPopGO, NextPushGO, NextRegGO;
	GraphObj ***gObs;
	GraphObj ***goStack;
};

class Default{
public:
	int dUnits, cUnits;
	char DecPoint[2], ColSep[2];
	char *svgAttr, *svgScript, *currPath, *IniFile;
	char *File1, *File2, *File3, *File4, *File5, *File6;
	double min4log, ss_txt;
	RECT clipRC;

	Default();
	~Default();
	void SetDisp(anyOutput *o);
	double GetSize(int select);
	DWORD Color(int select);
	LineDEF *GetLine();
	void SetLine(int u, LineDEF *l, int which);
	FillDEF *GetFill();
	void SetFill(int u, FillDEF *fd);
	LineDEF *GetOutLine();
	bool PropertyDlg();
	LineDEF *plLineDEF(LineDEF *ld);
	LineDEF *pgLineDEF(LineDEF *ol);
	FillDEF *pgFillDEF(FillDEF *fd);
	double rrectRad(double rad);
	void FileHistory(char *path);

private:
	LineDEF Line_0, Line_1, Line_2, *pl, *pgl;
	FillDEF Fill_0, Fill_1, Fill_2, *pg;
	LineDEF FillLine_0, FillLine_1, FillLine_2, *pg_fl;
	LineDEF OutLine_0, OutLine_1, OutLine_2;
	double *rrect_rad;
	anyOutput *cdisp;
	DWORD axis_color;
};

class DefsRW:public GraphObj{
public:
	DefsRW():GraphObj(0, 0){Id = 0; return;};
	DefsRW(int rw):GraphObj(0,0){FileIO(rw);Id=GO_DEFRW;return;};
	~DefsRW() {return;};
	bool FileIO(int rw);
};

class ReadCache{
public:
	unsigned char last, *Cache, Line[4096];
	int iFile, idx, max;
	bool eof;

	ReadCache();
	~ReadCache();
	virtual bool Open(char *name);
	virtual void Close();
	virtual unsigned char Getc();
	virtual unsigned char *GetField();
	void ReadLine(char *dest, int size);
	bool GetInt(long *in);
	bool GetFloat(double *fn);
	unsigned char Lastc();
	bool IsEOF();
};

class MemCache:public ReadCache{
public:
	MemCache(unsigned char *ptr);
	~MemCache();
	bool Open(char *name){return false;};
	void Close(){return;};
	unsigned char Getc();
	unsigned char *GetField();
};

#define UNDO_CONTINUE 0x01
#define UNDO_STORESET 0x1000
class UndoObj {
	enum {UNDO_UNDEFINED, UNDO_DEL_GO, UNDO_GOLIST, UNDO_DROPMEM,
		UNDO_VALDWORD, UNDO_VALINT, UNDO_VALLONG, UNDO_OBJCONF, UNDO_OBJCONF_1,
		UNDO_LFP, UNDO_POINT, UNDO_VOIDPTR, UNDO_MOVE, UNDO_RECT,
		UNDO_STRING, UNDO_ROTDEF, UNDO_SETGO, UNDO_LINEDEF, UNDO_FILLDEF,
		UNDO_AXISDEF, UNDO_LFP3D, UNDO_FLOAT, UNDO_MEM, UNDO_MUTATE, 
		UNDO_DROPGOLIST, UNDO_TEXTDEF, UNDO_SAVVAR, UNDO_DATA, UNDO_ET};
	typedef struct _UndoInfo {
		int cmd;
		DWORD flags;
		GraphObj *owner;
		void *data;
		void **loc;
		ZoomDEF zd;
		}UndoInfo;

	typedef struct _UndoList {
		void *array;
		void **loc_arr;
		long count, size;
		long *loc_count;
		}UndoList;

	typedef struct _UndoBuff {
		int count;
		UndoInfo **buff;
		anyOutput *disp;
		}UndoBuff;

	typedef struct _EtBuff {
		char *txt;
		DataObj *DaO;
		int *cur, *m1, *m2, vcur, vm1, vm2, row, col;
		}EtBuff;

public:
	int *pcb;
	anyOutput *cdisp, *ldisp;
	bool busy;

	UndoObj();
	~UndoObj();
	void Flush();
	void SetDisp(anyOutput *o);
	void KillDisp(anyOutput *o);
	void InvalidGO(GraphObj *go);
	void Pop(anyOutput *o);
	void Restore(bool redraw, anyOutput *o);
	void ListGOmoved(GraphObj **oldlist, GraphObj **newlist, long size);
	void DeleteGO(GraphObj **go, DWORD flags, anyOutput *o);
	void MutateGO(GraphObj **old, GraphObj *repl, DWORD flags, anyOutput *o);
	void StoreListGO(GraphObj *parent, GraphObj ***go, long *count, DWORD flags);
	void DropListGO(GraphObj *parent, GraphObj ***go, long *count, DWORD flags);
	void DropMemory(GraphObj *parent, void **mem, DWORD flags);
	void SavVarBlock(GraphObj *parent, void **mem, DWORD flags);
	void ValDword(GraphObj *parent, DWORD *val, DWORD flags);
	void Point(GraphObj *parent, POINT *pt, anyOutput * o, DWORD flags);
	void VoidPtr(GraphObj *parent, void **pptr, void *ptr, anyOutput * o, DWORD flags);
	void ValInt(GraphObj *parent, int *val, DWORD flags);
	void ValLong(GraphObj *parent, long *val, DWORD flags);
	void ObjConf(GraphObj *go, DWORD flags);
	int SaveLFP(GraphObj *go, lfPOINT *lfp, DWORD flags);
	void MoveObj(GraphObj *go, lfPOINT *lfp, DWORD flags);
	void ValRe