11.17 实例：加速图形驱动.txt

qt的源代码

 myApplication -qws -display svgalib
 class SvgalibScreen : public QScreen
 {
 public:
     SvgalibScreen(int displayId) : QScreen(displayId) {}
     ~SvgalibScreen() {}
     bool connect(const QString &displaySpec);
     bool initDevice();
     void shutdownDevice();
     void disconnect();
     void setMode(int, int, int) {}
     void blank(bool) {}
     void exposeRegion(QRegion r, int changing);
     void blit(const QImage &img, const QPoint &topLeft, const QRegion &region);
     void solidFill(const QColor &color, const QRegion &region);
 private:
     GraphicsContext *context;
 };
  bool SvgalibScreen::connect(const QString &displaySpec)
 {
     Q_UNUSED(displaySpec);
     int mode = vga_getdefaultmode();
     if (mode <= 0) {
         qCritical("SvgalibScreen::connect(): invalid vga mode");
         return false;
     }
     vga_modeinfo *modeinfo = vga_getmodeinfo(mode);
     QScreen::lstep = modeinfo->linewidth;
     QScreen::dw = QScreen::w = modeinfo->width;
     QScreen::dh = QScreen::h = modeinfo->height;
     QScreen::d = modeinfo->bytesperpixel * 8;
     QScreen::size = QScreen::lstep * dh;
     QScreen::data = 0;
     switch (depth()) {
     case 32:
         setPixelFormat(QImage::Format_ARGB32_Premultiplied);
         break;
     case 16:
         setPixelFormat(QImage::Format_RGB16);
         break;
     default:
         break;
     }
 const int dpi = 72;
     QScreen::physWidth = qRound(QScreen::dw * 25.4 / dpi);
     QScreen::physHeight = qRound(QScreen::dh * 25.4 / dpi);
     return true;
 }
 bool SvgalibScreen::initDevice()
 {
     if (vga_init() != 0) {
         qCritical("SvgalibScreen::initDevice(): unable to initialize svgalib");
         return false;
     }
     int mode = vga_getdefaultmode();
     if (vga_setmode(mode) == -1) {
         qCritical("SvgalibScreen::initialize(): unable to set graphics mode");
         return false;
  }
     if (gl_setcontextvga(mode) != 0) {
         qCritical("SvgalibScreen::initDevice(): unable to set vga context");
         return false;
     }
     context = gl_allocatecontext();
     gl_getcontext(context);
     vga_modeinfo *modeinfo = vga_getmodeinfo(mode);
     if (modeinfo->flags & IS_LINEAR)
         QScreen::data = vga_getgraphmem();
     QScreenCursor::initSoftwareCursor();
     return true;
 }
 void SvgalibScreen::shutdownDevice()
 {
     gl_freecontext(context);
     vga_setmode(TEXT);
 }
 void SvgalibScreen::disconnect()
 {
 }
void SvgalibScreen::exposeRegion(QRegion region, int changing)
 {
     QScreen::exposeRegion(region, changing);
 }
 void SvgalibScreen::solidFill(const QColor &color, const QRegion &reg)
 {
     if (depth() != 32 && depth() != 16) {
         if (base())
             QScreen::solidFill(color, reg);
         return;
     }
     const QVector<QRect> rects = (reg & region()).rects();
     for (int i = 0; i < rects.size(); ++i) {
         const QRect r = rects.at(i);
         gl_fillbox(r.left(), r.top(), r.width(), r.height(), color.rgba());
     }
 }
 void SvgalibScreen::blit(const QImage &img, const QPoint &topLeft,
                          const QRegion &reg)
 {
     if (img.format() != pixelFormat()) {
         if (base())
             QScreen::blit(img, topLeft, reg);
         return;
     }
     const QVector<QRect> rects = (reg & region()).rects();
     for (int i = 0; i < rects.size(); ++i) {
         const QRect r = rects.at(i);
         gl_putboxpart(r.x(), r.y(), r.width(), r.height(),
                       img.width(), img.height(),
                       static_cast<void*>(const_cast<uchar*>(img.bits())),
                       r.x() - topLeft.x(), r.y() - topLeft.y());
     }
 }
 #include <private/qpaintengine_raster_p.h>
 class SvgalibPaintEngine : public QRasterPaintEngine
 {
 public:
     SvgalibPaintEngine();
     ~SvgalibPaintEngine();
     bool begin(QPaintDevice *device);
     bool end();
     void updateState(const QPaintEngineState &state);
     void drawRects(const QRect *rects, int rectCount);
 private:
     void setClip(const QRegion &region);
     void updateClip();
     QPen pen;
     bool simplePen;
     QBrush brush;
     bool simpleBrush;
     QMatrix matrix;
     bool simpleMatrix;
     QRegion clip;
     bool clipEnabled;
 bool simpleClip;
     bool opaque;
     bool aliased;
     bool sourceOver;
     QPaintDevice *device;
 };
 bool SvgalibPaintEngine::begin(QPaintDevice *dev)
 {
     device = dev;
     pen = Qt::NoPen;
     simplePen = true;
     brush = Qt::NoBrush;
     simpleBrush = true;
     matrix = QMatrix();
     simpleMatrix = true;
     setClip(QRect(0, 0, device->width(), device->height()));
     opaque = true;
     aliased = true;
     sourceOver = true;
     return QRasterPaintEngine::begin(dev);
 }
 bool SvgalibPaintEngine::end()
 {
     gl_setclippingwindow(0, 0, device->width() - 1, device->height() - 1);
     return QRasterPaintEngine::end();
 }
