void TouchUI::draw( QPainter & painter )
{
_screen_width = painter.window().width();
_screen_height = painter.window().height();
limitScroll();
// draw background
QRect rect(0,0,painter.window().width(),_height);
painter.drawTiledPixmap( rect, _background );
// draw icons
for ( int i = 0; i < _items.count(); i++ )
{
UIItem * t = _items[i];
int posx = t->x1;
int posy = t->y1;
if ( posx < 0 ) posx = _screen_width+posx;
QSvgRenderer * image = t->image;
if ( t->highlighted )
painter.setCompositionMode( QPainter::CompositionMode_HardLight );
else
painter.setCompositionMode( QPainter::CompositionMode_SourceOver );
if ( image == NULL ) continue;
int h = image->defaultSize().height();
int w = image->defaultSize().width();
int img_width = g_config.ui_size;
int img_height = g_config.ui_size;
ImageLoadThread::fitImage( w,h, img_width, img_height, false );
QRectF r( posx+_xoffset, posy+_yoffset, w, h );
image->render( &painter, r );
}
}
QPixmap MIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
{
QPixmap pm;
QString pmckey(d->pmcKey(size, mode, state));
if (QPixmapCache::find(pmckey, pm))
return pm;
if (d->addedPixmaps) {
pm = d->addedPixmaps->value(d->hashKey(mode, state));
if (!pm.isNull() && pm.size() == size)
return pm;
}
QSvgRenderer renderer;
d->loadDataForModeAndState(&renderer, mode, state);
if (!renderer.isValid())
return pm;
QSize actualSize = renderer.defaultSize();
if (!actualSize.isNull())
actualSize.scale(size, Qt::KeepAspectRatio);
QImage img(actualSize, QImage::Format_ARGB32);
img.fill(0x00000000);
QPainter p(&img);
renderer.render(&p);
p.end();
pm = QPixmap::fromImage(img);
if (!pm.isNull())
QPixmapCache::insert(pmckey, pm);
return pm;
}
void QucsActiveFilter::slotUpdateResponse()
{
QString s = ":/images/bitmaps/AFR.svg";
switch (cbxResponse->currentIndex()) {
case tLowPass :
s = ":/images/bitmaps/AFR.svg";
ftyp = Filter::LowPass;
break;
case tHiPass : s = ":/images/bitmaps/high-pass.svg";
ftyp = Filter::HighPass;
break;
case tBandPass : s = ":/images/bitmaps/bandpass.svg";
ftyp = Filter::BandPass;
break;
case tBandStop : s = ":/images/bitmaps/bandstop.svg";
ftyp = Filter::BandStop;
break;
default: ftyp = Filter::NoFilter;
break;
}
QSvgRenderer *ren = new QSvgRenderer(s);
QSize sz = ren->defaultSize();
sz *= 1.1;
delete ren;
imgAFR->load(s);
imgAFR->setFixedSize(sz);
}
QPixmap SIconPool::loadIcon(
const QString &fileName,
const QSize &size,
Qt::AspectRatioMode mode,
const QColor &color)
{
QPixmap pm;
// SVG? Use QSvgRenderer
if (fileName.endsWith(".svg")) {
QSvgRenderer *renderer = getSvgRenderer(fileName);
if (renderer->isValid()) {
QSize renderSize = renderer->defaultSize();
// If given size is valid, scale default size to it using the given aspect ratio mode
if (size.isValid()) {
renderSize.scale(size, mode);
// If only one dimension is valid, scale other dimension keeping the aspect ratio
} else if (size.height() > 0) {
Qt::AspectRatioMode scaleMode = size.height() > renderSize.height()
? Qt::KeepAspectRatioByExpanding
: Qt::KeepAspectRatio;
renderSize.scale(renderSize.width(), size.height(), scaleMode);
} else if (size.width() > 0) {
Qt::AspectRatioMode scaleMode = size.width() > renderSize.width()
? Qt::KeepAspectRatioByExpanding
: Qt::KeepAspectRatio;
renderSize.scale(size.width(), renderSize.height(), scaleMode);
}
// Otherwise (-1,-1) was given as size, leave renderSize as icon's default size
pm = QPixmap(renderSize);
pm.fill(QColor(0, 0, 0, 0));
QPainter painter(&pm);
renderer->render(&painter, QRectF(QPointF(), renderSize));
}
} else {
// Otherwise load with QPixmap
pm.load(fileName);
if (!pm.isNull()) {
pm = pm.scaled(size, mode, Qt::SmoothTransformation);
}
}
if (!pm.isNull() && color.isValid()) {
// Colorize the icon
QPixmap mask = pm.alphaChannel();
pm.fill(color);
pm.setAlphaChannel(mask);
}
#ifdef Q_DEBUG_ICON
if (pm.isNull()) {
qDebug() << "Fail to load icon: " << filename;
}
#endif
return pm;
}
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;
}
QPixmap QSvgIconEngine::pixmap(const QSize &size, QIcon::Mode mode,
QIcon::State state)
{
QPixmap pm;
QString pmckey(d->pmcKey(size, mode, state));
if (QPixmapCache::find(pmckey, pm))
return pm;
if (d->addedPixmaps) {
pm = d->addedPixmaps->value(d->hashKey(mode, state));
if (!pm.isNull() && pm.size() == size)
return pm;
}
QSvgRenderer renderer;
d->loadDataForModeAndState(&renderer, mode, state);
if (!renderer.isValid())
return pm;
QSize actualSize = renderer.defaultSize();
if (!actualSize.isNull())
actualSize.scale(size, Qt::KeepAspectRatio);
if (actualSize.isEmpty())
return QPixmap();
QImage img(actualSize, QImage::Format_ARGB32_Premultiplied);
img.fill(0x00000000);
QPainter p(&img);
renderer.render(&p);
p.end();
pm = QPixmap::fromImage(img);
if (qobject_cast<QGuiApplication *>(QCoreApplication::instance())) {
const QPixmap generated = QGuiApplicationPrivate::instance()->applyQIconStyleHelper(mode, pm);
if (!generated.isNull())
pm = generated;
}
if (!pm.isNull())
QPixmapCache::insert(pmckey, pm);
return pm;
}
void QucsActiveFilter::slotUpdateSchematic()
{
slotUpdateResponse();
QString s;
switch (cbxFilterType->currentIndex()) {
case topoCauer : if ((ftyp==Filter::BandStop)||
(ftyp==Filter::BandPass)) {
s = ":images/bitmaps/cauer-bandpass.svg"; // Cauer section
} else {
s = ":images/bitmaps/cauer.svg"; // Cauer section
}
break;
case topoMFB : if (ftyp==Filter::HighPass) { // Multifeedback
s = ":/images/bitmaps/mfb-highpass.svg";
} else if (ftyp==Filter::LowPass) {
s = ":/images/bitmaps/mfb-lowpass.svg";
} else if (ftyp==Filter::BandPass) {
s = ":/images/bitmaps/mfb-bandpass.svg";
}
break;
case topoSallenKey : if (ftyp==Filter::HighPass) { // Sallen-Key
s = ":/images/bitmaps/sk-highpass.svg";
} else if (ftyp==Filter::LowPass) {
s = ":/images/bitmaps/sk-lowpass.svg";
} else if (ftyp==Filter::BandPass) {
s = ":/images/bitmaps/sk-bandpass.svg";
}
break;
case 3 : s = ":/images/bitmaps/mfb-lowpass.svg";
break;
default:
break;
}
QSvgRenderer *ren = new QSvgRenderer(s);
QSize sz = ren->defaultSize();
sz *= 0.65;
delete ren;
sch_pic->load(s);
sch_pic->setFixedSize(sz);
}
QPixmap QSvgIconEngine::pixmap(const QSize &size, QIcon::Mode mode,
QIcon::State state)
{
QPixmap pm;
QString pmckey(d->pmcKey(size, mode, state));
if (QPixmapCache::find(pmckey, pm))
return pm;
if (d->addedPixmaps) {
pm = d->addedPixmaps->value(d->hashKey(mode, state));
if (!pm.isNull() && pm.size() == size)
return pm;
}
QSvgRenderer renderer;
d->loadDataForModeAndState(&renderer, mode, state);
if (!renderer.isValid())
return pm;
QSize actualSize = renderer.defaultSize();
if (!actualSize.isNull())
actualSize.scale(size, Qt::KeepAspectRatio);
QImage img(actualSize, QImage::Format_ARGB32_Premultiplied);
img.fill(0x00000000);
QPainter p(&img);
renderer.render(&p);
p.end();
pm = QPixmap::fromImage(img);
QStyleOption opt(0);
opt.palette = QApplication::palette();
QPixmap generated = QApplication::style()->generatedIconPixmap(mode, pm, &opt);
if (!generated.isNull())
pm = generated;
if (!pm.isNull())
QPixmapCache::insert(pmckey, pm);
return pm;
}
/*!
\fn SvgImageProvider::scaledElementBounds(const QString &svgFile, const QString &element)
Returns the bound of \a element in logical coordinates,
scalled to the default size of svg document (so the bounds of whole doc would be (0,0,1,1) ).
*/
QRectF SvgImageProvider::scaledElementBounds(const QString &svgFile, const QString &elementName)
{
QSvgRenderer *renderer = loadRenderer(svgFile);
if (!renderer)
return QRectF();
if (!renderer->elementExists(elementName)) {
qWarning() << "invalid element:" << elementName << "of" << svgFile;
return QRectF();
}
QRectF elementBounds = renderer->boundsOnElement(elementName);
QMatrix matrix = renderer->matrixForElement(elementName);
elementBounds = matrix.mapRect(elementBounds);
QSize docSize = renderer->defaultSize();
return QRectF(elementBounds.x()/docSize.width(),
elementBounds.y()/docSize.height(),
elementBounds.width()/docSize.width(),
elementBounds.height()/docSize.height());
}
QSize SIconPool::defaultSize(const QString &fileName)
{
QSize defSize;
// Get the default size from svg renderer or pixmap size
if (!fileName.isEmpty()) {
// SVG? Use QSvgRenderer
if (fileName.endsWith(".svg")) {
QSvgRenderer *svgRenderer = getSvgRenderer(fileName);
if (svgRenderer->isValid()) {
defSize = svgRenderer->defaultSize();
}
} else {
// Otherwise load with QPixmap
QPixmap pixmap;
pixmap.load(fileName);
defSize = pixmap.size();
}
}
return defSize;
}
QPixmap MIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
{
QPixmap pm;
QString pmckey(d->pmcKey(size, mode, state));
pmckey.prepend("Ms");
if (QPixmapCache::find(pmckey, pm))
return pm;
if (d->addedPixmaps) {
pm = d->addedPixmaps->value(d->hashKey(mode, state));
if (!pm.isNull() && pm.size() == size)
return pm;
}
QSvgRenderer renderer;
d->loadDataForModeAndState(&renderer, mode, state);
if (!renderer.isValid())
return pm;
QSize actualSize = renderer.defaultSize();
if (!actualSize.isNull())
actualSize.scale(size, Qt::KeepAspectRatio);
// Generate an image of the requested size, but render the
// the SVG with the correct aspect ratio centered in the image
// to prevent scaling issues when setting non square icon size.
QImage img(size, QImage::Format_ARGB32);
img.fill(0x00000000);
QPainter p(&img);
renderer.render(&p, getBounds(size, actualSize));
p.end();
pm = QPixmap::fromImage(img);
if (!pm.isNull())
QPixmapCache::insert(pmckey, pm);
return pm;
}
QPixmap MIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
{
QPixmap pm;
QString pmckey(d->pmcKey(size, mode, state));
if (QPixmapCache::find(pmckey, pm))
return pm;
if (d->addedPixmaps) {
pm = d->addedPixmaps->value(d->hashKey(mode, state));
if (!pm.isNull() && pm.size() == size)
return pm;
}
QSvgRenderer renderer;
d->loadDataForModeAndState(&renderer, mode, state);
if (!renderer.isValid())
return pm;
QSize actualSize = renderer.defaultSize();
if (!actualSize.isNull())
actualSize.scale(size, Qt::KeepAspectRatio);
QImage img(actualSize, QImage::Format_ARGB32);
img.fill(0x00000000);
QPainter p(&img);
renderer.render(&p);
p.end();
bool light = Ms::preferences.globalStyle == Ms::STYLE_LIGHT;
int ww = img.width();
if (state == QIcon::On) {
if (light) {
for (int y = 0; y < img.height(); ++y) {
QRgb *scanLine = (QRgb*)img.scanLine(y);
for (int x = 0; x < img.width(); ++x) {
QRgb pixel = *scanLine;
int alpha = qAlpha(pixel);
if (alpha < 0)
alpha = 0;
*scanLine = qRgba(qRed(255-pixel), qGreen(255-pixel), qBlue(255-pixel), alpha);
++scanLine;
}
}
}
else {
for (int y = 0; y < img.height(); ++y) {
quint32* p = (quint32*)img.scanLine(y);
for (int x = 0; x < ww; ++x) {
if (*p & 0xff000000) {
int d = 0xff - (*p & 0xff);
int dd = 50;
QColor color(QColor::fromRgba(*p));
int r = 70 - d + dd;
if (r < 0)
r = 0;
int g = 130 - d + dd;
if (g < 0)
g = 0;
int b = 180 - d + dd;
if (b < 0)
b = 0;
QColor nc = QColor(r, g, b, color.alpha());
*p = nc.rgba();
}
++p;
}
}
}
}
else {
// change alpha channel
int delta = 51;
if (mode == QIcon::Disabled)
delta = 178;
else if (state == QIcon::On)
delta = 0;
if (light) {
for (int y = 0; y < img.height(); ++y) {
QRgb *scanLine = (QRgb*)img.scanLine(y);
for (int x = 0; x < img.width(); ++x) {
QRgb pixel = *scanLine;
int alpha = qAlpha(pixel) - delta;
if (alpha < 0)
alpha = 0;
*scanLine = qRgba(qRed(255-pixel), qGreen(255-pixel), qBlue(255-pixel), alpha);
++scanLine;
}
}
}
else {
for (int y = 0; y < img.height(); ++y) {
QRgb *scanLine = (QRgb*)img.scanLine(y);
for (int x = 0; x < img.width(); ++x) {
QRgb pixel = *scanLine;
int alpha = qAlpha(pixel) - delta;
if (alpha < 0)
alpha = 0;
*scanLine = qRgba(qRed(pixel), qGreen(pixel), qBlue(pixel), alpha);
++scanLine;
}
}
}
}
pm = QPixmap::fromImage(img);
if (!pm.isNull())
QPixmapCache::insert(pmckey, pm);
return pm;
}
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;
}
/**
Supported id format: fileName[!elementName[?parameters]]
where parameters may be:
vslice=1:2;hslice=2:4 - use the 3rd horizontal slice of total 4 slices, slice numbering starts from 0
borders=1 - 1 pixel wide transparent border
requestedSize is related to the whole element size, even if slice is requested.
usage:
Image {
source: "image://svg/pfd.svg!world"
}
*/
QImage SvgImageProvider::requestImage(const QString &id, QSize *size, const QSize &requestedSize)
{
QString svgFile = id;
QString element;
QString parameters;
int separatorPos = id.indexOf('!');
if (separatorPos != -1) {
svgFile = id.left(separatorPos);
element = id.mid(separatorPos+1);
}
int parametersPos = element.indexOf('?');
if (parametersPos != -1) {
parameters = element.mid(parametersPos+1);
element = element.left(parametersPos);
}
int hSlicesCount = 0;
int hSlice = 0;
int vSlicesCount = 0;
int vSlice = 0;
int border = 0;
if (!parameters.isEmpty()) {
QRegExp hSliceRx("hslice=(\\d+):(\\d+)");
if (hSliceRx.indexIn(parameters) != -1) {
hSlice = hSliceRx.cap(1).toInt();
hSlicesCount = hSliceRx.cap(2).toInt();
}
QRegExp vSliceRx("vslice=(\\d+):(\\d+)");
if (vSliceRx.indexIn(parameters) != -1) {
vSlice = vSliceRx.cap(1).toInt();
vSlicesCount = vSliceRx.cap(2).toInt();
}
QRegExp borderRx("border=(\\d+)");
if (borderRx.indexIn(parameters) != -1) {
border = borderRx.cap(1).toInt();
}
}
if (size)
*size = QSize();
QSvgRenderer *renderer = loadRenderer(svgFile);
if (!renderer)
return QImage();
qreal xScale = 1.0;
qreal yScale = 1.0;
QSize docSize = renderer->defaultSize();
if (!requestedSize.isEmpty()) {
if (!element.isEmpty()) {
QRectF elementBounds = renderer->boundsOnElement(element);
xScale = qreal(requestedSize.width())/elementBounds.width();
yScale = qreal(requestedSize.height())/elementBounds.height();
} else if (!docSize.isEmpty()) {
xScale = qreal(requestedSize.width())/docSize.width();
yScale = qreal(requestedSize.height())/docSize.height();
}
}
//keep the aspect ratio
//TODO: how to configure it? as a part of image path?
xScale = yScale = qMin(xScale, yScale);
if (!element.isEmpty()) {
if (!renderer->elementExists(element)) {
qWarning() << "invalid element:" << element << "of" << svgFile;
return QImage();
}
QRectF elementBounds = renderer->boundsOnElement(element);
int elementWidth = qRound(elementBounds.width() * xScale);
int elementHeigh = qRound(elementBounds.height() * yScale);
int w = elementWidth;
int h = elementHeigh;
int x = 0;
int y = 0;
if (hSlicesCount > 1) {
x = (w*hSlice)/hSlicesCount;
w = (w*(hSlice+1))/hSlicesCount - x;
}
if (vSlicesCount > 1) {
y = (h*(vSlice))/vSlicesCount;
h = (h*(vSlice+1))/vSlicesCount - y;
}
QImage img(w+border*2, h+border*2, QImage::Format_ARGB32_Premultiplied);
img.fill(0);
QPainter p(&img);
p.setRenderHints(QPainter::TextAntialiasing |
QPainter::Antialiasing |
QPainter::SmoothPixmapTransform);
p.translate(-x+border,-y+border);
renderer->render(&p, element, QRectF(0, 0, elementWidth, elementHeigh));
if (size)
*size = QSize(w, h);
//img.save(element+parameters+".png");
return img;
} else {
//render the whole svg file
int w = qRound(docSize.width() * xScale);
int h = qRound(docSize.height() * yScale);
QImage img(w, h, QImage::Format_ARGB32_Premultiplied);
img.fill(0);
QPainter p(&img);
p.setRenderHints(QPainter::TextAntialiasing |
QPainter::Antialiasing |
QPainter::SmoothPixmapTransform);
p.scale(xScale, yScale);
renderer->render(&p, QRectF(QPointF(), QSizeF(docSize)));
if (size)
*size = QSize(w, h);
return img;
}
}
QPixmap QgsGrassModule::pixmap( QString path, int height )
{
//QgsDebugMsg( QString( "path = %1" ).arg( path ) );
QList<QPixmap> pixmaps;
// Create vector of available pictures
int cnt = 1;
for ( ;; )
{
// SVG
QString fpath = path + "." + QString::number( cnt ) + ".svg";
QFileInfo fi( fpath );
if ( fi.exists() )
{
QSvgRenderer pic;
if ( ! pic.load( fpath ) )
break;
QRect br( QPoint( 0, 0 ), pic.defaultSize() );
double scale = 1. * height / br.height();
int width = ( int )( scale * br.width() );
if ( width <= 0 )
width = height; // should not happen
QPixmap pixmap( width, height );
pixmap.fill( Qt::transparent );
//pixmap.fill( QColor( 255, 255, 255 ) );
QPainter painter( &pixmap );
painter.setRenderHint( QPainter::Antialiasing );
pic.render( &painter );
painter.end();
pixmaps << pixmap;
}
else // PNG
{
fpath = path + "." + QString::number( cnt ) + ".png";
fi.setFile( fpath );
if ( !fi.exists() )
break;
QPixmap pixmap;
if ( ! pixmap.load( fpath, "PNG" ) )
break;
double scale = 1. * height / pixmap.height();
int width = ( int )( scale * pixmap.width() );
QImage img = pixmap.toImage();
img = img.scaled( width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
pixmap = QPixmap::fromImage( img );
pixmaps.push_back( pixmap );
}
cnt++;
}
if ( pixmaps.isEmpty() )
{
return QPixmap();
}
// Get total width
int width = 0;
for ( int i = 0; i < pixmaps.size(); i++ )
{
width += pixmaps[i].width();
}
if ( width <= 0 )
width = height; //should not happen
QString iconsPath = QgsApplication::pkgDataPath() + "/grass/modules/";
QFileInfo iconsfi( iconsPath );
int plusWidth = 8;
int arrowWidth = 9;
QString arrowPath = iconsPath + "grass_arrow.png";
QPixmap arrowPixmap;
iconsfi.setFile( arrowPath );
if ( iconsfi.exists() && arrowPixmap.load( arrowPath, "PNG" ) )
{
double scale = 1. * height / arrowPixmap.height();
arrowWidth = ( int )( scale * arrowPixmap.width() );
QImage img = arrowPixmap.toImage();
img = img.scaled( arrowWidth, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
arrowPixmap = QPixmap::fromImage( img );
}
#if 0
if ( iconsfi.exists() )
{
QSvgRenderer pic;
if ( pic.load( arrowPath ) )
{
QRect br( QPoint( 0, 0 ), pic.defaultSize() );
double scale = 1. * height / br.height();
arrowWidth = ( int )( scale * br.width() );
if ( arrowWidth <= 0 )
arrowWidth = height; // should not happen
arrowPixmap = QPixmap( arrowWidth, height );
arrowPixmap.fill( Qt::transparent );
QPainter painter( &arrowPixmap );
painter.setRenderHint( QPainter::Antialiasing );
pic.render( &painter );
painter.end();
}
}
#endif
QString plusPath = iconsPath + "grass_plus.svg";
QPixmap plusPixmap;
iconsfi.setFile( plusPath );
#if 0
if ( iconsfi.exists() && plusPixmap.load( plusPath, "PNG" ) )
{
double scale = 1. * height / plusPixmap.height();
plusWidth = ( int )( scale * plusPixmap.width() );
QImage img = plusPixmap.toImage();
img = img.scaled( plusWidth, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
plusPixmap = QPixmap::fromImage( img );
}
#endif
if ( iconsfi.exists() )
{
QSvgRenderer pic;
if ( pic.load( plusPath ) )
{
QRect br( QPoint( 0, 0 ), pic.defaultSize() );
double scale = 1. * height / br.height();
plusWidth = ( int )( scale * br.width() );
if ( plusWidth <= 0 )
plusWidth = height; // should not happen
plusPixmap = QPixmap( plusWidth, height );
plusPixmap.fill( Qt::transparent );
QPainter painter( &plusPixmap );
painter.setRenderHint( QPainter::Antialiasing );
pic.render( &painter );
painter.end();
}
}
int buffer = height / 3; // buffer around a sign
if ( pixmaps.size() > 1 )
width += arrowWidth + 2 * buffer; // ->
if ( pixmaps.size() > 2 )
width += plusWidth + 2 * buffer; // +
QPixmap pixmap( width, height );
pixmap.fill( Qt::transparent );
//pixmap.fill( QColor( 255, 255, 255 ) );
QPainter painter( &pixmap );
//QColor color( 255, 255, 255 );
//painter.setBrush( QBrush( color ) );
painter.setRenderHint( QPainter::Antialiasing );
int pos = 0;
for ( int i = 0; i < pixmaps.size(); i++ )
{
if ( i == 1 && pixmaps.size() == 3 ) // +
{
pos += buffer;
painter.drawPixmap( pos, 0, plusPixmap );
pos += buffer + plusWidth;
}
if ( ( i == 1 && pixmaps.size() == 2 ) || ( i == 2 && pixmaps.size() == 3 ) ) // ->
{
pos += buffer;
painter.drawPixmap( pos, 0, arrowPixmap );
pos += buffer + arrowWidth;
}
painter.drawPixmap( pos, 0, pixmaps[i] );
pos += pixmaps[i].width();
}
painter.end();
return pixmap;
}
void SvgWindow::setFile(QString fileName)
{
svgWidget->load(fileName);
QSvgRenderer *render = svgWidget->renderer();
svgWidget->resize(render->defaultSize());
}
/**
requestedSize is realted to the whole svg file, not to specific element
*/
QImage SvgImageProvider::requestImage(const QString &id, QSize *size, const QSize &requestedSize)
{
QString svgFile = id;
QString element;
int separatorPos = id.indexOf('!');
if (separatorPos != -1) {
svgFile = id.left(separatorPos);
element = id.mid(separatorPos+1);
}
if (size)
*size = QSize();
QSvgRenderer *renderer = m_renderers.value(svgFile);
if (!renderer) {
renderer = new QSvgRenderer(svgFile);
QString fn = QUrl::fromLocalFile(m_basePath).resolved(svgFile).toLocalFile();
//convert path to be relative to base
if (!renderer->isValid())
renderer->load(fn);
if (!renderer->isValid()) {
qWarning() << "Failed to load svg file:" << svgFile << fn;
return QImage();
}
m_renderers.insert(svgFile, renderer);
}
qreal xScale = 1.0;
qreal yScale = 1.0;
QSize docSize = renderer->defaultSize();
if (!requestedSize.isEmpty() && !docSize.isEmpty()) {
xScale = qreal(requestedSize.width())/docSize.width();
yScale = qreal(requestedSize.height())/docSize.height();
}
//keep the aspect ratio
//TODO: how to configure it? as a part of image path?
xScale = yScale = qMin(xScale, yScale);
if (!element.isEmpty()) {
if (!renderer->elementExists(element)) {
qWarning() << "invalid element:" << element << "of" << svgFile;
return QImage();
}
QRectF elementBounds = renderer->boundsOnElement(element);
int w = qRound(elementBounds.width() * xScale);
int h = qRound(elementBounds.height() * yScale);
QImage img(w, h, QImage::Format_ARGB32_Premultiplied);
img.fill(0);
QPainter p(&img);
renderer->render(&p, element);
if (size)
*size = QSize(w, h);
return img;
} else {
//render the whole svg file
int w = qRound(docSize.width() * xScale);
int h = qRound(docSize.height() * yScale);
QImage img(w, h, QImage::Format_ARGB32_Premultiplied);
img.fill(0);
QPainter p(&img);
renderer->render(&p);
if (size)
*size = QSize(w, h);
return img;
}
}
QSizeF HbIconSource::defaultSize()
{
// If the default size has not been fetched yet, do it now.
if (!mDefaultSize.isValid()) {
type(); // make sure type is initialized
if (mType == "NVG") {
#ifndef HB_BOOTSTRAPPED
#ifdef HB_NVG_CS_ICON
if (!mByteArray) {
QFile file(mFilename);
if (!file.open(QIODevice::NotOpen | QIODevice::ReadOnly)) {
return QSizeF();
}
mByteArray = new QByteArray(file.readAll());
}
HbNvgEngine nvgEngine;
mDefaultSize = nvgEngine.contentDimensions(*mByteArray);
#endif // HB_NVG_CS_ICON
#else // HB_BOOTSTRAPPED
if (!mByteArray) {
QFile file(mFilename);
if (!file.open(QIODevice::NotOpen | QIODevice::ReadOnly)) {
return QSizeF();
}
mByteArray = new QByteArray(file.readAll());
}
mDefaultSize = nvgContentDimensions(*mByteArray);
#endif
} else if (mType == "SVG") {
QSvgRenderer *renderer = svgRenderer();
if (renderer) { // isValid() is already checked in svgRenderer()
mDefaultSize = renderer->defaultSize();
}
releaseSvgRenderer();
} else if (mType == "PIC") {
if (!mPicture) {
mPicture = new QPicture;
mPicture->load(mFilename);
}
mDefaultSize = mPicture->boundingRect().size();
}
// Image reader supports getting the default size without rasterizing the image so
// using it with the formats that it supports.
else if (mType == "MNG" || mType == "GIF" || mType == "JPG" || mType == "PNG") {
// Note that QImageReader::canRead() results in opening the file and so the
// file will be locked until the QImageReader instance is
// destroyed. Therefore the image reader instance must be destroyed as soon
// as possible and must not be kept for later use.
// Exception: Files on Z drive on Symbian. See canKeepOpen() and releaseImageReader().
QImageReader *reader = imageReader();
if (reader) { // canRead() is already checked in imageReader()
if (mType != "MNG") {
mDefaultSize = reader->size();
} else {
// MNG handler does not support size query so have to render it to get the size
QImage img = reader->read();
mDefaultSize = img.size();
}
}
releaseImageReader();
} else if (mType != "BLOB") {
if (!mPixmap) {
mPixmap = new QPixmap(mFilename);
}
mDefaultSize = mPixmap->size();
}
}
return QSizeF(mDefaultSize);
}
QucsActiveFilter::QucsActiveFilter(QWidget *parent)
: QMainWindow(parent)
{
Nfil = 4;
Fc = 1000;
ftyp = Filter::NoFilter;
QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
// -------- create menubar -------------------
QMenu *fileMenu = new QMenu(tr("&File"));
QAction * fileQuit = new QAction(tr("E&xit"), this);
fileQuit->setShortcut(Qt::CTRL+Qt::Key_Q);
connect(fileQuit, SIGNAL(activated()), SLOT(close()));
fileMenu->addAction(fileQuit);
QMenu *helpMenu = new QMenu(tr("&Help"), this);
QAction * helpHelp = new QAction(tr("Help..."), this);
helpHelp->setShortcut(Qt::Key_F1);
connect(helpHelp, SIGNAL(activated()), SLOT(slotHelpIntro()));
QAction * helpAbout = new QAction(tr("&About QucsActiveFilter..."), this);
helpMenu->addAction(helpAbout);
connect(helpAbout, SIGNAL(activated()), SLOT(slotHelpAbout()));
QAction * helpAboutQt = new QAction(tr("About Qt..."), this);
helpMenu->addAction(helpAboutQt);
connect(helpAboutQt, SIGNAL(activated()), SLOT(slotHelpAboutQt()));
helpMenu->addAction(helpHelp);
helpMenu->addSeparator();
helpMenu->addAction(helpAbout);
helpMenu->addAction(helpAboutQt);
menuBar()->addMenu(fileMenu);
menuBar()->addSeparator();
menuBar()->addMenu(helpMenu);
//lblInputData = new QLabel(tr("Входные данные"));
lblA1 = new QLabel(tr("Passband attenuation, Ap (dB)"));
lblA2 = new QLabel(tr("Stopband attenuation, As (dB)"));
lblF1 = new QLabel(tr("Cuttof frequency, Fc (Hz)"));
lblF2 = new QLabel(tr("Stopband frequency, Fs (Hz)"));
lblRpl1 = new QLabel(tr("Passband ripple Rp(dB)"));
//lblRpl2 = new QLabel(tr("Stopband ripple (dB)"));
lblKv = new QLabel(tr("Passband gain, Kv (dB)"));
edtA1 = new QLineEdit("3");
QDoubleValidator *val1 = new QDoubleValidator(0,100000,3);
edtA1->setValidator(val1);
edtA2 = new QLineEdit("20");
edtA2->setValidator(val1);
edtF1 = new QLineEdit("1000");
edtF1->setValidator(val1);
edtF2 = new QLineEdit("1200");
edtF2->setValidator(val1);
edtPassbRpl = new QLineEdit("3");
edtPassbRpl->setValidator(val1);
//edtStopbRpl = new QLineEdit("3");
//edtStopbRpl->setValidator(val1);
edtKv = new QLineEdit("0");
edtKv->setValidator(val1);
QIntValidator *val2 = new QIntValidator(2,20);
lblOrder = new QLabel(tr("Filter order"));
edtOrder = new QLineEdit("5");
edtOrder->setValidator(val2);
lblTyp = new QLabel(tr("Approximation type:"));
cbxFilterFunc = new QComboBox;
QStringList lst2;
lst2<<tr("Butterworth")
<<tr("Chebyshev")
<<tr("Inverse Chebyshev")
<<tr("Cauer (Elliptic)")
<<tr("Bessel")
<<tr("User defined");
cbxFilterFunc->addItems(lst2);
connect(cbxFilterFunc,SIGNAL(currentIndexChanged(int)),this,SLOT(slotSwitchParameters()));
btnDefineTransferFunc = new QPushButton(tr("Manually define transfer function"));
btnDefineTransferFunc->setEnabled(false);
connect(btnDefineTransferFunc,SIGNAL(clicked()),this,SLOT(slotDefineTransferFunc()));
btnCalcSchematic = new QPushButton(tr("Calculate and copy to clipboard"));
connect(btnCalcSchematic,SIGNAL(clicked()),SLOT(slotCalcSchematic()));
lblResult = new QLabel(tr("Calculation console"));
txtResult = new QTextEdit;
lblSch = new QLabel(tr("Filter topology"));
lblResp = new QLabel(tr("Filter type:"));
cbxResponse = new QComboBox;
QStringList lst3;
lst3<<tr("LowPass")
<<tr("High Pass")
<<tr("Band Pass")
<<tr("Band Stop");
cbxResponse->addItems(lst3);
connect(cbxResponse,SIGNAL(currentIndexChanged(int)),this,SLOT(slotUpdateResponse()));
connect(cbxResponse,SIGNAL(currentIndexChanged(int)),this,SLOT(slotUpdateSchematic()));
connect(cbxResponse,SIGNAL(currentIndexChanged(int)),this,SLOT(slotSetLabels()));
connect(cbxResponse,SIGNAL(currentIndexChanged(int)),this,SLOT(slotSwitchParameters()));
cbxFilterType = new QComboBox;
QStringList lst;
lst<<tr("Multifeedback (MFB)")
<<tr("Sallen-Key (S-K)")
<<tr("Cauer section");
//<<tr("Пассивный");
cbxFilterType->addItems(lst);
connect(cbxFilterType,SIGNAL(currentIndexChanged(int)),this,SLOT(slotUpdateSchematic()));
this->slotSwitchParameters();
cbxFilterType->setMaxCount(3);
lblAFR = new QLabel(tr("General amplitude frequency response"));
lblTopology = new QLabel(tr("Filter topology preview (one stage)"));
QString s1 = ":/images/bitmaps/AFR.svg";
QSvgRenderer *ren = new QSvgRenderer(s1);
QSize sz = ren->defaultSize();
sz *= 1.3;
delete ren;
imgAFR = new QSvgWidget(s1);
imgAFR->setFixedSize(sz);
imgAFR->show();
s1 = ":/images/bitmaps/cauer.svg";
ren = new QSvgRenderer(s1);
sz = ren->defaultSize();
sz *= 0.65;
delete ren;
sch_pic = new QSvgWidget(s1);
sch_pic->setFixedSize(sz);
sch_pic->show();
this->slotUpdateSchematic();
top = new QHBoxLayout;
left = new QVBoxLayout;
center = new QVBoxLayout;
right = new QHBoxLayout;
//left->addWidget(lblInputData);
QGroupBox *gpbPar = new QGroupBox(tr("Filter parameters"));
QGridLayout *vl3 = new QGridLayout;
vl3->setSpacing(3);
vl3->addWidget(lblA1,0,0);
vl3->addWidget(edtA1,0,1);
vl3->addWidget(lblA2,1,0);
vl3->addWidget(edtA2,1,1);
vl3->addWidget(lblF1,2,0);
vl3->addWidget(edtF1,2,1);
vl3->addWidget(lblF2,3,0);
vl3->addWidget(edtF2,3,1);
vl3->addWidget(lblRpl1,4,0);
vl3->addWidget(edtPassbRpl,4,1);
vl3->addWidget(lblKv,5,0);
vl3->addWidget(edtKv,5,1);
vl3->addWidget(lblOrder,6,0);
vl3->addWidget(edtOrder,6,1);
left->addWidget(gpbPar);
gpbPar->setLayout(vl3);
QGroupBox *gpbFunc = new QGroupBox(tr("Transfer function and Topology"));
QVBoxLayout *vl4 = new QVBoxLayout;
QHBoxLayout *l3 = new QHBoxLayout;
l3->addWidget(lblTyp);
l3->addWidget(cbxFilterFunc);
vl4->addLayout(l3);
vl4->addWidget(btnDefineTransferFunc);
QHBoxLayout *l1 = new QHBoxLayout;
l1->addWidget(lblResp);
l1->addWidget(cbxResponse);
vl4->addLayout(l1);
QHBoxLayout *l2 = new QHBoxLayout;
l2->addWidget(lblSch);
l2->addWidget(cbxFilterType);
vl4->addLayout(l2);
vl4->addWidget(btnCalcSchematic);
gpbFunc->setLayout(vl4);
left->addWidget(gpbFunc);
left->addStretch();
QGroupBox *gpbAFR = new QGroupBox(tr("General filter amplidure-frequency response"));
QVBoxLayout *vl1 = new QVBoxLayout;
vl1->addWidget(imgAFR);
gpbAFR->setLayout(vl1);
right->addWidget(gpbAFR);
QGroupBox *gpbSCH = new QGroupBox(tr("Filter topology preview"));
QVBoxLayout *vl2 = new QVBoxLayout;
vl2->addWidget(sch_pic);
gpbSCH->setLayout(vl2);
right->addWidget(gpbSCH);
/*right->addWidget(lblAFR);
right->addWidget(imgAFR);
right->addWidget(lblTopology);
right->addWidget(sch_pic);
right->addStretch();*/
top->addLayout(left);
top->addLayout(center);
top->addLayout(right);
top1 = new QVBoxLayout;
top1->addLayout(top);
QSplitter *sp1 = new QSplitter;
top1->addWidget(sp1);
txtResult->setReadOnly(true);
QGroupBox *gpbCons = new QGroupBox(tr("Filter calculation console"));
QVBoxLayout *vl5 = new QVBoxLayout;
vl5->addWidget(txtResult);
gpbCons->setLayout(vl5);
top1->addWidget(gpbCons);
txtResult->setMinimumHeight(180);
zenter = new QWidget;
this->setCentralWidget(zenter);
zenter->setLayout(top1);
}
