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?

Qt Code: 
  1. #ifndef ARTHURWIDGETS_H
  2. #define ARTHURWIDGETS_H
  3.  
  4. #include "arthurstyle.h"
  5. #include <QBitmap>
  6. #include <QPushButton>
  7. #include <QGroupBox>
  8.  
  9. #if defined(QT_OPENGL_SUPPORT)
  10. #include <QGLWidget>
  11. #include <QEvent>
  12. class GLWidget : public QGLWidget
  13. {
  14. public:
  15.     GLWidget(QWidget *parent)
  16.         : QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
  17.     {
  18.         setAttribute(Qt::WA_AcceptTouchEvents);
  19.     }
  20.     void disableAutoBufferSwap() { setAutoBufferSwap(false); }
  21.     void paintEvent(QPaintEvent *) { parentWidget()->update(); }
  22. protected:
  23.     bool event(QEvent *event)
  24.     {
  25.         switch (event->type()) {
  26.         case QEvent::TouchBegin:
  27.         case QEvent::TouchUpdate:
  28.         case QEvent::TouchEnd:
  29.             event->ignore();
  30.             return false;
  31.             break;
  32.         default:
  33.             break;
  34.         }
  35.         return QGLWidget::event(event);
  36.     }
  37. };
  38. #endif
  39.  
  40. QT_FORWARD_DECLARE_CLASS(QTextDocument)
  41. QT_FORWARD_DECLARE_CLASS(QTextEdit)
  42. QT_FORWARD_DECLARE_CLASS(QVBoxLayout)
  43.  
  44. class ArthurFrame : public QWidget
  45. {
  46.     Q_OBJECT
  47. public:
  48.     ArthurFrame(QWidget *parent);
  49.     virtual void paint(QPainter *) {}
  50.  
  51.  
  52.     void paintDescription(QPainter *p);
  53.  
  54.     void loadDescription(const QString &filename);
  55.     void setDescription(const QString &htmlDesc);
  56.  
  57.     void loadSourceFile(const QString &fileName);
  58.  
  59.     bool preferImage() const { return m_prefer_image; }
  60.  
  61. #if defined(QT_OPENGL_SUPPORT)
  62.     QGLWidget *glWidget() const { return glw; }
  63. #endif
  64.  
  65. public slots:
  66.     void setPreferImage(bool pi) { m_prefer_image = pi; }
  67.     void setDescriptionEnabled(bool enabled);
  68.     void showSource();
  69.  
  70. #if defined(QT_OPENGL_SUPPORT)
  71.     void enableOpenGL(bool use_opengl);
  72.     bool usesOpenGL() { return m_use_opengl; }
  73. #endif
  74.  
  75. signals:
  76.     void descriptionEnabledChanged(bool);
  77.  
  78. protected:
  79.     void paintEvent(QPaintEvent *);
  80.     void resizeEvent(QResizeEvent *);
  81.  
  82. #if defined(QT_OPENGL_SUPPORT)
  83.     GLWidget *glw;
  84.     bool m_use_opengl;
  85. #endif
  86.     QPixmap m_tile;
  87.  
  88.     bool m_show_doc;
  89.     bool m_prefer_image;
  90.     QTextDocument *m_document;
  91.  
  92.     QString m_sourceFileName;
  93.  
  94. };
  95.  
  96. #endif
To copy to clipboard, switch view to plain text mode 

