*~

*.a

*.core

*.moc

*.o

bin/uic*

bin/qcollectiongenerator

bin/qhelpgenerator

tools/qdoc3/qdoc3*

#configure.cache

mkspecs/default

mkspecs/qconfig.pri

table->setItem(3, 0, new SpreadSheetItem("Lunch"));

table->setItem(4, 0, new SpreadSheetItem("Flight (LA)"));

table->setItem(5, 0, new SpreadSheetItem("Taxi"));

table->setItem(7, 0, new SpreadSheetItem("Hotel"));

table->setItem(8, 0, new SpreadSheetItem("Flight (Oslo)"));

table->setItem(9, 0, new SpreadSheetItem("Total:"));

****************************************************************************/

/*!

The Fancy Browser example shows how to use jQuery with QtWebKit to

\image fancybrowser-example.png

*/

\snippet doc/src/snippets/code/doc_src_layout.qdoc 1

and \c{takeAt()}. These functions are used internally by the layout system

to handle deletion of widgets. They are also available for application

programmers.

structure, we may have to spend more effort defining a linear order for the

items.

\c{addItem()} implements the default placement strategy for layout items.

This function must be implemented. It is used by QLayout::add(), by the

QGridLayout::addItem(), QGridLayout::addWidget(), and

QGridLayout::addLayout().

The layout takes over responsibility of the items added. Since QLayoutItem

does not inherit QObject, we must delete the items manually. The function

QLayout::deleteAllItems() uses \c{takeAt()} defined above to delete all the

items in the layout.

The \c{setGeometry()} function actually performs the layout. The rectangle

supplied as an argument does not include \c{margin()}. If relevant, use

\c{spacing()} as the distance between items.

\c{sizeHint()} and \c{minimumSize()} are normally very similar in

implementation. The sizes returned by both functions should include

\c{spacing()}, but not \c{margin()}.

\section2 Further Notes

\fn QSet::const_iterator QSet::insert(const T &value)

Inserts item \a value into the set, if \a value isn't already

item.

\sa operator<<(), remove(), contains()

#ifndef CARD_H

#define CARD_H

#include <QList>

class CardLayout : public QLayout

{

public:

~CardLayout();

void addItem(QLayoutItem *item);

QSize sizeHint() const;

QSize minimumSize() const;

QLayoutItem *itemAt(int) const;

QLayoutItem *takeAt(int);

void setGeometry(const QRect &rect);

//! [1]

//! [1]

//! [2]

QLayoutItem *CardLayout::itemAt(int idx) const

{

// QList::value() performs index checking, and returns 0 if we are

// QList::take does not do index checking

return idx >= 0 && idx < list.size() ? list.takeAt(idx) : 0;

}

void CardLayout::addItem(QLayoutItem *item)

{

list.append(item);

}

CardLayout::~CardLayout()

{

deleteAllItems();

}

void CardLayout::setGeometry(const QRect &r)

{

QLayout::setGeometry(r);

++i;

}

}

QSize CardLayout::sizeHint() const

{

QSize s(0,0);

}

return s + n*QSize(spacing(), spacing());

}

bool fetchLast() { return false; }

int size() { return 0; }

int numRowsAffected() { return 0; }

};

//! [47]

customcompleter \

echoplugin \

i18n \

plugandpaintplugins \

plugandpaint \

regexp \

#include <QtWebKit>

#include "mainwindow.h"

MainWindow::MainWindow()

{

progress = 0;

file.open(QIODevice::ReadOnly);

jQuery = file.readAll();

file.close();

view = new QWebView(this);

view->load(QUrl("http://www.google.com/ncr"));

connect(view, SIGNAL(loadFinished(bool)), SLOT(adjustLocation()));

toolBar->addAction(view->pageAction(QWebPage::Reload));

toolBar->addAction(view->pageAction(QWebPage::Stop));

toolBar->addWidget(locationEdit);

QMenu *effectMenu = menuBar()->addMenu(tr("&Effect"));

effectMenu->addAction("Highlight all links", this, SLOT(highlightAllLinks()));

setCentralWidget(view);

}

void MainWindow::adjustLocation()

