PDA

View Full Version : problem drawing image



saman_artorious
24th February 2012, 17:16
I have problems drawing the output image in this program. The attached zip file contains the svg formatted images for the output.
Let's jump to my question:

1. The top n bottom rectangles are images. I want the angles of the bottom rectangle look rounded. In lines 254 to 257, a rectangle is created using QRect, I need to change this so that the bottom angles of the bottom rectangle look rounded.

2. You know, In lines 259 to 264 another left rectangle is to be added to the shape. How can I paint this rectangle to black when I create it?

I would thank if you add the required code to the following:



#include <QtCore/QDebug>
#include <QtGui/QMouseEvent>
#include <QtGui/QPainter>
#include <QtSvg/QSvgRenderer>

#include "qtmultislider.h"

/*!

\class QtMultiSlider qtmultislider.h

The description of the QtMultiSlider.

\brief The QtMultiSlider class provides a double slider with SVG
graphics.

The QtMultiSlider is an example to show the capabilities of the Qt Framework
related to customized controls.

Here is a possible implementation shown

\code

// Create a QtSvgDialGauge
QWidget * widget = new QWidget(this);
QtMultiSlider * slider = new QtMultiSlider("&Range", widget);
slider->setRange(0, 100);
slider->setMaximumRange(70);
slider->setValue(80);
slider->setSkin("Beryl");
widget->addWidget(slider);
widget->show();

\endcode

It is important to call the function \a setSkin() to load a skin. If \a setSkin() is not called
the QtMultiSlider will not have any visible content.
The parameter \p skin has the skin name. The skins are in the resource file defined in the project file.
The name scheme in the resource file is "Skin Name"/"unique picture name.svg".

The \a setSkin() function loads the diffrent skins over the "Skin name".
The needed graphics for this control are "normal.svg", "hovered.svg" and "pressed.svg".
If you want to add new skins, they have to follow the name scheme to work.

The current skin can be read over the \a skin() function.

\sa skin(), setSkin()


Signals: \n

\fn void maximumExceeded()
\fn void minimumExceeded()

Slots: \n

\fn void setMaximumRange()
\fn void setMinimumRange()
\fn void setValue()

*/

/*! \class QtMultiSliderHelper qtmultiSlider.h
\brief Private class of QtMultiSlider
*/

QtMultiSliderHelper::QtMultiSliderHelper(QWidget * parent)
: QAbstractSlider(parent)
{
}

QtMultiSliderHelper::~QtMultiSliderHelper()
{
}

void QtMultiSliderHelper::paintEvent(QPaintEvent * event)
{
Q_UNUSED(event)
}

QtMultiSlider::QtMultiSlider(QWidget * parent)
: QProgressBar(parent)
{
init();
}

QtMultiSlider::~QtMultiSlider()
{
}

void QtMultiSlider::setSkin(const QString& skin)
{
m_skin = skin;
const QString base = ":/multislider/" + skin + '/';

m_rendererValueBar->load(base + "valuebar.svg");
m_rendererValueBarFilled->load(base + "valuebar_filled.svg");
m_rendererValueBarTop->load(base + "valuebar_top.svg");
m_rendererValueBarBottom->load(base + "valuebar_bottom.svg");

m_topSliderRenderer = m_rendererTopSlider;
m_bottomSliderRenderer = m_rendererBottomSlider;

// update geometry for new sizeHint and repaint
updateGeometry();
update();
}

QString QtMultiSlider::skin() const
{
return m_skin;
}

void QtMultiSlider::init()
{


m_previousExceededMaximum = false;
m_previousExceededMinimum = false;

m_rendererValueBar = new QtSvgPixmapCache(this);
m_rendererValueBarFilled = new QtSvgPixmapCache(this);
m_rendererValueBarTop = new QtSvgPixmapCache(this);
m_rendererValueBarBottom = new QtSvgPixmapCache(this);
m_rendererTopSlider = new QtSvgPixmapCache(this);
m_rendererTopSliderHovered = new QtSvgPixmapCache(this);
m_rendererTopSliderPressed = new QtSvgPixmapCache(this);
m_rendererBottomSlider = new QtSvgPixmapCache(this);
m_rendererBottomSliderHovered = new QtSvgPixmapCache(this);
m_rendererBottomSliderPressed = new QtSvgPixmapCache(this);
m_rendererGroove = new QtSvgPixmapCache(this);

m_topSliderRenderer = m_rendererTopSlider;
m_bottomSliderRenderer = m_rendererBottomSlider;

//Prepare for mouse over ( "hover") detection
setMouseTracking(true);
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);

m_topSlider = new QtMultiSliderHelper(this);
m_topSlider->setValue(maximum());
m_topSlider->setMaximum(maximum());
m_topSlider->setMinimum(minimum());

m_bottomSlider = new QtMultiSliderHelper(this);
m_bottomSlider->setValue(minimum());
m_bottomSlider->setMaximum(maximum());
m_bottomSlider->setMinimum(minimum());

