637 lines
16 KiB
C++
637 lines
16 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
|
** All rights reserved.
|
|
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
**
|
|
** This file is part of the QtOpenGL module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** GNU Lesser General Public License Usage
|
|
** This file may be used under the terms of the GNU Lesser General Public
|
|
** License version 2.1 as published by the Free Software Foundation and
|
|
** appearing in the file LICENSE.LGPL included in the packaging of this
|
|
** file. Please review the following information to ensure the GNU Lesser
|
|
** General Public License version 2.1 requirements will be met:
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
**
|
|
** In addition, as a special exception, Nokia gives you certain additional
|
|
** rights. These rights are described in the Nokia Qt LGPL Exception
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU General
|
|
** Public License version 3.0 as published by the Free Software Foundation
|
|
** and appearing in the file LICENSE.GPL included in the packaging of this
|
|
** file. Please review the following information to ensure the GNU General
|
|
** Public License version 3.0 requirements will be met:
|
|
** http://www.gnu.org/copyleft/gpl.html.
|
|
**
|
|
** Other Usage
|
|
** Alternatively, this file may be used in accordance with the terms and
|
|
** conditions contained in a signed written agreement between you and Nokia.
|
|
**
|
|
**
|
|
**
|
|
**
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
|
|
#include <qgl.h>
|
|
#include <qlist.h>
|
|
#include <qmap.h>
|
|
#include <qpixmap.h>
|
|
#include <qevent.h>
|
|
#include <private/qgl_p.h>
|
|
#include <qcolormap.h>
|
|
#include <qvarlengtharray.h>
|
|
#include <qdebug.h>
|
|
#include <qapplication.h>
|
|
#include <qdesktopwidget>
|
|
|
|
#include <windows.h>
|
|
|
|
#include <private/qeglproperties_p.h>
|
|
#include <private/qeglcontext_p.h>
|
|
#include <private/qgl_egl_p.h>
|
|
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
|
|
|
|
class QGLCmapPrivate
|
|
{
|
|
public:
|
|
QGLCmapPrivate() : count(1) { }
|
|
void ref() { ++count; }
|
|
bool deref() { return !--count; }
|
|
uint count;
|
|
|
|
enum AllocState{ UnAllocated = 0, Allocated = 0x01, Reserved = 0x02 };
|
|
|
|
int maxSize;
|
|
QVector<uint> colorArray;
|
|
QVector<quint8> allocArray;
|
|
QVector<quint8> contextArray;
|
|
QMap<uint,int> colorMap;
|
|
};
|
|
|
|
/*****************************************************************************
|
|
QColorMap class - temporarily here, until it is ready for prime time
|
|
*****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
**
|
|
** Definition of QColorMap class
|
|
**
|
|
****************************************************************************/
|
|
|
|
#ifndef QGLCMAP_H
|
|
#define QGLCMAP_H
|
|
|
|
#include <qcolor.h>
|
|
|
|
/*
|
|
QGLTemporaryContext implementation
|
|
*/
|
|
|
|
class QGLTemporaryContextPrivate
|
|
{
|
|
public:
|
|
QGLWidget *widget;
|
|
};
|
|
|
|
QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
|
|
: d(new QGLTemporaryContextPrivate)
|
|
{
|
|
d->widget = new QGLWidget;
|
|
d->widget->makeCurrent();
|
|
}
|
|
|
|
QGLTemporaryContext::~QGLTemporaryContext()
|
|
{
|
|
delete d->widget;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
QGLFormat Win32/WGL-specific code
|
|
*****************************************************************************/
|
|
|
|
static bool opengl32dll = false;
|
|
|
|
bool QGLFormat::hasOpenGLOverlays()
|
|
{
|
|
return false; // ###
|
|
}
|
|
|
|
|
|
bool QGLContext::chooseContext(const QGLContext* shareContext)
|
|
{
|
|
Q_D(QGLContext);
|
|
|
|
// Validate the device.
|
|
if (!device())
|
|
return false;
|
|
int devType = device()->devType();
|
|
if (devType != QInternal::Pixmap && devType != QInternal::Image && devType != QInternal::Widget) {
|
|
qWarning("QGLContext::chooseContext(): Cannot create QGLContext's for paint device type %d", devType);
|
|
return false;
|
|
}
|
|
|
|
// Get the display and initialize it.
|
|
d->eglContext = new QEglContext();
|
|
d->ownsEglContext = true;
|
|
d->eglContext->setApi(QEgl::OpenGL);
|
|
|
|
// Construct the configuration we need for this surface.
|
|
QEglProperties configProps;
|
|
qt_eglproperties_set_glformat(configProps, d->glFormat);
|
|
configProps.setDeviceType(devType);
|
|
configProps.setPaintDeviceFormat(device());
|
|
configProps.setRenderableType(QEgl::OpenGL);
|
|
|
|
// Search for a matching configuration, reducing the complexity
|
|
// each time until we get something that matches.
|
|
if (!d->eglContext->chooseConfig(configProps)) {
|
|
delete d->eglContext;
|
|
d->eglContext = 0;
|
|
return false;
|
|
}
|
|
|
|
// Inform the higher layers about the actual format properties.
|
|
qt_glformat_from_eglconfig(d->glFormat, d->eglContext->config());
|
|
|
|
// Create a new context for the configuration.
|
|
if (!d->eglContext->createContext
|
|
(shareContext ? shareContext->d_func()->eglContext : 0)) {
|
|
delete d->eglContext;
|
|
d->eglContext = 0;
|
|
return false;
|
|
}
|
|
d->sharing = d->eglContext->isSharing();
|
|
if (d->sharing && shareContext)
|
|
const_cast<QGLContext *>(shareContext)->d_func()->sharing = true;
|
|
|
|
#if defined(EGL_VERSION_1_1)
|
|
if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget)
|
|
eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval());
|
|
#endif
|
|
|
|
// Create the EGL surface to draw into.
|
|
d->eglSurface = d->eglContext->createSurface(device());
|
|
if (d->eglSurface == EGL_NO_SURFACE) {
|
|
delete d->eglContext;
|
|
d->eglContext = 0;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool qLogEq(bool a, bool b)
|
|
{
|
|
return (((!a) && (!b)) || (a && b));
|
|
}
|
|
|
|
int QGLContext::choosePixelFormat(void* , HDC )
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
class QGLCmapPrivate;
|
|
|
|
class /*Q_EXPORT*/ QGLCmap
|
|
{
|
|
public:
|
|
enum Flags { Reserved = 0x01 };
|
|
|
|
QGLCmap(int maxSize = 256);
|
|
QGLCmap(const QGLCmap& map);
|
|
~QGLCmap();
|
|
|
|
QGLCmap& operator=(const QGLCmap& map);
|
|
|
|
// isEmpty and/or isNull ?
|
|
int size() const;
|
|
int maxSize() const;
|
|
|
|
void resize(int newSize);
|
|
|
|
int find(QRgb color) const;
|
|
int findNearest(QRgb color) const;
|
|
int allocate(QRgb color, uint flags = 0, quint8 context = 0);
|
|
|
|
void setEntry(int idx, QRgb color, uint flags = 0, quint8 context = 0);
|
|
|
|
const QRgb* colors() const;
|
|
|
|
private:
|
|
void detach();
|
|
QGLCmapPrivate* d;
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
QGLCmap::QGLCmap(int maxSize) // add a bool prealloc?
|
|
{
|
|
d = new QGLCmapPrivate;
|
|
d->maxSize = maxSize;
|
|
}
|
|
|
|
QGLCmap::QGLCmap(const QGLCmap& map)
|
|
{
|
|
d = map.d;
|
|
d->ref();
|
|
}
|
|
|
|
QGLCmap::~QGLCmap()
|
|
{
|
|
if (d && d->deref())
|
|
delete d;
|
|
d = 0;
|
|
}
|
|
|
|
QGLCmap& QGLCmap::operator=(const QGLCmap& map)
|
|
{
|
|
map.d->ref();
|
|
if (d->deref())
|
|
delete d;
|
|
d = map.d;
|
|
return *this;
|
|
}
|
|
|
|
int QGLCmap::size() const
|
|
{
|
|
return d->colorArray.size();
|
|
}
|
|
|
|
int QGLCmap::maxSize() const
|
|
{
|
|
return d->maxSize;
|
|
}
|
|
|
|
void QGLCmap::detach()
|
|
{
|
|
if (d->count != 1) {
|
|
d->deref();
|
|
QGLCmapPrivate* newd = new QGLCmapPrivate;
|
|
newd->maxSize = d->maxSize;
|
|
newd->colorArray = d->colorArray;
|
|
newd->allocArray = d->allocArray;
|
|
newd->contextArray = d->contextArray;
|
|
newd->colorArray.detach();
|
|
newd->allocArray.detach();
|
|
newd->contextArray.detach();
|
|
newd->colorMap = d->colorMap;
|
|
d = newd;
|
|
}
|
|
}
|
|
|
|
|
|
void QGLCmap::resize(int newSize)
|
|
{
|
|
if (newSize < 0 || newSize > d->maxSize) {
|
|
qWarning("QGLCmap::resize(): size out of range");
|
|
return;
|
|
}
|
|
int oldSize = size();
|
|
detach();
|
|
//if shrinking; remove the lost elems from colorMap
|
|
d->colorArray.resize(newSize);
|
|
d->allocArray.resize(newSize);
|
|
d->contextArray.resize(newSize);
|
|
if (newSize > oldSize) {
|
|
memset(d->allocArray.data() + oldSize, 0, newSize - oldSize);
|
|
memset(d->contextArray.data() + oldSize, 0, newSize - oldSize);
|
|
}
|
|
}
|
|
|
|
|
|
int QGLCmap::find(QRgb color) const
|
|
{
|
|
QMap<uint,int>::ConstIterator it = d->colorMap.find(color);
|
|
if (it != d->colorMap.end())
|
|
return *it;
|
|
return -1;
|
|
}
|
|
|
|
|
|
int QGLCmap::findNearest(QRgb color) const
|
|
{
|
|
int idx = find(color);
|
|
if (idx >= 0)
|
|
return idx;
|
|
int mapSize = size();
|
|
int mindist = 200000;
|
|
int r = qRed(color);
|
|
int g = qGreen(color);
|
|
int b = qBlue(color);
|
|
int rx, gx, bx, dist;
|
|
for (int i=0; i < mapSize; i++) {
|
|
if (!(d->allocArray[i] & QGLCmapPrivate::Allocated))
|
|
continue;
|
|
QRgb ci = d->colorArray[i];
|
|
rx = r - qRed(ci);
|
|
gx = g - qGreen(ci);
|
|
bx = b - qBlue(ci);
|
|
dist = rx*rx + gx*gx + bx*bx; // calculate distance
|
|
if (dist < mindist) { // minimal?
|
|
mindist = dist;
|
|
idx = i;
|
|
}
|
|
}
|
|
return idx;
|
|
}
|
|
|
|
|
|
// Does not always allocate; returns existing c idx if found
|
|
|
|
int QGLCmap::allocate(QRgb color, uint flags, quint8 context)
|
|
{
|
|
int idx = find(color);
|
|
if (idx >= 0)
|
|
return idx;
|
|
|
|
int mapSize = d->colorArray.size();
|
|
int newIdx = d->allocArray.indexOf(QGLCmapPrivate::UnAllocated);
|
|
|
|
if (newIdx < 0) { // Must allocate more room
|
|
if (mapSize < d->maxSize) {
|
|
newIdx = mapSize;
|
|
mapSize++;
|
|
resize(mapSize);
|
|
}
|
|
else {
|
|
//# add a bool param that says what to do in case no more room -
|
|
// fail (-1) or return nearest?
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
d->colorArray[newIdx] = color;
|
|
if (flags & QGLCmap::Reserved) {
|
|
d->allocArray[newIdx] = QGLCmapPrivate::Reserved;
|
|
}
|
|
else {
|
|
d->allocArray[newIdx] = QGLCmapPrivate::Allocated;
|
|
d->colorMap.insert(color, newIdx);
|
|
}
|
|
d->contextArray[newIdx] = context;
|
|
return newIdx;
|
|
}
|
|
|
|
|
|
void QGLCmap::setEntry(int idx, QRgb color, uint flags, quint8 context)
|
|
{
|
|
if (idx < 0 || idx >= d->maxSize) {
|
|
qWarning("QGLCmap::set(): Index out of range");
|
|
return;
|
|
}
|
|
detach();
|
|
int mapSize = size();
|
|
if (idx >= mapSize) {
|
|
mapSize = idx + 1;
|
|
resize(mapSize);
|
|
}
|
|
d->colorArray[idx] = color;
|
|
if (flags & QGLCmap::Reserved) {
|
|
d->allocArray[idx] = QGLCmapPrivate::Reserved;
|
|
}
|
|
else {
|
|
d->allocArray[idx] = QGLCmapPrivate::Allocated;
|
|
d->colorMap.insert(color, idx);
|
|
}
|
|
d->contextArray[idx] = context;
|
|
}
|
|
|
|
|
|
const QRgb* QGLCmap::colors() const
|
|
{
|
|
return d->colorArray.data();
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
QGLWidget Win32/WGL-specific code
|
|
*****************************************************************************/
|
|
|
|
void QGLWidgetPrivate::init(QGLContext *ctx, const QGLWidget* shareWidget)
|
|
{
|
|
Q_Q(QGLWidget);
|
|
olcx = 0;
|
|
initContext(ctx, shareWidget);
|
|
|
|
if (q->isValid() && q->context()->format().hasOverlay()) {
|
|
olcx = new QGLContext(QGLFormat::defaultOverlayFormat(), q);
|
|
if (!olcx->create(shareWidget ? shareWidget->overlayContext() : 0)) {
|
|
delete olcx;
|
|
olcx = 0;
|
|
glcx->d_func()->glFormat.setOverlay(false);
|
|
}
|
|
} else {
|
|
olcx = 0;
|
|
}
|
|
}
|
|
|
|
/*\internal
|
|
Store color values in the given colormap.
|
|
*/
|
|
static void qStoreColors(HPALETTE cmap, const QGLColormap & cols)
|
|
{
|
|
QRgb color;
|
|
PALETTEENTRY pe;
|
|
|
|
for (int i = 0; i < cols.size(); i++) {
|
|
color = cols.entryRgb(i);
|
|
pe.peRed = qRed(color);
|
|
pe.peGreen = qGreen(color);
|
|
pe.peBlue = qBlue(color);
|
|
pe.peFlags = 0;
|
|
|
|
SetPaletteEntries(cmap, i, 1, &pe);
|
|
}
|
|
}
|
|
|
|
void QGLWidgetPrivate::updateColormap()
|
|
{
|
|
Q_Q(QGLWidget);
|
|
if (!cmap.handle())
|
|
return;
|
|
HDC hdc = GetDC(q->winId());
|
|
SelectPalette(hdc, (HPALETTE) cmap.handle(), TRUE);
|
|
qStoreColors((HPALETTE) cmap.handle(), cmap);
|
|
RealizePalette(hdc);
|
|
ReleaseDC(q->winId(), hdc);
|
|
}
|
|
|
|
bool QGLWidget::event(QEvent *e)
|
|
{
|
|
Q_D(QGLWidget);
|
|
if (e->type() == QEvent::ParentChange) {
|
|
setContext(new QGLContext(d->glcx->requestedFormat(), this));
|
|
// the overlay needs to be recreated as well
|
|
delete d->olcx;
|
|
if (isValid() && context()->format().hasOverlay()) {
|
|
d->olcx = new QGLContext(QGLFormat::defaultOverlayFormat(), this);
|
|
if (!d->olcx->create(isSharing() ? d->glcx : 0)) {
|
|
delete d->olcx;
|
|
d->olcx = 0;
|
|
d->glcx->d_func()->glFormat.setOverlay(false);
|
|
}
|
|
} else {
|
|
d->olcx = 0;
|
|
}
|
|
} else if (e->type() == QEvent::Show && !format().rgba()) {
|
|
d->updateColormap();
|
|
}
|
|
|
|
return QWidget::event(e);
|
|
}
|
|
|
|
|
|
void QGLWidget::resizeEvent(QResizeEvent *)
|
|
{
|
|
Q_D(QGLWidget);
|
|
if (!isValid())
|
|
return;
|
|
makeCurrent();
|
|
if (!d->glcx->initialized())
|
|
glInit();
|
|
resizeGL(width(), height());
|
|
if (d->olcx) {
|
|
makeOverlayCurrent();
|
|
resizeOverlayGL(width(), height());
|
|
}
|
|
}
|
|
|
|
|
|
const QGLContext* QGLWidget::overlayContext() const
|
|
{
|
|
return d_func()->olcx;
|
|
}
|
|
|
|
|
|
void QGLWidget::makeOverlayCurrent()
|
|
{
|
|
Q_D(QGLWidget);
|
|
if (d->olcx) {
|
|
d->olcx->makeCurrent();
|
|
if (!d->olcx->initialized()) {
|
|
initializeOverlayGL();
|
|
d->olcx->setInitialized(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void QGLWidget::updateOverlayGL()
|
|
{
|
|
Q_D(QGLWidget);
|
|
if (d->olcx) {
|
|
makeOverlayCurrent();
|
|
paintOverlayGL();
|
|
if (d->olcx->format().doubleBuffer()) {
|
|
if (d->autoSwap)
|
|
d->olcx->swapBuffers();
|
|
}
|
|
else {
|
|
glFlush();
|
|
}
|
|
}
|
|
}
|
|
|
|
void QGLWidget::setContext(QGLContext *context,
|
|
const QGLContext* shareContext,
|
|
bool deleteOldContext)
|
|
{
|
|
Q_D(QGLWidget);
|
|
if (context == 0) {
|
|
qWarning("QGLWidget::setContext: Cannot set null context");
|
|
return;
|
|
}
|
|
if (!context->deviceIsPixmap() && context->device() != this) {
|
|
qWarning("QGLWidget::setContext: Context must refer to this widget");
|
|
return;
|
|
}
|
|
|
|
if (d->glcx)
|
|
d->glcx->doneCurrent();
|
|
QGLContext* oldcx = d->glcx;
|
|
d->glcx = context;
|
|
|
|
bool doShow = false;
|
|
if (oldcx && oldcx->d_func()->win == winId() && !d->glcx->deviceIsPixmap()) {
|
|
// We already have a context and must therefore create a new
|
|
// window since Windows does not permit setting a new OpenGL
|
|
// context for a window that already has one set.
|
|
doShow = isVisible();
|
|
QWidget *pW = static_cast<QWidget *>(parent());
|
|
QPoint pos = geometry().topLeft();
|
|
setParent(pW, windowFlags());
|
|
move(pos);
|
|
}
|
|
|
|
if (!d->glcx->isValid()) {
|
|
d->glcx->create(shareContext ? shareContext : oldcx);
|
|
// the above is a trick to keep disp lists etc when a
|
|
// QGLWidget has been reparented, so remove the sharing
|
|
// flag if we don't actually have a sharing context.
|
|
if (!shareContext)
|
|
d->glcx->d_ptr->sharing = false;
|
|
}
|
|
|
|
if (deleteOldContext)
|
|
delete oldcx;
|
|
|
|
if (doShow)
|
|
show();
|
|
}
|
|
|
|
|
|
void QGLWidgetPrivate::cleanupColormaps()
|
|
{
|
|
Q_Q(QGLWidget);
|
|
if (cmap.handle()) {
|
|
HDC hdc = GetDC(q->winId());
|
|
SelectPalette(hdc, (HPALETTE) GetStockObject(DEFAULT_PALETTE), FALSE);
|
|
DeleteObject((HPALETTE) cmap.handle());
|
|
ReleaseDC(q->winId(), hdc);
|
|
cmap.setHandle(0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
const QGLColormap & QGLWidget::colormap() const
|
|
{
|
|
return d_func()->cmap;
|
|
}
|
|
|
|
void QGLWidget::setColormap(const QGLColormap & c)
|
|
{
|
|
Q_D(QGLWidget);
|
|
d->cmap = c;
|
|
|
|
if (d->cmap.handle()) { // already have an allocated cmap
|
|
d->updateColormap();
|
|
} else {
|
|
LOGPALETTE *lpal = (LOGPALETTE *) malloc(sizeof(LOGPALETTE)
|
|
+c.size()*sizeof(PALETTEENTRY));
|
|
lpal->palVersion = 0x300;
|
|
lpal->palNumEntries = c.size();
|
|
d->cmap.setHandle(CreatePalette(lpal));
|
|
free(lpal);
|
|
d->updateColormap();
|
|
}
|
|
}
|
|
|
|
QT_END_NAMESPACE
|