{

locationEdit->setText(view->url().toString());

void MainWindow::changeLocation()

{

QUrl url = QUrl(locationEdit->text());

view->load(url);

view->setFocus();

}

void MainWindow::adjustTitle()

{

if (progress <= 0 || progress >= 100)

progress = p;

adjustTitle();

}

void MainWindow::finishLoading(bool)

{

progress = 100;

adjustTitle();

view->page()->mainFrame()->evaluateJavaScript(jQuery);

}

void MainWindow::highlightAllLinks()

{

QString code = "$('a').each( function () { $(this).css('background-color', 'yellow') } )";

view->page()->mainFrame()->evaluateJavaScript(code);

}

void MainWindow::rotateImages(bool toggle)

{

QString code = "$('img').each( function () { $(this).css('-webkit-transition', '-webkit-transform 2s') } )";

code = "$('img').each( function () { $(this).css('-webkit-transform', 'rotate(0deg)') } )";

view->page()->mainFrame()->evaluateJavaScript(code);

}

void MainWindow::removeGifImages()

{

QString code = "$('[src*=gif]').remove()";

QString code = "$('embed').remove()";

view->page()->mainFrame()->evaluateJavaScript(code);

}

**

****************************************************************************/

QT_BEGIN_NAMESPACE

class QWebView;

class QLineEdit;

QT_END_NAMESPACE

class MainWindow : public QMainWindow

{

Q_OBJECT

QWebView *view;

QLineEdit *locationEdit;

int progress;

};

QMAKE_CFLAGS = -nologo -Zm200 -Zc:wchar_t-

QMAKE_CFLAGS_WARN_ON = -W3

QMAKE_CFLAGS_WARN_OFF = -W0

QMAKE_CFLAGS_DEBUG = -Zi -MDd

QMAKE_CFLAGS_YACC =

QMAKE_CXX = $$QMAKE_CC

QMAKE_CXXFLAGS = $$QMAKE_CFLAGS

QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE

QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG

QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC

QMAKE_CXXFLAGS_STL_ON = -EHsc

QMAKE_CXXFLAGS_STL_OFF =

QMAKE_CXXFLAGS_RTTI_ON = -GR

QMAKE_LINK = link

QMAKE_LFLAGS = /NOLOGO

QMAKE_LFLAGS_DEBUG = /DEBUG

QMAKE_LFLAGS_CONSOLE = /SUBSYSTEM:CONSOLE

QMAKE_LFLAGS_WINDOWS = /SUBSYSTEM:WINDOWS \"/MANIFESTDEPENDENCY:type=\'win32\' name=\'Microsoft.Windows.Common-Controls\' version=\'6.0.0.0\' publicKeyToken=\'6595b64144ccf1df\' language=\'*\' processorArchitecture=\'*\'\"

QMAKE_LFLAGS_DLL = /DLL

QMAKE_LIBS_CORE = kernel32.lib user32.lib shell32.lib uuid.lib ole32.lib advapi32.lib ws2_32.lib

QMAKE_LIBS_GUI = gdi32.lib comdlg32.lib oleaut32.lib imm32.lib winmm.lib winspool.lib ws2_32.lib ole32.lib user32.lib advapi32.lib

QMAKE_CFLAGS = -nologo -Zm200 -Zc:wchar_t-

QMAKE_CFLAGS_WARN_ON = -W3

QMAKE_CFLAGS_WARN_OFF = -W0

QMAKE_CFLAGS_DEBUG = -Zi -MDd

QMAKE_CFLAGS_YACC =

QMAKE_CXX = $$QMAKE_CC

QMAKE_CXXFLAGS = $$QMAKE_CFLAGS

QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE

QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG

QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC

QMAKE_CXXFLAGS_STL_ON = -EHsc

QMAKE_CXXFLAGS_STL_OFF =

QMAKE_CXXFLAGS_RTTI_ON = -GR

QMAKE_LINK = link

QMAKE_LFLAGS = /NOLOGO

QMAKE_LFLAGS_DEBUG = /DEBUG

QMAKE_LFLAGS_CONSOLE = /SUBSYSTEM:CONSOLE

QMAKE_LFLAGS_WINDOWS = /SUBSYSTEM:WINDOWS \"/MANIFESTDEPENDENCY:type=\'win32\' name=\'Microsoft.Windows.Common-Controls\' version=\'6.0.0.0\' publicKeyToken=\'6595b64144ccf1df\' language=\'*\' processorArchitecture=\'*\'\"

QMAKE_LFLAGS_DLL = /DLL

QMAKE_LIBS_CORE = kernel32.lib user32.lib shell32.lib uuid.lib ole32.lib advapi32.lib ws2_32.lib

QMAKE_LIBS_GUI = gdi32.lib comdlg32.lib oleaut32.lib imm32.lib winmm.lib winspool.lib ws2_32.lib ole32.lib user32.lib advapi32.lib

void XmlOutput::closeTo(const QString &tag)

{

bool cont = true;

//warn_msg(WarnLogic, "<%s>: Cannot close to tag <%s>, not on stack", tagStack.last().latin1(), tag.latin1());

qDebug("<%s>: Cannot close to tag <%s>, not on stack", tagStack.last().toLatin1().constData(), tag.toLatin1().constData());

return;

qfile.h \

qabstractfileengine.h \

qfileinfo.h \

qglobal.h \

qnumeric.h \

qhash.h \

#if defined(Q_CC_GNU) && !defined(Q_OS_IRIX)

inline bool QBasicAtomicInt::ref()

{

register int originalValue;

register int newValue;

"ll %[originalValue], %[_q_value]\n"

"addiu %[newValue], %[originalValue], %[one]\n"

"sc %[newValue], %[_q_value]\n"

"beqz %[newValue], 0b\n"

"nop\n"

: [originalValue] "=&r" (originalValue),

[_q_value] "+m" (_q_value),

[newValue] "=&r" (newValue)

{

register int originalValue;

register int newValue;

"ll %[originalValue], %[_q_value]\n"

"addiu %[newValue], %[originalValue], %[minusOne]\n"

"sc %[newValue], %[_q_value]\n"

"beqz %[newValue], 0b\n"

"nop\n"

: [originalValue] "=&r" (originalValue),

[_q_value] "+m" (_q_value),

[newValue] "=&r" (newValue)

{

register int result;

register int tempValue;

"ll %[result], %[_q_value]\n"

"xor %[result], %[result], %[expectedValue]\n"

"bnez %[result], 0f\n"

"beqz %[tempValue], 0b\n"

"nop\n"

"0:\n"

: [result] "=&r" (result),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register int result;

register int tempValue;

"ll %[result], %[_q_value]\n"

"xor %[result], %[result], %[expectedValue]\n"

"bnez %[result], 0f\n"

"nop\n"

"sync\n"

"0:\n"

: [result] "=&r" (result),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register int result;

register int tempValue;

"0:\n"

"ll %[result], %[_q_value]\n"

"xor %[result], %[result], %[expectedValue]\n"

"beqz %[tempValue], 0b\n"

"nop\n"

"0:\n"

: [result] "=&r" (result),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register int originalValue;

register int tempValue;

"ll %[originalValue], %[_q_value]\n"

"move %[tempValue], %[newValue]\n"

"sc %[tempValue], %[_q_value]\n"

"beqz %[tempValue], 0b\n"

"nop\n"

: [originalValue] "=&r" (originalValue),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register int originalValue;

register int tempValue;

"ll %[originalValue], %[_q_value]\n"

"move %[tempValue], %[newValue]\n"

"sc %[tempValue], %[_q_value]\n"

"beqz %[tempValue], 0b\n"

"nop\n"

"sync\n"

: [originalValue] "=&r" (originalValue),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register int originalValue;

register int tempValue;

"0:\n"

"ll %[originalValue], %[_q_value]\n"

"move %[tempValue], %[newValue]\n"

"sc %[tempValue], %[_q_value]\n"

"beqz %[tempValue], 0b\n"

"nop\n"

: [originalValue] "=&r" (originalValue),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register int originalValue;

register int newValue;

"ll %[originalValue], %[_q_value]\n"

"addu %[newValue], %[originalValue], %[valueToAdd]\n"

"sc %[newValue], %[_q_value]\n"

"beqz %[newValue], 0b\n"

"nop\n"

: [originalValue] "=&r" (originalValue),

[_q_value] "+m" (_q_value),

[newValue] "=&r" (newValue)

{

register int originalValue;

register int newValue;

"ll %[originalValue], %[_q_value]\n"

"addu %[newValue], %[originalValue], %[valueToAdd]\n"

"sc %[newValue], %[_q_value]\n"

"beqz %[newValue], 0b\n"

"nop\n"

"sync\n"

: [originalValue] "=&r" (originalValue),

[_q_value] "+m" (_q_value),

[newValue] "=&r" (newValue)

{

register int originalValue;

register int newValue;

"0:\n"

"ll %[originalValue], %[_q_value]\n"

"addu %[newValue], %[originalValue], %[valueToAdd]\n"

"sc %[newValue], %[_q_value]\n"

"beqz %[newValue], 0b\n"

"nop\n"

: [originalValue] "=&r" (originalValue),

[_q_value] "+m" (_q_value),

[newValue] "=&r" (newValue)

{

register T *result;

register T *tempValue;

LLP" %[result], %[_q_value]\n"

"xor %[result], %[result], %[expectedValue]\n"

"bnez %[result], 0f\n"

"beqz %[tempValue], 0b\n"

"nop\n"

"0:\n"

: [result] "=&r" (result),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register T *result;

register T *tempValue;

LLP" %[result], %[_q_value]\n"

"xor %[result], %[result], %[expectedValue]\n"

"bnez %[result], 0f\n"

"nop\n"

"sync\n"

"0:\n"

: [result] "=&r" (result),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register T *result;

register T *tempValue;

"0:\n"

LLP" %[result], %[_q_value]\n"

"xor %[result], %[result], %[expectedValue]\n"

"beqz %[tempValue], 0b\n"

"nop\n"

"0:\n"

: [result] "=&r" (result),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register T *originalValue;

register T *tempValue;

LLP" %[originalValue], %[_q_value]\n"

"move %[tempValue], %[newValue]\n"

SCP" %[tempValue], %[_q_value]\n"

"beqz %[tempValue], 0b\n"

"nop\n"

: [originalValue] "=&r" (originalValue),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register T *originalValue;

register T *tempValue;

LLP" %[originalValue], %[_q_value]\n"

"move %[tempValue], %[newValue]\n"

SCP" %[tempValue], %[_q_value]\n"

"beqz %[tempValue], 0b\n"

"nop\n"

"sync\n"

: [originalValue] "=&r" (originalValue),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register T *originalValue;

register T *tempValue;

"0:\n"

LLP" %[originalValue], %[_q_value]\n"

"move %[tempValue], %[newValue]\n"

SCP" %[tempValue], %[_q_value]\n"

"beqz %[tempValue], 0b\n"

"nop\n"

: [originalValue] "=&r" (originalValue),

[tempValue] "=&r" (tempValue),

[_q_value] "+m" (_q_value)

{

register T *originalValue;

register T *newValue;

LLP" %[originalValue], %[_q_value]\n"

"addu %[newValue], %[originalValue], %[valueToAdd]\n"

SCP" %[newValue], %[_q_value]\n"

"beqz %[newValue], 0b\n"

"nop\n"

: [originalValue] "=&r" (originalValue),

[_q_value] "+m" (_q_value),

[newValue] "=&r" (newValue)

{

register T *originalValue;

register T *newValue;

LLP" %[originalValue], %[_q_value]\n"

"addu %[newValue], %[originalValue], %[valueToAdd]\n"

SCP" %[newValue], %[_q_value]\n"

"beqz %[newValue], 0b\n"

"nop\n"

"sync\n"

: [originalValue] "=&r" (originalValue),

[_q_value] "+m" (_q_value),

[newValue] "=&r" (newValue)

{

register T *originalValue;

register T *newValue;

"0:\n"

LLP" %[originalValue], %[_q_value]\n"

"addu %[newValue], %[originalValue], %[valueToAdd]\n"

SCP" %[newValue], %[_q_value]\n"

"beqz %[newValue], 0b\n"

"nop\n"

: [originalValue] "=&r" (originalValue),

[_q_value] "+m" (_q_value),

[newValue] "=&r" (newValue)

break;

emit q->progressValueChanged(event->index1);

q->progressTextChanged(event->text);

break;

case QFutureCallOutEvent::ProgressRange:

io/qdiriterator.h \

io/qfile.h \

io/qfileinfo.h \

io/qiodevice.h \

io/qiodevice_p.h \

io/qprocess.h \

io/qprocess_p.h \

io/qtextstream.h \

io/qfile.cpp \

io/qfileinfo.cpp \

io/qiodevice.cpp \

io/qprocess.cpp \

io/qtextstream.cpp \

io/qtemporaryfile.cpp \

#include <QtCore/qstring.h>

#include <QtCore/qvector.h>

#include <QtCore/qset.h>

QT_BEGIN_HEADER

return operator<<(debug, set.toList());

}

#if !defined(QT_NO_DEBUG_STREAM)

Q_CORE_EXPORT_INLINE QDebug qDebug() { return QDebug(QtDebugMsg); }

#endif

if (len > 0) {

QString ret;

QDir parent(d->filePath);

parent.cdUp();

ret = parent.path();

}

QCoreApplicationPrivate *d = self->d_func();

d->cachedApplicationDirPath = QFileInfo(applicationFilePath()).path();

return d->cachedApplicationDirPath;

}

}

QCoreApplicationPrivate *d = self->d_func();

return d->cachedApplicationFilePath;

#if defined( Q_WS_WIN )

and versatile, but may prove less memory and speed efficient than

storing specific types in standard data structures.

\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 1

#endif

/*!

\class QHash

\brief The QHash class is a template class that provides a hash-table-based dictionary.

key. With QHash, the items are arbitrarily ordered.

\i The key type of a QMap must provide operator<(). The key

type of a QHash must provide operator==() and a global

\endlist

Here's an example QHash with QString keys and \c int values:

*/

/*! \fn const T QHash::value(const Key &key, const T &defaultValue) const

\overload

If the hash contains no item with the given \a key, the function returns

\sa operator+=(), operator-()

*/

/*! \fn QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)

\relates QHash

return buffers.isEmpty() ? 0 : (buffers.first().constData() + head);

}

inline void free(int bytes) {

bufferSize -= bytes;

if (bufferSize < 0)

/*!

\since 4.2

If \a size is -1 (default), the \a string has to be 0 terminated.

valueForTime() and emitting valueChanged(). By default, valueForTime()

applies an interpolation algorithm to generate these value. You can choose

from a set of predefined timeline algorithms by calling

which provides a value that grows slowly, then grows steadily, and

finally grows slowly. For a custom timeline, you can reimplement

valueForTime(), in which case QTimeLine's curveShape property is ignored.

tools/qlocale_p.h \

tools/qlocale_data_p.h \

tools/qmap.h \

tools/qpodlist_p.h \

tools/qpoint.h \

tools/qqueue.h \

tools/qlocale.cpp \

tools/qpoint.cpp \

tools/qmap.cpp \

tools/qrect.cpp \

tools/qregexp.cpp \

tools/qshareddata.cpp \

continue;

for (int j = 0; move && j < rowCount(); ++j) {

#if defined(Q_OS_WIN)

#else

#endif

removeRow(j);

if (j <= row)

*/

QTransform QGraphicsItem::deviceTransform(const QTransform &viewportTransform) const

{

// Find the topmost item that ignores view transformations.

const QGraphicsItem *untransformedAncestor = this;

QList<const QGraphicsItem *> parents;

bool disabled = !item->isEnabled();

bool isWindow = item->isWindow();

if (mouseEvent->type() == QEvent::GraphicsSceneMouseDoubleClick

// If this item is different from the item that received the last

// mouse event, and mouseEvent is a doubleclick event, then the

// event is converted to a press. Known limitation:

// Calculate a simple level-of-detail metric.

// ### almost identical code in QGraphicsView::paintEvent()

// and QGraphicsView::render() - consider refactoring

option.levelOfDetail = qSqrt(itemToDeviceTransform.map(v1).length() * itemToDeviceTransform.map(v2).length());

option.matrix = itemToDeviceTransform.toAffine(); //### discards perspective

// optimization, but it's hit very rarely.

for (int i = clippers.size() - 1; i >= 0; --i) {

QGraphicsItem *clipper = clippers[i];

childClippers.append(clipper);

painter->save();

}

// Set up the painter transform

// Save painter

bool saveState = (d->painterStateProtection || (item->flags() & QGraphicsItem::ItemClipsToShape));

if (saveState)

// Calculate a simple level-of-detail metric.

// ### almost identical code in QGraphicsScene::render()

// and QGraphicsView::render() - consider refactoring

if (itemToViewportTransform.type() <= QTransform::TxTranslate) {

// Translation and rotation only? The LOD is 1.

disconnect(d->scene, SIGNAL(sceneRectChanged(QRectF)),

this, SLOT(updateSceneRect(QRectF)));

d->scene->d_func()->views.removeAll(this);

}

// Assign the new scene and update the contents (scrollbars, etc.)).

// Calculate a simple level-of-detail metric.

// ### almost identical code in QGraphicsScene::render()

// and QGraphicsView::paintEvent() - consider refactoring

option->levelOfDetail = qSqrt(itemToViewportTransform.map(v1).length() * itemToViewportTransform.map(v2).length());

option->matrix = itemToViewportTransform.toAffine();

QImageWriter::supportedImageFormats() functions to retrieve a

complete list of the supported file formats.

\sa addPixmap()

*/

void QIcon::addFile(const QString &fileName, const QSize &size, Mode mode, State state)

} else {

qWarning("qt_fromWinHBITMAP(), failed to get bitmap bits");

}

return image;

}

}

if (info.isDir())

#ifdef Q_WS_WIN

#else

#endif

// Windows - "File Folder"

// OS X - "Folder"

// Konqueror - "Folder"

// Nautilus - "folder"

if (info.isSymLink())

#ifdef Q_OS_MAC

#else

#endif

// OS X - "Alias"

// Windows - "Shortcut"

// Konqueror - "Folder" or "TXT File" i.e. what it is pointing to

if (!selection.at(i).isValid())

continue;

QModelIndex parent = selection.at(i).topLeft().parent();

int t = selection.at(i).topLeft().row();

int b = selection.at(i).bottomRight().row();

if (d->viewMode == IconMode || d->isWrapping()) { // in non-static mode, we have to go through all selected items

} else { // in static mode, we can optimize a bit

while (t <= b && d->isHidden(t)) ++t;

while (b >= t && d->isHidden(b)) --b;

QRect rect(visualRect(top).topLeft(),

visualRect(bottom).bottomRight());

selectionRegion += QRegion(rect);

Q_Q(QTreeView);

QModelIndex current;

QModelIndex parent = (i < 0) ? (QModelIndex)root : modelIndex(i);

if (i>=0 && !parent.isValid()) {

//modelIndex() should never return something invalid for the real items.

void QApplicationPrivate::setFocusWidget(QWidget *focus, Qt::FocusReason reason)

{

#ifndef QT_NO_GRAPHICSVIEW

return;

hidden_focus_widget = 0;

(dm->xdndMimeTransferedPixmapIndex + 1) % 2;

}

} else {

}

}

return data;

if (format == QLatin1String("image/ppm")) {

if (a == XA_PIXMAP && data.size() == sizeof(Pixmap)) {

Pixmap xpm = *((Pixmap*)data.data());

if (!xpm)

return QByteArray();

QPixmap qpm = QPixmap::fromX11Pixmap(xpm);

The \a type parameter must be QEvent::KeyPress, QEvent::KeyRelease,

or QEvent::ShortcutOverride.

*/

QKeyEvent::QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text,

bool autorep, ushort count)

inline static QRect fromLayoutItemRect(QWidgetPrivate *priv, const QRect &rect)

{

}

inline static QSize fromLayoutItemSize(QWidgetPrivate *priv, const QSize &size)

inline static QRect toLayoutItemRect(QWidgetPrivate *priv, const QRect &rect)

{

}

inline static QSize toLayoutItemSize(QWidgetPrivate *priv, const QSize &size)

tw = tw->parentWidget();

return tw == w;

}

}

// Below is Qt::WindowShortcut context

extern bool qt_sendSpontaneousEvent(QObject*, QEvent*); // qapplication.cpp

extern QDesktopWidget *qt_desktopWidget; // qapplication.cpp

#if defined(Q_WS_X11)

#endif

{

if (!qApp) {

qFatal("QWidget: Must construct a QApplication before a QPaintDevice");

d->setDirtyOpaqueRegion();

if (isWindow() && isVisible() && internalWinId())

#if defined(Q_WS_WIN) || defined(Q_WS_X11)

else if (!internalWinId() && isVisible())

qApp->d_func()->sendSyntheticEnterLeave(this);

createExtra();

if (!extra->topextra) {

QTLWExtra* x = extra->topextra = new QTLWExtra;

x->windowSurface = 0;

x->opacity = 255;

x->posFromMove = false;

x->sizeAdjusted = false;

x->inTopLevelResize = false;

x->inRepaint = false;

x->embedded = 0;

createTLSysExtra();

#ifdef QWIDGET_EXTRA_DEBUG

#endif

}

}

{

if (!extra) { // if not exists

extra = new QWExtra;

extra->explicitMinSize = 0;

extra->explicitMaxSize = 0;

extra->autoFillBackground = 0;

extra->nativeChildrenForced = 0;

extra->inRenderWithPainter = 0;

extra->hasMask = 0;

createSysExtra();

#ifdef QWIDGET_EXTRA_DEBUG

#endif

}

}

}

/*

Returns true if there are widgets above this which overlap with

\a rect, which is in parent's coordinate system (same as crect).

*/

}

}

bool QWidgetPrivate::paintOnScreen() const

{

#if defined(Q_WS_QWS)

return dx + dy;

}

/*!

\property QWidget::frameSize

\brief the size of the widget including any window frame

static EventTypeSpec window_events[] = {

{ kEventClassWindow, kEventWindowClose },

{ kEventClassWindow, kEventWindowExpanded },

{ kEventClassWindow, kEventWindowZoomed },

{ kEventClassWindow, kEventWindowCollapsed },

{ kEventClassWindow, kEventWindowToolbarSwitchMode },

// By also setting the current modal window back into the event, we

// help Carbon determining which window is supposed to be raised.

handled_event = qApp->activePopupWidget() ? true : false;

#endif

} else if(ekind == kEventWindowClose) {

widget->d_func()->close_helper(QWidgetPrivate::CloseWithSpontaneousEvent);

}

}

}

} else {

handled_event = false;

}

return true;

}

bool QWidgetPrivate::qt_widget_rgn(QWidget *widget, short wcode, RgnHandle rgn, bool force = false)

{

bool ret = false;

void QWidgetPrivate::createTLSysExtra()

{

extra->topextra->wclass = 0;

extra->topextra->group = 0;

extra->topextra->windowIcon = 0;

extra->topextra->savedWindowAttributesFromMaximized = 0;

}

class QStyle;

struct QTLWExtra {

QString caption; // widget caption

QString iconText; // widget icon text

QString role; // widget role

QString filePath; // widget file path

short incw, inch; // size increments

// frame strut, don't use these directly, use QWidgetPrivate::frameStrut() instead.

QRect frameStrut;

uint opacity : 8;

uint posFromMove : 1;

uint sizeAdjusted : 1;

uint inTopLevelResize : 1;

uint inRepaint : 1;

uint spont_unmapped: 1; // window was spontaneously unmapped

uint dnd : 1; // DND properties installed

uint validWMState : 1; // is WM_STATE valid?

uint waitingForMapNotify : 1; // show() has been called, haven't got the MapNotify yet

WId userTimeWindow; // window id that contains user-time timestamp when WM supports a _NET_WM_USER_TIME_WINDOW atom

QPoint fullScreenOffset;

quint32 wattr;

quint32 wclass;

WindowGroupRef group;

IconRef windowIcon; // the current window icon, if set with setWindowIcon_sys.

quint32 savedWindowAttributesFromMaximized; // Saved attributes from when the calling updateMaximizeButton_sys()

QWSManager *qwsManager;

#endif

#endif

};

struct QWExtra {

QTLWExtra *topextra; // only useful for TLWs

QGraphicsProxyWidget *proxyWidget; // if the widget is embedded

#endif

QRegion mask; // widget mask

QSize staticContentsSize;

uint explicitMinSize : 2;

uint explicitMaxSize : 2;

uint autoFillBackground : 1;

uint inRenderWithPainter : 1;

uint hasMask : 1;

// Cocoa Mask stuff

QImage maskBits;

CGImageRef imageMask;

#endif

};

class Q_GUI_EXPORT QWidgetPrivate : public QObjectPrivate

Q_DECLARE_PUBLIC(QWidget)

public:

explicit QWidgetPrivate(int version = QObjectPrivateVersion);

~QWidgetPrivate();

QPainter *sharedPainter() const;

void setSharedPainter(QPainter *painter);

QWidgetBackingStore *maybeBackingStore() const;

void init(QWidget *desktopWidget, Qt::WindowFlags f);

void create_sys(WId window, bool initializeWindow, bool destroyOldWindow);

void createRecursively();

QPalette naturalWidgetPalette(uint inheritedMask) const;

void setMask_sys(const QRegion &);

void raise_sys();

void lower_sys();

void stackUnder_sys(QWidget *);

void setStyle_helper(QStyle *newStyle, bool propagate, bool metalHack = false);

void inheritStyle();

void setUpdatesEnabled_helper(bool );

void paintBackground(QPainter *, const QRegion &, const QPoint & = QPoint(), int flags = DrawAsRoot) const;

bool isAboutToShow() const;

QRegion prepareToRender(const QRegion &region, QWidget::RenderFlags renderFlags);

void render_helper(QPainter *painter, const QPoint &targetOffset, const QRegion &sourceRegion,

QWindowSurface *createDefaultWindowSurface();

QWindowSurface *createDefaultWindowSurface_sys();

void repaint_sys(const QRegion &rgn);

QRect clipRect() const;

QRegion clipRegion() const;

void updateIsOpaque();

void setOpaque(bool opaque);

void updateIsTranslucent();

bool paintOnScreen() const;

QRegion getOpaqueRegion() const;

const QRegion &getOpaqueChildren() const;

void setDirtyOpaqueRegion();

bool close_helper(CloseMode mode);

void setWindowIcon_helper();

void setWindowIcon_sys(bool forceReset = false);

void setWindowOpacity_sys(qreal opacity);

void adjustQuitOnCloseAttribute();

void scrollChildren(int dx, int dy);

void moveRect(const QRect &, int dx, int dy);

void scrollRect(const QRect &, int dx, int dy);

void invalidateBuffer_resizeHelper(const QPoint &oldPos, const QSize &oldSize);

void reparentFocusWidgets(QWidget *oldtlw);

static int pointToRect(const QPoint &p, const QRect &r);

void setWinId(WId);

void showChildren(bool spontaneous);

void scroll_sys(int dx, int dy, const QRect &r);

void deactivateWidgetCleanup();

void setGeometry_sys(int, int, int, int, bool);

void sendPendingMoveAndResizeEvents(bool recursive = false, bool disableUpdates = false);

void activateChildLayoutsRecursively();

void show_recursive();

void setEnabled_helper(bool);

void registerDropSite(bool);

static void adjustFlags(Qt::WindowFlags &flags, QWidget *w = 0);

void updateFrameStrut();

void setWindowIconText_helper(const QString &cap);

void setWindowTitle_sys(const QString &cap);

#ifndef QT_NO_CURSOR

void setCursor_sys(const QCursor &cursor);

void unsetCursor_sys();

#endif

void setWindowTitle_helper(const QString &cap);

void setWindowFilePath_helper(const QString &filePath);

QInputContext *inputContext() const;

QWExtra *extra;

QWidget *focus_next;

QWidget *focus_prev;

QWidget *focus_child;

QLayout *layout;

QWidgetItemV2 *widgetItem;

// All widgets are initially added into the uncreatedWidgets set. Once

// they receive a window id they are removed and added to the mapper

static QWidgetMapper *mapper;

static QWidgetSet *uncreatedWidgets;

#ifndef QT_NO_TOOLTIP

QString toolTip;

#endif

#ifndef QT_NO_WHATSTHIS

QString whatsThis;

#endif

QPalette::ColorRole fg_role : 8;

QPalette::ColorRole bg_role : 8;

uint dirtyOpaqueChildren : 1;

uint isOpaque : 1;

uint inDirtyList : 1;

uint isMoved : 1;

uint usesDoubleBufferedGLContext : 1;

QX11Info xinfo;

Qt::HANDLE picture;

#endif

// Each wiget keeps a list of all its child and grandchild OpenGL widgets.

// This list is used to update the gl context whenever a parent and a granparent

QWidget * widget;

QWidget * lastUpdateWidget;

};

// dirtyOnWidget contains the areas in the widget that needs to be repained,

// in the same way as dirtyOnScreen does for the window. Areas are added in

// dirtyWidget_sys and cleared in the paint event. In scroll_sys we then use

// this information repaint invalid areas when widgets are scrolled.

QRegion dirtyOnWidget;

//these are here just for code compat (HIViews)

Qt::HANDLE qd_hd;

#else

#endif

#endif

#endif

};

inline QWExtra *QWidgetPrivate::extraData() const

}

}

void QWidgetPrivate::show_sys()

{

Q_Q(QWidget);

void QWidgetPrivate::createTLSysExtra()

{

}

void QWidgetPrivate::deleteTLSysExtra()

if (newstate & Qt::WindowFullScreen) {

if (d->topData()->normalGeometry.width() < 0 && !(oldstate & Qt::WindowMaximized))

d->topData()->normalGeometry = geometry();

#ifndef Q_FLATTEN_EXPOSE

UINT style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_POPUP;

#else

UINT style = WS_POPUP;

#endif

style |= WS_SYSMENU;

if (isVisible())

style |= WS_VISIBLE;

(In all comments below: s/X/Windows/g)

*/

{

Q_Q(QWidget);

Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));

return val;

}

void QWidgetPrivate::createSysExtra()

{

#ifndef QT_NO_DRAGANDDROP

#endif

}

void QWidgetPrivate::deleteSysExtra()

{

}

void QWidgetPrivate::createTLSysExtra()

{

extra->topextra->winIconBig = 0;

}

void QWidgetPrivate::deleteTLSysExtra()

if (newstate & Qt::WindowFullScreen) {

if (d->topData()->normalGeometry.width() < 0 && !(oldstate & Qt::WindowMaximized))

d->topData()->normalGeometry = geometry();

UINT style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_POPUP;

if (isVisible())

style |= WS_VISIBLE;

QApplication::sendEvent(this, &e);

}

void QWidgetPrivate::deleteSysExtra()

{

Q_Q(QWidget);

#endif

}

void QWidget::destroy(bool destroyWindow, bool destroySubWindows)

{

Q_D(QWidget);

parentWRect is the geometry of the parent's X rect, measured in

parent's coord sys

*/

{

Q_Q(QWidget);

Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));

void QWidgetPrivate::createSysExtra()

{

extra->compress_events = true;

}

void QWidgetPrivate::deleteSysExtra()

void QWidgetPrivate::createTLSysExtra()

{

extra->topextra->validWMState = 0;

extra->topextra->waitingForMapNotify = 0;

extra->topextra->userTimeWindow = 0;

}

*/

QColor QColor::toHsv() const

{

return *this;

if (cspec != Rgb)

*/

QColor QColor::toCmyk() const

{

return *this;

if (cspec != Rgb)

return toRgb().toCmyk();

real_engine->stroke(path, bgPen);

}

QBrush brush = pen.brush();

Qt::BrushStyle style = qbrush_style(brush);

if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {

const QGradient *g = brush.gradient();

if (g->coordinateMode() > QGradient::LogicalMode) {

}

}

ti.ascent.toReal(),

ti.descent.toReal());

#endif

if (glyph_height == 0 || glyph_width == 0)

continue;

// align to 8-bit boundary

if (m_type == QFontEngineGlyphCache::Raster_Mono)

glyph_width = (glyph_width+7)&~7;

int QImageTextureGlyphCache::glyphMargin() const

{

return 2;

}

void QImageTextureGlyphCache::fillTexture(const Coord &c, glyph_t g)

if (!styleHint(SH_UnderlineShortcut, opt, widget))

alignment |= Qt::TextHideMnemonic;

rect.translate(shiftX, shiftY);

drawItemText(p, rect, alignment, toolbutton->palette,

opt->state & State_Enabled, toolbutton->text,

QPalette::ButtonText);

QSize sz(contentsSize);

switch(ct) {

case CT_RadioButton:

case CT_CheckBox:

sz = QCommonStyle::sizeFromContents(ct, opt, contentsSize, widget);

\value PM_LayoutVerticalSpacing Default \l{QLayout::spacing}{vertical spacing} for a QLayout.

\value PM_MaximumDragDistance The maximum allowed distance between

distance will cause the slider to jump back to the original

position; a value of -1 disables this behavior.

if (const QStyleOptionToolButton *tool = qstyleoption_cast<const QStyleOptionToolButton *>(opt)) {

QStyleOptionToolButton toolOpt(*tool);

rule.configurePalette(&toolOpt.palette, QPalette::ButtonText, QPalette::Button);

toolOpt.rect = rule.borderRect(opt->rect);

bool customArrow = (tool->features & (QStyleOptionToolButton::HasMenu | QStyleOptionToolButton::MenuButtonPopup));

bool customDropDown = tool->features & QStyleOptionToolButton::MenuButtonPopup;

return;

case PE_IndicatorToolBarSeparator:

name = QLatin1String("TOOLBAR");

partId = TP_SEPARATOR;

subpixelType = Subpixel_None;

lcdFilterType = 0;

#if defined(FT_LCD_FILTER_H)

#endif

defaultFormat = Format_None;

canUploadGlyphsToServer = false;

#endif

#endif

QNativeImage::systemFormat(), true);

ni->image.fill(0xffffffff);

font = CreateFontIndirectW(&lf);

}

if (mask == 0)

return QImage();

case QEvent::Resize:

d->layoutChildren();

break;

if (d->cornerPaintingRect.isValid()) {

option.rect = d->cornerPaintingRect;

QPainter p(this);

style()->drawPrimitive(QStyle::PE_PanelScrollAreaCorner, &option, &p, this);

}

#ifdef Q_WS_MAC

if (d->reverseCornerPaintingRect.isValid()) {

option.rect = d->reverseCornerPaintingRect;

QPainter p(this);

style()->drawPrimitive(QStyle::PE_PanelScrollAreaCorner, &option, &p, this);

}

#endif

QFrame::paintEvent((QPaintEvent*)e);

break;

#ifndef QT_NO_CONTEXTMENU

Q_D(QAbstractSpinBox);

if (d->buttonSymbols != buttonSymbols) {

d->buttonSymbols = buttonSymbols;

update();

}

}

mbi.nToolBarId = toolbarID;

if (ptrCreateMenuBar(&mbi)) {

// Tell the menu bar that we want to override hot key behaviour.

LPARAM lparam = MAKELPARAM(SHMBOF_NODEFAULT | SHMBOF_NOTIFY,

SHMBOF_NODEFAULT | SHMBOF_NOTIFY);

int tickInterval;

QSlider::TickPosition tickPosition;

int clickOffset;

void init();

void resetLayoutItemMargins();

int pixelPosToRangeValue(int pos) const;

setRepeatAction(SliderNoAction);

QRect sr = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this);

d->clickOffset = d->pick(ev->pos() - sr.topLeft());

update(sr);

setSliderDown(true);

}

int newPosition = d->pixelPosToRangeValue(d->pick(ev->pos()) - d->clickOffset);

QStyleOptionSlider opt;

initStyleOption(&opt);