SIM/qucs_s
1
0
Fork 0
mirror of https://github.com/ra3xdh/qucs_s synced 2025-03-28 21:13:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

*** empty log message ***

Browse Source
This commit is contained in:
margraf 2007-02-08 07:04:54 +00:00
parent 4d3a6f4a05
commit 6ec6986763
44 changed files with 817 additions and 605 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
qucs/ChangeLog
View File

@ -1,3 +1,9 @@
2006-12-22 Michael Margraf <michael.margraf@alumni.tu-berlin.de>
* better resizing at zoom levels <> 1
* better selecting at zoom levels <> 1
* correct cursor cross before starting new wire
2006-12-22 Michael Margraf <michael.margraf@alumni.tu-berlin.de>
* new components: twisted-pair transmission line, bond wire

18
qucs/diagrams/curvediagram.cpp
View File

@ -40,19 +40,19 @@ CurveDiagram::~CurveDiagram()
// ------------------------------------------------------------
void CurveDiagram::calcCoordinate(double* &, double* &yD, double* &,
int *px, int *py, Axis *pa)
float *px, float *py, Axis *pa)
{
double yr = *(yD++);
double yi = *(yD++);
if(xAxis.log)
*px = int(log10(yr / xAxis.low)/log10(xAxis.up / xAxis.low)
*double(x2) + 0.5);
else *px = int((yr-xAxis.low)/(xAxis.up-xAxis.low)*double(x2) + 0.5);
*px = float(log10(yr / xAxis.low)/log10(xAxis.up / xAxis.low)
*double(x2));
else *px = float((yr-xAxis.low)/(xAxis.up-xAxis.low)*double(x2));
if(pa->log)
*py = int(log10(yi / pa->low)/log10(pa->up / pa->low)
*double(y2) + 0.5);
else *py = int((yi-pa->low)/(pa->up-pa->low)*double(y2) + 0.5);
*py = float(log10(yi / pa->low)/log10(pa->up / pa->low)
*double(y2));
else *py = float((yi-pa->low)/(pa->up-pa->low)*double(y2));
}
// --------------------------------------------------------------
@ -207,13 +207,13 @@ Frame:
}
// ------------------------------------------------------------
bool CurveDiagram::insideDiagram(int x, int y)
bool CurveDiagram::insideDiagram(float x, float y)
{
return (regionCode(x, y) == 0);
}
// ------------------------------------------------------------
void CurveDiagram::clip(int* &p)
void CurveDiagram::clip(float* &p)
{
rectClip(p);
}

6
qucs/diagrams/curvediagram.h
View File

@ -31,11 +31,11 @@ public:
static Element* info(QString&, char* &, bool getNewOne=false);
int calcDiagram();
void calcLimits();
void calcCoordinate(double* &, double* &, double* &, int*, int*, Axis*);
bool insideDiagram(int, int);
void calcCoordinate(double* &, double* &, double* &, float*, float*, Axis*);
bool insideDiagram(float, float);
protected:
void clip(int* &);
void clip(float* &);
};
#endif

171
qucs/diagrams/diagram.cpp
View File

