summaryrefslogtreecommitdiffstats
path: root/doc/src
diff options
context:
space:
mode:
Diffstat (limited to 'doc/src')
-rw-r--r--doc/src/declarative/extending.qdoc16
-rw-r--r--doc/src/declarative/integrating.qdoc4
-rw-r--r--doc/src/declarative/qtdeclarative.qdoc87
-rw-r--r--doc/src/declarative/qtprogrammers.qdoc2
-rw-r--r--doc/src/examples/bearercloud.qdoc197
-rw-r--r--doc/src/examples/bearermonitor.qdoc49
-rw-r--r--doc/src/examples/qtscriptcustomclass.qdoc13
-rw-r--r--doc/src/getting-started/examples.qdoc2
-rw-r--r--doc/src/images/bearercloud-example.pngbin0 -> 37582 bytes
-rw-r--r--doc/src/images/bearermonitor-example.pngbin0 -> 34862 bytes
-rw-r--r--doc/src/network-programming/bearermanagement.qdoc286
-rw-r--r--doc/src/network-programming/qtnetwork.qdoc30
-rw-r--r--doc/src/snippets/code/src_gui_image_qicon.cpp4
-rw-r--r--doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp9
-rw-r--r--doc/src/snippets/qelapsedtimer/main.cpp112
-rw-r--r--doc/src/snippets/qelapsedtimer/qelapsedtimer.pro2
-rw-r--r--doc/src/sql-programming/sql-driver.qdoc67
17 files changed, 822 insertions, 58 deletions
diff --git a/doc/src/declarative/extending.qdoc b/doc/src/declarative/extending.qdoc
index 0ae4f7d..8c096da 100644
--- a/doc/src/declarative/extending.qdoc
+++ b/doc/src/declarative/extending.qdoc
@@ -177,7 +177,7 @@ The guest property declaration looks like this:
\snippet examples/declarative/extending/properties/birthdayparty.h 2
-\l {Extending QML in C++ - Object and List Property Types Example} shows the complete
+\l {Extending QML - Object and List Property Types Example} shows the complete
code used to create the \c BirthdayParty type.
\section1 Inheritance and Coercion
@@ -224,7 +224,7 @@ QML will automatically coerce C++ types when assigning to either an object
property, or to a list property. Only if coercion fails does an assignment
error occur.
-\l {Extending QML in C++ - Inheritance and Coercion Example} shows the complete
+\l {Extending QML - Inheritance and Coercion Example} shows the complete
code used to create the \c Boy and \c Girl types.
\section1 Default Property
@@ -256,7 +256,7 @@ refer to a property declared in the class itself, or a property inherited from a
base class.
\endquotation
-\l {Extending QML in C++ - Default Property Example} shows the complete code used to
+\l {Extending QML - Default Property Example} shows the complete code used to
specify a default property.
\section1 Grouped Properties
@@ -281,7 +281,7 @@ property block - in this case the size, color, brand and price properties.
Grouped property blocks may declared and accessed be recusively.
-\l {Extending QML in C++ - Grouped Properties Example} shows the complete code used to
+\l {Extending QML - Grouped Properties Example} shows the complete code used to
implement the \c shoe property grouping.
\section1 Attached Properties
@@ -373,7 +373,7 @@ creating it if it does not already exist. If \a create is false, the attachment
object will only be returned if it has previously been created.
\endquotation
-\l {Extending QML in C++ - Attached Properties Example} shows the complete code used to
+\l {Extending QML - Attached Properties Example} shows the complete code used to
implement the rsvp attached property.
\section1 Memory Management and QVariant types
@@ -435,7 +435,7 @@ listed in \l {Adding Types}, as well registered object types are permitted as
signal parameter types. Using other types is not an error, but the parameter
value will not be accessible from script.
-\l {Extending QML in C++ - Signal Support Example} shows the complete code used to
+\l {Extending QML - Signal Support Example} shows the complete code used to
implement the onPartyStarted signal property.
\section1 Property Value Sources
@@ -482,7 +482,7 @@ to assign it normally, as though it were a regular QML type. Only if this
assignment fails does the engine call the setTarget() method. This allows
the type to also be used in contexts other than just as a value source.
-\l {Extending QML in C++ - Property Value Source Example} shows the complete code used
+\l {Extending QML - Property Value Source Example} shows the complete code used
implement the HappyBirthday property value source.
\section1 Property Binding
@@ -554,7 +554,7 @@ The CONSTANT attribute should only be used for properties whose value is set,
and finalized, only in the class constructor. All other properties that want
to be used in bindings should have a NOTIFY signal instead.
-\l {Extending QML in C++ - Binding Example} shows the BirthdayParty example updated to
+\l {Extending QML - Binding Example} shows the BirthdayParty example updated to
include NOTIFY signals for use in binding.
\section1 Extension Objects
diff --git a/doc/src/declarative/integrating.qdoc b/doc/src/declarative/integrating.qdoc
index c685d3d..165a735 100644
--- a/doc/src/declarative/integrating.qdoc
+++ b/doc/src/declarative/integrating.qdoc
@@ -103,13 +103,13 @@ and that this approach allows you to integrate new items written in QML
without using the above method.
You can make custom C++ types
-available in QML using the pair of macros listed in \l{Extending QML}.
+available in QML using the pair of macros listed in \l{Extending QML in C++}.
While this is normally only useful for
types that were designed for QML use, in conjunction with the
\l{GraphicsObjectContainer} element QGraphicsWidget subclasses can also be
used effectively (if they were designed, like QGraphicsWidget, to be controllable through Qt's property system).
This way you can write your UI using QML, without having to rewrite your existing items.
-For details on implementing this approach see \l{Extending QML} page for details on exposing your C++ types,
+For details on implementing this approach see \l{Extending QML in C++} page for details on exposing your C++ types,
and the \l{GraphicsObjectContainer} documentation for details about using it to wrap QGraphicsWidgets.
*/
diff --git a/doc/src/declarative/qtdeclarative.qdoc b/doc/src/declarative/qtdeclarative.qdoc
index b43d0ec..8013b92 100644
--- a/doc/src/declarative/qtdeclarative.qdoc
+++ b/doc/src/declarative/qtdeclarative.qdoc
@@ -40,76 +40,75 @@
****************************************************************************/
/*!
-\module QtDeclarative
-\title QtDeclarative Module
-\ingroup modules
+ \module QtDeclarative
+ \title QtDeclarative Module
+ \ingroup modules
-\brief The Qt Declarative module provides a declarative framework for building
-highly dynamic, custom user interfaces.
+ \brief The Qt Declarative module provides a declarative framework
+ for building highly dynamic, custom user interfaces.
-To include the definitions of the module's classes, use the
-following directive:
+ To include the definitions of the module's classes, use the
+ following directive:
-\code
-#include <QtDeclarative>
-\endcode
+ \code
+ #include <QtDeclarative>
+ \endcode
-To link against the module, add this line to your \l qmake \c
-.pro file:
+ To link against the module, add this line to your \l qmake \c
+ .pro file:
-\code
-QT += declarative
-\endcode
-
-For more information on the Qt Declarative module, see the
-\l{declarativeui.html}{Declarative UI} documentation.
+ \code
+ QT += declarative
+ \endcode
+ For more information on the Qt Declarative module, see the
+ \l{declarativeui.html}{Declarative UI} documentation.
*/
/*!
- \macro QML_DECLARE_TYPE(T)
- \relates QDeclarativeEngine
-
- yada yada yada
-
+ \macro QML_DECLARE_TYPE()
+ \relates QDeclarativeEngine
*/
/*!
- \fn int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
- \relates QDeclarativeEngine
+ \fn int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
+ \relates QDeclarativeEngine
- This template function registers the C++ type \a T with the QML system, and make it available in
- QML under the name \a qmlName in the import library \a uri version \a versionMajor.versionMajor.
+ This template function registers the C++ type in the QML system with
+ the name \a qmlName. in the library imported from \a uri having the
+ version number composed from \a versionMajor and \a versionMinor.
- Returns the QML type id.
+ Returns the QML type id.
- Example: Register the C++ class \c MinehuntGame as QML type \c Game version 0.1 in the import
- library \c MinehuntCore:
+ Example: Register the C++ class \c MinehuntGame as the QML type
+ named \c Game for version 0.1 in the import library \c MinehuntCore:
- \code
- qmlRegisterType<MinehuntGame>("MinehuntCore", 0, 1, "Game");
- \endcode
+ \code
+ qmlRegisterType<MinehuntGame>("MinehuntCore", 0, 1, "Game");
+ \endcode
*/
/*!
- \fn int qmlRegisterType()
- \relates QDeclarativeEngine
- \overload
+ \fn int qmlRegisterType()
+ \relates QDeclarativeEngine
+ \overload
- This template function registers the C++ type \a T with the QML system. Instances of this type cannot
- be created from the QML system.
+ This template function registers the C++ type in the QML
+ system. Instances of this type cannot be created from the QML
+ system.
- Returns the QML type id.
+ Returns the QML type id.
*/
-/*! \fn int qmlRegisterInterface(const char *typeName)
- \relates QDeclarativeEngine
+/*!
+ \fn int qmlRegisterInterface(const char *typeName)
+ \relates QDeclarativeEngine
- This template function registers the C++ type \a T as interface with the QML system, under the name
- \a typeName.
+ This template function registers the C++ type in the QML system
+ under the name \a typeName.
- Returns the QML type id.
+ Returns the QML type id.
*/
diff --git a/doc/src/declarative/qtprogrammers.qdoc b/doc/src/declarative/qtprogrammers.qdoc
index ca1d596..05ffeb0 100644
--- a/doc/src/declarative/qtprogrammers.qdoc
+++ b/doc/src/declarative/qtprogrammers.qdoc
@@ -65,7 +65,7 @@ QML provides direct access to the following concepts from Qt:
\o Qt models - used directly in data binding (QAbstractItemModel and next generation QListModelInterface)
\endlist
-Qt knowledge is \e required for \l {Extending QML}, and also for \l{Integrating QML with existing Qt UI code}.
+Qt knowledge is \e required for \l {Extending QML in C++}, and also for \l{Integrating QML with existing Qt UI code}.
\section1 QML Items compared with QWidgets
diff --git a/doc/src/examples/bearercloud.qdoc b/doc/src/examples/bearercloud.qdoc
new file mode 100644
index 0000000..c7acf04
--- /dev/null
+++ b/doc/src/examples/bearercloud.qdoc
@@ -0,0 +1,197 @@
+/****************************************************************************
+**
+** 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 documentation 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$
+**
+****************************************************************************/
+
+/*!
+ \example network/bearercloud
+ \title Bearer Cloud Example
+
+ The Bearer Cloud example shows how to use the Bearer Management API to monitor the
+ connectivity state of the local device.
+
+ \image bearercloud-example.png Screenshot of the Bearer Cloud example
+
+ Bearer Management provides the QNetworkConfigurationManager class which can be used to monitor
+ changes in the available \l {QNetworkConfiguration}{network configurations} and the
+ QNetworkSession class which is used to \l {QNetworkSession::open()}{open} and
+ \l {QNetworkSession::close()}{close} a session bringing a network interface up or down if
+ necessary.
+
+ This example displays all known \l {QNetworkConfiguration}{network configurations} in a cloud
+ orbiting the local device. There are four orbits representing the four possible
+ \l {QNetworkConfiguration::StateFlags}{states} that the network configuration can be in.
+ The closer the orbit the more useful the network configuration is in its current state.
+ The inner orbit is populated with network configurations that are in the
+ \l {QNetworkConfiguration::Active}{Active} state. The second orbit is populated with network
+ configurations that are in the \l {QNetworkConfiguration::Discovered}{Discovered} state. The
+ third orbit is populated with network configurations that are in the
+ \l {QNetworkConfiguration::Defined}{Defined} state. Finally the outer orbit is populated by
+ configurations that are in the \l {QNetworkConfiguration::Undefined}{Undefined} state.
+
+ Hovering the mouse over a network configuration will display information about the network
+ configuration in a tool tip.
+
+ Double clicking on an Active or Discovered network configuration will
+ \l {QNetworkSession::close()}{close} or \l {QNetworkSession::open()}{open} a network session,
+ respectively.
+
+ Lastly you can reorganize the cloud without changing the state of the network configurations by
+ dragging them around.
+
+ This example consists of two main classes, the BearerCloud and Cloud classes. The Cloud class
+ represents a single network session and associated network configuration. The BearerCloud
+ class implements a Graphics View scene and manages the life-cycle of Cloud
+ objects in response to notification signals from QNetworkConfigurationManager.
+
+ \section1 Setting the scene
+
+ When constructing the scene we first calculate some random offsets using the global qsand()
+ and qrand() functions. We will use these offsets to scatter the initial position of new Cloud
+ objects.
+
+ Next we place a text item in the center of the scene to represent the local device and
+ surround it with four concentric circles to help visualize the orbits.
+
+ Finally we connect up the network configuration notification signals and queue the initial
+ population of the scene during the next iteration of the event loop.
+
+ \snippet examples/network/bearercloud/bearercloud.cpp 0
+
+ Populating the scene with the initial list of known network configuration is easy. Iterate
+ over the list returned by QNetworkConfigurationManager::allConfigurations(), calling our
+ configurationAdded() slot on each one.
+
+ We finishing off by calling cloudMoved() to ensure that animations are started.
+
+ \snippet examples/network/bearercloud/bearercloud.cpp 1
+
+ The configurationAdded() slot gets called when a new network configuration is added to the
+ system.
+
+ It stores the \l {QNetworkConfiguration::identifier()}{identifier} of the network
+ configuration in the \e {configStates} map, which is used to keep a count of the number of
+ network configurations in each state. This in turn is used to calculate the initial position
+ of new Cloud objects.
+
+ Next we create a new Cloud object for this network configuration. Set its initial position
+ and store it in the \e {configurations} hash.
+
+ The last step is to add it to the scene by calling QGraphicsScene::addItem().
+
+ \snippet examples/network/bearercloud/bearercloud.cpp 2
+
+ The configurationRemoved() slot gets called when a network configuration is removed from the
+ system.
+
+ First we remove all references to the network configuration from the \e {configStates} and
+ \e {configurations} member variables.
+
+ Next we initiate animation by setting a final scale value on the Cloud object associated with
+ the removed network configuration.
+
+ Finally we flag the Cloud object to delete itself after it has finished animating.
+
+ \snippet examples/network/bearercloud/bearercloud.cpp 3
+
+ The Cloud object will take care of most of the work required when a network configuration
+ changes. All we do in the configurationChanged() slot is update the \e {configStates} member
+ variable.
+
+ \snippet examples/network/bearercloud/bearercloud.cpp 4
+
+
+ \section1 Responding to changes
+
+ Each network session and associated network configuration known to the system is represented in
+ the scene as a Cloud object.
+
+ In the Cloud constructor we first initialize member variables. Then we create a new
+ QNetworkSession object bound to the network configuration. Next we connect the QNetworkSession
+ signals which we use to monitor it for state changes.
+
+ Next we set some QGraphicsItem properties. The QGraphicsItem::ItemIsMovable flag enables mouse
+ interaction with the Cloud object.
+
+ The Cloud object consists of an icon and a text caption, these are constructed here. We will
+ assign values to them later, as these will change as the sessions state changes.
+
+ Next we set the initial animation state and call our newConfigurationActivated() slot to finish
+ setting up the Cloud object based on the state of network session.
+
+ \snippet examples/network/bearercloud/cloud.cpp 0
+
+ The newConfigurationActivated() slot is called when a session has successfully roamed from one
+ access point to another.
+
+ The first thing we do is set the icon, inserting it into a shared SVG renderer cache if it is
+ not already available. Next we set the text caption to the name of the network configuration.
+
+ We then set the position of the icon and text caption so that they are centered horizontally.
+
+ Finally we call our stateChanged() slot.
+
+ \snippet examples/network/bearercloud/cloud.cpp 1
+
+ The stateChanged() slot is called when the session state changes.
+
+ In this slot we set lower the opacity of Cloud objects with network sessions that cannot be
+ \l {QNetworkSession::open()}{opened}, and set a detailed tool tip describing the sessions
+ state.
+
+ \snippet examples/network/bearercloud/cloud.cpp 2
+
+ In our reimplementation of the QGraphicsItem::mouseDoubleClickEvent() function we call
+ QNetworkSession::open() or QNetworkSession::close() to open or close the session in response
+ to a double left click.
+
+ \snippet examples/network/bearercloud/cloud.cpp 3
+
+ As we support the user dragging Cloud objects around we need to restart animations when the
+ position of the Cloud object changes. This is accomplished by reimplementing the
+ QGraphicsItem::itemChanged() function and calling the cloudMoved() function of the BearerCloud
+ object.
+
+ \snippet examples/network/bearercloud/cloud.cpp 4
+
+ The remainder of the code for the Cloud object implements the animations. The
+ calculateForces() function calculates the new position of the Cloud object based on the
+ position of all the other Cloud objects in the scene. The new position is set when the
+ advance() function is called to update the Cloud object for the current animation frame.
+*/
diff --git a/doc/src/examples/bearermonitor.qdoc b/doc/src/examples/bearermonitor.qdoc
new file mode 100644
index 0000000..592d1e5
--- /dev/null
+++ b/doc/src/examples/bearermonitor.qdoc
@@ -0,0 +1,49 @@
+/****************************************************************************
+**
+** 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 documentation 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$
+**
+****************************************************************************/
+
+/*!
+ \example network/bearermonitor
+ \title Bearer Monitor Example
+
+ The Bearer Monitor example shows how to use the Bearer Management API.
+
+ \image bearermonitor-example.png Screenshot of the Bearer Monitor example
+*/
diff --git a/doc/src/examples/qtscriptcustomclass.qdoc b/doc/src/examples/qtscriptcustomclass.qdoc
index f825ad9..028c7a6 100644
--- a/doc/src/examples/qtscriptcustomclass.qdoc
+++ b/doc/src/examples/qtscriptcustomclass.qdoc
@@ -120,6 +120,8 @@
this ByteArrayClass object, so that the constructor, when it is invoked, can extract the
pointer and use it to create a new \c{ByteArray} object.
+ \snippet examples/script/customclass/bytearrayclass.cpp 10
+
\snippet examples/script/customclass/bytearrayclass.cpp 1
The newInstance() function isn't part of the QScriptClass API; its purpose is to offer
@@ -128,6 +130,11 @@
QScriptEngine::newObject() will call the prototype() function of our class, ensuring that
the prototype of the new object will be the standard \c{ByteArray} prototype.
+ QScriptEngine::reportAdditionalMemoryCost() is called to inform the script engine of the
+ memory occupied by the QByteArray. This gives the garbage collector a hint that it should
+ perhaps trigger more frequently, possibly freeing up memory associated with large ByteArray
+ objects that are no longer in use.
+
\snippet examples/script/customclass/bytearrayclass.cpp 2
construct() is the native function that will act as a constructor for \c{ByteArray}
@@ -159,6 +166,12 @@
array index that was calculated in the queryProperty() function, enlarge the array if necessary,
and write the given value to the array.
+ \snippet examples/script/customclass/bytearrayclass.cpp 9
+
+ The resize() function is a helper function that resizes the QByteArray to a new size, and,
+ if the new size is greater than the old, reports the additional memory cost to the script
+ engine.
+
\snippet examples/script/customclass/bytearrayclass.cpp 6
The propertyFlags() reimplementation specifies that the \c{length} property can't be deleted,
diff --git a/doc/src/getting-started/examples.qdoc b/doc/src/getting-started/examples.qdoc
index bc6404c..885e96c 100644
--- a/doc/src/getting-started/examples.qdoc
+++ b/doc/src/getting-started/examples.qdoc
@@ -880,6 +880,8 @@
\o \l{network/threadedfortuneserver}{Threaded Fortune Server}\raisedaster
\o \l{network/torrent}{Torrent}
\o \l{network/googlesuggest}{Google Suggest}
+ \o \l{network/bearercloud}{Bearer Cloud}\raisedaster
+ \o \l{network/bearermonitor}{Bearer Monitor}
\endlist
Examples marked with an asterisk (*) are fully documented.
diff --git a/doc/src/images/bearercloud-example.png b/doc/src/images/bearercloud-example.png
new file mode 100644
index 0000000..aaf69df
--- /dev/null
+++ b/doc/src/images/bearercloud-example.png
Binary files differ
diff --git a/doc/src/images/bearermonitor-example.png b/doc/src/images/bearermonitor-example.png
new file mode 100644
index 0000000..1b8a9c3
--- /dev/null
+++ b/doc/src/images/bearermonitor-example.png
Binary files differ
diff --git a/doc/src/network-programming/bearermanagement.qdoc b/doc/src/network-programming/bearermanagement.qdoc
new file mode 100644
index 0000000..10d697a
--- /dev/null
+++ b/doc/src/network-programming/bearermanagement.qdoc
@@ -0,0 +1,286 @@
+/****************************************************************************
+**
+** 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 documentation 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$
+**
+****************************************************************************/
+
+/*!
+\page bearer-management.html
+
+\title Bearer Management
+\brief An API to control the system's connectivity state.
+
+\ingroup network
+
+Bearer Management controls the connectivity state of the system so that
+the user can start or stop interfaces or roam transparently between
+access points.
+
+\tableofcontents
+
+
+\section1 Overview
+
+The Bearer Management API controls the system's connectivity state. This
+incorporates simple information such as whether the device is online and
+how many interfaces there are as well as enables the application developer
+to start, stop network interfaces and influences other connection specific
+details. Depending on the platform's capabilities it may even provide
+session management so that a network interface remains up for as long as
+clients have a registered interest in them while at the same time
+optimizes the interface's uptime.
+
+This API does not provide support for management of network configurations
+themselves. It is up to the platform to provide infrastructure which
+enables to user to create, edit or delete network configurations.
+
+\section2 The API in Detail
+
+Computer systems manage their network interfaces via a set of configurations.
+Each configuration describes a set of parameters which instruct the system
+how a particular network interface is started. One of the most simplistic
+examples might be an Ethernet configuration that links a network card to a
+DHCP server. A more complex example might be a Wireless LAN configuration
+which may comprise of hardware details such as the WLAN card address,
+WLAN access point details (e.g ESSID, encryption details) and user specific
+information (for example username and password). Once the network interface
+was configured and started according to the configuration blue print,
+multiple applications are free to use this link layer connection/session
+for their own socket operations. Note that the QNetworkConfiguration object
+only provides limited information about the configuration details themselves.
+It's main purpose is to act as a configuration identifier through which link
+layer connections can be created, destroyed and monitored.
+
+QNetworkSession provides two types of use cases. It enables the monitoring of
+physical network interfaces and management of network sessions. Network sessions
+are a common feature on mobile devices where multiple applications
+can request network sessions as they see fit. The system consolidates and tracks
+active network sessions for the same network interface by maintaining the link
+layer connections until the last session has been closed. The subsequent table
+lists the major QNetworkSession functions and how they fit into the session and
+hardware management categories:
+
+\table 60%
+\header \o Interface management \o Session management
+\row \o QNetworkSession::stop() \o QNetworkSession::open()
+\row \o QNetworkSession::interface() \o QNetworkSession::close()
+\row \o QNetworkSession::state() \o QNetworkSession::isOpen()
+\row \o QNetworkSession::bytesWritten() \o QNetworkSession::migrate()
+\row \o QNetworkSession::bytesReceived() \o QNetworkSession::ignore()
+\row \o QNetworkSession::activeTime() \o QNetworkSession::accept()
+\row \o QNetworkSession::stateChanged() \o QNetworkSession::reject()
+\row \o \o QNetworkSession::opened()
+\row \o \o QNetworkSession::closed()
+\endtable
+
+The state of the session represents the state of the underlying access point
+whereas the session's openness implies the networking/connectivity state available
+to the current process.
+
+Possible use cases for interface management are network management related
+applications which intend to monitor the connectivity state but do not engage
+in network communication themselves. Any application wanting to open a socket
+to a remote address will typically use session management related functionality.
+
+\section3 Service networks
+
+Some mobile platforms use the concept of grouped access points (also
+called SNAP or Service Network Access Point). In principle multiple
+configurations are grouped together and possibly even prioritized when
+compared to each other. This is useful for use cases where all
+configurations serve a similar purpose or context. A common context could
+be that they provide access to the public Internet or possibly only to the
+office Intranet. By providing a pool of configurations the system can make
+a decision based on given priorities which usually map to factors such as
+speed, availability and cost. Furthermore the system can automatically
+roam from one access point to the next one while ensuring minimal impact on
+the user experience.
+
+The \l{QNetworkConfiguration::Type} flag specifies to what category a
+configuration belongs. The \l{QNetworkConfiguration::InternetAccessPoint}
+type is the most common example. It represents a configuration that can be
+used to create a session. The above mentioned grouping behavior is provided
+by \l {QNetworkConfiguration::ServiceNetwork} configurations. Service
+networks are place holders until such time when the user attempts to
+\l {QNetworkSession::open()}{open()} a new session. At that point in time
+the system determines which of the configurations \l{QNetworkConfiguration::children()}
+is best to use. The selection algorithm is provided by the platform and is usually managed
+by network settings applications. A service network can only have one level of indirection
+which implies children can only be of type \l {QNetworkConfiguration::InternetAccessPoint}.
+
+Most systems allow the user to define the systems default configuration.
+Usually the default behavior is either a service network, a particular
+Internet access point or the user instructs the platform to ask the user
+once an application requests the network. User interaction is generally
+implemented by some sort of system dialog which shows up at the appropriate
+point in time. The application does not have to handle the user input. This
+API provides the \l QNetworkConfigurationManager::defaultConfiguration()
+call which serves a similar purpose. The subsequent code snippet provides
+a quick way how an application can quickly create a new network session
+without (or only minimal) user interaction:
+
+\code
+ // Set Internet Access Point
+ QNetworkConfigurationManager manager;
+ const bool canStartIAP = (manager.capabilities()
+ & QNetworkConfigurationManager::CanStartAndStopInterfaces);
+ // Is there default access point, use it
+ QNetworkConfiguration cfg = manager.defaultConfiguration();
+ if (!cfg.isValid() || (!canStartIAP && cfg.state() != QNetworkConfiguration::Active)) {
+ QMessageBox::information(this, tr("Network"), tr(
+ "No Access Point found."));
+ return;
+ }
+
+ session = new QNetworkSession(cfg, this);
+ session->open();
+ session->waitForOpened(-1);
+\endcode
+
+To accommodate the "Ask user" use case the default configuration can be of
+type QNetworkConfiguration::UserChoice. A user choice configuration is
+resolved as part of the \l {QNetworkSession::open()} call. Note that a
+\l{QNetworkConfiguration::UserChoice}{UserChoice} configuration is only
+ever returned via \l {QNetworkConfigurationManager::defaultConfiguration()}
+and not \l QNetworkConfigurationManager::allConfigurations().
+
+On systems which do not maintain a list of
+\l {QNetworkConfigurationManager::defaultConfiguration()}{defaultConfiguration()}
+an invalid configuration is returned. A possible workaround could be to
+implement a custom dialog which is populated based on what
+\l QNetworkConfigurationManager::allConfigurations() returns.
+
+\section3 Managing network sessions
+
+A QNetworkSession object separates a \l {QNetworkSession::state()}{state()}
+and an \l{QNetworkSession::isOpen()}{isOpen()} condition.
+
+The state() attribute enables developers to detect whether the system
+currently maintains a global network session for the given
+QNetworkConfiguration. If \l {QNetworkSession::isOpen()}{isOpen()}
+returns true the QNetworkSession instance at hand was at least one of the
+entities requesting the global network session. This distinction is
+required to support the notion of session registrations. For as long as
+there are one or more open QNetworkSession instances the underlying
+network interface is not shut down. Therefore the session
+\l{QNetworkSession::state()}{state()} can be used to monitor the state of
+network interfaces.
+
+An open session is created by calling \l {QNetworkSession::open()} and
+closed via \l{QNetworkSession::close()}, respectively. If the session
+is \l{QNetworkSession::Disconnected}{disconnected} at the time of the
+\l{QNetworkSession::open()}{open()} call the underlying interface is started;
+otherwise only the reference counter against the global session is
+incremeted. The opposite behavior can be observed when using
+\l{QNetworkSession::close()}{close()}.
+
+In some use cases it may be necessary to turn the interface off despite of
+open sessions. This can be achieved by calling
+\l{QNetworkSession::stop()}{stop()}. An example use case could be a
+network manager type of application allowing the user to control the
+overall state of the devices connectivity.
+
+Global (inter-process) session support is platform dependent and can be
+detected via \l {QNetworkConfigurationManager::SystemSessionSupport}.
+If the system does not support global session calling
+\l{QNetworkSession::close()}{close()} never stops the interface.
+
+\section3 Roaming
+
+Roaming is the process of reconnecting a device from one network to another
+while minimizing the impact on the application. The system notifies the application
+about link layer changes so that the required preparation can be taken.
+The most common reaction would be to reinitialize sockets and to renegotiate
+stateful connections with other parties. In the most extreme cases applications
+may even prevent the roaming altogether.
+
+Roaming is initiated when the system determines that a more appropriate access point
+becomes available to the user. In general such a decision is based on cost, network speed
+or network type (access to certain private networks may only be provided via certain access points).
+Almost all devices providing roaming support have some form of global configuration application
+enabling the user to define such groups of access points (service networks) and priorities.
+
+This API supports two types of roaming. Application level roaming (ALR)
+provides the most control over the process. Applications will be notified about upcoming
+link layer changes and get the opportunity to test the new access point. Eventually they can
+reject or accept the link layer change. The second form of roaming is referred to as Forced Roaming.
+The system simply changes the link layer without consulting the application. It is up to
+the application to detect that some of its internal socket may have become invalid. As a consequence
+it has to reinitialize those sockets and reestablish the previous user session without
+any interruption. Forced roaming has the advantage that applications don't have to
+manage the entire roaming process by themselves.
+
+QNetworkSession is the central class for managing roaming related issues.
+
+\section3 Platform capabilities
+
+Some API features are not available on all platforms. The
+\l QNetworkConfigurationManager::Capability should be used to detect
+platform features at runtime. The following table lists the various
+platform APIs being used by this API. This may assist in the process of
+determining the feature support:
+
+\table
+ \header
+ \o Platform
+ \o Backend capabilities
+ \row
+ \o Linux\unicode{0xAE}
+ \o Linux uses the \l {http://projects.gnome.org/NetworkManager}{NetworkManager API} which supports interface notifications and starting and stopping of network interfaces.
+ \row
+ \o Windows\unicode{0xAE} XP
+ \o This platform supports interface notifications without active polling.
+ \row
+ \o Windows XP SP2+Hotfixes, Windows XP SP3, Windows Vista, Windows 7
+ \o In addition to standard Windows XP wifi access point monitoring has been improved which includes the ability to start and stop wifi interfaces. This requires Windows to manage the wifi interfaces.
+ \row
+ \o Symbian\unicode{0xAE} Platform & S60 3.1
+ \o Symbian support is based on Symbian platforms RConnection. In addition to interface notifications, starting and stopping of network it provides system wide session support and direct connection routing.
+ \row
+ \o Symbian Platform & S60 3.2+
+ \o This platform enjoys the most comprehensive feature set. In addition to the features support by the S60 3.1 Network roaming is supported.
+ \row
+ \o Mac OS\unicode{0xAE}
+ \o This platform has full support by way of CoreWLAN offered in Mac OS 10.6. Previous
+ versions of Mac OS - 10.5 and 10.4 have limited support.
+ \row
+ \o All other platforms (*nix, Windows Mobile)
+ \o This backend is the fallback for all platforms supports network interface notifications via active polling only.
+\endtable
+
+*/
diff --git a/doc/src/network-programming/qtnetwork.qdoc b/doc/src/network-programming/qtnetwork.qdoc
index d7e7481..36f48cf 100644
--- a/doc/src/network-programming/qtnetwork.qdoc
+++ b/doc/src/network-programming/qtnetwork.qdoc
@@ -53,11 +53,14 @@
\brief An Introduction to Network Programming with Qt
The QtNetwork module offers classes that allow you to write TCP/IP clients
- and servers. it offers classes such as QFtp that implement specific
+ and servers. It offers classes such as QFtp that implement specific
application-level protocols, lower-level classes such as QTcpSocket,
QTcpServer and QUdpSocket that represent low level network concepts,
and high level classes such as QNetworkRequest, QNetworkReply and
QNetworkAccessManager to perform network operations using common protocols.
+ It also offers classes such as QNetworkConfiguration,
+ QNetworkConfigurationManager and QNetworkSession that implement bearer
+ management.
\tableofcontents
@@ -327,4 +330,29 @@
by passing a factory to QNetworkProxyFactory::setApplicationProxyFactory()
and a custom proxying policy can be created by subclassing
QNetworkProxyFactory; see the class documentation for details.
+
+ \section1 Bearer Management Support
+
+ Bearer Management controls the connectivity state of the device such that
+ the application can start or stop network interfaces and roam
+ transparently between access points.
+
+ The QNetworkConfigurationManager class manages the list of network
+ configurations known to the device. A network configuration describes the
+ set of parameters used to start a network interface and is represented by
+ the QNetworkConfiguration class.
+
+ A network interface is started by openning a QNetworkSession based on a
+ given network configuration. In most situations creating a network session
+ based on the platform specified default network configuration is
+ appropriate. The default network configuration is returned by the
+ QNetworkConfigurationManager::defaultConfiguration() function.
+
+ On some platforms it is a platform requirement that the application open a
+ network session before any network operations can be performed. This can be
+ tested by the presents of the
+ QNetworkConfigurationManager::NetworkSessionRequired flag in the value
+ returned by the QNetworkConfigurationManager::capabilities() function.
+
+ \sa {Bearer Management}
*/
diff --git a/doc/src/snippets/code/src_gui_image_qicon.cpp b/doc/src/snippets/code/src_gui_image_qicon.cpp
index df1fa82..e0dcfa6 100644
--- a/doc/src/snippets/code/src_gui_image_qicon.cpp
+++ b/doc/src/snippets/code/src_gui_image_qicon.cpp
@@ -56,8 +56,8 @@ void MyWidget::drawIcon(QPainter *painter, QPoint pos)
QPixmap pixmap = icon.pixmap(QSize(22, 22),
isEnabled() ? QIcon::Normal
: QIcon::Disabled,
- isOn() ? QIcon::On
- : QIcon::Off);
+ isChecked() ? QIcon::On
+ : QIcon::Off);
painter->drawPixmap(pos, pixmap);
}
//! [2]
diff --git a/doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp b/doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp
index 5db6676..1853650 100644
--- a/doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp
+++ b/doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp
@@ -69,3 +69,12 @@ networkAccessManager->setConfiguration(manager.defaultConfiguration());
//! [3]
networkAccessManager->setConfiguration(QNetworkConfiguration());
//! [3]
+
+//! [4]
+networkAccessManager->setNetworkAccessible(QNetworkAccessManager::NotAccessible);
+//! [4]
+
+//! [5]
+networkAccessManager->setNetworkAccessible(QNetworkAccessManager::Accessible);
+//! [5]
+
diff --git a/doc/src/snippets/qelapsedtimer/main.cpp b/doc/src/snippets/qelapsedtimer/main.cpp
new file mode 100644
index 0000000..9d0421f
--- /dev/null
+++ b/doc/src/snippets/qelapsedtimer/main.cpp
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** 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 QtNetwork 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 <QtCore>
+
+void slowOperation1()
+{
+ static char buf[256];
+ for (int i = 0; i < (1<<20); ++i)
+ buf[i % sizeof buf] = i;
+}
+
+void slowOperation2(int) { slowOperation1(); }
+
+void startExample()
+{
+//![0]
+ QElapsedTimer timer;
+ timer.start();
+
+ slowOperation1();
+
+ qDebug() << "The slow operation took" << timer.elapsed() << "milliseconds";
+//![0]
+}
+
+//![1]
+void executeSlowOperations(int timeout)
+{
+ QElapsedTimer timer;
+ timer.start();
+ slowOperation1();
+
+ int remainingTime = timeout - timer.elapsed();
+ if (remainingTime > 0)
+ slowOperation2(remainingTime);
+}
+//![1]
+
+//![2]
+void executeOperationsForTime(int ms)
+{
+ QElapsedTimer timer;
+ timer.start();
+
+ while (!timer.hasExpired(ms))
+ slowOperation1();
+}
+//![2]
+
+int restartExample()
+{
+//![3]
+ QElapsedTimer timer;
+
+ int count = 1;
+ timer.start();
+ do {
+ count *= 2;
+ slowOperation2(count);
+ } while (timer.restart() < 250);
+
+ return count;
+//![3]
+}
+
+int main(int argc, char **argv)
+{
+ QCoreApplication app(argc, argv);
+
+ startExample();
+ restartExample();
+ executeSlowOperations(5);
+ executeOperationsForTime(5);
+}
diff --git a/doc/src/snippets/qelapsedtimer/qelapsedtimer.pro b/doc/src/snippets/qelapsedtimer/qelapsedtimer.pro
new file mode 100644
index 0000000..b0a8f66
--- /dev/null
+++ b/doc/src/snippets/qelapsedtimer/qelapsedtimer.pro
@@ -0,0 +1,2 @@
+SOURCES = main.cpp
+QT -= gui
diff --git a/doc/src/sql-programming/sql-driver.qdoc b/doc/src/sql-programming/sql-driver.qdoc
index e26472e..6bccd83 100644
--- a/doc/src/sql-programming/sql-driver.qdoc
+++ b/doc/src/sql-programming/sql-driver.qdoc
@@ -192,6 +192,73 @@
built in release mode only. If you are expecting a debug version
to be built as well, don't use the \c{"-o Makefile"} option.
+ \section3 How to build the MySQL driver for MinGW users
+
+ The following steps have been used successfully for WinXP SP3. In
+ this example, Qt 4.6.2 is shown.
+
+ \list
+
+ \o Download the following components:
+ \list
+ \o \c{MinGW-5.1.6.exe}
+ \o \c{mingw-utils-0.3.tar.gz}
+ \o Qt sources, e.g. \c{qt-everywhere-opensource-src-4.6.2.zip}
+ \o \c{mysql-5.1.35-win32.msi}
+ \endlist
+
+ \o Install \c{MinGW-5.1.6.exe} in, e.g. \c{C:\MinGW}.
+
+ \o Extract \c{mingw-utils-0.3.tar.gz} into, e.g. \c{C:\MinGW}.
+
+ \o Add the path for \c{MinGW-5.1.6.exe} to your \c{PATH} variable,
+ e.g. \c{C:\MinGW\bin;}
+
+ \o Extract the Qt sources, (\c{qt-everywhere-opensource-src-4.6.2.zip}),
+ into, e.g. \c{C:\Qt}.
+
+ \o Add the path for the eventual Qt binary to your \c{PATH} variable,
+ e.g. \c{C:\Qt\4.6.2\bin;}.
+
+ \o Install MySQL (\c{mysql-5.1.35-win32.msi}), customizing the
+ components. Select only the headers and libraries. Install in,
+ e.g. \c{C:\MySQL\MySQL51}.
+
+ \o Open the DOS prompt, go to \c{C:\MySQL\MySQL51\lib\opt}, and run
+ the following commands:
+ \list
+ \o \c{reimp -d libmysql.lib}
+ \o \c{dlltool -k -d libmysql.def -l libmysql.a}
+ \endlist
+
+ \o Open the DOS prompt, go to \c{C:\Qt\4.6.2} and run the following commands:
+ \list
+ \o \c{configure.exe -debug-and-release -platform win32-g++ -qt-sql-mysql
+ -l mysql -I C:\MySQL\MySQL51\include -L C:\MySQL\MySQL51\lib\opt}
+ \o \c{mingw32-make sub-src}
+ \endlist
+ This step takes a long time.
+
+ \o Open the DOS prompt, go to
+ \c{C:\Qt\4.6.2\src\plugins\sqldrivers\mysql} and run the
+ following command:
+ \list
+ \o \c{qmake "INCLUDEPATH+=C:\MySQL\MySQL51\include" "LIBS+=-L. mysql" mysql.pro}
+ \endlist
+
+ \o Now the following libraries are ready in \c{C:\Qt\4.6.2\plugins\sqldrivers}.
+ \list
+ \o \c{libqsqlmysql4.a}
+ \o \c{libqsqlmysqld4.a}
+ \o \c{qsqlmysql4.dll}
+ \o \c{qsqlmysqld4.dll}
+ \endlist
+ To use the SDK and QtCreator directly, copy these libraries to
+ your \c{C:\Qt\...\qt\plugins\sqldrivers\}, and copy
+ \c{C:\MySQL\MySQL51\lib\opt\libmysql.dll} to your \c{C:\Qt\...\qt\bin\}.
+
+ \endlist
+
\target QOCI
\section2 QOCI for the Oracle Call Interface (OCI)
generated by cgit v0.12 at 2024-11-12 10:22:01 (GMT)