PDA

View Full Version : Purpose of ArthurFrame?



StarShaper
13th February 2012, 00:21
Hi,

I found some classes in the Qt demo apps. A lot of them are using ArthurFrame. This is a small class, that extends QWidget and QGLWidget. What purpose they do serve?


#ifndef ARTHURWIDGETS_H
#define ARTHURWIDGETS_H

#include "arthurstyle.h"
#include <QBitmap>
#include <QPushButton>
#include <QGroupBox>

#if defined(QT_OPENGL_SUPPORT)
#include <QGLWidget>
#include <QEvent>
class GLWidget : public QGLWidget
{
public:
GLWidget(QWidget *parent)
: QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
{
setAttribute(Qt::WA_AcceptTouchEvents);
}
void disableAutoBufferSwap() { setAutoBufferSwap(false); }
void paintEvent(QPaintEvent *) { parentWidget()->update(); }
protected:
bool event(QEvent *event)
{
switch (event->type()) {
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
case QEvent::TouchEnd:
event->ignore();
return false;
break;
default:
break;
}
return QGLWidget::event(event);
}
};
#endif

QT_FORWARD_DECLARE_CLASS(QTextDocument)
QT_FORWARD_DECLARE_CLASS(QTextEdit)
QT_FORWARD_DECLARE_CLASS(QVBoxLayout)

class ArthurFrame : public QWidget
{
Q_OBJECT
public:
ArthurFrame(QWidget *parent);
virtual void paint(QPainter *) {}


void paintDescription(QPainter *p);

void loadDescription(const QString &filename);
void setDescription(const QString &htmlDesc);

void loadSourceFile(const QString &fileName);

bool preferImage() const { return m_prefer_image; }

#if defined(QT_OPENGL_SUPPORT)
QGLWidget *glWidget() const { return glw; }
#endif

public slots:
void setPreferImage(bool pi) { m_prefer_image = pi; }
void setDescriptionEnabled(bool enabled);
void showSource();

#if defined(QT_OPENGL_SUPPORT)
void enableOpenGL(bool use_opengl);
bool usesOpenGL() { return m_use_opengl; }
#endif

signals:
void descriptionEnabledChanged(bool);

protected:
void paintEvent(QPaintEvent *);
void resizeEvent(QResizeEvent *);

#if defined(QT_OPENGL_SUPPORT)
GLWidget *glw;
bool m_use_opengl;
#endif
QPixmap m_tile;

bool m_show_doc;
bool m_prefer_image;
QTextDocument *m_document;

QString m_sourceFileName;

};

#endif


#include "arthurwidgets.h"
#include <QApplication>
#include <QPainter>
#include <QPainterPath>
#include <QPixmapCache>
#include <QtEvents>
#include <QTextDocument>
#include <QAbstractTextDocumentLayout>
#include <QFile>
#include <QTextBrowser>
#include <QBoxLayout>

#include <private/qpixmapdata_p.h>

extern QPixmap cached(const QString &img);

ArthurFrame::ArthurFrame(QWidget *parent)
: QWidget(parent)
, m_prefer_image(false)
{
#ifdef QT_OPENGL_SUPPORT
glw = 0;
m_use_opengl = false;
QGLFormat f = QGLFormat::defaultFormat();
f.setSampleBuffers(true);
f.setStencil(true);
f.setAlpha(true);
f.setAlphaBufferSize(8);
QGLFormat::setDefaultFormat(f);
#endif
m_document = 0;
m_show_doc = false;

m_tile = QPixmap(128, 128);
m_tile.fill(Qt::white);
QPainter pt(&m_tile);
QColor color(230, 230, 230);
pt.fillRect(0, 0, 64, 64, color);
pt.fillRect(64, 64, 64, 64, color);
pt.end();

// QPalette pal = palette();
// pal.setBrush(backgroundRole(), m_tile);
// setPalette(pal);

#ifdef Q_WS_X11
QPixmap xRenderPixmap(1, 1);
m_prefer_image = xRenderPixmap.pixmapData()->classId() == QPixmapData::X11Class && !xRenderPixmap.x11PictureHandle();
#endif
}


#ifdef QT_OPENGL_SUPPORT
void ArthurFrame::enableOpenGL(bool use_opengl)
{
m_use_opengl = use_opengl;

if (!glw) {
glw = new GLWidget(this);
glw->setAutoFillBackground(false);
glw->disableAutoBufferSwap();
QApplication::postEvent(this, new QResizeEvent(size(), size()));
}

if (use_opengl) {
glw->show();
} else {
glw->hide();
}

update();
}
#endif

