qt_spec.cpp

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

	OutputClass = o;
	BaseObj = g;
	setMinimumSize(100, 80);
	setBackgroundMode(NoBackground);
	HScroll = new QScrollBar(QScrollBar::Horizontal, this, 0);
	HScroll->setRange(0, 1000);
	HScroll->setSteps(1, 16);
	connect(HScroll, SIGNAL(valueChanged(int)), SLOT(hScrollEvent(int)));
	VScroll = new QScrollBar(QScrollBar::Vertical, this, 0);
	VScroll->setRange(0, 1000);
	VScroll->setSteps(1, 16);
	connect(VScroll, SIGNAL(valueChanged(int)), SLOT(vScrollEvent(int)));
	if(!MainWidget) QAppl->setMainWidget(MainWidget = this);
	setMouseTracking(true);
	setFocusPolicy(StrongFocus);
}

RLPwidget::~RLPwidget()
{
	if(OutputClass)((OutputQT*)OutputClass)->widget = 0L;
	OutputClass = 0L;
	if(BaseObj){
		BaseObj->Command(CMD_CAN_DELETE, 0L, 0L);
		BaseObj = 0L;
		}
}

//public slots: menu items, events
void
RLPwidget::hScrollEvent(int pos)
{
	if(BaseObj){
		BaseObj->Command(CMD_SETHPOS, (void*)(&pos), OutputClass);
		repaint();
		}
}

void
RLPwidget::vScrollEvent(int pos)
{
	if(BaseObj){
		BaseObj->Command(CMD_SETVPOS, (void*)(&pos), OutputClass);
		repaint();
		}
}


void
RLPwidget::cmOpen()
{
	if(BaseObj)BaseObj->Command(CMD_OPEN, (void *)NULL, OutputClass);
}

void
RLPwidget::cmSaveDataAs()
{
	if(BaseObj)BaseObj->Command(CMD_SAVEDATAAS, (void *)NULL, OutputClass);
}

void
RLPwidget::cmExit()
{
	if(BaseObj) {
		if(BaseObj->Command(CMD_CAN_CLOSE, 0L, 0L)){
			BaseObj = 0L;
			delete this;
			}
		}
	else delete(this);
}

void
RLPwidget::cmNewGraph()
{
	if(BaseObj)BaseObj->Command(CMD_NEWGRAPH, (void *)NULL, OutputClass);
}

void
RLPwidget::cmNewPage()
{
	if(BaseObj)BaseObj->Command(CMD_NEWPAGE, (void *)NULL, OutputClass);
}

void
RLPwidget::cmDelGraph()
{
	if(BaseObj)BaseObj->Command(CMD_DELGRAPH, (void *)NULL, OutputClass);
}

void
RLPwidget::cmAddPlot()
{
	if(BaseObj)BaseObj->Command(CMD_ADDPLOT, (void *)NULL, OutputClass);
}

void
RLPwidget::cmAddLegend()
{
	if(BaseObj)BaseObj->Command(CMD_LEGEND, (void *)NULL, OutputClass);
}

void
RLPwidget::cmLayers()
{
	if(BaseObj)BaseObj->Command(CMD_LAYERS, (void *)NULL, OutputClass);
}

void
RLPwidget::cmAbout()
{
	RLPlotInfo();
}

void
RLPwidget::cmAddRowCol()
{
	if(BaseObj)BaseObj->Command(CMD_ADDROWCOL, (void *)NULL, OutputClass);
}

void
RLPwidget::cmCopy()
{
	if(BaseObj && BaseObj->Id == GO_SPREADDATA) {
		if(BaseObj->Command(CMD_QUERY_COPY, 0L, OutputClass))
			CopyData(BaseObj);
		}
}

void
RLPwidget::cmCut()
{
	if(BaseObj && BaseObj->Id == GO_SPREADDATA) {
		BaseObj->Command(CMD_CUT, 0L, OutputClass);
		CopyData(BaseObj);
		}
}

void
RLPwidget::cmPaste()
{
	if(BaseObj) {
		OutputClass->MouseCursor(MC_WAIT, true);
		TestClipboard(BaseObj);
		OutputClass->MouseCursor(MC_ARROW, true);
		}
}

void
RLPwidget::cmCopyGraph()
{
	if(BaseObj) CopyGraph(BaseObj);
}

void
RLPwidget::cmSaveGraphAs()
{
	SaveGraphAs(BaseObj);
}

void
RLPwidget::cmRedraw()
{
	if(OutputClass && BaseObj && OutputClass->Erase(defs.Color(COL_BG))) {
		BaseObj->Command(CMD_SETSCROLL, 0L, OutputClass);
		repaint();
		}
}

