FCL/sf/mw/qt: comparison src/gui/painting/qpainter.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:2f34d5167611
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 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 QtGui module of the Qt Toolkit.
 **
 || brushStyle == Qt::TexturePattern));
 bool penTextureAlpha = false;
 if (penBrush.style() == Qt::TexturePattern)
 penTextureAlpha = qHasPixmapTexture(penBrush)
-? penBrush.texture().hasAlpha()
+? (penBrush.texture().depth() > 1) && penBrush.texture().hasAlpha()
 : penBrush.textureImage().hasAlphaChannel();
 bool brushTextureAlpha = false;
-if (s->brush.style() == Qt::TexturePattern)
+if (s->brush.style() == Qt::TexturePattern) {
 brushTextureAlpha = qHasPixmapTexture(s->brush)
-? s->brush.texture().hasAlpha()
+? (s->brush.texture().depth() > 1) && s->brush.texture().hasAlpha()
 : s->brush.textureImage().hasAlphaChannel();
+}
 if (((penBrush.style() == Qt::TexturePattern && penTextureAlpha)
 || (s->brush.style() == Qt::TexturePattern && brushTextureAlpha))
 && !engine->hasFeature(QPaintEngine::MaskedBrush))
 s->emulationSpecifier |= QPaintEngine::MaskedBrush;
 else
 implications for performance, and ensuring that every single
 operation is fast in combination with all the various combinations
 of composition modes, brushes, clipping, transformation, etc, is
 close to an impossible task because of the number of
 permutations. As a compromise we have selected a subset of the
-QPainter API and backends, were performance is guaranteed to be as
+QPainter API and backends, where performance is guaranteed to be as
 good as we can sensibly get it for the given combination of
 hardware and software.
 The backends we focus on as high-performance engines are:
 0, 90, 180, 270 degree rotations.
 \o \c drawPixmap() in combination with simple transformations and
 opacity with non-smooth transformation mode
 (\c QPainter::SmoothPixmapTransform not enabled as a render hint).
-\o Text drawing with regular font sizes with simple
-transformations with solid colors using no or 8-bit antialiasing.
 \o Rectangle fills with solid color, two-color linear gradients
 and simple transforms.
 \o Rectangular clipping with simple transformations and intersect
 }
 /*!
 \since 4.6
-Flushes the painting pipeline and prepares for the user issuing
+Flushes the painting pipeline and prepares for the user issuing commands
-commands directly to the underlying graphics context. Must be
+directly to the underlying graphics context. Must be followed by a call to
-followed by a call to endNativePainting().
+endNativePainting().
-Here is an example that shows intermixing of painter commands
+Note that only the states the underlying paint engine changes will be reset
-and raw OpenGL commands:
+to their respective default states. The states we reset may change from
+release to release. The following states are currently reset in the OpenGL
+2 engine:
+\list
+\i blending is disabled
+\i the depth, stencil and scissor tests are disabled
+\i the active texture unit is reset to 0
+\i the depth mask, depth function and the clear depth are reset to their
+default values
+\i the stencil mask, stencil operation and stencil function are reset to
+their default values
+\i the current color is reset to solid white
+\endlist
+If, for example, the OpenGL polygon mode is changed by the user inside a
+beginNativePaint()/endNativePainting() block, it will not be reset to the
+default state by endNativePainting(). Here is an example that shows
+intermixing of painter commands and raw OpenGL commands:
 \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 21
 \sa endNativePainting()
 */
 }
 /*!
 \since 4.6
-Restores the painter after manually issuing native painting commands.
+Restores the painter after manually issuing native painting commands. Lets
-Lets the painter restore any native state that it relies on before
+the painter restore any native state that it relies on before calling any
-calling any other painter commands.
+other painter commands.
 \sa beginNativePainting()
 */
 void QPainter::endNativePainting()
 {
 };
 typedef QList<QPaintDeviceRedirection> QPaintDeviceRedirectionList;
 Q_GLOBAL_STATIC(QPaintDeviceRedirectionList, globalRedirections)
 Q_GLOBAL_STATIC(QMutex, globalRedirectionsMutex)