void SvgalibPaintEngine::updateState(const QPaintEngineState &state)
 {
     QPaintEngine::DirtyFlags flags = state.state();
     if (flags & DirtyTransform) {
         matrix = state.matrix();
         simpleMatrix = (matrix.m12() == 0 && matrix.m21() == 0);
     }
     if (flags & DirtyPen) {
         pen = state.pen();
         simplePen = (pen.width() == 0 || pen.widthF() <= 1)
                     && (pen.style() == Qt::NoPen || pen.style() == Qt::SolidLine)
                     && (pen.color().alpha() == 255);
     }
     if (flags & DirtyBrush) {
         brush = state.brush();
 simpleBrush = (brush.style() == Qt::SolidPattern
                        || brush.style() == Qt::NoBrush)
                       && (brush.color().alpha() == 255);
     }
     if (flags & DirtyClipRegion)
         setClip(state.clipRegion());
     if (flags & DirtyClipEnabled) {
         clipEnabled = state.isClipEnabled();
         updateClip();
     }
     if (flags & DirtyClipPath) {
         setClip(QRegion());
         simpleClip = false;
     }
     if (flags & DirtyCompositionMode) {
         const QPainter::CompositionMode m = state.compositionMode();
         sourceOver = (m == QPainter::CompositionMode_SourceOver);
     }
     if (flags & DirtyOpacity)
         opaque = (state.opacity() == 256);
     if (flags & DirtyHints)
         aliased = !(state.renderHints() & QPainter::Antialiasing);
     QRasterPaintEngine::updateState(state);
 }
 void SvgalibPaintEngine::setClip(const QRegion &region)
 {
     if (region.isEmpty())
         clip = QRect(0, 0, device->width(), device->height());
     else
         clip = matrix.map(region) & QRect(0, 0, device->width(), device->height());
     clipEnabled = true;
     updateClip();
 }
 void SvgalibPaintEngine::updateClip()
 {
     QRegion clipRegion = QRect(0, 0, device->width(), device->height());
     if (!systemClip().isEmpty())
         clipRegion &= systemClip();
     if (clipEnabled)
         clipRegion &= clip;
     simpleClip = (clipRegion.rects().size() <= 1);
     const QRect r = clipRegion.boundingRect();
  gl_setclippingwindow(r.left(), r.top(),
                          r.x() + r.width(),
                          r.y() + r.height());
 }
 void SvgalibPaintEngine::drawRects(const QRect *rects, int rectCount)
 {
     const bool canAccelerate = simplePen && simpleBrush && simpleMatrix
                                && simpleClip && opaque && aliased
                                && sourceOver;
     if (!canAccelerate) {
         QRasterPaintEngine::drawRects(rects, rectCount);
         return;
     }
     for (int i = 0; i < rectCount; ++i) {
         const QRect r = matrix.mapRect(rects[i]);
         if (brush != Qt::NoBrush) {
             gl_fillbox(r.left(), r.top(), r.width(), r.height(),
                        brush.color().rgba());
         }
         if (pen != Qt::NoPen) {
             const int c = pen.color().rgba();
             gl_hline(r.left(), r.top(), r.right(), c);
             gl_hline(r.left(), r.bottom(), r.right(), c);
             gl_line(r.left(), r.top(), r.left(), r.bottom(), c);
             gl_line(r.right(), r.top(), r.right(), r.bottom(), c);
         }
     }
 }
  class SvgalibPaintDevice : public QCustomRasterPaintDevice
 {
 public:
     SvgalibPaintDevice(QWidget *w);
     ~SvgalibPaintDevice();
     void* memory() const { return QScreen::instance()->base(); }
     QPaintEngine *paintEngine() const { return pengine; }
     int metric(PaintDeviceMetric m) const;
 private:
     SvgalibPaintEngine *pengine;
 };
 class SvgalibSurface : public QWSWindowSurface
 {
 public:
     SvgalibSurface();
     SvgalibSurface(QWidget *w);
     ~SvgalibSurface();
     void setGeometry(const QRect &rect);
     bool isValid() const { return true; }
     bool scroll(const QRegion &region, int dx, int dy);
     QString key() const { return QLatin1String("svgalib"); }
     bool attach(const QByteArray &) { return true; }
     void detach() {}
     QImage image() const { return QImage(); }
     QPaintDevice *paintDevice() { return pdevice; }
     QPoint painterOffset() const;
 private:
     SvgalibPaintDevice *pdevice;
 };
 QWSWindowSurface* SvgalibScreen::createSurface(QWidget *widget) const
 {
     if (base()) {
         static int onScreenPaint = -1;
         if (onScreenPaint == -1)
             onScreenPaint = qgetenv("QT_ONSCREEN_PAINT").toInt();
         if (onScreenPaint > 0 || widget->testAttribute(Qt::WA_PaintOnScreen))
             return new SvgalibSurface(widget);
     }
     return QScreen::createSurface(widget);
 }
 QWSWindowSurface* SvgalibScreen::createSurface(const QString &key) const
 {
     if (key == QLatin1String("svgalib"))
 return new SvgalibSurface;
     return QScreen::createSurface(key);
 }