/*! With this function you can set the skin that will be displayed in the widget. \code QtScrollDial * scroll = new QtScrollDial(this); scroll->setSkin("Beryl"); \endcode This function has to be called before using the QtScrollDial. \sa skin() */ void QtScrollDial::setSkin(const QString& skin) { m_skin = skin; const QString base = ":/scrolldial/" + skin + '/'; if(m_popup != NULL) m_popup->setSkin(skin); m_label->setStyleSheet("color: white; border-width: 2px;" "border-image: url(" + base + "label.svg);"); // set to null pictures m_background = QPicture(); m_hoverBackground = QPicture(); QSvgRenderer renderer; QPainter painter; if (renderer.load(base + "background.svg")) { painter.begin(&m_background); renderer.render(&painter, QRectF(0.0, 0.0, 1.0, 1.0)); painter.end(); } if (renderer.load(base + "background_hover.svg")) { painter.begin(&m_hoverBackground); renderer.render(&painter, QRectF(0.0, 0.0, 1.0, 1.0)); painter.end(); } // update geometry for new sizeHint and repaint updateGeometry(); update(); }
bool QSvgIOHandlerPrivate::load(QIODevice *device) { if (loaded) return true; if (q->format().isEmpty()) q->canRead(); // # The SVG renderer doesn't handle trailing, unrelated data, so we must // assume that all available data in the device is to be read. bool res = false; QBuffer *buf = qobject_cast<QBuffer *>(device); if (buf) { const QByteArray &ba = buf->data(); res = r.load(QByteArray::fromRawData(ba.constData() + buf->pos(), ba.size() - buf->pos())); buf->seek(ba.size()); } else if (q->format() == "svgz") { res = r.load(device->readAll()); } else { xmlReader.setDevice(device); res = r.load(&xmlReader); } if (res) { defaultSize = QSize(r.viewBox().width(), r.viewBox().height()); loaded = true; } return loaded; }
bool GoTableWidget::buildPixmaps(int diameter) { QSvgRenderer svgR; delete blackStonePixmap; blackStonePixmap = new QPixmap(diameter, diameter); blackStonePixmap->fill(Qt::transparent); svgR.load(QString(":/resources/cursorBlack.svg")); QPainter bPainter(blackStonePixmap); svgR.render(&bPainter); delete blackCursor; blackCursor = new QCursor(*blackStonePixmap); delete whiteStonePixmap; whiteStonePixmap = new QPixmap(diameter, diameter); whiteStonePixmap->fill(QColor(0, 0, 0, 0)); svgR.load(QString(":/resources/cursorWhite.svg")); QPainter wPainter(whiteStonePixmap); svgR.render(&wPainter); delete whiteCursor; whiteCursor = new QCursor(*whiteStonePixmap); delete redStonePixmap; redStonePixmap = new QPixmap(diameter, diameter); redStonePixmap->fill(QColor(0, 0, 0, 0)); svgR.load(QString(":/resources/cursorRed.svg")); QPainter rPainter(redStonePixmap); svgR.render(&rPainter); delete redCursor; redCursor = new QCursor(*redStonePixmap); return true; }
qreal PdfElementImage::paint(QPainter *painter) { qreal x = toQReal(_attributes.value("x", "0")); qreal y = toQReal(_attributes.value("y", "0")) + _offsetY; qreal w = toQReal(_attributes.value("width", "0")); qreal h = toQReal(_attributes.value("height", "0")); if (w > 0 && h > 0) { painter->setPen(Qt::NoPen); painter->setBrush(Qt::NoBrush); QRectF box(QPointF(x, y), QSizeF(w, h)); QImage picture; // Get the variable defined in the attribute "file" QString var = _attributes.value("file", ""); bool drawn = FALSE; // No variable found, the attribute "file" might point to an imagefile if (_variables->value(var, "").isEmpty()) { // Load the image (or default image) and print it QList<QString> images = replaceVariables(var); QString img; for (int i = 0; i < images.size(); i++) { img = QString("/").prepend(_templatePath).append(images.at(i)); if (picture.load(img)) { painter->drawImage( box, picture, QRectF(picture.rect()) ); drawn = TRUE; break; } } } else { // if an attribute exists with the addition "_file" the string in the attribute should be iinterpreted as a file, otherwise as SVG-Content bool imageIsFile = _variables->contains(var) && !_variables->value(var.append("_file"), "").isEmpty(); // Try to render a normal pixel image or as an SVG Image / Content QSvgRenderer svg; if (imageIsFile && picture.load(_variables->value(var))) { painter->drawImage( box, picture, QRectF(picture.rect()) ); drawn = TRUE; } else if ( (imageIsFile && svg.load( _variables->value(var) )) || (!imageIsFile && svg.load( _variables->value(var).toUtf8() )) ) { svg.render(painter, box); drawn = TRUE; } } // If the Image isn't drawn, show the default one if (!drawn) { showDefaultImage(painter, box); } } return bottom(); }
QPixmap SCPageLayout::thumbnail() const { static KIconLoader * loader = KIconLoader::global(); QSvgRenderer renderer; QSize size(80, 60); QPixmap pic(size); pic.fill(); QPainter p(&pic); QString file = loader->iconPath("layout-elements", KIconLoader::User); if (renderer.load(file)) { QList<SCPlaceholder *>::const_iterator it(m_placeholders.begin()); for (; it != m_placeholders.end(); ++it) { kDebug(33001) << "-----------------" <<(*it)->presentationObject() << (*it)->rect(size); renderer.render(&p, (*it)->presentationObject(), (*it)->rect(size)); } } else { kWarning(33001) << "could not load" << file; } return pic; }
void KWaitedPlayerSetupDialog::fillWaitedPlayersCombo() { kDebug() << "Filling nations combo" << endl; QList<PlayerMatrix>::iterator it, it_end; it = m_automaton->game()->waitedPlayers().begin(); it_end = m_automaton->game()->waitedPlayers().end(); for (; it != it_end; it++) { kDebug() << "Adding waited player " << (*it).name << endl; QString imgName = m_automaton->game()->theWorld()->nationNamed((*it).nation)->flagFileName(); // load image QPixmap flag; QSize size(flag.width()/Sprites::SkinSpritesData::single().intData("flag-frames"),flag.height()); QImage image(size, QImage::Format_ARGB32_Premultiplied); image.fill(0); QPainter p(&image); QSvgRenderer renderer; renderer.load(imgName); renderer.render(&p/*, svgid*/); QPixmap allpm = QPixmap::fromImage(image); flag = allpm.copy(0, 0, size.width(), size.height()); // get name QString name = (*it).name; name += QString(" ("); name += (i18n((*it).nation.toUtf8().data())); name += QString(")"); // fill a combo entry waitedPlayersCombo->addItem(QIcon(flag),name); } }
bool SvgRenderer::load(const QString &filename) { if (renderer.load(filename) && renderer.isValid()) return true; return false; }
void QgsLayoutItemPolyline::drawSvgMarker( QPainter *p, QPointF point, double angle, const QString &markerPath, double height ) const { // translate angle from ccw from axis to cw from north angle = 90 - angle; if ( mArrowHeadWidth <= 0 || height <= 0 ) { //bad image size return; } if ( markerPath.isEmpty() ) return; QSvgRenderer r; const QByteArray &svgContent = QgsApplication::svgCache()->svgContent( markerPath, mArrowHeadWidth, mArrowHeadFillColor, mArrowHeadStrokeColor, mArrowHeadStrokeWidth, 1.0 ); r.load( svgContent ); p->save(); p->translate( point.x(), point.y() ); p->rotate( angle ); p->translate( -mArrowHeadWidth / 2.0, -height / 2.0 ); r.render( p, QRectF( 0, 0, mArrowHeadWidth, height ) ); p->restore(); }
void B9Edit::importSlicesFromSvg(QString file, double pixelsizemicrons) { int layers = 0; double xsizemm = 0.0; double ysizemm = 0.0; double x = 0; double y = 0; bool inverted = false; QSvgRenderer SvgRender; if(!SvgRender.load(file)) { QMessageBox msgBox; msgBox.setText("Unable to import SVG file."); msgBox.exec(); return; } if(!SvgRender.elementExists("layer0")) { QMessageBox msgBox; msgBox.setText("SVG file does not contain compatible layer information\nUnable to import."); msgBox.exec(); return; } //do a quick search for the word "slic3r:type="contour"" and then the following "style="fill:" //to figure out whether the image is inverted or not. QString buff = ""; QFile searchfile(file); searchfile.open(QIODevice::ReadOnly); QTextStream searchstream(&searchfile); while(buff != "slic3r:type=\"contour\"" && !searchstream.atEnd()) { searchstream >> buff; } if(!searchstream.atEnd())//we must have found it. { while(buff != "style=\"fill:" && !searchstream.atEnd()) { searchstream >> buff; } if(!searchstream.atEnd()) { searchstream >> buff; if(buff == "white\"") { inverted = false; } else { inverted = true; } } else {
bool QSvgIOHandlerPrivate::load(QIODevice *device) { if (loaded) return true; if (r->load(device->readAll())) { defaultSize = QSize(r->viewBox().width(), r->viewBox().height()); if (currentSize.isEmpty()) currentSize = defaultSize; } loaded = r->isValid(); return loaded; }
QImage SvgElementProvider::requestImage(const QString& id, QSize* size, const QSize& requestedSize) { // Resolve URL QUrl url = QUrl(id); if (url.isRelative() && !mBaseUrl.isEmpty()) url = mBaseUrl.resolved(url); if (!url.isValid()) return placeholder(QString("Invalid URL\nBase: %1\nInput: %2").arg(mBaseUrl.toString()).arg(id), requestedSize); // Make a filename from the given URL QString imagepath = QQmlFile::urlToLocalFileOrQrc(url); // Fragment is used to specify SVG element QString elementId = url.fragment(); // Load image QSvgRenderer renderer; if (!renderer.load(imagepath)) { qWarning() << "Unable to load image:" << imagepath; return placeholder(QStringLiteral("Unable to load image:\n") + imagepath, requestedSize); } // Check whether requested element exists if (!elementId.isEmpty() && !renderer.elementExists(elementId)) return placeholder(QStringLiteral("Unable to find element:\n") + elementId + "\nin image:\n" + imagepath, requestedSize); // Get image or element size QSize itemSize = elementId.isEmpty() ? renderer.defaultSize() : renderer.boundsOnElement(elementId).size().toSize(); if (size) *size = itemSize; // Create image QImage image(requestedSize.width() > 0 ? requestedSize.width() : itemSize.width(), requestedSize.height() > 0 ? requestedSize.height() : itemSize.height(), QImage::Format_ARGB32_Premultiplied); image.fill(Qt::transparent); // Paint svg or element QPainter p(&image); if (elementId.isEmpty()) renderer.render(&p); else renderer.render(&p, elementId); return image; }
/* * Initialize the widget */ GpsConstellationWidget::GpsConstellationWidget(QWidget *parent) : QGraphicsView(parent) { // Create a layout, add a QGraphicsView and put the SVG inside. // The constellation widget looks like this: // |--------------------| // | | // | | // | Constellation | // | | // | | // | | // |--------------------| setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); QSvgRenderer *renderer = new QSvgRenderer(); renderer->load(QString(":/gpsgadget/images/gpsEarth.svg")); world = new QGraphicsSvgItem(); world->setSharedRenderer(renderer); world->setElementId("map"); scene = new QGraphicsScene(this); scene->addItem(world); scene->setSceneRect(world->boundingRect()); setScene(scene); QFontDatabase::addApplicationFont(":/gpsgadget/font/digital-7_mono.ttf"); // Now create 'maxSatellites' satellite icons which we will move around on the map: for (int i = 0; i < MAX_SATTELITES; i++) { satellites[i][0] = 0; satellites[i][1] = 0; satellites[i][2] = 0; satellites[i][3] = 0; satIcons[i] = new QGraphicsSvgItem(world); satIcons[i]->setSharedRenderer(renderer); satIcons[i]->setElementId("sat-notSeen"); satIcons[i]->hide(); satTexts[i] = new QGraphicsSimpleTextItem("##", satIcons[i]); satTexts[i]->setBrush(QColor("Black")); satTexts[i]->setFont(QFont("Digital-7")); } }
void QgsLayoutItemPolyline::setEndSvgMarkerPath( const QString &path ) { QSvgRenderer r; mEndMarkerFile = path; if ( path.isEmpty() || !r.load( path ) ) { mEndArrowHeadHeight = 0; } else { //calculate mArrowHeadHeight from svg file and mArrowHeadWidth QRect viewBox = r.viewBox(); mEndArrowHeadHeight = mArrowHeadWidth / viewBox.width() * viewBox.height(); } updateBoundingRect(); }
SelectionPage::SelectionPage(SetupWizard *wizard, QString shapeFile, QWidget *parent) : AbstractWizardPage(wizard, parent), Selection(), ui(new Ui::SelectionPage) { ui->setupUi(this); QSvgRenderer *renderer = new QSvgRenderer(); renderer->load(shapeFile); m_shape = new QGraphicsSvgItem(); m_shape->setSharedRenderer(renderer); QGraphicsScene *scene = new QGraphicsScene(this); scene->addItem(m_shape); ui->typeGraphicsView->setScene(scene); connect(ui->typeCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(selectionChanged(int))); }
void QgsComposerArrow::setEndMarker( const QString& svgPath ) { QSvgRenderer r; mEndMarkerFile = svgPath; if ( svgPath.isEmpty() || !r.load( svgPath ) ) { mStopArrowHeadHeight = 0; } else { //calculate mArrowHeadHeight from svg file and mArrowHeadWidth QRect viewBox = r.viewBox(); mStopArrowHeadHeight = mArrowHeadWidth / viewBox.width() * viewBox.height(); } adaptItemSceneRect(); }
/* * Initialize the widget */ GpsDisplayWidget::GpsDisplayWidget(QWidget *parent) : QWidget(parent) { setupUi(this); //Not elegant, just load the image for now QGraphicsScene *fescene = new QGraphicsScene(this); QPixmap earthpix( ":/gpsgadget/images/flatEarth.png" ); fescene->addPixmap( earthpix ); flatEarth->setScene(fescene); marker = new QGraphicsSvgItem(); QSvgRenderer *renderer = new QSvgRenderer(); renderer->load(QString(":/gpsgadget/images/marker.svg")); marker->setSharedRenderer(renderer); fescene->addItem(marker); double scale = earthpix.width()/(marker->boundingRect().width()*20); marker->setScale(scale); }
void PdfElementImage::showDefaultImage(QPainter *painter, QRectF box) { QSvgRenderer svg; QImage picture; QString img; QList<QString> images = replaceVariables(_attributes.value("default", "")); // Try to load the image as SVG and after as a pixel graphic for (int i = 0; i < images.size(); i++) { img = QString("/").prepend(_templatePath).append( images.at(i) ); if (svg.load(img)) { painter->setPen(Qt::NoPen); svg.render(painter, box); break; } else if (picture.load( img )) { painter->drawImage( box, picture, QRectF(picture.rect()) ); break; } } }
MultiPage::MultiPage(SetupWizard *wizard, QWidget *parent) : AbstractWizardPage(wizard, parent), ui(new Ui::MultiPage) { ui->setupUi(this); QSvgRenderer *renderer = new QSvgRenderer(); renderer->load(QString(":/configgadget/images/multirotor-shapes.svg")); m_multiPic = new QGraphicsSvgItem(); m_multiPic->setSharedRenderer(renderer); QGraphicsScene *scene = new QGraphicsScene(this); scene->addItem(m_multiPic); ui->typeGraphicsView->setScene(scene); setupMultiTypesCombo(); // Default to Quad X since it is the most common setup ui->typeCombo->setCurrentIndex(1); connect(ui->typeCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateImageAndDescription())); ui->typeGraphicsView->setSceneRect(m_multiPic->boundingRect()); ui->typeGraphicsView->fitInView(m_multiPic, Qt::KeepAspectRatio); }
/* * Initialize the widget */ MixerCurveWidget::MixerCurveWidget(QWidget *parent) : QGraphicsView(parent) { // Create a layout, add a QGraphicsView and put the SVG inside. // The Mixer Curve widget looks like this: // |--------------------| // | | // | | // | Graph | // | | // | | // | | // |--------------------| setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setRenderHint(QPainter::Antialiasing); curveMin=0.0; curveMax=1.0; QGraphicsScene *scene = new QGraphicsScene(this); QSvgRenderer *renderer = new QSvgRenderer(); plot = new QGraphicsSvgItem(); renderer->load(QString(":/configgadget/images/curve-bg.svg")); plot->setSharedRenderer(renderer); //plot->setElementId("map"); scene->addItem(plot); plot->setZValue(-1); scene->setSceneRect(plot->boundingRect()); setScene(scene); }
void StartGameDialog::loadChipImages() { QSvgRenderer svgRenderer; svgRenderer.load(m_provider->currentTheme()->graphicsPath()); QPixmap blackChip(QSize(46, 46)); blackChip.fill(Qt::transparent); QPixmap whiteChip(QSize(46, 46)); whiteChip.fill(Qt::transparent); QPainter *painter = new QPainter(&blackChip); QString prefix = Utils::chipPrefixToString(m_chipsPrefix); svgRenderer.render(painter, prefix + "_1"); delete painter; painter = new QPainter(&whiteChip); // TODO: get 12 from some global constant that is shared with QML svgRenderer.render(painter, prefix + "_12"); delete painter; ui->blackLabel->setPixmap(blackChip); ui->whiteLabel->setPixmap(whiteChip); QGraphicsDropShadowEffect *blackShadow = new QGraphicsDropShadowEffect(this); blackShadow->setBlurRadius(10.0); blackShadow->setColor(Qt::black); blackShadow->setOffset(0.0); QGraphicsDropShadowEffect *whiteShadow = new QGraphicsDropShadowEffect(this); whiteShadow->setBlurRadius(10.0); whiteShadow->setColor(Qt::black); whiteShadow->setOffset(0.0); ui->blackLabel->setGraphicsEffect(blackShadow); ui->whiteLabel->setGraphicsEffect(whiteShadow); }
QPixmap KPrPageLayout::thumbnail() const { QSvgRenderer renderer; QSize size( 80, 60 ); QPixmap pic( size ); pic.fill(); QPainter p( &pic ); // TODO: use QStandardPaths for that instead QString file = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("stage/pics/layout-elements.svg")); if ( renderer.load( file ) ) { QList<KPrPlaceholder *>::const_iterator it( m_placeholders.begin() ); for ( ; it != m_placeholders.end(); ++it ) { debugStage << "-----------------" <<( *it )->presentationObject() << ( *it )->rect( size ); renderer.render( &p, ( *it )->presentationObject(), ( *it )->rect( size ) ); } } else { warnStage << "could not load" << file; } return pic; }
ConfigAHRSWidget::ConfigAHRSWidget(QWidget *parent) : ConfigTaskWidget(parent) { m_ahrs = new Ui_AHRSWidget(); m_ahrs->setupUi(this); // Initialization of the Paper plane widget m_ahrs->sixPointsHelp->setScene(new QGraphicsScene(this)); paperplane = new QGraphicsSvgItem(); paperplane->setSharedRenderer(new QSvgRenderer()); paperplane->renderer()->load(QString(":/configgadget/images/paper-plane.svg")); paperplane->setElementId("plane-horizontal"); m_ahrs->sixPointsHelp->scene()->addItem(paperplane); m_ahrs->sixPointsHelp->setSceneRect(paperplane->boundingRect()); // Initialization of the AHRS bargraph graph m_ahrs->ahrsBargraph->setScene(new QGraphicsScene(this)); QSvgRenderer *renderer = new QSvgRenderer(); ahrsbargraph = new QGraphicsSvgItem(); renderer->load(QString(":/configgadget/images/ahrs-calib.svg")); ahrsbargraph->setSharedRenderer(renderer); ahrsbargraph->setElementId("background"); ahrsbargraph->setObjectName("background"); m_ahrs->ahrsBargraph->scene()->addItem(ahrsbargraph); m_ahrs->ahrsBargraph->setSceneRect(ahrsbargraph->boundingRect()); // Initialize the 9 bargraph values: QMatrix lineMatrix = renderer->matrixForElement("accel_x"); QRectF rect = lineMatrix.mapRect(renderer->boundsOnElement("accel_x")); qreal startX = rect.x(); qreal startY = rect.y()+ rect.height(); // maxBarHeight will be used for scaling it later. maxBarHeight = rect.height(); // Then once we have the initial location, we can put it // into a QGraphicsSvgItem which we will display at the same // place: we do this so that the heading scale can be clipped to // the compass dial region. accel_x = new QGraphicsSvgItem(); accel_x->setSharedRenderer(renderer); accel_x->setElementId("accel_x"); m_ahrs->ahrsBargraph->scene()->addItem(accel_x); accel_x->setPos(startX, startY); accel_x->setTransform(QTransform::fromScale(1,0),true); lineMatrix = renderer->matrixForElement("accel_y"); rect = lineMatrix.mapRect(renderer->boundsOnElement("accel_y")); startX = rect.x(); startY = rect.y()+ rect.height(); accel_y = new QGraphicsSvgItem(); accel_y->setSharedRenderer(renderer); accel_y->setElementId("accel_y"); m_ahrs->ahrsBargraph->scene()->addItem(accel_y); accel_y->setPos(startX,startY); accel_y->setTransform(QTransform::fromScale(1,0),true); lineMatrix = renderer->matrixForElement("accel_z"); rect = lineMatrix.mapRect(renderer->boundsOnElement("accel_z")); startX = rect.x(); startY = rect.y()+ rect.height(); accel_z = new QGraphicsSvgItem(); accel_z->setSharedRenderer(renderer); accel_z->setElementId("accel_z"); m_ahrs->ahrsBargraph->scene()->addItem(accel_z); accel_z->setPos(startX,startY); accel_z->setTransform(QTransform::fromScale(1,0),true); lineMatrix = renderer->matrixForElement("gyro_x"); rect = lineMatrix.mapRect(renderer->boundsOnElement("gyro_x")); startX = rect.x(); startY = rect.y()+ rect.height(); gyro_x = new QGraphicsSvgItem(); gyro_x->setSharedRenderer(renderer); gyro_x->setElementId("gyro_x"); m_ahrs->ahrsBargraph->scene()->addItem(gyro_x); gyro_x->setPos(startX,startY); gyro_x->setTransform(QTransform::fromScale(1,0),true); lineMatrix = renderer->matrixForElement("gyro_y"); rect = lineMatrix.mapRect(renderer->boundsOnElement("gyro_y")); startX = rect.x(); startY = rect.y()+ rect.height(); gyro_y = new QGraphicsSvgItem(); gyro_y->setSharedRenderer(renderer); gyro_y->setElementId("gyro_y"); m_ahrs->ahrsBargraph->scene()->addItem(gyro_y); gyro_y->setPos(startX,startY); gyro_y->setTransform(QTransform::fromScale(1,0),true); lineMatrix = renderer->matrixForElement("gyro_z"); rect = lineMatrix.mapRect(renderer->boundsOnElement("gyro_z")); startX = rect.x(); startY = rect.y()+ rect.height(); gyro_z = new QGraphicsSvgItem(); gyro_z->setSharedRenderer(renderer); gyro_z->setElementId("gyro_z"); m_ahrs->ahrsBargraph->scene()->addItem(gyro_z); gyro_z->setPos(startX,startY); gyro_z->setTransform(QTransform::fromScale(1,0),true); lineMatrix = renderer->matrixForElement("mag_x"); rect = lineMatrix.mapRect(renderer->boundsOnElement("mag_x")); startX = rect.x(); startY = rect.y()+ rect.height(); mag_x = new QGraphicsSvgItem(); mag_x->setSharedRenderer(renderer); mag_x->setElementId("mag_x"); m_ahrs->ahrsBargraph->scene()->addItem(mag_x); mag_x->setPos(startX,startY); mag_x->setTransform(QTransform::fromScale(1,0),true); lineMatrix = renderer->matrixForElement("mag_y"); rect = lineMatrix.mapRect(renderer->boundsOnElement("mag_y")); startX = rect.x(); startY = rect.y()+ rect.height(); mag_y = new QGraphicsSvgItem(); mag_y->setSharedRenderer(renderer); mag_y->setElementId("mag_y"); m_ahrs->ahrsBargraph->scene()->addItem(mag_y); mag_y->setPos(startX,startY); mag_y->setTransform(QTransform::fromScale(1,0),true); lineMatrix = renderer->matrixForElement("mag_z"); rect = lineMatrix.mapRect(renderer->boundsOnElement("mag_z")); startX = rect.x(); startY = rect.y()+ rect.height(); mag_z = new QGraphicsSvgItem(); mag_z->setSharedRenderer(renderer); mag_z->setElementId("mag_z"); m_ahrs->ahrsBargraph->scene()->addItem(mag_z); mag_z->setPos(startX,startY); mag_z->setTransform(QTransform::fromScale(1,0),true); position = -1; // Fill the dropdown menus: UAVObject *obj = dynamic_cast<UAVDataObject*>(getObjectManager()->getObject(QString("AHRSSettings"))); UAVObjectField *field = obj->getField(QString("Algorithm")); m_ahrs->algorithm->addItems(field->getOptions()); // Register for Home Location state changes obj = dynamic_cast<UAVDataObject*>(getObjectManager()->getObject(QString("HomeLocation"))); connect(obj, SIGNAL(objectUpdated(UAVObject*)), this , SLOT(enableHomeLocSave(UAVObject*))); // Connect the signals connect(m_ahrs->ahrsCalibStart, SIGNAL(clicked()), this, SLOT(launchAHRSCalibration())); connect(m_ahrs->ahrsSettingsRequest, SIGNAL(clicked()), this, SLOT(ahrsSettingsRequest())); /* connect(m_ahrs->algorithm, SIGNAL(currentIndexChanged(int)), this, SLOT(ahrsSettingsSave())); connect(m_ahrs->indoorFlight, SIGNAL(stateChanged(int)), this, SLOT(homeLocationSave())); connect(m_ahrs->homeLocation, SIGNAL(clicked()), this, SLOT(homeLocationSaveSD())); */ connect(m_ahrs->ahrsSettingsSaveRAM, SIGNAL(clicked()), this, SLOT(ahrsSettingsSaveRAM())); connect(m_ahrs->ahrsSettingsSaveSD, SIGNAL(clicked()), this, SLOT(ahrsSettingsSaveSD())); connect(m_ahrs->sixPointsStart, SIGNAL(clicked()), this, SLOT(sixPointCalibrationMode())); connect(m_ahrs->sixPointsSave, SIGNAL(clicked()), this, SLOT(savePositionData())); connect(parent, SIGNAL(autopilotConnected()),this, SLOT(ahrsSettingsRequest())); }
/** Virtual function to setup the UI */ void ConfigGroundVehicleWidget::setupUI(QString frameType) { // Setup the UI Q_ASSERT(m_aircraft); QSvgRenderer *renderer = new QSvgRenderer(); renderer->load(QString(":/configgadget/images/ground-shapes.svg")); m_vehicleImg = new QGraphicsSvgItem(); m_vehicleImg->setSharedRenderer(renderer); UAVDataObject *system = dynamic_cast<UAVDataObject *>(getObjectManager()->getObject(QString("SystemSettings"))); Q_ASSERT(system); QPointer<UAVObjectField> frameTypeSaved = system->getField(QString("AirframeType")); m_aircraft->differentialSteeringSlider1->setEnabled(false); m_aircraft->differentialSteeringSlider2->setEnabled(false); m_aircraft->gvThrottleCurve1GroupBox->setEnabled(true); m_aircraft->gvThrottleCurve2GroupBox->setEnabled(true); m_aircraft->groundVehicleThrottle1->setMixerType(MixerCurve::MIXERCURVE_THROTTLE); m_aircraft->groundVehicleThrottle2->setMixerType(MixerCurve::MIXERCURVE_PITCH); initMixerCurves(frameType); if (frameType == "GroundVehicleDifferential" || frameType == "Differential (tank)") { // Tank m_vehicleImg->setElementId("tank"); setComboCurrentIndex(m_aircraft->groundVehicleType, m_aircraft->groundVehicleType->findText("Differential (tank)")); m_aircraft->gvMotor1ChannelBox->setEnabled(true); m_aircraft->gvMotor2ChannelBox->setEnabled(true); m_aircraft->gvThrottleCurve1GroupBox->setEnabled(false); m_aircraft->gvMotor1Label->setText("Left motor"); m_aircraft->gvMotor2Label->setText("Right motor"); m_aircraft->gvSteering1ChannelBox->setEnabled(false); m_aircraft->gvSteering2ChannelBox->setEnabled(false); m_aircraft->gvSteering1Label->setText("Front steering"); m_aircraft->gvSteering2Label->setText("Rear steering"); m_aircraft->differentialSteeringSlider1->setEnabled(true); m_aircraft->differentialSteeringSlider2->setEnabled(true); m_aircraft->gvThrottleCurve1GroupBox->setTitle("Throttle curve1"); m_aircraft->gvThrottleCurve2GroupBox->setTitle("Throttle curve2 "); m_aircraft->groundVehicleThrottle2->setMixerType(MixerCurve::MIXERCURVE_PITCH); m_aircraft->groundVehicleThrottle1->setMixerType(MixerCurve::MIXERCURVE_THROTTLE); initMixerCurves(frameType); // If new setup, set sliders to defaults and set curves values if (frameTypeSaved->getValue().toString() != "GroundVehicleDifferential") { m_aircraft->differentialSteeringSlider1->setValue(100); m_aircraft->differentialSteeringSlider2->setValue(100); m_aircraft->groundVehicleThrottle1->initLinearCurve(5, 1.0, 0.0); m_aircraft->groundVehicleThrottle2->initLinearCurve(5, 1.0, 0.0); } } else if (frameType == "GroundVehicleMotorcycle" || frameType == "Motorcycle") { // Motorcycle m_vehicleImg->setElementId("motorbike"); setComboCurrentIndex(m_aircraft->groundVehicleType, m_aircraft->groundVehicleType->findText("Motorcycle")); m_aircraft->gvMotor1ChannelBox->setEnabled(true); m_aircraft->gvMotor2ChannelBox->setEnabled(false); m_aircraft->gvMotor2Label->setText("Rear motor"); m_aircraft->gvSteering1ChannelBox->setEnabled(true); m_aircraft->gvSteering2ChannelBox->setEnabled(true); m_aircraft->gvSteering1Label->setText("Front steering"); m_aircraft->gvSteering2Label->setText("Balancing"); // Curve1 for Motorcyle m_aircraft->gvThrottleCurve1GroupBox->setTitle("Throttle curve1"); m_aircraft->gvThrottleCurve1GroupBox->setEnabled(true); m_aircraft->gvThrottleCurve2GroupBox->setTitle("Throttle curve2"); m_aircraft->gvThrottleCurve2GroupBox->setEnabled(true); m_aircraft->groundVehicleThrottle2->setMixerType(MixerCurve::MIXERCURVE_THROTTLE); m_aircraft->groundVehicleThrottle1->setMixerType(MixerCurve::MIXERCURVE_THROTTLE); initMixerCurves(frameType); // If new setup, set curves values if (frameTypeSaved->getValue().toString() != "GroundVehicleMotorCycle") { m_aircraft->groundVehicleThrottle2->initLinearCurve(5, 1.0, 0.0); m_aircraft->groundVehicleThrottle1->initLinearCurve(5, 1.0, 0.0); } } else { // Car m_vehicleImg->setElementId("car"); setComboCurrentIndex(m_aircraft->groundVehicleType, m_aircraft->groundVehicleType->findText("Turnable (car)")); m_aircraft->gvMotor1ChannelBox->setEnabled(true); m_aircraft->gvMotor2ChannelBox->setEnabled(true); m_aircraft->gvMotor1Label->setText("Front motor"); m_aircraft->gvMotor2Label->setText("Rear motor"); m_aircraft->gvSteering1ChannelBox->setEnabled(true); m_aircraft->gvSteering2ChannelBox->setEnabled(true); m_aircraft->gvSteering1Label->setText("Front steering"); m_aircraft->gvSteering2Label->setText("Rear steering"); m_aircraft->gvThrottleCurve2GroupBox->setTitle("Throttle curve2"); m_aircraft->gvThrottleCurve2GroupBox->setEnabled(true); m_aircraft->gvThrottleCurve1GroupBox->setTitle("Throttle curve1"); m_aircraft->gvThrottleCurve1GroupBox->setEnabled(true); m_aircraft->groundVehicleThrottle2->setMixerType(MixerCurve::MIXERCURVE_PITCH); m_aircraft->groundVehicleThrottle1->setMixerType(MixerCurve::MIXERCURVE_THROTTLE); initMixerCurves(frameType); // If new setup, set curves values if (frameTypeSaved->getValue().toString() != "GroundVehicleCar") { m_aircraft->groundVehicleThrottle1->initLinearCurve(5, 1.0, 0.0); m_aircraft->groundVehicleThrottle2->initLinearCurve(5, 1.0, 0.0); } } QGraphicsScene *scene = new QGraphicsScene(); scene->addItem(m_vehicleImg); scene->setSceneRect(m_vehicleImg->boundingRect()); m_aircraft->groundShape->fitInView(m_vehicleImg, Qt::KeepAspectRatio); m_aircraft->groundShape->setScene(scene); }
MonitorWidget::MonitorWidget(QWidget *parent) : QGraphicsView(parent), aspectRatioMode(Qt::KeepAspectRatio) { setMinimumSize(180, 25); QGraphicsScene *scene = new QGraphicsScene(); setScene(scene); setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred); // no scroll bars setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setBackgroundBrush(QBrush(Utils::StyleHelper::baseColor())); setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing); QSvgRenderer *renderer = new QSvgRenderer(); if (renderer->load(QString(":/telemetry/images/tx-rx.svg"))) { // create graph graph = new QGraphicsSvgItem(); graph->setSharedRenderer(renderer); graph->setElementId("background"); graph->setFlags(QGraphicsItem::ItemClipsChildrenToShape | QGraphicsItem::ItemClipsToShape); scene->addItem(graph); int i; // create tx nodes i = 0; while (true) { QString id = QString("tx%0").arg(i); QString bgId = QString("tx_bg%0").arg(i); if (!renderer->elementExists(id) || !renderer->elementExists(bgId)) { break; } QGraphicsSvgItem *item = createSvgItem(graph, bgId); item->setElementId(id); txNodes.append(item); i++; } // create rx nodes i = 0; while (true) { QString id = QString("rx%0").arg(i); QString bgId = QString("rx_bg%0").arg(i); if (!renderer->elementExists(id) || !renderer->elementExists(bgId)) { break; } QGraphicsSvgItem *item = createSvgItem(graph, bgId); item->setElementId(id); rxNodes.append(item); i++; } if (renderer->elementExists("txSpeed")) { txSpeed = createTextItem(graph, "txSpeed", "Helvetica"); txSpeed->setDefaultTextColor(Qt::white); } else { txSpeed = NULL; } if (renderer->elementExists("rxSpeed")) { rxSpeed = createTextItem(graph, "rxSpeed", "Helvetica"); rxSpeed->setDefaultTextColor(Qt::white); } else { rxSpeed = NULL; } // scene->setSceneRect(graph->boundingRect()); } connected = false; setMin(0.0); setMax(1200.0); telemetryUpdated(0.0, 0.0); }
void QgsDecorationNorthArrow::render( const QgsMapSettings &mapSettings, QgsRenderContext &context ) { if ( !enabled() ) return; double maxLength = mSize * mapSettings.outputDpi() / 25.4; QSvgRenderer svg; const QByteArray &svgContent = QgsApplication::svgCache()->svgContent( svgPath(), maxLength, mColor, mOutlineColor, 1.0, 1.0 ); svg.load( svgContent ); if ( svg.isValid() ) { QSize size( maxLength, maxLength ); QRectF viewBox = svg.viewBoxF(); if ( viewBox.height() > viewBox.width() ) { size.setWidth( maxLength * viewBox.width() / viewBox.height() ); } else { size.setHeight( maxLength * viewBox.height() / viewBox.width() ); } double centerXDouble = size.width() / 2.0; double centerYDouble = size.height() / 2.0; //save the current canvas rotation context.painter()->save(); // //work out how to shift the image so that it rotates // properly about its center //(x cos a + y sin a - x, -x sin a + y cos a - y) // // could move this call to somewhere else so that it is only // called when the projection or map extent changes if ( mAutomatic ) { try { mRotationInt = QgsBearingUtils:: bearingTrueNorth( mapSettings.destinationCrs(), mapSettings.transformContext(), context.extent().center() ); } catch ( QgsException & ) { mRotationInt = 0.0; } mRotationInt += mapSettings.rotation(); } double radiansDouble = mRotationInt * M_PI / 180.0; int xShift = static_cast<int>( ( ( centerXDouble * std::cos( radiansDouble ) ) + ( centerYDouble * std::sin( radiansDouble ) ) ) - centerXDouble ); int yShift = static_cast<int>( ( ( -centerXDouble * std::sin( radiansDouble ) ) + ( centerYDouble * std::cos( radiansDouble ) ) ) - centerYDouble ); // need width/height of paint device int deviceHeight = context.painter()->device()->height(); int deviceWidth = context.painter()->device()->width(); // Set margin according to selected units int xOffset = 0; int yOffset = 0; switch ( mMarginUnit ) { case QgsUnitTypes::RenderMillimeters: { int pixelsInchX = context.painter()->device()->logicalDpiX(); int pixelsInchY = context.painter()->device()->logicalDpiY(); xOffset = pixelsInchX * INCHES_TO_MM * mMarginHorizontal; yOffset = pixelsInchY * INCHES_TO_MM * mMarginVertical; break; } case QgsUnitTypes::RenderPixels: xOffset = mMarginHorizontal - 5; // Minus 5 to shift tight into corner yOffset = mMarginVertical - 5; break; case QgsUnitTypes::RenderPercentage: xOffset = ( ( deviceWidth - size.width() ) / 100. ) * mMarginHorizontal; yOffset = ( ( deviceHeight - size.width() ) / 100. ) * mMarginVertical; break; case QgsUnitTypes::RenderMapUnits: case QgsUnitTypes::RenderPoints: case QgsUnitTypes::RenderInches: case QgsUnitTypes::RenderUnknownUnit: case QgsUnitTypes::RenderMetersInMapUnits: break; } //Determine placement of label from form combo box switch ( mPlacement ) { case BottomLeft: context.painter()->translate( xOffset, deviceHeight - yOffset - maxLength + ( maxLength - size.height() ) / 2 ); break; case TopLeft: context.painter()->translate( xOffset, yOffset ); break; case TopRight: context.painter()->translate( deviceWidth - xOffset - maxLength + ( maxLength - size.width() ) / 2, yOffset ); break; case BottomRight: context.painter()->translate( deviceWidth - xOffset - maxLength + ( maxLength - size.width() ) / 2, deviceHeight - yOffset - maxLength + ( maxLength - size.height() ) / 2 ); break; } //rotate the canvas by the north arrow rotation amount context.painter()->rotate( mRotationInt ); //Now we can actually do the drawing, and draw a smooth north arrow even when rotated context.painter()->translate( xShift, yShift ); svg.render( context.painter(), QRectF( 0, 0, size.width(), size.height() ) ); //unrotate the canvas again context.painter()->restore(); } }
TelemetryMonitorWidget::TelemetryMonitorWidget(QWidget *parent) : QGraphicsView(parent) { setMinimumSize(180,100); setMaximumSize(180,100); setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed); setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setAlignment(Qt::AlignCenter); setFrameStyle(QFrame::NoFrame); setStyleSheet("background:transparent;"); setAttribute(Qt::WA_TranslucentBackground); setWindowFlags(Qt::FramelessWindowHint); QGraphicsScene *scene = new QGraphicsScene(0,0,180,100, this); QSvgRenderer *renderer = new QSvgRenderer(); if (renderer->load(QString(":/core/images/tx-rx.svg"))) { graph = new QGraphicsSvgItem(); graph->setSharedRenderer(renderer); graph->setElementId("txrxBackground"); QString name; QGraphicsSvgItem* pt; for (int i=0; i<NODE_NUMELEM; i++) { name = QString("tx%0").arg(i); if (renderer->elementExists(name)) { pt = new QGraphicsSvgItem(); pt->setSharedRenderer(renderer); pt->setElementId(name); pt->setParentItem(graph); txNodes.append(pt); } name = QString("rx%0").arg(i); if (renderer->elementExists(name)) { pt = new QGraphicsSvgItem(); pt->setSharedRenderer(renderer); pt->setElementId(name); pt->setParentItem(graph); rxNodes.append(pt); } } scene->addItem(graph); txSpeed = new QGraphicsTextItem(); txSpeed->setDefaultTextColor(Qt::white); txSpeed->setFont(QFont("Helvetica",22,2)); txSpeed->setParentItem(graph); scene->addItem(txSpeed); rxSpeed = new QGraphicsTextItem(); rxSpeed->setDefaultTextColor(Qt::white); rxSpeed->setFont(QFont("Helvetica",22,2)); rxSpeed->setParentItem(graph); scene->addItem(rxSpeed); scene->setSceneRect(graph->boundingRect()); setScene(scene); } connected = false; txValue = 0.0; rxValue = 0.0; setMin(0.0); setMax(1200.0); showTelemetry(); }
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 ); } QString svgFileName = ( type == StartMarker ? mStartMarkerFile : mEndMarkerFile ); if ( svgFileName.isEmpty() ) return; QSvgRenderer r; const QByteArray &svgContent = QgsApplication::svgCache()->svgContent( svgFileName, mArrowHeadWidth, mArrowHeadFillColor, mArrowHeadOutlineColor, mArrowHeadOutlineWidth, 1.0, 1.0 ); r.load( svgContent ); 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; }
QImage *ConvertThread::loadSvgImage(const QString &imagePath) { QSvgRenderer renderer; if (shared.svgModifiersEnabled) { SvgModifier modifier(pd.imagePath); // modify SVG file if (!shared.svgRemoveTextString.isNull()) modifier.removeText(shared.svgRemoveTextString); if (shared.svgRemoveEmptyGroup) modifier.removeEmptyGroups(); // save SVG file if (shared.svgSave) { QString svgTargetFileName = targetFilePath.left(targetFilePath.lastIndexOf('.')+1) + "svg"; QFile file(svgTargetFileName); // ask overwrite if (file.exists()) { shared.mutex.lock(); emit question(svgTargetFileName, Overwrite); shared.mutex.unlock(); } if (shared.overwriteResult == QMessageBox::Yes || shared.overwriteResult == QMessageBox::YesToAll) { if (!file.open(QIODevice::WriteOnly)) { emit imageStatus(pd.imgData, tr("Failed to save new SVG file"), Failed); return NULL; } file.write(modifier.content()); } } // and load QByteArray buffer to renderer if (!renderer.load(modifier.content())) { emit imageStatus(pd.imgData, tr("Failed to open changed SVG file"), Failed); return NULL; } } else if (!renderer.load(pd.imagePath)) { emit imageStatus(pd.imgData, tr("Failed to open SVG file"), Failed); return NULL; } sizeComputed = computeSize(&renderer, pd.imagePath); if (sizeComputed == 2) return NULL; // keep aspect ratio if (shared.maintainAspect) { qreal w = width; qreal h = height; qreal targetRatio = w / h; QSizeF svgSize = renderer.defaultSize(); qreal currentRatio = svgSize.width() / svgSize.height(); if (currentRatio != targetRatio) { qreal diffRatio; if (currentRatio > targetRatio) diffRatio = w / svgSize.width(); else diffRatio = h / svgSize.height(); width = diffRatio * svgSize.width(); height = diffRatio * svgSize.height(); } } // create image QImage *img = new QImage(width, height, QImage::Format_ARGB32); fillImage(img); QPainter painter(img); renderer.render(&painter); // don't scale rendered image hasWidth = false; hasHeight = false; // finaly return the image pointer return img; }
void QgsDecorationNorthArrow::render( const QgsMapSettings &mapSettings, QgsRenderContext &context ) { //Large IF statement controlled by enable checkbox if ( enabled() ) { QSize size( 64, 64 ); QSvgRenderer svg; const QByteArray &svgContent = QgsApplication::svgCache()->svgContent( QStringLiteral( ":/images/north_arrows/default.svg" ), size.width(), mColor, mOutlineColor, 1.0, 1.0 ); svg.load( svgContent ); if ( svg.isValid() ) { double centerXDouble = size.width() / 2.0; double centerYDouble = size.width() / 2.0; //save the current canvas rotation context.painter()->save(); // //work out how to shift the image so that it rotates // properly about its center //(x cos a + y sin a - x, -x sin a + y cos a - y) // // could move this call to somewhere else so that it is only // called when the projection or map extent changes if ( mAutomatic ) { mRotationInt = QgsBearingUtils:: bearingTrueNorth( mapSettings.destinationCrs(), context.extent().center() ); mRotationInt += mapSettings.rotation(); } double myRadiansDouble = mRotationInt * M_PI / 180.0; int xShift = static_cast<int>( ( ( centerXDouble * cos( myRadiansDouble ) ) + ( centerYDouble * sin( myRadiansDouble ) ) ) - centerXDouble ); int yShift = static_cast<int>( ( ( -centerXDouble * sin( myRadiansDouble ) ) + ( centerYDouble * cos( myRadiansDouble ) ) ) - centerYDouble ); // need width/height of paint device int myHeight = context.painter()->device()->height(); int myWidth = context.painter()->device()->width(); //QgsDebugMsg("Rendering north arrow at " + mPlacementLabels.at(mPlacementIndex)); // Set margin according to selected units int myXOffset = 0; int myYOffset = 0; switch ( mMarginUnit ) { case QgsUnitTypes::RenderMillimeters: { int myPixelsInchX = context.painter()->device()->logicalDpiX(); int myPixelsInchY = context.painter()->device()->logicalDpiY(); myXOffset = myPixelsInchX * INCHES_TO_MM * mMarginHorizontal; myYOffset = myPixelsInchY * INCHES_TO_MM * mMarginVertical; break; } case QgsUnitTypes::RenderPixels: myXOffset = mMarginHorizontal - 5; // Minus 5 to shift tight into corner myYOffset = mMarginVertical - 5; break; case QgsUnitTypes::RenderPercentage: myXOffset = ( ( myWidth - size.width() ) / 100. ) * mMarginHorizontal; myYOffset = ( ( myHeight - size.width() ) / 100. ) * mMarginVertical; break; default: // Use default of top left break; } //Determine placement of label from form combo box switch ( mPlacement ) { case BottomLeft: context.painter()->translate( myXOffset, myHeight - myYOffset - size.width() ); break; case TopLeft: context.painter()->translate( myXOffset, myYOffset ); break; case TopRight: context.painter()->translate( myWidth - myXOffset - size.width(), myYOffset ); break; case BottomRight: context.painter()->translate( myWidth - myXOffset - size.width(), myHeight - myYOffset - size.width() ); break; default: { //QgsDebugMsg("Unable to determine where to put north arrow so defaulting to top left"); } } //rotate the canvas by the north arrow rotation amount context.painter()->rotate( mRotationInt ); //Now we can actually do the drawing, and draw a smooth north arrow even when rotated context.painter()->translate( xShift, yShift ); svg.render( context.painter(), QRectF( 0, 0, size.width(), size.height() ) ); //unrotate the canvas again context.painter()->restore(); } else { QFont myQFont( QStringLiteral( "time" ), 12, QFont::Bold ); context.painter()->setFont( myQFont ); context.painter()->setPen( Qt::black ); context.painter()->drawText( 10, 20, tr( "North arrow pixmap not found" ) ); } } }
void QgsDecorationNorthArrowDialog::drawNorthArrow() { int rotation = spinAngle->value(); double maxLength = 64; QSvgRenderer svg; const QByteArray &svgContent = QgsApplication::svgCache()->svgContent( mDeco.svgPath(), maxLength, pbnChangeColor->color(), pbnChangeOutlineColor->color(), 1.0, 1.0 ); svg.load( svgContent ); if ( svg.isValid() ) { QSize size( maxLength, maxLength ); QRectF viewBox = svg.viewBoxF(); if ( viewBox.height() > viewBox.width() ) { size.setWidth( maxLength * viewBox.width() / viewBox.height() ); } else { size.setHeight( maxLength * viewBox.height() / viewBox.width() ); } QPixmap myPainterPixmap( maxLength, maxLength ); myPainterPixmap.fill(); QPainter myQPainter; myQPainter.begin( &myPainterPixmap ); myQPainter.setRenderHint( QPainter::SmoothPixmapTransform ); double centerXDouble = size.width() / 2.0; double centerYDouble = size.height() / 2.0; //save the current canvas rotation myQPainter.save(); myQPainter.translate( ( maxLength - size.width() ) / 2, ( maxLength - size.height() ) / 2 ); //rotate the canvas myQPainter.rotate( rotation ); //work out how to shift the image so that it appears in the center of the canvas //(x cos a + y sin a - x, -x sin a + y cos a - y) double myRadiansDouble = ( M_PI / 180 ) * rotation; int xShift = static_cast<int>( ( ( centerXDouble * std::cos( myRadiansDouble ) ) + ( centerYDouble * std::sin( myRadiansDouble ) ) ) - centerXDouble ); int yShift = static_cast<int>( ( ( -centerXDouble * std::sin( myRadiansDouble ) ) + ( centerYDouble * std::cos( myRadiansDouble ) ) ) - centerYDouble ); //draw the pixmap in the proper position myQPainter.translate( xShift, yShift ); svg.render( &myQPainter, QRectF( 0, 0, size.width(), size.height() ) ); //unrotate the canvas again myQPainter.restore(); myQPainter.end(); pixmapLabel->setPixmap( myPainterPixmap ); } else { QPixmap myPainterPixmap( 200, 200 ); myPainterPixmap.fill(); QPainter myQPainter; myQPainter.begin( &myPainterPixmap ); QFont myQFont( QStringLiteral( "time" ), 12, QFont::Bold ); myQPainter.setFont( myQFont ); myQPainter.setPen( Qt::red ); myQPainter.drawText( 10, 20, tr( "Pixmap not found" ) ); myQPainter.end(); pixmapLabel->setPixmap( myPainterPixmap ); } }