connect(m_topSlider, SIGNAL(valueChanged(int)), SLOT(checkMaximumRange(int)));
connect(m_bottomSlider, SIGNAL(valueChanged(int)), SLOT(checkMinimumRange(int)));
}


QtMultiSliderHelper * QtMultiSlider::topSlider()
{
return m_topSlider;
}


QtMultiSliderHelper * QtMultiSlider::bottomSlider()
{
return m_bottomSlider;
}


void QtMultiSlider::setValue(int value)
{
QProgressBar::setValue(value);

checkMaximumRange(topSlider()->value());
checkMinimumRange(bottomSlider()->value());
}


void QtMultiSlider::checkMaximumRange(int topSliderValue)
{
const bool exceeded = value() > topSliderValue;
if (m_previousExceededMaximum != exceeded) {
m_previousExceededMaximum = exceeded;
emit maximumExceeded(exceeded);
}
}


void QtMultiSlider::checkMinimumRange(int bottomSliderValue)
{
const bool exceeded = value() < bottomSliderValue;
if (m_previousExceededMinimum != exceeded) {
m_previousExceededMinimum = exceeded;
emit minimumExceeded(exceeded);
}
}

void QtMultiSlider::setMaximumRange(int maximum)
{
topSlider()->setValue(maximum);
}


void QtMultiSlider::setMinimumRange(int minimum)
{
bottomSlider()->setValue(minimum);
}


void QtMultiSlider::paintEvent(QPaintEvent * event)
{
Q_UNUSED(event)

if (!isVisible())
return;

QPainter painter;
painter.begin(this);

// Calculating the layout:
int spacing = 30;
int labelHeight = 0;

int valueBarWidth = 300;

// Calculating the maximum string size

int valueBarX = spacing;

int valueBarTopY = 0;
int valueBarBottomY = 0;

QSizeF originalSize = m_rendererValueBarTop->defaultSize();
QSizeF targetSize = originalSize;
targetSize.scale(QSizeF(valueBarWidth, originalSize.height()), Qt::KeepAspectRatio);
qreal scaleRatio = targetSize.width() /
originalSize.width();

QSize valueBarTopSize = m_rendererValueBarTop->defaultSize() * scaleRatio;


QRect valueBarTopRect = QRect(QPoint(valueBarX, valueBarTopY),
QPoint(valueBarX + 300, valueBarTopSize.height()));

m_rendererValueBarTop->render(&painter, valueBarTopRect);

QSize valueBarBottomSize = m_rendererValueBarBottom->defaultSize() * scaleRatio;

valueBarBottomY = height() - labelHeight - valueBarTopRect.bottom()
- valueBarBottomSize.height();

m_valueBarRightRect = QRect(QPoint(valueBarX, valueBarTopRect.bottom()),
QSize(valueBarWidth, valueBarBottomY));

m_rendererValueBar->render(&painter, m_valueBarRightRect);

QRect valueBarBottomRect = QRect(QPoint(valueBarX, m_valueBarRightRect.bottom()),
QPoint(valueBarX + 300, 200));

m_rendererValueBarBottom->render(&painter, valueBarBottomRect);

/*
m_valueBarLeftRect = QRect(QPoint(valueBarX - 20, valueBarTopRect.top() ),
QSize(valueBarX - 10, valueBarBottomRect.bottom() ));

m_rendererValueBar->render(&painter, m_valueBarLeftRect);
*/

// Drawing the actual value bar
int filledPixels = ((double)value()) / maximum() * m_valueBarRightRect.height();
QRect filledRect = m_valueBarRightRect;
filledRect.setTop(filledRect.bottom() - filledPixels);
m_rendererValueBarFilled->render(&painter, filledRect);

painter.end();

}

//----------------------------------------------------


int QtMultiSlider::valueToPixel(int value)
{
return (double)(value) / (double)(maximum() - minimum())
* (double)(m_valueBarRightRect.bottom() - m_valueBarRightRect.top());
}

int QtMultiSlider::pixelToValue(int pixel)
{
if (pixel < 0)
return minimum();
if (pixel > m_valueBarRightRect.bottom())
return maximum();

return (double)(pixel) / (double)(m_valueBarRightRect.bottom() - m_valueBarRightRect.top())
* (double)(maximum() - minimum());
}


QSize QtMultiSlider::minimumSizeHint() const
{
return QSize(80, 100);
}

QSize QtMultiSlider::sizeHint() const
{
return QSize(100, 200);
}

void QtMultiSlider::leaveEvent(QEvent * event)
{
Q_UNUSED(event)

update();
}

ChrisW67
25th February 2012, 07:37
I am not sure why this has anything to do with SVG.

Normally if you want a rounded rectangle when rendering your widget you would use QPainter::drawRoundedRect(). If you want a filled rectangle then use QPainter::fillRect().