void ArthurFrame::paintEvent(QPaintEvent *e)
{
#ifdef Q_WS_QWS
static QPixmap *static_image = 0;
#else
static QImage *static_image = 0;
#endif
QPainter painter;
if (preferImage()
#ifdef QT_OPENGL_SUPPORT
&& !m_use_opengl
#endif
) {
if (!static_image || static_image->size() != size()) {
delete static_image;
#ifdef Q_WS_QWS
static_image = new QPixmap(size());
#else
static_image = new QImage(size(), QImage::Format_RGB32);
#endif
}
painter.begin(static_image);

int o = 10;

QBrush bg = palette().brush(QPalette::Background);
painter.fillRect(0, 0, o, o, bg);
painter.fillRect(width() - o, 0, o, o, bg);
painter.fillRect(0, height() - o, o, o, bg);
painter.fillRect(width() - o, height() - o, o, o, bg);
} else {
#ifdef QT_OPENGL_SUPPORT
if (m_use_opengl) {
painter.begin(glw);
painter.fillRect(QRectF(0, 0, glw->width(), glw->height()), palette().color(backgroundRole()));
} else {
painter.begin(this);
}
#else
painter.begin(this);
#endif
}

painter.setClipRect(e->rect());

painter.setRenderHint(QPainter::Antialiasing);

QPainterPath clipPath;

QRect r = rect();
qreal left = r.x() + 1;
qreal top = r.y() + 1;
qreal right = r.right();
qreal bottom = r.bottom();
qreal radius2 = 8 * 2;

clipPath.moveTo(right - radius2, top);
clipPath.arcTo(right - radius2, top, radius2, radius2, 90, -90);
clipPath.arcTo(right - radius2, bottom - radius2, radius2, radius2, 0, -90);
clipPath.arcTo(left, bottom - radius2, radius2, radius2, 270, -90);
clipPath.arcTo(left, top, radius2, radius2, 180, -90);
clipPath.closeSubpath();

painter.save();
painter.setClipPath(clipPath, Qt::IntersectClip);

painter.drawTiledPixmap(rect(), m_tile);

// client painting

paint(&painter);

painter.restore();

painter.save();
if (m_show_doc)
paintDescription(&painter);
painter.restore();

int level = 180;
painter.setPen(QPen(QColor(level, level, level), 2));
painter.setBrush(Qt::NoBrush);
painter.drawPath(clipPath);

if (preferImage()
#ifdef QT_OPENGL_SUPPORT
&& !m_use_opengl
#endif
) {
painter.end();
painter.begin(this);
#ifdef Q_WS_QWS
painter.drawPixmap(e->rect(), *static_image, e->rect());
#else
painter.drawImage(e->rect(), *static_image, e->rect());
#endif
}

#ifdef QT_OPENGL_SUPPORT
if (m_use_opengl && (inherits("PathDeformRenderer") || inherits("PathStrokeRenderer") || inherits("CompositionRenderer") || m_show_doc))
glw->swapBuffers();
#endif
}

void ArthurFrame::resizeEvent(QResizeEvent *e)
{
#ifdef QT_OPENGL_SUPPORT
if (glw)
glw->setGeometry(0, 0, e->size().width()-1, e->size().height()-1);
#endif
QWidget::resizeEvent(e);
}

void ArthurFrame::setDescriptionEnabled(bool enabled)
{
if (m_show_doc != enabled) {
m_show_doc = enabled;
emit descriptionEnabledChanged(m_show_doc);
update();
}
}

void ArthurFrame::loadDescription(const QString &fileName)
{
QFile textFile(fileName);
QString text;
if (!textFile.open(QFile::ReadOnly))
text = QString("Unable to load resource file: '%1'").arg(fileName);
else
text = textFile.readAll();
setDescription(text);
}


void ArthurFrame::setDescription(const QString &text)
{
m_document = new QTextDocument(this);
m_document->setHtml(text);
}

void ArthurFrame::paintDescription(QPainter *painter)
{
if (!m_document)
return;

int pageWidth = qMax(width() - 100, 100);
int pageHeight = qMax(height() - 100, 100);
if (pageWidth != m_document->pageSize().width()) {
m_document->setPageSize(QSize(pageWidth, pageHeight));
}

QRect textRect(width() / 2 - pageWidth / 2,
height() / 2 - pageHeight / 2,
pageWidth,
pageHeight);
int pad = 10;
QRect clearRect = textRect.adjusted(-pad, -pad, pad, pad);
painter->setPen(Qt::NoPen);
painter->setBrush(QColor(0, 0, 0, 63));
int shade = 10;
painter->drawRect(clearRect.x() + clearRect.width() + 1,
clearRect.y() + shade,
shade,
clearRect.height() + 1);
painter->drawRect(clearRect.x() + shade,
clearRect.y() + clearRect.height() + 1,
clearRect.width() - shade + 1,
shade);

painter->setRenderHint(QPainter::Antialiasing, false);
painter->setBrush(QColor(255, 255, 255, 220));
painter->setPen(Qt::black);
painter->drawRect(clearRect);

painter->setClipRegion(textRect, Qt::IntersectClip);
painter->translate(textRect.topLeft());

QAbstractTextDocumentLayout::PaintContext ctx;

QLinearGradient g(0, 0, 0, textRect.height());
g.setColorAt(0, Qt::black);
g.setColorAt(0.9, Qt::black);
g.setColorAt(1, Qt::transparent);

QPalette pal = palette();
pal.setBrush(QPalette::Text, g);

ctx.palette = pal;
ctx.clip = QRect(0, 0, textRect.width(), textRect.height());
m_document->documentLayout()->draw(painter, ctx);
}

void ArthurFrame::loadSourceFile(const QString &sourceFile)
{
m_sourceFileName = sourceFile;
}

void ArthurFrame::showSource()
{
// Check for existing source
if (qFindChild<QTextBrowser *>(this))
return;

//...