@ -293,21 +293,21 @@ void Diagram::paintScheme(QPainter *p)
}
// ------------------------------------------------------------
int Diagram::regionCode(int x, int y)
int Diagram::regionCode(float x, float y)
{
int code=0; // code for clipping
if(x < 0) code |= 1;
else if(x > x2) code |= 2;
if(y < 0) code |= 4;
else if(y > y2) code |= 8;
if(x < 0.0) code |= 1;
else if(int(x) > x2) code |= 2;
if(y < 0.0) code |= 4;
else if(int(y) > y2) code |= 8;
return code;
}
// ------------------------------------------------------------
// Is virtual. This one is for round diagrams only.
bool Diagram::insideDiagram(int x, int y)
bool Diagram::insideDiagram(float x, float y)
{
int R = (x2 >> 1) + 1; // +1 seems better (graph sometimes little outside)
float R = float(x2)/2.0 + 1.0; // +1 seems better (graph sometimes little outside)
x -= R;
y -= R;
return ((x*x + y*y) <= R*R);
@ -315,11 +315,12 @@ bool Diagram::insideDiagram(int x, int y)
// ------------------------------------------------------------
// Cohen-Sutherland clipping algorithm
void Diagram::rectClip(int* &p)
void Diagram::rectClip(float* &p)
{
int x=0, y=0, dx, dy, code, z=0;
int x_1 = *(p-4), y_1 = *(p-3);
int x_2 = *(p-2), y_2 = *(p-1);
int code, z=0;
float x=0, y=0, dx, dy;
float x_1 = *(p-4), y_1 = *(p-3);
float x_2 = *(p-2), y_2 = *(p-1);
int code1 = regionCode(x_1, y_1);
int code2 = regionCode(x_2, y_2);
@ -350,19 +351,19 @@ void Diagram::rectClip(int* &p)
dy = y_2 - y_1;
if(code & 1) {
y = y_1 - dy * x_1 / dx;
x = 0;
x = 0.0;
}
else if(code & 2) {
y = y_1 + dy * (x2-x_1) / dx;
x = x2;
x = float(x2);
}
else if(code & 4) {
x = x_1 - dx * y_1 / dy;
y = 0;
y = 0.0;
}
else if(code & 8) {
x = x_1 + dx * (y2-y_1) / dy;
y = y2;
y = float(y2);
}
if(code == code1) {
@ -394,29 +395,28 @@ endWithHidden:
// ------------------------------------------------------------
// Clipping for round diagrams (smith, polar, ...)
void Diagram::clip(int* &p)
void Diagram::clip(float* &p)
{
int R = x2 >> 1;
int x_1 = *(p-4) - R, y_1 = *(p-3) - R;
int x_2 = *(p-2) - R, y_2 = *(p-1) - R;
float R = float(x2) / 2.0;
float x_1 = *(p-4) - R, y_1 = *(p-3) - R;
float x_2 = *(p-2) - R, y_2 = *(p-1) - R;
int dt1 = R*R; // square of radius
int dt2 = dt1 - x_2*x_2 - y_2*y_2;
float dt1 = R*R; // square of radius
float dt2 = dt1 - x_2*x_2 - y_2*y_2;
dt1 -= x_1*x_1 + y_1*y_1;
if(dt1 >= 0) if(dt2 >= 0) return; // line completly inside ?
if(dt1 >= 0.0) if(dt2 >= 0.0) return; // line completly inside ?
if(dt1 < 0) if(*(p-5) >= 0) { // is there already a line end flag ?
if(dt1 < 0.0) if(*(p-5) >= 0.0) { // is there already a line end flag ?
p++;
*(p-5) = STROKEEND;
}
int x = x_1-x_2;
int y = y_1-y_2;
int C = x_1*x + y_1*y;
int D = x*x + y*y;
float F = float(C);
F = F*F + float(dt1)*float(D); // use float because number is easily > 2^32
float x = x_1-x_2;
float y = y_1-y_2;
float C = x_1*x + y_1*y;
float D = x*x + y*y;
float F = C*C + dt1*D;
x_1 += R;
y_1 += R;
@ -430,9 +430,9 @@ void Diagram::clip(int* &p)
}
int code = 0;
R = int(sqrt(F)+0.5);
R = sqrt(F);
dt1 = C - R;
if((dt1 > 0) && (dt1 < D)) { // intersection outside start/end point ?
if((dt1 > 0.0) && (dt1 < D)) { // intersection outside start/end point ?
*(p-4) = x_1 - x*dt1 / D;
*(p-3) = y_1 - y*dt1 / D;
code |= 1;
@ -443,7 +443,7 @@ void Diagram::clip(int* &p)
}
dt2 = C + R;
if((dt2 > 0) && (dt2 < D)) { // intersection outside start/end point ?
if((dt2 > 0.0) && (dt2 < D)) { // intersection outside start/end point ?
*(p-2) = x_1 - x*dt2 / D;
*(p-1) = y_1 - y*dt2 / D;
*p = STROKEEND;
@ -471,7 +471,8 @@ void Diagram::calcData(Graph *g)
if(!pz) return;
if(g->cPointsX.count() < 1) return;
int dx, dy, xtmp, ytmp, tmp, i, z, Counter=2;
int i, z, tmp, Counter=2;
float dx, dy, xtmp, ytmp;
int Size = ((2*(g->cPointsX.getFirst()->count) + 1) * g->countY) + 10;
if(xAxis.autoScale) if(yAxis.autoScale) if(zAxis.autoScale)
@ -480,9 +481,9 @@ void Diagram::calcData(Graph *g)
double Dummy = 0.0; // not used
double *py = &Dummy;
int *p = (int*)malloc( Size*sizeof(int) ); // create memory for points
int *p_end;
g->Points = p_end = p;
float *p = (float*)malloc( Size*sizeof(float) ); // create memory for points
float *p_end;
g->ScrPoints = p_end = p;
p_end += Size - 9; // limit of buffer
Axis *pa;
@ -491,7 +492,7 @@ void Diagram::calcData(Graph *g)
double Stroke=10.0, Space=10.0; // length of strokes and spaces in pixel
switch(g->Style) {
case 0: // ***** solid line **********************************
case GRAPHSTYLE_SOLID: // ***** solid line ****************************
for(i=g->countY; i>0; i--) { // every branch of curves
px = g->cPointsX.getFirst()->Points;
calcCoordinate(px, pz, py, p, p+1, pa);
@ -503,14 +504,11 @@ void Diagram::calcData(Graph *g)
if(Counter >= 2) // clipping only if an axis is manual
clip(p);
}
switch(*(p-3)) {
case STROKEEND:
p -= 3; // no single point after "no stroke"
break;
case BRANCHEND:
if((*(p-2) < 0) || (*(p-1) < 0))
p -= 2; // erase last hidden point
break;
if(*(p-3) == STROKEEND)
p -= 3; // no single point after "no stroke"
else if(*(p-3) == BRANCHEND) {
if((*(p-2) < 0) || (*(p-1) < 0))
p -= 2; // erase last hidden point
}
*(p++) = BRANCHEND;
}
@ -524,26 +522,25 @@ for(int zz=0; zz<z; zz+=2)
qDebug("c: %d/%d", *(p+zz), *(p+zz+1));*/
return;
case 1: Stroke = 10.0; Space = 6.0; break; // dash line
case 2: Stroke = 2.0; Space = 4.0; break; // dot line
case 3: Stroke = 24.0; Space = 8.0; break; // long dash line
default: // symbol at each point ************************************
if(g->Style == 4) xtmp = GRAPHSTAR;
else if(g->Style == 5) xtmp = GRAPHCIRCLE;
else if(g->Style == 6) xtmp = GRAPHARROW;
case GRAPHSTYLE_DASH:
Stroke = 10.0; Space = 6.0;
break;
case GRAPHSTYLE_DOT:
Stroke = 2.0; Space = 4.0;
break;
case GRAPHSTYLE_LONGDASH:
Stroke = 24.0; Space = 8.0;
break;
default: // symbol (e.g. star) at each point **********************
for(i=g->countY; i>0; i--) { // every branch of curves
px = g->cPointsX.getFirst()->Points;
for(z=g->cPointsX.getFirst()->count; z>0; z--) { // every point
FIT_MEMORY_SIZE; // need to enlarge memory block ?
calcCoordinate(px, pz, py, p, p+1, pa);
if(insideDiagram(*p, *(p+1))) { // within diagram ?
*(p+2) = xtmp;
p += 3;
}
}
*(p++) = BRANCHEND;
px = g->cPointsX.getFirst()->Points;
for(z=g->cPointsX.getFirst()->count; z>0; z--) { // every point
calcCoordinate(px, pz, py, p, p+1, pa);
if(insideDiagram(*p, *(p+1))) // within diagram ?
p += 2;
}
*(p++) = BRANCHEND;
}
*p = GRAPHEND;
/*qDebug("\n******");
@ -581,8 +578,8 @@ for(int zz=0; zz<60; zz+=2)
while(dist > 0) { // stroke or space finished ?
FIT_MEMORY_SIZE; // need to enlarge memory block ?
*(p++) = xtmp - int(dist*cos(alpha) + 0.5); // linearly interpolate
*(p++) = ytmp - int(dist*sin(alpha) + 0.5);
*(p++) = xtmp - float(dist*cos(alpha)); // linearly interpolate
*(p++) = ytmp - float(dist*sin(alpha));
if((++Counter) >= 2) clip(p);
if(Flag == 0) {
@ -604,14 +601,12 @@ for(int zz=0; zz<60; zz+=2)
}
} // of x loop
switch(*(p-3)) {
case STROKEEND:
p -= 3; // no single point after "no stroke"
break;
case BRANCHEND:
if((*(p-2) < 0) || (*(p-1) < 0))
p -= 2; // erase last hidden point
break;
if(*(p-3) == STROKEEND)
p -= 3; // no single point after "no stroke"
else if(*(p-3) == BRANCHEND) {
if((*(p-2) < 0) || (*(p-1) < 0))
p -= 2; // erase last hidden point
}
*(p++) = BRANCHEND;
} // of y loop
@ -646,18 +641,20 @@ bool Diagram::getSelected(int x_, int y_)
// ------------------------------------------------------------
// Checks if the resize area was clicked. If so return "true" and sets
// x1/y1 and x2/y2 to the border coordinates to draw a rectangle.
bool Diagram::ResizeTouched(int x, int y, int len)
bool Diagram::resizeTouched(float fX, float fY, float len)
{
if(x < cx-len) return false;
if(x > cx+x2+len) return false;
if(y < cy-y2-len) return false;
if(y > cy+len) return false;
float fCX = float(cx), fCY = float(cy);
float fX2 = float(cx+x2), fY2 = float(cy-y2);
if(fX < fCX-len) return false;
if(fX > fX2+len) return false;
if(fY < fY2-len) return false;
if(fY > fCY+len) return false;
State = 0;
if(x < cx+len) State = 1;
else if(x <= cx+x2-len) return false;
if(y > cy-len) State |= 2;
else if(y >= cy-y2+len) return false;
if(fX < fCX+len) State = 1;
else if(fX <= fX2-len) return false;
if(fY > fCY-len) State |= 2;
else if(fY >= fY2+len) return false;
return true;
}
@ -793,10 +790,16 @@ void Diagram::updateGraphData()
Graph *pg;
for(pg = Graphs.first(); pg != 0; pg = Graphs.next()) {
if(pg->Points != 0) { free(pg->Points); pg->Points = 0; }
if(pg->ScrPoints != 0) {
free(pg->ScrPoints);
pg->ScrPoints = 0;
}
if((valid & (pg->yAxisNo+1)) != 0)
calcData(pg); // calculate screen coordinates
else if(pg->cPointsY) { delete[] pg->cPointsY; pg->cPointsY = 0; }
else if(pg->cPointsY) {
delete[] pg->cPointsY;
pg->cPointsY = 0;
}
}
createAxisLabels(); // virtual function

16
qucs/diagrams/diagram.h
View File

@ -34,8 +34,8 @@
#define FIT_MEMORY_SIZE \
if(p >= p_end) { \
Size += 256; \
tmp = p - g->Points; \
p = p_end = g->Points = (int*)realloc(g->Points, Size*sizeof(int)); \
tmp = p - g->ScrPoints; \
p = p_end = g->ScrPoints = (float*)realloc(g->ScrPoints, Size*sizeof(float)); \
p += tmp; \
p_end += Size - 9; \
} \
@ -62,7 +62,7 @@ public:
virtual Diagram* newOne();
virtual int calcDiagram() { return 0; };
virtual void calcCoordinate
(double* &, double* &, double* &, int*, int*, Axis*) {};
(double* &, double* &, double* &, float*, float*, Axis*) {};
virtual void calcLimits() {};
virtual void paint(ViewPainter*);
@ -71,7 +71,7 @@ public:
void paintScheme(QPainter*);
void Bounding(int&, int&, int&, int&);
bool getSelected(int, int);
bool ResizeTouched(int, int, int);
bool resizeTouched(float, float, float);
QString save();
bool load(const QString&, QTextStream*);
@ -83,7 +83,7 @@ public:
bool sameDependencies(Graph*, Graph*);
int checkColumnWidth(const QString&, const QFontMetrics&, int, int, int);
virtual bool insideDiagram(int, int);
virtual bool insideDiagram(float, float);
QString Name; // identity of diagram type (e.g. Polar), used for saving etc.
QPen GridPen;
@ -112,9 +112,9 @@ protected:
bool calcYAxis(Axis*, int);
virtual void createAxisLabels();
int regionCode(int, int);
virtual void clip(int* &);
void rectClip(int* &);
int regionCode(float, float);
virtual void clip(float* &);
void rectClip(float* &);
virtual void calcData(Graph*);

122
qucs/diagrams/graph.cpp
View File

@ -27,7 +27,6 @@ Graph::Graph(const QString& _Line)
Var = _Line;
countY = 0; // no points in graph
Points = 0;
Thick = numMode = 0;
Color = 0x0000ff; // blue
Style = 0; // solid line
@ -35,7 +34,7 @@ Graph::Graph(const QString& _Line)
isSelected = false;
yAxisNo = 0; // left y axis
Points = 0;
ScrPoints = 0;
cPointsY = 0;
Markers.setAutoDelete(true);
@ -44,14 +43,16 @@ Graph::Graph(const QString& _Line)
Graph::~Graph()
{
if(Points != 0) free(Points);
if(cPointsY != 0) delete[] cPointsY;
if(ScrPoints != 0)
free(ScrPoints);
if(cPointsY != 0)
delete[] cPointsY;
}
// ---------------------------------------------------------------------
void Graph::paint(ViewPainter *p, int x0, int y0)
{
if(Points == 0)
if(ScrPoints == 0)
return;
if(isSelected) {
@ -71,40 +72,18 @@ void Graph::paint(ViewPainter *p, int x0, int y0)
// ---------------------------------------------------------------------
void Graph::paintLines(ViewPainter *p, int x0, int y0)
{
int x, y;
int *pp = Points;
if(*pp < 0) pp++;
while(*pp > -99) {
if(*pp >= 0) if(*(pp+2) != GRAPHCIRCLE)
p->drawPoint(x0+(*pp), y0-(*(pp+1)));
while(*pp > -9) { // until end of branch
pp += 2;
while(*pp > -2) { // until end of stroke
p->drawLine(x0+(*(pp-2)), y0-(*(pp-1)), x0+(*pp), y0-(*(pp+1)));
pp += 2;
}
if(*pp < -9) break; // end of line ?
else {
x = x0 + *(pp-2);
y = y0 - *(pp-1);
if(*pp == GRAPHSTAR) { // paint star
p->drawLine(x-5, y, x+5, y); // horizontal line
p->drawLine(x-4, y+4, x+4, y-4); // upper left to lower right
p->drawLine(x+4, y+4, x-4, y-4); // upper right to lower left
}
else if(*pp == GRAPHCIRCLE) // paint circle
p->drawEllipse(x-4, y-4, 8, 8);
else if(*pp == GRAPHARROW) { // paint arrow
p->drawLine(x, y, x, y0);
p->drawLine(x-4, y+7, x, y);
p->drawLine(x+4, y+7, x, y);
}
}
pp++;
}
// if(*pp < -99) break; // end of all lines ?
pp++;
switch(Style) {
case GRAPHSTYLE_STAR:
p->drawStarSymbols(x0, y0, ScrPoints);
break;
case GRAPHSTYLE_CIRCLE:
p->drawCircleSymbols(x0, y0, ScrPoints);
break;
case GRAPHSTYLE_ARROW:
p->drawArrowSymbols(x0, y0, ScrPoints);
break;
default:
p->drawLines(x0, y0, ScrPoints);
}
}
@ -168,7 +147,7 @@ bool Graph::load(const QString& _s)
// diagram cx/cy. 5 is the precision the user must point onto the graph.
int Graph::getSelected(int x, int y)
{
int *pp = Points;
float *pp = ScrPoints;
if(pp == 0) return -1;
int A, z=0;
@ -176,41 +155,60 @@ int Graph::getSelected(int x, int y)
int dy, dy2, y1;
int countX = cPointsX.getFirst()->count;
if(*pp < 0) {
if(*pp < -9) z++;
if(*pp <= STROKEEND) {
if(*pp <= BRANCHEND) z++;
pp++;
if(*pp < -9) {
if(*pp <= BRANCHEND) {
z++;
pp++;
if(*pp < -10) return -1; // not even one point ?
if(*pp < BRANCHEND) return -1; // not even one point ?
}
}
while(*pp > -99) {
while(*pp > -5) {
x1 = *(pp++); y1 = *(pp++);
if(Style >= GRAPHSTYLE_STAR) {
// for graph symbols
while(*pp > GRAPHEND) {
if(*pp > STROKEEND) {
dx = x - int(*(pp++));
dy = y - int(*(pp++));
if(dx < -5) continue;
if(dx > 5) continue;
if(dy < -5) continue;
if(dy > 5) continue;
return z*countX; // points on graph symbol
}
else {
z++; // next branch
pp++;
}
}
return -1;
}
// for graph lines
while(*pp > GRAPHEND) {
while(*pp >= STROKEEND) {
x1 = int(*(pp++));
y1 = int(*(pp++));
dx = x - x1;
dy = y - y1;
dx2 = (*pp);
if(dx2 < -1) {
if(dx2 < -9) break;
pp++;
if(dx2 < -2) { // no line, but single point (e.g. star) ?
if(*pp < -9) break;
if(dx < -5) continue;
if(dx > 5) continue;
if(dy < -5) continue;
if(dy > 5) continue;
return z*countX; // points on graph
}
dx2 = *pp;
if(dx2 < -9) break;
dx2 = int(*pp);
if(dx2 <= STROKEEND) { // end of stroke ?
if(dx2 <= BRANCHEND) break;
pp++;
dx2 = int(*pp); // go on as graph can also be selected between strokes
if(dx2 <= BRANCHEND) break;
}
if(dx < -5) { if(x < dx2-5) continue; } // point between x coordinates ?
else { if(x > 5) if(x > dx2+5) continue; }
dy2 = (*(pp+1));
dy2 = int(*(pp+1));
if(dy < -5) { if(y < dy2-5) continue; } // point between y coordinates ?
else { if(y > 5) if(y > dy2+5) continue; }

15
qucs/diagrams/graph.h
View File

@ -29,12 +29,16 @@
// meaning of the values in a graph "Points" list
#define STROKEEND -2
#define GRAPHARROW -5
#define GRAPHCIRCLE -6
#define GRAPHSTAR -7
#define BRANCHEND -10
#define GRAPHEND -100
#define GRAPHSTYLE_SOLID 0
#define GRAPHSTYLE_DASH 1
#define GRAPHSTYLE_DOT 2
#define GRAPHSTYLE_LONGDASH 3
#define GRAPHSTYLE_STAR 4
#define GRAPHSTYLE_CIRCLE 5
#define GRAPHSTYLE_ARROW 6
class Diagram;
class ViewPainter;
@ -63,10 +67,11 @@ public:
Graph* sameNewOne();
QDateTime lastLoaded; // when it was loaded into memory
int yAxisNo; // which y axis is used
int yAxisNo; // which y axis is used
QPtrList<DataX> cPointsX;
double *cPointsY;
int *Points, countY; // data in screen coordinates, countY = curves number
float *ScrPoints; // data in screen coordinates
int countY; // number of curves
QString Var;
QColor Color;
int Thick;

32
qucs/diagrams/marker.cpp
View File

@ -65,6 +65,7 @@ void Marker::initText(int n)
Text = "";
nVarPos = 0;
float fX, fY;
bool isCross = false;
int nn, nnn, m, x, y, d, dmin = INT_MAX;
DataX *pD = pGraph->cPointsX.first();
@ -90,14 +91,14 @@ void Marker::initText(int n)
m = nnn - 1;
pz = pGraph->cPointsY + 2*n;
for(nn=0; nn<nnn; nn++) {
Diag->calcCoordinate(px, pz, py, &x, &y, pa);
Diag->calcCoordinate(px, pz, py, &fX, &fY, pa);
if(isCross) {
px--;
py++;
pz += 2*(pD->count-1);
}
x -= cx;
y -= cy;
x = int(fX+0.5) - cx;
y = int(fY+0.5) - cy;
d = x*x + y*y;
if(d < dmin) {
dmin = d;
@ -121,20 +122,22 @@ void Marker::initText(int n)
Text += pGraph->Var + ": ";
switch(numMode) {
case 0: Text += complexRect(*pz, *(pz+1), Precision);
break;
break;
case 1: Text += complexDeg(*pz, *(pz+1), Precision);
break;
break;
case 2: Text += complexRad(*pz, *(pz+1), Precision);
break;
break;
}
VarPos[nVarPos] = *pz;
VarPos[nVarPos+1] = *(pz+1);
px = VarPos;
py = VarPos + 1;
Diag->calcCoordinate(px, pz, py, &cx, &cy, pa);
Diag->calcCoordinate(px, pz, py, &fX, &fY, pa);
cx = int(fX+0.5);
cy = int(fY+0.5);
if(!Diag->insideDiagram(cx, cy))
if(!Diag->insideDiagram(fX, fY))
// if marker out of valid bounds, point to origin
if((Diag->Name.left(4) != "Rect") && (Diag->Name != "Curve")) {
cx = Diag->x2 >> 1;
@ -191,11 +194,11 @@ void Marker::createText()
Text += pGraph->Var + ": ";
switch(numMode) {
case 0: Text += complexRect(*pz, *(pz+1), Precision);
break;
break;
case 1: Text += complexDeg(*pz, *(pz+1), Precision);
break;
break;
case 2: Text += complexRad(*pz, *(pz+1), Precision);
break;
break;
}
VarPos[nVarPos] = *pz;
VarPos[nVarPos+1] = *(pz+1);
@ -204,10 +207,13 @@ void Marker::createText()
if(pGraph->yAxisNo == 0) pa = &(Diag->yAxis);
else pa = &(Diag->zAxis);
pp = &(VarPos[0]);
Diag->calcCoordinate(pp, pz, py, &cx, &cy, pa);
float fX, fY;
Diag->calcCoordinate(pp, pz, py, &fX, &fY, pa);
cx = int(fX+0.5);
cy = int(fY+0.5);
if(!Diag->insideDiagram(cx, cy))
if(!Diag->insideDiagram(fX, fY))
// if marker out of valid bounds, point to origin
if((Diag->Name.left(4) != "Rect") && (Diag->Name != "Curve")) {
cx = Diag->x2 >> 1;

6
qucs/diagrams/polardiagram.cpp
View File

@ -40,12 +40,12 @@ PolarDiagram::~PolarDiagram()
// ------------------------------------------------------------
void PolarDiagram::calcCoordinate(double* &, double* &yD, double* &,
int *px, int *py, Axis*)
float *px, float *py, Axis*)
{
double yr = *(yD++);
double yi = *(yD++);
*px = int((yr/yAxis.up + 1.0)*double(x2)/2.0 + 0.5);
*py = int((yi/yAxis.up + 1.0)*double(y2)/2.0 + 0.5);
*px = float((yr/yAxis.up + 1.0)*double(x2)/2.0);
*py = float((yi/yAxis.up + 1.0)*double(y2)/2.0);
}
// --------------------------------------------------------------

4
qucs/diagrams/polardiagram.h
View File

@ -24,14 +24,14 @@
class PolarDiagram : public Diagram {
public:
PolarDiagram(int _cx=0, int _cy=0);
~PolarDiagram();
~PolarDiagram();
Diagram* newOne();
static Element* info(QString&, char* &, bool getNewOne=false);
int calcDiagram();
void calcLimits();
void calcCoordinate(double* &, double* &, double* &, int*, int*, Axis*);
void calcCoordinate(double* &, double* &, double* &, float*, float*, Axis*);
};
#endif

6
qucs/diagrams/psdiagram.cpp
View File

@ -42,12 +42,12 @@ PSDiagram::~PSDiagram()
// ------------------------------------------------------------
void PSDiagram::calcCoordinate(double* &, double* &yD, double* &,
int *px, int *py, Axis *pa)
float *px, float *py, Axis *pa)
{
double yr = *(yD++);
double yi = *(yD++);
*px = int((yr/pa->up + 1.0)*double(x2)/2.0 + 0.5);
*py = int((yi/pa->up + 1.0)*double(y2)/2.0 + 0.5);
*px = float((yr/pa->up + 1.0)*double(x2)/2.0);
*py = float((yi/pa->up + 1.0)*double(y2)/2.0);
}
// --------------------------------------------------------------

2
qucs/diagrams/psdiagram.h
View File

@ -33,7 +33,7 @@ public:
static Element* info_sp(QString&, char* &, bool getNewOne=false);
int calcDiagram();
void calcLimits();
void calcCoordinate(double* &, double* &, double* &, int*, int*, Axis*);
void calcCoordinate(double* &, double* &, double* &, float*, float*, Axis*);
};
#endif

74
qucs/diagrams/rect3ddiagram.cpp
View File

@ -110,12 +110,12 @@ int Rect3DDiagram::calcCross(int *Xses, int *Yses)
scaleX = double(x2) / (XMAX_2D - XMIN_2D); // scaling 3D -> 2D transformation
scaleY = double(y2) / (YMAX_2D - YMIN_2D);
xorig = -int(XMIN_2D * scaleX); // position of origin
yorig = -int(YMIN_2D * scaleY);
xorig = -XMIN_2D * scaleX; // position of origin
yorig = -YMIN_2D * scaleY;
for(z=0; z<8; z++) { // calculate 2D coordinates of all corners
*(Xses+z) = int(x2D[z] * scaleX + 0.5) + xorig;
*(Yses+z) = int(y2D[z] * scaleY + 0.5) + yorig;
*(Xses+z) = int(x2D[z] * scaleX + 0.5 + xorig);
*(Yses+z) = int(y2D[z] * scaleY + 0.5 + yorig);
}
return Center;
}
@ -123,7 +123,7 @@ int Rect3DDiagram::calcCross(int *Xses, int *Yses)
// ------------------------------------------------------------
// Is needed for markers.
void Rect3DDiagram::calcCoordinate(double* &xD, double* &zD, double* &yD,
int *px, int *py, Axis*)
float *px, float *py, Axis*)
{
double x3D = *(zD++);
double y3D = *(zD++);
@ -162,8 +162,8 @@ void Rect3DDiagram::calcCoordinate(double* &xD, double* &zD, double* &yD,
else
y3D = (*yD - yAxis.low) / (yAxis.up - yAxis.low);
*px = int(calcX_2D(x3D, y3D, z3D) + 0.5) + xorig;
*py = int(calcY_2D(x3D, y3D, z3D) + 0.5) + yorig;
*px = float(calcX_2D(x3D, y3D, z3D)) + xorig;
*py = float(calcY_2D(x3D, y3D, z3D)) + yorig;
}
// ------------------------------------------------------------
@ -203,8 +203,8 @@ void Rect3DDiagram::calcCoordinate3D(double x, double y, double zr, double zi,
else
y = (y - yAxis.low) / (yAxis.up - yAxis.low);
p->x = int(calcX_2D(x, y, zr) + 0.5) + xorig;
p->y = int(calcY_2D(x, y, zr) + 0.5) + yorig;
p->x = int(calcX_2D(x, y, zr) + 0.5 + xorig);
p->y = int(calcY_2D(x, y, zr) + 0.5 + yorig);
p->No = pz->No = p-Mem;
p->done = 0;
pz->z = float(calcZ_2D(x, y, zr));
@ -377,7 +377,7 @@ void Rect3DDiagram::removeHiddenLines(char *zBuffer, tBound *Bounds)
for(j=dx; j>0; j--) { // x coordinates
calcCoordinate3D(*(px++), *py, *pz, *(pz+1), pMem++, zp++);
pz += 2;
pz += 2;
}
(pMem-1)->done |= 8; // mark as "last in line"
@ -385,6 +385,7 @@ void Rect3DDiagram::removeHiddenLines(char *zBuffer, tBound *Bounds)
if(dy > 0) if((i % dy) == 0)
py = g->cPointsX.at(1)->Points;
}
(pMem-1)->done |= 512; // mark as "last point before grid"
// ..........................................
// copy points for cross lines ("dx", "dy" still unchanged ! )
@ -924,14 +925,14 @@ void Rect3DDiagram::calcData(Graph *g)
double *py;
if(g->countY > 1) py = g->cPointsX.at(1)->Points;
int *p = (int*)malloc( Size*sizeof(int) ); // create memory for points
int *p_end;
g->Points = p_end = p;
float *p = (float*)malloc( Size*sizeof(float) ); // create memory for points
float *p_end;
g->ScrPoints = p_end = p;
p_end += Size - 9; // limit of buffer
*(p++) = STROKEEND;
int dx=0, dy=0, xtmp=0, ytmp=0;
float dx=0.0, dy=0.0, xtmp=0.0, ytmp=0.0;
double Stroke=10.0, Space=10.0; // length of strokes and spaces in pixel
switch(g->Style) {
case 0: // ***** solid line **********************************
@ -963,15 +964,17 @@ void Rect3DDiagram::calcData(Graph *g)
*p = GRAPHEND;
return;
case 1: Stroke = 10.0; Space = 6.0; break; // dash line
case 2: Stroke = 2.0; Space = 4.0; break; // dot line
case 3: Stroke = 24.0; Space = 8.0; break; // long dash line
default: // symbol at each point ******************************
if(g->Style == 4) xtmp = GRAPHSTAR;
else if(g->Style == 5) xtmp = GRAPHCIRCLE;
else if(g->Style == 6) xtmp = GRAPHARROW;
case GRAPHSTYLE_DASH:
Stroke = 10.0; Space = 6.0;
break;
case GRAPHSTYLE_DOT:
Stroke = 2.0; Space = 4.0;
break;
case GRAPHSTYLE_LONGDASH:
Stroke = 24.0; Space = 8.0;
break;
default: // symbol (e.g. star) at each point **********************
do {
while(1) {
if(pMem->done & 11) // is grid point ?
@ -982,16 +985,14 @@ void Rect3DDiagram::calcData(Graph *g)
}
else break;
FIT_MEMORY_SIZE; // need to enlarge memory block ?
*(p++) = pMem->x;
*(p++) = pMem->y;
*(p++) = xtmp;
break;
}
FIT_MEMORY_SIZE; // need to enlarge memory block ?
if(pMem->done & 8) *(p++) = BRANCHEND; // new branch
} while(((pMem++)->done & 256) == 0);
if(pMem->done & 8)
*(p++) = BRANCHEND; // new branch
} while(((pMem++)->done & 512) == 0);
*p = GRAPHEND;
return;
}
@ -1036,8 +1037,8 @@ void Rect3DDiagram::calcData(Graph *g)
while(dist > 0) { // stroke or space finished ?
FIT_MEMORY_SIZE; // need to enlarge memory block ?
*(p++) = xtmp - int(dist*cos(alpha) + 0.5); // linearly interpolate
*(p++) = ytmp - int(dist*sin(alpha) + 0.5);
*(p++) = xtmp - float(dist*cos(alpha)); // linearly interpolate
*(p++) = ytmp - float(dist*sin(alpha));
if(Flag == 0) {
dist -= Stroke;
@ -1062,14 +1063,11 @@ void Rect3DDiagram::calcData(Graph *g)
dy = ytmp;
if(pMem->done & 8) {
switch(*(p-3)) {
case STROKEEND:
p -= 3; // no single point after "no stroke"
break;
case BRANCHEND:
if((*(p-2) < 0) || (*(p-1) < 0))
p -= 2; // erase last hidden point
break;
if(*(p-3) == STROKEEND)
p -= 3; // no single point after "no stroke"
else if(*(p-3) == BRANCHEND) {
if((*(p-2) < 0) || (*(p-1) < 0))
p -= 2; // erase last hidden point
}
*(p++) = BRANCHEND; // new branch
Counter = 0;
@ -1106,7 +1104,7 @@ void Rect3DDiagram::createAxisLabels()
}
// ------------------------------------------------------------
bool Rect3DDiagram::insideDiagram(int x, int y)
bool Rect3DDiagram::insideDiagram(float x, float y)
{
return (regionCode(x, y) == 0);
}

6
qucs/diagrams/rect3ddiagram.h
View File

@ -46,10 +46,10 @@ public:
static Element* info(QString&, char* &, bool getNewOne=false);
int calcDiagram();
void calcLimits();
void calcCoordinate(double* &, double* &, double* &, int*, int*, Axis*);
void calcCoordinate(double* &, double* &, double* &, float*, float*, Axis*);
void createAxisLabels();
bool insideDiagram(int, int);
bool insideDiagram(float, float);
tPoint3D *Mem; // memory for all points during hidden line algorithm
tPoint3D *pMem; // current position in "Mem"
@ -77,7 +77,7 @@ private:
void removeHiddenLines(char*, tBound*);
void removeHiddenCross(int, int, int, int, char*, tBound*);
int xorig, yorig; // where is the 3D origin with respect to cx/cy
float xorig, yorig; // where is the 3D origin with respect to cx/cy
double cxx, cxy, cxz, cyx, cyy, cyz, czx, czy, czz; // coefficients 3D -> 2D
double scaleX, scaleY;
};

16
qucs/diagrams/rectdiagram.cpp
View File

@ -41,7 +41,7 @@ RectDiagram::~RectDiagram()
// ------------------------------------------------------------
void RectDiagram::calcCoordinate(double* &xD, double* &yD, double* &,
int *px, int *py, Axis *pa)
float *px, float *py, Axis *pa)
{
double x = *(xD++);
double yr = *(yD++);
@ -49,20 +49,20 @@ void RectDiagram::calcCoordinate(double* &xD, double* &yD, double* &,
if(xAxis.log) {
x /= xAxis.low;
if(x <= 0.0) *px = -100000; // "negative infinity"
else *px = int(log10(x)/log10(xAxis.up / xAxis.low) * double(x2) + 0.5);
else *px = float(log10(x)/log10(xAxis.up / xAxis.low) * double(x2));
}
else *px = int((x-xAxis.low)/(xAxis.up-xAxis.low)*double(x2) + 0.5);
else *px = float((x-xAxis.low)/(xAxis.up-xAxis.low)*double(x2));
if(pa->log) {
yr = sqrt(yr*yr + yi*yi);
if(yr <= 0.0) *py = -100000; // "negative infinity"
else *py = int(log10(yr/fabs(pa->low)) /
log10(pa->up/pa->low) * double(y2) + 0.5);
else *py = float(log10(yr/fabs(pa->low)) /
log10(pa->up/pa->low) * double(y2));
}
else {
if(fabs(yi) > 1e-250) // preserve negative values if not complex number
yr = sqrt(yr*yr + yi*yi);
*py = int((yr-pa->low)/(pa->up-pa->low)*double(y2) + 0.5);
*py = float((yr-pa->low)/(pa->up-pa->low)*double(y2));
}
}
@ -207,13 +207,13 @@ Frame:
}
// ------------------------------------------------------------
bool RectDiagram::insideDiagram(int x, int y)
bool RectDiagram::insideDiagram(float x, float y)
{
return (regionCode(x, y) == 0);
}
// ------------------------------------------------------------
void RectDiagram::clip(int* &p)
void RectDiagram::clip(float* &p)
{
rectClip(p);
}

6
qucs/diagrams/rectdiagram.h
View File

@ -31,11 +31,11 @@ public:
static Element* info(QString&, char* &, bool getNewOne=false);
int calcDiagram();
void calcLimits();
void calcCoordinate(double* &, double* &, double* &, int*, int*, Axis*);
bool insideDiagram(int, int);
void calcCoordinate(double* &, double* &, double* &, float*, float*, Axis*);
bool insideDiagram(float, float);
protected:
void clip(int* &);
void clip(float* &);
};
#endif

6
qucs/diagrams/smithdiagram.cpp
View File

@ -43,12 +43,12 @@ SmithDiagram::~SmithDiagram()
// ------------------------------------------------------------
// calculate the screen coordinates for the graph data
void SmithDiagram::calcCoordinate(double* &, double* &yD, double* &,
int *px, int *py, Axis*)
float *px, float *py, Axis*)
{
double yr = *(yD++);
double yi = *(yD++);
*px = int((yr/yAxis.up + 1.0)*double(x2)/2.0 + 0.5);
*py = int((yi/yAxis.up + 1.0)*double(y2)/2.0 + 0.5);
*px = float((yr/yAxis.up + 1.0)*double(x2)/2.0);
*py = float((yi/yAxis.up + 1.0)*double(y2)/2.0);
}
// ------------------------------------------------------------

4
qucs/diagrams/smithdiagram.h
View File

@ -24,7 +24,7 @@
class SmithDiagram : public Diagram {
public:
SmithDiagram(int _cx=0, int _cy=0, bool ImpMode=true);
~SmithDiagram();
~SmithDiagram();
Diagram* newOne();
@ -32,7 +32,7 @@ public:
static Element* info_y(QString&, char* &, bool getNewOne=false);
int calcDiagram();
void calcLimits();
void calcCoordinate(double* &, double* &, double* &, int*, int*, Axis*);
void calcCoordinate(double* &, double* &, double* &, float*, float*, Axis*);
};
#endif

187
qucs/mouseactions.cpp
View File

@ -43,6 +43,14 @@
#include <stdlib.h>
#define DOC_X_POS(x) (int(float(x)/Doc->Scale) + Doc->ViewX1)
#define DOC_Y_POS(y) (int(float(y)/Doc->Scale) + Doc->ViewY1)
#define DOC_X_FPOS (float(Event->pos().x())/Doc->Scale + float(Doc->ViewX1))
#define DOC_Y_FPOS (float(Event->pos().y())/Doc->Scale + float(Doc->ViewY1))
#define SCR_X_POS(x) int(float(x - Doc->ViewX1) * Doc->Scale)
#define SCR_Y_POS(y) int(float(y - Doc->ViewY1) * Doc->Scale)
MouseActions::MouseActions()
{
selElem = 0; // no component/diagram is selected
@ -263,8 +271,8 @@ void MouseActions::MMoveElement(Schematic *Doc, QMouseEvent *Event)
int x = Event->pos().x();
int y = Event->pos().y();
int fx = int(float(x)/Doc->Scale) + Doc->ViewX1;
int fy = int(float(y)/Doc->Scale) + Doc->ViewY1;
int fx = DOC_X_POS(x);
int fy = DOC_Y_POS(y);
int gx = fx;
int gy = fy;
Doc->setOnGrid(gx, gy);
@ -310,8 +318,8 @@ void MouseActions::MMoveWire2(Schematic *Doc, QMouseEvent *Event)
}
else drawn = true;
MAx2 = int(float(Event->pos().x())/Doc->Scale) + Doc->ViewX1;
MAy2 = int(float(Event->pos().y())/Doc->Scale) + Doc->ViewY1;
MAx2 = DOC_X_POS(Event->pos().x());
MAy2 = DOC_Y_POS(Event->pos().y());
Doc->setOnGrid(MAx2, MAy2);
if(MAx1 == 0) {
@ -330,25 +338,26 @@ void MouseActions::MMoveWire2(Schematic *Doc, QMouseEvent *Event)
void MouseActions::MMoveWire1(Schematic *Doc, QMouseEvent *Event)
{
QPainter painter(Doc->viewport());
setPainter(Doc, &painter);
painter.setPen(Qt::DotLine);
painter.setRasterOp(Qt::NotROP); // background should not be erased
if(drawn) {
painter.drawLine(MAx1, MAy3, MAx2, MAy3); // erase old
painter.drawLine(MAx3, MAy1, MAx3, MAy2);
painter.drawLine(0, MAy3, MAx2, MAy3); // erase old
painter.drawLine(MAx3, 0, MAx3, MAy2);
}
drawn = true;
MAx3 = int(float(Event->pos().x())/Doc->Scale) + Doc->ViewX1;
MAy3 = int(float(Event->pos().y())/Doc->Scale) + Doc->ViewY1;
MAx3 = DOC_X_POS(Event->pos().x());
MAy3 = DOC_Y_POS(Event->pos().y());
Doc->setOnGrid(MAx3, MAy3);
MAx3 = SCR_X_POS(MAx3) - Doc->contentsX();
MAy3 = SCR_Y_POS(MAy3) - Doc->contentsY();
MAx1 = Doc->contentsX()+Doc->ViewX1;
MAy1 = Doc->contentsY()+Doc->ViewY1;
MAx2 = MAx1 + Doc->visibleWidth();
MAy2 = MAy1 + Doc->visibleHeight();
MAx2 = Doc->visibleWidth();
MAy2 = Doc->visibleHeight();
painter.drawLine(MAx1, MAy3, MAx2, MAy3); // paint
painter.drawLine(MAx3, MAy1, MAx3, MAy2);
drawn = true;
painter.drawLine(0, MAy3, MAx2, MAy3); // paint
painter.drawLine(MAx3, 0, MAx3, MAy2);
}
// -----------------------------------------------------------
@ -360,8 +369,8 @@ void MouseActions::MMoveSelect(Schematic *Doc, QMouseEvent *Event)
if(drawn) painter.drawRect(MAx1, MAy1, MAx2, MAy2); // erase old rectangle
drawn = true;
MAx2 = int(float(Event->pos().x())/Doc->Scale) + Doc->ViewX1 - MAx1;
MAy2 = int(float(Event->pos().y())/Doc->Scale) + Doc->ViewY1 - MAy1;
MAx2 = DOC_X_POS(Event->pos().x()) - MAx1;
MAy2 = DOC_Y_POS(Event->pos().y()) - MAy1;
if(isMoveEqual) // x and y size must be equal ?
if(abs(MAx2) > abs(MAy2)) {
if(MAx2<0) MAx2 = -abs(MAy2); else MAx2 = abs(MAy2);
@ -376,8 +385,8 @@ void MouseActions::MMoveResizePainting(Schematic *Doc, QMouseEvent *Event)
QPainter painter(Doc->viewport());
setPainter(Doc, &painter);
MAx1 = int(float(Event->pos().x())/Doc->Scale) + Doc->ViewX1;
MAy1 = int(float(Event->pos().y())/Doc->Scale) + Doc->ViewY1;
MAx1 = DOC_X_POS(Event->pos().x());
MAy1 = DOC_Y_POS(Event->pos().y());
Doc->setOnGrid(MAx1, MAy1);
((Painting*)focusElement)->MouseResizeMoving(MAx1, MAy1, &painter);
}
@ -389,8 +398,8 @@ void MouseActions::MMoveMoving(Schematic *Doc, QMouseEvent *Event)
QPainter painter(Doc->viewport());
setPainter(Doc, &painter);
MAx2 = int(Event->pos().x()/Doc->Scale) + Doc->ViewX1;
MAy2 = int(Event->pos().y()/Doc->Scale) + Doc->ViewY1;
MAx2 = DOC_X_POS(Event->pos().x());
MAy2 = DOC_X_POS(Event->pos().y());
Doc->setOnGrid(MAx2, MAy2);
MAx3 = MAx1 = MAx2 - MAx1;
@ -442,8 +451,8 @@ void MouseActions::MMoveMoving2(Schematic *Doc, QMouseEvent *Event)
QPainter painter(Doc->viewport());
setPainter(Doc, &painter);
MAx2 = int(float(Event->pos().x())/Doc->Scale) + Doc->ViewX1;
MAy2 = int(float(Event->pos().y())/Doc->Scale) + Doc->ViewY1;
MAx2 = DOC_X_POS(Event->pos().x());
MAy2 = DOC_Y_POS(Event->pos().y());
Element *pe;
if(drawn) // erase old scheme
@ -480,8 +489,8 @@ void MouseActions::MMovePaste(Schematic *Doc, QMouseEvent *Event)
QPainter painter(Doc->viewport());
setPainter(Doc, &painter);
MAx1 = int(float(Event->pos().x())/Doc->Scale) + Doc->ViewX1;
MAy1 = int(float(Event->pos().y())/Doc->Scale) + Doc->ViewY1;
MAx1 = DOC_X_POS(Event->pos().x());
MAy1 = DOC_Y_POS(Event->pos().y());
Doc->setOnGrid(MAx1, MAy1);
for(Element *pe=movingElements.first(); pe!=0; pe=movingElements.next()) {
@ -504,8 +513,8 @@ void MouseActions::MMovePaste(Schematic *Doc, QMouseEvent *Event)
void MouseActions::MMoveScrollBar(Schematic *Doc, QMouseEvent *Event)
{
TabDiagram *d = (TabDiagram*)focusElement;
int x = int(float(Event->pos().x())/Doc->Scale) + Doc->ViewX1;
int y = int(float(Event->pos().y())/Doc->Scale) + Doc->ViewY1;
int x = DOC_X_POS(Event->pos().x());
int y = DOC_Y_POS(Event->pos().y());
if(d->scrollTo(MAx2, x - MAx1, y - MAy1)) {
Doc->setChanged(true, true, 'm'); // 'm' = only the first time
@ -760,8 +769,8 @@ void MouseActions::MMoveMoveText(Schematic *Doc, QMouseEvent *Event)
painter.drawRect(MAx1, MAy1, MAx2, MAy2); // erase old
drawn = true;
int newX = int(float(Event->pos().x())/Doc->Scale) + Doc->ViewX1;
int newY = int(float(Event->pos().y())/Doc->Scale) + Doc->ViewY1;
int newX = DOC_X_POS(Event->pos().x());
int newY = DOC_Y_POS(Event->pos().y());
MAx1 += newX - MAx3;
MAy1 += newY - MAy3;
MAx3 = newX;
@ -800,11 +809,11 @@ void MouseActions::MMoveZoomIn(Schematic *Doc, QMouseEvent *Event)
// ************************************************************************
// Is called from several MousePress functions to show right button menu.
void MouseActions::rightPressMenu(Schematic *Doc, QMouseEvent *Event, int x, int y)
void MouseActions::rightPressMenu(Schematic *Doc, QMouseEvent *Event, float fX, float fY)
{
MAx1 = x;
MAy1 = y;
focusElement = Doc->selectElement(x, y, false);
MAx1 = int(fX);
MAy1 = int(fY);
focusElement = Doc->selectElement(fX, fY, false);
if(focusElement) // remove special function (4 least significant bits)
focusElement->Type &= isSpecialMask;
@ -877,8 +886,9 @@ void MouseActions::rightPressMenu(Schematic *Doc, QMouseEvent *Event, int x, int
}
// -----------------------------------------------------------
void MouseActions::MPressLabel(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressLabel(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
int x = int(fX), y = int(fY);
Wire *pw = 0;
WireLabel *pl=0;
Node *pn = Doc->selectedNode(x, y);
@ -895,7 +905,7 @@ void MouseActions::MPressLabel(Schematic *Doc, QMouseEvent*, int x, int y)
if(pe) {
if(pe->Type & isComponent) {
QMessageBox::information(0, QObject::tr("Info"),
QObject::tr("The ground potential cannot be labeled!"));
QObject::tr("The ground potential cannot be labeled!"));
return;
}
pl = ((Conductor*)pe)->Label;
@ -945,16 +955,16 @@ void MouseActions::MPressLabel(Schematic *Doc, QMouseEvent*, int x, int y)
}
// -----------------------------------------------------------
void MouseActions::MPressSelect(Schematic *Doc, QMouseEvent *Event, int x, int y)
void MouseActions::MPressSelect(Schematic *Doc, QMouseEvent *Event, float fX, float fY)
{
bool Ctrl;
if(Event->state() & Qt::ControlButton) Ctrl = true;
else Ctrl = false;
int No=0;
MAx1 = x;
MAy1 = y;
focusElement = Doc->selectElement(x, y, Ctrl, &No);
MAx1 = int(fX);
MAy1 = int(fY);
focusElement = Doc->selectElement(fX, fY, Ctrl, &No);
isMoveEqual = false; // moving not neccessarily square
@ -1056,9 +1066,9 @@ void MouseActions::MPressSelect(Schematic *Doc, QMouseEvent *Event, int x, int y
}
// -----------------------------------------------------------
void MouseActions::MPressDelete(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressDelete(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
Element *pe = Doc->selectElement(x, y, false);
Element *pe = Doc->selectElement(fX, fY, false);
if(pe) {
pe->isSelected = true;
Doc->deleteElements();
@ -1070,11 +1080,11 @@ void MouseActions::MPressDelete(Schematic *Doc, QMouseEvent*, int x, int y)
}
// -----------------------------------------------------------
void MouseActions::MPressActivate(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressActivate(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
MAx1 = x;
MAy1 = y;
if(!Doc->activateSpecifiedComponent(x, y)) {
MAx1 = int(fX);
MAy1 = int(fY);
if(!Doc->activateSpecifiedComponent(MAx1, MAy1)) {
// if(Event->button() != Qt::LeftButton) return;
MAx2 = 0; // if not clicking on a component => open a rectangle
MAy2 = 0;
@ -1087,17 +1097,17 @@ void MouseActions::MPressActivate(Schematic *Doc, QMouseEvent*, int x, int y)
}
// -----------------------------------------------------------
void MouseActions::MPressMirrorX(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressMirrorX(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
// no use in mirroring wires or diagrams
Component *c = Doc->selectedComponent(x, y);
Component *c = Doc->selectedComponent(int(fX), int(fY));
if(c) {
if(c->Ports.count() < 1) return; // only mirror components with ports
c->mirrorX();
Doc->setCompPorts(c);
}
else {
Painting *p = Doc->selectedPainting(x, y);
Painting *p = Doc->selectedPainting(fX, fY);
if(p == 0) return;
p->mirrorX();
}
@ -1108,17 +1118,17 @@ void MouseActions::MPressMirrorX(Schematic *Doc, QMouseEvent*, int x, int y)
}
// -----------------------------------------------------------
void MouseActions::MPressMirrorY(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressMirrorY(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
// no use in mirroring wires or diagrams
Component *c = Doc->selectedComponent(x, y);
Component *c = Doc->selectedComponent(int(fX), int(fY));
if(c) {
if(c->Ports.count() < 1) return; // only mirror components with ports
c->mirrorY();
Doc->setCompPorts(c);
}
else {
Painting *p = Doc->selectedPainting(x, y);
Painting *p = Doc->selectedPainting(fX, fY);
if(p == 0) return;
p->mirrorY();
}
@ -1129,9 +1139,9 @@ void MouseActions::MPressMirrorY(Schematic *Doc, QMouseEvent*, int x, int y)
}
// -----------------------------------------------------------
void MouseActions::MPressRotate(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressRotate(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
Element *e = Doc->selectElement(x, y, false);
Element *e = Doc->selectElement(int(fX), int(fY), false);
if(e == 0) return;
e->Type &= isSpecialMask; // remove special functions
@ -1184,7 +1194,7 @@ void MouseActions::MPressRotate(Schematic *Doc, QMouseEvent*, int x, int y)
}
// -----------------------------------------------------------
void MouseActions::MPressElement(Schematic *Doc, QMouseEvent *Event, int, int)
void MouseActions::MPressElement(Schematic *Doc, QMouseEvent *Event, float, float)
{
if(selElem == 0) return;
QPainter painter(Doc->viewport());
@ -1270,20 +1280,21 @@ void MouseActions::MPressElement(Schematic *Doc, QMouseEvent *Event, int, int)
// -----------------------------------------------------------
// Is called if starting point of wire is pressed
void MouseActions::MPressWire1(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressWire1(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
QPainter painter(Doc->viewport());
setPainter(Doc, &painter);
painter.setPen(Qt::DotLine);
painter.setRasterOp(Qt::NotROP); // background should not be erased
if(drawn) {
painter.drawLine(MAx1, MAy3, MAx2, MAy3); // erase old mouse cross
painter.drawLine(MAx3, MAy1, MAx3, MAy2);
painter.drawLine(0, MAy3, MAx2, MAy3); // erase old mouse cross
painter.drawLine(MAx3, 0, MAx3, MAy2);
}
drawn = false;
MAx1 = 0; // paint wire corner first up, then left/right
MAx3 = x;
MAy3 = y;
MAx3 = int(fX);
MAy3 = int(fY);
Doc->setOnGrid(MAx3, MAy3);
QucsMain->MouseMoveAction = &MouseActions::MMoveWire2;
@ -1294,7 +1305,7 @@ void MouseActions::MPressWire1(Schematic *Doc, QMouseEvent*, int x, int y)
// -----------------------------------------------------------
// Is called if ending point of wire is pressed
void MouseActions::MPressWire2(Schematic *Doc, QMouseEvent *Event, int x, int y)
void MouseActions::MPressWire2(Schematic *Doc, QMouseEvent *Event, float fX, float fY)
{
QPainter painter(Doc->viewport());
setPainter(Doc, &painter);
@ -1361,8 +1372,8 @@ void MouseActions::MPressWire2(Schematic *Doc, QMouseEvent *Event, int x, int y)
painter.drawLine(MAx2, MAy3, MAx2, MAy2); // erase old
}
MAx2 = x;
MAy2 = y;
MAx2 = int(fX);
MAy2 = int(fY);
Doc->setOnGrid(MAx2, MAy2);
MAx1 ^= 1; // change the painting direction of wire corner
@ -1382,10 +1393,10 @@ void MouseActions::MPressWire2(Schematic *Doc, QMouseEvent *Event, int x, int y)
// -----------------------------------------------------------
// Is called for setting a marker on a diagram's graph
void MouseActions::MPressMarker(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressMarker(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
MAx1 = x;
MAy1 = y;
MAx1 = int(fX);
MAy1 = int(fY);
Marker *pm = Doc->setMarker(MAx1, MAy1);
if(pm) {
@ -1398,9 +1409,9 @@ void MouseActions::MPressMarker(Schematic *Doc, QMouseEvent*, int x, int y)
}
// -----------------------------------------------------------
void MouseActions::MPressOnGrid(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressOnGrid(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
Element *pe = Doc->selectElement(x, y, false);
Element *pe = Doc->selectElement(fX, fY, false);
if(pe) {
pe->Type &= isSpecialMask; // remove special functions (4 lowest bits)
@ -1415,10 +1426,10 @@ void MouseActions::MPressOnGrid(Schematic *Doc, QMouseEvent*, int x, int y)
}
// -----------------------------------------------------------
void MouseActions::MPressMoveText(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressMoveText(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
MAx1 = x;
MAy1 = y;
MAx1 = int(fX);
MAy1 = int(fY);
focusElement = Doc->selectCompText(MAx1, MAy1, MAx2, MAy2);
if(focusElement) {
@ -1435,10 +1446,10 @@ void MouseActions::MPressMoveText(Schematic *Doc, QMouseEvent*, int x, int y)
}
// -----------------------------------------------------------
void MouseActions::MPressZoomIn(Schematic *Doc, QMouseEvent*, int x, int y)
void MouseActions::MPressZoomIn(Schematic *Doc, QMouseEvent*, float fX, float fY)
{
MAx1 = x;
MAy1 = y;
MAx1 = int(fX);
MAy1 = int(fY);
MAx2 = 0; // rectangle size
MAy2 = 0;
@ -1665,8 +1676,8 @@ void MouseActions::MReleasePaste(Schematic *Doc, QMouseEvent *Event)
pe->paintScheme(&painter);
drawn = true;
x1 = int(float(Event->pos().x())/Doc->Scale) + Doc->ViewX1;
y1 = int(float(Event->pos().y())/Doc->Scale) + Doc->ViewY1;
x1 = DOC_X_POS(Event->pos().x());
y1 = DOC_Y_POS(Event->pos().y());
Doc->setOnGrid(x1, y1);
for(pe = movingElements.first(); pe != 0; pe = movingElements.next()) {
@ -1674,12 +1685,12 @@ void MouseActions::MReleasePaste(Schematic *Doc, QMouseEvent *Event)
case isComponent:
case isAnalogComponent:
case isDigitalComponent:
((Component*)pe)->rotate(); // rotate !before! rotating the center
((Component*)pe)->rotate(); // rotate !before! rotating the center
x2 = x1 - pe->cx;
pe->setCenter(pe->cy - y1 + x1, x2 + y1);
break;
case isWire:
x2 = pe->x1;
x2 = pe->x1;
pe->x1 = pe->y1 - y1 + x1;
pe->y1 = x1 - x2 + y1;
x2 = pe->x2;
@ -1687,12 +1698,12 @@ void MouseActions::MReleasePaste(Schematic *Doc, QMouseEvent *Event)
pe->y2 = x1 - x2 + y1;
break;
case isPainting:
((Painting*)pe)->rotate(); // rotate !before! rotating the center
((Painting*)pe)->rotate(); // rotate !before! rotating the center
((Painting*)pe)->getCenter(x2, y2);
pe->setCenter(y2 - y1 + x1, x1 - x2 + y1);
break;
default:
x2 = x1 - pe->cx; // if diagram -> only rotate cx/cy
x2 = x1 - pe->cx; // if diagram -> only rotate cx/cy
pe->setCenter(pe->cy - y1 + x1, x2 + y1);
break;
}
@ -1775,8 +1786,7 @@ void MouseActions::editElement(Schematic *Doc, QMouseEvent *Event)
int x1, y1, x2, y2;
QFileInfo Info(Doc->DocName);
int x = int(Event->pos().x()/Doc->Scale) + Doc->ViewX1;
int y = int(Event->pos().y()/Doc->Scale) + Doc->ViewY1;
float fX = DOC_X_FPOS, fY = DOC_Y_FPOS;
switch(focusElement->Type) {
case isComponent:
@ -1812,14 +1822,14 @@ void MouseActions::editElement(Schematic *Doc, QMouseEvent *Event)
dia = (Diagram*)focusElement;
if(dia->Name.at(0) == 'T') // don't open dialog on scrollbar
if(dia->Name == "Time") {
if(dia->cy < y) {
if(dia->cy < int(fY)) {
if(((TimingDiagram*)focusElement)->scroll(MAx1))
Doc->setChanged(true, true, 'm'); // 'm' = only the first time
break;
}
}
else {
if(dia->cx > x) {
if(dia->cx > int(fX)) {
if(((TabDiagram*)focusElement)->scroll(MAy1))
Doc->setChanged(true, true, 'm'); // 'm' = only the first time
break;
@ -1851,7 +1861,7 @@ void MouseActions::editElement(Schematic *Doc, QMouseEvent *Event)
break;
case isWire:
MPressLabel(Doc, Event, x, y);
MPressLabel(Doc, Event, fX, fY);
break;
case isNodeLabel:
@ -1893,10 +1903,7 @@ void MouseActions::MDoubleClickSelect(Schematic *Doc, QMouseEvent *Event)
// -----------------------------------------------------------
void MouseActions::MDoubleClickWire2(Schematic *Doc, QMouseEvent *Event)
{
int x = int(Event->pos().x()/Doc->Scale) + Doc->ViewX1;
int y = int(Event->pos().y()/Doc->Scale) + Doc->ViewY1;
MPressWire2(Doc, Event, x, y);
MPressWire2(Doc, Event, DOC_X_FPOS, DOC_Y_FPOS);
QucsMain->MouseMoveAction = &MouseActions::MMoveWire1;
QucsMain->MousePressAction = &MouseActions::MPressWire1;

32
qucs/mouseactions.h
View File

@ -77,21 +77,21 @@ public:
void MMoveZoomIn(Schematic*, QMouseEvent*);
void MMoveScrollBar(Schematic*, QMouseEvent*);
void MPressSelect(Schematic*, QMouseEvent*, int, int);
void MPressDelete(Schematic*, QMouseEvent*, int, int);
void MPressActivate(Schematic*, QMouseEvent*, int, int);
void MPressMirrorX(Schematic*, QMouseEvent*, int, int);
void MPressMirrorY(Schematic*, QMouseEvent*, int, int);
void MPressRotate(Schematic*, QMouseEvent*, int, int);
void MPressElement(Schematic*, QMouseEvent*, int, int);
void MPressLabel(Schematic*, QMouseEvent*, int, int);
void MPressWire1(Schematic*, QMouseEvent*, int, int);
void MPressWire2(Schematic*, QMouseEvent*, int, int);
void MPressPainting(Schematic*, QMouseEvent*, int, int);
void MPressMarker(Schematic*, QMouseEvent*, int, int);
void MPressOnGrid(Schematic*, QMouseEvent*, int, int);
void MPressMoveText(Schematic*, QMouseEvent*, int, int);
void MPressZoomIn(Schematic*, QMouseEvent*, int, int);
void MPressSelect(Schematic*, QMouseEvent*, float, float);
void MPressDelete(Schematic*, QMouseEvent*, float, float);
void MPressActivate(Schematic*, QMouseEvent*, float, float);
void MPressMirrorX(Schematic*, QMouseEvent*, float, float);
void MPressMirrorY(Schematic*, QMouseEvent*, float, float);
void MPressRotate(Schematic*, QMouseEvent*, float, float);
void MPressElement(Schematic*, QMouseEvent*, float, float);
void MPressLabel(Schematic*, QMouseEvent*, float, float);
void MPressWire1(Schematic*, QMouseEvent*, float, float);
void MPressWire2(Schematic*, QMouseEvent*, float, float);
void MPressPainting(Schematic*, QMouseEvent*, float, float);
void MPressMarker(Schematic*, QMouseEvent*, float, float);
void MPressOnGrid(Schematic*, QMouseEvent*, float, float);
void MPressMoveText(Schematic*, QMouseEvent*, float, float);
void MPressZoomIn(Schematic*, QMouseEvent*, float, float);
void MDoubleClickSelect(Schematic*, QMouseEvent*);
void MDoubleClickWire2(Schematic*, QMouseEvent*);
@ -108,7 +108,7 @@ public:
void moveElements(QPtrList<Element>*, int, int);
void endElementMoving(Schematic*, QPtrList<Element>*);
void rightPressMenu(Schematic*, QMouseEvent*, int, int);
void rightPressMenu(Schematic*, QMouseEvent*, float, float);
};
#endif

115
qucs/paintings/arrow.cpp
View File

@ -208,14 +208,17 @@ QString Arrow::save()
// --------------------------------------------------------------------------
// Checks if the resize area was clicked.
bool Arrow::ResizeTouched(int x, int y, int len)
bool Arrow::resizeTouched(float fX, float fY, float len)
{
if(x < cx+len) if(x > cx-len) if(y < cy+len) if(y > cy-len) {
float fCX = float(cx),fCY = float(cy);
if(fX < fCX+len) if(fX > fCX-len) if(fY < fCY+len) if(fY > fCY-len) {
State = 1;
return true;
}
if(x < cx+x2+len) if(x > cx+x2-len) if(y < cy+y2+len) if(y > cy+y2-len) {
fCX += float(x2);
fCY += float(y2);
if(fX < fCX+len) if(fX > fCX-len) if(fY < fCY+len) if(fY > fCY-len) {
State = 2;
return true;
}
@ -301,53 +304,95 @@ bool Arrow::MousePressing()
// --------------------------------------------------------------------------
// Checks if the coordinates x/y point to the painting.
// 5 is the precision the user must point onto the painting.
bool Arrow::getSelected(int x, int y)
bool Arrow::getSelected(float fX, float fY, float w)
{
int A, xn, yn;
float A, xn, yn;
// first check if coordinates match the arrow body
x -= cx;
y -= cy;
fX -= float(cx);
fY -= float(cy);
if(x < -5) { if(x < x2-5) goto Head1; } // is point between x coordinates ?
else { if(x > 5) if(x > x2+5) goto Head1; }
if(y < -5) { if(y < y2-5) goto Head1; } // is point between y coordinates ?
else { if(y > 5) if(y > y2+5) goto Head1; }
if(fX < -w) {
if(fX < float(x2)-w) // is point between x coordinates ?
goto Head1;
}
else {
if(fX > w)
if(fX > float(x2)+w)
goto Head1;
}
A = x2*y - x*y2; // calculate the rectangle area spanned
A *= A; // avoid the need for square root
A -= 25*(x2*x2 + y2*y2); // substract selectable area
if(fY < -w) {
if(fY < float(y2)-w) // is point between y coordinates ?
goto Head1;
}
else {
if(fY > w)
if(fY > float(y2)+w)
goto Head1;
}
if(A <= 0) return true; // lies x/y onto the graph line ?
A = float(x2)*fY - fX*float(y2); // calculate the rectangle area spanned
A *= A; // avoid the need for square root
if(A <= w*w*float(x2*x2 + y2*y2))
return true; // x/y lies on the graph line
Head1: // check if coordinates match the first arrow head line
xn = xp1-x2; x -= x2;
yn = yp1-y2; y -= y2;
xn = float(xp1-x2); fX -= float(x2);
yn = float(yp1-y2); fY -= float(y2);
if(x < -5) { if(x < xn-5) goto Head2; } // is point between x coordinates ?
else { if(x > 5) if(x > xn+5) goto Head2; }
if(y < -5) { if(y < yn-5) goto Head2; } // is point between y coordinates ?
else { if(y > 5) if(y > yn+5) goto Head2; }
if(fX < -w) {
if(fX < xn-w) // is point between x coordinates ?
goto Head2;
}
else {
if(fX > w)
if(fX > xn+w)
goto Head2;
}
A = xn*y - x*yn; // calculate the rectangle area spanned
A *= A; // avoid the need for square root
A -= 25*(xn*xn + yn*yn); // substract selectable area
if(fY < -w) {
if(fY < yn-w) // is point between y coordinates ?
goto Head2;
}
else
if(fY > w)
if(fY > yn+w)
goto Head2;
if(A <= 0) return true; // lies x/y onto the graph line ?
A = xn*fY - fX*yn; // calculate the rectangle area spanned
A *= A; // avoid the need for square root
if(A <= w*w*(xn*xn + yn*yn))
return true; // x/y lies on the arrow head
Head2: // check if coordinates match the second arrow head line
xn = xp2-x2;
yn = yp2-y2;
xn = float(xp2-x2);
yn = float(yp2-y2);
if(x < -5) { if(x < xn-5) return false; }// is point between x coordinates ?
else { if(x > 5) if(x > xn+5) return false; }
if(y < -5) { if(y < yn-5) return false; }// is point between y coordinates ?
else { if(y > 5) if(y > yn+5) return false; }
if(fX < -w) {
if(fX < xn-w) // is point between x coordinates ?
return false;
}
else
if(fX > w)
if(fX > xn+w)
return false;
A = xn*y - x*yn; // calculate the rectangle area spanned
A *= A; // avoid the need for square root
A -= 25*(xn*xn + yn*yn); // substract selectable area
if(fY < -w) {
if(fY < yn-w) // is point between y coordinates ?
return false;
}
else
if(fY > w)
if(fY > yn+w)
return false;
if(A <= 0) return true; // lies x/y onto the graph line ?
A = xn*fY - fX*yn; // calculate the rectangle area spanned
A *= A; // avoid the need for square root
if(A <= w*w*(xn*xn + yn*yn))
return true; // x/y lies on the arrow head
return false;
}

4
qucs/paintings/arrow.h
View File

@ -39,9 +39,9 @@ public:
QString save();
void MouseMoving(QPainter*, int, int, int, int, QPainter*, int, int, bool);
bool MousePressing();
bool getSelected(int, int);
bool getSelected(float, float, float);
void Bounding(int&, int&, int&, int&);
bool ResizeTouched(int, int, int);
bool resizeTouched(float, float, float);
void MouseResizeMoving(int, int, QPainter*);
void rotate();

66
qucs/paintings/ellipse.cpp
View File

@ -180,19 +180,22 @@ QString Ellipse::save()
// --------------------------------------------------------------------------
// Checks if the resize area was clicked.
bool Ellipse::ResizeTouched(int x, int y, int len)
bool Ellipse::resizeTouched(float fX, float fY, float len)
{
float fCX = float(cx), fCY = float(cy);
float fX2 = float(cx+x2), fY2 = float(cy+y2);
State = -1;
if(x < cx-len) return false;
if(y < cy-len) return false;
if(x > cx+x2+len) return false;
if(y > cy+y2+len) return false;
if(fX < fCX-len) return false;
if(fY < fCY-len) return false;
if(fX > fX2+len) return false;
if(fY > fY2+len) return false;
State = 0;
if(x < cx+len) State = 1;
else if(x <= cx+x2-len) { State = -1; return false; }
if(y < cy+len) State |= 2;
else if(y <= cy+y2-len) { State = -1; return false; }
if(fX < fCX+len) State = 1;
else if(fX <= fX2-len) { State = -1; return false; }
if(fY < fCY+len) State |= 2;
else if(fY <= fY2-len) { State = -1; return false; }
return true;
}
@ -277,42 +280,33 @@ bool Ellipse::MousePressing()
// --------------------------------------------------------------------------
// Checks if the coordinates x/y point to the painting.
bool Ellipse::getSelected(int x, int y)
bool Ellipse::getSelected(float fX, float fY, float w)
{
float fX2 = float(x2);
float fY2 = float(y2);
fX -= float(cx) + fX2/2.0;
fY -= float(cy) + fY2/2.0;
if(filled) {
x = (x-cx-(x2>>1)); x *= x;
y = (y-cy-(y2>>1)); y *= y;
float a = 2.0 * fX / fX2; a *= a;
float b = 2.0 * fY / fY2; b *= b;
int a = x2 >> 1; a *= a;
int b = y2 >> 1; b *= b;
if(a+b > 1.0)
return false;
}
else {
float a1 = fX / (fX2/2.0 - w); a1 *= a1;
float a2 = fX / (fX2/2.0 + w); a2 *= a2;
float b1 = fY / (fY2/2.0 - w); b1 *= b1;
float b2 = fY / (fY2/2.0 + w); b2 *= b2;
if((double(x)/double(a) + double(y)/double(b)) > 1.0) return false;
return true;
if(a1+b1 < 1.0) return false;
if(a2+b2 > 1.0) return false;
}
x = (x-cx-(x2>>1)); x *= x;
y = (y-cy-(y2>>1)); y *= y;
int a1 = (x2-5)>>1; a1 *= a1;
int a2 = (x2+5)>>1; a2 *= a2;
int b1 = (y2-5)>>1; b1 *= b1;
int b2 = (y2+5)>>1; b2 *= b2;
double x_double = double(x);
double y_double = double(y);
if((x_double/double(a1) + y_double/double(b1)) < 1.0) return false;
if((x_double/double(a2) + y_double/double(b2)) > 1.0) return false;
return true;
}
// --------------------------------------------------------------------------
void Ellipse::Bounding(int& _x1, int& _y1, int& _x2, int& _y2)
{
_x1 = cx; _y1 = cy;
_x2 = cx+x2; _y2 = cy+y2;
}
// --------------------------------------------------------------------------
// Rotates around the center.
void Ellipse::rotate()

5
qucs/paintings/ellipse.h
View File

@ -40,9 +40,8 @@ public:
void paint(ViewPainter*);
void MouseMoving(QPainter*, int, int, int, int, QPainter*, int, int, bool);
bool MousePressing();
bool getSelected(int, int);
void Bounding(int&, int&, int&, int&);
bool ResizeTouched(int, int, int);
bool getSelected(float, float, float);
bool resizeTouched(float, float, float);
void MouseResizeMoving(int, int, QPainter*);
void rotate();

61
qucs/paintings/ellipsearc.cpp
View File

@ -156,19 +156,22 @@ QString EllipseArc::save()
// --------------------------------------------------------------------------
// Checks if the resize area was clicked.
bool EllipseArc::ResizeTouched(int x, int y, int len)
bool EllipseArc::resizeTouched(float fX, float fY, float len)
{
float fCX = float(cx), fCY = float(cy);
float fX2 = float(cx+x2), fY2 = float(cy+y2);
State = -1;
if(x < cx-len) return false;
if(y < cy-len) return false;
if(x > cx+x2+len) return false;
if(y > cy+y2+len) return false;
if(fX < fCX-len) return false;
if(fY < fCY-len) return false;
if(fX > fX2+len) return false;
if(fY > fY2+len) return false;
State = 0;
if(x < cx+len) State = 1;
else if(x <= cx+x2-len) { State = -1; return false; }
if(y < cy+len) State |= 2;
else if(y <= cy+y2-len) { State = -1; return false; }
if(fX < fCX+len) State = 1;
else if(fX <= fX2-len) { State = -1; return false; }
if(fY < fCY+len) State |= 2;
else if(fY <= fY2-len) { State = -1; return false; }
return true;
}
@ -288,39 +291,33 @@ bool EllipseArc::MousePressing()
// --------------------------------------------------------------------------
// Checks if the coordinates x/y point to the painting.
bool EllipseArc::getSelected(int x, int y)
bool EllipseArc::getSelected(float fX, float fY, float w)
{
int Phase = int(16.0*180.0/M_PI
* atan2(double(x2*(cy+(y2>>1) - y)),
double(y2*(x - cx-(x2>>1)))));
int Phase =
int(16.0*180.0/M_PI *
atan2(double(x2*cy + ((x2*y2)>>1)) - double(x2)*double(fY),
double(y2)*double(fX) - double(y2*cx-((y2*x2)>>1))));
Phase -= Angle;
while(Phase < 0) Phase += 16*360;
if(Phase > ArcLen) return false;
if(Phase > ArcLen)
return false;
x = (x-cx-(x2>>1)); x *= x;
y = (y-cy-(y2>>1)); y *= y;
float fX2 = float(x2);
float fY2 = float(y2);
fX -= float(cx) + fX2/2.0;
fY -= float(cy) + fY2/2.0;
int a1 = (x2-5)>>1; a1 *= a1;
int a2 = (x2+5)>>1; a2 *= a2;
int b1 = (y2-5)>>1; b1 *= b1;
int b2 = (y2+5)>>1; b2 *= b2;
float a1 = fX / (fX2/2.0 - w); a1 *= a1;
float a2 = fX / (fX2/2.0 + w); a2 *= a2;
float b1 = fY / (fY2/2.0 - w); b1 *= b1;
float b2 = fY / (fY2/2.0 + w); b2 *= b2;
double x_double = double(x);
double y_double = double(y);
if((x_double/double(a1) + y_double/double(b1)) < 1.0) return false;
if((x_double/double(a2) + y_double/double(b2)) > 1.0) return false;
if(a1+b1 < 1.0) return false;
if(a2+b2 > 1.0) return false;
return true;
}
// --------------------------------------------------------------------------
void EllipseArc::Bounding(int& _x1, int& _y1, int& _x2, int& _y2)
{
_x1 = cx; _y1 = cy;
_x2 = cx+x2; _y2 = cy+y2;
}
// --------------------------------------------------------------------------
// Rotates around the center.
void EllipseArc::rotate()

5
qucs/paintings/ellipsearc.h
View File

@ -39,9 +39,8 @@ public:
void paint(ViewPainter*);
void MouseMoving(QPainter*, int, int, int, int, QPainter*, int, int, bool);
bool MousePressing();
bool getSelected(int, int);
void Bounding(int&, int&, int&, int&);
bool ResizeTouched(int, int, int);
bool getSelected(float, float, float);
bool resizeTouched(float, float, float);
void MouseResizeMoving(int, int, QPainter*);
void rotate();

47
qucs/paintings/graphicline.cpp
View File

@ -147,14 +147,18 @@ QString GraphicLine::save()
// --------------------------------------------------------------------------
// Checks if the resize area was clicked.
bool GraphicLine::ResizeTouched(int x, int y, int len)
bool GraphicLine::resizeTouched(float fX, float fY, float len)
{
if(x <= cx+len) if(x >= cx-len) if(y <= cy+len) if(y >= cy-len) {
float fCX = float(cx), fCY = float(cy);
if(fX <= fCX+len) if(fX >= fCX-len) if(fY <= fCY+len) if(fY >= fCY-len) {
State = 1;
return true;
}
if(x <= cx+x2+len) if(x >= cx+x2-len) if(y <= cy+y2+len) if(y >= cy+y2-len) {
fCX += float(x2);
fCY += float(y2);
if(fX <= fCX+len) if(fX >= fCX-len) if(fY <= fCY+len) if(fY >= fCY-len) {
State = 2;
return true;
}
@ -220,21 +224,36 @@ bool GraphicLine::MousePressing()
// --------------------------------------------------------------------------
// Checks if the coordinates x/y point to the painting.
// 5 is the precision the user must point onto the painting.
bool GraphicLine::getSelected(int x, int y)
bool GraphicLine::getSelected(float fX, float fY, float w)
{
x -= cx;
if(x < -5) { if(x < x2-5) return false; } // is between x coordinates ?
else { if(x > 5) if(x > x2+5) return false; }
fX -= float(cx);
fY -= float(cy);
y -= cy;
if(y < -5) { if(y < y2-5) return false; } // is between y coordinates ?
else { if(y > 5) if(y > y2+5) return false; }
if(fX < -w) {
if(fX < float(x2)-w) // is point between x coordinates ?
return false;
}
else {
if(fX > w)
if(fX > float(x2)+w)
return false;
}
int A = x2*y - x*y2; // calculate the rectangle area spanned
A *= A; // avoid the need for square root
A -= 25*(x2*x2 + y2*y2); // substract selectable area
if(fY < -w) {
if(fY < float(y2)-w) // is point between y coordinates ?
return false;
}
else {
if(fY > w)
if(fY > float(y2)+w)
return false;
}
if(A <= 0) return true; // lies x/y onto the graph line ?
float A = float(x2)*fY - fX*float(y2); // calculate the rectangle area spanned
A *= A; // avoid the need for square root
if(A <= w*w*float(x2*x2 + y2*y2))
return true; // x/y lies on the graph line
return false;
}

4
qucs/paintings/graphicline.h
View File

@ -38,9 +38,9 @@ public:
void paint(ViewPainter*);
void MouseMoving(QPainter*, int, int, int, int, QPainter*, int, int, bool);
bool MousePressing();
bool getSelected(int, int);
bool getSelected(float, float, float);
void Bounding(int&, int&, int&, int&);
bool ResizeTouched(int, int, int);
bool resizeTouched(float, float, float);
void MouseResizeMoving(int, int, QPainter*);
void rotate();

17
qucs/paintings/graphictext.cpp
View File

@ -210,14 +210,19 @@ bool GraphicText::MousePressing()
// ------------------------------------------------------------------------
// Checks if the coordinates x/y point to the painting.
// 5 is the precision the user must point onto the painting.
bool GraphicText::getSelected(int x, int y)
bool GraphicText::getSelected(float fX, float fY, float)
{
double phi = M_PI/180.0*double(Angle);
double sine = sin(phi), cosine = cos(phi);
int _x = int( double(x-cx)*cosine - double(y-cy)*sine );
int _y = int( double(y-cy)*cosine + double(x-cx)*sine );
double phi = M_PI/180.0*double(Angle);
float sine = sin(phi), cosine = cos(phi);
fX -= float(cx);
fY -= float(cy);
int _x = int( fX*cosine - fY*sine );
int _y = int( fY*cosine + fX*sine );
if(_x >= 0) if(_y >= 0) if(_x <= x2) if(_y <= y2)
return true;
if(_x >= 0) if(_y >= 0) if(_x <= x2) if(_y <= y2) return true;
return false;
}

4
qucs/paintings/graphictext.h
View File

@ -24,7 +24,7 @@
class GraphicText : public Painting {
public:
GraphicText();
~GraphicText();
~GraphicText();
void paintScheme(QPainter*);
void getCenter(int&, int&);
@ -37,7 +37,7 @@ public:
void paint(ViewPainter*);
void MouseMoving(QPainter*, int, int, int, int, QPainter*, int, int, bool);
bool MousePressing();
bool getSelected(int, int);
bool getSelected(float, float, float);
void Bounding(int&, int&, int&, int&);
void rotate();

20
qucs/paintings/id_text.cpp
View File

@ -63,6 +63,9 @@ void ID_Text::paint(ViewPainter *p)
p->Painter->setPen(QPen(QPen::darkGray,3));
p->Painter->drawRoundRect(x-4, y-4, x2+8, y2+8);
}
x2 = int(float(x2) / p->Scale);
y2 = int(float(y2) / p->Scale);
}
// --------------------------------------------------------------------------
@ -136,23 +139,16 @@ QString ID_Text::save()
// --------------------------------------------------------------------------
// Checks if the coordinates x/y point to the painting.
bool ID_Text::getSelected(int x, int y)
bool ID_Text::getSelected(float fX, float fY, float)
{
if(x < cx) return false;
if(y < cy) return false;
if(x > cx+x2) return false;
if(y > cy+y2) return false;
if(int(fX) < cx) return false;
if(int(fY) < cy) return false;
if(int(fX) > cx+x2) return false;
if(int(fY) > cy+y2) return false;
return true;
}
// --------------------------------------------------------------------------
void ID_Text::Bounding(int& _x1, int& _y1, int& _x2, int& _y2)
{
_x1 = cx; _y1 = cy;
_x2 = cx+x2; _y2 = cy+y2;
}
// --------------------------------------------------------------------------
// Rotates around the center.
void ID_Text::rotate()

3
qucs/paintings/id_text.h
View File

@ -44,8 +44,7 @@ public:
bool load(const QString&);
QString save();
void paint(ViewPainter*);
bool getSelected(int, int);
void Bounding(int&, int&, int&, int&);
bool getSelected(float, float, float);
void rotate();
void mirrorX();

10
qucs/paintings/painting.cpp
View File

@ -23,15 +23,17 @@ Painting::Painting()
State = 0;
}
Painting::~Painting()
{
}
Painting* Painting::newOne()
{
return new Painting();
}
void Painting::Bounding(int& _x1, int& _y1, int& _x2, int& _y2)
{
_x1 = cx; _y1 = cy;
_x2 = cx+x2; _y2 = cy+y2;
}
QString Painting::save()
{
return QString();

8
qucs/paintings/painting.h
View File

@ -27,10 +27,10 @@ class QPainter;
class Painting : public Element {
public:
Painting();
~Painting();
~Painting() {};
virtual void getCenter(int&, int &) {};
virtual bool getSelected(int, int) { return false; };
virtual bool getSelected(float, float, float) { return false; };
virtual Painting* newOne();
virtual bool load(const QString&) { return true; };
@ -39,8 +39,8 @@ public:
virtual void MouseMoving(QPainter*, int, int, int, int,
QPainter*, int, int, bool) {};
virtual bool MousePressing() { return false; };
virtual void Bounding(int&, int&, int&, int&) {};
virtual bool ResizeTouched(int, int, int) { return false; };
virtual void Bounding(int&, int&, int&, int&);
virtual bool resizeTouched(float, float, float) { return false; };
virtual void MouseResizeMoving(int, int, QPainter*) {};
virtual void rotate() {};

10
qucs/paintings/portsymbol.cpp
View File

@ -165,12 +165,12 @@ QString PortSymbol::save()
// --------------------------------------------------------------------------
// Checks if the coordinates x/y point to the painting.
bool PortSymbol::getSelected(int x, int y)
bool PortSymbol::getSelected(float fX, float fY, float)
{
if(x < cx+x1) return false;
if(y < cy+y1) return false;
if(x > cx+x1+x2) return false;
if(y > cy+y1+y2) return false;
if(int(fX) < cx+x1) return false;
if(int(fY) < cy+y1) return false;
if(int(fX) > cx+x1+x2) return false;
if(int(fY) > cy+y1+y2) return false;
return true;
}

2
qucs/paintings/portsymbol.h
View File

@ -34,7 +34,7 @@ public:
bool load(const QString&);
QString save();
void paint(ViewPainter*);
bool getSelected(int, int);
bool getSelected(float, float, float);
void Bounding(int&, int&, int&, int&);
void rotate();

63
qucs/paintings/rectangle.cpp
View File

@ -179,19 +179,22 @@ QString Rectangle::save()
// --------------------------------------------------------------------------
// Checks if the resize area was clicked.
bool Rectangle::ResizeTouched(int x, int y, int len)
bool Rectangle::resizeTouched(float fX, float fY, float len)
{
float fCX = float(cx), fCY = float(cy);
float fX2 = float(cx+x2), fY2 = float(cy+y2);
State = -1;
if(x < cx-len) return false;
if(y < cy-len) return false;
if(x > cx+x2+len) return false;
if(y > cy+y2+len) return false;
if(fX < fCX-len) return false;
if(fY < fCY-len) return false;
if(fX > fX2+len) return false;
if(fY > fY2+len) return false;
State = 0;
if(x < cx+len) State = 1;
else if(x < cx+x2-len) { State = -1; return false; }
if(y < cy+len) State |= 2;
else if(y < cy+y2-len) { State = -1; return false; }
if(fX < fCX+len) State = 1;
else if(fX < fX2-len) { State = -1; return false; }
if(fY < fCY+len) State |= 2;
else if(fY < fY2-len) { State = -1; return false; }
return true;
}
@ -276,37 +279,33 @@ bool Rectangle::MousePressing()
// --------------------------------------------------------------------------
// Checks if the coordinates x/y point to the painting.
bool Rectangle::getSelected(int x, int y)
bool Rectangle::getSelected(float fX, float fY, float w)
{
if(filled) {
if(x > (cx+x2)) return false; // coordinates outside the rectangle ?
if(y > (cy+y2)) return false;
if(x < cx) return false;
if(y < cy) return false;
if(int(fX) > cx+x2) return false; // coordinates outside the rectangle ?
if(int(fY) > cy+y2) return false;
if(int(fX) < cx) return false;
if(int(fY) < cy) return false;
}
else {
fX -= float(cx);
fY -= float(cy);
float fX2 = float(x2);
float fY2 = float(y2);
return true;
if(fX > fX2+w) return false; // coordinates outside the rectangle ?
if(fY > fY2+w) return false;
if(fX < -w) return false;
if(fY < -w) return false;
// coordinates inside the rectangle ?
if(fX < fX2-w) if(fX > w) if(fY < fY2-w) if(fY > w)
return false;
}
// 5 is the precision the user must point onto the rectangle
if(x > (cx+x2+5)) return false; // coordinates outside the rectangle ?
if(y > (cy+y2+5)) return false;
if(x < (cx-5)) return false;
if(y < (cy-5)) return false;
// coordinates inside the rectangle ?
if(x < (cx+x2-5)) if(x > (cx+5)) if(y < (cy+y2-5)) if(y > (cy+5))
return false;
return true;
}
// --------------------------------------------------------------------------
void Rectangle::Bounding(int& _x1, int& _y1, int& _x2, int& _y2)
{
_x1 = cx; _y1 = cy;
_x2 = cx+x2; _y2 = cy+y2;
}
// --------------------------------------------------------------------------
// Rotates around the center.
void Rectangle::rotate()

5
qucs/paintings/rectangle.h
View File

@ -40,9 +40,8 @@ public:
void paint(ViewPainter*);
void MouseMoving(QPainter*, int, int, int, int, QPainter*, int, int, bool);
bool MousePressing();
bool getSelected(int, int);
void Bounding(int&, int&, int&, int&);
bool ResizeTouched(int, int, int);
bool getSelected(float, float, float);
bool resizeTouched(float, float, float);
void MouseResizeMoving(int, int, QPainter*);
void rotate();

4
qucs/qucs.h
View File

@ -46,7 +46,7 @@ class VTabWidget;
typedef bool (Schematic::*pToggleFunc) ();
typedef void (MouseActions::*pMouseFunc) (Schematic*, QMouseEvent*);
typedef void (MouseActions::*pMouseFunc2) (Schematic*, QMouseEvent*, int, int);
typedef void (MouseActions::*pMouseFunc2) (Schematic*, QMouseEvent*, float, float);
extern QDir QucsWorkDir;
extern QDir QucsHomeDir;
@ -70,7 +70,7 @@ public:
// current mouse methods
void (MouseActions::*MouseMoveAction) (Schematic*, QMouseEvent*);
void (MouseActions::*MousePressAction) (Schematic*, QMouseEvent*, int, int);
void (MouseActions::*MousePressAction) (Schematic*, QMouseEvent*, float, float);
void (MouseActions::*MouseDoubleClickAction) (Schematic*, QMouseEvent*);
void (MouseActions::*MouseReleaseAction) (Schematic*, QMouseEvent*);

26
qucs/schematic.cpp
View File

@ -432,21 +432,19 @@ void Schematic::contentsMousePressEvent(QMouseEvent *Event)
if(App->MouseReleaseAction == &MouseActions::MReleasePaste)
return;
int x = int(float(Event->pos().x())/Scale) + ViewX1;
int y = int(float(Event->pos().y())/Scale) + ViewY1;
float x = float(Event->pos().x())/Scale + float(ViewX1);
float y = float(Event->pos().y())/Scale + float(ViewY1);
if(Event->button() != Qt::LeftButton) {
if(App->MousePressAction == &MouseActions::MPressElement)
App->view->MPressElement(this, Event, x, y);
else if(App->MousePressAction == &MouseActions::MPressWire2)
App->view->MPressWire2(this, Event, x, y);
else {
App->view->rightPressMenu(this, Event, x, y); // show menu on right mouse button
if(App->MouseReleaseAction)
(App->view->*(App->MouseReleaseAction))(this, Event); // not called (menu has focus)
}
return;
}
if(Event->button() != Qt::LeftButton)
if(App->MousePressAction != &MouseActions::MPressElement)
if(App->MousePressAction != &MouseActions::MPressWire2) {
// show menu on right mouse button
App->view->rightPressMenu(this, Event, x, y);
if(App->MouseReleaseAction)
// Is not called automatically because menu has focus.
(App->view->*(App->MouseReleaseAction))(this, Event);
return;
}
if(App->MousePressAction)
(App->view->*(App->MousePressAction))(this, Event, x, y);

4
qucs/schematic.h
View File

@ -157,7 +157,7 @@ public:
void markerLeftRight(bool, QPtrList<Element>*);
void markerUpDown(bool, QPtrList<Element>*);
Element* selectElement(int, int, bool, int *index=0);
Element* selectElement(float, float, bool, int *index=0);
void deselectElements(Element*);
int selectElements(int, int, int, int, bool);
void selectMarkers();
@ -187,7 +187,7 @@ public:
void insertNodeLabel(WireLabel*);
void copyLabels(int&, int&, int&, int&, QPtrList<Element>*);
Painting* selectedPainting(int, int);
Painting* selectedPainting(float, float);
void copyPaintings(int&, int&, int&, int&, QPtrList<Element>*);
private:

67
qucs/schematic_element.cpp
View File

@ -869,9 +869,9 @@ void Schematic::markerUpDown(bool up, QPtrList<Element> *Elements)
// Selects the element that contains the coordinates x/y.
// Returns the pointer to the element.
// If 'flag' is true, the element can be deselected.
Element* Schematic::selectElement(int x, int y, bool flag, int *index)
Element* Schematic::selectElement(float fX, float fY, bool flag, int *index)
{
int n;
int n, x = int(fX), y = int(fY);
Element *pe_1st=0, *pe_sel=0;
float Corr = textCorr(); // for selecting text
@ -880,8 +880,8 @@ Element* Schematic::selectElement(int x, int y, bool flag, int *index)
if(pc->getSelected(x, y)) {
if(flag) { pc->isSelected ^= flag; return pc; }
if(pe_sel) {
pe_sel->isSelected = false;
return pc;
pe_sel->isSelected = false;
return pc;
}
if(pe_1st == 0) pe_1st = pc; // give access to elements lying beneath
if(pc->isSelected) pe_sel = pc;
@ -901,8 +901,8 @@ Element* Schematic::selectElement(int x, int y, bool flag, int *index)
if(pw->getSelected(x, y)) {
if(flag) { pw->isSelected ^= flag; return pw; }
if(pe_sel) {
pe_sel->isSelected = false;
return pw;
pe_sel->isSelected = false;
return pw;
}
if(pe_1st == 0) pe_1st = pw; // give access to elements lying beneath
if(pw->isSelected) pe_sel = pw;
@ -911,8 +911,8 @@ Element* Schematic::selectElement(int x, int y, bool flag, int *index)
if(pl) if(pl->getSelected(x, y)) {
if(flag) { pl->isSelected ^= flag; return pl; }
if(pe_sel) {
pe_sel->isSelected = false;
return pl;
pe_sel->isSelected = false;
return pl;
}
if(pe_1st == 0) pe_1st = pl; // give access to elements lying beneath
if(pl->isSelected) pe_sel = pl;
@ -925,8 +925,8 @@ Element* Schematic::selectElement(int x, int y, bool flag, int *index)
if(pl) if(pl->getSelected(x, y)) {
if(flag) { pl->isSelected ^= flag; return pl; }
if(pe_sel) {
pe_sel->isSelected = false;
return pl;
pe_sel->isSelected = false;
return pl;
}
if(pe_1st == 0) pe_1st = pl; // give access to elements lying beneath
if(pl->isSelected) pe_sel = pl;
@ -934,7 +934,7 @@ Element* Schematic::selectElement(int x, int y, bool flag, int *index)
}
Graph *pg;
n = int(5.0 / Scale); // size if area for resizing
Corr = 5.0 / Scale; // size of line select and area for resizing
// test all diagrams
for(Diagram *pd = Diagrams->last(); pd != 0; pd = Diagrams->prev()) {
@ -944,19 +944,19 @@ Element* Schematic::selectElement(int x, int y, bool flag, int *index)
if(pm->getSelected(x-pd->cx, y-pd->cy)) {
if(flag) { pm->isSelected ^= flag; return pm; }
if(pe_sel) {
pe_sel->isSelected = false;
return pm;
}
pe_sel->isSelected = false;
return pm;
}
if(pe_1st == 0) pe_1st = pm; // give access to elements beneath
if(pm->isSelected) pe_sel = pm;
}
// resize area clicked ?
if(pd->isSelected)
if(pd->ResizeTouched(x, y, n))
if(pe_1st == 0) {
pd->Type = isDiagramResize;
return pd;
if(pd->resizeTouched(fX, fY, Corr))
if(pe_1st == 0) {
pd->Type = isDiagramResize;
return pd;
}
if(pd->getSelected(x, y)) {
@ -980,9 +980,9 @@ Element* Schematic::selectElement(int x, int y, bool flag, int *index)
if(pg->getSelected(x-pd->cx, pd->cy-y) >= 0) {
if(flag) { pg->isSelected ^= flag; return pg; }
if(pe_sel) {
pe_sel->isSelected = false;
return pg;
}
pe_sel->isSelected = false;
return pg;
}
if(pe_1st == 0) pe_1st = pg; // access to elements lying beneath
if(pg->isSelected) pe_sel = pg;
}
@ -990,8 +990,8 @@ Element* Schematic::selectElement(int x, int y, bool flag, int *index)
if(flag) { pd->isSelected ^= flag; return pd; }
if(pe_sel) {
pe_sel->isSelected = false;
return pd;
pe_sel->isSelected = false;
return pd;
}
if(pe_1st == 0) pe_1st = pd; // give access to elements lying beneath
if(pd->isSelected) pe_sel = pd;
@ -1001,17 +1001,17 @@ Element* Schematic::selectElement(int x, int y, bool flag, int *index)
// test all paintings
for(Painting *pp = Paintings->last(); pp != 0; pp = Paintings->prev()) {
if(pp->isSelected)
if(pp->ResizeTouched(x, y, n))
if(pe_1st == 0) {
pp->Type = isPaintingResize;
return pp;
if(pp->resizeTouched(fX, fY, Corr))
if(pe_1st == 0) {
pp->Type = isPaintingResize;
return pp;
}
if(pp->getSelected(x, y)) {
if(pp->getSelected(fX, fY, Corr)) {
if(flag) { pp->isSelected ^= flag; return pp; }
if(pe_sel) {
pe_sel->isSelected = false;
return pp;
pe_sel->isSelected = false;
return pp;
}
if(pe_1st == 0) pe_1st = pp; // give access to elements lying beneath
if(pp->isSelected) pe_sel = pp;
@ -2544,11 +2544,12 @@ void Schematic::copyLabels(int& x1, int& y1, int& x2, int& y2,
***** *****
******************************************************************* */
Painting* Schematic::selectedPainting(int x, int y)
Painting* Schematic::selectedPainting(float fX, float fY)
{
// test all paintings
float Corr = 5.0 / Scale; // size of line select
for(Painting *pp = Paintings->first(); pp != 0; pp = Paintings->next())
if(pp->getSelected(x,y))
if(pp->getSelected(fX, fY, Corr))
return pp;
return 0;

133
qucs/viewpainter.cpp
View File

@ -16,6 +16,7 @@
***************************************************************************/
#include "viewpainter.h"
#include "diagrams/graph.h"
#include <math.h>
@ -87,6 +88,138 @@ void ViewPainter::drawLine(int x1, int y1, int x2, int y2)
Painter->drawLine(x1, y1, x2, y2);
}
// -------------------------------------------------------------
void ViewPainter::drawLines(int x0, int y0, float *pp)
{
float z, DX_, DY_;
int x1, x2, y1, y2;
if(*pp < 0)
pp++;
DX_ = DX + float(x0)*Scale;
DY_ = DY + float(y0)*Scale;
while(*pp > GRAPHEND) {
if(*pp >= 0) {
z = DX_ + (*pp)*Scale;
x1 = TO_INT(z);
z = DY_ - (*(pp+1))*Scale;
y1 = TO_INT(z);
Painter->drawPoint(x1, y1);
}
while(*pp > BRANCHEND) { // until end of branch
z = DX_ + (*pp)*Scale;
x1 = TO_INT(z);
z = DY_ - (*(pp+1))*Scale;
y1 = TO_INT(z);
pp += 2;
while(*pp > STROKEEND) { // until end of stroke
z = DX_ + (*pp)*Scale;
x2 = TO_INT(z);
z = DY_ - (*(pp+1))*Scale;
y2 = TO_INT(z);
Painter->drawLine(x1, y1, x2, y2);
pp += 2;
if(*pp <= STROKEEND) break;
z = DX_ + (*pp)*Scale;
x1 = TO_INT(z);
z = DY_ - (*(pp+1))*Scale;
y1 = TO_INT(z);
Painter->drawLine(x2, y2, x1, y1);
pp += 2;
}
if(*pp <= BRANCHEND) break; // end of line ?
pp++;
}
pp++;
}
}
// -------------------------------------------------------------
void ViewPainter::drawStarSymbols(int x0, int y0, float *pp)
{
int x3, x1, x2, y1, y2;
float z, DX_, DY_;
if(*pp < 0)
pp++;
DX_ = DX + float(x0)*Scale;
DY_ = DY + float(y0)*Scale;
while(*pp > GRAPHEND) {
if(*pp >= 0) {
z = DX_ + (*(pp++))*Scale;
x0 = TO_INT(z-5.0*Scale);
x3 = TO_INT(z+5.0*Scale);
x1 = TO_INT(z-4.0*Scale);
x2 = TO_INT(z+4.0*Scale);
z = DY_ - (*(pp++))*Scale;
y0 = TO_INT(z);
y1 = TO_INT(z-4.0*Scale);
y2 = TO_INT(z+4.0*Scale);
Painter->drawLine(x0, y0, x3, y0); // horizontal line
Painter->drawLine(x1, y2, x2, y1); // upper left to lower right
Painter->drawLine(x2, y2, x1, y1); // upper right to lower left
}
else pp++;
}
}
// -------------------------------------------------------------
void ViewPainter::drawCircleSymbols(int x0, int y0, float *pp)
{
int d;
float z, DX_, DY_;
if(*pp < 0)
pp++;
z = 8.0*Scale;
d = TO_INT(z);
DX_ = DX + float(x0)*Scale;
DY_ = DY + float(y0)*Scale;
while(*pp > GRAPHEND) {
if(*pp >= 0) {
z = DX_ + (*(pp++)-4.0)*Scale;
x0 = TO_INT(z);
z = DY_ - (*(pp++)-4.0)*Scale;
y0 = TO_INT(z);
Painter->drawEllipse(x0, y0, d, d);
}
else pp++;
}
}
// -------------------------------------------------------------
void ViewPainter::drawArrowSymbols(int x0, int y0, float *pp)
{
int x1, x2, y1, y2;
float z, DX_, DY_;
if(*pp < 0)
pp++;
DX_ = DX + float(x0)*Scale;
DY_ = DY + float(y0)*Scale;
y2 = TO_INT(DY_);
while(*pp > GRAPHEND) {
if(*pp >= 0) {
z = DX_ + (*(pp++))*Scale;
x0 = TO_INT(z);
x1 = TO_INT(z-4.0*Scale);
x2 = TO_INT(z+4.0*Scale);
z = DY_ - (*(pp++))*Scale;
y0 = TO_INT(z);
y1 = TO_INT(z+7.0*Scale);
Painter->drawLine(x0, y0, x0, y2);
Painter->drawLine(x1, y1, x0, y0);
Painter->drawLine(x2, y1, x0, y0);
}
else pp++;
}
}
// -------------------------------------------------------------
void ViewPainter::drawRect(int x1, int y1, int dx, int dy)
{

4
qucs/viewpainter.h
View File

@ -38,6 +38,7 @@ public:
void map(int, int, int&, int&);
void drawPoint(int, int);
void drawLine (int, int, int, int);
void drawLines(int, int, float*);
void drawRect (int, int, int, int);
void drawRectD(int, int, int, int);
void drawRoundRect(int, int, int, int);
@ -47,6 +48,9 @@ public:
void fillRect(int, int, int, int, const QColor&);
void eraseRect(int, int, int, int);
void drawResizeRect(int, int);
void drawStarSymbols(int, int, float*);
void drawCircleSymbols(int, int, float*);
void drawArrowSymbols(int, int, float*);
QPainter *Painter;
float Scale, FontScale, DX , DY;