void
RLPwidget::cmZoom25()
{
	BaseObj->Command(CMD_ZOOM, (void*)(&"25"), OutputClass);
}

void
RLPwidget::cmZoom50()
{
	BaseObj->Command(CMD_ZOOM, (void*)(&"50"), OutputClass);
}

void
RLPwidget::cmZoom100()
{
	BaseObj->Command(CMD_ZOOM, (void*)(&"100"), OutputClass);
}

void
RLPwidget::cmZoom200()
{
	BaseObj->Command(CMD_ZOOM, (void*)(&"200"), OutputClass);
}

void
RLPwidget::cmZoom400()
{
	BaseObj->Command(CMD_ZOOM, (void*)(&"400"), OutputClass);
}

void
RLPwidget::cmZoomIn()
{
	BaseObj->Command(CMD_ZOOM, (void*)(&"+"), OutputClass);
}

void
RLPwidget::cmZoomOut()
{
	BaseObj->Command(CMD_ZOOM, (void*)(&"-"), OutputClass);
}

void
RLPwidget::cmZoomFit()
{
	BaseObj->Command(CMD_ZOOM, (void*)(&"fit"), OutputClass);
}

void
RLPwidget::cmPrint()
{
	int m;
	PrintQT out(0L, 0L);

	if(!BaseObj) return;
	if(BaseObj->Id == GO_SPREADDATA) {
		m = iround(out.hres/60.0);
#ifdef Q_CHECK_PTR				//Qt version 3, n.a. in version 2
		out.printer->setMargins(m, m, m, m);
#endif
		BaseObj->Command(CMD_PRINT, 0L, &out);
		}
	else if(out.StartPage()){
		BaseObj->DoPlot(&out);
		out.EndPage();
		}
	BaseObj->DoPlot(OutputClass);
}

void
RLPwidget::cmExport()
{
	OpenExportName(BaseObj, "hello.svg");
	BaseObj->DoPlot(0L);
}

void
RLPwidget::cmDelObj()
{
	if(CurrGO && CurrGO->parent && CurrGO->parent->
		Command(CMD_DELOBJ, (void*)CurrGO, OutputClass)) {
		CurrGO = 0L;
		OutputClass->Erase(defs.Color(COL_BG));
		BaseObj->DoPlot(OutputClass);
		}
	else if(!CurrGO) InfoBox("No object selected!");
}

void
RLPwidget::cmUpdate()
{
	if(BaseObj) BaseObj->Command(CMD_UPDATE, 0L, OutputClass);
}

void
RLPwidget::cmDefaults()
{
	BaseObj->Command(CMD_CONFIG, 0L, OutputClass);
}

void
RLPwidget::cmAddAxis()
{
	BaseObj->Command(CMD_ADDAXIS, 0L, OutputClass);
}

void
RLPwidget::cmUndo()
{
	BaseObj->Command(CMD_UNDO, 0L, OutputClass);
}

void
RLPwidget::cmFillRange()
{
	BaseObj->Command(CMD_FILLRANGE, 0L, OutputClass);
}

void
RLPwidget::cmInsRow()
{
	BaseObj->Command(CMD_INSROW, 0L, OutputClass);
}

void
RLPwidget::cmInsCol()
{
	BaseObj->Command(CMD_INSCOL, 0L, OutputClass);
}

void
RLPwidget::cmDelRow()
{
	BaseObj->Command(CMD_DELROW, 0L, OutputClass);
}

void
RLPwidget::cmDelCol()
{
	BaseObj->Command(CMD_DELCOL, 0L, OutputClass);
}

void ToolMenu(GraphObj *b, anyOutput *o, int tm)
{
	if(b && o) b->Command(CMD_TOOLMODE, (void*)(& tm), o);
}

void
RLPwidget::cmtStandard()
{
	ToolMenu(BaseObj, OutputClass, TM_STANDARD);
}

void
RLPwidget::cmtDraw()
{
	ToolMenu(BaseObj, OutputClass, TM_DRAW);
}

void
RLPwidget::cmtPolyline()
{
	ToolMenu(BaseObj, OutputClass, TM_POLYLINE);
}

void
RLPwidget::cmtPolygon()
{
	ToolMenu(BaseObj, OutputClass, TM_POLYGON);
}

void
RLPwidget::cmtRectangle()
{
	ToolMenu(BaseObj, OutputClass, TM_RECTANGLE);
}

void
RLPwidget::cmtRoundrect()
{
	ToolMenu(BaseObj, OutputClass, TM_ROUNDREC);
}