Qt Code: 
  1. #include "arthurwidgets.h"
  2. #include <QApplication>
  3. #include <QPainter>
  4. #include <QPainterPath>
  5. #include <QPixmapCache>
  6. #include <QtEvents>
  7. #include <QTextDocument>
  8. #include <QAbstractTextDocumentLayout>
  9. #include <QFile>
  10. #include <QTextBrowser>
  11. #include <QBoxLayout>
  12.  
  13. #include <private/qpixmapdata_p.h>
  14.  
  15. extern QPixmap cached(const QString &img);
  16.  
  17. ArthurFrame::ArthurFrame(QWidget *parent)
  18.     : QWidget(parent)
  19.     , m_prefer_image(false)
  20. {
  21. #ifdef QT_OPENGL_SUPPORT
  22.     glw = 0;
  23.     m_use_opengl = false;
  24.     QGLFormat f = QGLFormat::defaultFormat();
  25.     f.setSampleBuffers(true);
  26.     f.setStencil(true);
  27.     f.setAlpha(true);
  28.     f.setAlphaBufferSize(8);
  29.     QGLFormat::setDefaultFormat(f);
  30. #endif
  31.     m_document = 0;
  32.     m_show_doc = false;
  33.  
  34.     m_tile = QPixmap(128, 128);
  35.     m_tile.fill(Qt::white);
  36.     QPainter pt(&m_tile);
  37.     QColor color(230, 230, 230);
  38.     pt.fillRect(0, 0, 64, 64, color);
  39.     pt.fillRect(64, 64, 64, 64, color);
  40.     pt.end();
  41.  
  42. //     QPalette pal = palette();
  43. //     pal.setBrush(backgroundRole(), m_tile);
  44. //     setPalette(pal);
  45.  
  46. #ifdef Q_WS_X11
  47.     QPixmap xRenderPixmap(1, 1);
  48.     m_prefer_image = xRenderPixmap.pixmapData()->classId() == QPixmapData::X11Class && !xRenderPixmap.x11PictureHandle();
  49. #endif
  50. }
  51.  
  52.  
  53. #ifdef QT_OPENGL_SUPPORT
  54. void ArthurFrame::enableOpenGL(bool use_opengl)
  55. {
  56.     m_use_opengl = use_opengl;
  57.  
  58.     if (!glw) {
  59.         glw = new GLWidget(this);
  60.         glw->setAutoFillBackground(false);
  61.         glw->disableAutoBufferSwap();
  62.         QApplication::postEvent(this, new QResizeEvent(size(), size()));
  63.     }
  64.  
  65.     if (use_opengl) {
  66.         glw->show();
  67.     } else {
  68.         glw->hide();
  69.     }
  70.  
  71.     update();
  72. }
  73. #endif
  74.  
  75. void ArthurFrame::paintEvent(QPaintEvent *e)
  76. {
  77. #ifdef Q_WS_QWS
  78.     static QPixmap *static_image = 0;
  79. #else
  80.     static QImage *static_image = 0;
  81. #endif
  82.     QPainter painter;
  83.     if (preferImage()
  84. #ifdef QT_OPENGL_SUPPORT
  85.         && !m_use_opengl
  86. #endif
  87.         ) {
  88.         if (!static_image || static_image->size() != size()) {
  89.             delete static_image;
  90. #ifdef Q_WS_QWS
  91.             static_image = new QPixmap(size());
  92. #else
  93.             static_image = new QImage(size(), QImage::Format_RGB32);
  94. #endif
  95.         }
  96.         painter.begin(static_image);
  97.  
  98.         int o = 10;
  99.  
  100.         QBrush bg = palette().brush(QPalette::Background);
  101.         painter.fillRect(0, 0, o, o, bg);
  102.         painter.fillRect(width() - o, 0, o, o, bg);
  103.         painter.fillRect(0, height() - o, o, o, bg);
  104.         painter.fillRect(width() - o, height() - o, o, o, bg);
  105.     } else {
  106. #ifdef QT_OPENGL_SUPPORT
  107.         if (m_use_opengl) {
  108.             painter.begin(glw);
  109.             painter.fillRect(QRectF(0, 0, glw->width(), glw->height()), palette().color(backgroundRole()));
  110.         } else {
  111.             painter.begin(this);
  112.         }
  113. #else
  114.         painter.begin(this);
  115. #endif
  116.     }
  117.  
  118.     painter.setClipRect(e->rect());
  119.  
  120.     painter.setRenderHint(QPainter::Antialiasing);
  121.  
  122.     QPainterPath clipPath;
  123.  
  124.     QRect r = rect();
  125.     qreal left = r.x() + 1;
  126.     qreal top = r.y() + 1;
  127.     qreal right = r.right();
  128.     qreal bottom = r.bottom();
  129.     qreal radius2 = 8 * 2;
  130.  
  131.     clipPath.moveTo(right - radius2, top);
  132.     clipPath.arcTo(right - radius2, top, radius2, radius2, 90, -90);
  133.     clipPath.arcTo(right - radius2, bottom - radius2, radius2, radius2, 0, -90);
  134.     clipPath.arcTo(left, bottom - radius2, radius2, radius2, 270, -90);
  135.     clipPath.arcTo(left, top, radius2, radius2, 180, -90);
  136.     clipPath.closeSubpath();
  137.  
  138.     painter.save();
  139.     painter.setClipPath(clipPath, Qt::IntersectClip);
  140.  
  141.     painter.drawTiledPixmap(rect(), m_tile);
  142.  
  143.     // client painting
  144.  
  145.     paint(&painter);
  146.  
  147.     painter.restore();
  148.  
  149.     painter.save();
  150.     if (m_show_doc)
  151.         paintDescription(&painter);
  152.     painter.restore();
  153.  
  154.     int level = 180;
  155.     painter.setPen(QPen(QColor(level, level, level), 2));
  156.     painter.setBrush(Qt::NoBrush);
  157.     painter.drawPath(clipPath);
  158.  
  159.     if (preferImage()
  160. #ifdef QT_OPENGL_SUPPORT
  161.         && !m_use_opengl
  162. #endif
  163.         ) {
  164.         painter.end();
  165.         painter.begin(this);
  166. #ifdef Q_WS_QWS
  167.         painter.drawPixmap(e->rect(), *static_image, e->rect());
  168. #else
  169.         painter.drawImage(e->rect(), *static_image, e->rect());
  170. #endif
  171.     }
  172.  
  173. #ifdef QT_OPENGL_SUPPORT
  174.     if (m_use_opengl && (inherits("PathDeformRenderer") || inherits("PathStrokeRenderer") || inherits("CompositionRenderer") || m_show_doc))
  175.         glw->swapBuffers();
  176. #endif
  177. }
  178.  
  179. void ArthurFrame::resizeEvent(QResizeEvent *e)
  180. {
  181. #ifdef QT_OPENGL_SUPPORT
  182.     if (glw)
  183.         glw->setGeometry(0, 0, e->size().width()-1, e->size().height()-1);
  184. #endif
  185.     QWidget::resizeEvent(e);
  186. }
  187.  
  188. void ArthurFrame::setDescriptionEnabled(bool enabled)
  189. {
  190.     if (m_show_doc != enabled) {
  191.         m_show_doc = enabled;
  192.         emit descriptionEnabledChanged(m_show_doc);
  193.         update();
  194.     }
  195. }
  196.  
  197. void ArthurFrame::loadDescription(const QString &fileName)
  198. {
  199.     QFile textFile(fileName);
  200.     QString text;
  201.     if (!textFile.open(QFile::ReadOnly))
  202.         text = QString("Unable to load resource file: '%1'").arg(fileName);
  203.     else
  204.         text = textFile.readAll();
  205.     setDescription(text);
  206. }
  207.  
  208.  
  209. void ArthurFrame::setDescription(const QString &text)
  210. {
  211.     m_document = new QTextDocument(this);
  212.     m_document->setHtml(text);
  213. }
  214.  
  215. void ArthurFrame::paintDescription(QPainter *painter)
  216. {
  217.     if (!m_document)
  218.         return;
  219.  
  220.     int pageWidth = qMax(width() - 100, 100);
  221.     int pageHeight = qMax(height() - 100, 100);
  222.     if (pageWidth != m_document->pageSize().width()) {
  223.         m_document->setPageSize(QSize(pageWidth, pageHeight));
  224.     }
  225.  
  226.     QRect textRect(width() / 2 - pageWidth / 2,
  227.                    height() / 2 - pageHeight / 2,
  228.                    pageWidth,
  229.                    pageHeight);
  230.     int pad = 10;
  231.     QRect clearRect = textRect.adjusted(-pad, -pad, pad, pad);
  232.     painter->setPen(Qt::NoPen);
  233.     painter->setBrush(QColor(0, 0, 0, 63));
  234.     int shade = 10;
  235.     painter->drawRect(clearRect.x() + clearRect.width() + 1,
  236.                       clearRect.y() + shade,
  237.                       shade,
  238.                       clearRect.height() + 1);
  239.     painter->drawRect(clearRect.x() + shade,
  240.                       clearRect.y() + clearRect.height() + 1,
  241.                       clearRect.width() - shade + 1,
  242.                       shade);
  243.  
  244.     painter->setRenderHint(QPainter::Antialiasing, false);
  245.     painter->setBrush(QColor(255, 255, 255, 220));
  246.     painter->setPen(Qt::black);
  247.     painter->drawRect(clearRect);
  248.  
  249.     painter->setClipRegion(textRect, Qt::IntersectClip);
  250.     painter->translate(textRect.topLeft());
  251.  
  252.     QAbstractTextDocumentLayout::PaintContext ctx;
  253.  
  254.     QLinearGradient g(0, 0, 0, textRect.height());
  255.     g.setColorAt(0, Qt::black);
  256.     g.setColorAt(0.9, Qt::black);
  257.     g.setColorAt(1, Qt::transparent);
  258.  
  259.     QPalette pal = palette();
  260.     pal.setBrush(QPalette::Text, g);
  261.  
  262.     ctx.palette = pal;
  263.     ctx.clip = QRect(0, 0, textRect.width(), textRect.height());
  264.     m_document->documentLayout()->draw(painter, ctx);
  265. }
  266.  
  267. void ArthurFrame::loadSourceFile(const QString &sourceFile)
  268. {
  269.     m_sourceFileName = sourceFile;
  270. }
  271.  
  272. void ArthurFrame::showSource()
  273. {
  274.     // Check for existing source
  275.     if (qFindChild<QTextBrowser *>(this))
  276.         return;
  277.  
  278.     //...
To copy to clipboard, switch view to plain text mode