+Q_GLOBAL_STATIC(QAtomicInt, globalRedirectionAtomic)
 /*!
 \threadsafe
+\obsolete
+Please use QWidget::render() instead.
 Redirects all paint commands for the given paint \a device, to the
 \a replacement device. The optional point \a offset defines an
 offset within the source device.
 The redirection will not be effective until the begin() function
 has been called; make sure to call end() for the given \a
 device's painter (if any) before redirecting. Call
 restoreRedirected() to restore the previous redirection.
-In general, you'll probably find that calling
+\warning Making use of redirections in the QPainter API implies
-QPixmap::grabWidget() or QPixmap::grabWindow() is an easier
+that QPainter::begin() and QPaintDevice destructors need to hold
-solution.
+a mutex for a short period. This can impact performance. Use of
+QWidget::render is strongly encouraged.
 \sa redirected(), restoreRedirected()
 */
 void QPainter::setRedirected(const QPaintDevice *device,
 QPaintDevice *replacement,
 QMutexLocker locker(globalRedirectionsMutex());
 QPaintDeviceRedirectionList *redirections = globalRedirections();
 Q_ASSERT(redirections != 0);
 *redirections += QPaintDeviceRedirection(device, rdev ? rdev : replacement, offset + roffset,
 hadInternalWidgetRedirection ? redirections->size() - 1 : -1);
+globalRedirectionAtomic()->ref();
 }
 /*!
 \threadsafe
+\obsolete
+Using QWidget::render() obsoletes the use of this function.
 Restores the previous redirection for the given \a device after a
 call to setRedirected().
+\warning Making use of redirections in the QPainter API implies
+that QPainter::begin() and QPaintDevice destructors need to hold
+a mutex for a short period. This can impact performance. Use of
+QWidget::render is strongly encouraged.
 \sa redirected()
 */
 void QPainter::restoreRedirected(const QPaintDevice *device)
 {
 QMutexLocker locker(globalRedirectionsMutex());
 QPaintDeviceRedirectionList *redirections = globalRedirections();
 Q_ASSERT(redirections != 0);
 for (int i = redirections->size()-1; i >= 0; --i) {
 if (redirections->at(i) == device) {
+globalRedirectionAtomic()->deref();
 const int internalWidgetRedirectionIndex = redirections->at(i).internalWidgetRedirectionIndex;
 redirections->removeAt(i);
 // Restore the internal widget redirection, i.e. remove it from the global
 // redirection list and put it back into QWidgetPrivate. The index is only set when
 // someone call QPainter::setRedirected in a widget's paint event and we internally
 }
 /*!
 \threadsafe
+\obsolete
+Using QWidget::render() obsoletes the use of this function.
 Returns the replacement for given \a device. The optional out
 parameter \a offset returns the offset within the replaced device.
+\warning Making use of redirections in the QPainter API implies
+that QPainter::begin() and QPaintDevice destructors need to hold
+a mutex for a short period. This can impact performance. Use of
+QWidget::render is strongly encouraged.
 \sa setRedirected(), restoreRedirected()
 */
 QPaintDevice *QPainter::redirected(const QPaintDevice *device, QPoint *offset)
 {
 if (device->devType() == QInternal::Widget) {
 const QWidgetPrivate *widgetPrivate = static_cast<const QWidget *>(device)->d_func();
 if (widgetPrivate->redirectDev)
 return widgetPrivate->redirected(offset);
 }
+if (!globalRedirectionAtomic() || *globalRedirectionAtomic() == 0)
+return 0;
 QMutexLocker locker(globalRedirectionsMutex());
 QPaintDeviceRedirectionList *redirections = globalRedirections();
 Q_ASSERT(redirections != 0);
 for (int i = redirections->size()-1; i >= 0; --i)
 }
 void qt_painter_removePaintDevice(QPaintDevice *dev)
 {
+if (!globalRedirectionAtomic() || *globalRedirectionAtomic() == 0)
+return;
 QMutex *mutex = 0;
 QT_TRY {
 mutex = globalRedirectionsMutex();
 } QT_CATCH(...) {
 // ignore the missing mutex, since we could be called from

changeset 18	2f34d5167611
parent 3	41300fa6a67c
child 25	e24348a560a6