void
RLPwidget::cmtEllipse()
{
	ToolMenu(BaseObj, OutputClass, TM_ELLIPSE);
}

void
RLPwidget::cmtArrow()
{
	ToolMenu(BaseObj, OutputClass, TM_ARROW);
}

void
RLPwidget::cmtText()
{
	ToolMenu(BaseObj, OutputClass, TM_TEXT);
}

//protected: widget events
void
RLPwidget::paintEvent(QPaintEvent *range)
{
	QRect rc;

	rc = range->rect();
	bitBlt(this, rc.left(), rc.top(), this->mempic, rc.left(), rc.top(),
		1+rc.right()-rc.left(), 1+rc.bottom()-rc.top());
}

void
RLPwidget::resizeEvent(QResizeEvent *)
{
	HScroll->resize(width() -16, 16);
	HScroll->move(0, height()-16);
	VScroll->resize(16, height()-OutputClass->MenuHeight-16);
	VScroll->move(width()-16, OutputClass->MenuHeight);
	if(BaseObj) BaseObj->Command(CMD_SETSCROLL, 0L, OutputClass);
}

void
RLPwidget::closeEvent(QCloseEvent *e)
{
	if(BaseObj){
		if(BaseObj->Command(CMD_CAN_CLOSE, 0L, 0L)) {
			if(OutputClass)((OutputQT*)OutputClass)->widget = 0L;
			OutputClass = 0L;
			BaseObj = 0L;
			e->accept();
			}
		}
	else e->accept();
}

void
RLPwidget::mouseDoubleClickEvent(QMouseEvent *e)
{
	MouseEvent mev = {1, e->button() == Qt::LeftButton?MOUSE_LBDOUBLECLICK:-1,e->x(),e->y()};

	if (BaseObj)BaseObj->Command(CMD_MOUSE_EVENT, (void *)&mev, OutputClass);
}

void
RLPwidget::mousePressEvent(QMouseEvent *e)
{
	int i;
	MouseEvent mev = {1, e->button() == Qt::LeftButton ? MOUSE_LBDOWN : -1, e->x(), e->y()};

	HideTextCursor();
	i = e->state();
	if(i & Qt::ShiftButton) mev.StateFlags |= 0x08;
	if(i & Qt::ControlButton) mev.StateFlags |= 0x10;
	if (BaseObj)BaseObj->Command(CMD_MOUSE_EVENT, (void *)&mev, OutputClass);
}

void
RLPwidget::mouseReleaseEvent(QMouseEvent *e)
{
	int i;
	MouseEvent mev = {0, e->button() == Qt::LeftButton ? MOUSE_LBUP :
		e->button() == Qt::RightButton ? MOUSE_RBUP : -1, e->x(), e->y()};

	i = e->state();
	if(i & Qt::ShiftButton) mev.StateFlags |= 0x08;
	if(i & Qt::ControlButton) mev.StateFlags |= 0x10;
	if (BaseObj) BaseObj->Command(CMD_MOUSE_EVENT, (void *)&mev, OutputClass);
}

void
RLPwidget::mouseMoveEvent(QMouseEvent *e)
{
	int i;
	MouseEvent mev = {0, MOUSE_MOVE, e->x(), e->y()};

	i = e->state();
	if(i & Qt::LeftButton) mev.StateFlags |= 0x01;
	if(i & Qt::ShiftButton) mev.StateFlags |= 0x08;
	if(i & Qt::ControlButton) mev.StateFlags |= 0x10;
	if (BaseObj) BaseObj->Command(CMD_MOUSE_EVENT, (void *)&mev, OutputClass);
}

void
RLPwidget::keyPressEvent(QKeyEvent *e)
{
	int i, c;

	if(BaseObj) switch(c = e->key()) {
		case Key_Prior:
			i = e->state();
			if(i & Qt::ShiftButton) BaseObj->Command(CMD_SHPGUP, 0L, OutputClass);
			else BaseObj->Command(CMD_PAGEUP, 0L, OutputClass);
			break;
		case Key_Next:
			i = e->state();
			if(i & Qt::ShiftButton) BaseObj->Command(CMD_SHPGDOWN, 0L, OutputClass);
			else BaseObj->Command(CMD_PAGEDOWN, 0L, OutputClass);
			break;
		case Key_Left:
			if(e->state() & ShiftButton) BaseObj->Command(CMD_SHIFTLEFT, 0L, OutputClass);
			else BaseObj->Command(CMD_CURRLEFT, 0L, OutputClass);
			break;
		case Key_Ri