void RelationshipView::configureDescriptor(void)
{
QLineF lin;
QPolygonF pol;
BaseRelationship *base_rel=this->getSourceObject();
Relationship *rel=dynamic_cast<Relationship *>(base_rel);
unsigned rel_type=base_rel->getRelationshipType();
float x, y, x1, y1, factor=font_config[ParsersAttributes::GLOBAL].font().pointSizeF()/DEFAULT_FONT_SIZE;
QPen pen;
QPointF pnt;
vector<QPointF> points=base_rel->getPoints();
QColor line_color=base_rel->getCustomColor();
QGraphicsPolygonItem *pol_item=nullptr;
//Configuring the relationship descriptor color
if(base_rel->getCustomColor()!=Qt::transparent)
//Using custom color
pen.setColor(base_rel->getCustomColor());
else
//Using the default color
pen=BaseObjectView::getBorderStyle(ParsersAttributes::RELATIONSHIP);
if(rel_type==BaseRelationship::RELATIONSHIP_DEP)
pen.setStyle(Qt::DashLine);
descriptor->setPen(pen);
if(line_color!=Qt::transparent)
{
QColor colors[2];
QLinearGradient grad;
BaseObjectView::getFillStyle(ParsersAttributes::RELATIONSHIP, colors[0], colors[1]);
for(unsigned i=0; i < 2; i++)
{
colors[i].setRed((colors[i].red() + line_color.red() + 255)/3);
colors[i].setGreen((colors[i].green() + line_color.green() + 255)/3);
colors[i].setBlue((colors[i].blue() + line_color.blue() + 255)/3);
grad.setColorAt(i, colors[i]);
}
grad.setCoordinateMode(QGradient::ObjectBoundingMode);;
descriptor->setBrush(grad);
}
else
descriptor->setBrush(BaseObjectView::getFillStyle(ParsersAttributes::RELATIONSHIP));
if(rel_type==BaseRelationship::RELATIONSHIP_DEP ||
rel_type==BaseRelationship::RELATIONSHIP_GEN)
{
pol.append(QPointF(0,0)); pol.append(QPointF(21,13));
pol.append(QPointF(0,26)); pol.append(QPointF(0,13));
}
else
{
pol.append(QPointF(13,0)); pol.append(QPointF(26,13));
pol.append(QPointF(13,26)); pol.append(QPointF(0,13));
}
//Resizes the polygon according the font factor
if(factor!=1.0f)
this->resizePolygon(pol,
pol.boundingRect().width() * factor ,
pol.boundingRect().height() * factor);
if(base_rel->isSelfRelationship())
pnt=points.at(points.size()/2);
else
{
lin=lines.at(lines.size()/2)->line();
if(rel && rel->isIdentifier())
pnt=lin.p1();
else
{
pnt.setX((lin.p1().x() + lin.p2().x()) / 2.0f);
pnt.setY((lin.p1().y() + lin.p2().y()) / 2.0f);
}
descriptor->setRotation(-lin.angle());
obj_selection->setRotation(-lin.angle());
obj_shadow->setRotation(-lin.angle());
}
x=x1=pnt.x() - (pol.boundingRect().width()/2.0f);
y=y1=pnt.y() - (pol.boundingRect().height()/2.0f);
protected_icon->setPos(x + ((pol.boundingRect().width()/2.0f) * 0.60f),
y + ((pol.boundingRect().height()/2.0f) * 0.55f));
configureSQLDisabledInfo();
x1+=6 * HORIZ_SPACING;
y1-=3 * VERT_SPACING;
sql_disabled_box->setPos(x1, y1);
sql_disabled_txt->setPos(x1 + HORIZ_SPACING, y1 + VERT_SPACING);
descriptor->setPolygon(pol);
descriptor->setTransformOriginPoint(descriptor->boundingRect().center());
descriptor->setPos(x, y);
pol_item=dynamic_cast<QGraphicsPolygonItem *>(obj_selection);
pol_item->setPolygon(pol);
pol_item->setTransformOriginPoint(obj_selection->boundingRect().center());
pol_item->setPos(x,y);
pol_item->setBrush(this->getFillStyle(ParsersAttributes::OBJ_SELECTION));
pol_item->setPen(this->getBorderStyle(ParsersAttributes::OBJ_SELECTION));
pol_item=dynamic_cast<QGraphicsPolygonItem *>(obj_shadow);
pol_item->setPolygon(pol);
pol_item->setTransformOriginPoint(obj_shadow->boundingRect().center());
pol_item->setPos(x + 2.5f, y + 3.5f);
pol_item->setPen(Qt::NoPen);
pol_item->setBrush(QColor(50,50,50,60));
this->configureAttributes();
this->configurePositionInfo();
}
void DataCurve::loadData()
{
Graph *g = (Graph *)plot();
if (!g)
return;
int xcol = d_x_table->colIndex(d_x_column);
int ycol = d_table->colIndex(title().text());
if (xcol < 0 || ycol < 0) {
remove();
return;
}
int rows = d_table->numRows();
if (d_end_row < 0 || d_end_row >= rows)
d_end_row = rows - 1;
int xColType = d_x_table->columnType(xcol);
int yColType = d_table->columnType(ycol);
int r = abs(d_end_row - d_start_row) + 1;
QPolygonF data;
data.reserve(r);
QStringList xLabels, yLabels;// store text labels
int xAxis = QwtPlot::xBottom;
if (d_type == Graph::HorizontalBars)
xAxis = QwtPlot::yLeft;
QString date_time_fmt = d_table->columnFormat(xcol);
int size = 0, from = 0;
d_data_ranges.clear();
for (int i = d_start_row; i <= d_end_row; i++ ) {
QString xval = d_x_table->text(i, xcol);
QString yval = d_table->text(i, ycol);
if (!xval.isEmpty() && !yval.isEmpty()) {
bool valid_data = true;
QPointF p;
if (xColType == Table::Text) {
xLabels << xval;
p.setX((double)(size + 1));
} else if (xColType == Table::Time)
p.setX(Table::fromTime(QTime::fromString(xval.trimmed(), date_time_fmt)));
else if (xColType == Table::Date)
p.setX(Table::fromDateTime(QDateTime::fromString(xval.trimmed(), date_time_fmt)));
else
p.setX(g->locale().toDouble(xval, &valid_data));
if (yColType == Table::Text) {
yLabels << yval;
p.setY((double)(size + 1));
} else
p.setY(g->locale().toDouble(yval, &valid_data));
if (valid_data) {
data << p;
size++;
}
} else if (from < size) {
DataRange range;
range.from = from;
range.to = size - 1;
d_data_ranges.push_back(range);
from = size;
}
}
if (d_data_ranges.size() && from < size) {
DataRange range;
range.from = from;
range.to = size - 1;
d_data_ranges.push_back(range);
}
if (!size) {
remove();
return;
}
data.resize(size);
if (g->isWaterfallPlot()) {
int index = g->curveIndex(this);
int curves = g->curveCount();
DataCurve *c = g->dataCurve(0);
if (index > 0 && c) {
double xmin = c->minXValue();
double dx = index*g->waterfallXOffset()*0.01*g->canvas()->width()/(double)(curves - 1);
d_x_offset = g->invTransform(xAxis, g->transform(xAxis, xmin) + dx) - xmin;
double ymin = c->minYValue();
double dy = index*g->waterfallYOffset()*0.01*g->canvas()->height()/(double)(curves - 1);
d_y_offset = ymin - g->invTransform(yAxis(), g->transform(yAxis(), ymin) + dy);
setZ(-index);
setBaseline(d_y_offset);
data.translate(d_x_offset, d_y_offset);
} else {
setZ(0);
setBaseline(0.0);
}
if (g->grid())
g->grid()->setZ(-g->curveCount() - 1);
}
double speedTol = g->getDouglasPeukerTolerance();
if (speedTol != 0.0 && size >= g->speedModeMaxPoints()) {
QwtWeedingCurveFitter *fitter = new QwtWeedingCurveFitter(speedTol);
data = fitter->fitCurve(data);
delete fitter;
}
if (d_type == Graph::HorizontalBars) {
size = data.size();
for (int i = 0; i < size; i++) {
QPointF p = data.at(i);
data[i] = QPointF(p.y(), p.x());
}
}
setData(data);
foreach(ErrorBarsCurve *c, d_error_bars)
c->setData(data);
if (xColType == Table::Text)
g->setLabelsTextFormat(xAxis, ScaleDraw::Text, d_x_column, xLabels);
if (yColType == Table::Text)
g->setLabelsTextFormat(QwtPlot::yLeft, ScaleDraw::Text, title().text(), yLabels);
setRenderHint(QwtPlotItem::RenderAntialiased, g->isCurveAntialiasingEnabled(this));
if (!d_labels_list.isEmpty()) {
((Graph*)plot())->updatePlot();
loadLabels();
}
}
void TwoPlayerTimingGameWidget2::addEffect(
#ifdef USE_PIXMAP
QPixmap& pixmap,
#else
QPainter* painter,
#endif
int width,
int height)
{
#ifdef USE_PIXMAP
// Get the painter
QPainter *painter = new QPainter(&pixmap);
#endif
// if (startAnimCount <= START_ANIM_LAST_TIME)
// {
// QPointF center = gameboardInfo->centerPos();
// double size = qMax(1,
// qMin(FONT_DIGIT_SIZE *
// startAnimCount /
// START_ANIM_SEP_TIME,
// FONT_DIGIT_SIZE));
// double opacity = startAnimCount < START_ANIM_SEP_TIME ?
// 1.0 * startAnimCount / START_ANIM_SEP_TIME :
// 1 - 1.0 * (startAnimCount - START_ANIM_SEP_TIME) /
// (START_ANIM_LAST_TIME - START_ANIM_SEP_TIME);
// painter->setOpacity(opacity);
// QPainterPath path;
// path.addText(- size * 2 / 3, 0, goFont(size), "GO");
// painter->scale(1.0 * gameboardInfo->width() / width,
// 1.0 * gameboardInfo->height() / height);
// QPen pen = QPen(QColor( 50, 255, 255, 100));
// pen.setWidth(PEN_WIDTH * startAnimCount / START_ANIM_SEP_TIME);
// painter->setPen(pen);
// QPointF pos1 = game1ToGlobal(center);
// painter->translate(pos1.x(), pos1.y());
// painter->rotate(90);
// painter->drawPath(path);
// painter->fillPath(path, QBrush(QColor(0, 0, 0)));
// painter->rotate(-90);
// painter->translate(-pos1.x(), -pos1.y());
// pos1 = game2ToGlobal(center);
// painter->translate(pos1.x(), pos1.y());
// painter->rotate(-90);
// painter->drawPath(path);
// painter->fillPath(path, QBrush(QColor(0, 0, 0)));
// painter->rotate(90);
// painter->translate(-pos1.x(), -pos1.y());
// painter->setOpacity(1);
// painter->scale(1.0 * width / gameboardInfo->width(),
// 1.0 * height / gameboardInfo->height());
// }
if (timeUp)
{
QPointF pos;
for (QList<int>::Iterator itr1 = endAnimCount1.begin(),
itr2 = endAnimBonusKind1.begin();
itr1 != endAnimCount1.end();
++itr1, ++itr2)
{
painter->setOpacity(1.0 * (END_BONUS_ANIM_LAST_TIME - *itr1) / END_BONUS_ANIM_LAST_TIME);
AbstractBonusItem *bonusItem = ((*itr2) == 0) ? flame1 : star1;
pos.setX((currentScore1->getPos().x() * (*itr1) +
bonusItem->getPos().x() * (END_BONUS_ANIM_LAST_TIME - *itr1)) /
END_BONUS_ANIM_LAST_TIME *
width);
pos.setY((currentScore1->getPos().y() * (*itr1) +
bonusItem->getPos().y() * (END_BONUS_ANIM_LAST_TIME - *itr1)) /
END_BONUS_ANIM_LAST_TIME *
height);
bonusItem->paintLocatingIcon(painter, width, height, pos, frameCount);
painter->setOpacity(1);
}
for (QList<int>::Iterator itr1 = endAnimCount2.begin(),
itr2 = endAnimBonusKind2.begin();
itr1 != endAnimCount2.end();
++itr1, ++itr2)
{
painter->setOpacity(1.0 * (END_BONUS_ANIM_LAST_TIME - *itr1) / END_BONUS_ANIM_LAST_TIME);
AbstractBonusItem *bonusItem = ((*itr2) == 0) ? flame2 : star2;
pos.setX((currentScore2->getPos().x() * (*itr1) +
bonusItem->getPos().x() * (END_BONUS_ANIM_LAST_TIME - *itr1)) /
END_BONUS_ANIM_LAST_TIME *
width);
pos.setY((currentScore2->getPos().y() * (*itr1) +
bonusItem->getPos().y() * (END_BONUS_ANIM_LAST_TIME - *itr1)) /
END_BONUS_ANIM_LAST_TIME *
height);
bonusItem->paintLocatingIcon(painter, width, height, pos, frameCount);
painter->setOpacity(1);
}
}
double xRate = 1.0 * width / LOGICAL_WIDTH;
double yRate = 1.0 * height / LOGICAL_HEIGHT;
if (endAnimCount >= 0)
{
BasicPainter::darken(painter, width, height);
painter->scale(xRate, yRate);
painter->setOpacity(qMin(1.0, 1.0 * endAnimCount / END_ANIM_LAST_TIME));
QPointF gFrom = QPointF(frameCount * 8, 0);
QPointF gTo = QPointF(frameCount * 8 - 100, -100);
QLinearGradient gradient = QLinearGradient(gFrom, gTo);
gradient.setColorAt(0, LINENEAR_COLOR_0);
gradient.setColorAt(1, LINENEAR_COLOR_1);
gradient.setSpread(QGradient::ReflectSpread);
QBrush brush = QBrush(gradient);
painter->setPen(QPen(brush, 4));
painter->translate((GAME1_X_FROM + GAME1_X_TO) / 2,
LOGICAL_HEIGHT / 2);
painter->rotate(90);
if (currentScore1->getValue() > currentScore2->getValue())
{
painter->drawPath(youWin);
painter->fillPath(youWin, brush);
}
else if (currentScore1->getValue() < currentScore2->getValue())
{
painter->drawPath(youLose);
painter->fillPath(youLose, brush);
}
else
{
painter->drawPath(drawGame);
painter->fillPath(drawGame, brush);
}
painter->rotate(-90);
painter->translate(-(GAME1_X_FROM + GAME1_X_TO) / 2,
-LOGICAL_HEIGHT / 2);
painter->translate((GAME2_X_FROM + GAME2_X_TO) / 2,
LOGICAL_HEIGHT / 2);
painter->rotate(-90);
if (currentScore1->getValue() < currentScore2->getValue())
{
painter->drawPath(youWin);
painter->fillPath(youWin, brush);
}
else if (currentScore1->getValue() > currentScore2->getValue())
{
painter->drawPath(youLose);
painter->fillPath(youLose, brush);
}
else
{
painter->drawPath(drawGame);
painter->fillPath(drawGame, brush);
}
painter->rotate(90);
painter->translate(-(GAME2_X_FROM + GAME2_X_TO) / 2,
-LOGICAL_HEIGHT / 2);
painter->scale(1 / xRate, 1 / yRate);
}
if (endAnimCount != -1)
{
++endAnimCount;
}
++startAnimCount;
#ifdef USE_PIXMAP
// End the paint and release the space
painter->end();
delete painter;
#endif
}
//Latest and most updated version
int calcBoundFromShapes(QString shapeConstraint,QSqlDatabase db, double &dbCellSize, double &xllCenter, double &yllCenter, int &ncols, int &nrows, int &bottom, int &left)
{
//ShapeDataSet:shapeID,ShapeID,
if (shapeConstraint.count(":") != 1)
{
gbtLog(QObject::tr("Error in shape constraint"));
return 1;
}
int pos;
pos = shapeConstraint.indexOf(":");
QString dataset = shapeConstraint.left(pos);
QSqlQuery qry(db);
QString sql;
dbCellSize = 0.0;
sql = "SELECT cellSize FROM gbtconfig";
if (qry.exec(sql))
{
if (qry.first())
dbCellSize = qry.value(0).toDouble();
else
return 1;
}
else
return 1;
sql = "SELECT count(*) FROM datasetinfo WHERE dataset_id = '" + dataset + "' and dataset_type = 2";
if (qry.exec(sql))
{
if (qry.first())
{
if (qry.value(0).toInt() == 0)
{
gbtLog(QObject::tr(" is not a shape dataset"));
return 1;
}
}
else
return 1;
}
else
return 1;
sql = "SELECT shapeid,AsText(max(envelope(ogc_geom))) as boundbox FROM " + dataset + " WHERE ";
QString shapes = shapeConstraint.mid(pos+1,shapeConstraint.length()-pos+1);
QString shape;
pos =0;
while (pos <= shapes.length()-1)
{
if (shapes[pos] != ',')
{
shape = shape + shapes[pos];
pos++;
}
else
{
sql = sql + " shapeid = " + shape + " OR ";
shape = "";
shapes = shapes.mid(pos+1,shapes.length()-pos+1);
pos = 0;
}
}
sql = sql + "shapeid = " + shape;
sql = sql + " GROUP BY shapeid";
double maxX;
double maxY;
double minX;
double minY;
maxX = -3000;
maxY = -3000;
minX = 3000;
minY = 3000;
QString cadena;
QString geopos;
double temp;
if (qry.exec(sql))
{
while (qry.next())
{
cadena = qry.value(1).toString();
pos = cadena.indexOf("(");
cadena = cadena.mid(pos+1,cadena.length()-pos+1); //Remove the type of shape
cadena = cadena.replace("(","");
cadena = cadena.replace(")","");
pos = 0;
while (pos <= cadena.length()-1)
{
if (cadena[pos] != ',')
{
geopos = geopos + cadena[pos];
pos++;
}
else
{
cadena = cadena.mid(pos+1,cadena.length()-pos+1);
pos = geopos.indexOf(" ");
temp = geopos.left(pos).toDouble();
if (temp > maxX)
maxX = temp;
if (temp < minX)
minX = temp;
temp = geopos.mid(pos+1,geopos.length()-pos+1).toDouble();
if (temp > maxY)
maxY = temp;
if (temp < minY)
minY = temp;
pos = 0;
geopos = "";
}
}
//Final string
pos = geopos.indexOf(" ");
temp = geopos.left(pos).toDouble();
if (temp > maxX)
maxX = temp;
if (temp < minX)
minX = temp;
temp = geopos.mid(pos+1,geopos.length()-pos+1).toDouble();
if (temp > maxY)
maxY = temp;
if (temp < minY)
minY = temp;
}
QPointF UL;
QPointF LR;
UL.setX(minX);
UL.setY(maxY);
LR.setX(maxX);
LR.setY(minY);
double v_xMin,v_xMax,v_yMin,v_yMax;
double halfx;
int v_cols,v_rows;
v_xMin = trunc(UL.x() / dbCellSize) * dbCellSize;
v_yMin = trunc(LR.y() / dbCellSize) * dbCellSize;
v_cols = trunc((LR.x() - UL.x()) / dbCellSize) + 1;
v_rows = trunc((UL.y() - LR.y()) / dbCellSize) + 1;
v_xMax = v_xMin + v_cols * dbCellSize;
v_yMax = v_yMin + v_rows * dbCellSize;
halfx = dbCellSize / 2;
xllCenter = v_xMin + halfx;
yllCenter = (v_yMin + halfx) - 0.0200;
ncols = trunc(fabs(v_xMax - v_xMin) / dbCellSize);
nrows = trunc(fabs(v_yMax - v_yMin) / dbCellSize);
left = ceil((UL.x() + 180) / dbCellSize);
bottom = ceil((90 - UL.y()) / dbCellSize);
return 0;
}
else
return 1;
}
void KoTextShapeContainerModel::proposeMove(KoShape *child, QPointF &move)
{
Relation *relation = d->children.value(child);
if (relation == 0 || relation->anchor == 0)
return;
QPointF newPosition = child->position() + move;
QRectF parentShapeRect(QPointF(0, 0), child->parent()->size());
//kDebug(32500) <<"proposeMove:" << move <<" |" << newPosition <<" |" << parentShapeRect;
if (qAbs(newPosition.x()) < 10) // align left
relation->anchor->setAlignment(KoTextAnchor::Left);
else if (qAbs(parentShapeRect.width() - newPosition.x()) < 10.0)
relation->anchor->setAlignment(KoTextAnchor::Right);
else if (qAbs(parentShapeRect.width() / 2.0 - newPosition.x()) < 10.0)
relation->anchor->setAlignment(KoTextAnchor::Center);
/*else {
relation->anchor->setAlignment(KoTextAnchor::HorizontalOffset);
// TODO
//QPointF offset = relation->anchor->offset();
//offset.setX(offset.x() + move.x());
//relation->anchor->setOffset(offset);
} */
if (qAbs(newPosition.y()) < 10.0) // TopOfFrame
{
kDebug(32500) <<" TopOfFrame";
relation->anchor->setAlignment(KoTextAnchor::TopOfFrame);
} else if (qAbs(parentShapeRect.height() - newPosition.y()) < 10.0) {
kDebug(32500) <<" BottomOfFrame";
relation->anchor->setAlignment(KoTextAnchor::BottomOfFrame); // TODO
} else { // need layout info..
QTextBlock block = relation->anchor->document()->findBlock(relation->anchor->positionInDocument());
QTextLayout *layout = block.layout();
if (layout->lineCount() > 0) {
KoTextShapeData *data = dynamic_cast<KoTextShapeData*>(child->parent()->userData());
Q_ASSERT(data);
QTextLine tl = layout->lineAt(0);
qreal y = tl.y() - data->documentOffset() - newPosition.y();
if (y >= 0 && y < 10) {
kDebug(32500) <<" TopOfParagraph" << y <<"";
relation->anchor->setAlignment(KoTextAnchor::TopOfParagraph);
} else {
tl = layout->lineAt(layout->lineCount() - 1);
y = newPosition.y() - tl.y() - data->documentOffset() - tl.ascent();
if (y >= 0 && y < 10) {
kDebug(32500) <<" BottomOfParagraph" << y;
relation->anchor->setAlignment(KoTextAnchor::BottomOfParagraph); // TODO
} else {
tl = layout->lineForTextPosition(relation->anchor->positionInDocument() - block.position());
y = tl.y() - data->documentOffset() - newPosition.y();
if (y >= 0 && y < 10) {
kDebug(32500) <<" AboveCurrentLine";
relation->anchor->setAlignment(KoTextAnchor::AboveCurrentLine);
}
//else do VerticalOffset here as well?
}
}
}
}
move.setX(0); // let the text layout move it.
move.setY(0);
}
/**
* Calcul les coordonnnées des différents points
*
* @brief Fleche::CalculerCoordonnees()
*/
void Fleche::CalculerCoordonnees()
{
QPointF PointDepart (pItemDepart->pos()) ;
QPointF PointArrivee (pItemArrivee->pos()) ;
//Si les deux item sont parfaitement allignés
if(PointDepart.x() == PointArrivee.x())
{
if(this->bSortieDecaleeCondition)
{
this->CreerFlecheDecalleeVide(PointDepart, PointArrivee);
}
else
{
qreal YDepart (PointDepart.y() + TAILLE_V/2) ;
qreal YArrivee (PointArrivee.y() - TAILLE_V/2) ;
PointDepart.setY(YDepart) ;
PointArrivee.setY(YArrivee) ;
this->ListePoints.append(PointDepart);
this->ListePoints.append(PointArrivee);
}
}
else
{
//Sinon, si c'est un décalage vers la droite
if(PointDepart.x() < PointArrivee.x())
{
qreal XDepart (PointDepart.x() + TAILLE_H/2) ;
qreal YArrivee (PointArrivee.y() - TAILLE_V/2) ;
PointDepart.setX(XDepart) ;
PointArrivee.setY(YArrivee) ;
QPointF Intermediraire (PointArrivee.x(), PointDepart.y()) ;
this->ListePoints.append(PointDepart);
this->ListePoints.append(Intermediraire);
this->ListePoints.append(PointArrivee);
}
else //Sinon c'est un décalage vers la gauche
{
if(this->bSortieDecaleeCondition)
{
this->CreerFlecheDecalleeVide(PointDepart, PointArrivee);
}
else
{
qreal YDepart (PointDepart.y() + TAILLE_V/2) ;
qreal YArrivee (PointArrivee.y() - TAILLE_V) ;
PointDepart.setY(YDepart) ;
PointArrivee.setY(YArrivee) ;
QPointF Intermediraire (PointDepart.x(), PointArrivee.y()) ;
this->ListePoints.append(PointDepart);
this->ListePoints.append(Intermediraire);
this->ListePoints.append(PointArrivee);
}
}
}
}
//Latest version
int getGridValuesFromExtent(QString extent,QSqlDatabase db, double &dbCellSize, double &xllCenter, double &yllCenter, int &ncols, int &nrows, int &bottom, int &left)
{
//(1.3333,32.1212321) (-4.12121,41.212121)
if (!extent.count(" ") == 1)
{
gbtLog(QObject::tr("Extent is invalid"));
return 1;
}
if (!extent.count(",") == 2)
{
gbtLog(QObject::tr("Extent is invalid"));
return 1;
}
if (!extent.count("(") == 2)
{
gbtLog(QObject::tr("Extent is invalid"));
return 1;
}
if (!extent.count(")") == 2)
{
gbtLog(QObject::tr("Extent is invalid"));
return 1;
}
int pos;
pos = extent.indexOf(" ");
QString from;
QString to;
from = extent.left(pos);
to = extent.mid(pos+1,extent.length()-pos+1);
from.replace("(","");
from.replace(")","");
to.replace("(","");
to.replace(")","");
//Get UpperLeft
QPointF dupperLeft;
pos = from.indexOf(",");
dupperLeft.setX(from.left(pos).toDouble());
dupperLeft.setY(from.mid(pos+1,from.length()-pos+1).toDouble());
//Get lower right
QPointF dlowerRight;
pos = to.indexOf(",");
dlowerRight.setX(to.left(pos).toDouble());
dlowerRight.setY(to.mid(pos+1,to.length()-pos+1).toDouble());
QSqlQuery qry(db);
QString sql;
dbCellSize = 0.0;
sql = "SELECT cellSize FROM gbtconfig";
if (qry.exec(sql))
{
if (qry.first())
dbCellSize = qry.value(0).toDouble();
else
return 1;
}
else
return 1;
if (dbCellSize == 0.0)
return 1;
//*************************
double v_xMin;
double v_xMax;
double v_yMin;
double v_yMax;
double halfx;
int v_cols;
int v_rows;
v_xMin = trunc(( dupperLeft.x() *1.0/ dbCellSize )) * dbCellSize;
v_yMin = trunc(( dlowerRight.y() *1.0/ dbCellSize )) * dbCellSize;
v_cols = trunc( ( dlowerRight.x() - dupperLeft.x() ) *1.0/ dbCellSize ) + 1;
v_rows = trunc( ( dupperLeft.y() - dlowerRight.y() ) *1.0/ dbCellSize ) + 1;
v_xMax = v_xMin + v_cols * dbCellSize;
v_yMax = v_yMin + v_rows * dbCellSize;
halfx = dbCellSize *1.0/ 2;
xllCenter = v_xMin + halfx;
yllCenter = (v_yMin + halfx) - 0.0200;
nrows = trunc( fabs( v_yMax - v_yMin ) *1.0/ dbCellSize );
ncols = trunc(fabs(v_xMax - v_xMin) / dbCellSize);
//*******************
left = ceil((dupperLeft.x() + 180) / dbCellSize);
bottom = ceil((90 - dupperLeft.y()) / dbCellSize);
return 0;
}
//virtual
QVariant AbstractGroupItem::itemChange(GraphicsItemChange change, const QVariant &value)
{
if (change == QGraphicsItem::ItemSelectedChange) {
if (value.toBool()) setZValue(3);
else setZValue(1);
}
CustomTrackScene *scene = NULL;
if (change == ItemPositionChange && parentItem() == 0) {
scene = projectScene();
}
if (scene) {
// calculate new position.
if (scene->isZooming) {
// For some reason, mouse wheel on selected itm sometimes triggered
// a position change event corrupting timeline, so discard it
return pos();
}
// calculate new position.
const int trackHeight = KdenliveSettings::trackheight();
QPointF start = sceneBoundingRect().topLeft();
QPointF newPos = value.toPointF();
int xpos = projectScene()->getSnapPointForPos((int)(start.x() + newPos.x() - pos().x()), KdenliveSettings::snaptopoints());
xpos = qMax(xpos, 0);
////qDebug()<<"GRP XPOS:"<<xpos<<", START:"<<start.x()<<",NEW:"<<newPos.x()<<"; SCENE:"<<scenePos().x()<<",POS:"<<pos().x();
newPos.setX((int)(pos().x() + xpos - (int) start.x()));
QStringList lockedTracks = property("locked_tracks").toStringList();
int proposedTrack = trackForPos(property("y_absolute").toInt() + newPos.y());
// Check if top item is a clip or a transition
int offset = 0;
int topTrack = -1;
QList<int> groupTracks;
QList<QGraphicsItem *> children = childItems();
for (int i = 0; i < children.count(); ++i) {
int currentTrack = 0;
if (children.at(i)->type() == AVWidget || children.at(i)->type() == TransitionWidget) {
currentTrack = static_cast <AbstractClipItem*> (children.at(i))->track();
if (!groupTracks.contains(currentTrack)) groupTracks.append(currentTrack);
}
else if (children.at(i)->type() == GroupWidget) {
currentTrack = static_cast <AbstractGroupItem*> (children.at(i))->track();
}
else continue;
if (children.at(i)->type() == AVWidget) {
if (topTrack == -1 || currentTrack >= topTrack) {
offset = 0;
topTrack = currentTrack;
}
} else if (children.at(i)->type() == TransitionWidget) {
if (topTrack == -1 || currentTrack > topTrack) {
offset = (int)(trackHeight / 3 * 2 - 1);
topTrack = currentTrack;
}
} else if (children.at(i)->type() == GroupWidget) {
QList<QGraphicsItem *> subchildren = children.at(i)->childItems();
bool clipGroup = false;
for (int j = 0; j < subchildren.count(); ++j) {
if (subchildren.at(j)->type() == AVWidget || subchildren.at(j)->type() == TransitionWidget) {
int subTrack = static_cast <AbstractClipItem*> (subchildren.at(j))->track();
if (!groupTracks.contains(subTrack)) groupTracks.append(subTrack);
clipGroup = true;
}
}
if (clipGroup) {
if (topTrack == -1 || currentTrack >= topTrack) {
offset = 0;
topTrack = currentTrack;
}
} else {
if (topTrack == -1 || currentTrack > topTrack) {
offset = (int)(trackHeight / 3 * 2 - 1);
topTrack = currentTrack;
}
}
}
}
// Check no clip in the group goes outside of existing tracks
int maximumTrack = projectScene()->tracksCount();
int groupHeight = 0;
for (int i = 0; i < groupTracks.count(); ++i) {
int trackOffset = topTrack - groupTracks.at(i) + 1;
if (trackOffset > groupHeight) groupHeight = trackOffset;
}
proposedTrack = qBound(groupHeight, proposedTrack, maximumTrack);
int groupOffset = proposedTrack - topTrack;
if (!lockedTracks.isEmpty()) {
for (int i = 0; i < groupTracks.count(); ++i) {
if (lockedTracks.contains(QString::number(groupTracks.at(i) + groupOffset))) {
return pos();
}
}
}
newPos.setY(posForTrack(proposedTrack) + offset);
//if (newPos == start) return start;
/*if (newPos.x() < 0) {
// If group goes below 0, adjust position to 0
return QPointF(pos().x() - start.x(), pos().y());
}*/
QList<QGraphicsItem*> collidingItems;
QPainterPath shape;
if (projectScene()->editMode() == NormalEdit) {
shape = clipGroupShape(newPos - pos());
collidingItems = scene->items(shape, Qt::IntersectsItemShape);
collidingItems.removeAll(this);
for (int i = 0; i < children.count(); ++i) {
if (children.at(i)->type() == GroupWidget) {
QList<QGraphicsItem *> subchildren = children.at(i)->childItems();
for (int j = 0; j < subchildren.count(); ++j) {
collidingItems.removeAll(subchildren.at(j));
}
}
collidingItems.removeAll(children.at(i));
}
}
if (!collidingItems.isEmpty()) {
bool forwardMove = xpos > start.x();
int offset = 0;
for (int i = 0; i < collidingItems.count(); ++i) {
QGraphicsItem *collision = collidingItems.at(i);
if (collision->type() == AVWidget) {
// Collision
if (newPos.y() != pos().y()) {
// Track change results in collision, restore original position
return pos();
}
AbstractClipItem *item = static_cast <AbstractClipItem *>(collision);
// Determine best pos
QPainterPath clipPath;
clipPath.addRect(item->sceneBoundingRect());
QPainterPath res = shape.intersected(clipPath);
offset = qMax(offset, (int)(res.boundingRect().width() + 0.5));
}
}
if (offset > 0) {
if (forwardMove) {
newPos.setX(newPos.x() - offset);
} else {
newPos.setX(newPos.x() + offset);
}
// If there is still a collision after our position adjust, restore original pos
collidingItems = scene->items(clipGroupShape(newPos - pos()), Qt::IntersectsItemShape);
collidingItems.removeAll(this);
for (int i = 0; i < children.count(); ++i) {
if (children.at(i)->type() == GroupWidget) {
QList<QGraphicsItem *> subchildren = children.at(i)->childItems();
for (int j = 0; j < subchildren.count(); ++j) {
collidingItems.removeAll(subchildren.at(j));
}
}
collidingItems.removeAll(children.at(i));
}
for (int i = 0; i < collidingItems.count(); ++i)
if (collidingItems.at(i)->type() == AVWidget) return pos();
}
}
if (projectScene()->editMode() == NormalEdit) {
shape = transitionGroupShape(newPos - pos());
collidingItems = scene->items(shape, Qt::IntersectsItemShape);
collidingItems.removeAll(this);
for (int i = 0; i < children.count(); ++i) {
if (children.at(i)->type() == GroupWidget) {
QList<QGraphicsItem *> subchildren = children.at(i)->childItems();
for (int j = 0; j < subchildren.count(); ++j) {
collidingItems.removeAll(subchildren.at(j));
}
}
collidingItems.removeAll(children.at(i));
}
}
if (collidingItems.isEmpty()) return newPos;
else {
bool forwardMove = xpos > start.x();
int offset = 0;
for (int i = 0; i < collidingItems.count(); ++i) {
QGraphicsItem *collision = collidingItems.at(i);
if (collision->type() == TransitionWidget) {
// Collision
if (newPos.y() != pos().y()) {
// Track change results in collision, restore original position
return pos();
}
AbstractClipItem *item = static_cast <AbstractClipItem *>(collision);
// Determine best pos
QPainterPath clipPath;
clipPath.addRect(item->sceneBoundingRect());
QPainterPath res = shape.intersected(clipPath);
offset = qMax(offset, (int)(res.boundingRect().width() + 0.5));
}
}
if (offset > 0) {
if (forwardMove) {
newPos.setX(newPos.x() - offset);
} else {
newPos.setX(newPos.x() + offset);
}
// If there is still a collision after our position adjust, restore original pos
collidingItems = scene->items(transitionGroupShape(newPos - pos()), Qt::IntersectsItemShape);
for (int i = 0; i < children.count(); ++i) {
collidingItems.removeAll(children.at(i));
}
for (int i = 0; i < collidingItems.count(); ++i)
if (collidingItems.at(i)->type() == TransitionWidget) return pos();
}
}
return newPos;
}
return QGraphicsItemGroup::itemChange(change, value);
}
void RawDelegate::createPlotPath(const QModelIndex &index, const QStyleOptionViewItem &option, QPainterPath& path, QList<RowVectorPair>& listPairs, double channelMean) const
{
//get maximum range of respective channel type (range value in FiffChInfo does not seem to contain a reasonable value)
qint32 kind = (static_cast<const RawModel*>(index.model()))->m_chInfolist[index.row()].kind;
double dMaxValue = 1e-9;
switch(kind) {
case FIFFV_MEG_CH: {
qint32 unit = (static_cast<const RawModel*>(index.model()))->m_pfiffIO->m_qlistRaw[0]->info.chs[index.row()].unit;
if(unit == FIFF_UNIT_T_M) {
dMaxValue = m_scaleMap["MEG_grad"];
}
else if(unit == FIFF_UNIT_T)
dMaxValue = m_scaleMap["MEG_mag"];
break;
}
case FIFFV_EEG_CH: {
dMaxValue = m_scaleMap["MEG_EEG"];
break;
}
case FIFFV_EOG_CH: {
dMaxValue = m_scaleMap["MEG_EOG"];
break;
}
case FIFFV_STIM_CH: {
dMaxValue = m_scaleMap["MEG_STIM"];
break;
}
case FIFFV_EMG_CH: {
dMaxValue = m_scaleMap["MEG_EMG"];
break;
}
case FIFFV_MISC_CH: {
dMaxValue = m_scaleMap["MEG_MISC"];
break;
}
}
double dValue;
double dScaleY = option.rect.height()/(2*dMaxValue);
double y_base = -path.currentPosition().y();
QPointF qSamplePosition;
path.moveTo(path.currentPosition().x(), -(y_base + ((*(listPairs[0].first) - channelMean)*dScaleY)));
//plot all rows from list of pairs
for(qint8 i=0; i < listPairs.size(); ++i) {
//create lines from one to the next sample
for(qint32 j=0; j < listPairs[i].second; ++j)
{
double val = *(listPairs[i].first+j);
//subtract mean of the channel here (if wanted by the user)
dValue = (val - channelMean)*dScaleY;
double newY = y_base+dValue;
qSamplePosition.setY(-newY);
qSamplePosition.setX(path.currentPosition().x()+m_dDx);
path.lineTo(qSamplePosition);
}
}
// qDebug("Plot-PainterPath created!");
}
/**
* Sets the bounding area for a tile.
*
* The logic for taking a blocking type and converting it to a bounding area.
* Closed type will use a box based on the size of the tile, semiclosed tiles
* will have a triangle. Open type will not have a bounding box. The
* coordinates will be based on the position of the tile in the map.
*
* @author Luke Queenan
*/
void Tile::setInitialBounds(int row, int column, BlockingType type)
{
QPointF point = QPointF();
QVector<QPointF> points = QVector<QPointF>();
switch (type) {
case CLOSED:
// Top left corner
point.setX(column * width_ + width_);
point.setY(row * height_);
points.append(point);
// Top right corner
point.setX(column * width_ + width_);
point.setY(row * height_);
points.append(point);
// Bottom right corner
point.setX(column * width_ + width_);
point.setY(row * height_ + height_);
points.append(point);
// Bottom left corner
point.setX(column * width_);
point.setY(row * height_ + height_);
points.append(point);
// Create bounding box
myBounds_ = QPolygonF(points);
break;
case NORTH_WEST:
// Top right corner
point.setX(column * width_ + width_);
point.setY(row * height_);
points.append(point);
// Bottom left corner
point.setX(column * width_);
point.setY(row * height_ + height_);
points.append(point);
// Bottom right corner
point.setX(column * width_ + width_);
point.setY(row * height_ + height_);
points.append(point);
// Create bounding box
myBounds_ = QPolygonF(points);
break;
case NORTH_EAST:
// Top left corner
point.setX(column * width_);
point.setY(row * height_);
points.append(point);
// Bottom left corner
point.setX(column * width_);
point.setY(row * height_ + height_);
points.append(point);
// Bottom right corner
point.setX(column * width_ + width_);
point.setY(row * height_ + height_);
points.append(point);
// Create bounding box
myBounds_ = QPolygonF(points);
break;
case SOUTH_WEST:
// Top left corner
point.setX(column * width_);
point.setY(row * height_);
points.append(point);
// Top right corner
point.setX(column * width_ + width_);
point.setY(row * height_);
points.append(point);
// Bottom right corner
point.setX(column * width_ + width_);
point.setY(row * height_ + height_);
points.append(point);
// Create bounding box
myBounds_ = QPolygonF(points);
break;
case SOUTH_EAST:
// Top left corner
point.setX(column * width_);
point.setY(row * height_);
points.append(point);
// Top right corner
point.setX(column * width_ + width_);
point.setY(row * height_);
points.append(point);
// Bottom left corner
point.setX(column * width_);
point.setY(row * height_ + height_);
points.append(point);
// Create bounding box
myBounds_ = QPolygonF(points);
break;
default:
break;
}
}
void CustomGraphicsScene::appendCard(int _cardType, const QString& _title, const QString& _description)
{
QPointF scenePosition = sceneRect().center();
//
// Если выделена карточка
//
CardShape* selectedCard = nullptr;
CardShape* previousCard = nullptr;
CardShape* nextCard = nullptr;
CardShape* parentCard = nullptr;
if (!selectedItems().isEmpty()
&& selectedItems().size() == 1
&& (selectedCard = dynamic_cast<CardShape*>(selectedItems().last()))) {
//
// Если карточка вложена в группирующую, то расширяем родителя и вкладываем карту в него
//
if (selectedCard->parentItem() != nullptr) {
//
// Запомним родителя
//
parentCard = dynamic_cast<CardShape*>(selectedCard->parentItem());
}
//
// Если выделен группирующий элемент, то соединять будем с последним из его детей
//
if (hasCards(selectedCard)) {
selectedCard = dynamic_cast<CardShape*>(lastCard(selectedCard));
}
//
// Предыдущей будет выделенная
//
previousCard = selectedCard;
//
// Настроим позицию для добавления новой карточки
//
scenePosition = previousCard->scenePos();
scenePosition.setX(scenePosition.x() + previousCard->boundingRect().width() + SHAPE_MOVE_DELTA);
scenePosition.setY(scenePosition.y() + previousCard->boundingRect().height() + SHAPE_MOVE_DELTA);
//
// Определим карточку, которая будет следовать за новой
//
Flow* flow = cardFlow(previousCard, CARD_ON_FLOW_START);
if (flow != nullptr) {
nextCard = dynamic_cast<CardShape*>(flow->endShape());
removeShape(flow);
}
}
//
// В противном случае добавляем карточку после самой последней карточки, если карточки уже есть
//
else if (hasCards()) {
//
// Определим последнюю карточку
//
Shape* lastCardShape = lastCard();
previousCard = dynamic_cast<CardShape*>(lastCardShape);
//
// Настроим позицию для добавления новой карточки
//
scenePosition = previousCard->scenePos();
scenePosition.setX(scenePosition.x() + previousCard->boundingRect().width() + SHAPE_MOVE_DELTA);
scenePosition.setY(scenePosition.y() + previousCard->boundingRect().height() + SHAPE_MOVE_DELTA);
}
//
// В противном случае добавляем карточку по середине видимой части сцены, если подключены представления
//
else if (!views().isEmpty()) {
if (QGraphicsView* view = views().last()) {
const QRect viewportRect(0, 0, view->viewport()->width(), view->viewport()->height());
const QRectF visibleSceneRect = view->mapToScene(viewportRect).boundingRect();
scenePosition = visibleSceneRect.center();
}
}
//
// Добавляем карточку
//
CardShape* newCard = new CardShape((CardShape::CardType)_cardType, _title, _description, scenePosition, parentCard);
insertShape(newCard, previousCard);
//
// ... корректируем позицию вкладываемой карточки
//
if (parentCard != nullptr) {
const QPointF newPos = parentCard->mapFromScene(newCard->scenePos());
const QPointF newBottomRightPos = newPos + QPointF(newCard->boundingRect().width(), newCard->boundingRect().height());
//
newCard->setParentItem(parentCard);
newCard->setPos(newPos);
//
// ... и масштабируем родителя, если нужно
//
if (!parentCard->contains(newBottomRightPos)) {
QSizeF newSize = parentCard->size();
if (newSize.width() <= newBottomRightPos.x()) {
newSize.setWidth(newBottomRightPos.x() + SHAPE_MICROMOVE_DELTA);
}
if (newSize.height() <= newBottomRightPos.y()) {
newSize.setHeight(newBottomRightPos.y() + SHAPE_MICROMOVE_DELTA);
}
parentCard->setSize(newSize);
}
}
//
// Соединяем с предыдущей
//
if (previousCard != nullptr) {
appendShape(new ArrowFlow(previousCard, newCard, parentCard));
}
//
// Соединяем со следующей
//
if (nextCard != nullptr) {
appendShape(new ArrowFlow(newCard, nextCard, parentCard));
}
}
void RealTimeButterflyPlot::createPlotPath(qint32 row, QPainterPath& path) const
{
//get maximum range of respective channel type (range value in FiffChInfo does not seem to contain a reasonable value)
qint32 kind = m_pRealTimeEvokedModel->getKind(row);
float fMaxValue = 1e-9f;
switch(kind) {
case FIFFV_MEG_CH: {
qint32 unit =m_pRealTimeEvokedModel->getUnit(row);
if(unit == FIFF_UNIT_T_M) { //gradiometers
fMaxValue = 1e-10f;
if(m_pRealTimeEvokedModel->getScaling().contains(FIFF_UNIT_T_M))
fMaxValue = m_pRealTimeEvokedModel->getScaling()[FIFF_UNIT_T_M];
}
else if(unit == FIFF_UNIT_T) //magnitometers
{
if(m_pRealTimeEvokedModel->getCoil(row) == FIFFV_COIL_BABY_MAG)
fMaxValue = 1e-11f;
else
fMaxValue = 1e-11f;
if(m_pRealTimeEvokedModel->getScaling().contains(FIFF_UNIT_T))
fMaxValue = m_pRealTimeEvokedModel->getScaling()[FIFF_UNIT_T];
}
break;
}
case FIFFV_REF_MEG_CH: { /*11/04/14 Added by Limin: MEG reference channel */
fMaxValue = 1e-11f;
if(m_pRealTimeEvokedModel->getScaling().contains(FIFF_UNIT_T))
fMaxValue = m_pRealTimeEvokedModel->getScaling()[FIFF_UNIT_T];
break;
}
case FIFFV_EEG_CH: {
fMaxValue = 1e-4f;
if(m_pRealTimeEvokedModel->getScaling().contains(FIFFV_EEG_CH))
fMaxValue = m_pRealTimeEvokedModel->getScaling()[FIFFV_EEG_CH];
break;
}
case FIFFV_EOG_CH: {
fMaxValue = 1e-3f;
if(m_pRealTimeEvokedModel->getScaling().contains(FIFFV_EOG_CH))
fMaxValue = m_pRealTimeEvokedModel->getScaling()[FIFFV_EOG_CH];
break;
}
case FIFFV_STIM_CH: {
fMaxValue = 5;
if(m_pRealTimeEvokedModel->getScaling().contains(FIFFV_STIM_CH))
fMaxValue = m_pRealTimeEvokedModel->getScaling()[FIFFV_STIM_CH];
break;
}
case FIFFV_MISC_CH: {
fMaxValue = 1e-3f;
if(m_pRealTimeEvokedModel->getScaling().contains(FIFFV_MISC_CH))
fMaxValue = m_pRealTimeEvokedModel->getScaling()[FIFFV_MISC_CH];
break;
}
}
float fValue;
float fScaleY = this->height()/(2*fMaxValue);
//restrictions for paint performance
float fWinMaxVal = ((float)this->height()-2)/2.0f;
qint32 iDownSampling = (m_pRealTimeEvokedModel->getNumSamples() * 4 / (this->width()-2));
if(iDownSampling < 1)
iDownSampling = 1;
float y_base = path.currentPosition().y();
QPointF qSamplePosition;
float fDx = (float)(this->width()-2) / ((float)m_pRealTimeEvokedModel->getNumSamples()-1.0f);//((float)option.rect.width()) / m_pRealTimeEvokedModel->getMaxSamples();
// fDx *= iDownSampling;
RowVectorXd rowVec = m_pRealTimeEvokedModel->data(row,1).value<RowVectorXd>();
//Move to initial starting point
if(rowVec.size() > 0)
{
float val = rowVec[0];
fValue = (val/*-rowVec[m_pRealTimeEvokedModel->getNumPreStimSamples()-1]*/)*fScaleY;//ToDo -> -2 PreStim is one too short
float newY = y_base+fValue;
qSamplePosition.setY(-newY);
qSamplePosition.setX(path.currentPosition().x());
path.moveTo(qSamplePosition);
}
//create lines from one to the next sample
qint32 i;
for(i = 1; i < rowVec.size(); ++i) {
// if(i != m_pRealTimeEvokedModel->getNumPreStimSamples() - 2)
// {
float val = /*rowVec[m_pRealTimeEvokedModel->getNumPreStimSamples()-1] - */rowVec[i]; //remove first sample data[0] as offset
fValue = val*fScaleY;
fValue = fValue > fWinMaxVal ? fWinMaxVal : fValue < -fWinMaxVal ? -fWinMaxVal : fValue;
float newY = y_base+fValue;
qSamplePosition.setY(-newY);
// }
// else
// qSamplePosition.setY(y_base);
qSamplePosition.setX(path.currentPosition().x()+fDx);
path.lineTo(qSamplePosition);
}
// //create lines from one to the next sample for last path
// qint32 sample_offset = m_pRealTimeEvokedModel->numVLines() + 1;
// qSamplePosition.setX(qSamplePosition.x() + fDx*sample_offset);
// lastPath.moveTo(qSamplePosition);
// for(i += sample_offset; i < lastData.size(); ++i) {
// float val = lastData[i] - lastData[0]; //remove first sample lastData[0] as offset
// fValue = val*fScaleY;
// float newY = y_base+fValue;
// qSamplePosition.setY(newY);
// qSamplePosition.setX(lastPath.currentPosition().x()+fDx);
// lastPath.lineTo(qSamplePosition);
// }
}
bool OpenGL_Widget::loadConfigFromJson(QString filename)
{
FILE *f = fopen(filename.toStdString().c_str(), "r");
if (f == NULL) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Can't load from to %s",
filename.toStdString().c_str());
return false;
}
// Lines and parameters to read
char line[1024];
char param[1024];
float val;
QPointF cop;
// Skip the first three lines.
char* unused;
unused = fgets(line, sizeof(line), f);
unused = fgets(line, sizeof(line), f);
unused = fgets(line, sizeof(line), f);
// Try and read the red term
if (fgets(line, sizeof(line), f) == NULL) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Can't read red line");
return false;
}
if (sscanf(line, "%s %g", param, &val) != 2) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Bad red line: %s",
line);
return false;
}
d_k1_red = val;
// Try and read the green term
if (fgets(line, sizeof(line), f) == NULL) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Can't read green line");
return false;
}
if (sscanf(line, "%s %g", param, &val) != 2) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Bad green line: %s",
line);
return false;
}
d_k1_green = val;
// Try and read the blue term
if (fgets(line, sizeof(line), f) == NULL) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Can't read blue line");
return false;
}
if (sscanf(line, "%s %g", param, &val) != 2) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Bad blue line: %s",
line);
return false;
}
d_k1_blue = val;
// Skip the next three lines
unused = fgets(line, sizeof(line), f);
unused = fgets(line, sizeof(line), f);
unused = fgets(line, sizeof(line), f);
// Try and read the eye X COP term
if (fgets(line, sizeof(line), f) == NULL) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Can't read COP x line");
return false;
}
if (sscanf(line, "%s %f", param, &val) != 2) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Bad COP x line: %s",
line);
return false;
}
cop.setX(val);
// Try and read the eye Y COP term
if (fgets(line, sizeof(line), f) == NULL) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Can't read COP y line");
return false;
}
if (sscanf(line, "%s %f", param, &val) != 2) {
fprintf(stderr, "OpenGL_Widget::loadConfigFromJson(): Bad COP y line: %s",
line);
return false;
}
cop.setY(val);
if (fullscreen){
d_cop = relativeToPixel(cop);
}
else{
d_cop_l = relativeToPixel(cop);
// Find the mirror of the left-eye's center of projection
// around the screen center to find the right eye's COP.
d_cop_r = QPoint(d_width - d_cop_l.x(), d_cop_l.y());
}
fclose(f);
return true;
}
void NetworkGraphics::updateNetwork(){
qDebug() << "NetworkGraphics::updateNetwork()";
scene->clear();
linkMap.clear();
rebuildNetwork();
QPointF position = QPointF(0.0, 0.0);
QList<raw_address> rootAddrs = network->getTopLevelAddresses();
for(int i=0; i<rootAddrs.size(); i++){
if(positionBranch(rootAddrs[i], position)){
QSizeF size = computeSize(rootAddrs[i]);
QRectF rect = QRectF(position, size);
//scene->addRect(rect);*/
position.setX( position.x() + size.width() + (3.0*CLOUD_X_MARGIN) );
//scene->update(rect);
}
}
//Draw links
QList<NetLink*> links = network->getLinks();
QPen blackPen = QPen();
blackPen.setColor(Qt::gray);
blackPen.setWidth(2);
for(int i=0; i<links.size(); i++){
NetLink* link = links[i];
GraphicNetCloud* firstCloud = cloudMap[nodeMap[link->getFirst()]];
GraphicNetCloud* secondCloud = cloudMap[nodeMap[link->getSecond()]];
if(firstCloud != secondCloud){
QPointF startPoint = firstCloud->boundingRect().center();
QPointF endPoint = secondCloud->boundingRect().center();
startPoint.setX(firstCloud->pos().x() + startPoint.x());
startPoint.setY(firstCloud->pos().y() + startPoint.y());
endPoint.setX(secondCloud->pos().x() + endPoint.x());
endPoint.setY(secondCloud->pos().y() + endPoint.y());
QLineF line(startPoint, endPoint);
QGraphicsLineItem* lineItem = new QGraphicsLineItem(line);
lineItem->setPen(blackPen);
lineItem->setZValue(1);
lineItem->setOpacity(.8);
scene->addItem(lineItem);
//qDebug() << "Line: " << line ;
linkMap.insert(link, lineItem);
}
}
}
void QgsComposerArrow::drawSVGMarker( QPainter* p, MarkerType type, const QString &markerPath )
{
Q_UNUSED( markerPath );
double ang = QgsComposerUtils::angle( mStartPoint, mStopPoint );
double arrowHeadHeight;
if ( type == StartMarker )
{
arrowHeadHeight = mStartArrowHeadHeight;
}
else
{
arrowHeadHeight = mStopArrowHeadHeight;
}
if ( mArrowHeadWidth <= 0 || arrowHeadHeight <= 0 )
{
//bad image size
return;
}
QPointF imageFixPoint;
imageFixPoint.setX( mArrowHeadWidth / 2.0 );
QPointF canvasPoint;
if ( type == StartMarker )
{
canvasPoint = QPointF( mStartPoint.x() - pos().x(), mStartPoint.y() - pos().y() );
imageFixPoint.setY( mStartArrowHeadHeight );
}
else //end marker
{
canvasPoint = QPointF( mStopPoint.x() - pos().x(), mStopPoint.y() - pos().y() );
imageFixPoint.setY( 0 );
}
//rasterize svg
QSvgRenderer r;
if ( type == StartMarker )
{
if ( mStartMarkerFile.isEmpty() || !r.load( mStartMarkerFile ) )
{
return;
}
}
else //end marker
{
if ( mEndMarkerFile.isEmpty() || !r.load( mEndMarkerFile ) )
{
return;
}
}
p->save();
p->setRenderHint( QPainter::Antialiasing );
if ( mBoundsBehaviour == 22 )
{
//if arrow was created in versions prior to 2.4, use the old rendering style
//rotate image fix point for backtransform
QPointF fixPoint;
if ( type == StartMarker )
{
fixPoint.setX( 0 ); fixPoint.setY( arrowHeadHeight / 2.0 );
}
else
{
fixPoint.setX( 0 ); fixPoint.setY( -arrowHeadHeight / 2.0 );
}
QPointF rotatedFixPoint;
double angleRad = ang / 180 * M_PI;
rotatedFixPoint.setX( fixPoint.x() * cos( angleRad ) + fixPoint.y() * -sin( angleRad ) );
rotatedFixPoint.setY( fixPoint.x() * sin( angleRad ) + fixPoint.y() * cos( angleRad ) );
p->translate( canvasPoint.x() - rotatedFixPoint.x(), canvasPoint.y() - rotatedFixPoint.y() );
}
else
{
p->translate( canvasPoint.x(), canvasPoint.y() );
}
p->rotate( ang );
p->translate( -mArrowHeadWidth / 2.0, -arrowHeadHeight / 2.0 );
r.render( p, QRectF( 0, 0, mArrowHeadWidth, arrowHeadHeight ) );
p->restore();
return;
}
void ButterflySceneItem::paintAveragePaths(QPainter *painter)
{
//Create path for all channels
for(int i = 0; i<m_pFiffInfo->chs.size() ;i++) {
FiffChInfo fiffChInfoTemp = m_pFiffInfo->chs.at(i);
if(m_pFiffInfo->bads.contains(fiffChInfoTemp.ch_name) == false) {
//Only plot EEG or MEG channels
if((fiffChInfoTemp.kind == FIFFV_MEG_CH && m_iSetKind == FIFFV_MEG_CH && fiffChInfoTemp.unit == FIFF_UNIT_T_M && m_iSetUnit == FIFF_UNIT_T_M) || //MEG grad
(fiffChInfoTemp.kind == FIFFV_MEG_CH && m_iSetKind == FIFFV_MEG_CH && fiffChInfoTemp.unit == FIFF_UNIT_T && m_iSetUnit == FIFF_UNIT_T) || //MEG mag
(fiffChInfoTemp.kind == FIFFV_EEG_CH && m_iSetKind == FIFFV_EEG_CH)) { //EEG
//Determine channel scaling
double dMaxValue = 1e-09;
switch(fiffChInfoTemp.kind) {
case FIFFV_MEG_CH: {
if(fiffChInfoTemp.unit == FIFF_UNIT_T_M) {
dMaxValue = m_scaleMap["MEG_grad"];
}
else if(fiffChInfoTemp.unit == FIFF_UNIT_T)
dMaxValue = m_scaleMap["MEG_mag"];
break;
}
case FIFFV_EEG_CH: {
dMaxValue = m_scaleMap["MEG_EEG"];
break;
}
}
//Get data pointer for the current channel
const double* averageData = m_lAverageData.first;
int totalCols = m_lAverageData.second; //equals to the number of samples stored in the data matrix
//Calculate downsampling factor of averaged data in respect to the items width
int dsFactor;
QRectF boundingRect = this->boundingRect();
totalCols / boundingRect.width()<1 ? dsFactor = 1 : dsFactor = totalCols / boundingRect.width();
//Calculate scaling value
double dScaleY = (boundingRect.height())/(2*dMaxValue);
//Setup the painter
QPainterPath path = QPainterPath(QPointF(boundingRect.x(), *(averageData+(0*m_pFiffInfo->chs.size())+i) * -dScaleY));
QPen pen;
pen.setStyle(Qt::SolidLine);
if(!m_cAverageColors.isEmpty() && i<m_cAverageColors.size())
pen.setColor(m_cAverageColors.at(i));
pen.setWidthF(0.25);
painter->setPen(pen);
//Generate plot path
QPointF qSamplePosition;
for(int u = 0; u < totalCols && path.elementCount() <= boundingRect.width(); u += dsFactor) {
//evoked matrix is stored in column major
double val = (*(averageData+(u*m_pFiffInfo->chs.size())+i) * dScaleY);
qSamplePosition.setY(-val);
qSamplePosition.setX(path.currentPosition().x()+1);
path.lineTo(qSamplePosition);
}
//Paint the path
painter->drawPath(path);
}
}
}
}
void KUnitItem::slotMouseMove(QGraphicsSceneMouseEvent *event)
{
if (myMode == MouseMode_RESIZE)
{
QPointF curPoint(event->scenePos());
QPointF curPointItem = this->mapFromScene(curPoint);
bool flagx = lastPoint.x() > oppositePos.x();
bool flagx1 = curPointItem.x() > oppositePos.x();
bool flagy = lastPoint.y() > oppositePos.y();
bool flagy1 = curPointItem.y() > oppositePos.y();
qreal dist = 0;
QRectF rectf;
rectf.setRect(m_frame.x()
, m_frame.y()
, m_frame.width()
, m_frame.height());
KResizeFocus::PosInHost pos = curResizeFocus->getInHost();
if (pos == KResizeFocus::NORTH_MIDDLE)
{
QPointF br = dashRect->rect().bottomRight();
dist = Util::GetPointDistLine(oppositePos,br,curPointItem);
if (dist < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
dist = 20;
}
rectf.setY(curPointItem.y());
rectf.setHeight(dist);
}
else if(pos == KResizeFocus::SOUTH_MIDDLE)
{
QPointF br = dashRect->rect().topRight();
dist = Util::GetPointDistLine(oppositePos,br,curPointItem);
if (dist < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
dist = 20;
}
rectf.setHeight(dist);
}
else if(pos == KResizeFocus::EAST_MIDDLE)
{
QPointF br = dashRect->rect().bottomLeft();
dist = Util::GetPointDistLine(oppositePos,br,curPointItem);
if (dist < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
dist = 20;
}
rectf.setWidth(dist);
}
else if(pos == KResizeFocus::WEST_MIDDLE)
{
QPointF br = dashRect->rect().bottomRight();
dist = Util::GetPointDistLine(oppositePos,br,curPointItem);
if (dist < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
dist = 20;
}
rectf.setX(curPointItem.x());
rectf.setWidth(dist);
}
else if(pos == KResizeFocus::NORTH_WEST)
{
QPointF topRight = dashRect->rect().topRight();
QPointF bottomLeft = dashRect->rect().bottomLeft();
qreal distx = Util::GetPointDistLine(oppositePos,topRight,curPointItem);
qreal disty = Util::GetPointDistLine(oppositePos,bottomLeft,curPointItem);
if (distx < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
distx = 20;
}
if (disty < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
disty = 20;
}
rectf.setTopLeft(curPointItem);
}
else if(pos == KResizeFocus::NORTH_EAST)
{
QPointF topLeft = dashRect->rect().topLeft();
QPointF bottomRight = dashRect->rect().bottomRight();
qreal distx = Util::GetPointDistLine(oppositePos,topLeft,curPointItem);
qreal disty = Util::GetPointDistLine(oppositePos,bottomRight,curPointItem);
if (distx < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
distx = 20;
}
if (disty < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
disty = 20;
}
rectf.setTopRight(curPointItem);
}
else if(pos == KResizeFocus::SOUTH_EAST)
{
QPointF topRight = dashRect->rect().topRight();
QPointF bottomLeft = dashRect->rect().bottomLeft();
qreal disty = Util::GetPointDistLine(oppositePos,topRight,curPointItem);
qreal distx = Util::GetPointDistLine(oppositePos,bottomLeft,curPointItem);
if (distx < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
distx = 20;
}
if (disty < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
disty = 20;
}
rectf.setBottomRight(curPointItem);
}
else if(pos == KResizeFocus::SOUTH_WEST)
{
QPointF topLeft = dashRect->rect().topLeft();
QPointF bottomRight = dashRect->rect().bottomRight();
qreal disty = Util::GetPointDistLine(oppositePos,topLeft,curPointItem);
qreal distx = Util::GetPointDistLine(oppositePos,bottomRight,curPointItem);
if (distx < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
distx = 20;
}
if (disty < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
disty = 20;
}
rectf.setBottomLeft(curPointItem);
}
dashRect->setRect(rectf);
}
else if(myMode == MouseMode_ROTATE)
{
QPointF curPos = event->scenePos();
QPointF cpos = this->mapToScene(frame().center());
// qDebug()<<cpos;
qreal angleLast = Util::ComputeAngle(mLastRotatePoint, cpos);
qreal angleCur = Util::ComputeAngle(curPos, cpos);
qreal angle = angleCur - angleLast;
setAngle(angle);
mLastRotatePoint = curPos;
onRotate();
}
else if(myMode == MouseMode_MOVE)
{
onMoving();
}
else
{
QGraphicsItem::mouseMoveEvent(event);
}
}
//virtual
QVariant Transition::itemChange(GraphicsItemChange change, const QVariant &value)
{
if (change == QGraphicsItem::ItemSelectedChange) {
if (value.toBool()) setZValue(5);
else setZValue(4);
}
CustomTrackScene *scene = NULL;
if (change == ItemPositionChange) {
scene = projectScene();
}
if (scene) {
// calculate new position.
if (scene->isZooming) {
// For some reason, mouse wheel on selected itm sometimes triggered
// a position change event corrupting timeline, so discard it
return pos();
}
QPointF newPos = value.toPointF();
int xpos = projectScene()->getSnapPointForPos((int) newPos.x(), KdenliveSettings::snaptopoints());
xpos = qMax(xpos, 0);
newPos.setX(xpos);
int newTrack = trackForPos(newPos.y());
QStringList lockedTracks = property("locked_tracks").toStringList();
if (lockedTracks.contains(QString::number(newTrack))) {
// Trying to move to a locked track
return pos();
}
int maximumTrack = projectScene()->tracksCount();
newTrack = qMin(newTrack, maximumTrack);
newTrack = qMax(newTrack, 0);
newPos.setY(posForTrack(newTrack) + itemOffset());
// Only one clip is moving
QRectF sceneShape = rect();
sceneShape.translate(newPos);
QList<QGraphicsItem*> items;
// TODO: manage transitions in OVERWRITE MODE
//if (projectScene()->editMode() == NORMALEDIT)
items = scene->items(sceneShape, Qt::IntersectsItemShape);
items.removeAll(this);
bool forwardMove = newPos.x() > pos().x();
if (!items.isEmpty()) {
for (int i = 0; i < items.count(); ++i) {
if (!items.at(i)->isEnabled()) continue;
if (items.at(i)->type() == type()) {
int offset = 0;
// Collision!
QPointF otherPos = items.at(i)->pos();
if ((int) otherPos.y() != (int) pos().y()) {
return pos();
}
if (forwardMove) {
offset = qMax(offset, (int)(newPos.x() - (static_cast < AbstractClipItem* >(items.at(i))->startPos() - cropDuration()).frames(m_fps)));
} else {
offset = qMax(offset, (int)((static_cast < AbstractClipItem* >(items.at(i))->endPos().frames(m_fps)) - newPos.x()));
}
if (offset > 0) {
if (forwardMove) {
sceneShape.translate(QPointF(-offset, 0));
newPos.setX(newPos.x() - offset);
} else {
sceneShape.translate(QPointF(offset, 0));
newPos.setX(newPos.x() + offset);
}
QList<QGraphicsItem*> subitems = scene->items(sceneShape, Qt::IntersectsItemShape);
subitems.removeAll(this);
for (int j = 0; j < subitems.count(); ++j) {
if (!subitems.at(j)->isEnabled()) continue;
if (subitems.at(j)->type() == type()) {
// move was not successful, revert to previous pos
m_info.startPos = GenTime((int) pos().x(), m_fps);
return pos();
}
}
}
m_info.track = newTrack;
m_info.startPos = GenTime((int) newPos.x(), m_fps);
return newPos;
}
}
}
m_info.track = newTrack;
m_info.startPos = GenTime((int) newPos.x(), m_fps);
////qDebug()<<"// ITEM NEW POS: "<<newPos.x()<<", mapped: "<<mapToScene(newPos.x(), 0).x();
return newPos;
}
return QGraphicsItem::itemChange(change, value);
}
bool IGraphicsItem::onSceneEventFilter(QGraphicsItem *watched, QEvent *event)
{
auto *corner = dynamic_cast<CornerGrabber*>(watched);
if(!corner) return false;
auto *mevent = dynamic_cast<QGraphicsSceneMouseEvent*>(event);
if(!mevent) return false;
switch(event->type()) {
case QEvent::GraphicsSceneMousePress:
moving_ = true;
start_pos_ = mevent->scenePos();
setGrabbersState(true);
return true;
case QEvent::GraphicsSceneMouseRelease:
case QEvent::GraphicsSceneMouseMove:
break;
default:
return false;
}
if(!moving_) return true;
QPointF delta = mevent->scenePos() - start_pos_;
if(aspectRatioMode() == Qt::KeepAspectRatio) {
QSizeF s = size();
qreal grad = s.height() / s.width();
if(corner->iX() ^ corner->iY()) {
grad = -grad;
}
if((delta.y() > grad * delta.x()) ^ !corner->iY()) {
delta.setX(delta.y() / grad);
} else {
delta.setY(grad * delta.x());
}
}
QRectF rect = item_->boundingRect();
qreal x, y, w, h;
if(corner->iX() == 0) {
x = rect.x() + delta.x();
w = rect.width() - delta.x();
} else {
x = rect.x();
w = rect.width() + delta.x();
}
if(corner->iY() == 0) {
y = rect.y() + delta.y();
h = rect.height() - delta.y();
} else {
y = rect.y();
h = rect.height() + delta.y();
}
if(event->type() == QEvent::GraphicsSceneMouseRelease) {
moving_ = false;
setSize(QSize(w - 1, h - 1));
update();
setGrabbersState(false);
item_->setPos(item_->pos() + QPointF(x + 0.5, y + 0.5));
updatePos();
x = rect.x();
y = rect.y();
}
setGrabbersPosition(QRectF(x,y,w,h));
return true;
}
void QtViewportInteractionEngine::zoomToAreaGestureEnded(const QPointF& touchPoint, const QRectF& targetArea)
{
if (!targetArea.isValid())
return;
if (scrollAnimationActive() || scaleAnimationActive())
return;
m_hadUserInteraction = true;
const int margin = 10; // We want at least a little bit of margin.
QRectF endArea = itemRectFromCSS(targetArea.adjusted(-margin, -margin, margin, margin));
const QRectF viewportRect = m_viewport->boundingRect();
qreal targetCSSScale = viewportRect.size().width() / endArea.size().width();
qreal endCSSScale = innerBoundedCSSScale(qMin(targetCSSScale, qreal(2.5)));
qreal endItemScale = itemScaleFromCSS(endCSSScale);
qreal currentScale = m_content->contentsScale();
// We want to end up with the target area filling the whole width of the viewport (if possible),
// and centralized vertically where the user requested zoom. Thus our hotspot is the center of
// the targetArea x-wise and the requested zoom position, y-wise.
const QPointF hotspot = QPointF(endArea.center().x(), itemCoordFromCSS(touchPoint.y()));
const QPointF viewportHotspot = viewportRect.center();
QPointF endPosition = hotspot * endCSSScale - viewportHotspot;
QRectF endPosRange = computePosRangeForItemAtScale(endItemScale);
endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight());
QRectF endVisibleContentRect(endPosition / endItemScale, viewportRect.size() / endItemScale);
enum { ZoomIn, ZoomBack, ZoomOut, NoZoom } zoomAction = ZoomIn;
if (!m_scaleStack.isEmpty()) {
// Zoom back out if attempting to scale to the same current scale, or
// attempting to continue scaling out from the inner most level.
// Use fuzzy compare with a fixed error to be able to deal with largish differences due to pixel rounding.
if (fuzzyCompare(endItemScale, currentScale, 0.01)) {
// If moving the viewport would expose more of the targetRect and move at least 40 pixels, update position but do not scale out.
QRectF currentContentRect(m_viewport->contentPos() / currentScale, viewportRect.size() / currentScale);
QRectF targetIntersection = endVisibleContentRect.intersected(targetArea);
if (!currentContentRect.contains(targetIntersection) && (qAbs(endVisibleContentRect.top() - currentContentRect.top()) >= 40 || qAbs(endVisibleContentRect.left() - currentContentRect.left()) >= 40))
zoomAction = NoZoom;
else
zoomAction = ZoomBack;
} else if (fuzzyCompare(endItemScale, m_zoomOutScale, 0.01))
zoomAction = ZoomBack;
else if (endItemScale < currentScale)
zoomAction = ZoomOut;
}
switch (zoomAction) {
case ZoomIn:
m_scaleStack.append(ScaleStackItem(currentScale, m_viewport->contentPos().x()));
m_zoomOutScale = endItemScale;
break;
case ZoomBack: {
ScaleStackItem lastScale = m_scaleStack.takeLast();
endItemScale = lastScale.scale;
endCSSScale = cssScaleFromItem(lastScale.scale);
// Recalculate endPosition and bound it according to new scale.
endPosition.setY(hotspot.y() * endCSSScale - viewportHotspot.y());
endPosition.setX(lastScale.xPosition);
endPosRange = computePosRangeForItemAtScale(endItemScale);
endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight());
endVisibleContentRect = QRectF(endPosition / endItemScale, viewportRect.size() / endItemScale);
break;
}
case ZoomOut:
// Unstack all scale-levels deeper than the new level, so a zoom-back won't end up zooming in.
while (!m_scaleStack.isEmpty() && m_scaleStack.last().scale >= endItemScale)
m_scaleStack.removeLast();
m_zoomOutScale = endItemScale;
break;
case NoZoom:
break;
}
animateItemRectVisible(endVisibleContentRect);
}
QString getWhereClauseFromExtent(QString extent,QSqlDatabase db, QString table)
{
//(1.3333,32.1212321) (-4.12121,41.212121)
if (!extent.count(" ") == 1)
{
gbtLog(QObject::tr("Extent is invalid"));
return QString();
}
if (!extent.count(",") == 2)
{
gbtLog(QObject::tr("Extent is invalid"));
return QString();
}
if (!extent.count("(") == 2)
{
gbtLog(QObject::tr("Extent is invalid"));
return QString();
}
if (!extent.count(")") == 2)
{
gbtLog(QObject::tr("Extent is invalid"));
return QString();
}
int pos;
pos = extent.indexOf(" ");
QString from;
QString to;
from = extent.left(pos);
to = extent.mid(pos+1,extent.length()-pos+1);
from.replace("(","");
from.replace(")","");
to.replace("(","");
to.replace(")","");
//Get UpperLeft
QPointF dupperLeft;
pos = from.indexOf(",");
dupperLeft.setX(from.left(pos).toDouble());
dupperLeft.setY(from.mid(pos+1,from.length()-pos+1).toDouble());
//Get lower right
QPointF dlowerRight;
pos = to.indexOf(",");
dlowerRight.setX(to.left(pos).toDouble());
dlowerRight.setY(to.mid(pos+1,to.length()-pos+1).toDouble());
QSqlQuery qry(db);
QString sql;
double dbCellSize;
dbCellSize = 0.0;
sql = "SELECT cellSize FROM gbtconfig";
if (qry.exec(sql))
{
if (qry.first())
dbCellSize = qry.value(0).toDouble();
else
return QString();
}
else
return QString();
if (dbCellSize == 0.0)
return QString();
double xllCenter;
double yllCenter;
int NumberRows;
sql = "SELECT xllCenter,yllCenter,nrows FROM datasetinfo WHERE dataset_id = '" + table + "'";
if (qry.exec(sql))
{
if (qry.first())
{
xllCenter = qry.value(0).toDouble();
yllCenter = qry.value(1).toDouble();
NumberRows = qry.value(2).toInt();
}
else
return QString();
}
else
return QString();
QPoint upperLeft;
QPoint lowerRight;
int xpos;
int ypos;
if(dbCellSize != 0.0)
{
//Plots the bounds in the grid
upperLeft.setX(round( ( dupperLeft.x() - xllCenter )/dbCellSize ));
upperLeft.setY(NumberRows - round( ( dupperLeft.y() - yllCenter )/dbCellSize ) - 1);
QPointF UL;
UL = dupperLeft;
lowerRight.setX(round( ( dlowerRight.x() - xllCenter )/dbCellSize ));
lowerRight.setY(NumberRows - round( ( dlowerRight.y() - yllCenter )/dbCellSize ) - 1);
QPointF LR;
LR = dlowerRight;
//Plots the bounds in the GOBLET coordinate system
ypos = round((180/dbCellSize) - (fabs((-90 - yllCenter)/dbCellSize) + NumberRows)) + 1;
xpos = round(fabs((-180 - xllCenter)/dbCellSize))+1;
upperLeft.setX(xpos + upperLeft.x());
upperLeft.setY(ypos + upperLeft.y());
lowerRight.setX(xpos + lowerRight.x());
lowerRight.setY(ypos + lowerRight.y());
//Crete the where clause
QString idsuit;
idsuit = getStrValue(upperLeft.y()) + getStrValue(upperLeft.x());
QString where;
where = " TA.geokey BETWEEN '" + idsuit + "' AND ";
idsuit = getStrValue(lowerRight.y()) + getStrValue(lowerRight.x());
where = where + "'" + idsuit + "'";
return where;
}
return QString();
}
/**
* Update position the edge
*/
void GuiEdge::updatePosition (bool original_run)
{
GuiNode* pre = addGui (pred());
GuiNode* suc = addGui (succ());
edge_start_point_priv = mapFromItem( pre, pre->width()/2, pre->height()/2);
edge_end_point_priv = mapFromItem( suc, suc->width()/2, suc->height()/2);//!!!rarely it not work
if (pre == suc)//mesh edge
{
QPointF heigh (0, 2*pre->height());
QPointF middle (pre->pos().x() - 10, pre->pos().y() + pre->height()/2);
QPointF middleDirUp = middle + heigh;
QPointF middleDirDown = middle - heigh;
edge_start_dir_priv = edge_start_point_priv + heigh;
edge_end_dir_priv = edge_end_point_priv - heigh;
QPolygonF polygon = suc->polygon();
polygon.translate (suc->pos());
getIntersection (QLineF (edge_start_point_priv, edge_start_dir_priv), polygon, &edge_start_point_priv);
getIntersection (QLineF (edge_end_point_priv, edge_end_dir_priv), polygon, &edge_end_point_priv);
QPainterPath path;
path.moveTo (edge_start_point_priv);
path.cubicTo (edge_start_dir_priv, middleDirUp, middle);
path.cubicTo (middleDirDown, edge_end_dir_priv, edge_end_point_priv);
edge_curve_priv = path;
}
else
{
edge_valid_priv = true;
QPolygonF headPolygon = suc->polygon();
headPolygon.translate (suc->pos());
QPolygonF tailPolygon = pre->polygon();
tailPolygon.translate (pre->pos());
if (suc->real())
edge_valid_priv = edge_valid_priv && getIntersection (QLineF (edge_start_point_priv, edge_end_point_priv), headPolygon, &edge_end_point_priv) == QLineF::BoundedIntersection;
if (pre->real())
edge_valid_priv = edge_valid_priv && getIntersection (QLineF (edge_start_point_priv, edge_end_point_priv), tailPolygon, &edge_start_point_priv) == QLineF::BoundedIntersection;
QPointF delta = edge_start_point_priv - edge_end_point_priv;
delta.setX(0);
if (pre->real())
edge_start_dir_priv = (edge_start_point_priv + edge_end_point_priv)/2;
else
{
if (pre->firstPred() != 0)
edge_start_dir_priv = (suc->coor() - pre->firstPred()->pred()->coor())/8 + pre->coor();
else
edge_start_dir_priv = edge_start_point_priv - delta/2;
}
if (suc->real())
edge_end_dir_priv = (edge_start_point_priv + edge_end_point_priv)/2;
else
if (suc->firstSucc() != 0)
edge_end_dir_priv = (pre->coor() - suc->firstSucc()->succ()->coor())/8 + suc->coor();
else
edge_end_dir_priv = edge_end_point_priv + delta/2;
QPainterPath path;
path.moveTo (edge_start_point_priv);
path.cubicTo (edge_start_dir_priv, edge_end_dir_priv, edge_end_point_priv);
if (edge_valid_priv) edge_curve_priv = path;
}
edge_top_left_priv.setX( min< qreal>( edge_start_point_priv.x(), edge_end_point_priv.x()));
edge_top_left_priv.setY( min< qreal>( edge_start_point_priv.y(), edge_end_point_priv.y()));
edge_bottom_right_priv.setX( max< qreal>( edge_start_point_priv.x(), edge_end_point_priv.x()));
edge_bottom_right_priv.setY( max< qreal>( edge_start_point_priv.y(), edge_end_point_priv.y()));
if (original_run)
{
if (Edge::succ() && !addAux (Edge::succ())->real() && Edge::succ()->firstSucc())
addGui (Edge::succ()->firstSucc())->updatePosition (false);//avoidance sharp corners
if (Edge::pred() && !addAux (Edge::pred())->real() && Edge::pred()->firstPred())
addGui (Edge::pred()->firstPred())->updatePosition (false);//avoidance sharp corners
GuiEdge* i = this;
for (i; !i->startEdge(); i->pred()->firstPred() && (i = addGui (i->pred()->firstPred())));
i->updateLabels();
}
prepareGeometryChange();
}
//Most updated version
int calcExtendFromGrid(QString gridName,QSqlDatabase db, double &dbCellSize, double &xllCenter, double &yllCenter, int &ncols, int &nrows, int &bottom, int &left)
{
QSqlQuery qry(db);
QString sql;
dbCellSize = 0.0;
sql = "SELECT cellSize FROM gbtconfig";
if (qry.exec(sql))
{
if (qry.first())
dbCellSize = qry.value(0).toDouble();
else
return 1;
}
else
return 1;
sql = "SELECT xllcenter,yllcenter,ncols,nrows FROM datasetinfo WHERE dataset_id = '" + gridName + "' and dataset_type = 1";
if (qry.exec(sql))
{
if (qry.first())
{
xllCenter = qry.value(0).toDouble();
yllCenter = qry.value(1).toDouble() - 0.0200;
ncols = qry.value(2).toInt();
nrows = qry.value(3).toInt();
}
else
return 1;
}
else
return 1;
int xpos;
int ypos;
ypos = round((180/dbCellSize) - (fabs((-90 - yllCenter)/dbCellSize) + nrows)) + 1;
xpos = round(fabs((-180 - xllCenter)/dbCellSize))+1;
sql = "SELECT max(xpos),max(ypos),min(xpos),min(ypos) FROM " + gridName;
if (qry.exec(sql))
{
if (qry.first())
{
//double utx;
//double uty;
//utx = ((qry.value(0).toInt() - xpos) * dbCellSize) + xllCenter;
//uty = (((((qry.value(1).toInt() - ypos) + 1) - nrows) * dbCellSize) - yllCenter) * -1;
double ltx;
double lty;
ltx = ((qry.value(2).toInt() - xpos) * dbCellSize) + xllCenter;
lty = (((((qry.value(3).toInt() - ypos) + 1) - nrows) * dbCellSize) - yllCenter) * -1;
QPointF UL;
UL.setX(ltx);
UL.setY(lty);
left = ceil((UL.x() + 180) / dbCellSize);
bottom = ceil((90 - UL.y()) / dbCellSize);
return 0;
}
else
return 1;
}
else
return 1;
}
void QAbstractKineticScrollerPrivate::handleMove(QMouseEvent *me, QPoint &delta)
{
Q_Q(QAbstractKineticScroller);
if (mode == QAbstractKineticScroller::AccelerationMode) {
// we need delta to be the delta to ipos, not pos in this case
delta = me->globalPos() - ipos;
}
if (axisLockThreshold) {
int dx = qAbs(delta.x());
int dy = qAbs(delta.y());
if (dx || dy) {
bool vertical = (dy > dx);
qreal alpha = qreal(vertical ? dx : dy) / qreal(vertical ? dy : dx);
qKSDebug() << "axis lock: " << alpha << " / " << axisLockThreshold << " - isvertical: " << vertical << " - dx: " << dx << " - dy: " << dy;
if (alpha <= axisLockThreshold) {
if (vertical)
delta.setX(0);
else
delta.setY(0);
}
}
}
switch (mode) {
case QAbstractKineticScroller::PushMode:
// Scroll by the amount of pixels the cursor has moved
// since the last motion event.
scrollUpdate(delta);
pos = me->globalPos();
break;
case QAbstractKineticScroller::AccelerationMode: {
// Set acceleration relative to the initial click
QSize size = q->viewportSize();
qreal signX = 0, signY = 0;
if (delta.x() < 0)
signX = -1;
else if (delta.x() > 0)
signX = 1;
if (delta.y() < 0)
signY = -1;
else if (delta.y() > 0)
signY = 1;
velocity.setX(signX * ((qreal(qAbs(delta.x())) / qreal(size.width()) * (maxVelocity - minVelocity)) + minVelocity));
velocity.setY(signY * ((qreal(qAbs(delta.y())) / qreal(size.height()) * (maxVelocity - minVelocity)) + minVelocity));
break;
}
case QAbstractKineticScroller::AutoMode:
QPointF newVelocity = calculateVelocity(delta, lastTime.elapsed());
QPoint maxPos = q->maximumScrollPosition();
bool alwaysOvershoot = (overshootPolicy == QAbstractKineticScroller::OvershootAlwaysOn);
if (!maxPos.x() && !alwaysOvershoot) {
delta.setX(0);
newVelocity.setX(0);
}
if (!maxPos.y() && !alwaysOvershoot) {
delta.setY(0);
newVelocity.setY(0);
}
velocity = newVelocity;
scrollUpdate(delta);
if (maxPos.x() || alwaysOvershoot)
pos.setX(me->globalPos().x());
if (maxPos.y() || alwaysOvershoot)
pos.setY(me->globalPos().y());
break;
}
}
void PageViewportControllerClientQt::zoomToAreaGestureEnded(const QPointF& touchPoint, const QRectF& targetArea)
{
// This can only happen as a result of a user interaction.
ASSERT(m_controller->hadUserInteraction());
if (!targetArea.isValid())
return;
if (m_scrollChange.inProgress() || m_scaleChange.inProgress())
return;
const float margin = 10; // We want at least a little bit of margin.
QRectF endArea = targetArea.adjusted(-margin, -margin, margin, margin);
const QRectF viewportRect = m_viewportItem->boundingRect();
qreal minViewportScale = qreal(2.5);
qreal targetScale = viewportRect.size().width() / endArea.size().width();
targetScale = m_controller->innerBoundedViewportScale(qMin(minViewportScale, targetScale));
qreal currentScale = m_pageItem->contentsScale();
// We want to end up with the target area filling the whole width of the viewport (if possible),
// and centralized vertically where the user requested zoom. Thus our hotspot is the center of
// the targetArea x-wise and the requested zoom position, y-wise.
const QPointF hotspot = QPointF(endArea.center().x(), touchPoint.y());
const QPointF viewportHotspot = viewportRect.center();
QPointF endPosition = hotspot - viewportHotspot / targetScale;
endPosition = m_controller->clampViewportToContents(endPosition, targetScale);
QRectF endVisibleContentRect(endPosition, viewportRect.size() / targetScale);
enum { ZoomIn, ZoomBack, ZoomOut, NoZoom } zoomAction = ZoomIn;
// Zoom back out if attempting to scale to the same current scale, or
// attempting to continue scaling out from the inner most level.
// Use fuzzy compare with a fixed error to be able to deal with largish differences due to pixel rounding.
if (!m_scaleStack.isEmpty() && fuzzyCompare(targetScale, currentScale, 0.01)) {
// If moving the viewport would expose more of the targetRect and move at least 40 pixels, update position but do not scale out.
QRectF currentContentRect(m_viewportItem->mapRectToWebContent(viewportRect));
QRectF targetIntersection = endVisibleContentRect.intersected(targetArea);
if (!currentContentRect.contains(targetIntersection)
&& (qAbs(endVisibleContentRect.top() - currentContentRect.top()) >= 40
|| qAbs(endVisibleContentRect.left() - currentContentRect.left()) >= 40))
zoomAction = NoZoom;
else
zoomAction = ZoomBack;
} else if (fuzzyCompare(targetScale, m_zoomOutScale, 0.01))
zoomAction = ZoomBack;
else if (targetScale < currentScale)
zoomAction = ZoomOut;
switch (zoomAction) {
case ZoomIn:
m_scaleStack.append(ScaleStackItem(currentScale, m_viewportItem->contentPos().x() / currentScale));
m_zoomOutScale = targetScale;
break;
case ZoomBack: {
if (m_scaleStack.isEmpty()) {
targetScale = m_controller->minimumContentsScale();
endPosition.setY(hotspot.y() - viewportHotspot.y() / targetScale);
endPosition.setX(0);
m_zoomOutScale = 0;
} else {
ScaleStackItem lastScale = m_scaleStack.takeLast();
targetScale = lastScale.scale;
// Recalculate endPosition and clamp it according to the new scale.
endPosition.setY(hotspot.y() - viewportHotspot.y() / targetScale);
endPosition.setX(lastScale.xPosition);
}
endPosition = m_controller->clampViewportToContents(endPosition, targetScale);
endVisibleContentRect = QRectF(endPosition, viewportRect.size() / targetScale);
break;
}
case ZoomOut:
// Unstack all scale-levels deeper than the new level, so a zoom-back won't end up zooming in.
while (!m_scaleStack.isEmpty() && m_scaleStack.last().scale >= targetScale)
m_scaleStack.removeLast();
m_zoomOutScale = targetScale;
break;
case NoZoom:
break;
}
animateContentRectVisible(endVisibleContentRect);
}
void FieldView::drawRobot(QPainter& painter, bool blueRobot, int ID,
QPointF pos, float theta, bool hasBall, bool faulty) {
painter.setPen(Qt::NoPen);
painter.setBrush(Qt::NoBrush);
painter.save();
painter.translate(pos.x(), pos.y());
if (faulty) {
painter.save();
painter.setPen(redPen);
painter.setBrush(QBrush{Qt::red, Qt::SolidPattern});
auto r = Robot_Radius + 0.025;
painter.drawEllipse(QPointF(0, 0), r, r);
painter.restore();
}
if (blueRobot) {
painter.setPen(bluePen);
painter.setBrush(Qt::blue);
} else {
painter.setPen(yellowPen);
painter.setBrush(Qt::yellow);
}
painter.rotate(RadiansToDegrees(theta) + 90);
int span = 40;
int start = span * 16 + 90 * 16;
int end = 360 * 16 - (span * 2) * 16;
const float r = Robot_Radius;
painter.drawChord(QRectF(-r, -r, r * 2, r * 2), start, end);
if (showDotPatterns) {
painter.setPen(Qt::NoPen);
for (int i = 0; i < 4; i++) {
painter.setBrush(QBrush(Dot_Pattern_Colors[ID][i]));
QPointF center;
center.setX((i >= 2) ? Dots_Small_Offset : Dots_Large_Offset);
center.setX(center.x() * ((i == 1 || i == 2) ? -1 : 1));
center.setY((i <= 1) ? Dots_Small_Offset : Dots_Large_Offset);
center.setY(center.y() * ((i <= 1) ? -1 : 1));
painter.drawEllipse(center, Dots_Radius, Dots_Radius);
}
}
if (hasBall) {
painter.setPen(redPen);
const float r = Robot_Radius * 0.75f;
painter.drawChord(QRectF(-r, -r, r * 2, r * 2), start, end);
}
painter.restore();
// draw shell number
painter.save();
painter.translate(pos.x(), pos.y());
if (blueRobot) {
painter.setPen(whitePen);
} else {
painter.setPen(blackPen);
}
drawText(painter, QPointF(), QString::number(ID));
painter.restore();
}
void PolarGrid::drawGrid( PaintContext* context )
{
// if ( d->coordinateTransformations.size () <= 0 ) return;
PolarCoordinatePlane* plane = dynamic_cast<PolarCoordinatePlane*>(context->coordinatePlane());
Q_ASSERT_X ( plane, "PolarGrid::drawGrid",
"Bad function call: PaintContext::coodinatePlane() NOT a polar plane." );
const GridAttributes gridAttrsCircular( plane->gridAttributes( true ) );
const GridAttributes gridAttrsSagittal( plane->gridAttributes( false ) );
//qDebug() << "OK:";
if ( !gridAttrsCircular.isGridVisible() && !gridAttrsSagittal.isGridVisible() ) return;
//qDebug() << "A";
// FIXME: we paint the rulers to the settings of the first diagram for now:
AbstractPolarDiagram* dgr = dynamic_cast<AbstractPolarDiagram*> (plane->diagrams().first() );
Q_ASSERT ( dgr ); // only polar diagrams are allowed here
// Do not draw a grid for pie diagrams
if( dynamic_cast<PieDiagram*> (plane->diagrams().first() ) ) return;
context->painter()->setPen ( PrintingParameters::scalePen( QColor ( Qt::lightGray ) ) );
const double min = dgr->dataBoundaries().first.y();
QPointF origin = plane->translate( QPointF( min, 0 ) ) + context->rectangle().topLeft();
//qDebug() << "origin" << origin;
const double r = qAbs( min ) + dgr->dataBoundaries().second.y(); // use the full extents
if ( gridAttrsSagittal.isGridVisible() ){
const int numberOfSpokes = ( int ) ( 360 / plane->angleUnit() );
for ( int i = 0; i < numberOfSpokes ; ++i ) {
context->painter()->drawLine( origin, plane->translate( QPointF( r - qAbs( min ), i ) ) + context->rectangle().topLeft() );
}
}
if ( gridAttrsCircular.isGridVisible() )
{
const qreal startPos = plane->startPosition();
plane->setStartPosition( 0.0 );
const int numberOfGridRings = ( int )dgr->numberOfGridRings();
for ( int j = 0; j < numberOfGridRings; ++j ) {
const double rad = min - ( ( j + 1) * r / numberOfGridRings );
if ( rad == 0 )
continue;
QRectF rect;
QPointF topLeftPoint;
QPointF bottomRightPoint;
topLeftPoint = plane->translate( QPointF( rad, 0 ) );
topLeftPoint.setX( plane->translate( QPointF( rad, 90 / plane->angleUnit() ) ).x() );
bottomRightPoint = plane->translate( QPointF( rad, 180 / plane->angleUnit() ) );
bottomRightPoint.setX( plane->translate( QPointF( rad, 270 / plane->angleUnit() ) ).x() );
rect.setTopLeft( topLeftPoint + context->rectangle().topLeft() );
rect.setBottomRight( bottomRightPoint + context->rectangle().topLeft() );
context->painter()->drawEllipse( rect );
}
plane->setStartPosition( startPos );
}
}
NonPdfFrameHandle::NonPdfFrameHandle (QGraphicsScene &scene,
QGraphicsView &view,
const QPointF &pointReference,
int orientationFlags,
NonPdfCropping &nonPdfCropping,
int zValue) :
m_nonPdfCropping (nonPdfCropping),
m_orientationFlags (orientationFlags),
m_disableEventsWhileMovingAutomatically (false),
m_scene (scene),
m_view (view)
{
const double SUBTLE_OPACITY = 0.2;
// Advantages of using ItemIgnoresTransformations:
// 1) handles do not get bigger or smaller depending on the size of the image
// 2) handles never get ugly when zoomed in
// 3) handles never get too tiny when zoomed out
// Disadvantages of using ItemIgnoresTransformation:
// 1) Resizing the preview window with ItemIgnoresTransformations moves the handles out of position
// 2) More conversions back and forth between untransformed and transformed coordinates. This was the deal breaker since
// the transformations were undocumented and ultimately too difficult
// The solution is to have constant-size handles WITHOUT ItemIgnoresTransformations. This means resizing the window
// also involves resizing the handles, but everything else is pretty easy
//
// ItemIgnoresTransformations flag must agree with the QGraphicsRectItem used for the frame box by PdfCropping
setFlags (QGraphicsItem::ItemIsMovable |
QGraphicsItem::ItemIsSelectable |
QGraphicsItem::ItemSendsScenePositionChanges);
// Fill with nice color for better visibility. Note that the pen is disabled by overriding the paint method
setBrush (QBrush (Qt::blue));
setVisible (true);
setZValue (zValue);
setOpacity (SUBTLE_OPACITY);
setPos (pointReference); // Point position is handled in scene/view coordinates
// Add to scene
scene.addItem (this);
QSize handleSize = m_nonPdfCropping.windowSize() / HANDLE_SIZE_AS_FRACTION_OF_WINDOW_SIZE;
// Adjust positions of handles that are not at the top left so handles are laid out symmetrically
QPointF pointPos = pointReference;
if ((orientationFlags & NonPdfCropping::NON_PDF_CROPPING_LEFT) != 0) {
pointPos.setX (pointPos.x() - handleSize.width() / 2.0);
} else if ((orientationFlags & NonPdfCropping::NON_PDF_CROPPING_RIGHT) != 0) {
pointPos.setX (pointPos.x() + handleSize.width() / 2.0);
}
if ((orientationFlags & NonPdfCropping::NON_PDF_CROPPING_TOP) != 0) {
pointPos.setY (pointPos.y() - handleSize.height() / 2.0);
} else if ((orientationFlags & NonPdfCropping::NON_PDF_CROPPING_BOTTOM) != 0) {
pointPos.setY (pointPos.y() + handleSize.height() / 2.0);
}
// Start with geometry. Since point positions are handled in scene/view coordinates, we have to convert
// to local coordinates for the rectangle
QPointF topLeftLocal = mapFromScene (pointPos);
setRect (QRectF (topLeftLocal,
handleSize));
}
// Update the painter path
void GLEEllipse::updateEllipse()
{
QPointF p;
QPair<QPointF,int> snap;
double angle;
// Only do this if both the centre and radius have been set
if (isSet(CentrePoint) && isSet(RadiusX) && isSet(RadiusY) && isSet(Angle))
{
// This is guaranteed to have been created in the constructor
// of GLEDrawingObject
delete(paintPath);
// Create a new path starting at ellipseCentre
paintPath = new QPainterPath(getQtPoint(CentrePoint));
// Add the ellipse based on the qrect
// This needs to be modified to suit the angle!
// CHECK: I think we only use this for bounding boxes,
// so just make a rectangle of the bounding box
angle = getGLEAngle(Angle);
// Get the bounding box of the ellipse
QRectF rect;
rect.setTopLeft(getQtPoint(BBoxCornerA));
rect.setBottomRight(getQtPoint(BBoxCornerB));
paintPath->addRect(rect);
// Update GLE object
GLEEllipseDO* ellipse = (GLEEllipseDO*)getGLEObject();
if (ellipse != NULL) {
ellipse->setCenter(QGLE::QPointFToGLEPoint(getGLEPoint(CentrePoint)));
ellipse->setRadiusX(getGLELength(RadiusX));
ellipse->setRadiusY(getGLELength(RadiusY));
}
// Update the calculated equation parameters
updateEquationParameters();
// Now we add the osnap handles
osnapHandles.clear();
p.setX(getQtLength(RadiusX)*cos(M_PI-angle));
p.setY(getQtLength(RadiusX)*sin(M_PI-angle));
p += getQtPoint(CentrePoint);
snap.first = p;
snap.second = QGLE::QuadrantSnap;
osnapHandles.append(snap);
p.setX(-getQtLength(RadiusX)*cos(M_PI-angle));
p.setY(-getQtLength(RadiusX)*sin(M_PI-angle));
p += getQtPoint(CentrePoint);
snap.first = p;
snap.second = QGLE::QuadrantSnap;
osnapHandles.append(snap);
p.setX(-getQtLength(RadiusY)*sin(angle));
p.setY(-getQtLength(RadiusY)*cos(angle));
p += getQtPoint(CentrePoint);
snap.first = p;
snap.second = QGLE::QuadrantSnap;
osnapHandles.append(snap);
p.setX(getQtLength(RadiusY)*sin(angle));
p.setY(getQtLength(RadiusY)*cos(angle));
p += getQtPoint(CentrePoint);
snap.first = p;
snap.second = QGLE::QuadrantSnap;
osnapHandles.append(snap);
snap.first = getQtPoint(CentrePoint);
snap.second = QGLE::CentreSnap;
osnapHandles.append(snap);
}
}
/**
Internal method that draws the surface of one of the pies in a pie chart.
\param painter the QPainter to draw in
\param dataset the dataset to draw the pie for
\param pie the pie to draw
*/
void PieDiagram::drawPieSurface( QPainter* painter,
DataValueTextInfoList* list,
uint dataset, uint pie,
qreal granularity )
{
// Is there anything to draw at all?
qreal angleLen = d->angleLens[ pie ];
if ( angleLen ) {
qreal startAngle = d->startAngles[ pie ];
QModelIndex index( model()->index( 0, pie, rootIndex() ) );
const PieAttributes attrs( pieAttributes( index ) );
const ThreeDPieAttributes threeDAttrs( threeDPieAttributes( index ) );
QRectF drawPosition = piePosition( dataset, pie );
painter->setRenderHint ( QPainter::Antialiasing );
QBrush br = brush( index );
if( threeDAttrs.isEnabled() ) {
br = threeDAttrs.threeDBrush( br, drawPosition );
}
painter->setBrush( br );
painter->setPen( pen( index ) );
if ( angleLen == 360 ) {
// full circle, avoid nasty line in the middle
painter->drawEllipse( drawPosition );
//Add polygon to Reverse mapper for showing tool tips.
QPolygonF poly( drawPosition );
d->reverseMapper.addPolygon( index.row(), index.column(), poly );
} else {
// draw the top of this piece
// Start with getting the points for the arc.
const int arcPoints = static_cast<int>(trunc( angleLen / granularity ));
QPolygonF poly( arcPoints+2 );
qreal degree=0.0;
int iPoint = 0;
bool perfectMatch = false;
while ( degree <= angleLen ){
poly[ iPoint ] = pointOnCircle( drawPosition, startAngle + degree );
//qDebug() << degree << angleLen << poly[ iPoint ];
perfectMatch = (degree == angleLen);
degree += granularity;
++iPoint;
}
// if necessary add one more point to fill the last small gap
if( ! perfectMatch ){
poly[ iPoint ] = pointOnCircle( drawPosition, startAngle + angleLen );
// add the center point of the piece
poly.append( drawPosition.center() );
}else{
poly[ iPoint ] = drawPosition.center();
}
//find the value and paint it
//fix value position
d->reverseMapper.addPolygon( index.row(), index.column(), poly );
painter->drawPolygon( poly );
}
// the new code is setting the needed position points according to the slice:
// all is calculated as if the slice were 'standing' on it's tip and the border
// were on top, so North is the middle of the curved outside line and South is the tip
//
const qreal sum = valueTotals();
const QPointF south = drawPosition.center();
const QPointF southEast = south;
const QPointF southWest = south;
const QPointF north = pointOnCircle( drawPosition, startAngle + angleLen/2.0 );
const QPointF northEast = pointOnCircle( drawPosition, startAngle );
const QPointF northWest = pointOnCircle( drawPosition, startAngle + angleLen );
QPointF center = (south + north) / 2.0;
const QPointF east = (south + northEast) / 2.0;
const QPointF west = (south + northWest) / 2.0;
CartesianDiagramDataCompressor::DataValueAttributesList allAttrs( d->aggregatedAttrs( this, index, 0 ) );
const QFontMetrics * fm = (d->cachedFontMetrics( allAttrs.value(index).textAttributes().calculatedFont(d->plane,KDChartEnums::MeasureOrientationMinimum ), this ));
if(!list->isEmpty())
{
QRect textRect = fm->boundingRect(QString::number(list->last().value));
textRect.translated(center.toPoint());
QPoint textRectCenter = textRect.center();
qreal newX = center.x() - textRectCenter.x();
qreal newY = center.y() - textRectCenter.y();
center.setX(newX);
center.setY(newY);
}
PositionPoints points( center, northWest, north, northEast, east, southEast, south, southWest, west);
qreal topAngle = startAngle - 90;
if( topAngle < 0.0 )
topAngle += 360;
points.setDegrees(KDChartEnums::PositionEast, topAngle);
points.setDegrees(KDChartEnums::PositionNorthEast, topAngle);
points.setDegrees(KDChartEnums::PositionWest, topAngle + angleLen);
points.setDegrees(KDChartEnums::PositionNorthWest, topAngle + angleLen);
points.setDegrees(KDChartEnums::PositionCenter, topAngle + angleLen/2.0);
points.setDegrees(KDChartEnums::PositionNorth, topAngle + angleLen/2.0);
//painter->drawText(points.mPositionCenter,QLatin1String("P"));
d->appendDataValueTextInfoToList(
this, *list, index, 0,
points, Position::Center, Position::Center,
angleLen*sum / 360 );
// The following, old code (since kdc 2.0.0) was not correct:
// Settings made for the position had been totally ignored,
// AND the center was NOT the center - except for pieces of 45 degrees size
//
// QLineF centerLine( drawPosition.center(),
// QPointF( (poly[ last - 2].x() + poly.first().x())/2,
// ( poly.first().y() + poly[last-2].y() )/2 ) );
// QPointF valuePos( ( centerLine.x1() + centerLine.x2() )/2,
// ( centerLine.y1() + centerLine.y2() )/2 ) ;
//
// paintDataValueText( painter, index, valuePos, angleLen*sum / 360 );
}
}
