/****************************************************************************
**
** Copyright (C) 2010 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$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $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/qegl_p.h>
#include <private/qgl_egl_p.h>
#include <private/qgl_cl_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
*****************************************************************************/
void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device)
{
int devType = device->devType();
if (devType == QInternal::Image)
props.setPixelFormat(static_cast<QImage *>(device)->format());
else
props.setPixelFormat(QImage::Format_RGB16);
}
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->eglContext->setApi(QEgl::OpenGL);
if (!d->eglContext->openDisplay(device())) {
delete d->eglContext;
d->eglContext = 0;
return false;
}
// Construct the configuration we need for this surface.
QEglProperties configProps;
qt_egl_add_platform_config(configProps, device());
qt_egl_set_format(configProps, devType, d->glFormat);
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_egl_update_format(*(d->eglContext), d->glFormat);
// 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