Merge remote branch 'staging/master' into refactor
Conflicts: src/gui/painting/qdrawhelper_p.h src/gui/painting/qgraphicssystemfactory.cpp src/gui/painting/qpainter.cpp src/gui/painting/qunifiedtoolbarsurface_mac.cpp src/gui/painting/qunifiedtoolbarsurface_mac_p.h src/openvg/openvg.pro src/openvg/qpaintengine_vg.cpp src/openvg/qwindowsurface_vg.cpp src/openvg/qwindowsurface_vgegl.cpp src/plugins/platforms/wayland/qwaylanddisplay.cpp src/widgets/graphicsview/qgraphicsscene.cppbb10
Samuel Rødal
commit
5e2b0aa1b3
|
|
@ -238,11 +238,7 @@ if ($templatepkg =~ m/_installer\.pkg$/i && $onlyUnsigned) {
|
|||
my $unsigned_sis_name = $sisoutputbasename."_unsigned.sis";
|
||||
my $stub_sis_name = $sisoutputbasename.".sis";
|
||||
|
||||
# Store some utility variables
|
||||
my $scriptpath = dirname(__FILE__);
|
||||
my $certtext = $certificate;
|
||||
# certificates are one step up in hierarchy
|
||||
my $certpath = File::Spec->catdir($scriptpath, File::Spec->updir(), "src/s60installs/");
|
||||
|
||||
# Check some pre-conditions and print error messages if needed.
|
||||
unless (length($templatepkg)) {
|
||||
|
|
@ -265,6 +261,16 @@ if (length($certificate)) {
|
|||
}
|
||||
} else {
|
||||
#If no certificate is given, check default options
|
||||
my $scriptpath = dirname(__FILE__);
|
||||
my $certpath = File::Spec->catdir($scriptpath, File::Spec->updir(), "src/s60installs");
|
||||
|
||||
unless (-e $certpath) {
|
||||
my $qmakeCmd = File::Spec->catfile($scriptpath, "qmake");
|
||||
$certpath = `$qmakeCmd -query QT_INSTALL_PREFIX`;
|
||||
$certpath =~ s/\s+$//;
|
||||
$certpath = File::Spec->catdir($certpath, "src/s60installs");
|
||||
}
|
||||
|
||||
$certtext = "RnD";
|
||||
$certificate = File::Spec->catfile($certpath, "rd.cer");
|
||||
$key = File::Spec->catfile($certpath, "rd-key.pem");
|
||||
|
|
|
|||
|
|
@ -27,8 +27,8 @@ our $quoted_basedir;
|
|||
# normally the script location should be enough, if not fall back to
|
||||
# QTDIR environment variable. If that doesn't work, later ask the
|
||||
# user to use the -qtdir option explicitly.
|
||||
my $qtbasedir = dirname(dirname($0));
|
||||
$qtbasedir = $ENV{"QTDIR"} if ($qtbasedir !~ /qtbase/);
|
||||
my $qtbasedir = $ENV{"QTDIR"};
|
||||
$qtbasedir = dirname(dirname($0)) if (!$qtbasedir);
|
||||
$qtbasedir =~ s=\\=/=g if (defined $qtbasedir);
|
||||
|
||||
# will be defined based on the modules sync.profile
|
||||
|
|
@ -717,7 +717,7 @@ while ( @ARGV ) {
|
|||
die "Cannot automatically detect/use provided path to QtBase's build directory!\n" .
|
||||
"QTDIR detected/provided: " . (defined $qtbasedir ? $qtbasedir : "-none-") . "\n" .
|
||||
"Please -qtdir option to provide the correct path.\nsyncqt failed"
|
||||
if (!defined $qtbasedir || (!-e "$qtbasedir/.qmake.cache" && $qtbasedir !~ /qtbase/));
|
||||
if (!$qtbasedir || !-d "$qtbasedir/mkspecs");
|
||||
|
||||
# if we have no $basedir we cannot be sure which sources you want, so die
|
||||
die "Could not find any sync.profile for your module!\nPass <module directory> to syncqt to sync your header files.\nsyncqt failed" if (!$basedir);
|
||||
|
|
|
|||
|
|
@ -38,10 +38,12 @@ loc.prf /epoc32/tools/qt/mkspecs/features/loc.prf
|
|||
//For UDA image
|
||||
confml/qt.confml CONFML_EXPORT_PATH(qt.confml,uda_content)
|
||||
implml/qt_copy.implml CRML_EXPORT_PATH(qt_copy.implml,uda_content)
|
||||
content/apps/qt.sisx CRML_EXPORT_PATH(../content/sis/,uda_content)
|
||||
content/apps/qt_stub.sis /epoc32/data/z/system/install/qt_stub.sis
|
||||
qt.sisx CRML_EXPORT_PATH(../content/sis/,uda_content)
|
||||
#endif
|
||||
|
||||
/* export stub sis to enable eclipsing */
|
||||
qt_stub.sis /epoc32/data/z/system/install/qt_stub.sis
|
||||
|
||||
//tools
|
||||
../../bin/createpackage.bat /epoc32/tools/createpackage.bat
|
||||
../../bin/createpackage.pl /epoc32/tools/createpackage.pl
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
1
|
||||
|
|
@ -15,56 +15,3 @@
|
|||
; Unique Vendor name
|
||||
:"Nokia, Qt"
|
||||
|
||||
; Dependencies of Qt libraries
|
||||
|
||||
"" - "z:\sys\bin\QtCore.dll"
|
||||
"" - "z:\sys\bin\QtXml.dll"
|
||||
"" - "z:\sys\bin\QtGui.dll"
|
||||
"" - "z:\sys\bin\QtNetwork.dll"
|
||||
"" - "z:\sys\bin\QtTest.dll"
|
||||
"" - "z:\sys\bin\QtSql.dll"
|
||||
"" - "z:\sys\bin\QtSvg.dll"
|
||||
"" - "z:\sys\bin\phonon.dll"
|
||||
"" - "z:\sys\bin\QtScript.dll"
|
||||
"" - "z:\sys\bin\QtXmlPatterns.dll"
|
||||
"" - "z:\sys\bin\QtDeclarative.dll"
|
||||
"" - "z:\sys\bin\QtOpenVG.dll"
|
||||
"" - "z:\sys\bin\QtOpenGL.dll"
|
||||
"" - "z:\sys\bin\QtMultimedia.dll"
|
||||
"" - "z:\private\10202D56\import\packages\2001E61C\backup_registration.xml"
|
||||
"" - "z:\sys\bin\qjpeg.dll"
|
||||
"" - "z:\resource\qt\plugins\imageformats\qjpeg.qtplugin"
|
||||
"" - "z:\sys\bin\qgif.dll"
|
||||
"" - "z:\resource\qt\plugins\imageformats\qgif.qtplugin"
|
||||
"" - "z:\sys\bin\qmng.dll"
|
||||
"" - "z:\resource\qt\plugins\imageformats\qmng.qtplugin"
|
||||
"" - "z:\sys\bin\qtiff.dll"
|
||||
"" - "z:\resource\qt\plugins\imageformats\qtiff.qtplugin"
|
||||
"" - "z:\sys\bin\qico.dll"
|
||||
"" - "z:\resource\qt\plugins\imageformats\qico.qtplugin"
|
||||
"" - "z:\sys\bin\qsvg.dll"
|
||||
"" - "z:\resource\qt\plugins\imageformats\qsvg.qtplugin"
|
||||
"" - "z:\sys\bin\qcncodecs.dll"
|
||||
"" - "z:\resource\qt\plugins\codecs\qcncodecs.qtplugin"
|
||||
"" - "z:\sys\bin\qjpcodecs.dll"
|
||||
"" - "z:\resource\qt\plugins\codecs\qjpcodecs.qtplugin"
|
||||
"" - "z:\sys\bin\qtwcodecs.dll"
|
||||
"" - "z:\resource\qt\plugins\codecs\qtwcodecs.qtplugin"
|
||||
"" - "z:\sys\bin\qkrcodecs.dll"
|
||||
"" - "z:\resource\qt\plugins\codecs\qkrcodecs.qtplugin"
|
||||
"" - "z:\sys\bin\qvggraphicssystem.dll"
|
||||
"" - "z:\resource\qt\plugins\graphicssystems\qvggraphicssystem.qtplugin"
|
||||
"" - "z:\sys\bin\qglgraphicssystem.dll"
|
||||
"" - "z:\resource\qt\plugins\graphicssystems\qglgraphicssystem.qtplugin"
|
||||
"" - "z:\sys\bin\qsvgicon.dll"
|
||||
"" - "z:\resource\qt\plugins\iconengines\qsvgicon.qtplugin"
|
||||
"" - "z:\sys\bin\qmlfolderlistmodelplugin.dll"
|
||||
"" - "z:\resource\qt\imports\Qt\labs\folderlistmodel\qmlfolderlistmodelplugin.qtplugin"
|
||||
"" - "z:\resource\qt\imports\Qt\labs\folderlistmodel\qmldir"
|
||||
"" - "z:\sys\bin\qmlgesturesplugin.dll"
|
||||
"" - "z:\resource\qt\imports\Qt\labs\gestures\qmlgesturesplugin.qtplugin"
|
||||
"" - "z:\resource\qt\imports\Qt\labs\gestures\qmldir"
|
||||
"" - "z:\sys\bin\qmlparticlesplugin.dll"
|
||||
"" - "z:\resource\qt\imports\Qt\labs\particles\qmlparticlesplugin.qtplugin"
|
||||
"" - "z:\resource\qt\imports\Qt\labs\particles\qmldir"
|
||||
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -699,7 +699,7 @@ CFG_FONTCONFIG=auto
|
|||
CFG_QWS_FREETYPE=auto
|
||||
CFG_LIBFREETYPE=auto
|
||||
CFG_SQL_AVAILABLE=
|
||||
QT_DEFAULT_BUILD_PARTS="libs examples demos"
|
||||
QT_DEFAULT_BUILD_PARTS="libs examples demos tests"
|
||||
CFG_BUILD_PARTS=""
|
||||
CFG_NOBUILD_PARTS=""
|
||||
CFG_RELEASE_QMAKE=no
|
||||
|
|
@ -712,6 +712,7 @@ CFG_DECLARATIVE=auto
|
|||
CFG_DECLARATIVE_DEBUG=yes
|
||||
CFG_WEBKIT=auto # (yes|no|auto|debug)
|
||||
CFG_JAVASCRIPTCORE_JIT=auto
|
||||
CFG_LOCATION=auto
|
||||
|
||||
CFG_GFX_AVAILABLE="linuxfb transformed qvfb vnc multiscreen directfb"
|
||||
CFG_GFX_ON="linuxfb multiscreen"
|
||||
|
|
@ -2145,6 +2146,17 @@ while [ "$#" -gt 0 ]; do
|
|||
[ "$VAL" = "auto" ] && VAL="yes"
|
||||
CFG_WEBKIT="$VAL"
|
||||
;;
|
||||
location)
|
||||
if [ "$VAL" = "yes" ]; then
|
||||
CFG_LOCATION="yes"
|
||||
else
|
||||
if [ "$VAL" = "no" ]; then
|
||||
CFG_LOCATION="no"
|
||||
else
|
||||
UNKNOWN_OPT=yes
|
||||
fi
|
||||
fi
|
||||
;;
|
||||
javascript-jit)
|
||||
if [ "$VAL" = "yes" ] || [ "$VAL" = "auto" ] || [ "$VAL" = "no" ]; then
|
||||
CFG_JAVASCRIPTCORE_JIT="$VAL"
|
||||
|
|
@ -3726,6 +3738,7 @@ Usage: $relconf [-h] [-prefix <dir>] [-prefix-install] [-bindir <dir>] [-libdir
|
|||
[-no-javascript-jit] [-javascript-jit]
|
||||
[-no-script] [-script] [-no-scripttools] [-scripttools]
|
||||
[-no-declarative] [-declarative] [-no-declarative-debug] [-declarative-debug]
|
||||
[-no-location] [-location]
|
||||
[additional platform specific options (see below)]
|
||||
|
||||
|
||||
|
|
@ -3897,6 +3910,9 @@ fi
|
|||
-no-declarative-debug ..... Do not build the declarative debugging support.
|
||||
+ -declarative-debug ....... Build the declarative debugging support.
|
||||
|
||||
-no-location ....... Do not build the QtLocation module.
|
||||
+ -location .......... Build the QtLocation module.
|
||||
|
||||
-platform target ... The operating system and compiler you are building
|
||||
on ($PLATFORM).
|
||||
|
||||
|
|
@ -7659,6 +7675,22 @@ else
|
|||
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_DECLARATIVE"
|
||||
fi
|
||||
|
||||
if [ "$CFG_LOCATION" = "auto" ]; then
|
||||
CFG_LOCATION="$CFG_GUI"
|
||||
fi
|
||||
|
||||
if [ "$CFG_LOCATION" = "yes" ] && [ "$CFG_GUI" = "no" ]; then
|
||||
echo "QtLocation requested, but it can't be built without QtGui"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
#Disable QtLocation until ready
|
||||
CFG_LOCATION="no"
|
||||
|
||||
if [ "$CFG_LOCATION" = "no" ]; then
|
||||
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_LOCATION"
|
||||
fi
|
||||
|
||||
if [ "$CFG_EXCEPTIONS" = "no" ]; then
|
||||
case "$COMPILER" in
|
||||
g++*)
|
||||
|
|
@ -8679,6 +8711,7 @@ echo "Declarative module ..... $CFG_DECLARATIVE"
|
|||
if [ "$CFG_DECLARATIVE" = "yes" ]; then
|
||||
echo "Declarative debugging ...$CFG_DECLARATIVE_DEBUG"
|
||||
fi
|
||||
echo "Location module ........ $CFG_LOCATION"
|
||||
echo "Support for S60 ........ $CFG_S60"
|
||||
echo "Symbian DEF files ...... $CFG_SYMBIAN_DEFFILES"
|
||||
echo "STL support ............ $CFG_STL"
|
||||
|
|
|
|||
|
|
@ -97,9 +97,17 @@ Qt for Windows CE
|
|||
|
||||
- Assistant
|
||||
|
||||
|
||||
- Designer
|
||||
|
||||
* [QTBUG-18631] Enabled the use of promoted QWidgets in the buddy editor.
|
||||
* [QTBUG-18120] Fixed saving of the Z-order.
|
||||
* [QTBUG-13683] Fixed saving of QGridLayout and QFormLayout
|
||||
by QFormBuilder.
|
||||
* [QTBUG-10890] Added a filter to the rich text editor dialog.
|
||||
that simplifies the HTML markup generated.
|
||||
* [QTBUG-7777] Added support for QIcon::fromTheme.
|
||||
* [QTBUG-7169] Fixed QtUiTools to be built with the correct
|
||||
lib-infix.
|
||||
* [QTBUG-3120] Added support for alignment of box layout items.
|
||||
|
||||
- Linguist
|
||||
- Linguist GUI
|
||||
|
|
|
|||
|
|
@ -86,38 +86,3 @@ beginMoveRows(parent, 2, 2, parent, 0);
|
|||
//! [9]
|
||||
beginMoveRows(parent, 2, 2, parent, 4);
|
||||
//! [9]
|
||||
|
||||
|
||||
//! [10]
|
||||
class CustomDataProxy : public QSortFilterProxyModel
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
CustomDataProxy(QObject *parent)
|
||||
: QSortFilterProxyModel(parent)
|
||||
{
|
||||
}
|
||||
|
||||
...
|
||||
|
||||
QVariant data(const QModelIndex &index, int role)
|
||||
{
|
||||
if (role != Qt::BackgroundRole)
|
||||
return QSortFilterProxyModel::data(index, role);
|
||||
|
||||
if (m_customData.contains(index.row()))
|
||||
return m_customData.value(index.row());
|
||||
return QSortFilterProxyModel::data(index, role);
|
||||
}
|
||||
|
||||
private slots:
|
||||
void resetInternalData()
|
||||
{
|
||||
m_customData.clear();
|
||||
}
|
||||
|
||||
private:
|
||||
QHash<int, QVariant> m_customData;
|
||||
};
|
||||
//! [10]
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
// This is an auto-generated lite registration file
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
!isEmpty(MODULE_PRI) {
|
||||
pritarget.path = $$[QT_INSTALL_DATA]/mkspecs/modules
|
||||
pritarget.files = $$MODULE_PRI
|
||||
INSTALLS = pritarget
|
||||
INSTALLS += pritarget
|
||||
} else {
|
||||
warning("Project $$basename(_PRO_FILE_) is a module, but has not defined MODULE_PRI, which is required for Qt to expose the module to other projects")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,7 +26,11 @@ equals(GENERATE_SIS_TARGETS, true) {
|
|||
|
||||
qtPrepareTool(QMAKE_CREATEPACKAGE, createpackage)
|
||||
|
||||
CREATEPACKAGE_DIR = $$OBJECTS_DIR/createpackage_tmp
|
||||
sis_objects_dir = $$OBJECTS_DIR
|
||||
isEmpty(sis_objects_dir):sis_objects_dir = .
|
||||
|
||||
CREATEPACKAGE_DIR = $$sis_objects_dir/createpackage_tmp
|
||||
|
||||
QMAKE_CLEAN += $$CREATEPACKAGE_DIR/*
|
||||
|
||||
symbian-abld|symbian-sbsv2 {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,32 @@
|
|||
contains(TEMPLATE, ".*app") {
|
||||
baseTarget = $$symbianRemoveSpecialCharacters($$basename(TARGET))
|
||||
|
||||
symbian-abld|symbian-sbsv2 {
|
||||
LITE_REG_TARGET = $$_PRO_FILE_PWD_
|
||||
} else {
|
||||
contains(DESTDIR, "/.*") {
|
||||
LITE_REG_TARGET = $$DESTDIR
|
||||
} else:isEmpty(DESTDIR) {
|
||||
LITE_REG_TARGET = $$OUT_PWD
|
||||
} else {
|
||||
LITE_REG_TARGET = $$OUT_PWD/$$DESTDIR
|
||||
}
|
||||
}
|
||||
|
||||
LITE_REG_TARGET = $${LITE_REG_TARGET}/$${baseTarget}.applite
|
||||
LITE_REG_TEMPLATE = $$[QT_INSTALL_DATA]/mkspecs/common/symbian/template.applite
|
||||
|
||||
lite_reg_copy.input = LITE_REG_TEMPLATE
|
||||
lite_reg_copy.output = $$LITE_REG_TARGET
|
||||
lite_reg_copy.variable_out = PRE_TARGETDEPS
|
||||
lite_reg_copy.commands = $$QMAKE_COPY ${QMAKE_FILE_IN} ${QMAKE_FILE_OUT}
|
||||
lite_reg_copy.CONFIG += no_link
|
||||
QMAKE_EXTRA_COMPILERS += lite_reg_copy
|
||||
|
||||
isEmpty(LITE_IMPORT_DIR): LITE_IMPORT_DIR = /private/20034884/import/apps
|
||||
lite_deployment.sources += $$LITE_REG_TARGET
|
||||
lite_deployment.path = $$LITE_IMPORT_DIR
|
||||
DEPLOYMENT += lite_deployment
|
||||
|
||||
LIBS += -lqDeclarativeBooster.dll
|
||||
}
|
||||
|
|
@ -1,90 +1,74 @@
|
|||
#
|
||||
# qmake configuration for hurd-g++
|
||||
#
|
||||
# Submitted by uch@nop.or.jp as "gnu-g++".
|
||||
# Renamed to "hurd-g++" because people were confusing GNU/Hurd with GNU/Linux.
|
||||
#
|
||||
|
||||
MAKEFILE_GENERATOR = UNIX
|
||||
TARGET_PLATFORM = unix
|
||||
TEMPLATE = app
|
||||
CONFIG += qt warn_on release incremental link_prl gdb_dwarf_index
|
||||
QT += core gui
|
||||
CONFIG += qt warn_on release link_prl
|
||||
QMAKE_INCREMENTAL_STYLE = sublib
|
||||
|
||||
QMAKE_CC = gcc
|
||||
QMAKE_LEX = flex
|
||||
QMAKE_LEXFLAGS =
|
||||
QMAKE_YACC = yacc
|
||||
QMAKE_YACCFLAGS = -d
|
||||
QMAKE_CFLAGS = -pipe
|
||||
QMAKE_CFLAGS_DEPS = -M
|
||||
QMAKE_CFLAGS_WARN_ON = -Wall -W
|
||||
QMAKE_CFLAGS_WARN_OFF = -w
|
||||
QMAKE_CFLAGS_RELEASE = -O2
|
||||
QMAKE_CFLAGS_DEBUG = -g
|
||||
QMAKE_CFLAGS_SHLIB = -fPIC
|
||||
QMAKE_CFLAGS_STATIC_LIB = $$QMAKE_CFLAGS_SHLIB
|
||||
QMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses
|
||||
QMAKE_CFLAGS_THREAD = -D_REENTRANT
|
||||
QMAKE_CFLAGS_THREAD += -D_REENTRANT
|
||||
QMAKE_CXXFLAGS_THREAD += $$QMAKE_CFLAGS_THREAD
|
||||
|
||||
QMAKE_CXX = g++
|
||||
QMAKE_CXXFLAGS = $$QMAKE_CFLAGS
|
||||
QMAKE_CXXFLAGS_DEPS = $$QMAKE_CFLAGS_DEPS
|
||||
QMAKE_CXXFLAGS_WARN_ON = $$QMAKE_CFLAGS_WARN_ON
|
||||
QMAKE_CXXFLAGS_WARN_OFF = $$QMAKE_CFLAGS_WARN_OFF
|
||||
QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE
|
||||
QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG
|
||||
QMAKE_CXXFLAGS_SHLIB = $$QMAKE_CFLAGS_SHLIB
|
||||
QMAKE_CXXFLAGS_STATIC_LIB = $$QMAKE_CFLAGS_STATIC_LIB
|
||||
QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC
|
||||
QMAKE_CXXFLAGS_THREAD = $$QMAKE_CXXFLAGS_THREAD
|
||||
QMAKE_INCDIR =
|
||||
QMAKE_LIBDIR =
|
||||
QMAKE_INCDIR_X11 = /usr/X11R6/include
|
||||
QMAKE_LIBDIR_X11 = /usr/X11R6/lib
|
||||
QMAKE_INCDIR_QT = $$[QT_INSTALL_HEADERS]
|
||||
QMAKE_LIBDIR_QT = $$[QT_INSTALL_LIBS]
|
||||
QMAKE_INCDIR_OPENGL = /usr/X11R6/include
|
||||
QMAKE_LIBDIR_OPENGL = /usr/X11R6/lib
|
||||
QMAKE_INCDIR_OPENGL_ES1 = $$QMAKE_INCDIR_OPENGL
|
||||
QMAKE_LIBDIR_OPENGL_ES1 = $$QMAKE_LIBDIR_OPENGL
|
||||
QMAKE_INCDIR_OPENGL_ES2 = $$QMAKE_INCDIR_OPENGL
|
||||
QMAKE_LIBDIR_OPENGL_ES2 = $$QMAKE_LIBDIR_OPENGL
|
||||
QMAKE_INCDIR_EGL =
|
||||
QMAKE_LIBDIR_EGL =
|
||||
QMAKE_INCDIR_OPENVG =
|
||||
QMAKE_LIBDIR_OPENVG =
|
||||
|
||||
QMAKE_INCDIR =
|
||||
QMAKE_LIBDIR =
|
||||
QMAKE_INCDIR_X11 = /usr/X11R6/include
|
||||
QMAKE_LIBDIR_X11 = /usr/X11R6/lib
|
||||
QMAKE_INCDIR_QT = $$[QT_INSTALL_HEADERS]
|
||||
QMAKE_LIBDIR_QT = $$[QT_INSTALL_LIBS]
|
||||
QMAKE_INCDIR_OPENGL = /usr/X11R6/include
|
||||
QMAKE_LIBDIR_OPENGL = /usr/X11R6/lib
|
||||
QMAKE_LIBS =
|
||||
QMAKE_LIBS_DYNLOAD = -ldl
|
||||
QMAKE_LIBS_X11 = -lXext -lX11 -lm
|
||||
QMAKE_LIBS_X11SM = -lSM -lICE
|
||||
QMAKE_LIBS_NIS = -lnsl
|
||||
QMAKE_LIBS_EGL = -lEGL
|
||||
QMAKE_LIBS_OPENGL = -lGL
|
||||
QMAKE_LIBS_OPENGL_QT = -lGL
|
||||
QMAKE_LIBS_OPENGL_ES1 = -lGLES_CM
|
||||
QMAKE_LIBS_OPENGL_ES2 = -lGLESv2
|
||||
QMAKE_LIBS_OPENVG = -lOpenVG
|
||||
QMAKE_LIBS_THREAD = -lpthread
|
||||
|
||||
QMAKE_LINK = g++
|
||||
QMAKE_LINK_SHLIB = g++
|
||||
QMAKE_LINK_C = gcc
|
||||
QMAKE_LINK_C_SHLIB = gcc
|
||||
QMAKE_LFLAGS = -Wl,-rpath=/lib:/usr/X11R6/lib:$$[QT_INSTALL_LIBS]
|
||||
QMAKE_LFLAGS_RELEASE =
|
||||
QMAKE_LFLAGS_DEBUG =
|
||||
QMAKE_LFLAGS_SHLIB = -shared
|
||||
QMAKE_LFLAGS_PLUGIN = $$QMAKE_LFLAGS_SHLIB
|
||||
QMAKE_LFLAGS_SONAME = -Wl,-soname,
|
||||
QMAKE_MOC = $$[QT_INSTALL_BINS]/moc
|
||||
QMAKE_UIC = $$[QT_INSTALL_BINS]/uic
|
||||
|
||||
QMAKE_LIBS = -lpthread # This is tricky but needed
|
||||
QMAKE_LIBS_DYNLOAD = -ldl
|
||||
QMAKE_LIBS_X11 = -lXext -lX11 -lm
|
||||
QMAKE_LIBS_X11SM = -lSM -lICE
|
||||
QMAKE_LIBS_NIS = -lnsl
|
||||
QMAKE_LIBS_QT_THREAD = -lqt-mt
|
||||
QMAKE_LIBS_THREAD =
|
||||
QMAKE_AR = ar cqs
|
||||
QMAKE_OBJCOPY = objcopy
|
||||
QMAKE_RANLIB =
|
||||
|
||||
QMAKE_LIBS_OPENGL = -lGL
|
||||
QMAKE_LIBS_OPENGL_QT = -lGL
|
||||
QMAKE_TAR = tar -cf
|
||||
QMAKE_GZIP = gzip -9f
|
||||
|
||||
QMAKE_MOC = $$[QT_INSTALL_BINS]/moc
|
||||
QMAKE_UIC = $$[QT_INSTALL_BINS]/uic
|
||||
QMAKE_COPY = cp -f
|
||||
QMAKE_COPY_FILE = $(COPY)
|
||||
QMAKE_COPY_DIR = $(COPY) -r
|
||||
QMAKE_MOVE = mv -f
|
||||
QMAKE_DEL_FILE = rm -f
|
||||
QMAKE_DEL_DIR = rmdir
|
||||
QMAKE_STRIP = strip
|
||||
QMAKE_STRIPFLAGS_LIB += --strip-unneeded
|
||||
QMAKE_CHK_DIR_EXISTS = test -d
|
||||
QMAKE_MKDIR = mkdir -p
|
||||
QMAKE_INSTALL_FILE = install -m 644 -p
|
||||
QMAKE_INSTALL_PROGRAM = install -m 755 -p
|
||||
|
||||
QMAKE_AR = ar cqs
|
||||
QMAKE_OBJCOPY = objcopy
|
||||
QMAKE_RANLIB =
|
||||
|
||||
QMAKE_TAR = tar -cf
|
||||
QMAKE_GZIP = gzip -9f
|
||||
|
||||
QMAKE_COPY = cp -f
|
||||
QMAKE_MOVE = mv -f
|
||||
QMAKE_DEL_FILE = rm -f
|
||||
QMAKE_DEL_DIR = rmdir
|
||||
QMAKE_CHK_DIR_EXISTS = test -d
|
||||
QMAKE_MKDIR = mkdir -p
|
||||
include(../common/unix.conf)
|
||||
include(../common/gcc-base-unix.conf)
|
||||
include(../common/g++-unix.conf)
|
||||
load(qt_config)
|
||||
|
||||
# This is tricky but needed
|
||||
QMAKE_LIBS += $$QMAKE_LIBS_THREAD
|
||||
|
|
|
|||
|
|
@ -2527,7 +2527,7 @@ MakefileGenerator::writeSubTargets(QTextStream &t, QList<MakefileGenerator::SubT
|
|||
t << " " << targets.at(target-1)->target << "-" << targetSuffixes.at(suffix) << "-ordered ";
|
||||
if(project->isEmpty("QMAKE_NOFORCE"))
|
||||
t << " FORCE";
|
||||
writeSubMakeCall(t, out_directory_cdin, makefilein, out_directory_cdout);
|
||||
writeSubMakeCall(t, out_directory_cdin, makefilein + " " + s, out_directory_cdout);
|
||||
}
|
||||
t << subtarget->target << "-" << targetSuffixes.at(suffix) << ": " << mkfile;
|
||||
if(!subtarget->depends.isEmpty())
|
||||
|
|
@ -2535,7 +2535,7 @@ MakefileGenerator::writeSubTargets(QTextStream &t, QList<MakefileGenerator::SubT
|
|||
"-"+targetSuffixes.at(suffix));
|
||||
if(project->isEmpty("QMAKE_NOFORCE"))
|
||||
t << " FORCE";
|
||||
writeSubMakeCall(t, out_directory_cdin, makefilein, out_directory_cdout);
|
||||
writeSubMakeCall(t, out_directory_cdin, makefilein + " " + s, out_directory_cdout);
|
||||
}
|
||||
}
|
||||
t << endl;
|
||||
|
|
|
|||
|
|
@ -96,7 +96,8 @@ UnixMakefileGenerator::writeMakefile(QTextStream &t)
|
|||
}
|
||||
|
||||
if (project->values("TEMPLATE").first() == "app" ||
|
||||
project->values("TEMPLATE").first() == "lib") {
|
||||
project->values("TEMPLATE").first() == "lib" ||
|
||||
project->values("TEMPLATE").first() == "aux") {
|
||||
if(Option::mkfile::do_stub_makefile && MakefileGenerator::writeStubMakefile(t))
|
||||
return true;
|
||||
writeMakeParts(t);
|
||||
|
|
@ -1017,6 +1018,9 @@ void UnixMakefileGenerator::init2()
|
|||
if(project->isEmpty("QMAKE_FRAMEWORK_VERSION"))
|
||||
project->values("QMAKE_FRAMEWORK_VERSION").append(project->values("VER_MAJ").first());
|
||||
|
||||
if (project->values("TEMPLATE").first() == "aux")
|
||||
return;
|
||||
|
||||
if (!project->values("QMAKE_APP_FLAG").isEmpty()) {
|
||||
if(!project->isEmpty("QMAKE_BUNDLE")) {
|
||||
QString bundle_loc = project->first("QMAKE_BUNDLE_LOCATION");
|
||||
|
|
|
|||
|
|
@ -68,7 +68,8 @@ BorlandMakefileGenerator::writeMakefile(QTextStream &t)
|
|||
}
|
||||
|
||||
if(project->first("TEMPLATE") == "app" ||
|
||||
project->first("TEMPLATE") == "lib") {
|
||||
project->first("TEMPLATE") == "lib" ||
|
||||
project->first("TEMPLATE") == "aux") {
|
||||
writeBorlandParts(t);
|
||||
return MakefileGenerator::writeMakefile(t);
|
||||
}
|
||||
|
|
@ -136,6 +137,11 @@ BorlandMakefileGenerator::init()
|
|||
|
||||
void BorlandMakefileGenerator::writeBuildRulesPart(QTextStream &t)
|
||||
{
|
||||
if (project->first("TEMPLATE") == "aux") {
|
||||
t << "first:" << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
t << "first: all" << endl;
|
||||
t << "all: " << fileFixify(Option::output.fileName()) << " " << varGlue("ALL_DEPS"," "," "," ") << " $(DESTDIR_TARGET)" << endl << endl;
|
||||
t << "$(DESTDIR_TARGET): " << var("PRE_TARGETDEPS") << " $(OBJECTS) " << var("POST_TARGETDEPS");
|
||||
|
|
|
|||
|
|
@ -141,7 +141,8 @@ bool MingwMakefileGenerator::writeMakefile(QTextStream &t)
|
|||
}
|
||||
|
||||
if(project->first("TEMPLATE") == "app" ||
|
||||
project->first("TEMPLATE") == "lib") {
|
||||
project->first("TEMPLATE") == "lib" ||
|
||||
project->first("TEMPLATE") == "aux") {
|
||||
if(project->isActiveConfig("create_pc") && project->first("TEMPLATE") == "lib")
|
||||
writePkgConfigFile();
|
||||
|
||||
|
|
@ -436,6 +437,11 @@ void MingwMakefileGenerator::writeObjectsPart(QTextStream &t)
|
|||
|
||||
void MingwMakefileGenerator::writeBuildRulesPart(QTextStream &t)
|
||||
{
|
||||
if (project->first("TEMPLATE") == "aux") {
|
||||
t << "first:" << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
t << "first: all" << endl;
|
||||
t << "all: " << escapeDependencyPath(fileFixify(Option::output.fileName())) << " " << valGlue(escapeDependencyPaths(project->values("ALL_DEPS"))," "," "," ") << " $(DESTDIR_TARGET)" << endl << endl;
|
||||
t << "$(DESTDIR_TARGET): " << var("PRE_TARGETDEPS") << " $(OBJECTS) " << var("POST_TARGETDEPS");
|
||||
|
|
|
|||
|
|
@ -70,7 +70,8 @@ NmakeMakefileGenerator::writeMakefile(QTextStream &t)
|
|||
}
|
||||
|
||||
if(project->first("TEMPLATE") == "app" ||
|
||||
project->first("TEMPLATE") == "lib") {
|
||||
project->first("TEMPLATE") == "lib" ||
|
||||
project->first("TEMPLATE") == "aux") {
|
||||
#if 0
|
||||
if(Option::mkfile::do_stub_makefile)
|
||||
return MakefileGenerator::writeStubMakefile(t);
|
||||
|
|
@ -341,6 +342,11 @@ void NmakeMakefileGenerator::writeImplicitRulesPart(QTextStream &t)
|
|||
|
||||
void NmakeMakefileGenerator::writeBuildRulesPart(QTextStream &t)
|
||||
{
|
||||
if (project->first("TEMPLATE") == "aux") {
|
||||
t << "first:" << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
t << "first: all" << endl;
|
||||
t << "all: " << fileFixify(Option::output.fileName()) << " " << varGlue("ALL_DEPS"," "," "," ") << "$(DESTDIR_TARGET)" << endl << endl;
|
||||
t << "$(DESTDIR_TARGET): " << var("PRE_TARGETDEPS") << " $(OBJECTS) " << var("POST_TARGETDEPS");
|
||||
|
|
|
|||
|
|
@ -208,6 +208,7 @@ const char _slnExtSections[] = "\n\tGlobalSection(ExtensibilityGlobals) = pos
|
|||
VcprojGenerator::VcprojGenerator()
|
||||
: Win32MakefileGenerator(),
|
||||
init_flag(false),
|
||||
is64Bit(false),
|
||||
projectWriter(0)
|
||||
{
|
||||
}
|
||||
|
|
@ -597,14 +598,16 @@ nextfile:
|
|||
}
|
||||
}
|
||||
t << _slnGlobalBeg;
|
||||
|
||||
QString slnConf = _slnSolutionConf;
|
||||
if (!project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH")) {
|
||||
QString slnConfCE = _slnSolutionConf;
|
||||
QString platform = QString("|") + project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";
|
||||
slnConfCE.replace(QString("|Win32"), platform);
|
||||
t << slnConfCE;
|
||||
} else {
|
||||
t << _slnSolutionConf;
|
||||
QString slnPlatform = QString("|") + project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";
|
||||
slnConf.replace(QString("|Win32"), slnPlatform);
|
||||
} else if (is64Bit) {
|
||||
slnConf.replace(QString("|Win32"), "|x64");
|
||||
}
|
||||
t << slnConf;
|
||||
|
||||
t << _slnProjDepBeg;
|
||||
|
||||
// Restore previous after_user_var options
|
||||
|
|
@ -621,7 +624,7 @@ nextfile:
|
|||
t << _slnProjDepEnd;
|
||||
t << _slnProjConfBeg;
|
||||
for(QList<VcsolutionDepend*>::Iterator it = solution_cleanup.begin(); it != solution_cleanup.end(); ++it) {
|
||||
QString platform = "Win32";
|
||||
QString platform = is64Bit ? "x64" : "Win32";
|
||||
if (!project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH"))
|
||||
platform = project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";
|
||||
t << "\n\t\t" << (*it)->uuid << QString(_slnProjDbgConfTag1).arg(platform) << platform;
|
||||
|
|
@ -661,6 +664,7 @@ void VcprojGenerator::init()
|
|||
if (init_flag)
|
||||
return;
|
||||
init_flag = true;
|
||||
is64Bit = (project->first("QMAKE_TARGET.arch") == "x86_64");
|
||||
projectWriter = createProjectWriter();
|
||||
|
||||
if(project->first("TEMPLATE") == "vcsubdirs") //too much work for subdirs
|
||||
|
|
@ -831,7 +835,7 @@ void VcprojGenerator::initProject()
|
|||
|
||||
vcProject.Keyword = project->first("VCPROJ_KEYWORD");
|
||||
if (project->isEmpty("CE_SDK") || project->isEmpty("CE_ARCH")) {
|
||||
vcProject.PlatformName = (vcProject.Configuration.idl.TargetEnvironment == midlTargetWin64 ? "Win64" : "Win32");
|
||||
vcProject.PlatformName = (is64Bit ? "x64" : "Win32");
|
||||
} else {
|
||||
vcProject.PlatformName = project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";
|
||||
}
|
||||
|
|
@ -895,7 +899,7 @@ void VcprojGenerator::initConfiguration()
|
|||
conf.Name = isDebug ? "Debug" : "Release";
|
||||
conf.ConfigurationName = conf.Name;
|
||||
if (project->isEmpty("CE_SDK") || project->isEmpty("CE_ARCH")) {
|
||||
conf.Name += (conf.idl.TargetEnvironment == midlTargetWin64 ? "|Win64" : "|Win32");
|
||||
conf.Name += (is64Bit ? "|x64" : "|Win32");
|
||||
} else {
|
||||
conf.Name += "|" + project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,6 +57,7 @@ struct QUuid;
|
|||
class VcprojGenerator : public Win32MakefileGenerator
|
||||
{
|
||||
bool init_flag;
|
||||
bool is64Bit;
|
||||
bool writeVcprojParts(QTextStream &);
|
||||
|
||||
bool writeMakefile(QTextStream &);
|
||||
|
|
|
|||
|
|
@ -41,25 +41,8 @@
|
|||
|
||||
#include "msvc_vcxproj.h"
|
||||
#include "msbuild_objectmodel.h"
|
||||
#include <qdir.h>
|
||||
#include <qdiriterator.h>
|
||||
#include <quuid.h>
|
||||
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
// Filter GUIDs (Do NOT change these!) ------------------------------
|
||||
const char _GUIDSourceFiles[] = "{4FC737F1-C7A5-4376-A066-2A32D752A2FF}";
|
||||
const char _GUIDHeaderFiles[] = "{93995380-89BD-4b04-88EB-625FBE52EBFB}";
|
||||
const char _GUIDGeneratedFiles[] = "{71ED8ED8-ACB9-4CE9-BBE1-E00B30144E11}";
|
||||
const char _GUIDResourceFiles[] = "{D9D6E242-F8AF-46E4-B9FD-80ECBC20BA3E}";
|
||||
const char _GUIDLexYaccFiles[] = "{E12AE0D2-192F-4d59-BD23-7D3FA58D3183}";
|
||||
const char _GUIDTranslationFiles[] = "{639EADAA-A684-42e4-A9AD-28FC9BCB8F7C}";
|
||||
const char _GUIDFormFiles[] = "{99349809-55BA-4b9d-BF79-8FDBB0286EB3}";
|
||||
const char _GUIDExtraCompilerFiles[] = "{E0D8C965-CC5F-43d7-AD63-FAEF0BBC0F85}";
|
||||
QT_END_NAMESPACE
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
|
||||
VcxprojGenerator::VcxprojGenerator() : VcprojGenerator()
|
||||
{
|
||||
|
|
@ -71,4 +54,3 @@ VCProjectWriter *VcxprojGenerator::createProjectWriter()
|
|||
}
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
|
|
|
|||
|
|
@ -42,8 +42,6 @@
|
|||
#ifndef MSVC_VCXPROJ_H
|
||||
#define MSVC_VCXPROJ_H
|
||||
|
||||
#include "winmakefile.h"
|
||||
#include "msbuild_objectmodel.h"
|
||||
#include "msvc_vcproj.h"
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
|
@ -52,19 +50,11 @@ class VcxprojGenerator : public VcprojGenerator
|
|||
{
|
||||
public:
|
||||
VcxprojGenerator();
|
||||
~VcxprojGenerator();
|
||||
|
||||
protected:
|
||||
virtual VCProjectWriter *createProjectWriter();
|
||||
|
||||
private:
|
||||
friend class VCFilter;
|
||||
|
||||
};
|
||||
|
||||
inline VcxprojGenerator::~VcxprojGenerator()
|
||||
{ }
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
#endif // MSVC_VCXPROJ_H
|
||||
|
|
|
|||
11
qtbase.pro
11
qtbase.pro
|
|
@ -7,12 +7,19 @@ TEMPLATE = subdirs
|
|||
|
||||
cross_compile: CONFIG += nostrip
|
||||
|
||||
module_qtbase_tests.subdir = tests
|
||||
module_qtbase_tests.target = module-qtbase-tests
|
||||
module_qtbase_tests.depends = module_qtbase_src
|
||||
module_qtbase_tests.CONFIG = no_default_target no_default_install
|
||||
|
||||
#process the projects
|
||||
for(PROJECT, $$list($$lower($$unique(QT_BUILD_PARTS)))) {
|
||||
isEqual(PROJECT, examples) {
|
||||
SUBDIRS += examples
|
||||
} else:isEqual(PROJECT, demos) {
|
||||
SUBDIRS += demos
|
||||
} else:isEqual(PROJECT, tests) {
|
||||
module_qtbase_tests.CONFIG -= no_default_target
|
||||
} else:isEqual(PROJECT, libs) {
|
||||
include(src/src.pro)
|
||||
} else:isEqual(PROJECT, qmake) {
|
||||
|
|
@ -22,10 +29,6 @@ for(PROJECT, $$list($$lower($$unique(QT_BUILD_PARTS)))) {
|
|||
}
|
||||
}
|
||||
|
||||
module_qtbase_tests.subdir = tests
|
||||
module_qtbase_tests.target = module-qtbase-tests
|
||||
module_qtbase_tests.depends = module_qtbase_src
|
||||
module_qtbase_tests.CONFIG = no_default_target no_default_install
|
||||
SUBDIRS += module_qtbase_tests
|
||||
|
||||
!symbian: confclean.depends += clean
|
||||
|
|
|
|||
|
|
@ -655,6 +655,7 @@ void HB_GetCharAttributes(const HB_UChar16 *string, hb_uint32 stringLength,
|
|||
const HB_ScriptItem *items, hb_uint32 numItems,
|
||||
HB_CharAttributes *attributes)
|
||||
{
|
||||
memset(attributes, 0, stringLength * sizeof(HB_CharAttributes));
|
||||
calcLineBreaks(string, stringLength, attributes);
|
||||
|
||||
for (hb_uint32 i = 0; i < numItems; ++i) {
|
||||
|
|
|
|||
|
|
@ -580,6 +580,8 @@ qint64 QAnimationDriver::elapsed() const
|
|||
QDefaultAnimationDriver::QDefaultAnimationDriver(QUnifiedTimer *timer)
|
||||
: QAnimationDriver(0), m_unified_timer(timer)
|
||||
{
|
||||
connect(this, SIGNAL(started()), this, SLOT(startTimer()));
|
||||
connect(this, SIGNAL(stopped()), this, SLOT(stopTimer()));
|
||||
}
|
||||
|
||||
void QDefaultAnimationDriver::timerEvent(QTimerEvent *e)
|
||||
|
|
@ -589,12 +591,12 @@ void QDefaultAnimationDriver::timerEvent(QTimerEvent *e)
|
|||
advance();
|
||||
}
|
||||
|
||||
void QDefaultAnimationDriver::started()
|
||||
void QDefaultAnimationDriver::startTimer()
|
||||
{
|
||||
m_timer.start(m_unified_timer->timingInterval, this);
|
||||
}
|
||||
|
||||
void QDefaultAnimationDriver::stopped()
|
||||
void QDefaultAnimationDriver::stopTimer()
|
||||
{
|
||||
m_timer.stop();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -124,8 +124,9 @@ public:
|
|||
QDefaultAnimationDriver(QUnifiedTimer *timer);
|
||||
void timerEvent(QTimerEvent *e);
|
||||
|
||||
void started();
|
||||
void stopped();
|
||||
private Q_SLOTS:
|
||||
void startTimer();
|
||||
void stopTimer();
|
||||
|
||||
private:
|
||||
QBasicTimer m_timer;
|
||||
|
|
|
|||
|
|
@ -115,19 +115,7 @@ ThreadEngineStarter<void> filterInternal(Sequence &sequence, KeepFunctor keep, T
|
|||
template <typename Sequence, typename KeepFunctor>
|
||||
QFuture<void> filter(Sequence &sequence, KeepFunctor keep)
|
||||
{
|
||||
return filterInternal(sequence, keep, &Sequence::push_back);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T>
|
||||
QFuture<void> filter(Sequence &sequence, bool (keep)(T))
|
||||
{
|
||||
return filterInternal(sequence, FunctionWrapper1<bool, T>(keep), &Sequence::push_back);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C>
|
||||
QFuture<void> filter(Sequence &sequence, bool (C::*keep)() const)
|
||||
{
|
||||
return filterInternal(sequence, ConstMemberFunctionWrapper<bool, C>(keep), &Sequence::push_back);
|
||||
return filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back);
|
||||
}
|
||||
|
||||
// filteredReduced() on sequences
|
||||
|
|
@ -137,103 +125,20 @@ QFuture<ResultType> filteredReduced(const Sequence &sequence,
|
|||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startFilteredReduced<ResultType>(sequence, keep, reduce, options);
|
||||
}
|
||||
return startFilteredReduced<ResultType>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename T, typename ReduceFunctor>
|
||||
QFuture<ResultType> filteredReduced(const Sequence &sequence,
|
||||
bool (filter)(T),
|
||||
template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
|
||||
QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> filteredReduced(const Sequence &sequence,
|
||||
KeepFunctor keep,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<ResultType>(sequence,
|
||||
FunctionWrapper1<bool, T>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename C, typename ReduceFunctor>
|
||||
QFuture<ResultType> filteredReduced(const Sequence &sequence,
|
||||
bool (C::*filter)() const,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<ResultType>(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename KeepFunctor, typename T, typename U, typename V>
|
||||
QFuture<U> filteredReduced(const Sequence &sequence,
|
||||
KeepFunctor keep,
|
||||
T (reduce)(U &, V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<U>(sequence,
|
||||
keep,
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename KeepFunctor, typename T, typename C, typename U>
|
||||
QFuture<C> filteredReduced(const Sequence &sequence,
|
||||
KeepFunctor keep,
|
||||
T (C::*reduce)(U),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<C>(sequence,
|
||||
keep,
|
||||
MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U, typename V, typename W>
|
||||
QFuture<V> filteredReduced(const Sequence &sequence,
|
||||
bool (keep)(T),
|
||||
U (reduce)(V &, W),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<V>(sequence,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
FunctionWrapper2<U, V &, W>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C, typename T, typename U, typename V>
|
||||
QFuture<U> filteredReduced(const Sequence &sequence,
|
||||
bool (C::*keep)() const,
|
||||
T (reduce)(U &, V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<U>(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U, typename C, typename V>
|
||||
QFuture<C> filteredReduced(const Sequence &sequence,
|
||||
bool (keep)(T),
|
||||
U (C::*reduce)(V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<C>(sequence,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
MemberFunctionWrapper1<U, C, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C, typename T, typename D, typename U>
|
||||
QFuture<D> filteredReduced(const Sequence &sequence,
|
||||
bool (C::*keep)() const,
|
||||
T (D::*reduce)(U),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<D>(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
MemberFunctionWrapper1<T, D, U>(reduce),
|
||||
options);
|
||||
return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(sequence,
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
// filteredReduced() on iterators
|
||||
|
|
@ -244,184 +149,42 @@ QFuture<ResultType> filteredReduced(Iterator begin,
|
|||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startFilteredReduced<ResultType>(begin, end, keep, reduce, options);
|
||||
return startFilteredReduced<ResultType>(begin, end, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename T, typename ReduceFunctor>
|
||||
QFuture<ResultType> filteredReduced(Iterator begin,
|
||||
template <typename Iterator, typename KeepFunctor, typename ReduceFunctor>
|
||||
QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> filteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (filter)(T),
|
||||
KeepFunctor keep,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<ResultType>(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(filter),
|
||||
reduce,
|
||||
options);
|
||||
return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename C, typename ReduceFunctor>
|
||||
QFuture<ResultType> filteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (C::*filter)() const,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<ResultType>(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename KeepFunctor, typename T, typename U, typename V>
|
||||
QFuture<U> filteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
KeepFunctor keep,
|
||||
T (reduce)(U &, V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<U>(begin,
|
||||
end,
|
||||
keep,
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename KeepFunctor, typename T, typename C, typename U>
|
||||
QFuture<C> filteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
KeepFunctor keep,
|
||||
T (C::*reduce)(U),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<C>(begin,
|
||||
end,
|
||||
keep,
|
||||
MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U, typename V, typename W>
|
||||
QFuture<V> filteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (keep)(T),
|
||||
U (reduce)(V &, W),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<V>(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
FunctionWrapper2<U, V &, W>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename C, typename T, typename U, typename V>
|
||||
QFuture<U> filteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (C::*keep)() const,
|
||||
T (reduce)(U &, V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<U>(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U, typename C, typename V>
|
||||
QFuture<C> filteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (keep)(T),
|
||||
U (C::*reduce)(V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<C>(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
MemberFunctionWrapper1<U, C, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename C, typename T, typename D, typename U>
|
||||
QFuture<D> filteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (C::*keep)() const,
|
||||
T (D::*reduce)(U),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return filteredReduced<D>(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
MemberFunctionWrapper1<T, D, U>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
|
||||
// filtered() on sequences
|
||||
template <typename Sequence, typename KeepFunctor>
|
||||
QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, KeepFunctor keep)
|
||||
{
|
||||
return startFiltered(sequence, keep);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T>
|
||||
QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, bool (keep)(T))
|
||||
{
|
||||
return startFiltered(sequence, FunctionWrapper1<bool, T>(keep));
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C>
|
||||
QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, bool (C::*keep)() const)
|
||||
{
|
||||
return startFiltered(sequence, ConstMemberFunctionWrapper<bool, C>(keep));
|
||||
return startFiltered(sequence, QtPrivate::createFunctionWrapper(keep));
|
||||
}
|
||||
|
||||
// filtered() on iterators
|
||||
template <typename Iterator, typename KeepFunctor>
|
||||
QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin, Iterator end, KeepFunctor keep)
|
||||
{
|
||||
return startFiltered(begin, end, keep);
|
||||
return startFiltered(begin, end, QtPrivate::createFunctionWrapper(keep));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T>
|
||||
QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin, Iterator end, bool (keep)(T))
|
||||
{
|
||||
return startFiltered(begin, end, FunctionWrapper1<bool, T>(keep));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename C>
|
||||
QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin,
|
||||
Iterator end,
|
||||
bool (C::*keep)() const)
|
||||
{
|
||||
return startFiltered(begin, end, ConstMemberFunctionWrapper<bool, C>(keep));
|
||||
}
|
||||
|
||||
|
||||
// blocking filter() on sequences
|
||||
template <typename Sequence, typename KeepFunctor>
|
||||
void blockingFilter(Sequence &sequence, KeepFunctor keep)
|
||||
{
|
||||
filterInternal(sequence, keep, &Sequence::push_back).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T>
|
||||
void blockingFilter(Sequence &sequence, bool (keep)(T))
|
||||
{
|
||||
filterInternal(sequence, FunctionWrapper1<bool, T>(keep), &Sequence::push_back)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C>
|
||||
void blockingFilter(Sequence &sequence, bool (C::*keep)() const)
|
||||
{
|
||||
filterInternal(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
&Sequence::push_back)
|
||||
.startBlocking();
|
||||
filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back).startBlocking();
|
||||
}
|
||||
|
||||
// blocking filteredReduced() on sequences
|
||||
|
|
@ -431,111 +194,20 @@ ResultType blockingFilteredReduced(const Sequence &sequence,
|
|||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startFilteredReduced<ResultType>(sequence, keep, reduce, options)
|
||||
return startFilteredReduced<ResultType>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename T, typename ReduceFunctor>
|
||||
ResultType blockingFilteredReduced(const Sequence &sequence,
|
||||
bool (filter)(T),
|
||||
template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
|
||||
typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingFilteredReduced(const Sequence &sequence,
|
||||
KeepFunctor keep,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<ResultType>
|
||||
return blockingFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(sequence,
|
||||
FunctionWrapper1<bool, T>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename C, typename ReduceFunctor>
|
||||
ResultType blockingFilteredReduced(const Sequence &sequence,
|
||||
bool (C::*filter)() const,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<ResultType>
|
||||
(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename KeepFunctor, typename T, typename U, typename V>
|
||||
U blockingFilteredReduced(const Sequence &sequence,
|
||||
KeepFunctor keep,
|
||||
T (reduce)(U &, V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<U>
|
||||
(sequence,
|
||||
keep,
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename KeepFunctor, typename T, typename C, typename U>
|
||||
C blockingFilteredReduced(const Sequence &sequence,
|
||||
KeepFunctor keep,
|
||||
T (C::*reduce)(U),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<C>
|
||||
(sequence,
|
||||
keep,
|
||||
MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U, typename V, typename W>
|
||||
V blockingFilteredReduced(const Sequence &sequence,
|
||||
bool (keep)(T),
|
||||
U (reduce)(V &, W),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<V>
|
||||
(sequence,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
FunctionWrapper2<U, V &, W>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C, typename T, typename U, typename V>
|
||||
U blockingFilteredReduced(const Sequence &sequence,
|
||||
bool (C::*keep)() const,
|
||||
T (reduce)(U &, V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<U>
|
||||
(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U, typename C, typename V>
|
||||
C blockingFilteredReduced(const Sequence &sequence,
|
||||
bool (keep)(T),
|
||||
U (C::*reduce)(V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<C>
|
||||
(sequence,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
MemberFunctionWrapper1<U, C, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C, typename T, typename D, typename U>
|
||||
D blockingFilteredReduced(const Sequence &sequence,
|
||||
bool (C::*keep)() const,
|
||||
T (D::*reduce)(U),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<D>
|
||||
(sequence,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
MemberFunctionWrapper1<T, D, U>(reduce),
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
|
|
@ -547,150 +219,34 @@ ResultType blockingFilteredReduced(Iterator begin,
|
|||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startFilteredReduced<ResultType>(begin, end, keep, reduce, options)
|
||||
return startFilteredReduced<ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename T, typename ReduceFunctor>
|
||||
ResultType blockingFilteredReduced(Iterator begin,
|
||||
template <typename Iterator, typename KeepFunctor, typename ReduceFunctor>
|
||||
typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingFilteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (filter)(T),
|
||||
KeepFunctor keep,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<ResultType>
|
||||
(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename C, typename ReduceFunctor>
|
||||
ResultType blockingFilteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (C::*filter)() const,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<ResultType>
|
||||
(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(filter),
|
||||
reduce,
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename KeepFunctor, typename T, typename U, typename V>
|
||||
U blockingFilteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
KeepFunctor keep,
|
||||
T (reduce)(U &, V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<U>
|
||||
(begin,
|
||||
end,
|
||||
keep,
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename KeepFunctor, typename T, typename C, typename U>
|
||||
C blockingFilteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
KeepFunctor keep,
|
||||
T (C::*reduce)(U),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<C>
|
||||
(begin,
|
||||
end,
|
||||
keep,
|
||||
MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U, typename V, typename W>
|
||||
V blockingFilteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (keep)(T),
|
||||
U (reduce)(V &, W),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<V>
|
||||
(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
FunctionWrapper2<U, V &, W>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename C, typename T, typename U, typename V>
|
||||
U blockingFilteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (C::*keep)() const,
|
||||
T (reduce)(U &, V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<U>
|
||||
(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
FunctionWrapper2<T, U &, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U, typename C, typename V>
|
||||
C blockingFilteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (keep)(T),
|
||||
U (C::*reduce)(V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<C>
|
||||
(begin,
|
||||
end,
|
||||
FunctionWrapper1<bool, T>(keep),
|
||||
MemberFunctionWrapper1<U, C, V>(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename C, typename T, typename D, typename U>
|
||||
D blockingFilteredReduced(Iterator begin,
|
||||
Iterator end,
|
||||
bool (C::*keep)() const,
|
||||
T (D::*reduce)(U),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return blockingFilteredReduced<D>
|
||||
(begin,
|
||||
end,
|
||||
ConstMemberFunctionWrapper<bool, C>(keep),
|
||||
MemberFunctionWrapper1<T, D, U>(reduce),
|
||||
options);
|
||||
return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
// blocking filtered() on sequences
|
||||
template <typename Sequence, typename KeepFunctor>
|
||||
Sequence blockingFiltered(const Sequence &sequence, KeepFunctor keep)
|
||||
{
|
||||
return blockingFilteredReduced(sequence, keep, &Sequence::push_back, OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T>
|
||||
Sequence blockingFiltered(const Sequence &sequence, bool (keep)(T))
|
||||
{
|
||||
return blockingFilteredReduced(sequence, keep, &Sequence::push_back, OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename C>
|
||||
Sequence blockingFiltered(const Sequence &sequence, bool (C::*filter)() const)
|
||||
{
|
||||
return blockingFilteredReduced(sequence,
|
||||
filter,
|
||||
&Sequence::push_back,
|
||||
OrderedReduce);
|
||||
return blockingFilteredReduced(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back, OrderedReduce);
|
||||
}
|
||||
|
||||
// blocking filtered() on iterators
|
||||
|
|
@ -699,27 +255,7 @@ OutputSequence blockingFiltered(Iterator begin, Iterator end, KeepFunctor keep)
|
|||
{
|
||||
return blockingFilteredReduced(begin,
|
||||
end,
|
||||
keep,
|
||||
&OutputSequence::push_back,
|
||||
OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename OutputSequence, typename Iterator, typename T>
|
||||
OutputSequence blockingFiltered(Iterator begin, Iterator end, bool (keep)(T))
|
||||
{
|
||||
return blockingFilteredReduced(begin,
|
||||
end,
|
||||
keep,
|
||||
&OutputSequence::push_back,
|
||||
OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename OutputSequence, typename Iterator, typename C>
|
||||
OutputSequence blockingFiltered(Iterator begin, Iterator end, bool (C::*filter)() const)
|
||||
{
|
||||
return blockingFilteredReduced(begin,
|
||||
end,
|
||||
filter,
|
||||
QtPrivate::createFunctionWrapper(keep),
|
||||
&OutputSequence::push_back,
|
||||
OrderedReduce);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -163,6 +163,125 @@ private:
|
|||
|
||||
} // namespace QtConcurrent.
|
||||
|
||||
namespace QtPrivate {
|
||||
|
||||
template <typename T>
|
||||
const T& createFunctionWrapper(const T& t)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
|
||||
template <typename T, typename U>
|
||||
QtConcurrent::FunctionWrapper1<T, U> createFunctionWrapper(T (*func)(U))
|
||||
{
|
||||
return QtConcurrent::FunctionWrapper1<T, U>(func);
|
||||
}
|
||||
|
||||
template <typename T, typename C>
|
||||
QtConcurrent::MemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)())
|
||||
{
|
||||
return QtConcurrent::MemberFunctionWrapper<T, C>(func);
|
||||
}
|
||||
|
||||
template <typename T, typename C, typename U>
|
||||
QtConcurrent::MemberFunctionWrapper1<T, C, U> createFunctionWrapper(T (C::*func)(U))
|
||||
{
|
||||
return QtConcurrent::MemberFunctionWrapper1<T, C, U>(func);
|
||||
}
|
||||
|
||||
template <typename T, typename C>
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)() const)
|
||||
{
|
||||
return QtConcurrent::ConstMemberFunctionWrapper<T, C>(func);
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
void *lazyResultType_helper(int, typename T::result_type * = 0);
|
||||
template<typename T>
|
||||
char lazyResultType_helper(double);
|
||||
|
||||
template <typename Functor, bool foo = sizeof(lazyResultType_helper<Functor>(0)) != sizeof(void*)>
|
||||
struct LazyResultType { typedef typename Functor::result_type Type; };
|
||||
template <typename Functor>
|
||||
struct LazyResultType<Functor, true> { typedef void Type; };
|
||||
|
||||
|
||||
template <class T>
|
||||
struct ReduceResultType;
|
||||
|
||||
template <class U, class V>
|
||||
struct ReduceResultType<void(*)(U&,V)>
|
||||
{
|
||||
typedef U ResultType;
|
||||
};
|
||||
|
||||
template <class T, class C, class U>
|
||||
struct ReduceResultType<T(C::*)(U)>
|
||||
{
|
||||
typedef C ResultType;
|
||||
};
|
||||
|
||||
template <class InputSequence, class MapFunctor>
|
||||
struct MapResultType
|
||||
{
|
||||
typedef typename LazyResultType<MapFunctor>::Type ResultType;
|
||||
};
|
||||
|
||||
template <class U, class V>
|
||||
struct MapResultType<void, U (*)(V)>
|
||||
{
|
||||
typedef U ResultType;
|
||||
};
|
||||
|
||||
template <class T, class C>
|
||||
struct MapResultType<void, T(C::*)() const>
|
||||
{
|
||||
typedef T ResultType;
|
||||
};
|
||||
|
||||
#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
|
||||
|
||||
template <template <typename> class InputSequence, typename MapFunctor, typename T>
|
||||
struct MapResultType<InputSequence<T>, MapFunctor>
|
||||
{
|
||||
typedef InputSequence<typename LazyResultType<MapFunctor>::Type> ResultType;
|
||||
};
|
||||
|
||||
template <template <typename> class InputSequence, class T, class U, class V>
|
||||
struct MapResultType<InputSequence<T>, U (*)(V)>
|
||||
{
|
||||
typedef InputSequence<U> ResultType;
|
||||
};
|
||||
|
||||
template <template <typename> class InputSequence, class T, class U, class C>
|
||||
struct MapResultType<InputSequence<T>, U(C::*)() const>
|
||||
{
|
||||
typedef InputSequence<U> ResultType;
|
||||
};
|
||||
|
||||
#endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER
|
||||
|
||||
template <class MapFunctor>
|
||||
struct MapResultType<QStringList, MapFunctor>
|
||||
{
|
||||
typedef QList<typename LazyResultType<MapFunctor>::Type> ResultType;
|
||||
};
|
||||
|
||||
template <class U, class V>
|
||||
struct MapResultType<QStringList, U (*)(V)>
|
||||
{
|
||||
typedef QList<U> ResultType;
|
||||
};
|
||||
|
||||
template <class U, class C>
|
||||
struct MapResultType<QStringList, U(C::*)() const>
|
||||
{
|
||||
typedef QList<U> ResultType;
|
||||
};
|
||||
|
||||
} // namespace QtPrivate.
|
||||
|
||||
#endif //qdoc
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
|
|
|||
|
|
@ -110,38 +110,14 @@ namespace QtConcurrent {
|
|||
template <typename Sequence, typename MapFunctor>
|
||||
QFuture<void> map(Sequence &sequence, MapFunctor map)
|
||||
{
|
||||
return startMap(sequence.begin(), sequence.end(), map);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U>
|
||||
QFuture<void> map(Sequence &sequence, T (map)(U))
|
||||
{
|
||||
return startMap(sequence.begin(), sequence.end(), FunctionWrapper1<T, U>(map));
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename C>
|
||||
QFuture<void> map(Sequence &sequence, T (C::*map)())
|
||||
{
|
||||
return startMap(sequence.begin(), sequence.end(), MemberFunctionWrapper<T, C>(map));
|
||||
return startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map));
|
||||
}
|
||||
|
||||
// map() on iterators
|
||||
template <typename Iterator, typename MapFunctor>
|
||||
QFuture<void> map(Iterator begin, Iterator end, MapFunctor map)
|
||||
{
|
||||
return startMap(begin, end, map);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U>
|
||||
QFuture<void> map(Iterator begin, Iterator end, T (map)(U))
|
||||
{
|
||||
return startMap(begin, end, FunctionWrapper1<T, U>(map));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename C>
|
||||
QFuture<void> map(Iterator begin, Iterator end, T (C::*map)())
|
||||
{
|
||||
return startMap(begin, end, MemberFunctionWrapper<T, C>(map));
|
||||
return startMap(begin, end, QtPrivate::createFunctionWrapper(map));
|
||||
}
|
||||
|
||||
// mappedReduced() for sequences.
|
||||
|
|
@ -151,88 +127,24 @@ QFuture<ResultType> mappedReduced(const Sequence &sequence,
|
|||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<typename MapFunctor::result_type, ResultType>
|
||||
(sequence, map, reduce, options);
|
||||
return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
|
||||
(sequence,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename MapFunctor, typename T, typename U, typename V>
|
||||
QFuture<U> mappedReduced(const Sequence &sequence,
|
||||
MapFunctor map,
|
||||
T (reduce)(U &, V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<typename MapFunctor::result_type, U>
|
||||
(sequence, map, FunctionWrapper2<T, U &, V>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename MapFunctor, typename T, typename C, typename U>
|
||||
QFuture<C> mappedReduced(const Sequence &sequence,
|
||||
MapFunctor map,
|
||||
T (C::*reduce)(U),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<typename MapFunctor::result_type, C>
|
||||
(sequence, map, MemberFunctionWrapper1<T, C, U>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename T, typename U, typename ReduceFunctor>
|
||||
QFuture<ResultType> mappedReduced(const Sequence &sequence,
|
||||
T (map)(U),
|
||||
template <typename Sequence, typename MapFunctor, typename ReduceFunctor>
|
||||
QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(const Sequence &sequence,
|
||||
MapFunctor map,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, ResultType>
|
||||
(sequence, FunctionWrapper1<T, U>(map), reduce, options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename T, typename C, typename ReduceFunctor>
|
||||
QFuture<ResultType> mappedReduced(const Sequence &sequence,
|
||||
T (C::*map)() const,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, ResultType>
|
||||
(sequence, ConstMemberFunctionWrapper<T, C>(map), reduce, options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U, typename V, typename W, typename X>
|
||||
QFuture<W> mappedReduced(const Sequence &sequence,
|
||||
T (map)(U),
|
||||
V (reduce)(W &, X),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, W>
|
||||
(sequence, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename C, typename U, typename V, typename W>
|
||||
QFuture<V> mappedReduced(const Sequence &sequence,
|
||||
T (C::*map)() const,
|
||||
U (reduce)(V &, W),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, V> (sequence, ConstMemberFunctionWrapper<T, C>(map),
|
||||
FunctionWrapper2<U, V &, W>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U, typename V, typename C, typename W>
|
||||
QFuture<C> mappedReduced(const Sequence &sequence,
|
||||
T (map)(U),
|
||||
V (C::*reduce)(W),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, C> (sequence, FunctionWrapper1<T, U>(map),
|
||||
MemberFunctionWrapper1<V, C, W>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename C, typename U,typename D, typename V>
|
||||
QFuture<D> mappedReduced(const Sequence &sequence,
|
||||
T (C::*map)() const,
|
||||
U (D::*reduce)(V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, D>(sequence, ConstMemberFunctionWrapper<T, C>(map),
|
||||
MemberFunctionWrapper1<U, D, V>(reduce), options);
|
||||
return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(sequence,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
// mappedReduced() for iterators
|
||||
|
|
@ -243,295 +155,85 @@ QFuture<ResultType> mappedReduced(Iterator begin,
|
|||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<ResultType, typename MapFunctor::result_type>
|
||||
(begin, end, map, reduce, options);
|
||||
return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename MapFunctor, typename T, typename U, typename V>
|
||||
QFuture<U> mappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
MapFunctor map,
|
||||
T (reduce)(U &, V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<typename MapFunctor::result_type, U>
|
||||
(begin, end, map, FunctionWrapper2<T, U &, V>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename MapFunctor, typename T, typename C, typename U>
|
||||
QFuture<C> mappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
MapFunctor map,
|
||||
T (C::*reduce)(U),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<typename MapFunctor::result_type, C>
|
||||
(begin, end, map, MemberFunctionWrapper1<T, C, U>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename T, typename U, typename ReduceFunctor>
|
||||
QFuture<ResultType> mappedReduced(Iterator begin,
|
||||
template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
|
||||
QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (map)(U),
|
||||
MapFunctor map,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, ResultType>
|
||||
(begin, end, FunctionWrapper1<T, U>(map), reduce, options);
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename T, typename C, typename ReduceFunctor>
|
||||
QFuture<ResultType> mappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (C::*map)() const,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, ResultType>
|
||||
(begin, end, ConstMemberFunctionWrapper<T, C>(map), reduce, options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U, typename V, typename W, typename X>
|
||||
QFuture<W> mappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (map)(U),
|
||||
V (reduce)(W &, X),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, W>
|
||||
(begin, end, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename C, typename U, typename V, typename W>
|
||||
QFuture<V> mappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (C::*map)() const,
|
||||
U (reduce)(V &, W),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, V>(begin, end, ConstMemberFunctionWrapper<T, C>(map),
|
||||
FunctionWrapper2<U, V &, W>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U, typename V, typename C, typename W>
|
||||
QFuture<C> mappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (map)(U),
|
||||
V (C::*reduce)(W),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, C>
|
||||
(begin, end, FunctionWrapper1<T, U>(map), MemberFunctionWrapper1<V, C, W>(reduce), options);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename C, typename U,typename D, typename V>
|
||||
QFuture<D> mappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (C::*map)() const,
|
||||
U (D::*reduce)(V),
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return startMappedReduced<T, D>(begin, end, ConstMemberFunctionWrapper<T, C>(map),
|
||||
MemberFunctionWrapper1<U, D, V>(reduce), options);
|
||||
return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options);
|
||||
}
|
||||
|
||||
// mapped() for sequences
|
||||
template <typename Sequence, typename MapFunctor>
|
||||
QFuture<typename MapFunctor::result_type> mapped(const Sequence &sequence, MapFunctor map)
|
||||
QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(const Sequence &sequence, MapFunctor map)
|
||||
{
|
||||
return startMapped<typename MapFunctor::result_type>(sequence, map);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U>
|
||||
QFuture<T> mapped(const Sequence &sequence, T (map)(U))
|
||||
{
|
||||
return startMapped<T>(sequence, FunctionWrapper1<T, U>(map));
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename C>
|
||||
QFuture<T> mapped(const Sequence &sequence, T (C::*map)() const)
|
||||
{
|
||||
return startMapped<T>(sequence, ConstMemberFunctionWrapper<T, C>(map));
|
||||
return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(sequence, QtPrivate::createFunctionWrapper(map));
|
||||
}
|
||||
|
||||
// mapped() for iterator ranges.
|
||||
template <typename Iterator, typename MapFunctor>
|
||||
QFuture<typename MapFunctor::result_type> mapped(Iterator begin, Iterator end, MapFunctor map)
|
||||
QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(Iterator begin, Iterator end, MapFunctor map)
|
||||
{
|
||||
return startMapped<Q_TYPENAME MapFunctor::result_type>(begin, end, map);
|
||||
return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(begin, end, QtPrivate::createFunctionWrapper(map));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U>
|
||||
QFuture<T> mapped(Iterator begin, Iterator end, T (map)(U))
|
||||
{
|
||||
return startMapped<T>(begin, end, FunctionWrapper1<T, U>(map));
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename C>
|
||||
QFuture<T> mapped(Iterator begin, Iterator end, T (C::*map)() const)
|
||||
{
|
||||
return startMapped<T>(begin, end, ConstMemberFunctionWrapper<T, C>(map));
|
||||
}
|
||||
|
||||
|
||||
// blockingMap() for sequences
|
||||
template <typename Sequence, typename MapFunctor>
|
||||
void blockingMap(Sequence &sequence, MapFunctor map)
|
||||
{
|
||||
startMap(sequence.begin(), sequence.end(), map).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U>
|
||||
void blockingMap(Sequence &sequence, T (map)(U))
|
||||
{
|
||||
startMap(sequence.begin(), sequence.end(), QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename C>
|
||||
void blockingMap(Sequence &sequence, T (C::*map)())
|
||||
{
|
||||
startMap(sequence.begin(), sequence.end(), QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();
|
||||
startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map)).startBlocking();
|
||||
}
|
||||
|
||||
// blockingMap() for iterator ranges
|
||||
template <typename Iterator, typename MapFunctor>
|
||||
void blockingMap(Iterator begin, Iterator end, MapFunctor map)
|
||||
{
|
||||
startMap(begin, end, map).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U>
|
||||
void blockingMap(Iterator begin, Iterator end, T (map)(U))
|
||||
{
|
||||
startMap(begin, end, QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename C>
|
||||
void blockingMap(Iterator begin, Iterator end, T (C::*map)())
|
||||
{
|
||||
startMap(begin, end, QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();
|
||||
startMap(begin, end, QtPrivate::createFunctionWrapper(map)).startBlocking();
|
||||
}
|
||||
|
||||
// blockingMappedReduced() for sequences
|
||||
template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
|
||||
ResultType blockingMappedReduced(const Sequence &sequence,
|
||||
MapFunctor map,
|
||||
ReduceFunctor reduce,
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, ResultType>
|
||||
(sequence, map, reduce, options).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename MapFunctor, typename T, typename U, typename V>
|
||||
U blockingMappedReduced(const Sequence &sequence,
|
||||
MapFunctor map,
|
||||
T (reduce)(U &, V),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>
|
||||
return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
|
||||
(sequence,
|
||||
map,
|
||||
QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename MapFunctor, typename T, typename C, typename U>
|
||||
C blockingMappedReduced(const Sequence &sequence,
|
||||
MapFunctor map,
|
||||
T (C::*reduce)(U),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>
|
||||
(sequence,
|
||||
map,
|
||||
QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename T, typename U, typename ReduceFunctor>
|
||||
ResultType blockingMappedReduced(const Sequence &sequence,
|
||||
T (map)(U),
|
||||
template <typename MapFunctor, typename ReduceFunctor, typename Sequence>
|
||||
typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(const Sequence &sequence,
|
||||
MapFunctor map,
|
||||
ReduceFunctor reduce,
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, ResultType>
|
||||
return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(sequence,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
reduce,
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Sequence, typename T, typename C, typename ReduceFunctor>
|
||||
ResultType blockingMappedReduced(const Sequence &sequence,
|
||||
T (C::*map)() const,
|
||||
ReduceFunctor reduce,
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, ResultType>
|
||||
(sequence,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
reduce,
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U, typename V, typename W, typename X>
|
||||
W blockingMappedReduced(const Sequence &sequence,
|
||||
T (map)(U),
|
||||
V (reduce)(W &, X),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, W>
|
||||
(sequence,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename C, typename U, typename V, typename W>
|
||||
V blockingMappedReduced(const Sequence &sequence,
|
||||
T (C::*map)() const,
|
||||
U (reduce)(V &, W),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, V>
|
||||
(sequence,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename U, typename V, typename C, typename W>
|
||||
C blockingMappedReduced(const Sequence &sequence,
|
||||
T (map)(U),
|
||||
V (C::*reduce)(W),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, C>
|
||||
(sequence,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Sequence, typename T, typename C, typename U,typename D, typename V>
|
||||
D blockingMappedReduced(const Sequence &sequence,
|
||||
T (C::*map)() const,
|
||||
U (D::*reduce)(V),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, D>
|
||||
(sequence,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
QtConcurrent::MemberFunctionWrapper1<U, D, V>(reduce),
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
// blockingMappedReduced() for iterator ranges
|
||||
template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
|
||||
ResultType blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
|
|
@ -539,134 +241,25 @@ ResultType blockingMappedReduced(Iterator begin,
|
|||
ReduceFunctor reduce,
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, ResultType>
|
||||
(begin, end, map, reduce, options).startBlocking();
|
||||
}
|
||||
|
||||
template <typename Iterator, typename MapFunctor, typename T, typename U, typename V>
|
||||
U blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
MapFunctor map,
|
||||
T (reduce)(U &, V),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>
|
||||
(begin,
|
||||
end,
|
||||
map,
|
||||
QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),
|
||||
return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Iterator, typename MapFunctor, typename T, typename C, typename U>
|
||||
C blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
MapFunctor map,
|
||||
T (C::*reduce)(U),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>
|
||||
(begin,
|
||||
end,
|
||||
map,
|
||||
QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename T, typename U, typename ReduceFunctor>
|
||||
ResultType blockingMappedReduced(Iterator begin,
|
||||
template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
|
||||
typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (map)(U),
|
||||
MapFunctor map,
|
||||
ReduceFunctor reduce,
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, ResultType>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
reduce,
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename ResultType, typename Iterator, typename T, typename C, typename ReduceFunctor>
|
||||
ResultType blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (C::*map)() const,
|
||||
ReduceFunctor reduce,
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, ResultType>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
reduce,
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U, typename V, typename W, typename X>
|
||||
W blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (map)(U),
|
||||
V (reduce)(W &, X),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, W>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename C, typename U, typename V, typename W>
|
||||
V blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (C::*map)() const,
|
||||
U (reduce)(V &, W),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, V>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename U, typename V, typename C, typename W>
|
||||
C blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (map)(U),
|
||||
V (C::*reduce)(W),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, C>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::FunctionWrapper1<T, U>(map),
|
||||
QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
||||
template <typename Iterator, typename T, typename C, typename U,typename D, typename V>
|
||||
D blockingMappedReduced(Iterator begin,
|
||||
Iterator end,
|
||||
T (C::*map)() const,
|
||||
U (D::*reduce)(V),
|
||||
QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
|
||||
{
|
||||
return QtConcurrent::startMappedReduced<T, D>
|
||||
(begin,
|
||||
end,
|
||||
QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
|
||||
QtConcurrent::MemberFunctionWrapper1<U, D, V>(reduce),
|
||||
return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
QtPrivate::createFunctionWrapper(reduce),
|
||||
options)
|
||||
.startBlocking();
|
||||
}
|
||||
|
|
@ -675,97 +268,44 @@ D blockingMappedReduced(Iterator begin,
|
|||
template <typename OutputSequence, typename InputSequence, typename MapFunctor>
|
||||
OutputSequence blockingMapped(const InputSequence &sequence, MapFunctor map)
|
||||
{
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
return blockingMappedReduced<OutputSequence>
|
||||
(sequence,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
&OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename OutputSequence, typename InputSequence, typename T, typename U>
|
||||
OutputSequence blockingMapped(const InputSequence &sequence, T (map)(U))
|
||||
template <typename MapFunctor, typename InputSequence>
|
||||
typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType blockingMapped(const InputSequence &sequence, MapFunctor map)
|
||||
{
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename OutputSequence, typename InputSequence, typename T, typename C>
|
||||
OutputSequence blockingMapped(const InputSequence &sequence, T (C::*map)() const)
|
||||
{
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
|
||||
|
||||
// overloads for changing the container value type:
|
||||
template <template <typename> class Sequence, typename MapFunctor, typename T>
|
||||
Sequence<typename MapFunctor::result_type> blockingMapped(const Sequence<T> &sequence, MapFunctor map)
|
||||
{
|
||||
typedef Sequence<typename MapFunctor::result_type> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <template <typename> class Sequence, typename T, typename U, typename V>
|
||||
Sequence<U> blockingMapped(const Sequence<T> &sequence, U (map)(V))
|
||||
{
|
||||
typedef Sequence<U> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <template <typename> class Sequence, typename T, typename U, typename C>
|
||||
Sequence<U> blockingMapped(const Sequence<T> &sequence, U (C::*map)() const)
|
||||
{
|
||||
typedef Sequence<U> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
#endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER
|
||||
|
||||
// overloads for changing the container value type from a QStringList:
|
||||
template <typename MapFunctor>
|
||||
QList<typename MapFunctor::result_type> blockingMapped(const QStringList &sequence, MapFunctor map)
|
||||
{
|
||||
typedef QList<typename MapFunctor::result_type> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename U, typename V>
|
||||
QList<U> blockingMapped(const QStringList &sequence, U (map)(V))
|
||||
{
|
||||
typedef QList<U> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename U, typename C>
|
||||
QList<U> blockingMapped(const QStringList &sequence, U (C::*map)() const)
|
||||
{
|
||||
typedef QList<U> OutputSequence;
|
||||
return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
typedef typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType OutputSequence;
|
||||
return blockingMappedReduced<OutputSequence>
|
||||
(sequence,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
&OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
// mapped() for iterator ranges
|
||||
template <typename Sequence, typename Iterator, typename MapFunctor>
|
||||
Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor map)
|
||||
{
|
||||
return blockingMappedReduced(begin, end, map, &Sequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
return blockingMappedReduced<Sequence>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
&Sequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename Iterator, typename T, typename U>
|
||||
Sequence blockingMapped(Iterator begin, Iterator end, T (map)(U))
|
||||
template <typename Iterator, typename MapFunctor>
|
||||
typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType blockingMapped(Iterator begin, Iterator end, MapFunctor map)
|
||||
{
|
||||
return blockingMappedReduced(begin, end, map, &Sequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
template <typename Sequence, typename Iterator, typename T, typename C>
|
||||
Sequence blockingMapped(Iterator begin, Iterator end, T (C::*map)() const)
|
||||
{
|
||||
return blockingMappedReduced(begin, end, map, &Sequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
typedef typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType OutputSequence;
|
||||
return blockingMappedReduced<OutputSequence>
|
||||
(begin, end,
|
||||
QtPrivate::createFunctionWrapper(map),
|
||||
&OutputSequence::push_back,
|
||||
QtConcurrent::OrderedReduce);
|
||||
}
|
||||
|
||||
} // namespace QtConcurrent
|
||||
|
|
|
|||
|
|
@ -1368,6 +1368,16 @@ class QDataStream;
|
|||
# else
|
||||
# define Q_DBUS_EXPORT Q_DECL_IMPORT
|
||||
# endif
|
||||
# if defined(QT_BUILD_LOCATION_LIB)
|
||||
# define Q_LOCATION_EXPORT Q_DECL_EXPORT
|
||||
# else
|
||||
# define Q_LOCATION_EXPORT Q_DECL_IMPORT
|
||||
# endif
|
||||
# if defined(QT_BUILD_SENSORS_LIB)
|
||||
# define Q_SENSORS_EXPORT Q_DECL_EXPORT
|
||||
# else
|
||||
# define Q_SENSORS_EXPORT Q_DECL_IMPORT
|
||||
# endif
|
||||
# define Q_TEMPLATEDLL
|
||||
# elif defined(QT_DLL) /* use a Qt DLL library */
|
||||
# define Q_CORE_EXPORT Q_DECL_IMPORT
|
||||
|
|
@ -1386,6 +1396,8 @@ class QDataStream;
|
|||
# define Q_SCRIPTTOOLS_EXPORT Q_DECL_IMPORT
|
||||
# define Q_COMPAT_EXPORT Q_DECL_IMPORT
|
||||
# define Q_DBUS_EXPORT Q_DECL_IMPORT
|
||||
# define Q_LOCATION_EXPORT Q_DECL_IMPORT
|
||||
# define Q_SENSORS_EXPORT Q_DECL_IMPORT
|
||||
# define Q_TEMPLATEDLL
|
||||
# endif
|
||||
# define Q_NO_DECLARED_NOT_DEFINED
|
||||
|
|
@ -1415,6 +1427,8 @@ class QDataStream;
|
|||
# define Q_SCRIPTTOOLS_EXPORT Q_DECL_EXPORT
|
||||
# define Q_COMPAT_EXPORT Q_DECL_EXPORT
|
||||
# define Q_DBUS_EXPORT Q_DECL_EXPORT
|
||||
# define Q_LOCATION_EXPORT Q_DECL_EXPORT
|
||||
# define Q_SENSORS_EXPORT Q_DECL_EXPORT
|
||||
# else
|
||||
# define Q_CORE_EXPORT
|
||||
# define Q_GUI_EXPORT
|
||||
|
|
@ -1430,6 +1444,8 @@ class QDataStream;
|
|||
# define Q_SCRIPTTOOLS_EXPORT
|
||||
# define Q_COMPAT_EXPORT
|
||||
# define Q_DBUS_EXPORT
|
||||
# define Q_LOCATION_EXPORT
|
||||
# define Q_SENSORS_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
|
@ -1843,6 +1859,10 @@ inline QT3_SUPPORT void qSuppressObsoleteWarnings(bool = true) {}
|
|||
inline QT3_SUPPORT void qObsolete(const char *, const char * = 0, const char * = 0) {}
|
||||
#endif
|
||||
|
||||
#if !defined(Q_UNIMPLEMENTED)
|
||||
# define Q_UNIMPLEMENTED() qWarning("%s:%d: %s: Unimplemented code.", __FILE__, __LINE__, Q_FUNC_INFO)
|
||||
#endif
|
||||
|
||||
#if defined(QT_NO_THREAD)
|
||||
|
||||
template <typename T>
|
||||
|
|
@ -2587,26 +2607,28 @@ Q_CORE_EXPORT int qt_symbian_exception2Error(const std::exception& ex);
|
|||
*/
|
||||
|
||||
/* Qt modules */
|
||||
#define QT_MODULE_CORE 0x00001
|
||||
#define QT_MODULE_GUI 0x00002
|
||||
#define QT_MODULE_NETWORK 0x00004
|
||||
#define QT_MODULE_OPENGL 0x00008
|
||||
#define QT_MODULE_SQL 0x00010
|
||||
#define QT_MODULE_XML 0x00020
|
||||
#define QT_MODULE_QT3SUPPORTLIGHT 0x00040
|
||||
#define QT_MODULE_QT3SUPPORT 0x00080
|
||||
#define QT_MODULE_SVG 0x00100
|
||||
#define QT_MODULE_ACTIVEQT 0x00200
|
||||
#define QT_MODULE_GRAPHICSVIEW 0x00400
|
||||
#define QT_MODULE_SCRIPT 0x00800
|
||||
#define QT_MODULE_XMLPATTERNS 0x01000
|
||||
#define QT_MODULE_HELP 0x02000
|
||||
#define QT_MODULE_TEST 0x04000
|
||||
#define QT_MODULE_DBUS 0x08000
|
||||
#define QT_MODULE_SCRIPTTOOLS 0x10000
|
||||
#define QT_MODULE_OPENVG 0x20000
|
||||
#define QT_MODULE_MULTIMEDIA 0x40000
|
||||
#define QT_MODULE_DECLARATIVE 0x80000
|
||||
#define QT_MODULE_CORE 0x000001
|
||||
#define QT_MODULE_GUI 0x000002
|
||||
#define QT_MODULE_NETWORK 0x000004
|
||||
#define QT_MODULE_OPENGL 0x000008
|
||||
#define QT_MODULE_SQL 0x000010
|
||||
#define QT_MODULE_XML 0x000020
|
||||
#define QT_MODULE_QT3SUPPORTLIGHT 0x000040
|
||||
#define QT_MODULE_QT3SUPPORT 0x000080
|
||||
#define QT_MODULE_SVG 0x000100
|
||||
#define QT_MODULE_ACTIVEQT 0x000200
|
||||
#define QT_MODULE_GRAPHICSVIEW 0x000400
|
||||
#define QT_MODULE_SCRIPT 0x000800
|
||||
#define QT_MODULE_XMLPATTERNS 0x001000
|
||||
#define QT_MODULE_HELP 0x002000
|
||||
#define QT_MODULE_TEST 0x004000
|
||||
#define QT_MODULE_DBUS 0x008000
|
||||
#define QT_MODULE_SCRIPTTOOLS 0x010000
|
||||
#define QT_MODULE_OPENVG 0x020000
|
||||
#define QT_MODULE_MULTIMEDIA 0x040000
|
||||
#define QT_MODULE_DECLARATIVE 0x080000
|
||||
#define QT_MODULE_LOCATION 0x100000
|
||||
#define QT_MODULE_SENSORS 0x200000
|
||||
|
||||
/* Qt editions */
|
||||
#define QT_EDITION_CONSOLE (QT_MODULE_CORE \
|
||||
|
|
@ -2642,6 +2664,8 @@ Q_CORE_EXPORT int qt_symbian_exception2Error(const std::exception& ex);
|
|||
| QT_MODULE_HELP \
|
||||
| QT_MODULE_TEST \
|
||||
| QT_MODULE_DBUS \
|
||||
| QT_MODULE_LOCATION \
|
||||
| QT_MODULE_SENSORS \
|
||||
| QT_MODULE_ACTIVEQT)
|
||||
#define QT_EDITION_DESKTOP (QT_EDITION_OPENSOURCE)
|
||||
#define QT_EDITION_UNIVERSAL QT_EDITION_DESKTOP
|
||||
|
|
@ -2721,6 +2745,12 @@ QT_LICENSED_MODULE(Test)
|
|||
#if (QT_EDITION & QT_MODULE_DBUS)
|
||||
QT_LICENSED_MODULE(DBus)
|
||||
#endif
|
||||
#if (QT_EDITION & QT_MODULE_LOCATION)
|
||||
QT_LICENSED_MODULE(Location)
|
||||
#endif
|
||||
#if (QT_EDITION & QT_MODULE_SENSORS)
|
||||
QT_LICENSED_MODULE(Sensors)
|
||||
#endif
|
||||
|
||||
#define QT_MODULE(x) \
|
||||
typedef QtValidLicenseFor##x##Module Qt##x##Module;
|
||||
|
|
|
|||
|
|
@ -356,6 +356,7 @@ bool QFileSystemEngine::fillMetaData(const QFileSystemEntry &entry, QFileSystemM
|
|||
const QByteArray &path = entry.nativeFilePath();
|
||||
nativeFilePath = path.constData();
|
||||
nativeFilePathLength = path.size();
|
||||
Q_UNUSED(nativeFilePathLength);
|
||||
}
|
||||
|
||||
bool entryExists = true; // innocent until proven otherwise
|
||||
|
|
@ -638,7 +639,7 @@ QFileSystemEntry QFileSystemEngine::currentPath()
|
|||
#if defined(__GLIBC__) && !defined(PATH_MAX)
|
||||
char *currentName = ::get_current_dir_name();
|
||||
if (currentName) {
|
||||
result = QFile::decodeName(QByteArray(currentName));
|
||||
result = QFileSystemEntry(QByteArray(currentName), QFileSystemEntry::FromNativePath());
|
||||
::free(currentName);
|
||||
}
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -143,55 +143,13 @@ QT_BEGIN_NAMESPACE
|
|||
|
||||
\sa QProcess, QProcess::systemEnvironment(), QProcess::setProcessEnvironment()
|
||||
*/
|
||||
#ifdef Q_OS_WIN
|
||||
static inline QProcessEnvironmentPrivate::Unit prepareName(const QString &name)
|
||||
{ return name.toUpper(); }
|
||||
static inline QProcessEnvironmentPrivate::Unit prepareName(const QByteArray &name)
|
||||
{ return QString::fromLocal8Bit(name).toUpper(); }
|
||||
static inline QString nameToString(const QProcessEnvironmentPrivate::Unit &name)
|
||||
{ return name; }
|
||||
static inline QProcessEnvironmentPrivate::Unit prepareValue(const QString &value)
|
||||
{ return value; }
|
||||
static inline QProcessEnvironmentPrivate::Unit prepareValue(const QByteArray &value)
|
||||
{ return QString::fromLocal8Bit(value); }
|
||||
static inline QString valueToString(const QProcessEnvironmentPrivate::Unit &value)
|
||||
{ return value; }
|
||||
static inline QByteArray valueToByteArray(const QProcessEnvironmentPrivate::Unit &value)
|
||||
{ return value.toLocal8Bit(); }
|
||||
#else
|
||||
static inline QProcessEnvironmentPrivate::Unit prepareName(const QByteArray &name)
|
||||
{ return name; }
|
||||
static inline QProcessEnvironmentPrivate::Unit prepareName(const QString &name)
|
||||
{ return name.toLocal8Bit(); }
|
||||
static inline QString nameToString(const QProcessEnvironmentPrivate::Unit &name)
|
||||
{ return QString::fromLocal8Bit(name); }
|
||||
static inline QProcessEnvironmentPrivate::Unit prepareValue(const QByteArray &value)
|
||||
{ return value; }
|
||||
static inline QProcessEnvironmentPrivate::Unit prepareValue(const QString &value)
|
||||
{ return value.toLocal8Bit(); }
|
||||
static inline QString valueToString(const QProcessEnvironmentPrivate::Unit &value)
|
||||
{ return QString::fromLocal8Bit(value); }
|
||||
static inline QByteArray valueToByteArray(const QProcessEnvironmentPrivate::Unit &value)
|
||||
{ return value; }
|
||||
#endif
|
||||
|
||||
template<> void QSharedDataPointer<QProcessEnvironmentPrivate>::detach()
|
||||
{
|
||||
if (d && d->ref == 1)
|
||||
return;
|
||||
QProcessEnvironmentPrivate *x = (d ? new QProcessEnvironmentPrivate(*d)
|
||||
: new QProcessEnvironmentPrivate);
|
||||
x->ref.ref();
|
||||
if (d && !d->ref.deref())
|
||||
delete d;
|
||||
d = x;
|
||||
}
|
||||
|
||||
QStringList QProcessEnvironmentPrivate::toList() const
|
||||
{
|
||||
QStringList result;
|
||||
QHash<Unit, Unit>::ConstIterator it = hash.constBegin(),
|
||||
end = hash.constEnd();
|
||||
result.reserve(hash.size());
|
||||
Hash::ConstIterator it = hash.constBegin(),
|
||||
end = hash.constEnd();
|
||||
for ( ; it != end; ++it) {
|
||||
QString data = nameToString(it.key());
|
||||
QString value = valueToString(it.value());
|
||||
|
|
@ -224,19 +182,27 @@ QProcessEnvironment QProcessEnvironmentPrivate::fromList(const QStringList &list
|
|||
QStringList QProcessEnvironmentPrivate::keys() const
|
||||
{
|
||||
QStringList result;
|
||||
QHash<Unit, Unit>::ConstIterator it = hash.constBegin(),
|
||||
end = hash.constEnd();
|
||||
result.reserve(hash.size());
|
||||
Hash::ConstIterator it = hash.constBegin(),
|
||||
end = hash.constEnd();
|
||||
for ( ; it != end; ++it)
|
||||
result << nameToString(it.key());
|
||||
return result;
|
||||
}
|
||||
|
||||
void QProcessEnvironmentPrivate::insert(const Hash &h)
|
||||
void QProcessEnvironmentPrivate::insert(const QProcessEnvironmentPrivate &other)
|
||||
{
|
||||
QHash<Unit, Unit>::ConstIterator it = h.constBegin(),
|
||||
end = h.constEnd();
|
||||
Hash::ConstIterator it = other.hash.constBegin(),
|
||||
end = other.hash.constEnd();
|
||||
for ( ; it != end; ++it)
|
||||
hash.insert(it.key(), it.value());
|
||||
|
||||
#ifdef Q_OS_UNIX
|
||||
QHash<QString, Key>::ConstIterator nit = other.nameMap.constBegin(),
|
||||
nend = other.nameMap.constEnd();
|
||||
for ( ; nit != nend; ++nit)
|
||||
nameMap.insert(nit.key(), nit.value());
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -317,6 +283,8 @@ void QProcessEnvironment::clear()
|
|||
{
|
||||
if (d)
|
||||
d->hash.clear();
|
||||
// Unix: Don't clear d->nameMap, as the environment is likely to be
|
||||
// re-populated with the same keys again.
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -331,7 +299,7 @@ void QProcessEnvironment::clear()
|
|||
*/
|
||||
bool QProcessEnvironment::contains(const QString &name) const
|
||||
{
|
||||
return d ? d->hash.contains(prepareName(name)) : false;
|
||||
return d ? d->hash.contains(d->prepareName(name)) : false;
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -353,7 +321,7 @@ bool QProcessEnvironment::contains(const QString &name) const
|
|||
void QProcessEnvironment::insert(const QString &name, const QString &value)
|
||||
{
|
||||
// d detaches from null
|
||||
d->hash.insert(prepareName(name), prepareValue(value));
|
||||
d->hash.insert(d->prepareName(name), d->prepareValue(value));
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -370,7 +338,7 @@ void QProcessEnvironment::insert(const QString &name, const QString &value)
|
|||
void QProcessEnvironment::remove(const QString &name)
|
||||
{
|
||||
if (d)
|
||||
d->hash.remove(prepareName(name));
|
||||
d->hash.remove(d->prepareName(name));
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -389,11 +357,11 @@ QString QProcessEnvironment::value(const QString &name, const QString &defaultVa
|
|||
if (!d)
|
||||
return defaultValue;
|
||||
|
||||
QProcessEnvironmentPrivate::Hash::ConstIterator it = d->hash.constFind(prepareName(name));
|
||||
QProcessEnvironmentPrivate::Hash::ConstIterator it = d->hash.constFind(d->prepareName(name));
|
||||
if (it == d->hash.constEnd())
|
||||
return defaultValue;
|
||||
|
||||
return valueToString(it.value());
|
||||
return d->valueToString(it.value());
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -438,7 +406,7 @@ void QProcessEnvironment::insert(const QProcessEnvironment &e)
|
|||
return;
|
||||
|
||||
// d detaches from null
|
||||
d->insert(e.d->hash);
|
||||
d->insert(*e.d);
|
||||
}
|
||||
|
||||
void QProcessPrivate::Channel::clear()
|
||||
|
|
@ -2321,6 +2289,8 @@ QStringList QProcess::systemEnvironment()
|
|||
}
|
||||
|
||||
/*!
|
||||
\fn QProcessEnvironment QProcessEnvironment::systemEnvironment()
|
||||
|
||||
\since 4.6
|
||||
|
||||
\brief The systemEnvironment function returns the environment of
|
||||
|
|
@ -2336,21 +2306,6 @@ QStringList QProcess::systemEnvironment()
|
|||
|
||||
\sa QProcess::systemEnvironment()
|
||||
*/
|
||||
QProcessEnvironment QProcessEnvironment::systemEnvironment()
|
||||
{
|
||||
QProcessEnvironment env;
|
||||
const char *entry;
|
||||
for (int count = 0; (entry = environ[count]); ++count) {
|
||||
const char *equal = strchr(entry, '=');
|
||||
if (!equal)
|
||||
continue;
|
||||
|
||||
QByteArray name(entry, equal - entry);
|
||||
QByteArray value(equal + 1);
|
||||
env.insert(QString::fromLocal8Bit(name), QString::fromLocal8Bit(value));
|
||||
}
|
||||
return env;
|
||||
}
|
||||
|
||||
/*!
|
||||
\typedef Q_PID
|
||||
|
|
|
|||
|
|
@ -81,23 +81,119 @@ class QTimer;
|
|||
class RProcess;
|
||||
#endif
|
||||
|
||||
#ifdef Q_OS_WIN
|
||||
class QProcEnvKey : public QString
|
||||
{
|
||||
public:
|
||||
QProcEnvKey() {}
|
||||
explicit QProcEnvKey(const QString &other) : QString(other) {}
|
||||
QProcEnvKey(const QProcEnvKey &other) : QString(other) {}
|
||||
bool operator==(const QProcEnvKey &other) const { return !compare(other, Qt::CaseInsensitive); }
|
||||
};
|
||||
inline uint qHash(const QProcEnvKey &key) { return qHash(key.toCaseFolded()); }
|
||||
|
||||
typedef QString QProcEnvValue;
|
||||
#else
|
||||
class QProcEnvKey
|
||||
{
|
||||
public:
|
||||
QProcEnvKey() : hash(0) {}
|
||||
explicit QProcEnvKey(const QByteArray &other) : key(other), hash(qHash(key)) {}
|
||||
QProcEnvKey(const QProcEnvKey &other) { *this = other; }
|
||||
bool operator==(const QProcEnvKey &other) const { return key == other.key; }
|
||||
|
||||
QByteArray key;
|
||||
uint hash;
|
||||
};
|
||||
inline uint qHash(const QProcEnvKey &key) { return key.hash; }
|
||||
|
||||
class QProcEnvValue
|
||||
{
|
||||
public:
|
||||
QProcEnvValue() {}
|
||||
QProcEnvValue(const QProcEnvValue &other) { *this = other; }
|
||||
explicit QProcEnvValue(const QString &value) : stringValue(value) {}
|
||||
explicit QProcEnvValue(const QByteArray &value) : byteValue(value) {}
|
||||
bool operator==(const QProcEnvValue &other) const
|
||||
{
|
||||
return byteValue.isEmpty() && other.byteValue.isEmpty()
|
||||
? stringValue == other.stringValue
|
||||
: bytes() == other.bytes();
|
||||
}
|
||||
QByteArray bytes() const
|
||||
{
|
||||
if (byteValue.isEmpty() && !stringValue.isEmpty())
|
||||
byteValue = stringValue.toLocal8Bit();
|
||||
return byteValue;
|
||||
}
|
||||
QString string() const
|
||||
{
|
||||
if (stringValue.isEmpty() && !byteValue.isEmpty())
|
||||
stringValue = QString::fromLocal8Bit(byteValue);
|
||||
return stringValue;
|
||||
}
|
||||
|
||||
mutable QByteArray byteValue;
|
||||
mutable QString stringValue;
|
||||
};
|
||||
Q_DECLARE_TYPEINFO(QProcEnvValue, Q_MOVABLE_TYPE);
|
||||
#endif
|
||||
Q_DECLARE_TYPEINFO(QProcEnvKey, Q_MOVABLE_TYPE);
|
||||
|
||||
class QProcessEnvironmentPrivate: public QSharedData
|
||||
{
|
||||
public:
|
||||
typedef QProcEnvKey Key;
|
||||
typedef QProcEnvValue Value;
|
||||
#ifdef Q_OS_WIN
|
||||
typedef QString Unit;
|
||||
inline Key prepareName(const QString &name) const { return Key(name); }
|
||||
inline QString nameToString(const Key &name) const { return name; }
|
||||
inline Value prepareValue(const QString &value) const { return value; }
|
||||
inline QString valueToString(const Value &value) const { return value; }
|
||||
#else
|
||||
typedef QByteArray Unit;
|
||||
inline Key prepareName(const QString &name) const
|
||||
{
|
||||
Key &ent = nameMap[name];
|
||||
if (ent.key.isEmpty())
|
||||
ent = Key(name.toLocal8Bit());
|
||||
return ent;
|
||||
}
|
||||
inline QString nameToString(const Key &name) const
|
||||
{
|
||||
const QString sname = QString::fromLocal8Bit(name.key);
|
||||
nameMap[sname] = name;
|
||||
return sname;
|
||||
}
|
||||
inline Value prepareValue(const QString &value) const { return Value(value); }
|
||||
inline QString valueToString(const Value &value) const { return value.string(); }
|
||||
#endif
|
||||
typedef QHash<Unit, Unit> Hash;
|
||||
|
||||
typedef QHash<Key, Value> Hash;
|
||||
Hash hash;
|
||||
|
||||
#ifdef Q_OS_UNIX
|
||||
typedef QHash<QString, Key> NameHash;
|
||||
mutable NameHash nameMap;
|
||||
#endif
|
||||
|
||||
static QProcessEnvironment fromList(const QStringList &list);
|
||||
QStringList toList() const;
|
||||
QStringList keys() const;
|
||||
void insert(const Hash &hash);
|
||||
void insert(const QProcessEnvironmentPrivate &other);
|
||||
};
|
||||
|
||||
template<> Q_INLINE_TEMPLATE void QSharedDataPointer<QProcessEnvironmentPrivate>::detach()
|
||||
{
|
||||
if (d && d->ref == 1)
|
||||
return;
|
||||
QProcessEnvironmentPrivate *x = (d ? new QProcessEnvironmentPrivate(*d)
|
||||
: new QProcessEnvironmentPrivate);
|
||||
x->ref.ref();
|
||||
if (d && !d->ref.deref())
|
||||
delete d;
|
||||
d = x;
|
||||
}
|
||||
|
||||
class QProcessPrivate : public QIODevicePrivate
|
||||
{
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -1062,6 +1062,11 @@ void QProcessPrivate::initializeProcessManager()
|
|||
(void) processManager();
|
||||
}
|
||||
|
||||
QProcessEnvironment QProcessEnvironment::systemEnvironment()
|
||||
{
|
||||
return QProcessEnvironment();
|
||||
}
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
#endif // QT_NO_PROCESS
|
||||
|
|
|
|||
|
|
@ -467,7 +467,35 @@ bool QProcessPrivate::createChannel(Channel &channel)
|
|||
}
|
||||
}
|
||||
|
||||
static char **_q_dupEnvironment(const QHash<QByteArray, QByteArray> &environment, int *envc)
|
||||
QT_BEGIN_INCLUDE_NAMESPACE
|
||||
#if defined(Q_OS_MAC) && !defined(QT_NO_CORESERVICES)
|
||||
# include <crt_externs.h>
|
||||
# define environ (*_NSGetEnviron())
|
||||
#else
|
||||
extern char **environ;
|
||||
#endif
|
||||
QT_END_INCLUDE_NAMESPACE
|
||||
|
||||
QProcessEnvironment QProcessEnvironment::systemEnvironment()
|
||||
{
|
||||
QProcessEnvironment env;
|
||||
#if !defined(Q_OS_MAC) || !defined(QT_NO_CORESERVICES)
|
||||
const char *entry;
|
||||
for (int count = 0; (entry = environ[count]); ++count) {
|
||||
const char *equal = strchr(entry, '=');
|
||||
if (!equal)
|
||||
continue;
|
||||
|
||||
QByteArray name(entry, equal - entry);
|
||||
QByteArray value(equal + 1);
|
||||
env.d->hash.insert(QProcessEnvironmentPrivate::Key(name),
|
||||
QProcessEnvironmentPrivate::Value(value));
|
||||
}
|
||||
#endif
|
||||
return env;
|
||||
}
|
||||
|
||||
static char **_q_dupEnvironment(const QProcessEnvironmentPrivate::Hash &environment, int *envc)
|
||||
{
|
||||
*envc = 0;
|
||||
if (environment.isEmpty())
|
||||
|
|
@ -483,17 +511,17 @@ static char **_q_dupEnvironment(const QHash<QByteArray, QByteArray> &environment
|
|||
#endif
|
||||
const QByteArray envLibraryPath = qgetenv(libraryPath);
|
||||
bool needToAddLibraryPath = !envLibraryPath.isEmpty() &&
|
||||
!environment.contains(libraryPath);
|
||||
!environment.contains(QProcessEnvironmentPrivate::Key(QByteArray(libraryPath)));
|
||||
|
||||
char **envp = new char *[environment.count() + 2];
|
||||
envp[environment.count()] = 0;
|
||||
envp[environment.count() + 1] = 0;
|
||||
|
||||
QHash<QByteArray, QByteArray>::ConstIterator it = environment.constBegin();
|
||||
const QHash<QByteArray, QByteArray>::ConstIterator end = environment.constEnd();
|
||||
QProcessEnvironmentPrivate::Hash::ConstIterator it = environment.constBegin();
|
||||
const QProcessEnvironmentPrivate::Hash::ConstIterator end = environment.constEnd();
|
||||
for ( ; it != end; ++it) {
|
||||
QByteArray key = it.key();
|
||||
QByteArray value = it.value();
|
||||
QByteArray key = it.key().key;
|
||||
QByteArray value = it.value().bytes();
|
||||
key.reserve(key.length() + 1 + value.length());
|
||||
key.append('=');
|
||||
key.append(value);
|
||||
|
|
|
|||
|
|
@ -278,29 +278,55 @@ static QString qt_create_commandline(const QString &program, const QStringList &
|
|||
return args;
|
||||
}
|
||||
|
||||
static QByteArray qt_create_environment(const QHash<QString, QString> &environment)
|
||||
QProcessEnvironment QProcessEnvironment::systemEnvironment()
|
||||
{
|
||||
QProcessEnvironment env;
|
||||
#if !defined(Q_OS_WINCE)
|
||||
// Calls to setenv() affect the low-level environment as well.
|
||||
// This is not the case the other way round.
|
||||
if (wchar_t *envStrings = GetEnvironmentStringsW()) {
|
||||
for (const wchar_t *entry = envStrings; *entry; ) {
|
||||
int entryLen = wcslen(entry);
|
||||
if (const wchar_t *equal = wcschr(entry, L'=')) {
|
||||
int nameLen = equal - entry;
|
||||
QString name = QString::fromWCharArray(entry, nameLen);
|
||||
QString value = QString::fromWCharArray(equal + 1, entryLen - nameLen - 1);
|
||||
env.d->hash.insert(QProcessEnvironmentPrivate::Key(name), value);
|
||||
}
|
||||
entry += entryLen + 1;
|
||||
}
|
||||
FreeEnvironmentStringsW(envStrings);
|
||||
}
|
||||
#endif
|
||||
return env;
|
||||
}
|
||||
|
||||
#if !defined(Q_OS_WINCE)
|
||||
static QByteArray qt_create_environment(const QProcessEnvironmentPrivate::Hash &environment)
|
||||
{
|
||||
QByteArray envlist;
|
||||
if (!environment.isEmpty()) {
|
||||
QHash<QString, QString> copy = environment;
|
||||
QProcessEnvironmentPrivate::Hash copy = environment;
|
||||
|
||||
// add PATH if necessary (for DLL loading)
|
||||
if (!copy.contains(QLatin1String("PATH"))) {
|
||||
QProcessEnvironmentPrivate::Key pathKey(QLatin1String("PATH"));
|
||||
if (!copy.contains(pathKey)) {
|
||||
QByteArray path = qgetenv("PATH");
|
||||
if (!path.isEmpty())
|
||||
copy.insert(QLatin1String("PATH"), QString::fromLocal8Bit(path));
|
||||
copy.insert(pathKey, QString::fromLocal8Bit(path));
|
||||
}
|
||||
|
||||
// add systemroot if needed
|
||||
if (!copy.contains(QLatin1String("SYSTEMROOT"))) {
|
||||
QByteArray systemRoot = qgetenv("SYSTEMROOT");
|
||||
QProcessEnvironmentPrivate::Key rootKey(QLatin1String("SystemRoot"));
|
||||
if (!copy.contains(rootKey)) {
|
||||
QByteArray systemRoot = qgetenv("SystemRoot");
|
||||
if (!systemRoot.isEmpty())
|
||||
copy.insert(QLatin1String("SYSTEMROOT"), QString::fromLocal8Bit(systemRoot));
|
||||
copy.insert(rootKey, QString::fromLocal8Bit(systemRoot));
|
||||
}
|
||||
|
||||
int pos = 0;
|
||||
QHash<QString, QString>::ConstIterator it = copy.constBegin(),
|
||||
end = copy.constEnd();
|
||||
QProcessEnvironmentPrivate::Hash::ConstIterator it = copy.constBegin(),
|
||||
end = copy.constEnd();
|
||||
|
||||
static const wchar_t equal = L'=';
|
||||
static const wchar_t nul = L'\0';
|
||||
|
|
@ -335,6 +361,7 @@ static QByteArray qt_create_environment(const QHash<QString, QString> &environme
|
|||
}
|
||||
return envlist;
|
||||
}
|
||||
#endif
|
||||
|
||||
void QProcessPrivate::startProcess()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -981,23 +981,6 @@ QStringList QSettingsPrivate::splitArgs(const QString &s, int idx)
|
|||
// ************************************************************************
|
||||
// QConfFileSettingsPrivate
|
||||
|
||||
/*
|
||||
If we don't have the permission to read the file, returns false.
|
||||
If the file doesn't exist, returns true.
|
||||
*/
|
||||
static bool checkAccess(const QString &name)
|
||||
{
|
||||
QFileInfo fileInfo(name);
|
||||
|
||||
if (fileInfo.exists()) {
|
||||
QFile file(name);
|
||||
// if the file exists but we can't open it, report an error
|
||||
return file.open(QFile::ReadOnly);
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
void QConfFileSettingsPrivate::initFormat()
|
||||
{
|
||||
extension = (format == QSettings::NativeFormat) ? QLatin1String(".conf") : QLatin1String(".ini");
|
||||
|
|
@ -1026,18 +1009,13 @@ void QConfFileSettingsPrivate::initFormat()
|
|||
|
||||
void QConfFileSettingsPrivate::initAccess()
|
||||
{
|
||||
bool readAccess = false;
|
||||
if (confFiles[spec]) {
|
||||
readAccess = checkAccess(confFiles[spec]->name);
|
||||
if (format > QSettings::IniFormat) {
|
||||
if (!readFunc)
|
||||
readAccess = false;
|
||||
setStatus(QSettings::AccessError);
|
||||
}
|
||||
}
|
||||
|
||||
if (!readAccess)
|
||||
setStatus(QSettings::AccessError);
|
||||
|
||||
sync(); // loads the files the first time
|
||||
}
|
||||
|
||||
|
|
@ -1432,7 +1410,7 @@ void QConfFileSettingsPrivate::syncConfFile(int confFileNo)
|
|||
We can often optimize the read-only case, if the file on disk
|
||||
hasn't changed.
|
||||
*/
|
||||
if (readOnly) {
|
||||
if (readOnly && confFile->size > 0) {
|
||||
QFileInfo fileInfo(confFile->name);
|
||||
if (confFile->size == fileInfo.size() && confFile->timeStamp == fileInfo.lastModified())
|
||||
return;
|
||||
|
|
@ -1455,6 +1433,9 @@ void QConfFileSettingsPrivate::syncConfFile(int confFileNo)
|
|||
if (!file.isOpen())
|
||||
file.open(QFile::ReadOnly);
|
||||
|
||||
if (!createFile && !file.isOpen())
|
||||
setStatus(QSettings::AccessError);
|
||||
|
||||
#ifdef Q_OS_WIN
|
||||
HANDLE readSemaphore = 0;
|
||||
HANDLE writeSemaphore = 0;
|
||||
|
|
|
|||
|
|
@ -270,6 +270,17 @@ bool QCoreApplicationPrivate::is_app_closing = false;
|
|||
Q_CORE_EXPORT bool qt_locale_initialized = false;
|
||||
|
||||
|
||||
/*
|
||||
Create an instance of Trolltech.conf. This ensures that the settings will not
|
||||
be thrown out of QSetting's cache for unused settings.
|
||||
*/
|
||||
Q_GLOBAL_STATIC_WITH_ARGS(QSettings, staticTrolltechConf, (QSettings::UserScope, QLatin1String("Trolltech")))
|
||||
|
||||
QSettings *QCoreApplicationPrivate::trolltechConf()
|
||||
{
|
||||
return staticTrolltechConf();
|
||||
}
|
||||
|
||||
Q_CORE_EXPORT uint qGlobalPostedEventsCount()
|
||||
{
|
||||
QThreadData *currentThreadData = QThreadData::current();
|
||||
|
|
|
|||
|
|
@ -55,6 +55,7 @@
|
|||
|
||||
#include "QtCore/qcoreapplication.h"
|
||||
#include "QtCore/qtranslator.h"
|
||||
#include "QtCore/qsettings.h"
|
||||
#include "private/qobject_p.h"
|
||||
|
||||
#ifdef Q_OS_SYMBIAN
|
||||
|
|
@ -141,6 +142,7 @@ public:
|
|||
#if defined(QT3_SUPPORT)
|
||||
static bool useQt3Support;
|
||||
#endif
|
||||
static QSettings *trolltechConf();
|
||||
};
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
|
|
|||
|
|
@ -52,6 +52,7 @@
|
|||
#include <qmap.h>
|
||||
#include <qsettings.h>
|
||||
#include <qdatetime.h>
|
||||
#include <private/qcoreapplication_p.h>
|
||||
#ifdef Q_OS_MAC
|
||||
# include <private/qcore_mac_p.h>
|
||||
#endif
|
||||
|
|
@ -408,12 +409,6 @@ static bool qt_unix_query(const QString &library, uint *version, bool *debug, QB
|
|||
typedef QMap<QString, QLibraryPrivate*> LibraryMap;
|
||||
|
||||
struct LibraryData {
|
||||
LibraryData() : settings(0) { }
|
||||
~LibraryData() {
|
||||
delete settings;
|
||||
}
|
||||
|
||||
QSettings *settings;
|
||||
LibraryMap libraryMap;
|
||||
QSet<QLibraryPrivate*> loadedLibs;
|
||||
};
|
||||
|
|
@ -711,11 +706,7 @@ bool QLibraryPrivate::isPlugin(QSettings *settings)
|
|||
QStringList reg;
|
||||
#ifndef QT_NO_SETTINGS
|
||||
if (!settings) {
|
||||
settings = libraryData()->settings;
|
||||
if (!settings) {
|
||||
settings = new QSettings(QSettings::UserScope, QLatin1String("Trolltech"));
|
||||
libraryData()->settings = settings;
|
||||
}
|
||||
settings = QCoreApplicationPrivate::trolltechConf();
|
||||
}
|
||||
reg = settings->value(regkey).toStringList();
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -107,18 +107,21 @@ bool QMutexPrivate::wait(int timeout)
|
|||
// lock acquired without waiting
|
||||
return true;
|
||||
}
|
||||
bool returnValue;
|
||||
kern_return_t r;
|
||||
if (timeout < 0) {
|
||||
returnValue = semaphore_wait(mach_semaphore) == KERN_SUCCESS;
|
||||
do {
|
||||
r = semaphore_wait(mach_semaphore);
|
||||
} while (r == KERN_ABORTED);
|
||||
if (r != KERN_SUCCESS)
|
||||
qWarning("QMutex: infinite wait failed, error %d", r);
|
||||
} else {
|
||||
mach_timespec_t ts;
|
||||
ts.tv_nsec = ((timeout % 1000) * 1000) * 1000;
|
||||
ts.tv_sec = (timeout / 1000);
|
||||
kern_return_t r = semaphore_timedwait(mach_semaphore, ts);
|
||||
returnValue = r == KERN_SUCCESS;
|
||||
r = semaphore_timedwait(mach_semaphore, ts);
|
||||
}
|
||||
contenders.deref();
|
||||
return returnValue;
|
||||
return r == KERN_SUCCESS;
|
||||
}
|
||||
|
||||
void QMutexPrivate::wakeUp()
|
||||
|
|
|
|||
|
|
@ -329,6 +329,8 @@ void *QThreadPrivate::start(void *arg)
|
|||
data->quitNow = thr->d_func()->exited;
|
||||
}
|
||||
|
||||
CTrapCleanup *cleanup = CTrapCleanup::New();
|
||||
|
||||
// ### TODO: allow the user to create a custom event dispatcher
|
||||
createEventDispatcher(data);
|
||||
|
||||
|
|
@ -337,6 +339,8 @@ void *QThreadPrivate::start(void *arg)
|
|||
|
||||
QThreadPrivate::finish(arg);
|
||||
|
||||
delete cleanup;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -300,7 +300,7 @@ void QThreadPrivate::createEventDispatcher(QThreadData *data)
|
|||
|
||||
#ifndef QT_NO_THREAD
|
||||
|
||||
unsigned int __stdcall QThreadPrivate::start(void *arg)
|
||||
unsigned int __stdcall QT_ENSURE_STACK_ALIGNED_FOR_SSE QThreadPrivate::start(void *arg)
|
||||
{
|
||||
QThread *thr = reinterpret_cast<QThread *>(arg);
|
||||
QThreadData *data = QThreadData::get2(thr);
|
||||
|
|
|
|||
|
|
@ -2460,7 +2460,11 @@ void QDateTime::setTime_t(uint secsSince1Jan1970UTC)
|
|||
|
||||
If the \a format is Qt::ISODate, the string format corresponds
|
||||
to the ISO 8601 extended specification for representations of
|
||||
dates and times, taking the form YYYY-MM-DDTHH:MM:SS.
|
||||
dates and times, taking the form YYYY-MM-DDTHH:MM:SS[Z|[+|-]HH:MM],
|
||||
depending on the timeSpec() of the QDateTime. If the timeSpec()
|
||||
is Qt::UTC, Z will be appended to the string; if the timeSpec() is
|
||||
Qt::OffsetFromUTC the offset in hours and minutes from UTC will
|
||||
be appended to the string.
|
||||
|
||||
If the \a format is Qt::SystemLocaleShortDate or
|
||||
Qt::SystemLocaleLongDate, the string format depends on the locale
|
||||
|
|
@ -2497,6 +2501,21 @@ QString QDateTime::toString(Qt::DateFormat f) const
|
|||
return QString(); // failed to convert
|
||||
buf += QLatin1Char('T');
|
||||
buf += d->time.toString(Qt::ISODate);
|
||||
switch (d->spec) {
|
||||
case QDateTimePrivate::UTC:
|
||||
buf += QLatin1Char('Z');
|
||||
break;
|
||||
case QDateTimePrivate::OffsetFromUTC: {
|
||||
int sign = d->utcOffset >= 0 ? 1: -1;
|
||||
buf += QString::fromLatin1("%1%2:%3").
|
||||
arg(sign == 1 ? QLatin1Char('+') : QLatin1Char('-')).
|
||||
arg(d->utcOffset * sign / SECS_PER_HOUR, 2, 10, QLatin1Char('0')).
|
||||
arg((d->utcOffset / 60) % 60, 2, 10, QLatin1Char('0'));
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
#ifndef QT_NO_TEXTDATE
|
||||
else if (f == Qt::TextDate) {
|
||||
|
|
|
|||
|
|
@ -95,7 +95,7 @@ qint64 QElapsedTimer::restart()
|
|||
qint64 oldt1 = t1;
|
||||
t1 = getMicrosecondFromTick();
|
||||
t2 = 0;
|
||||
return t1 - oldt1;
|
||||
return (t1 - oldt1) / 1000;
|
||||
}
|
||||
|
||||
qint64 QElapsedTimer::nsecsElapsed() const
|
||||
|
|
|
|||
|
|
@ -2782,8 +2782,6 @@ bool QLocalePrivate::numberToCLocale(const QString &num,
|
|||
if (idx == l)
|
||||
return false;
|
||||
|
||||
const QChar _group = group();
|
||||
|
||||
while (idx < l) {
|
||||
const QChar &in = uc[idx];
|
||||
|
||||
|
|
|
|||
|
|
@ -44,6 +44,7 @@
|
|||
#include <QTime>
|
||||
#include <QVariant>
|
||||
#include <QThread>
|
||||
#include <QStringList>
|
||||
|
||||
#include <e32std.h>
|
||||
#include <e32const.h>
|
||||
|
|
@ -86,6 +87,7 @@ static TPtrC defaultFormatSpec(TExtendedLocale&)
|
|||
struct symbianToISO {
|
||||
int symbian_language;
|
||||
char iso_name[8];
|
||||
char uilanguage[8];
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -94,77 +96,80 @@ struct symbianToISO {
|
|||
NOTE: This array should be sorted by the first column!
|
||||
*/
|
||||
static const symbianToISO symbian_to_iso_list[] = {
|
||||
{ ELangEnglish, "en_GB" }, // 1
|
||||
{ ELangFrench, "fr_FR" }, // 2
|
||||
{ ELangGerman, "de_DE" }, // 3
|
||||
{ ELangSpanish, "es_ES" }, // 4
|
||||
{ ELangItalian, "it_IT" }, // 5
|
||||
{ ELangSwedish, "sv_SE" }, // 6
|
||||
{ ELangDanish, "da_DK" }, // 7
|
||||
{ ELangNorwegian, "no_NO" }, // 8
|
||||
{ ELangFinnish, "fi_FI" }, // 9
|
||||
{ ELangAmerican, "en_US" }, // 10
|
||||
{ ELangPortuguese, "pt_PT" }, // 13
|
||||
{ ELangTurkish, "tr_TR" }, // 14
|
||||
{ ELangIcelandic, "is_IS" }, // 15
|
||||
{ ELangRussian, "ru_RU" }, // 16
|
||||
{ ELangHungarian, "hu_HU" }, // 17
|
||||
{ ELangDutch, "nl_NL" }, // 18
|
||||
{ ELangBelgianFlemish, "nl_BE" }, // 19
|
||||
{ ELangCzech, "cs_CZ" }, // 25
|
||||
{ ELangSlovak, "sk_SK" }, // 26
|
||||
{ ELangPolish, "pl_PL" }, // 27
|
||||
{ ELangSlovenian, "sl_SI" }, // 28
|
||||
{ ELangTaiwanChinese, "zh_TW" }, // 29
|
||||
{ ELangHongKongChinese, "zh_HK" }, // 30
|
||||
{ ELangPrcChinese, "zh_CN" }, // 31
|
||||
{ ELangJapanese, "ja_JP" }, // 32
|
||||
{ ELangThai, "th_TH" }, // 33
|
||||
{ ELangArabic, "ar_AE" }, // 37
|
||||
{ ELangTagalog, "tl_PH" }, // 39
|
||||
{ ELangBulgarian, "bg_BG" }, // 42
|
||||
{ ELangCatalan, "ca_ES" }, // 44
|
||||
{ ELangCroatian, "hr_HR" }, // 45
|
||||
{ ELangEstonian, "et_EE" }, // 49
|
||||
{ ELangFarsi, "fa_IR" }, // 50
|
||||
{ ELangCanadianFrench, "fr_CA" }, // 51
|
||||
{ ELangGreek, "el_GR" }, // 54
|
||||
{ ELangHebrew, "he_IL" }, // 57
|
||||
{ ELangHindi, "hi_IN" }, // 58
|
||||
{ ELangIndonesian, "id_ID" }, // 59
|
||||
{ ELangKorean, "ko_KO" }, // 65
|
||||
{ ELangLatvian, "lv_LV" }, // 67
|
||||
{ ELangLithuanian, "lt_LT" }, // 68
|
||||
{ ELangMalay, "ms_MY" }, // 70
|
||||
{ ELangNorwegianNynorsk, "nn_NO" }, // 75
|
||||
{ ELangBrazilianPortuguese, "pt_BR" }, // 76
|
||||
{ ELangRomanian, "ro_RO" }, // 78
|
||||
{ ELangSerbian, "sr_RS" }, // 79
|
||||
{ ELangLatinAmericanSpanish,"es_419" }, // 83
|
||||
{ ELangUkrainian, "uk_UA" }, // 93
|
||||
{ ELangUrdu, "ur_PK" }, // 94 - India/Pakistan
|
||||
{ ELangVietnamese, "vi_VN" }, // 96
|
||||
{ ELangEnglish, "en_GB", "en" }, // 1
|
||||
{ ELangFrench, "fr_FR", "fr" }, // 2
|
||||
{ ELangGerman, "de_DE", "de" }, // 3
|
||||
{ ELangSpanish, "es_ES", "es" }, // 4
|
||||
{ ELangItalian, "it_IT", "it" }, // 5
|
||||
{ ELangSwedish, "sv_SE", "sv" }, // 6
|
||||
{ ELangDanish, "da_DK", "da" }, // 7
|
||||
{ ELangNorwegian, "nb_NO", "nb" }, // 8
|
||||
{ ELangFinnish, "fi_FI", "fi" }, // 9
|
||||
{ ELangAmerican, "en_US", "en-US" }, // 10
|
||||
{ ELangPortuguese, "pt_PT", "pt" }, // 13
|
||||
{ ELangTurkish, "tr_TR", "tr" }, // 14
|
||||
{ ELangIcelandic, "is_IS", "is" }, // 15
|
||||
{ ELangRussian, "ru_RU", "ru" }, // 16
|
||||
{ ELangHungarian, "hu_HU", "hu" }, // 17
|
||||
{ ELangDutch, "nl_NL", "nl" }, // 18
|
||||
{ ELangCzech, "cs_CZ", "cs" }, // 25
|
||||
{ ELangSlovak, "sk_SK", "sk" }, // 26
|
||||
{ ELangPolish, "pl_PL", "pl" }, // 27
|
||||
{ ELangSlovenian, "sl_SI", "sl" }, // 28
|
||||
{ ELangTaiwanChinese, "zh_TW", "zh-TW" }, // 29
|
||||
{ ELangHongKongChinese, "zh_HK", "zh-HK" }, // 30
|
||||
{ ELangPrcChinese, "zh_CN", "zh" }, // 31
|
||||
{ ELangJapanese, "ja_JP", "ja" }, // 32
|
||||
{ ELangThai, "th_TH", "th" }, // 33
|
||||
{ ELangArabic, "ar_AE", "ar" }, // 37
|
||||
{ ELangTagalog, "tl_PH", "tl" }, // 39
|
||||
{ ELangBulgarian, "bg_BG", "bg" }, // 42
|
||||
{ ELangCatalan, "ca_ES", "ca" }, // 44
|
||||
{ ELangCroatian, "hr_HR", "hr" }, // 45
|
||||
{ ELangEstonian, "et_EE", "et" }, // 49
|
||||
{ ELangFarsi, "fa_IR", "fa" }, // 50
|
||||
{ ELangCanadianFrench, "fr_CA", "fr-CA" }, // 51
|
||||
{ ELangGreek, "el_GR", "el" }, // 54
|
||||
{ ELangHebrew, "he_IL", "he" }, // 57
|
||||
{ ELangHindi, "hi_IN", "hi" }, // 58
|
||||
{ ELangIndonesian, "id_ID", "id" }, // 59
|
||||
{ 63/*ELangKazakh*/, "kk_KZ", "kk" }, // 63
|
||||
{ ELangKorean, "ko_KO", "ko" }, // 65
|
||||
{ ELangLatvian, "lv_LV", "lv" }, // 67
|
||||
{ ELangLithuanian, "lt_LT", "lt" }, // 68
|
||||
{ ELangMalay, "ms_MY", "ms" }, // 70
|
||||
{ ELangNorwegianNynorsk, "nn_NO", "nn" }, // 75
|
||||
{ ELangBrazilianPortuguese, "pt_BR", "pt-BR" }, // 76
|
||||
{ ELangRomanian, "ro_RO", "ro" }, // 78
|
||||
{ ELangSerbian, "sr_RS", "sr" }, // 79
|
||||
{ ELangLatinAmericanSpanish,"es_419", "es-419" },// 83
|
||||
{ ELangUkrainian, "uk_UA", "uk" }, // 93
|
||||
{ ELangUrdu, "ur_PK", "ur" }, // 94 - India/Pakistan
|
||||
{ ELangVietnamese, "vi_VN", "vi" }, // 96
|
||||
#ifdef __E32LANG_H__
|
||||
// 5.0
|
||||
{ ELangBasque, "eu_ES" }, // 102
|
||||
{ ELangGalician, "gl_ES" }, // 103
|
||||
{ ELangBasque, "eu_ES", "eu" }, // 102
|
||||
{ ELangGalician, "gl_ES", "gl" }, // 103
|
||||
#endif
|
||||
#if !defined(__SERIES60_31__)
|
||||
{ ELangEnglish_Apac, "en" }, // 129
|
||||
{ ELangEnglish_Taiwan, "en_TW" }, // 157 ### Not supported by CLDR
|
||||
{ ELangEnglish_HongKong, "en_HK" }, // 158
|
||||
{ ELangEnglish_Prc, "en_CN" }, // 159 ### Not supported by CLDR
|
||||
{ ELangEnglish_Japan, "en_JP"}, // 160 ### Not supported by CLDR
|
||||
{ ELangEnglish_Thailand, "en_TH" }, // 161 ### Not supported by CLDR
|
||||
{ ELangMalay_Apac, "ms" }, // 326
|
||||
{ ELangEnglish_Apac, "en_GB", "en" }, // 129
|
||||
{ ELangEnglish_Taiwan, "en_TW", "en-TW" }, // 157 ### Not supported by CLDR
|
||||
{ ELangEnglish_HongKong, "en_HK", "en-HK" }, // 158
|
||||
{ ELangEnglish_Prc, "en_CN", "en-CN" }, // 159 ### Not supported by CLDR
|
||||
{ ELangEnglish_Japan, "en_JP", "en" }, // 160 ### Not supported by CLDR
|
||||
{ ELangEnglish_Thailand, "en_TH", "en" }, // 161 ### Not supported by CLDR
|
||||
{ 230/*ELangEnglish_India*/,"en_IN", "en" }, // 230
|
||||
{ ELangMalay_Apac, "ms_MY", "ms" }, // 326
|
||||
#endif
|
||||
{ 327/*ELangIndonesian_Apac*/,"id_ID" } // 327 - appeared in Symbian^3
|
||||
{ 327/*ELangIndonesian_Apac*/, "id_ID", "id" } // 327 - appeared in Symbian^3
|
||||
};
|
||||
|
||||
/*!
|
||||
Returns ISO name corresponding to the Symbian locale code \a sys_fmt.
|
||||
*/
|
||||
QByteArray qt_symbianLocaleName(int code)
|
||||
enum LocaleNameType {
|
||||
ISO,
|
||||
UILanguage
|
||||
};
|
||||
|
||||
QByteArray qt_resolveSymbianLocaleName(int code, LocaleNameType type)
|
||||
{
|
||||
//Number of Symbian to ISO locale mappings
|
||||
static const int symbian_to_iso_count
|
||||
|
|
@ -174,8 +179,11 @@ QByteArray qt_symbianLocaleName(int code)
|
|||
if (cmp < 0)
|
||||
return 0;
|
||||
|
||||
if (cmp == 0)
|
||||
return symbian_to_iso_list[0].iso_name;
|
||||
if (cmp == 0) {
|
||||
if (type == ISO)
|
||||
return symbian_to_iso_list[0].iso_name;
|
||||
return symbian_to_iso_list[0].uilanguage;
|
||||
}
|
||||
|
||||
int begin = 0;
|
||||
int end = symbian_to_iso_count;
|
||||
|
|
@ -185,17 +193,27 @@ QByteArray qt_symbianLocaleName(int code)
|
|||
|
||||
const symbianToISO *elt = symbian_to_iso_list + mid;
|
||||
int cmp = code - elt->symbian_language;
|
||||
if (cmp < 0)
|
||||
if (cmp < 0) {
|
||||
end = mid;
|
||||
else if (cmp > 0)
|
||||
} else if (cmp > 0) {
|
||||
begin = mid;
|
||||
else
|
||||
return elt->iso_name;
|
||||
} else {
|
||||
if (type == ISO)
|
||||
return elt->iso_name;
|
||||
return elt->uilanguage;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns ISO name corresponding to the Symbian locale code \a sys_fmt.
|
||||
*/
|
||||
QByteArray qt_symbianLocaleName(int code)
|
||||
{
|
||||
return qt_resolveSymbianLocaleName(code, ISO);
|
||||
}
|
||||
|
||||
// order is: normal, abbr, nmode, nmode+abbr
|
||||
static const char *us_locale_dep[] = {
|
||||
|
|
@ -822,6 +840,13 @@ QLocale QSystemLocale::fallbackLocale() const
|
|||
return QLocale(locale);
|
||||
}
|
||||
|
||||
static QStringList symbianUILanguages()
|
||||
{
|
||||
TLanguage lang = User::Language();
|
||||
QString s = QLatin1String(qt_resolveSymbianLocaleName(lang, UILanguage));
|
||||
return QStringList(s);
|
||||
}
|
||||
|
||||
QVariant QSystemLocale::query(QueryType type, QVariant in = QVariant()) const
|
||||
{
|
||||
switch(type) {
|
||||
|
|
@ -889,6 +914,8 @@ QVariant QSystemLocale::query(QueryType type, QVariant in = QVariant()) const
|
|||
return qt_TDes2QString(TAmPmName(TAmPm(EAm)));
|
||||
case PMText:
|
||||
return qt_TDes2QString(TAmPmName(TAmPm(EPm)));
|
||||
case UILanguages:
|
||||
return QVariant(symbianUILanguages());
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -695,9 +695,9 @@ inline QString::QString(const QLatin1String &aLatin1) : d(fromLatin1_helper(aLat
|
|||
inline int QString::length() const
|
||||
{ return d->size; }
|
||||
inline const QChar QString::at(int i) const
|
||||
{ Q_ASSERT(i >= 0 && i < size()); return d->data[i]; }
|
||||
{ Q_ASSERT(uint(i) < uint(size())); return d->data[i]; }
|
||||
inline const QChar QString::operator[](int i) const
|
||||
{ Q_ASSERT(i >= 0 && i < size()); return d->data[i]; }
|
||||
{ Q_ASSERT(uint(i) < uint(size())); return d->data[i]; }
|
||||
inline const QChar QString::operator[](uint i) const
|
||||
{ Q_ASSERT(i < uint(size())); return d->data[i]; }
|
||||
inline bool QString::isEmpty() const
|
||||
|
|
|
|||
|
|
@ -199,11 +199,11 @@ QTextBoundaryFinder &QTextBoundaryFinder::operator=(const QTextBoundaryFinder &o
|
|||
chars = other.chars;
|
||||
length = other.length;
|
||||
pos = other.pos;
|
||||
freePrivate = true;
|
||||
|
||||
QTextBoundaryFinderPrivate *newD = (QTextBoundaryFinderPrivate *)
|
||||
realloc(d, length*sizeof(HB_CharAttributes));
|
||||
realloc(freePrivate ? d : 0, length*sizeof(HB_CharAttributes));
|
||||
Q_CHECK_PTR(newD);
|
||||
freePrivate = true;
|
||||
d = newD;
|
||||
memcpy(d, other.d, length*sizeof(HB_CharAttributes));
|
||||
|
||||
|
|
|
|||
|
|
@ -574,8 +574,9 @@ void QVector<T>::append(const T &t)
|
|||
{
|
||||
if (d->ref != 1 || d->size + 1 > d->alloc) {
|
||||
const T copy(t);
|
||||
realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + 1, sizeof(T),
|
||||
QTypeInfo<T>::isStatic));
|
||||
realloc(d->size, (d->size + 1 > d->alloc) ?
|
||||
QVectorData::grow(sizeOfTypedData(), d->size + 1, sizeof(T), QTypeInfo<T>::isStatic)
|
||||
: d->alloc);
|
||||
if (QTypeInfo<T>::isComplex)
|
||||
new (p->array + d->size) T(copy);
|
||||
else
|
||||
|
|
|
|||
|
|
@ -113,6 +113,7 @@ protected:
|
|||
friend class QBaseApplication;
|
||||
friend class QDragManager;
|
||||
friend class QMimeSource;
|
||||
friend class QPlatformClipboard;
|
||||
|
||||
private:
|
||||
Q_DISABLE_COPY(QClipboard)
|
||||
|
|
|
|||
|
|
@ -42,6 +42,8 @@
|
|||
|
||||
#ifndef QT_NO_CLIPBOARD
|
||||
|
||||
#include <QtGui/private/qapplication_p.h>
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
class QClipboardData
|
||||
|
|
@ -81,7 +83,7 @@ QPlatformClipboard::~QPlatformClipboard()
|
|||
|
||||
}
|
||||
|
||||
const QMimeData *QPlatformClipboard::mimeData(QClipboard::Mode mode) const
|
||||
QMimeData *QPlatformClipboard::mimeData(QClipboard::Mode mode)
|
||||
{
|
||||
//we know its clipboard
|
||||
Q_UNUSED(mode);
|
||||
|
|
@ -100,6 +102,11 @@ bool QPlatformClipboard::supportsMode(QClipboard::Mode mode) const
|
|||
return mode == QClipboard::Clipboard;
|
||||
}
|
||||
|
||||
void QPlatformClipboard::emitChanged(QClipboard::Mode mode)
|
||||
{
|
||||
QApplication::clipboard()->emitChanged(mode);
|
||||
}
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
#endif //QT_NO_CLIPBOARD
|
||||
|
|
|
|||
|
|
@ -59,9 +59,10 @@ class Q_GUI_EXPORT QPlatformClipboard
|
|||
public:
|
||||
virtual ~QPlatformClipboard();
|
||||
|
||||
virtual const QMimeData *mimeData(QClipboard::Mode mode = QClipboard::Clipboard ) const;
|
||||
virtual QMimeData *mimeData(QClipboard::Mode mode = QClipboard::Clipboard);
|
||||
virtual void setMimeData(QMimeData *data, QClipboard::Mode mode = QClipboard::Clipboard);
|
||||
virtual bool supportsMode(QClipboard::Mode mode) const;
|
||||
void emitChanged(QClipboard::Mode mode);
|
||||
};
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
|
|
|||
|
|
@ -1156,12 +1156,8 @@ Qt::HANDLE QPixmap::handle() const
|
|||
{
|
||||
#if defined(Q_WS_X11)
|
||||
const QPixmapData *pd = pixmapData();
|
||||
if (pd) {
|
||||
if (pd->classId() == QPixmapData::X11Class)
|
||||
return static_cast<const QX11PixmapData*>(pd)->handle();
|
||||
else
|
||||
qWarning("QPixmap::handle(): Pixmap is not an X11 class pixmap");
|
||||
}
|
||||
if (pd && pd->classId() == QPixmapData::X11Class)
|
||||
return static_cast<const QX11PixmapData*>(pd)->handle();
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -810,6 +810,22 @@ const QGradient *QBrush::gradient() const
|
|||
return 0;
|
||||
}
|
||||
|
||||
Q_GUI_EXPORT bool qt_isExtendedRadialGradient(const QBrush &brush)
|
||||
{
|
||||
if (brush.style() == Qt::RadialGradientPattern) {
|
||||
const QGradient *g = brush.gradient();
|
||||
const QRadialGradient *rg = static_cast<const QRadialGradient *>(g);
|
||||
|
||||
if (!qFuzzyIsNull(rg->focalRadius()))
|
||||
return true;
|
||||
|
||||
QPointF delta = rg->focalPoint() - rg->center();
|
||||
if (delta.x() * delta.x() + delta.y() * delta.y() > rg->radius() * rg->radius())
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns true if the brush is fully opaque otherwise false. A brush
|
||||
|
|
@ -819,6 +835,7 @@ const QGradient *QBrush::gradient() const
|
|||
\i The alpha component of the color() is 255.
|
||||
\i Its texture() does not have an alpha channel and is not a QBitmap.
|
||||
\i The colors in the gradient() all have an alpha component that is 255.
|
||||
\i It is an extended radial gradient.
|
||||
\endlist
|
||||
*/
|
||||
|
||||
|
|
@ -830,6 +847,9 @@ bool QBrush::isOpaque() const
|
|||
if (d->style == Qt::SolidPattern)
|
||||
return opaqueColor;
|
||||
|
||||
if (qt_isExtendedRadialGradient(*this))
|
||||
return false;
|
||||
|
||||
if (d->style == Qt::LinearGradientPattern
|
||||
|| d->style == Qt::RadialGradientPattern
|
||||
|| d->style == Qt::ConicalGradientPattern) {
|
||||
|
|
@ -1179,8 +1199,10 @@ QDataStream &operator>>(QDataStream &s, QBrush &b)
|
|||
|
||||
\list
|
||||
\o \e Linear gradients interpolate colors between start and end points.
|
||||
\o \e Radial gradients interpolate colors between a focal point and end
|
||||
points on a circle surrounding it.
|
||||
\o \e Simple radial gradients interpolate colors between a focal point
|
||||
and end points on a circle surrounding it.
|
||||
\o \e Extended radial gradients interpolate colors between a center and
|
||||
a focal circle.
|
||||
\o \e Conical gradients interpolate colors around a center point.
|
||||
\endlist
|
||||
|
||||
|
|
@ -1476,8 +1498,6 @@ void QGradient::setInterpolationMode(InterpolationMode mode)
|
|||
dummy = p;
|
||||
}
|
||||
|
||||
#undef Q_DUMMY_ACCESSOR
|
||||
|
||||
/*!
|
||||
\fn bool QGradient::operator!=(const QGradient &gradient) const
|
||||
\since 4.2
|
||||
|
|
@ -1511,7 +1531,7 @@ bool QGradient::operator==(const QGradient &gradient) const
|
|||
|| m_data.radial.cy != gradient.m_data.radial.cy
|
||||
|| m_data.radial.fx != gradient.m_data.radial.fx
|
||||
|| m_data.radial.fy != gradient.m_data.radial.fy
|
||||
|| m_data.radial.radius != gradient.m_data.radial.radius)
|
||||
|| m_data.radial.cradius != gradient.m_data.radial.cradius)
|
||||
return false;
|
||||
} else { // m_type == ConicalGradient
|
||||
if (m_data.conical.cx != gradient.m_data.conical.cx
|
||||
|
|
@ -1717,10 +1737,17 @@ void QLinearGradient::setFinalStop(const QPointF &stop)
|
|||
\brief The QRadialGradient class is used in combination with QBrush to
|
||||
specify a radial gradient brush.
|
||||
|
||||
Radial gradients interpolate colors between a focal point and end
|
||||
points on a circle surrounding it. Outside the end points the
|
||||
gradient is either padded, reflected or repeated depending on the
|
||||
currently set \l {QGradient::Spread}{spread} method:
|
||||
Qt supports both simple and extended radial gradients.
|
||||
|
||||
Simple radial gradients interpolate colors between a focal point and end
|
||||
points on a circle surrounding it. Extended radial gradients interpolate
|
||||
colors between a focal circle and a center circle. Points outside the cone
|
||||
defined by the two circles will be transparent. For simple radial gradients
|
||||
the focal point is adjusted to lie inside the center circle, whereas the
|
||||
focal point can have any position in an extended radial gradient.
|
||||
|
||||
Outside the end points the gradient is either padded, reflected or repeated
|
||||
depending on the currently set \l {QGradient::Spread}{spread} method:
|
||||
|
||||
\table
|
||||
\row
|
||||
|
|
@ -1765,9 +1792,14 @@ static QPointF qt_radial_gradient_adapt_focal_point(const QPointF ¢er,
|
|||
}
|
||||
|
||||
/*!
|
||||
Constructs a radial gradient with the given \a center, \a
|
||||
Constructs a simple radial gradient with the given \a center, \a
|
||||
radius and \a focalPoint.
|
||||
|
||||
\note If the given focal point is outside the circle defined by the
|
||||
center (\a cx, \a cy) and the \a radius it will be re-adjusted to
|
||||
the intersection between the line from the center to the focal point
|
||||
and the circle.
|
||||
|
||||
\sa QGradient::setColorAt(), QGradient::setStops()
|
||||
*/
|
||||
|
||||
|
|
@ -1777,7 +1809,7 @@ QRadialGradient::QRadialGradient(const QPointF ¢er, qreal radius, const QPoi
|
|||
m_spread = PadSpread;
|
||||
m_data.radial.cx = center.x();
|
||||
m_data.radial.cy = center.y();
|
||||
m_data.radial.radius = radius;
|
||||
m_data.radial.cradius = radius;
|
||||
|
||||
QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(center, radius, focalPoint);
|
||||
m_data.radial.fx = adapted_focal.x();
|
||||
|
|
@ -1785,7 +1817,7 @@ QRadialGradient::QRadialGradient(const QPointF ¢er, qreal radius, const QPoi
|
|||
}
|
||||
|
||||
/*!
|
||||
Constructs a radial gradient with the given \a center, \a
|
||||
Constructs a simple radial gradient with the given \a center, \a
|
||||
radius and the focal point in the circle center.
|
||||
|
||||
\sa QGradient::setColorAt(), QGradient::setStops()
|
||||
|
|
@ -1796,16 +1828,21 @@ QRadialGradient::QRadialGradient(const QPointF ¢er, qreal radius)
|
|||
m_spread = PadSpread;
|
||||
m_data.radial.cx = center.x();
|
||||
m_data.radial.cy = center.y();
|
||||
m_data.radial.radius = radius;
|
||||
m_data.radial.cradius = radius;
|
||||
m_data.radial.fx = center.x();
|
||||
m_data.radial.fy = center.y();
|
||||
}
|
||||
|
||||
|
||||
/*!
|
||||
Constructs a radial gradient with the given center (\a cx, \a cy),
|
||||
Constructs a simple radial gradient with the given center (\a cx, \a cy),
|
||||
\a radius and focal point (\a fx, \a fy).
|
||||
|
||||
\note If the given focal point is outside the circle defined by the
|
||||
center (\a cx, \a cy) and the \a radius it will be re-adjusted to
|
||||
the intersection between the line from the center to the focal point
|
||||
and the circle.
|
||||
|
||||
\sa QGradient::setColorAt(), QGradient::setStops()
|
||||
*/
|
||||
|
||||
|
|
@ -1815,7 +1852,7 @@ QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qre
|
|||
m_spread = PadSpread;
|
||||
m_data.radial.cx = cx;
|
||||
m_data.radial.cy = cy;
|
||||
m_data.radial.radius = radius;
|
||||
m_data.radial.cradius = radius;
|
||||
|
||||
QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(QPointF(cx, cy),
|
||||
radius,
|
||||
|
|
@ -1826,7 +1863,7 @@ QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qre
|
|||
}
|
||||
|
||||
/*!
|
||||
Constructs a radial gradient with the center at (\a cx, \a cy) and the
|
||||
Constructs a simple radial gradient with the center at (\a cx, \a cy) and the
|
||||
specified \a radius. The focal point lies at the center of the circle.
|
||||
|
||||
\sa QGradient::setColorAt(), QGradient::setStops()
|
||||
|
|
@ -1837,14 +1874,14 @@ QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius)
|
|||
m_spread = PadSpread;
|
||||
m_data.radial.cx = cx;
|
||||
m_data.radial.cy = cy;
|
||||
m_data.radial.radius = radius;
|
||||
m_data.radial.cradius = radius;
|
||||
m_data.radial.fx = cx;
|
||||
m_data.radial.fy = cy;
|
||||
}
|
||||
|
||||
|
||||
/*!
|
||||
Constructs a radial gradient with the center and focal point at
|
||||
Constructs a simple radial gradient with the center and focal point at
|
||||
(0, 0) with a radius of 1.
|
||||
*/
|
||||
QRadialGradient::QRadialGradient()
|
||||
|
|
@ -1853,11 +1890,51 @@ QRadialGradient::QRadialGradient()
|
|||
m_spread = PadSpread;
|
||||
m_data.radial.cx = 0;
|
||||
m_data.radial.cy = 0;
|
||||
m_data.radial.radius = 1;
|
||||
m_data.radial.cradius = 1;
|
||||
m_data.radial.fx = 0;
|
||||
m_data.radial.fy = 0;
|
||||
}
|
||||
|
||||
/*!
|
||||
\since 4.8
|
||||
|
||||
Constructs an extended radial gradient with the given \a center, \a
|
||||
centerRadius, \a focalPoint, and \a focalRadius.
|
||||
*/
|
||||
QRadialGradient::QRadialGradient(const QPointF ¢er, qreal centerRadius, const QPointF &focalPoint, qreal focalRadius)
|
||||
{
|
||||
m_type = RadialGradient;
|
||||
m_spread = PadSpread;
|
||||
m_data.radial.cx = center.x();
|
||||
m_data.radial.cy = center.y();
|
||||
m_data.radial.cradius = centerRadius;
|
||||
|
||||
m_data.radial.fx = focalPoint.x();
|
||||
m_data.radial.fy = focalPoint.y();
|
||||
setFocalRadius(focalRadius);
|
||||
}
|
||||
|
||||
/*!
|
||||
\since 4.8
|
||||
|
||||
Constructs an extended radial gradient with the given \a center, \a
|
||||
centerRadius, \a focalPoint, and \a focalRadius.
|
||||
Constructs a radial gradient with the given center (\a cx, \a cy),
|
||||
center radius \a centerRadius, focal point (\a fx, \a fy), and
|
||||
focal radius \a focalRadius.
|
||||
*/
|
||||
QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal centerRadius, qreal fx, qreal fy, qreal focalRadius)
|
||||
{
|
||||
m_type = RadialGradient;
|
||||
m_spread = PadSpread;
|
||||
m_data.radial.cx = cx;
|
||||
m_data.radial.cy = cy;
|
||||
m_data.radial.cradius = centerRadius;
|
||||
|
||||
m_data.radial.fx = fx;
|
||||
m_data.radial.fy = fy;
|
||||
setFocalRadius(focalRadius);
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns the center of this radial gradient in logical coordinates.
|
||||
|
|
@ -1902,13 +1979,15 @@ void QRadialGradient::setCenter(const QPointF ¢er)
|
|||
/*!
|
||||
Returns the radius of this radial gradient in logical coordinates.
|
||||
|
||||
Equivalent to centerRadius()
|
||||
|
||||
\sa QGradient::stops()
|
||||
*/
|
||||
|
||||
qreal QRadialGradient::radius() const
|
||||
{
|
||||
Q_ASSERT(m_type == RadialGradient);
|
||||
return m_data.radial.radius;
|
||||
return m_data.radial.cradius;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1917,13 +1996,81 @@ qreal QRadialGradient::radius() const
|
|||
|
||||
Sets the radius of this radial gradient in logical coordinates
|
||||
to \a radius
|
||||
|
||||
Equivalent to setCenterRadius()
|
||||
*/
|
||||
void QRadialGradient::setRadius(qreal radius)
|
||||
{
|
||||
Q_ASSERT(m_type == RadialGradient);
|
||||
m_data.radial.radius = radius;
|
||||
m_data.radial.cradius = radius;
|
||||
}
|
||||
|
||||
/*!
|
||||
\since 4.8
|
||||
|
||||
Returns the center radius of this radial gradient in logical
|
||||
coordinates.
|
||||
|
||||
\sa QGradient::stops()
|
||||
*/
|
||||
qreal QRadialGradient::centerRadius() const
|
||||
{
|
||||
Q_ASSERT(m_type == RadialGradient);
|
||||
return m_data.radial.cradius;
|
||||
}
|
||||
|
||||
/*
|
||||
\since 4.8
|
||||
|
||||
Sets the center radius of this radial gradient in logical coordinates
|
||||
to \a radius
|
||||
*/
|
||||
void QRadialGradient::setCenterRadius(qreal radius)
|
||||
{
|
||||
Q_ASSERT(m_type == RadialGradient);
|
||||
m_data.radial.cradius = radius;
|
||||
}
|
||||
|
||||
/*!
|
||||
\since 4.8
|
||||
|
||||
Returns the focal radius of this radial gradient in logical
|
||||
coordinates.
|
||||
|
||||
\sa QGradient::stops()
|
||||
*/
|
||||
qreal QRadialGradient::focalRadius() const
|
||||
{
|
||||
Q_ASSERT(m_type == RadialGradient);
|
||||
Q_DUMMY_ACCESSOR
|
||||
|
||||
// mask away low three bits
|
||||
union { float f; quint32 i; } u;
|
||||
u.i = i & ~0x07;
|
||||
return u.f;
|
||||
}
|
||||
|
||||
/*
|
||||
\since 4.8
|
||||
|
||||
Sets the focal radius of this radial gradient in logical coordinates
|
||||
to \a radius
|
||||
*/
|
||||
void QRadialGradient::setFocalRadius(qreal radius)
|
||||
{
|
||||
Q_ASSERT(m_type == RadialGradient);
|
||||
Q_DUMMY_ACCESSOR
|
||||
|
||||
// Since there's no QGradientData, we only have the dummy void * to
|
||||
// store additional data in. The three lowest bits are already
|
||||
// taken, thus we cut the three lowest bits from the significand
|
||||
// and store the radius as a float.
|
||||
union { float f; quint32 i; } u;
|
||||
u.f = float(radius);
|
||||
// add 0x04 to round up when we drop the three lowest bits
|
||||
i |= (u.i + 0x04) & ~0x07;
|
||||
dummy = p;
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns the focal point of this radial gradient in logical
|
||||
|
|
@ -2163,4 +2310,6 @@ void QConicalGradient::setAngle(qreal angle)
|
|||
\sa setTransform()
|
||||
*/
|
||||
|
||||
#undef Q_DUMMY_ACCESSOR
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
|
|
|||
|
|
@ -245,6 +245,7 @@ private:
|
|||
friend class QLinearGradient;
|
||||
friend class QRadialGradient;
|
||||
friend class QConicalGradient;
|
||||
friend class QBrush;
|
||||
|
||||
Type m_type;
|
||||
Spread m_spread;
|
||||
|
|
@ -254,7 +255,7 @@ private:
|
|||
qreal x1, y1, x2, y2;
|
||||
} linear;
|
||||
struct {
|
||||
qreal cx, cy, fx, fy, radius;
|
||||
qreal cx, cy, fx, fy, cradius;
|
||||
} radial;
|
||||
struct {
|
||||
qreal cx, cy, angle;
|
||||
|
|
@ -293,6 +294,9 @@ public:
|
|||
QRadialGradient(const QPointF ¢er, qreal radius);
|
||||
QRadialGradient(qreal cx, qreal cy, qreal radius);
|
||||
|
||||
QRadialGradient(const QPointF ¢er, qreal centerRadius, const QPointF &focalPoint, qreal focalRadius);
|
||||
QRadialGradient(qreal cx, qreal cy, qreal centerRadius, qreal fx, qreal fy, qreal focalRadius);
|
||||
|
||||
QPointF center() const;
|
||||
void setCenter(const QPointF ¢er);
|
||||
inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); }
|
||||
|
|
@ -303,6 +307,12 @@ public:
|
|||
|
||||
qreal radius() const;
|
||||
void setRadius(qreal radius);
|
||||
|
||||
qreal centerRadius() const;
|
||||
void setCenterRadius(qreal radius);
|
||||
|
||||
qreal focalRadius() const;
|
||||
void setFocalRadius(qreal radius);
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -75,44 +75,10 @@ enum {
|
|||
fixed_scale = 1 << 16,
|
||||
half_point = 1 << 15
|
||||
};
|
||||
|
||||
// must be multiple of 4 for easier SIMD implementations
|
||||
static const int buffer_size = 2048;
|
||||
|
||||
struct LinearGradientValues
|
||||
{
|
||||
qreal dx;
|
||||
qreal dy;
|
||||
qreal l;
|
||||
qreal off;
|
||||
};
|
||||
|
||||
struct RadialGradientValues
|
||||
{
|
||||
qreal dx;
|
||||
qreal dy;
|
||||
qreal a;
|
||||
};
|
||||
|
||||
struct Operator;
|
||||
typedef uint* (QT_FASTCALL *DestFetchProc)(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length);
|
||||
typedef void (QT_FASTCALL *DestStoreProc)(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length);
|
||||
typedef const uint* (QT_FASTCALL *SourceFetchProc)(uint *buffer, const Operator *o, const QSpanData *data, int y, int x, int length);
|
||||
|
||||
|
||||
struct Operator
|
||||
{
|
||||
QPainter::CompositionMode mode;
|
||||
DestFetchProc dest_fetch;
|
||||
DestStoreProc dest_store;
|
||||
SourceFetchProc src_fetch;
|
||||
CompositionFunctionSolid funcSolid;
|
||||
CompositionFunction func;
|
||||
union {
|
||||
LinearGradientValues linear;
|
||||
RadialGradientValues radial;
|
||||
// TextureValues texture;
|
||||
};
|
||||
};
|
||||
|
||||
/*
|
||||
Destination fetch. This is simple as we don't have to do bounds checks or
|
||||
transformations
|
||||
|
|
@ -1346,64 +1312,13 @@ static const SourceFetchProc sourceFetch[NBlendTypes][QImage::NImageFormats] = {
|
|||
},
|
||||
};
|
||||
|
||||
|
||||
static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
|
||||
{
|
||||
int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));
|
||||
|
||||
// calculate the actual offset.
|
||||
if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
|
||||
if (data->spread == QGradient::RepeatSpread) {
|
||||
ipos = ipos % GRADIENT_STOPTABLE_SIZE;
|
||||
ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
|
||||
|
||||
} else if (data->spread == QGradient::ReflectSpread) {
|
||||
const int limit = GRADIENT_STOPTABLE_SIZE * 2 - 1;
|
||||
ipos = ipos % limit;
|
||||
ipos = ipos < 0 ? limit + ipos : ipos;
|
||||
ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - ipos : ipos;
|
||||
|
||||
} else {
|
||||
if (ipos < 0) ipos = 0;
|
||||
else if (ipos >= GRADIENT_STOPTABLE_SIZE) ipos = GRADIENT_STOPTABLE_SIZE-1;
|
||||
}
|
||||
}
|
||||
|
||||
Q_ASSERT(ipos >= 0);
|
||||
Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
|
||||
|
||||
return data->colorTable[ipos];
|
||||
}
|
||||
|
||||
#define FIXPT_BITS 8
|
||||
#define FIXPT_SIZE (1<<FIXPT_BITS)
|
||||
|
||||
static uint qt_gradient_pixel_fixed(const QGradientData *data, int fixed_pos)
|
||||
{
|
||||
int ipos = (fixed_pos + (FIXPT_SIZE / 2)) >> FIXPT_BITS;
|
||||
|
||||
// calculate the actual offset.
|
||||
if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
|
||||
if (data->spread == QGradient::RepeatSpread) {
|
||||
ipos = ipos % GRADIENT_STOPTABLE_SIZE;
|
||||
ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
|
||||
|
||||
} else if (data->spread == QGradient::ReflectSpread) {
|
||||
const int limit = GRADIENT_STOPTABLE_SIZE * 2 - 1;
|
||||
ipos = ipos % limit;
|
||||
ipos = ipos < 0 ? limit + ipos : ipos;
|
||||
ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - ipos : ipos;
|
||||
|
||||
} else {
|
||||
if (ipos < 0) ipos = 0;
|
||||
else if (ipos >= GRADIENT_STOPTABLE_SIZE) ipos = GRADIENT_STOPTABLE_SIZE-1;
|
||||
}
|
||||
}
|
||||
|
||||
Q_ASSERT(ipos >= 0);
|
||||
Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
|
||||
|
||||
return data->colorTable[ipos];
|
||||
return data->colorTable[qt_gradient_clamp(data, ipos)];
|
||||
}
|
||||
|
||||
static void QT_FASTCALL getLinearGradientValues(LinearGradientValues *v, const QSpanData *data)
|
||||
|
|
@ -1419,8 +1334,8 @@ static void QT_FASTCALL getLinearGradientValues(LinearGradientValues *v, const Q
|
|||
}
|
||||
}
|
||||
|
||||
static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator *op, const QSpanData *data,
|
||||
int y, int x, int length)
|
||||
static const uint * QT_FASTCALL qt_fetch_linear_gradient(uint *buffer, const Operator *op, const QSpanData *data,
|
||||
int y, int x, int length)
|
||||
{
|
||||
const uint *b = buffer;
|
||||
qreal t, inc;
|
||||
|
|
@ -1487,110 +1402,65 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator
|
|||
return b;
|
||||
}
|
||||
|
||||
static inline qreal determinant(qreal a, qreal b, qreal c)
|
||||
{
|
||||
return (b * b) - (4 * a * c);
|
||||
}
|
||||
|
||||
// function to evaluate real roots
|
||||
static inline qreal realRoots(qreal a, qreal b, qreal detSqrt)
|
||||
{
|
||||
return (-b + detSqrt)/(2 * a);
|
||||
}
|
||||
|
||||
static inline qreal qSafeSqrt(qreal x)
|
||||
{
|
||||
return x > 0 ? qSqrt(x) : 0;
|
||||
}
|
||||
|
||||
static void QT_FASTCALL getRadialGradientValues(RadialGradientValues *v, const QSpanData *data)
|
||||
{
|
||||
v->dx = data->gradient.radial.center.x - data->gradient.radial.focal.x;
|
||||
v->dy = data->gradient.radial.center.y - data->gradient.radial.focal.y;
|
||||
v->a = data->gradient.radial.radius*data->gradient.radial.radius - v->dx*v->dx - v->dy*v->dy;
|
||||
|
||||
v->dr = data->gradient.radial.center.radius - data->gradient.radial.focal.radius;
|
||||
v->sqrfr = data->gradient.radial.focal.radius * data->gradient.radial.focal.radius;
|
||||
|
||||
v->a = v->dr * v->dr - v->dx*v->dx - v->dy*v->dy;
|
||||
v->inv2a = 1 / (2 * v->a);
|
||||
|
||||
v->extended = !qFuzzyIsNull(data->gradient.radial.focal.radius) || v->a <= 0;
|
||||
}
|
||||
|
||||
static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator *op, const QSpanData *data,
|
||||
int y, int x, int length)
|
||||
class RadialFetchPlain
|
||||
{
|
||||
const uint *b = buffer;
|
||||
qreal rx = data->m21 * (y + qreal(0.5))
|
||||
+ data->dx + data->m11 * (x + qreal(0.5));
|
||||
qreal ry = data->m22 * (y + qreal(0.5))
|
||||
+ data->dy + data->m12 * (x + qreal(0.5));
|
||||
bool affine = !data->m13 && !data->m23;
|
||||
//qreal r = data->gradient.radial.radius;
|
||||
public:
|
||||
static inline void fetch(uint *buffer, uint *end, const Operator *op, const QSpanData *data, qreal det,
|
||||
qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
|
||||
{
|
||||
if (op->radial.extended) {
|
||||
while (buffer < end) {
|
||||
quint32 result = 0;
|
||||
if (det >= 0) {
|
||||
qreal w = qSqrt(det) - b;
|
||||
if (data->gradient.radial.focal.radius + op->radial.dr * w >= 0)
|
||||
result = qt_gradient_pixel(&data->gradient, w);
|
||||
}
|
||||
|
||||
const uint *end = buffer + length;
|
||||
if (affine) {
|
||||
rx -= data->gradient.radial.focal.x;
|
||||
ry -= data->gradient.radial.focal.y;
|
||||
*buffer = result;
|
||||
|
||||
qreal inv_a = 1 / qreal(2 * op->radial.a);
|
||||
det += delta_det;
|
||||
delta_det += delta_delta_det;
|
||||
b += delta_b;
|
||||
|
||||
const qreal delta_rx = data->m11;
|
||||
const qreal delta_ry = data->m12;
|
||||
|
||||
qreal b = 2*(rx * op->radial.dx + ry * op->radial.dy);
|
||||
qreal delta_b = 2*(delta_rx * op->radial.dx + delta_ry * op->radial.dy);
|
||||
const qreal b_delta_b = 2 * b * delta_b;
|
||||
const qreal delta_b_delta_b = 2 * delta_b * delta_b;
|
||||
|
||||
const qreal bb = b * b;
|
||||
const qreal delta_bb = delta_b * delta_b;
|
||||
|
||||
b *= inv_a;
|
||||
delta_b *= inv_a;
|
||||
|
||||
const qreal rxrxryry = rx * rx + ry * ry;
|
||||
const qreal delta_rxrxryry = delta_rx * delta_rx + delta_ry * delta_ry;
|
||||
const qreal rx_plus_ry = 2*(rx * delta_rx + ry * delta_ry);
|
||||
const qreal delta_rx_plus_ry = 2 * delta_rxrxryry;
|
||||
|
||||
inv_a *= inv_a;
|
||||
|
||||
qreal det = (bb + 4 * op->radial.a * rxrxryry) * inv_a;
|
||||
qreal delta_det = (b_delta_b + delta_bb + 4 * op->radial.a * (rx_plus_ry + delta_rxrxryry)) * inv_a;
|
||||
const qreal delta_delta_det = (delta_b_delta_b + 4 * op->radial.a * delta_rx_plus_ry) * inv_a;
|
||||
|
||||
while (buffer < end) {
|
||||
*buffer = qt_gradient_pixel(&data->gradient, qSafeSqrt(det) - b);
|
||||
|
||||
det += delta_det;
|
||||
delta_det += delta_delta_det;
|
||||
b += delta_b;
|
||||
|
||||
++buffer;
|
||||
}
|
||||
} else {
|
||||
qreal rw = data->m23 * (y + qreal(0.5))
|
||||
+ data->m33 + data->m13 * (x + qreal(0.5));
|
||||
if (!rw)
|
||||
rw = 1;
|
||||
while (buffer < end) {
|
||||
qreal gx = rx/rw - data->gradient.radial.focal.x;
|
||||
qreal gy = ry/rw - data->gradient.radial.focal.y;
|
||||
qreal b = 2*(gx*op->radial.dx + gy*op->radial.dy);
|
||||
qreal det = determinant(op->radial.a, b , -(gx*gx + gy*gy));
|
||||
qreal s = realRoots(op->radial.a, b, qSafeSqrt(det));
|
||||
|
||||
*buffer = qt_gradient_pixel(&data->gradient, s);
|
||||
|
||||
rx += data->m11;
|
||||
ry += data->m12;
|
||||
rw += data->m13;
|
||||
if (!rw) {
|
||||
rw += data->m13;
|
||||
++buffer;
|
||||
}
|
||||
} else {
|
||||
while (buffer < end) {
|
||||
*buffer++ = qt_gradient_pixel(&data->gradient, qSqrt(det) - b);
|
||||
|
||||
det += delta_det;
|
||||
delta_det += delta_delta_det;
|
||||
b += delta_b;
|
||||
}
|
||||
++buffer;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
return b;
|
||||
const uint * QT_FASTCALL qt_fetch_radial_gradient_plain(uint *buffer, const Operator *op, const QSpanData *data,
|
||||
int y, int x, int length)
|
||||
{
|
||||
return qt_fetch_radial_gradient_template<RadialFetchPlain>(buffer, op, data, y, x, length);
|
||||
}
|
||||
|
||||
static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operator *, const QSpanData *data,
|
||||
int y, int x, int length)
|
||||
static SourceFetchProc qt_fetch_radial_gradient = qt_fetch_radial_gradient_plain;
|
||||
|
||||
static const uint * QT_FASTCALL qt_fetch_conical_gradient(uint *buffer, const Operator *, const QSpanData *data,
|
||||
int y, int x, int length)
|
||||
{
|
||||
const uint *b = buffer;
|
||||
qreal rx = data->m21 * (y + qreal(0.5))
|
||||
|
|
@ -3347,16 +3217,16 @@ static inline Operator getOperator(const QSpanData *data, const QSpan *spans, in
|
|||
case QSpanData::LinearGradient:
|
||||
solidSource = !data->gradient.alphaColor;
|
||||
getLinearGradientValues(&op.linear, data);
|
||||
op.src_fetch = fetchLinearGradient;
|
||||
op.src_fetch = qt_fetch_linear_gradient;
|
||||
break;
|
||||
case QSpanData::RadialGradient:
|
||||
solidSource = !data->gradient.alphaColor;
|
||||
getRadialGradientValues(&op.radial, data);
|
||||
op.src_fetch = fetchRadialGradient;
|
||||
op.src_fetch = qt_fetch_radial_gradient;
|
||||
break;
|
||||
case QSpanData::ConicalGradient:
|
||||
solidSource = !data->gradient.alphaColor;
|
||||
op.src_fetch = fetchConicalGradient;
|
||||
op.src_fetch = qt_fetch_conical_gradient;
|
||||
break;
|
||||
case QSpanData::Texture:
|
||||
op.src_fetch = sourceFetch[getBlendType(data)][data->texture.format];
|
||||
|
|
@ -7278,6 +7148,11 @@ void qInitDrawhelperAsm()
|
|||
qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_sse2;
|
||||
qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_sse2;
|
||||
qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_sse2;
|
||||
|
||||
extern const uint * QT_FASTCALL qt_fetch_radial_gradient_sse2(uint *buffer, const Operator *op, const QSpanData *data,
|
||||
int y, int x, int length);
|
||||
|
||||
qt_fetch_radial_gradient = qt_fetch_radial_gradient_sse2;
|
||||
}
|
||||
|
||||
#ifdef QT_HAVE_SSSE3
|
||||
|
|
@ -7373,6 +7248,11 @@ void qInitDrawhelperAsm()
|
|||
qMemRotateFunctions[QImage::Format_RGB16][0] = qt_memrotate90_16_neon;
|
||||
qMemRotateFunctions[QImage::Format_RGB16][2] = qt_memrotate270_16_neon;
|
||||
qt_memfill32 = qt_memfill32_neon;
|
||||
|
||||
extern const uint * QT_FASTCALL qt_fetch_radial_gradient_neon(uint *buffer, const Operator *op, const QSpanData *data,
|
||||
int y, int x, int length);
|
||||
|
||||
qt_fetch_radial_gradient = qt_fetch_radial_gradient_neon;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -955,6 +955,46 @@ void qt_memrotate270_16_neon(const uchar *srcPixels, int w, int h,
|
|||
}
|
||||
}
|
||||
|
||||
class QSimdNeon
|
||||
{
|
||||
public:
|
||||
typedef int32x4_t Int32x4;
|
||||
typedef float32x4_t Float32x4;
|
||||
|
||||
union Vect_buffer_i { Int32x4 v; int i[4]; };
|
||||
union Vect_buffer_f { Float32x4 v; float f[4]; };
|
||||
|
||||
static inline Float32x4 v_dup(float x) { return vdupq_n_f32(x); }
|
||||
static inline Int32x4 v_dup(int x) { return vdupq_n_s32(x); }
|
||||
static inline Int32x4 v_dup(uint x) { return vdupq_n_s32(x); }
|
||||
|
||||
static inline Float32x4 v_add(Float32x4 a, Float32x4 b) { return vaddq_f32(a, b); }
|
||||
static inline Int32x4 v_add(Int32x4 a, Int32x4 b) { return vaddq_s32(a, b); }
|
||||
|
||||
static inline Float32x4 v_max(Float32x4 a, Float32x4 b) { return vmaxq_f32(a, b); }
|
||||
static inline Float32x4 v_min(Float32x4 a, Float32x4 b) { return vminq_f32(a, b); }
|
||||
static inline Int32x4 v_min_16(Int32x4 a, Int32x4 b) { return vminq_s32(a, b); }
|
||||
|
||||
static inline Int32x4 v_and(Int32x4 a, Int32x4 b) { return vandq_s32(a, b); }
|
||||
|
||||
static inline Float32x4 v_sub(Float32x4 a, Float32x4 b) { return vsubq_f32(a, b); }
|
||||
static inline Int32x4 v_sub(Int32x4 a, Int32x4 b) { return vsubq_s32(a, b); }
|
||||
|
||||
static inline Float32x4 v_mul(Float32x4 a, Float32x4 b) { return vmulq_f32(a, b); }
|
||||
|
||||
static inline Float32x4 v_sqrt(Float32x4 x) { Float32x4 y = vrsqrteq_f32(x); y = vmulq_f32(y, vrsqrtsq_f32(x, vmulq_f32(y, y))); return vmulq_f32(x, y); }
|
||||
|
||||
static inline Int32x4 v_toInt(Float32x4 x) { return vcvtq_s32_f32(x); }
|
||||
|
||||
static inline Int32x4 v_greaterOrEqual(Float32x4 a, Float32x4 b) { return vcge_f32(a, b); }
|
||||
};
|
||||
|
||||
const uint * QT_FASTCALL qt_fetch_radial_gradient_neon(uint *buffer, const Operator *op, const QSpanData *data,
|
||||
int y, int x, int length)
|
||||
{
|
||||
return qt_fetch_radial_gradient_template<QRadialFetchSimd<QSimdNeon> >(buffer, op, data, y, x, length);
|
||||
}
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
#endif // QT_HAVE_NEON
|
||||
|
|
|
|||
|
|
@ -63,6 +63,7 @@
|
|||
#endif
|
||||
#include "private/qrasterdefs_p.h"
|
||||
#include <private/qsimd_p.h>
|
||||
#include <private/qmath_p.h>
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
|
|
@ -170,6 +171,44 @@ void qBlendTexture(int count, const QSpan *spans, void *userData);
|
|||
typedef void (QT_FASTCALL *CompositionFunction)(uint *dest, const uint *src, int length, uint const_alpha);
|
||||
typedef void (QT_FASTCALL *CompositionFunctionSolid)(uint *dest, int length, uint color, uint const_alpha);
|
||||
|
||||
struct LinearGradientValues
|
||||
{
|
||||
qreal dx;
|
||||
qreal dy;
|
||||
qreal l;
|
||||
qreal off;
|
||||
};
|
||||
|
||||
struct RadialGradientValues
|
||||
{
|
||||
qreal dx;
|
||||
qreal dy;
|
||||
qreal dr;
|
||||
qreal sqrfr;
|
||||
qreal a;
|
||||
qreal inv2a;
|
||||
bool extended;
|
||||
};
|
||||
|
||||
struct Operator;
|
||||
typedef uint* (QT_FASTCALL *DestFetchProc)(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length);
|
||||
typedef void (QT_FASTCALL *DestStoreProc)(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length);
|
||||
typedef const uint* (QT_FASTCALL *SourceFetchProc)(uint *buffer, const Operator *o, const QSpanData *data, int y, int x, int length);
|
||||
|
||||
struct Operator
|
||||
{
|
||||
QPainter::CompositionMode mode;
|
||||
DestFetchProc dest_fetch;
|
||||
DestStoreProc dest_store;
|
||||
SourceFetchProc src_fetch;
|
||||
CompositionFunctionSolid funcSolid;
|
||||
CompositionFunction func;
|
||||
union {
|
||||
LinearGradientValues linear;
|
||||
RadialGradientValues radial;
|
||||
};
|
||||
};
|
||||
|
||||
void qInitDrawhelperAsm();
|
||||
|
||||
class QRasterPaintEngine;
|
||||
|
|
@ -196,12 +235,13 @@ struct QRadialGradientData
|
|||
struct {
|
||||
qreal x;
|
||||
qreal y;
|
||||
qreal radius;
|
||||
} center;
|
||||
struct {
|
||||
qreal x;
|
||||
qreal y;
|
||||
qreal radius;
|
||||
} focal;
|
||||
qreal radius;
|
||||
};
|
||||
|
||||
struct QConicalGradientData
|
||||
|
|
@ -224,6 +264,7 @@ struct QGradientData
|
|||
};
|
||||
|
||||
#define GRADIENT_STOPTABLE_SIZE 1024
|
||||
#define GRADIENT_STOPTABLE_SIZE_SHIFT 10
|
||||
|
||||
uint* colorTable; //[GRADIENT_STOPTABLE_SIZE];
|
||||
|
||||
|
|
@ -293,6 +334,218 @@ struct QSpanData
|
|||
void adjustSpanMethods();
|
||||
};
|
||||
|
||||
static inline uint qt_gradient_clamp(const QGradientData *data, int ipos)
|
||||
{
|
||||
if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
|
||||
if (data->spread == QGradient::RepeatSpread) {
|
||||
ipos = ipos % GRADIENT_STOPTABLE_SIZE;
|
||||
ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
|
||||
} else if (data->spread == QGradient::ReflectSpread) {
|
||||
const int limit = GRADIENT_STOPTABLE_SIZE * 2;
|
||||
ipos = ipos % limit;
|
||||
ipos = ipos < 0 ? limit + ipos : ipos;
|
||||
ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - 1 - ipos : ipos;
|
||||
} else {
|
||||
if (ipos < 0)
|
||||
ipos = 0;
|
||||
else if (ipos >= GRADIENT_STOPTABLE_SIZE)
|
||||
ipos = GRADIENT_STOPTABLE_SIZE-1;
|
||||
}
|
||||
}
|
||||
|
||||
Q_ASSERT(ipos >= 0);
|
||||
Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
|
||||
|
||||
return ipos;
|
||||
}
|
||||
|
||||
static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
|
||||
{
|
||||
int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));
|
||||
return data->colorTable[qt_gradient_clamp(data, ipos)];
|
||||
}
|
||||
|
||||
static inline qreal qRadialDeterminant(qreal a, qreal b, qreal c)
|
||||
{
|
||||
return (b * b) - (4 * a * c);
|
||||
}
|
||||
|
||||
template <class RadialFetchFunc>
|
||||
const uint * QT_FASTCALL qt_fetch_radial_gradient_template(uint *buffer, const Operator *op, const QSpanData *data,
|
||||
int y, int x, int length)
|
||||
{
|
||||
// avoid division by zero
|
||||
if (qFuzzyIsNull(op->radial.a)) {
|
||||
extern void (*qt_memfill32)(quint32 *dest, quint32 value, int count);
|
||||
qt_memfill32(buffer, 0, length);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
const uint *b = buffer;
|
||||
qreal rx = data->m21 * (y + qreal(0.5))
|
||||
+ data->dx + data->m11 * (x + qreal(0.5));
|
||||
qreal ry = data->m22 * (y + qreal(0.5))
|
||||
+ data->dy + data->m12 * (x + qreal(0.5));
|
||||
bool affine = !data->m13 && !data->m23;
|
||||
|
||||
uint *end = buffer + length;
|
||||
if (affine) {
|
||||
rx -= data->gradient.radial.focal.x;
|
||||
ry -= data->gradient.radial.focal.y;
|
||||
|
||||
qreal inv_a = 1 / qreal(2 * op->radial.a);
|
||||
|
||||
const qreal delta_rx = data->m11;
|
||||
const qreal delta_ry = data->m12;
|
||||
|
||||
qreal b = 2*(op->radial.dr*data->gradient.radial.focal.radius + rx * op->radial.dx + ry * op->radial.dy);
|
||||
qreal delta_b = 2*(delta_rx * op->radial.dx + delta_ry * op->radial.dy);
|
||||
const qreal b_delta_b = 2 * b * delta_b;
|
||||
const qreal delta_b_delta_b = 2 * delta_b * delta_b;
|
||||
|
||||
const qreal bb = b * b;
|
||||
const qreal delta_bb = delta_b * delta_b;
|
||||
|
||||
b *= inv_a;
|
||||
delta_b *= inv_a;
|
||||
|
||||
const qreal rxrxryry = rx * rx + ry * ry;
|
||||
const qreal delta_rxrxryry = delta_rx * delta_rx + delta_ry * delta_ry;
|
||||
const qreal rx_plus_ry = 2*(rx * delta_rx + ry * delta_ry);
|
||||
const qreal delta_rx_plus_ry = 2 * delta_rxrxryry;
|
||||
|
||||
inv_a *= inv_a;
|
||||
|
||||
qreal det = (bb - 4 * op->radial.a * (op->radial.sqrfr - rxrxryry)) * inv_a;
|
||||
qreal delta_det = (b_delta_b + delta_bb + 4 * op->radial.a * (rx_plus_ry + delta_rxrxryry)) * inv_a;
|
||||
const qreal delta_delta_det = (delta_b_delta_b + 4 * op->radial.a * delta_rx_plus_ry) * inv_a;
|
||||
|
||||
RadialFetchFunc::fetch(buffer, end, op, data, det, delta_det, delta_delta_det, b, delta_b);
|
||||
} else {
|
||||
qreal rw = data->m23 * (y + qreal(0.5))
|
||||
+ data->m33 + data->m13 * (x + qreal(0.5));
|
||||
|
||||
while (buffer < end) {
|
||||
if (rw == 0) {
|
||||
*buffer = 0;
|
||||
} else {
|
||||
qreal invRw = 1 / rw;
|
||||
qreal gx = rx * invRw - data->gradient.radial.focal.x;
|
||||
qreal gy = ry * invRw - data->gradient.radial.focal.y;
|
||||
qreal b = 2*(op->radial.dr*data->gradient.radial.focal.radius + gx*op->radial.dx + gy*op->radial.dy);
|
||||
qreal det = qRadialDeterminant(op->radial.a, b, op->radial.sqrfr - (gx*gx + gy*gy));
|
||||
|
||||
quint32 result = 0;
|
||||
if (det >= 0) {
|
||||
qreal detSqrt = qSqrt(det);
|
||||
|
||||
qreal s0 = (-b - detSqrt) * op->radial.inv2a;
|
||||
qreal s1 = (-b + detSqrt) * op->radial.inv2a;
|
||||
|
||||
qreal s = qMax(s0, s1);
|
||||
|
||||
if (data->gradient.radial.focal.radius + op->radial.dr * s >= 0)
|
||||
result = qt_gradient_pixel(&data->gradient, s);
|
||||
}
|
||||
|
||||
*buffer = result;
|
||||
}
|
||||
|
||||
rx += data->m11;
|
||||
ry += data->m12;
|
||||
rw += data->m13;
|
||||
|
||||
++buffer;
|
||||
}
|
||||
}
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
template <class Simd>
|
||||
class QRadialFetchSimd
|
||||
{
|
||||
public:
|
||||
static void fetch(uint *buffer, uint *end, const Operator *op, const QSpanData *data, qreal det,
|
||||
qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
|
||||
{
|
||||
typename Simd::Vect_buffer_f det_vec;
|
||||
typename Simd::Vect_buffer_f delta_det4_vec;
|
||||
typename Simd::Vect_buffer_f b_vec;
|
||||
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
det_vec.f[i] = det;
|
||||
delta_det4_vec.f[i] = 4 * delta_det;
|
||||
b_vec.f[i] = b;
|
||||
|
||||
det += delta_det;
|
||||
delta_det += delta_delta_det;
|
||||
b += delta_b;
|
||||
}
|
||||
|
||||
const typename Simd::Float32x4 v_delta_delta_det16 = Simd::v_dup(16 * delta_delta_det);
|
||||
const typename Simd::Float32x4 v_delta_delta_det6 = Simd::v_dup(6 * delta_delta_det);
|
||||
const typename Simd::Float32x4 v_delta_b4 = Simd::v_dup(4 * delta_b);
|
||||
|
||||
const typename Simd::Float32x4 v_r0 = Simd::v_dup(data->gradient.radial.focal.radius);
|
||||
const typename Simd::Float32x4 v_dr = Simd::v_dup(op->radial.dr);
|
||||
|
||||
const typename Simd::Float32x4 v_min = Simd::v_dup(0.0f);
|
||||
const typename Simd::Float32x4 v_max = Simd::v_dup(float(GRADIENT_STOPTABLE_SIZE-1));
|
||||
const typename Simd::Float32x4 v_half = Simd::v_dup(0.5f);
|
||||
|
||||
const typename Simd::Int32x4 v_repeat_mask = Simd::v_dup(~(uint(0xffffff) << GRADIENT_STOPTABLE_SIZE_SHIFT));
|
||||
const typename Simd::Int32x4 v_reflect_mask = Simd::v_dup(~(uint(0xffffff) << (GRADIENT_STOPTABLE_SIZE_SHIFT+1)));
|
||||
|
||||
const typename Simd::Int32x4 v_reflect_limit = Simd::v_dup(2 * GRADIENT_STOPTABLE_SIZE - 1);
|
||||
|
||||
const int extended_mask = op->radial.extended ? 0x0 : ~0x0;
|
||||
|
||||
#define FETCH_RADIAL_LOOP_PROLOGUE \
|
||||
while (buffer < end) { \
|
||||
typename Simd::Vect_buffer_i v_buffer_mask; \
|
||||
v_buffer_mask.v = Simd::v_greaterOrEqual(det_vec.v, v_min); \
|
||||
const typename Simd::Float32x4 v_index_local = Simd::v_sub(Simd::v_sqrt(Simd::v_max(v_min, det_vec.v)), b_vec.v); \
|
||||
const typename Simd::Float32x4 v_index = Simd::v_add(Simd::v_mul(v_index_local, v_max), v_half); \
|
||||
v_buffer_mask.v = Simd::v_and(v_buffer_mask.v, Simd::v_greaterOrEqual(Simd::v_add(v_r0, Simd::v_mul(v_dr, v_index_local)), v_min)); \
|
||||
typename Simd::Vect_buffer_i index_vec;
|
||||
#define FETCH_RADIAL_LOOP_CLAMP_REPEAT \
|
||||
index_vec.v = Simd::v_and(v_repeat_mask, Simd::v_toInt(v_index));
|
||||
#define FETCH_RADIAL_LOOP_CLAMP_REFLECT \
|
||||
const typename Simd::Int32x4 v_index_i = Simd::v_and(v_reflect_mask, Simd::v_toInt(v_index)); \
|
||||
const typename Simd::Int32x4 v_index_i_inv = Simd::v_sub(v_reflect_limit, v_index_i); \
|
||||
index_vec.v = Simd::v_min_16(v_index_i, v_index_i_inv);
|
||||
#define FETCH_RADIAL_LOOP_CLAMP_PAD \
|
||||
index_vec.v = Simd::v_toInt(Simd::v_min(v_max, Simd::v_max(v_min, v_index)));
|
||||
#define FETCH_RADIAL_LOOP_EPILOGUE \
|
||||
det_vec.v = Simd::v_add(Simd::v_add(det_vec.v, delta_det4_vec.v), v_delta_delta_det6); \
|
||||
delta_det4_vec.v = Simd::v_add(delta_det4_vec.v, v_delta_delta_det16); \
|
||||
b_vec.v = Simd::v_add(b_vec.v, v_delta_b4); \
|
||||
for (int i = 0; i < 4; ++i) \
|
||||
*buffer++ = (extended_mask | v_buffer_mask.i[i]) & data->gradient.colorTable[index_vec.i[i]]; \
|
||||
}
|
||||
|
||||
#define FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP) \
|
||||
FETCH_RADIAL_LOOP_PROLOGUE \
|
||||
FETCH_RADIAL_LOOP_CLAMP \
|
||||
FETCH_RADIAL_LOOP_EPILOGUE
|
||||
|
||||
switch (data->gradient.spread) {
|
||||
case QGradient::RepeatSpread:
|
||||
FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP_REPEAT)
|
||||
break;
|
||||
case QGradient::ReflectSpread:
|
||||
FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP_REFLECT)
|
||||
break;
|
||||
case QGradient::PadSpread:
|
||||
FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP_PAD)
|
||||
break;
|
||||
default:
|
||||
Q_ASSERT(false);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#if defined(Q_CC_RVCT)
|
||||
# pragma push
|
||||
# pragma arm
|
||||
|
|
|
|||
|
|
@ -112,8 +112,6 @@ void qt_blend_rgb32_on_rgb32_sse2(uchar *destPixels, int dbpl,
|
|||
|
||||
// First, align dest to 16 bytes:
|
||||
ALIGNMENT_PROLOGUE_16BYTES(dst, x, w) {
|
||||
quint32 s = src[x];
|
||||
s = BYTE_MUL(s, const_alpha);
|
||||
dst[x] = INTERPOLATE_PIXEL_255(src[x], const_alpha, dst[x], one_minus_const_alpha);
|
||||
}
|
||||
|
||||
|
|
@ -127,8 +125,6 @@ void qt_blend_rgb32_on_rgb32_sse2(uchar *destPixels, int dbpl,
|
|||
}
|
||||
}
|
||||
for (; x<w; ++x) {
|
||||
quint32 s = src[x];
|
||||
s = BYTE_MUL(s, const_alpha);
|
||||
dst[x] = INTERPOLATE_PIXEL_255(src[x], const_alpha, dst[x], one_minus_const_alpha);
|
||||
}
|
||||
dst = (quint32 *)(((uchar *) dst) + dbpl);
|
||||
|
|
@ -491,6 +487,58 @@ void qt_bitmapblit16_sse2(QRasterBuffer *rasterBuffer, int x, int y,
|
|||
}
|
||||
}
|
||||
|
||||
class QSimdSse2
|
||||
{
|
||||
public:
|
||||
typedef __m128i Int32x4;
|
||||
typedef __m128 Float32x4;
|
||||
|
||||
union Vect_buffer_i { Int32x4 v; int i[4]; };
|
||||
union Vect_buffer_f { Float32x4 v; float f[4]; };
|
||||
|
||||
static inline Float32x4 v_dup(float x) { return _mm_set1_ps(x); }
|
||||
static inline Float32x4 v_dup(double x) { return _mm_set1_ps(x); }
|
||||
static inline Int32x4 v_dup(int x) { return _mm_set1_epi32(x); }
|
||||
static inline Int32x4 v_dup(uint x) { return _mm_set1_epi32(x); }
|
||||
|
||||
static inline Float32x4 v_add(Float32x4 a, Float32x4 b) { return _mm_add_ps(a, b); }
|
||||
static inline Int32x4 v_add(Int32x4 a, Int32x4 b) { return _mm_add_epi32(a, b); }
|
||||
|
||||
static inline Float32x4 v_max(Float32x4 a, Float32x4 b) { return _mm_max_ps(a, b); }
|
||||
static inline Float32x4 v_min(Float32x4 a, Float32x4 b) { return _mm_min_ps(a, b); }
|
||||
static inline Int32x4 v_min_16(Int32x4 a, Int32x4 b) { return _mm_min_epi16(a, b); }
|
||||
|
||||
static inline Int32x4 v_and(Int32x4 a, Int32x4 b) { return _mm_and_si128(a, b); }
|
||||
|
||||
static inline Float32x4 v_sub(Float32x4 a, Float32x4 b) { return _mm_sub_ps(a, b); }
|
||||
static inline Int32x4 v_sub(Int32x4 a, Int32x4 b) { return _mm_sub_epi32(a, b); }
|
||||
|
||||
static inline Float32x4 v_mul(Float32x4 a, Float32x4 b) { return _mm_mul_ps(a, b); }
|
||||
|
||||
static inline Float32x4 v_sqrt(Float32x4 x) { return _mm_sqrt_ps(x); }
|
||||
|
||||
static inline Int32x4 v_toInt(Float32x4 x) { return _mm_cvttps_epi32(x); }
|
||||
|
||||
// pre-VS 2008 doesn't have cast intrinsics, whereas 2008 and later requires it
|
||||
#if defined(Q_CC_MSVC) && _MSC_VER < 1500
|
||||
static inline Int32x4 v_greaterOrEqual(Float32x4 a, Float32x4 b)
|
||||
{
|
||||
union Convert { Int32x4 vi; Float32x4 vf; } convert;
|
||||
convert.vf = _mm_cmpgt_ps(a, b);
|
||||
return convert.vi;
|
||||
}
|
||||
#else
|
||||
static inline Int32x4 v_greaterOrEqual(Float32x4 a, Float32x4 b) { return _mm_castps_si128(_mm_cmpgt_ps(a, b)); }
|
||||
#endif
|
||||
};
|
||||
|
||||
const uint * QT_FASTCALL qt_fetch_radial_gradient_sse2(uint *buffer, const Operator *op, const QSpanData *data,
|
||||
int y, int x, int length)
|
||||
{
|
||||
return qt_fetch_radial_gradient_template<QRadialFetchSimd<QSimdSse2> >(buffer, op, data, y, x, length);
|
||||
}
|
||||
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
#endif // QT_HAVE_SSE2
|
||||
|
|
|
|||
|
|
@ -535,16 +535,6 @@ QString QPaintBuffer::commandDescription(int command) const
|
|||
QTextItemInt &ti = (*tiCopy)();
|
||||
QString text(ti.text());
|
||||
|
||||
QFont font(ti.font());
|
||||
font.setUnderline(false);
|
||||
font.setStrikeOut(false);
|
||||
font.setOverline(false);
|
||||
|
||||
const QTextItemInt &si = static_cast<const QTextItemInt &>(ti);
|
||||
qreal justificationWidth = 0;
|
||||
if (si.justified)
|
||||
justificationWidth = si.width.toReal();
|
||||
|
||||
debug << "Cmd_DrawTextItem:" << pos << " " << text;
|
||||
break; }
|
||||
case QPaintBufferPrivate::Cmd_SystemStateChanged: {
|
||||
|
|
@ -1778,12 +1768,12 @@ void QPainterReplayer::process(const QPaintBufferCommand &cmd)
|
|||
rawFontD->fontEngine = fontD->engineForScript(QUnicodeTables::Common);
|
||||
rawFontD->fontEngine->ref.ref();
|
||||
|
||||
QGlyphs glyphs;
|
||||
glyphs.setFont(rawFont);
|
||||
QGlyphRun glyphs;
|
||||
glyphs.setRawFont(rawFont);
|
||||
glyphs.setGlyphIndexes(glyphIndexes);
|
||||
glyphs.setPositions(positions);
|
||||
|
||||
painter->drawGlyphs(QPointF(), glyphs);
|
||||
painter->drawGlyphRun(QPointF(), glyphs);
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -4814,6 +4814,84 @@ void QGradientCache::generateGradientColorTable(const QGradient& gradient, uint
|
|||
|
||||
bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation);
|
||||
|
||||
if (stopCount == 2) {
|
||||
uint first_color = ARGB_COMBINE_ALPHA(stops[0].second.rgba(), opacity);
|
||||
uint second_color = ARGB_COMBINE_ALPHA(stops[1].second.rgba(), opacity);
|
||||
|
||||
qreal first_stop = stops[0].first;
|
||||
qreal second_stop = stops[1].first;
|
||||
|
||||
if (second_stop < first_stop) {
|
||||
qSwap(first_color, second_color);
|
||||
qSwap(first_stop, second_stop);
|
||||
}
|
||||
|
||||
if (colorInterpolation) {
|
||||
first_color = PREMUL(first_color);
|
||||
second_color = PREMUL(second_color);
|
||||
}
|
||||
|
||||
int first_index = qRound(first_stop * (GRADIENT_STOPTABLE_SIZE-1));
|
||||
int second_index = qRound(second_stop * (GRADIENT_STOPTABLE_SIZE-1));
|
||||
|
||||
uint red_first = qRed(first_color) << 16;
|
||||
uint green_first = qGreen(first_color) << 16;
|
||||
uint blue_first = qBlue(first_color) << 16;
|
||||
uint alpha_first = qAlpha(first_color) << 16;
|
||||
|
||||
uint red_second = qRed(second_color) << 16;
|
||||
uint green_second = qGreen(second_color) << 16;
|
||||
uint blue_second = qBlue(second_color) << 16;
|
||||
uint alpha_second = qAlpha(second_color) << 16;
|
||||
|
||||
int i = 0;
|
||||
for (; i <= qMin(GRADIENT_STOPTABLE_SIZE, first_index); ++i) {
|
||||
if (colorInterpolation)
|
||||
colorTable[i] = first_color;
|
||||
else
|
||||
colorTable[i] = PREMUL(first_color);
|
||||
}
|
||||
|
||||
if (i < second_index) {
|
||||
qreal reciprocal = qreal(1) / (second_index - first_index);
|
||||
|
||||
int red_delta = qRound(int(red_second - red_first) * reciprocal);
|
||||
int green_delta = qRound(int(green_second - green_first) * reciprocal);
|
||||
int blue_delta = qRound(int(blue_second - blue_first) * reciprocal);
|
||||
int alpha_delta = qRound(int(alpha_second - alpha_first) * reciprocal);
|
||||
|
||||
// rounding
|
||||
red_first += 1 << 15;
|
||||
green_first += 1 << 15;
|
||||
blue_first += 1 << 15;
|
||||
alpha_first += 1 << 15;
|
||||
|
||||
for (; i < qMin(GRADIENT_STOPTABLE_SIZE, second_index); ++i) {
|
||||
red_first += red_delta;
|
||||
green_first += green_delta;
|
||||
blue_first += blue_delta;
|
||||
alpha_first += alpha_delta;
|
||||
|
||||
const uint color = ((alpha_first << 8) & 0xff000000) | (red_first & 0xff0000)
|
||||
| ((green_first >> 8) & 0xff00) | (blue_first >> 16);
|
||||
|
||||
if (colorInterpolation)
|
||||
colorTable[i] = color;
|
||||
else
|
||||
colorTable[i] = PREMUL(color);
|
||||
}
|
||||
}
|
||||
|
||||
for (; i < GRADIENT_STOPTABLE_SIZE; ++i) {
|
||||
if (colorInterpolation)
|
||||
colorTable[i] = second_color;
|
||||
else
|
||||
colorTable[i] = PREMUL(second_color);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
uint current_color = ARGB_COMBINE_ALPHA(stops[0].second.rgba(), opacity);
|
||||
if (stopCount == 1) {
|
||||
current_color = PREMUL(current_color);
|
||||
|
|
@ -4982,10 +5060,11 @@ void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode
|
|||
QPointF center = g->center();
|
||||
radialData.center.x = center.x();
|
||||
radialData.center.y = center.y();
|
||||
radialData.center.radius = g->centerRadius();
|
||||
QPointF focal = g->focalPoint();
|
||||
radialData.focal.x = focal.x();
|
||||
radialData.focal.y = focal.y();
|
||||
radialData.radius = g->radius();
|
||||
radialData.focal.radius = g->focalRadius();
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
|
|||
|
|
@ -1012,4 +1012,50 @@ void QPaintEngineEx::updateState(const QPaintEngineState &)
|
|||
// do nothing...
|
||||
}
|
||||
|
||||
Q_GUI_EXPORT QPainterPath qt_painterPathFromVectorPath(const QVectorPath &path)
|
||||
{
|
||||
const qreal *points = path.points();
|
||||
const QPainterPath::ElementType *types = path.elements();
|
||||
|
||||
QPainterPath p;
|
||||
if (types) {
|
||||
int id = 0;
|
||||
for (int i=0; i<path.elementCount(); ++i) {
|
||||
switch(types[i]) {
|
||||
case QPainterPath::MoveToElement:
|
||||
p.moveTo(QPointF(points[id], points[id+1]));
|
||||
id+=2;
|
||||
break;
|
||||
case QPainterPath::LineToElement:
|
||||
p.lineTo(QPointF(points[id], points[id+1]));
|
||||
id+=2;
|
||||
break;
|
||||
case QPainterPath::CurveToElement: {
|
||||
QPointF p1(points[id], points[id+1]);
|
||||
QPointF p2(points[id+2], points[id+3]);
|
||||
QPointF p3(points[id+4], points[id+5]);
|
||||
p.cubicTo(p1, p2, p3);
|
||||
id+=6;
|
||||
break;
|
||||
}
|
||||
case QPainterPath::CurveToDataElement:
|
||||
;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
p.moveTo(QPointF(points[0], points[1]));
|
||||
int id = 2;
|
||||
for (int i=1; i<path.elementCount(); ++i) {
|
||||
p.lineTo(QPointF(points[id], points[id+1]));
|
||||
id+=2;
|
||||
}
|
||||
}
|
||||
if (path.hints() & QVectorPath::WindingFill)
|
||||
p.setFillRule(Qt::WindingFill);
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@
|
|||
#include "qthread.h"
|
||||
#include "qvarlengtharray.h"
|
||||
#include "qstatictext.h"
|
||||
#include "qglyphs.h"
|
||||
#include "qglyphrun.h"
|
||||
|
||||
#include <private/qfontengine_p.h>
|
||||
#include <private/qpaintengine_p.h>
|
||||
|
|
@ -69,7 +69,7 @@
|
|||
#include <private/qpaintengine_raster_p.h>
|
||||
#include <private/qmath_p.h>
|
||||
#include <private/qstatictext_p.h>
|
||||
#include <private/qglyphs_p.h>
|
||||
#include <private/qglyphrun_p.h>
|
||||
#include <private/qhexstring_p.h>
|
||||
#include <private/qguiapplication_p.h>
|
||||
#include <private/qrawfont_p.h>
|
||||
|
|
@ -477,8 +477,12 @@ void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperatio
|
|||
|
||||
q->save();
|
||||
state->matrix = QTransform();
|
||||
state->dirtyFlags |= QPaintEngine::DirtyTransform;
|
||||
updateState(state);
|
||||
if (extended) {
|
||||
extended->transformChanged();
|
||||
} else {
|
||||
state->dirtyFlags |= QPaintEngine::DirtyTransform;
|
||||
updateState(state);
|
||||
}
|
||||
engine->drawImage(absPathRect,
|
||||
image,
|
||||
QRectF(0, 0, absPathRect.width(), absPathRect.height()),
|
||||
|
|
@ -661,11 +665,14 @@ void QPainterPrivate::updateInvMatrix()
|
|||
invMatrix = state->matrix.inverted();
|
||||
}
|
||||
|
||||
extern bool qt_isExtendedRadialGradient(const QBrush &brush);
|
||||
|
||||
void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
|
||||
{
|
||||
bool alpha = false;
|
||||
bool linearGradient = false;
|
||||
bool radialGradient = false;
|
||||
bool extendedRadialGradient = false;
|
||||
bool conicalGradient = false;
|
||||
bool patternBrush = false;
|
||||
bool xform = false;
|
||||
|
|
@ -697,6 +704,7 @@ void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
|
|||
(brushStyle == Qt::LinearGradientPattern));
|
||||
radialGradient = ((penBrushStyle == Qt::RadialGradientPattern) ||
|
||||
(brushStyle == Qt::RadialGradientPattern));
|
||||
extendedRadialGradient = radialGradient && (qt_isExtendedRadialGradient(penBrush) || qt_isExtendedRadialGradient(s->brush));
|
||||
conicalGradient = ((penBrushStyle == Qt::ConicalGradientPattern) ||
|
||||
(brushStyle == Qt::ConicalGradientPattern));
|
||||
patternBrush = (((penBrushStyle > Qt::SolidPattern
|
||||
|
|
@ -780,7 +788,7 @@ void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
|
|||
s->emulationSpecifier &= ~QPaintEngine::LinearGradientFill;
|
||||
|
||||
// Radial gradient emulation
|
||||
if (radialGradient && !engine->hasFeature(QPaintEngine::RadialGradientFill))
|
||||
if (extendedRadialGradient || (radialGradient && !engine->hasFeature(QPaintEngine::RadialGradientFill)))
|
||||
s->emulationSpecifier |= QPaintEngine::RadialGradientFill;
|
||||
else
|
||||
s->emulationSpecifier &= ~QPaintEngine::RadialGradientFill;
|
||||
|
|
@ -5664,19 +5672,19 @@ void QPainter::drawImage(const QRectF &targetRect, const QImage &image, const QR
|
|||
|
||||
\since 4.8
|
||||
|
||||
\sa QGlyphs::setFont(), QGlyphs::setPositions(), QGlyphs::setGlyphIndexes()
|
||||
\sa QGlyphRun::setRawFont(), QGlyphRun::setPositions(), QGlyphRun::setGlyphIndexes()
|
||||
*/
|
||||
#if !defined(QT_NO_RAWFONT)
|
||||
void QPainter::drawGlyphs(const QPointF &position, const QGlyphs &glyphs)
|
||||
void QPainter::drawGlyphRun(const QPointF &position, const QGlyphRun &glyphRun)
|
||||
{
|
||||
Q_D(QPainter);
|
||||
|
||||
QRawFont font = glyphs.font();
|
||||
QRawFont font = glyphRun.rawFont();
|
||||
if (!font.isValid())
|
||||
return;
|
||||
|
||||
QVector<quint32> glyphIndexes = glyphs.glyphIndexes();
|
||||
QVector<QPointF> glyphPositions = glyphs.positions();
|
||||
QVector<quint32> glyphIndexes = glyphRun.glyphIndexes();
|
||||
QVector<QPointF> glyphPositions = glyphRun.positions();
|
||||
|
||||
int count = qMin(glyphIndexes.size(), glyphPositions.size());
|
||||
QVarLengthArray<QFixedPoint, 128> fixedPointPositions(count);
|
||||
|
|
@ -5685,6 +5693,13 @@ void QPainter::drawGlyphs(const QPointF &position, const QGlyphs &glyphs)
|
|||
d->extended != 0
|
||||
? qt_paintengine_supports_transformations(d->extended->type())
|
||||
: qt_paintengine_supports_transformations(d->engine->type());
|
||||
|
||||
// If the matrix is not affine, the paint engine will fall back to
|
||||
// drawing the glyphs as paths, which in turn means we should not
|
||||
// preprocess the glyph positions
|
||||
if (!d->state->matrix.isAffine())
|
||||
paintEngineSupportsTransformations = true;
|
||||
|
||||
for (int i=0; i<count; ++i) {
|
||||
QPointF processedPosition = position + glyphPositions.at(i);
|
||||
if (!paintEngineSupportsTransformations)
|
||||
|
|
@ -5692,8 +5707,8 @@ void QPainter::drawGlyphs(const QPointF &position, const QGlyphs &glyphs)
|
|||
fixedPointPositions[i] = QFixedPoint::fromPointF(processedPosition);
|
||||
}
|
||||
|
||||
d->drawGlyphs(glyphIndexes.data(), fixedPointPositions.data(), count, font, glyphs.overline(),
|
||||
glyphs.underline(), glyphs.strikeOut());
|
||||
d->drawGlyphs(glyphIndexes.data(), fixedPointPositions.data(), count, font, glyphRun.overline(),
|
||||
glyphRun.underline(), glyphRun.strikeOut());
|
||||
}
|
||||
|
||||
void QPainterPrivate::drawGlyphs(quint32 *glyphArray, QFixedPoint *positions, int glyphCount,
|
||||
|
|
@ -5728,7 +5743,7 @@ void QPainterPrivate::drawGlyphs(quint32 *glyphArray, QFixedPoint *positions, in
|
|||
|
||||
QFixed width = rightMost - leftMost;
|
||||
|
||||
if (extended != 0) {
|
||||
if (extended != 0 && state->matrix.isAffine()) {
|
||||
QStaticTextItem staticTextItem;
|
||||
staticTextItem.color = state->pen.color();
|
||||
staticTextItem.font = state->font;
|
||||
|
|
|
|||
|
|
@ -78,7 +78,7 @@ class QTextItem;
|
|||
class QMatrix;
|
||||
class QTransform;
|
||||
class QStaticText;
|
||||
class QGlyphs;
|
||||
class QGlyphRun;
|
||||
|
||||
class QPainterPrivateDeleter;
|
||||
|
||||
|
|
@ -399,7 +399,7 @@ public:
|
|||
Qt::LayoutDirection layoutDirection() const;
|
||||
|
||||
#if !defined(QT_NO_RAWFONT)
|
||||
void drawGlyphs(const QPointF &position, const QGlyphs &glyphs);
|
||||
void drawGlyphRun(const QPointF &position, const QGlyphRun &glyphRun);
|
||||
#endif
|
||||
|
||||
void drawStaticText(const QPointF &topLeftPosition, const QStaticText &staticText);
|
||||
|
|
@ -480,6 +480,7 @@ private:
|
|||
friend class QPaintEngine;
|
||||
friend class QPaintEngineExPrivate;
|
||||
friend class QOpenGLPaintEngine;
|
||||
friend class QVGPaintEngine;
|
||||
friend class QX11PaintEngine;
|
||||
friend class QX11PaintEnginePrivate;
|
||||
friend class QWin32PaintEngine;
|
||||
|
|
|
|||
|
|
@ -1126,6 +1126,7 @@ void QPainterPath::addText(const QPointF &point, const QFont &f, const QString &
|
|||
QTextEngine *eng = layout.engine();
|
||||
layout.beginLayout();
|
||||
QTextLine line = layout.createLine();
|
||||
Q_UNUSED(line);
|
||||
layout.endLayout();
|
||||
const QScriptLine &sl = eng->lines[0];
|
||||
if (!sl.length || !eng->layoutData)
|
||||
|
|
|
|||
|
|
@ -534,7 +534,10 @@ int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, qint64 serial_n
|
|||
|
||||
QImage image = img;
|
||||
QImage::Format format = image.format();
|
||||
if (image.depth() == 1 && *bitmap && img.colorTable().size() == 0) {
|
||||
if (image.depth() == 1 && *bitmap && img.colorTable().size() == 2
|
||||
&& img.colorTable().at(0) == QColor(Qt::black).rgba()
|
||||
&& img.colorTable().at(1) == QColor(Qt::white).rgba())
|
||||
{
|
||||
if (format == QImage::Format_MonoLSB)
|
||||
image = image.convertToFormat(QImage::Format_Mono);
|
||||
format = QImage::Format_Mono;
|
||||
|
|
|
|||
|
|
@ -552,6 +552,7 @@ void QStroker::joinPoints(qfixed focal_x, qfixed focal_y, const QLineF &nextLine
|
|||
|
||||
// // line to the beginning of the arc segment, (should not be needed).
|
||||
// emitLineTo(qt_real_to_fixed(curve_start.x()), qt_real_to_fixed(curve_start.y()));
|
||||
Q_UNUSED(curve_start);
|
||||
|
||||
for (int i=0; i<point_count; i+=3) {
|
||||
emitCubicTo(qt_real_to_fixed(curves[i].x()),
|
||||
|
|
|
|||
|
|
@ -803,106 +803,6 @@ int QFontEngineFT::loadFlags(QGlyphSet *set, GlyphFormat format, int flags,
|
|||
return load_flags;
|
||||
}
|
||||
|
||||
QFontEngineFT::Glyph *QFontEngineFT::loadGlyphMetrics(QGlyphSet *set, uint glyph, GlyphFormat format) const
|
||||
{
|
||||
Glyph *g = set->getGlyph(glyph);
|
||||
if (g && g->format == format)
|
||||
return g;
|
||||
|
||||
bool hsubpixel = false;
|
||||
int vfactor = 1;
|
||||
int load_flags = loadFlags(set, format, 0, hsubpixel, vfactor);
|
||||
|
||||
// apply our matrix to this, but note that the metrics will not be affected by this.
|
||||
FT_Face face = lockFace();
|
||||
FT_Matrix matrix = this->matrix;
|
||||
FT_Matrix_Multiply(&set->transformationMatrix, &matrix);
|
||||
FT_Set_Transform(face, &matrix, 0);
|
||||
freetype->matrix = matrix;
|
||||
|
||||
bool transform = matrix.xx != 0x10000 || matrix.yy != 0x10000 || matrix.xy != 0 || matrix.yx != 0;
|
||||
if (transform)
|
||||
load_flags |= FT_LOAD_NO_BITMAP;
|
||||
|
||||
FT_Error err = FT_Load_Glyph(face, glyph, load_flags);
|
||||
if (err && (load_flags & FT_LOAD_NO_BITMAP)) {
|
||||
load_flags &= ~FT_LOAD_NO_BITMAP;
|
||||
err = FT_Load_Glyph(face, glyph, load_flags);
|
||||
}
|
||||
if (err == FT_Err_Too_Few_Arguments) {
|
||||
// this is an error in the bytecode interpreter, just try to run without it
|
||||
load_flags |= FT_LOAD_FORCE_AUTOHINT;
|
||||
err = FT_Load_Glyph(face, glyph, load_flags);
|
||||
}
|
||||
if (err != FT_Err_Ok)
|
||||
qWarning("load glyph failed err=%x face=%p, glyph=%d", err, face, glyph);
|
||||
|
||||
unlockFace();
|
||||
if (set->outline_drawing)
|
||||
return 0;
|
||||
|
||||
if (!g) {
|
||||
g = new Glyph;
|
||||
g->uploadedToServer = false;
|
||||
g->data = 0;
|
||||
}
|
||||
|
||||
FT_GlyphSlot slot = face->glyph;
|
||||
if (embolden) Q_FT_GLYPHSLOT_EMBOLDEN(slot);
|
||||
int left = slot->metrics.horiBearingX;
|
||||
int right = slot->metrics.horiBearingX + slot->metrics.width;
|
||||
int top = slot->metrics.horiBearingY;
|
||||
int bottom = slot->metrics.horiBearingY - slot->metrics.height;
|
||||
if (transform && slot->format != FT_GLYPH_FORMAT_BITMAP) { // freetype doesn't apply the transformation on the metrics
|
||||
int l, r, t, b;
|
||||
FT_Vector vector;
|
||||
vector.x = left;
|
||||
vector.y = top;
|
||||
FT_Vector_Transform(&vector, &matrix);
|
||||
l = r = vector.x;
|
||||
t = b = vector.y;
|
||||
vector.x = right;
|
||||
vector.y = top;
|
||||
FT_Vector_Transform(&vector, &matrix);
|
||||
if (l > vector.x) l = vector.x;
|
||||
if (r < vector.x) r = vector.x;
|
||||
if (t < vector.y) t = vector.y;
|
||||
if (b > vector.y) b = vector.y;
|
||||
vector.x = right;
|
||||
vector.y = bottom;
|
||||
FT_Vector_Transform(&vector, &matrix);
|
||||
if (l > vector.x) l = vector.x;
|
||||
if (r < vector.x) r = vector.x;
|
||||
if (t < vector.y) t = vector.y;
|
||||
if (b > vector.y) b = vector.y;
|
||||
vector.x = left;
|
||||
vector.y = bottom;
|
||||
FT_Vector_Transform(&vector, &matrix);
|
||||
if (l > vector.x) l = vector.x;
|
||||
if (r < vector.x) r = vector.x;
|
||||
if (t < vector.y) t = vector.y;
|
||||
if (b > vector.y) b = vector.y;
|
||||
left = l;
|
||||
right = r;
|
||||
top = t;
|
||||
bottom = b;
|
||||
}
|
||||
left = FLOOR(left);
|
||||
right = CEIL(right);
|
||||
bottom = FLOOR(bottom);
|
||||
top = CEIL(top);
|
||||
|
||||
g->linearAdvance = face->glyph->linearHoriAdvance >> 10;
|
||||
g->width = TRUNC(right-left);
|
||||
g->height = TRUNC(top-bottom);
|
||||
g->x = TRUNC(left);
|
||||
g->y = TRUNC(top);
|
||||
g->advance = TRUNC(ROUND(face->glyph->advance.x));
|
||||
g->format = Format_None;
|
||||
|
||||
return g;
|
||||
}
|
||||
|
||||
QFontEngineFT::Glyph *QFontEngineFT::loadGlyph(QGlyphSet *set, uint glyph,
|
||||
QFixed subPixelPosition,
|
||||
GlyphFormat format,
|
||||
|
|
@ -1697,7 +1597,7 @@ void QFontEngineFT::recalcAdvances(QGlyphLayout *glyphs, QTextEngine::ShaperFlag
|
|||
FT_Face face = 0;
|
||||
bool design = (default_hint_style == HintNone ||
|
||||
default_hint_style == HintLight ||
|
||||
(flags & HB_ShaperFlag_UseDesignMetrics));
|
||||
(flags & HB_ShaperFlag_UseDesignMetrics)) && FT_IS_SCALABLE(freetype->face);
|
||||
for (int i = 0; i < glyphs->numGlyphs; i++) {
|
||||
Glyph *g = defaultGlyphSet.getGlyph(glyphs->glyphs[i]);
|
||||
if (g) {
|
||||
|
|
|
|||
|
|
@ -343,7 +343,6 @@ protected:
|
|||
private:
|
||||
friend class QFontEngineFTRawFont;
|
||||
|
||||
QFontEngineFT::Glyph *loadGlyphMetrics(QGlyphSet *set, uint glyph, GlyphFormat format) const;
|
||||
int loadFlags(QGlyphSet *set, GlyphFormat format, int flags, bool &hsubpixel, int &vfactor) const;
|
||||
|
||||
GlyphFormat defaultFormat;
|
||||
|
|
|
|||
|
|
@ -43,14 +43,14 @@
|
|||
|
||||
#if !defined(QT_NO_RAWFONT)
|
||||
|
||||
#include "qglyphs.h"
|
||||
#include "qglyphs_p.h"
|
||||
#include "qglyphrun.h"
|
||||
#include "qglyphrun_p.h"
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
/*!
|
||||
\class QGlyphs
|
||||
\brief The QGlyphs class provides direct access to the internal glyphs in a font.
|
||||
\class QGlyphRun
|
||||
\brief The QGlyphRun class provides direct access to the internal glyphs in a font.
|
||||
\since 4.8
|
||||
|
||||
\ingroup text
|
||||
|
|
@ -67,42 +67,43 @@ QT_BEGIN_NAMESPACE
|
|||
Under certain circumstances, it can be useful as an application developer to have more low-level
|
||||
control over which glyphs in a specific font are drawn to the screen. This could for instance
|
||||
be the case in applications that use an external font engine and text shaper together with Qt.
|
||||
QGlyphs provides an interface to the raw data needed to get text on the screen. It
|
||||
QGlyphRun provides an interface to the raw data needed to get text on the screen. It
|
||||
contains a list of glyph indexes, a position for each glyph and a font.
|
||||
|
||||
It is the user's responsibility to ensure that the selected font actually contains the
|
||||
provided glyph indexes.
|
||||
|
||||
QTextLayout::glyphs() or QTextFragment::glyphs() can be used to convert unicode encoded text
|
||||
into a list of QGlyphs objects, and QPainter::drawGlyphs() can be used to draw the glyphs.
|
||||
QTextLayout::glyphRuns() or QTextFragment::glyphRuns() can be used to convert unicode encoded
|
||||
text into a list of QGlyphRun objects, and QPainter::drawGlyphRun() can be used to draw the
|
||||
glyphs.
|
||||
|
||||
\note Please note that QRawFont is considered local to the thread in which it is constructed.
|
||||
This in turn means that a new QRawFont will have to be created and set on the QGlyphs if it is
|
||||
moved to a different thread. If the QGlyphs contains a reference to a QRawFont from a different
|
||||
This in turn means that a new QRawFont will have to be created and set on the QGlyphRun if it is
|
||||
moved to a different thread. If the QGlyphRun contains a reference to a QRawFont from a different
|
||||
thread than the current, it will not be possible to draw the glyphs using a QPainter, as the
|
||||
QRawFont is considered invalid and inaccessible in this case.
|
||||
*/
|
||||
|
||||
|
||||
/*!
|
||||
Constructs an empty QGlyphs object.
|
||||
Constructs an empty QGlyphRun object.
|
||||
*/
|
||||
QGlyphs::QGlyphs() : d(new QGlyphsPrivate)
|
||||
QGlyphRun::QGlyphRun() : d(new QGlyphRunPrivate)
|
||||
{
|
||||
}
|
||||
|
||||
/*!
|
||||
Constructs a QGlyphs object which is a copy of \a other.
|
||||
Constructs a QGlyphRun object which is a copy of \a other.
|
||||
*/
|
||||
QGlyphs::QGlyphs(const QGlyphs &other)
|
||||
QGlyphRun::QGlyphRun(const QGlyphRun &other)
|
||||
{
|
||||
d = other.d;
|
||||
}
|
||||
|
||||
/*!
|
||||
Destroys the QGlyphs.
|
||||
Destroys the QGlyphRun.
|
||||
*/
|
||||
QGlyphs::~QGlyphs()
|
||||
QGlyphRun::~QGlyphRun()
|
||||
{
|
||||
// Required for QExplicitlySharedDataPointer
|
||||
}
|
||||
|
|
@ -110,26 +111,26 @@ QGlyphs::~QGlyphs()
|
|||
/*!
|
||||
\internal
|
||||
*/
|
||||
void QGlyphs::detach()
|
||||
void QGlyphRun::detach()
|
||||
{
|
||||
if (d->ref != 1)
|
||||
d.detach();
|
||||
}
|
||||
|
||||
/*!
|
||||
Assigns \a other to this QGlyphs object.
|
||||
Assigns \a other to this QGlyphRun object.
|
||||
*/
|
||||
QGlyphs &QGlyphs::operator=(const QGlyphs &other)
|
||||
QGlyphRun &QGlyphRun::operator=(const QGlyphRun &other)
|
||||
{
|
||||
d = other.d;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/*!
|
||||
Compares \a other to this QGlyphs object. Returns true if the list of glyph indexes,
|
||||
Compares \a other to this QGlyphRun object. Returns true if the list of glyph indexes,
|
||||
the list of positions and the font are all equal, otherwise returns false.
|
||||
*/
|
||||
bool QGlyphs::operator==(const QGlyphs &other) const
|
||||
bool QGlyphRun::operator==(const QGlyphRun &other) const
|
||||
{
|
||||
return ((d == other.d)
|
||||
|| (d->glyphIndexes == other.d->glyphIndexes
|
||||
|
|
@ -137,14 +138,14 @@ bool QGlyphs::operator==(const QGlyphs &other) const
|
|||
&& d->overline == other.d->overline
|
||||
&& d->underline == other.d->underline
|
||||
&& d->strikeOut == other.d->strikeOut
|
||||
&& d->font == other.d->font));
|
||||
&& d->rawFont == other.d->rawFont));
|
||||
}
|
||||
|
||||
/*!
|
||||
Compares \a other to this QGlyphs object. Returns true if any of the list of glyph
|
||||
Compares \a other to this QGlyphRun object. Returns true if any of the list of glyph
|
||||
indexes, the list of positions or the font are different, otherwise returns false.
|
||||
*/
|
||||
bool QGlyphs::operator!=(const QGlyphs &other) const
|
||||
bool QGlyphRun::operator!=(const QGlyphRun &other) const
|
||||
{
|
||||
return !(*this == other);
|
||||
}
|
||||
|
|
@ -152,13 +153,13 @@ bool QGlyphs::operator!=(const QGlyphs &other) const
|
|||
/*!
|
||||
\internal
|
||||
|
||||
Adds together the lists of glyph indexes and positions in \a other and this QGlyphs
|
||||
object and returns the result. The font in the returned QGlyphs will be the same as in
|
||||
this QGlyphs object.
|
||||
Adds together the lists of glyph indexes and positions in \a other and this QGlyphRun
|
||||
object and returns the result. The font in the returned QGlyphRun will be the same as in
|
||||
this QGlyphRun object.
|
||||
*/
|
||||
QGlyphs QGlyphs::operator+(const QGlyphs &other) const
|
||||
QGlyphRun QGlyphRun::operator+(const QGlyphRun &other) const
|
||||
{
|
||||
QGlyphs ret(*this);
|
||||
QGlyphRun ret(*this);
|
||||
ret += other;
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -166,10 +167,10 @@ QGlyphs QGlyphs::operator+(const QGlyphs &other) const
|
|||
/*!
|
||||
\internal
|
||||
|
||||
Appends the glyph indexes and positions in \a other to this QGlyphs object and returns
|
||||
Appends the glyph indexes and positions in \a other to this QGlyphRun object and returns
|
||||
a reference to the current object.
|
||||
*/
|
||||
QGlyphs &QGlyphs::operator+=(const QGlyphs &other)
|
||||
QGlyphRun &QGlyphRun::operator+=(const QGlyphRun &other)
|
||||
{
|
||||
detach();
|
||||
|
||||
|
|
@ -180,41 +181,41 @@ QGlyphs &QGlyphs::operator+=(const QGlyphs &other)
|
|||
}
|
||||
|
||||
/*!
|
||||
Returns the font selected for this QGlyphs object.
|
||||
Returns the font selected for this QGlyphRun object.
|
||||
|
||||
\sa setFont()
|
||||
\sa setRawFont()
|
||||
*/
|
||||
QRawFont QGlyphs::font() const
|
||||
QRawFont QGlyphRun::rawFont() const
|
||||
{
|
||||
return d->font;
|
||||
return d->rawFont;
|
||||
}
|
||||
|
||||
/*!
|
||||
Sets the font in which to look up the glyph indexes to \a font.
|
||||
|
||||
\sa font(), setGlyphIndexes()
|
||||
\sa rawFont(), setGlyphIndexes()
|
||||
*/
|
||||
void QGlyphs::setFont(const QRawFont &font)
|
||||
void QGlyphRun::setRawFont(const QRawFont &rawFont)
|
||||
{
|
||||
detach();
|
||||
d->font = font;
|
||||
d->rawFont = rawFont;
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns the glyph indexes for this QGlyphs object.
|
||||
Returns the glyph indexes for this QGlyphRun object.
|
||||
|
||||
\sa setGlyphIndexes(), setPositions()
|
||||
*/
|
||||
QVector<quint32> QGlyphs::glyphIndexes() const
|
||||
QVector<quint32> QGlyphRun::glyphIndexes() const
|
||||
{
|
||||
return d->glyphIndexes;
|
||||
}
|
||||
|
||||
/*!
|
||||
Set the glyph indexes for this QGlyphs object to \a glyphIndexes. The glyph indexes must
|
||||
Set the glyph indexes for this QGlyphRun object to \a glyphIndexes. The glyph indexes must
|
||||
be valid for the selected font.
|
||||
*/
|
||||
void QGlyphs::setGlyphIndexes(const QVector<quint32> &glyphIndexes)
|
||||
void QGlyphRun::setGlyphIndexes(const QVector<quint32> &glyphIndexes)
|
||||
{
|
||||
detach();
|
||||
d->glyphIndexes = glyphIndexes;
|
||||
|
|
@ -223,7 +224,7 @@ void QGlyphs::setGlyphIndexes(const QVector<quint32> &glyphIndexes)
|
|||
/*!
|
||||
Returns the position of the edge of the baseline for each glyph in this set of glyph indexes.
|
||||
*/
|
||||
QVector<QPointF> QGlyphs::positions() const
|
||||
QVector<QPointF> QGlyphRun::positions() const
|
||||
{
|
||||
return d->glyphPositions;
|
||||
}
|
||||
|
|
@ -232,87 +233,87 @@ QVector<QPointF> QGlyphs::positions() const
|
|||
Sets the positions of the edge of the baseline for each glyph in this set of glyph indexes to
|
||||
\a positions.
|
||||
*/
|
||||
void QGlyphs::setPositions(const QVector<QPointF> &positions)
|
||||
void QGlyphRun::setPositions(const QVector<QPointF> &positions)
|
||||
{
|
||||
detach();
|
||||
d->glyphPositions = positions;
|
||||
}
|
||||
|
||||
/*!
|
||||
Clears all data in the QGlyphs object.
|
||||
Clears all data in the QGlyphRun object.
|
||||
*/
|
||||
void QGlyphs::clear()
|
||||
void QGlyphRun::clear()
|
||||
{
|
||||
detach();
|
||||
d->glyphPositions = QVector<QPointF>();
|
||||
d->glyphIndexes = QVector<quint32>();
|
||||
d->font = QRawFont();
|
||||
d->rawFont = QRawFont();
|
||||
d->strikeOut = false;
|
||||
d->overline = false;
|
||||
d->underline = false;
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns true if this QGlyphs should be painted with an overline decoration.
|
||||
Returns true if this QGlyphRun should be painted with an overline decoration.
|
||||
|
||||
\sa setOverline()
|
||||
*/
|
||||
bool QGlyphs::overline() const
|
||||
bool QGlyphRun::overline() const
|
||||
{
|
||||
return d->overline;
|
||||
}
|
||||
|
||||
/*!
|
||||
Indicates that this QGlyphs should be painted with an overline decoration if \a overline is true.
|
||||
Otherwise the QGlyphs should be painted with no overline decoration.
|
||||
Indicates that this QGlyphRun should be painted with an overline decoration if \a overline is true.
|
||||
Otherwise the QGlyphRun should be painted with no overline decoration.
|
||||
|
||||
\sa overline()
|
||||
*/
|
||||
void QGlyphs::setOverline(bool overline)
|
||||
void QGlyphRun::setOverline(bool overline)
|
||||
{
|
||||
detach();
|
||||
d->overline = overline;
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns true if this QGlyphs should be painted with an underline decoration.
|
||||
Returns true if this QGlyphRun should be painted with an underline decoration.
|
||||
|
||||
\sa setUnderline()
|
||||
*/
|
||||
bool QGlyphs::underline() const
|
||||
bool QGlyphRun::underline() const
|
||||
{
|
||||
return d->underline;
|
||||
}
|
||||
|
||||
/*!
|
||||
Indicates that this QGlyphs should be painted with an underline decoration if \a underline is
|
||||
true. Otherwise the QGlyphs should be painted with no underline decoration.
|
||||
Indicates that this QGlyphRun should be painted with an underline decoration if \a underline is
|
||||
true. Otherwise the QGlyphRun should be painted with no underline decoration.
|
||||
|
||||
\sa underline()
|
||||
*/
|
||||
void QGlyphs::setUnderline(bool underline)
|
||||
void QGlyphRun::setUnderline(bool underline)
|
||||
{
|
||||
detach();
|
||||
d->underline = underline;
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns true if this QGlyphs should be painted with a strike out decoration.
|
||||
Returns true if this QGlyphRun should be painted with a strike out decoration.
|
||||
|
||||
\sa setStrikeOut()
|
||||
*/
|
||||
bool QGlyphs::strikeOut() const
|
||||
bool QGlyphRun::strikeOut() const
|
||||
{
|
||||
return d->strikeOut;
|
||||
}
|
||||
|
||||
/*!
|
||||
Indicates that this QGlyphs should be painted with an strike out decoration if \a strikeOut is
|
||||
true. Otherwise the QGlyphs should be painted with no strike out decoration.
|
||||
Indicates that this QGlyphRun should be painted with an strike out decoration if \a strikeOut is
|
||||
true. Otherwise the QGlyphRun should be painted with no strike out decoration.
|
||||
|
||||
\sa strikeOut()
|
||||
*/
|
||||
void QGlyphs::setStrikeOut(bool strikeOut)
|
||||
void QGlyphRun::setStrikeOut(bool strikeOut)
|
||||
{
|
||||
detach();
|
||||
d->strikeOut = strikeOut;
|
||||
|
|
@ -39,8 +39,8 @@
|
|||
**
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef QGLYPHS_H
|
||||
#define QGLYPHS_H
|
||||
#ifndef QGLYPHRUN_H
|
||||
#define QGLYPHRUN_H
|
||||
|
||||
#include <QtCore/qsharedpointer.h>
|
||||
#include <QtCore/qvector.h>
|
||||
|
|
@ -55,16 +55,16 @@ QT_BEGIN_NAMESPACE
|
|||
|
||||
QT_MODULE(Gui)
|
||||
|
||||
class QGlyphsPrivate;
|
||||
class Q_GUI_EXPORT QGlyphs
|
||||
class QGlyphRunPrivate;
|
||||
class Q_GUI_EXPORT QGlyphRun
|
||||
{
|
||||
public:
|
||||
QGlyphs();
|
||||
QGlyphs(const QGlyphs &other);
|
||||
~QGlyphs();
|
||||
QGlyphRun();
|
||||
QGlyphRun(const QGlyphRun &other);
|
||||
~QGlyphRun();
|
||||
|
||||
QRawFont font() const;
|
||||
void setFont(const QRawFont &font);
|
||||
QRawFont rawFont() const;
|
||||
void setRawFont(const QRawFont &rawFont);
|
||||
|
||||
QVector<quint32> glyphIndexes() const;
|
||||
void setGlyphIndexes(const QVector<quint32> &glyphIndexes);
|
||||
|
|
@ -74,9 +74,9 @@ public:
|
|||
|
||||
void clear();
|
||||
|
||||
QGlyphs &operator=(const QGlyphs &other);
|
||||
bool operator==(const QGlyphs &other) const;
|
||||
bool operator!=(const QGlyphs &other) const;
|
||||
QGlyphRun &operator=(const QGlyphRun &other);
|
||||
bool operator==(const QGlyphRun &other) const;
|
||||
bool operator!=(const QGlyphRun &other) const;
|
||||
|
||||
void setOverline(bool overline);
|
||||
bool overline() const;
|
||||
|
|
@ -88,14 +88,14 @@ public:
|
|||
bool strikeOut() const;
|
||||
|
||||
private:
|
||||
friend class QGlyphsPrivate;
|
||||
friend class QGlyphRunPrivate;
|
||||
friend class QTextLine;
|
||||
|
||||
QGlyphs operator+(const QGlyphs &other) const;
|
||||
QGlyphs &operator+=(const QGlyphs &other);
|
||||
QGlyphRun operator+(const QGlyphRun &other) const;
|
||||
QGlyphRun &operator+=(const QGlyphRun &other);
|
||||
|
||||
void detach();
|
||||
QExplicitlySharedDataPointer<QGlyphsPrivate> d;
|
||||
QExplicitlySharedDataPointer<QGlyphRunPrivate> d;
|
||||
};
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
|
@ -39,8 +39,8 @@
|
|||
**
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef QGLYPHS_P_H
|
||||
#define QGLYPHS_P_H
|
||||
#ifndef QGLYPHRUN_P_H
|
||||
#define QGLYPHRUN_P_H
|
||||
|
||||
//
|
||||
// W A R N I N G
|
||||
|
|
@ -53,7 +53,7 @@
|
|||
// We mean it.
|
||||
//
|
||||
|
||||
#include "qglyphs.h"
|
||||
#include "qglyphrun.h"
|
||||
#include "qrawfont.h"
|
||||
|
||||
#include <qfont.h>
|
||||
|
|
@ -64,21 +64,21 @@ QT_BEGIN_HEADER
|
|||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
class QGlyphsPrivate: public QSharedData
|
||||
class QGlyphRunPrivate: public QSharedData
|
||||
{
|
||||
public:
|
||||
QGlyphsPrivate()
|
||||
QGlyphRunPrivate()
|
||||
: overline(false)
|
||||
, underline(false)
|
||||
, strikeOut(false)
|
||||
{
|
||||
}
|
||||
|
||||
QGlyphsPrivate(const QGlyphsPrivate &other)
|
||||
QGlyphRunPrivate(const QGlyphRunPrivate &other)
|
||||
: QSharedData(other)
|
||||
, glyphIndexes(other.glyphIndexes)
|
||||
, glyphPositions(other.glyphPositions)
|
||||
, font(other.font)
|
||||
, rawFont(other.rawFont)
|
||||
, overline(other.overline)
|
||||
, underline(other.underline)
|
||||
, strikeOut(other.strikeOut)
|
||||
|
|
@ -87,7 +87,7 @@ public:
|
|||
|
||||
QVector<quint32> glyphIndexes;
|
||||
QVector<QPointF> glyphPositions;
|
||||
QRawFont font;
|
||||
QRawFont rawFont;
|
||||
|
||||
uint overline : 1;
|
||||
uint underline : 1;
|
||||
|
|
@ -78,7 +78,7 @@ QT_BEGIN_NAMESPACE
|
|||
A QRawFont object represents a single, physical instance of a given font in a given pixel size.
|
||||
I.e. in the typical case it represents a set of TrueType or OpenType font tables and uses a
|
||||
user specified pixel size to convert metrics into logical pixel units. In can be used in
|
||||
combination with the QGlyphs class to draw specific glyph indexes at specific positions, and
|
||||
combination with the QGlyphRun class to draw specific glyph indexes at specific positions, and
|
||||
also have accessors to some relevant data in the physical font.
|
||||
|
||||
QRawFont only provides support for the main font technologies: GDI and DirectWrite on Windows
|
||||
|
|
@ -87,9 +87,9 @@ QT_BEGIN_NAMESPACE
|
|||
|
||||
QRawFont can be constructed in a number of ways:
|
||||
\list
|
||||
\o \l It can be constructed by calling QTextLayout::glyphs() or QTextFragment::glyphs(). The
|
||||
returned QGlyphs objects will contain QRawFont objects which represent the actual fonts
|
||||
used to render each portion of the text.
|
||||
\o \l It can be constructed by calling QTextLayout::glyphRuns() or QTextFragment::glyphRuns().
|
||||
The returned QGlyphRun objects will contain QRawFont objects which represent the actual
|
||||
fonts used to render each portion of the text.
|
||||
\o \l It can be constructed by passing a QFont object to QRawFont::fromFont(). The function
|
||||
will return a QRawFont object representing the font that will be selected as response to
|
||||
the QFont query and the selected writing system.
|
||||
|
|
@ -234,7 +234,7 @@ void QRawFont::loadFromData(const QByteArray &fontData,
|
|||
the pixel in the rasterization of the glyph. Otherwise, the image will be in the format of
|
||||
QImage::Format_A8 and each pixel will contain the opacity of the pixel in the rasterization.
|
||||
|
||||
\sa pathForGlyph(), QPainter::drawGlyphs()
|
||||
\sa pathForGlyph(), QPainter::drawGlyphRun()
|
||||
*/
|
||||
QImage QRawFont::alphaMapForGlyph(quint32 glyphIndex, AntialiasingType antialiasingType,
|
||||
const QTransform &transform) const
|
||||
|
|
@ -301,6 +301,58 @@ qreal QRawFont::descent() const
|
|||
return d->fontEngine->descent().toReal();
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns the xHeight of this QRawFont in pixel units.
|
||||
|
||||
\sa QFontMetricsF::xHeight()
|
||||
*/
|
||||
qreal QRawFont::xHeight() const
|
||||
{
|
||||
if (!isValid())
|
||||
return 0.0;
|
||||
|
||||
return d->fontEngine->xHeight().toReal();
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns the leading of this QRawFont in pixel units.
|
||||
|
||||
\sa QFontMetricsF::leading()
|
||||
*/
|
||||
qreal QRawFont::leading() const
|
||||
{
|
||||
if (!isValid())
|
||||
return 0.0;
|
||||
|
||||
return d->fontEngine->leading().toReal();
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns the average character width of this QRawFont in pixel units.
|
||||
|
||||
\sa QFontMetricsF::averageCharWidth()
|
||||
*/
|
||||
qreal QRawFont::averageCharWidth() const
|
||||
{
|
||||
if (!isValid())
|
||||
return 0.0;
|
||||
|
||||
return d->fontEngine->averageCharWidth().toReal();
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns the width of the widest character in the font.
|
||||
|
||||
\sa QFontMetricsF::maxWidth()
|
||||
*/
|
||||
qreal QRawFont::maxCharWidth() const
|
||||
{
|
||||
if (!isValid())
|
||||
return 0.0;
|
||||
|
||||
return d->fontEngine->maxCharWidth();
|
||||
}
|
||||
|
||||
/*!
|
||||
Returns the pixel size set for this QRawFont. The pixel size affects how glyphs are
|
||||
rasterized, the size of glyphs returned by pathForGlyph(), and is used to convert
|
||||
|
|
@ -374,9 +426,9 @@ int QRawFont::weight() const
|
|||
underlying font. Note that in cases where there are other tables in the font that affect the
|
||||
shaping of the text, the returned glyph indexes will not correctly represent the rendering
|
||||
of the text. To get the correctly shaped text, you can use QTextLayout to lay out and shape the
|
||||
text, and then call QTextLayout::glyphs() to get the set of glyph index list and QRawFont pairs.
|
||||
text, and then call QTextLayout::glyphRuns() to get the set of glyph index list and QRawFont pairs.
|
||||
|
||||
\sa advancesForGlyphIndexes(), QGlyphs, QTextLayout::glyphs(), QTextFragment::glyphs()
|
||||
\sa advancesForGlyphIndexes(), QGlyphRun, QTextLayout::glyphRuns(), QTextFragment::glyphRuns()
|
||||
*/
|
||||
QVector<quint32> QRawFont::glyphIndexesForString(const QString &text) const
|
||||
{
|
||||
|
|
@ -535,17 +587,17 @@ QRawFont QRawFont::fromFont(const QFont &font, QFontDatabase::WritingSystem writ
|
|||
layout.beginLayout();
|
||||
QTextLine line = layout.createLine();
|
||||
layout.endLayout();
|
||||
QList<QGlyphs> list = layout.glyphs();
|
||||
QList<QGlyphRun> list = layout.glyphRuns();
|
||||
if (list.size()) {
|
||||
// Pick the one matches the family name we originally requested,
|
||||
// if none of them match, just pick the first one
|
||||
for (int i = 0; i < list.size(); i++) {
|
||||
QGlyphs glyphs = list.at(i);
|
||||
QRawFont rawfont = glyphs.font();
|
||||
QGlyphRun glyphs = list.at(i);
|
||||
QRawFont rawfont = glyphs.rawFont();
|
||||
if (rawfont.familyName() == font.family())
|
||||
return rawfont;
|
||||
}
|
||||
return list.at(0).font();
|
||||
return list.at(0).rawFont();
|
||||
}
|
||||
return QRawFont();
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -103,6 +103,10 @@ public:
|
|||
|
||||
qreal ascent() const;
|
||||
qreal descent() const;
|
||||
qreal leading() const;
|
||||
qreal xHeight() const;
|
||||
qreal averageCharWidth() const;
|
||||
qreal maxCharWidth() const;
|
||||
|
||||
qreal unitsPerEm() const;
|
||||
|
||||
|
|
|
|||
|
|
@ -3090,6 +3090,7 @@ void QTextDocumentLayoutPrivate::ensureLayouted(QFixed y) const
|
|||
if (currentLazyLayoutPosition == -1)
|
||||
return;
|
||||
const QSizeF oldSize = q->dynamicDocumentSize();
|
||||
Q_UNUSED(oldSize);
|
||||
|
||||
if (checkPoints.isEmpty())
|
||||
layoutStep();
|
||||
|
|
|
|||
|
|
@ -50,8 +50,8 @@
|
|||
#include "qtextdocument_p.h"
|
||||
#include "qtextformat_p.h"
|
||||
#include "qpainterpath.h"
|
||||
#include "qglyphs.h"
|
||||
#include "qglyphs_p.h"
|
||||
#include "qglyphrun.h"
|
||||
#include "qglyphrun_p.h"
|
||||
#include "qrawfont.h"
|
||||
#include "qrawfont_p.h"
|
||||
#include <limits.h>
|
||||
|
|
@ -992,12 +992,12 @@ static inline QRectF clipIfValid(const QRectF &rect, const QRectF &clip)
|
|||
|
||||
\since 4.8
|
||||
|
||||
\sa draw(), QPainter::drawGlyphs()
|
||||
\sa draw(), QPainter::drawGlyphRun()
|
||||
*/
|
||||
#if !defined(QT_NO_RAWFONT)
|
||||
QList<QGlyphs> QTextLayout::glyphs() const
|
||||
QList<QGlyphRun> QTextLayout::glyphRuns() const
|
||||
{
|
||||
QList<QGlyphs> glyphs;
|
||||
QList<QGlyphRun> glyphs;
|
||||
for (int i=0; i<d->lines.size(); ++i)
|
||||
glyphs += QTextLine(i, d).glyphs(-1, -1);
|
||||
|
||||
|
|
@ -1209,8 +1209,6 @@ void QTextLayout::drawCursor(QPainter *p, const QPointF &pos, int cursorPosition
|
|||
d->itemize();
|
||||
|
||||
QPointF position = pos + d->position;
|
||||
QFixed pos_x = QFixed::fromReal(position.x());
|
||||
QFixed pos_y = QFixed::fromReal(position.y());
|
||||
|
||||
cursorPosition = qBound(0, cursorPosition, d->layoutData->string.length());
|
||||
int line = d->lineNumberForTextPosition(cursorPosition);
|
||||
|
|
@ -2093,15 +2091,15 @@ namespace {
|
|||
|
||||
\since 4.8
|
||||
|
||||
\sa QTextLayout::glyphs()
|
||||
\sa QTextLayout::glyphRuns()
|
||||
*/
|
||||
#if !defined(QT_NO_RAWFONT)
|
||||
QList<QGlyphs> QTextLine::glyphs(int from, int length) const
|
||||
QList<QGlyphRun> QTextLine::glyphs(int from, int length) const
|
||||
{
|
||||
const QScriptLine &line = eng->lines[i];
|
||||
|
||||
if (line.length == 0)
|
||||
return QList<QGlyphs>();
|
||||
return QList<QGlyphRun>();
|
||||
|
||||
QHash<QFontEngine *, GlyphInfo> glyphLayoutHash;
|
||||
|
||||
|
|
@ -2166,7 +2164,7 @@ QList<QGlyphs> QTextLine::glyphs(int from, int length) const
|
|||
}
|
||||
}
|
||||
|
||||
QHash<QPair<QFontEngine *, int>, QGlyphs> glyphsHash;
|
||||
QHash<QPair<QFontEngine *, int>, QGlyphRun> glyphsHash;
|
||||
|
||||
QList<QFontEngine *> keys = glyphLayoutHash.uniqueKeys();
|
||||
for (int i=0; i<keys.size(); ++i) {
|
||||
|
|
@ -2223,14 +2221,14 @@ QList<QGlyphs> QTextLine::glyphs(int from, int length) const
|
|||
positions.append(positionsArray.at(i).toPointF() + pos);
|
||||
}
|
||||
|
||||
QGlyphs glyphIndexes;
|
||||
QGlyphRun glyphIndexes;
|
||||
glyphIndexes.setGlyphIndexes(glyphs);
|
||||
glyphIndexes.setPositions(positions);
|
||||
|
||||
glyphIndexes.setOverline(flags.testFlag(QTextItem::Overline));
|
||||
glyphIndexes.setUnderline(flags.testFlag(QTextItem::Underline));
|
||||
glyphIndexes.setStrikeOut(flags.testFlag(QTextItem::StrikeOut));
|
||||
glyphIndexes.setFont(font);
|
||||
glyphIndexes.setRawFont(font);
|
||||
|
||||
QPair<QFontEngine *, int> key(fontEngine, int(flags));
|
||||
if (!glyphsHash.contains(key))
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@
|
|||
#include <QtCore/qobject.h>
|
||||
#include <QtGui/qevent.h>
|
||||
#include <QtGui/qtextformat.h>
|
||||
#include <QtGui/qglyphs.h>
|
||||
#include <QtGui/qglyphrun.h>
|
||||
#include <QtGui/qtextcursor.h>
|
||||
|
||||
QT_BEGIN_HEADER
|
||||
|
|
@ -174,7 +174,7 @@ public:
|
|||
qreal maximumWidth() const;
|
||||
|
||||
#if !defined(QT_NO_RAWFONT)
|
||||
QList<QGlyphs> glyphs() const;
|
||||
QList<QGlyphRun> glyphRuns() const;
|
||||
#endif
|
||||
|
||||
QTextEngine *engine() const { return d; }
|
||||
|
|
@ -249,7 +249,7 @@ private:
|
|||
void layout_helper(int numGlyphs);
|
||||
|
||||
#if !defined(QT_NO_RAWFONT)
|
||||
QList<QGlyphs> glyphs(int from, int length) const;
|
||||
QList<QGlyphRun> glyphs(int from, int length) const;
|
||||
#endif
|
||||
|
||||
friend class QTextLayout;
|
||||
|
|
|
|||
|
|
@ -1664,25 +1664,25 @@ QTextBlock::iterator &QTextBlock::iterator::operator--()
|
|||
Returns the glyphs of this text fragment. The positions of the glyphs are
|
||||
relative to the position of the QTextBlock's layout.
|
||||
|
||||
\sa QGlyphs, QTextBlock::layout(), QTextLayout::position(), QPainter::drawGlyphs()
|
||||
\sa QGlyphRun, QTextBlock::layout(), QTextLayout::position(), QPainter::drawGlyphRun()
|
||||
*/
|
||||
#if !defined(QT_NO_RAWFONT)
|
||||
QList<QGlyphs> QTextFragment::glyphs() const
|
||||
QList<QGlyphRun> QTextFragment::glyphRuns() const
|
||||
{
|
||||
if (!p || !n)
|
||||
return QList<QGlyphs>();
|
||||
return QList<QGlyphRun>();
|
||||
|
||||
int pos = position();
|
||||
int len = length();
|
||||
if (len == 0)
|
||||
return QList<QGlyphs>();
|
||||
return QList<QGlyphRun>();
|
||||
|
||||
int blockNode = p->blockMap().findNode(pos);
|
||||
|
||||
const QTextBlockData *blockData = p->blockMap().fragment(blockNode);
|
||||
QTextLayout *layout = blockData->layout;
|
||||
|
||||
QList<QGlyphs> ret;
|
||||
QList<QGlyphRun> ret;
|
||||
for (int i=0; i<layout->lineCount(); ++i) {
|
||||
QTextLine textLine = layout->lineAt(i);
|
||||
ret += textLine.glyphs(pos, len);
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@
|
|||
|
||||
#include <QtCore/qobject.h>
|
||||
#include <QtGui/qtextformat.h>
|
||||
#include <QtGui/qglyphs.h>
|
||||
#include <QtGui/qglyphrun.h>
|
||||
|
||||
QT_BEGIN_HEADER
|
||||
|
||||
|
|
@ -317,7 +317,7 @@ public:
|
|||
QString text() const;
|
||||
|
||||
#if !defined(QT_NO_RAWFONT)
|
||||
QList<QGlyphs> glyphs() const;
|
||||
QList<QGlyphRun> glyphRuns() const;
|
||||
#endif
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -38,10 +38,10 @@ HEADERS += \
|
|||
text/qtextodfwriter_p.h \
|
||||
text/qstatictext_p.h \
|
||||
text/qstatictext.h \
|
||||
text/qglyphs.h \
|
||||
text/qglyphs_p.h \
|
||||
text/qrawfont.h \
|
||||
text/qrawfont_p.h
|
||||
text/qrawfont_p.h \
|
||||
text/qglyphrun.h \
|
||||
text/qglyphrun_p.h
|
||||
|
||||
SOURCES += \
|
||||
text/qfont.cpp \
|
||||
|
|
@ -71,8 +71,8 @@ SOURCES += \
|
|||
text/qzip.cpp \
|
||||
text/qtextodfwriter.cpp \
|
||||
text/qstatictext.cpp \
|
||||
text/qglyphs.cpp \
|
||||
text/qrawfont.cpp
|
||||
text/qrawfont.cpp \
|
||||
text/qglyphrun.cpp
|
||||
|
||||
win32 {
|
||||
SOURCES += \
|
||||
|
|
|
|||
|
|
@ -14,7 +14,6 @@ HEADERS += \
|
|||
access/qnetworkaccesscache_p.h \
|
||||
access/qnetworkaccessbackend_p.h \
|
||||
access/qnetworkaccessdebugpipebackend_p.h \
|
||||
access/qnetworkaccesshttpbackend_p.h \
|
||||
access/qnetworkaccessfilebackend_p.h \
|
||||
access/qnetworkaccesscachebackend_p.h \
|
||||
access/qnetworkaccessftpbackend_p.h \
|
||||
|
|
@ -29,6 +28,7 @@ HEADERS += \
|
|||
access/qnetworkreply_p.h \
|
||||
access/qnetworkreplyimpl_p.h \
|
||||
access/qnetworkreplydataimpl_p.h \
|
||||
access/qnetworkreplyhttpimpl_p.h \
|
||||
access/qnetworkreplyfileimpl_p.h \
|
||||
access/qabstractnetworkcache_p.h \
|
||||
access/qabstractnetworkcache.h \
|
||||
|
|
@ -54,13 +54,13 @@ SOURCES += \
|
|||
access/qnetworkaccessfilebackend.cpp \
|
||||
access/qnetworkaccesscachebackend.cpp \
|
||||
access/qnetworkaccessftpbackend.cpp \
|
||||
access/qnetworkaccesshttpbackend.cpp \
|
||||
access/qnetworkcookie.cpp \
|
||||
access/qnetworkcookiejar.cpp \
|
||||
access/qnetworkrequest.cpp \
|
||||
access/qnetworkreply.cpp \
|
||||
access/qnetworkreplyimpl.cpp \
|
||||
access/qnetworkreplydataimpl.cpp \
|
||||
access/qnetworkreplyhttpimpl.cpp \
|
||||
access/qnetworkreplyfileimpl.cpp \
|
||||
access/qabstractnetworkcache.cpp \
|
||||
access/qnetworkdiskcache.cpp \
|
||||
|
|
|
|||
|
|
@ -117,7 +117,6 @@ QHttpNetworkConnectionPrivate::~QHttpNetworkConnectionPrivate()
|
|||
|
||||
void QHttpNetworkConnectionPrivate::init()
|
||||
{
|
||||
Q_Q(QHttpNetworkConnection);
|
||||
for (int i = 0; i < channelCount; i++) {
|
||||
channels[i].setConnection(this->q_func());
|
||||
channels[i].ssl = encrypt;
|
||||
|
|
@ -520,6 +519,15 @@ bool QHttpNetworkConnectionPrivate::dequeueRequest(QAbstractSocket *socket)
|
|||
return false;
|
||||
}
|
||||
|
||||
QHttpNetworkRequest QHttpNetworkConnectionPrivate::predictNextRequest()
|
||||
{
|
||||
if (!highPriorityQueue.isEmpty())
|
||||
return highPriorityQueue.last().first;
|
||||
if (!lowPriorityQueue.isEmpty())
|
||||
return lowPriorityQueue.last().first;
|
||||
return QHttpNetworkRequest();
|
||||
}
|
||||
|
||||
// this is called from _q_startNextRequest and when a request has been sent down a socket from the channel
|
||||
void QHttpNetworkConnectionPrivate::fillPipeline(QAbstractSocket *socket)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -169,6 +169,7 @@ public:
|
|||
void requeueRequest(const HttpMessagePair &pair); // e.g. after pipeline broke
|
||||
bool dequeueRequest(QAbstractSocket *socket);
|
||||
void prepareRequest(HttpMessagePair &request);
|
||||
QHttpNetworkRequest predictNextRequest();
|
||||
|
||||
void fillPipeline(QAbstractSocket *socket);
|
||||
bool fillPipeline(QList<HttpMessagePair> &queue, QHttpNetworkConnectionChannel &channel);
|
||||
|
|
|
|||
|
|
@ -579,6 +579,17 @@ bool QHttpNetworkConnectionChannel::ensureConnection()
|
|||
connectHost = connection->d_func()->networkProxy.hostName();
|
||||
connectPort = connection->d_func()->networkProxy.port();
|
||||
}
|
||||
if (socket->proxy().type() == QNetworkProxy::HttpProxy) {
|
||||
// Make user-agent field available to HTTP proxy socket engine (QTBUG-17223)
|
||||
QByteArray value;
|
||||
// ensureConnection is called before any request has been assigned, but can also be called again if reconnecting
|
||||
if (request.url().isEmpty())
|
||||
value = connection->d_func()->predictNextRequest().headerField("user-agent");
|
||||
else
|
||||
value = request.headerField("user-agent");
|
||||
if (!value.isEmpty())
|
||||
socket->setProperty("_q_user-agent", value);
|
||||
}
|
||||
#endif
|
||||
if (ssl) {
|
||||
#ifndef QT_NO_OPENSSL
|
||||
|
|
|
|||
|
|
@ -41,6 +41,7 @@
|
|||
|
||||
#include "qnetworkaccessbackend_p.h"
|
||||
#include "qnetworkaccessmanager_p.h"
|
||||
#include "qnetworkconfigmanager.h"
|
||||
#include "qnetworkrequest.h"
|
||||
#include "qnetworkreply.h"
|
||||
#include "qnetworkreply_p.h"
|
||||
|
|
@ -315,13 +316,13 @@ void QNetworkAccessBackend::error(QNetworkReply::NetworkError code, const QStrin
|
|||
void QNetworkAccessBackend::proxyAuthenticationRequired(const QNetworkProxy &proxy,
|
||||
QAuthenticator *authenticator)
|
||||
{
|
||||
manager->proxyAuthenticationRequired(this, proxy, authenticator);
|
||||
manager->proxyAuthenticationRequired(proxy, synchronous, authenticator, &reply->lastProxyAuthentication);
|
||||
}
|
||||
#endif
|
||||
|
||||
void QNetworkAccessBackend::authenticationRequired(QAuthenticator *authenticator)
|
||||
{
|
||||
manager->authenticationRequired(this, authenticator);
|
||||
manager->authenticationRequired(authenticator, reply->q_func(), synchronous, reply->url, &reply->urlForLastAuthentication);
|
||||
}
|
||||
|
||||
void QNetworkAccessBackend::metaDataChanged()
|
||||
|
|
@ -343,8 +344,6 @@ void QNetworkAccessBackend::sslErrors(const QList<QSslError> &errors)
|
|||
#endif
|
||||
}
|
||||
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
|
||||
/*!
|
||||
Starts the backend. Returns true if the backend is started. Returns false if the backend
|
||||
could not be started due to an unopened or roaming session. The caller should recall this
|
||||
|
|
@ -352,31 +351,62 @@ void QNetworkAccessBackend::sslErrors(const QList<QSslError> &errors)
|
|||
*/
|
||||
bool QNetworkAccessBackend::start()
|
||||
{
|
||||
if (!manager->networkSession) {
|
||||
open();
|
||||
return true;
|
||||
}
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
// For bearer, check if session start is required
|
||||
if (manager->networkSession) {
|
||||
// session required
|
||||
if (manager->networkSession->isOpen() &&
|
||||
manager->networkSession->state() == QNetworkSession::Connected) {
|
||||
// Session is already open and ready to use.
|
||||
// copy network session down to the backend
|
||||
setProperty("_q_networksession", QVariant::fromValue(manager->networkSession));
|
||||
} else {
|
||||
// Session not ready, but can skip for loopback connections
|
||||
|
||||
// This is not ideal.
|
||||
const QString host = reply->url.host();
|
||||
if (host == QLatin1String("localhost") ||
|
||||
QHostAddress(host) == QHostAddress::LocalHost ||
|
||||
QHostAddress(host) == QHostAddress::LocalHostIPv6) {
|
||||
// Don't need an open session for localhost access.
|
||||
open();
|
||||
return true;
|
||||
}
|
||||
// This is not ideal.
|
||||
const QString host = reply->url.host();
|
||||
|
||||
if (manager->networkSession->isOpen() &&
|
||||
manager->networkSession->state() == QNetworkSession::Connected) {
|
||||
//copy network session down to the backend
|
||||
setProperty("_q_networksession", QVariant::fromValue(manager->networkSession));
|
||||
open();
|
||||
return true;
|
||||
if (host == QLatin1String("localhost") ||
|
||||
QHostAddress(host) == QHostAddress::LocalHost ||
|
||||
QHostAddress(host) == QHostAddress::LocalHostIPv6) {
|
||||
// Don't need an open session for localhost access.
|
||||
} else {
|
||||
// need to wait for session to be opened
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef QT_NO_NETWORKPROXY
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
// Get the proxy settings from the network session (in the case of service networks,
|
||||
// the proxy settings change depending which AP was activated)
|
||||
QNetworkSession *session = manager->networkSession.data();
|
||||
QNetworkConfiguration config;
|
||||
if (session) {
|
||||
QNetworkConfigurationManager configManager;
|
||||
// The active configuration tells us what IAP is in use
|
||||
QVariant v = session->sessionProperty(QLatin1String("ActiveConfiguration"));
|
||||
if (v.isValid())
|
||||
config = configManager.configurationFromIdentifier(qvariant_cast<QString>(v));
|
||||
// Fallback to using the configuration if no active configuration
|
||||
if (!config.isValid())
|
||||
config = session->configuration();
|
||||
// or unspecified configuration if that is no good either
|
||||
if (!config.isValid())
|
||||
config = QNetworkConfiguration();
|
||||
}
|
||||
reply->proxyList = manager->queryProxy(QNetworkProxyQuery(config, url()));
|
||||
#else // QT_NO_BEARERMANAGEMENT
|
||||
// Without bearer management, the proxy depends only on the url
|
||||
reply->proxyList = manager->queryProxy(QNetworkProxyQuery(url()));
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// now start the request
|
||||
open();
|
||||
return true;
|
||||
}
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
|
|
|||
|
|
@ -66,6 +66,7 @@ void QNetworkAccessCacheBackend::open()
|
|||
QString msg = QCoreApplication::translate("QNetworkAccessCacheBackend", "Error opening %1")
|
||||
.arg(this->url().toString());
|
||||
error(QNetworkReply::ContentNotFoundError, msg);
|
||||
} else {
|
||||
setAttribute(QNetworkRequest::SourceIsFromCacheAttribute, true);
|
||||
}
|
||||
finished();
|
||||
|
|
@ -85,14 +86,18 @@ bool QNetworkAccessCacheBackend::sendCacheContents()
|
|||
QNetworkCacheMetaData::AttributesMap attributes = item.attributes();
|
||||
setAttribute(QNetworkRequest::HttpStatusCodeAttribute, attributes.value(QNetworkRequest::HttpStatusCodeAttribute));
|
||||
setAttribute(QNetworkRequest::HttpReasonPhraseAttribute, attributes.value(QNetworkRequest::HttpReasonPhraseAttribute));
|
||||
setAttribute(QNetworkRequest::SourceIsFromCacheAttribute, true);
|
||||
|
||||
// set the raw headers
|
||||
QNetworkCacheMetaData::RawHeaderList rawHeaders = item.rawHeaders();
|
||||
QNetworkCacheMetaData::RawHeaderList::ConstIterator it = rawHeaders.constBegin(),
|
||||
end = rawHeaders.constEnd();
|
||||
for ( ; it != end; ++it)
|
||||
for ( ; it != end; ++it) {
|
||||
if (it->first.toLower() == "cache-control" &&
|
||||
it->second.toLower().contains("must-revalidate")) {
|
||||
return false;
|
||||
}
|
||||
setRawHeader(it->first, it->second);
|
||||
}
|
||||
|
||||
// handle a possible redirect
|
||||
QVariant redirectionTarget = attributes.value(QNetworkRequest::RedirectionTargetAttribute);
|
||||
|
|
|
|||
|
|
@ -262,13 +262,11 @@ bool QNetworkAccessHttpBackend::loadFromCacheIfAllowed(QHttpNetworkRequest &http
|
|||
if (lastModified.isValid())
|
||||
httpRequest.setHeaderField("If-Modified-Since", QNetworkHeadersPrivate::toHttpDate(lastModified));
|
||||
|
||||
if (CacheLoadControlAttribute == QNetworkRequest::PreferNetwork) {
|
||||
it = cacheHeaders.findRawHeader("Cache-Control");
|
||||
if (it != cacheHeaders.rawHeaders.constEnd()) {
|
||||
QHash<QByteArray, QByteArray> cacheControl = parseHttpOptionHeader(it->second);
|
||||
if (cacheControl.contains("must-revalidate"))
|
||||
return false;
|
||||
}
|
||||
it = cacheHeaders.findRawHeader("Cache-Control");
|
||||
if (it != cacheHeaders.rawHeaders.constEnd()) {
|
||||
QHash<QByteArray, QByteArray> cacheControl = parseHttpOptionHeader(it->second);
|
||||
if (cacheControl.contains("must-revalidate"))
|
||||
return false;
|
||||
}
|
||||
|
||||
QDateTime currentDateTime = QDateTime::currentDateTime();
|
||||
|
|
|
|||
|
|
@ -67,13 +67,12 @@
|
|||
#include "QtNetwork/qhttpmultipart.h"
|
||||
#include "qhttpmultipart_p.h"
|
||||
|
||||
#include "qnetworkreplyhttpimpl_p.h"
|
||||
|
||||
#include "qthread.h"
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
#ifndef QT_NO_HTTP
|
||||
Q_GLOBAL_STATIC(QNetworkAccessHttpBackendFactory, httpBackend)
|
||||
#endif // QT_NO_HTTP
|
||||
Q_GLOBAL_STATIC(QNetworkAccessFileBackendFactory, fileBackend)
|
||||
#ifndef QT_NO_FTP
|
||||
Q_GLOBAL_STATIC(QNetworkAccessFtpBackendFactory, ftpBackend)
|
||||
|
|
@ -85,10 +84,6 @@ Q_GLOBAL_STATIC(QNetworkAccessDebugPipeBackendFactory, debugpipeBackend)
|
|||
|
||||
static void ensureInitialized()
|
||||
{
|
||||
#ifndef QT_NO_HTTP
|
||||
(void) httpBackend();
|
||||
#endif // QT_NO_HTTP
|
||||
|
||||
#ifndef QT_NO_FTP
|
||||
(void) ftpBackend();
|
||||
#endif
|
||||
|
|
@ -356,6 +351,17 @@ QNetworkAccessManager::QNetworkAccessManager(QObject *parent)
|
|||
ensureInitialized();
|
||||
|
||||
qRegisterMetaType<QNetworkReply::NetworkError>("QNetworkReply::NetworkError");
|
||||
#ifndef QT_NO_NETWORKPROXY
|
||||
qRegisterMetaType<QNetworkProxy>("QNetworkProxy");
|
||||
#endif
|
||||
#ifndef QT_NO_OPENSSL
|
||||
qRegisterMetaType<QList<QSslError> >("QList<QSslError>");
|
||||
qRegisterMetaType<QSslConfiguration>("QSslConfiguration");
|
||||
#endif
|
||||
qRegisterMetaType<QList<QPair<QByteArray,QByteArray> > >("QList<QPair<QByteArray,QByteArray> >");
|
||||
qRegisterMetaType<QHttpNetworkRequest>("QHttpNetworkRequest");
|
||||
qRegisterMetaType<QNetworkReply::NetworkError>("QNetworkReply::NetworkError");
|
||||
qRegisterMetaType<QSharedPointer<char> >("QSharedPointer<char>");
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -861,7 +867,7 @@ QNetworkAccessManager::NetworkAccessibility QNetworkAccessManager::networkAccess
|
|||
device will be uploaded to the server; in that case, data must be open for
|
||||
reading and must remain valid until the finished() signal is emitted for this reply.
|
||||
|
||||
\note This feature is currently available for HTTP only.
|
||||
\note This feature is currently available for HTTP(S) only.
|
||||
|
||||
\sa get(), post(), put(), deleteResource()
|
||||
*/
|
||||
|
|
@ -967,6 +973,18 @@ QNetworkReply *QNetworkAccessManager::createRequest(QNetworkAccessManager::Opera
|
|||
}
|
||||
}
|
||||
|
||||
#ifndef QT_NO_HTTP
|
||||
// Since Qt 5 we use the new QNetworkReplyHttpImpl
|
||||
if (scheme == QLatin1String("http") || scheme == QLatin1String("https") ) {
|
||||
QNetworkReplyHttpImpl *reply = new QNetworkReplyHttpImpl(this, request, op, outgoingData);
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
connect(this, SIGNAL(networkSessionConnected()),
|
||||
reply, SLOT(_q_networkSessionConnected()));
|
||||
#endif
|
||||
return reply;
|
||||
}
|
||||
#endif // QT_NO_HTTP
|
||||
|
||||
// first step: create the reply
|
||||
QUrl url = request.url();
|
||||
QNetworkReplyImpl *reply = new QNetworkReplyImpl(this);
|
||||
|
|
@ -986,10 +1004,6 @@ QNetworkReply *QNetworkAccessManager::createRequest(QNetworkAccessManager::Opera
|
|||
// third step: find a backend
|
||||
priv->backend = d->findBackend(op, request);
|
||||
|
||||
#ifndef QT_NO_NETWORKPROXY
|
||||
QList<QNetworkProxy> proxyList = d->queryProxy(QNetworkProxyQuery(request.url()));
|
||||
priv->proxyList = proxyList;
|
||||
#endif
|
||||
if (priv->backend) {
|
||||
priv->backend->setParent(reply);
|
||||
priv->backend->reply = priv;
|
||||
|
|
@ -1055,42 +1069,43 @@ void QNetworkAccessManagerPrivate::createCookieJar() const
|
|||
}
|
||||
}
|
||||
|
||||
void QNetworkAccessManagerPrivate::authenticationRequired(QNetworkAccessBackend *backend,
|
||||
QAuthenticator *authenticator)
|
||||
void QNetworkAccessManagerPrivate::authenticationRequired(QAuthenticator *authenticator,
|
||||
QNetworkReply *reply,
|
||||
bool synchronous,
|
||||
QUrl &url,
|
||||
QUrl *urlForLastAuthentication)
|
||||
{
|
||||
Q_Q(QNetworkAccessManager);
|
||||
|
||||
// FIXME: Add support for domains (i.e., the leading path)
|
||||
QUrl url = backend->reply->url;
|
||||
|
||||
// don't try the cache for the same URL twice in a row
|
||||
// being called twice for the same URL means the authentication failed
|
||||
// also called when last URL is empty, e.g. on first call
|
||||
if (backend->reply->urlForLastAuthentication.isEmpty()
|
||||
|| url != backend->reply->urlForLastAuthentication) {
|
||||
if (urlForLastAuthentication->isEmpty()
|
||||
|| url != *urlForLastAuthentication) {
|
||||
QNetworkAuthenticationCredential cred = authenticationManager->fetchCachedCredentials(url, authenticator);
|
||||
if (!cred.isNull()) {
|
||||
authenticator->setUser(cred.user);
|
||||
authenticator->setPassword(cred.password);
|
||||
backend->reply->urlForLastAuthentication = url;
|
||||
*urlForLastAuthentication = url;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// if we emit a signal here in synchronous mode, the user might spin
|
||||
// an event loop, which might recurse and lead to problems
|
||||
if (backend->isSynchronous())
|
||||
if (synchronous)
|
||||
return;
|
||||
|
||||
backend->reply->urlForLastAuthentication = url;
|
||||
emit q->authenticationRequired(backend->reply->q_func(), authenticator);
|
||||
*urlForLastAuthentication = url;
|
||||
emit q->authenticationRequired(reply, authenticator);
|
||||
authenticationManager->cacheCredentials(url, authenticator);
|
||||
}
|
||||
|
||||
#ifndef QT_NO_NETWORKPROXY
|
||||
void QNetworkAccessManagerPrivate::proxyAuthenticationRequired(QNetworkAccessBackend *backend,
|
||||
const QNetworkProxy &proxy,
|
||||
QAuthenticator *authenticator)
|
||||
void QNetworkAccessManagerPrivate::proxyAuthenticationRequired(const QNetworkProxy &proxy,
|
||||
bool synchronous,
|
||||
QAuthenticator *authenticator,
|
||||
QNetworkProxy *lastProxyAuthentication)
|
||||
{
|
||||
Q_Q(QNetworkAccessManager);
|
||||
// ### FIXME Tracking of successful authentications
|
||||
|
|
@ -1100,7 +1115,7 @@ void QNetworkAccessManagerPrivate::proxyAuthenticationRequired(QNetworkAccessBac
|
|||
// proxyAuthenticationRequired gets emitted again
|
||||
// possible solution: some tracking inside the authenticator
|
||||
// or a new function proxyAuthenticationSucceeded(true|false)
|
||||
if (proxy != backend->reply->lastProxyAuthentication) {
|
||||
if (proxy != *lastProxyAuthentication) {
|
||||
QNetworkAuthenticationCredential cred = authenticationManager->fetchCachedProxyCredentials(proxy);
|
||||
if (!cred.isNull()) {
|
||||
authenticator->setUser(cred.user);
|
||||
|
|
@ -1111,10 +1126,10 @@ void QNetworkAccessManagerPrivate::proxyAuthenticationRequired(QNetworkAccessBac
|
|||
|
||||
// if we emit a signal here in synchronous mode, the user might spin
|
||||
// an event loop, which might recurse and lead to problems
|
||||
if (backend->isSynchronous())
|
||||
if (synchronous)
|
||||
return;
|
||||
|
||||
backend->reply->lastProxyAuthentication = proxy;
|
||||
*lastProxyAuthentication = proxy;
|
||||
emit q->proxyAuthenticationRequired(proxy, authenticator);
|
||||
authenticationManager->cacheProxyCredentials(proxy, authenticator);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -160,6 +160,7 @@ protected:
|
|||
private:
|
||||
friend class QNetworkReplyImplPrivate;
|
||||
friend class QNetworkAccessHttpBackend;
|
||||
friend class QNetworkReplyHttpImpl;
|
||||
|
||||
Q_DECLARE_PRIVATE(QNetworkAccessManager)
|
||||
Q_PRIVATE_SLOT(d_func(), void _q_replyFinished())
|
||||
|
|
|
|||
|
|
@ -94,14 +94,20 @@ public:
|
|||
QNetworkReply *postProcess(QNetworkReply *reply);
|
||||
void createCookieJar() const;
|
||||
|
||||
void authenticationRequired(QNetworkAccessBackend *backend, QAuthenticator *authenticator);
|
||||
void authenticationRequired(QAuthenticator *authenticator,
|
||||
QNetworkReply *reply,
|
||||
bool synchronous,
|
||||
QUrl &url,
|
||||
QUrl *urlForLastAuthentication);
|
||||
void cacheCredentials(const QUrl &url, const QAuthenticator *auth);
|
||||
QNetworkAuthenticationCredential *fetchCachedCredentials(const QUrl &url,
|
||||
const QAuthenticator *auth = 0);
|
||||
|
||||
#ifndef QT_NO_NETWORKPROXY
|
||||
void proxyAuthenticationRequired(QNetworkAccessBackend *backend, const QNetworkProxy &proxy,
|
||||
QAuthenticator *authenticator);
|
||||
void proxyAuthenticationRequired(const QNetworkProxy &proxy,
|
||||
bool synchronous,
|
||||
QAuthenticator *authenticator,
|
||||
QNetworkProxy *lastProxyAuthentication);
|
||||
void cacheProxyCredentials(const QNetworkProxy &proxy, const QAuthenticator *auth);
|
||||
QNetworkAuthenticationCredential *fetchCachedProxyCredentials(const QNetworkProxy &proxy,
|
||||
const QAuthenticator *auth = 0);
|
||||
|
|
|
|||
|
|
@ -395,8 +395,8 @@ static QPair<QByteArray, QByteArray> nextField(const QByteArray &text, int &posi
|
|||
// qdtext = <any TEXT except <">>
|
||||
// quoted-pair = "\" CHAR
|
||||
|
||||
// If its NAME=VALUE, retain the value as is
|
||||
// refer to ttp://bugreports.qt.nokia.com/browse/QTBUG-17746
|
||||
// If it is NAME=VALUE, retain the value as is
|
||||
// refer to http://bugreports.qt.nokia.com/browse/QTBUG-17746
|
||||
if (isNameValue)
|
||||
second += '"';
|
||||
++i;
|
||||
|
|
@ -432,7 +432,9 @@ static QPair<QByteArray, QByteArray> nextField(const QByteArray &text, int &posi
|
|||
position = i;
|
||||
for ( ; i < length; ++i) {
|
||||
register char c = text.at(i);
|
||||
if (c == ',' || c == ';' || isLWS(c))
|
||||
// for name value pairs, we want to parse until reaching the next ';'
|
||||
// and not break when reaching a space char
|
||||
if (c == ',' || c == ';' || ((isNameValue && (c == '\n' || c == '\r')) || (!isNameValue && isLWS(c))))
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -487,7 +489,6 @@ QByteArray QNetworkCookie::toRawForm(RawForm form) const
|
|||
result += '=';
|
||||
if ((d->value.contains(';') ||
|
||||
d->value.contains(',') ||
|
||||
d->value.contains(' ') ||
|
||||
d->value.contains('"')) &&
|
||||
(!d->value.startsWith('"') &&
|
||||
!d->value.endsWith('"'))) {
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,309 @@
|
|||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
||||
** All rights reserved.
|
||||
** Contact: Nokia Corporation (qt-info@nokia.com)
|
||||
**
|
||||
** This file is part of the 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$
|
||||
**
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef QNETWORKREPLYHTTPIMPL_P_H
|
||||
#define QNETWORKREPLYHTTPIMPL_P_H
|
||||
|
||||
//
|
||||
// W A R N I N G
|
||||
// -------------
|
||||
//
|
||||
// This file is not part of the Qt API. It exists for the convenience
|
||||
// of the Network Access API. This header file may change from
|
||||
// version to version without notice, or even be removed.
|
||||
//
|
||||
// We mean it.
|
||||
//
|
||||
|
||||
#include "qnetworkrequest.h"
|
||||
#include "qnetworkreply.h"
|
||||
|
||||
#include "QtCore/qpointer.h"
|
||||
#include "QtCore/qdatetime.h"
|
||||
#include "QtCore/qsharedpointer.h"
|
||||
#include "qatomic.h"
|
||||
|
||||
#include <QtNetwork/QNetworkCacheMetaData>
|
||||
#include <private/qhttpnetworkrequest_p.h>
|
||||
#include <private/qbytedata_p.h>
|
||||
#include <private/qnetworkreply_p.h>
|
||||
#include <QtNetwork/QNetworkProxy>
|
||||
|
||||
#ifndef QT_NO_OPENSSL
|
||||
#include <QtNetwork/QSslConfiguration>
|
||||
#endif
|
||||
|
||||
#ifndef QT_NO_HTTP
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
class QIODevice;
|
||||
|
||||
class QNetworkReplyHttpImplPrivate;
|
||||
class QNetworkReplyHttpImpl: public QNetworkReply
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
QNetworkReplyHttpImpl(QNetworkAccessManager* const, const QNetworkRequest&, QNetworkAccessManager::Operation&, QIODevice* outgoingData);
|
||||
virtual ~QNetworkReplyHttpImpl();
|
||||
|
||||
void close();
|
||||
void abort();
|
||||
qint64 bytesAvailable() const;
|
||||
bool isSequential () const;
|
||||
qint64 size() const;
|
||||
qint64 readData(char*, qint64);
|
||||
void setReadBufferSize(qint64 size);
|
||||
bool canReadLine () const;
|
||||
|
||||
#ifndef QT_NO_OPENSSL
|
||||
void ignoreSslErrors();
|
||||
// ### Qt5 Add proper virtual
|
||||
Q_INVOKABLE void ignoreSslErrorsImplementation(const QList<QSslError> &errors);
|
||||
// ### Qt5 Add proper virtual
|
||||
Q_INVOKABLE void setSslConfigurationImplementation(const QSslConfiguration &configuration);
|
||||
// ### Qt5 Add proper virtual
|
||||
Q_INVOKABLE QSslConfiguration sslConfigurationImplementation() const;
|
||||
#endif
|
||||
|
||||
Q_DECLARE_PRIVATE(QNetworkReplyHttpImpl)
|
||||
Q_PRIVATE_SLOT(d_func(), void _q_startOperation())
|
||||
Q_PRIVATE_SLOT(d_func(), void _q_cacheLoadReadyRead())
|
||||
Q_PRIVATE_SLOT(d_func(), void _q_bufferOutgoingData())
|
||||
Q_PRIVATE_SLOT(d_func(), void _q_bufferOutgoingDataFinished())
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
Q_PRIVATE_SLOT(d_func(), void _q_networkSessionConnected())
|
||||
Q_PRIVATE_SLOT(d_func(), void _q_networkSessionFailed())
|
||||
#endif
|
||||
Q_PRIVATE_SLOT(d_func(), void _q_finished())
|
||||
Q_PRIVATE_SLOT(d_func(), void _q_error(QNetworkReply::NetworkError, const QString &))
|
||||
|
||||
// From reply
|
||||
Q_PRIVATE_SLOT(d_func(), void replyDownloadData(QByteArray))
|
||||
Q_PRIVATE_SLOT(d_func(), void replyFinished())
|
||||
Q_PRIVATE_SLOT(d_func(), void replyDownloadMetaData(QList<QPair<QByteArray,QByteArray> >,int,QString,bool,QSharedPointer<char>,qint64))
|
||||
Q_PRIVATE_SLOT(d_func(), void replyDownloadProgressSlot(qint64,qint64))
|
||||
Q_PRIVATE_SLOT(d_func(), void httpAuthenticationRequired(const QHttpNetworkRequest &, QAuthenticator *))
|
||||
Q_PRIVATE_SLOT(d_func(), void httpError(QNetworkReply::NetworkError, const QString &))
|
||||
#ifndef QT_NO_OPENSSL
|
||||
Q_PRIVATE_SLOT(d_func(), void replySslErrors(const QList<QSslError> &, bool *, QList<QSslError> *))
|
||||
Q_PRIVATE_SLOT(d_func(), void replySslConfigurationChanged(const QSslConfiguration&))
|
||||
#endif
|
||||
Q_PRIVATE_SLOT(d_func(), void proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *auth))
|
||||
|
||||
Q_PRIVATE_SLOT(d_func(), void resetUploadDataSlot(bool *r))
|
||||
Q_PRIVATE_SLOT(d_func(), void wantUploadDataSlot(qint64))
|
||||
Q_PRIVATE_SLOT(d_func(), void sentUploadDataSlot(qint64))
|
||||
Q_PRIVATE_SLOT(d_func(), void emitReplyUploadProgress(qint64, qint64))
|
||||
|
||||
|
||||
|
||||
signals:
|
||||
// To HTTP thread:
|
||||
void startHttpRequest();
|
||||
void abortHttpRequest();
|
||||
|
||||
void startHttpRequestSynchronously();
|
||||
|
||||
void haveUploadData(QByteArray dataArray, bool dataAtEnd, qint64 dataSize);
|
||||
};
|
||||
|
||||
class QNetworkReplyHttpImplPrivate: public QNetworkReplyPrivate
|
||||
{
|
||||
public:
|
||||
|
||||
static QHttpNetworkRequest::Priority convert(const QNetworkRequest::Priority& prio);
|
||||
|
||||
enum State {
|
||||
Idle, // The reply is idle.
|
||||
Buffering, // The reply is buffering outgoing data.
|
||||
Working, // The reply is uploading/downloading data.
|
||||
Finished, // The reply has finished.
|
||||
Aborted, // The reply has been aborted.
|
||||
WaitingForSession, // The reply is waiting for the session to open before connecting.
|
||||
Reconnecting // The reply will reconnect to once roaming has completed.
|
||||
};
|
||||
|
||||
QNetworkReplyHttpImplPrivate();
|
||||
~QNetworkReplyHttpImplPrivate();
|
||||
|
||||
bool start();
|
||||
void _q_startOperation();
|
||||
|
||||
void _q_cacheLoadReadyRead();
|
||||
|
||||
void _q_bufferOutgoingData();
|
||||
void _q_bufferOutgoingDataFinished();
|
||||
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
void _q_networkSessionConnected();
|
||||
void _q_networkSessionFailed();
|
||||
#endif
|
||||
void _q_finished();
|
||||
|
||||
|
||||
// FIXME
|
||||
void finished();
|
||||
void error(QNetworkReply::NetworkError code, const QString &errorString);
|
||||
void _q_error(QNetworkReply::NetworkError code, const QString &errorString);
|
||||
void metaDataChanged();
|
||||
|
||||
void redirectionRequested(const QUrl &target);
|
||||
void checkForRedirect(const int statusCode);
|
||||
|
||||
|
||||
// incoming from user
|
||||
QNetworkAccessManager *manager;
|
||||
QNetworkAccessManagerPrivate *managerPrivate;
|
||||
QNetworkRequest request;
|
||||
QNetworkAccessManager::Operation operation; // FIXME already in replyprivate?
|
||||
QHttpNetworkRequest httpRequest; // There is also a copy in the HTTP thread
|
||||
bool synchronous;
|
||||
|
||||
State state;
|
||||
|
||||
// from http thread
|
||||
int statusCode;
|
||||
QString reasonPhrase;
|
||||
|
||||
// upload
|
||||
QNonContiguousByteDevice* createUploadByteDevice();
|
||||
QSharedPointer<QNonContiguousByteDevice> uploadByteDevice;
|
||||
QIODevice *outgoingData;
|
||||
QSharedPointer<QRingBuffer> outgoingDataBuffer;
|
||||
void emitReplyUploadProgress(qint64 bytesSent, qint64 bytesTotal); // dup?
|
||||
qint64 bytesUploaded;
|
||||
|
||||
|
||||
// cache
|
||||
void createCache();
|
||||
void completeCacheSave();
|
||||
void setCachingEnabled(bool enable);
|
||||
bool isCachingEnabled() const;
|
||||
void initCacheSaveDevice();
|
||||
QAbstractNetworkCache *networkCache() const;
|
||||
QIODevice *cacheLoadDevice;
|
||||
bool loadingFromCache;
|
||||
|
||||
QIODevice *cacheSaveDevice;
|
||||
bool cacheEnabled; // is this for saving?
|
||||
|
||||
|
||||
QUrl urlForLastAuthentication;
|
||||
#ifndef QT_NO_NETWORKPROXY
|
||||
QNetworkProxy lastProxyAuthentication;
|
||||
QList<QNetworkProxy> proxyList;
|
||||
#endif
|
||||
|
||||
|
||||
bool migrateBackend();
|
||||
bool canResume() const;
|
||||
void setResumeOffset(quint64 offset);
|
||||
quint64 resumeOffset;
|
||||
qint64 preMigrationDownloaded;
|
||||
|
||||
// Used for normal downloading. For "zero copy" the downloadZerocopyBuffer is used
|
||||
QByteDataBuffer downloadMultiBuffer;
|
||||
QByteDataBuffer pendingDownloadData; // For signal compression
|
||||
qint64 bytesDownloaded;
|
||||
qint64 lastBytesDownloaded;
|
||||
void setDownloadBuffer(QSharedPointer<char> sp, qint64 size);
|
||||
char* getDownloadBuffer(qint64 size);
|
||||
|
||||
// only used when the "zero copy" style is used. Else downloadMultiBuffer is used.
|
||||
// Please note that the whole "zero copy" download buffer API is private right now. Do not use it.
|
||||
qint64 downloadBufferReadPosition;
|
||||
qint64 downloadBufferCurrentSize;
|
||||
qint64 downloadBufferMaximumSize;
|
||||
QSharedPointer<char> downloadBufferPointer;
|
||||
char* downloadZerocopyBuffer;
|
||||
|
||||
// Will be increased by HTTP thread:
|
||||
QSharedPointer<QAtomicInt> pendingDownloadDataEmissions;
|
||||
QSharedPointer<QAtomicInt> pendingDownloadProgressEmissions;
|
||||
|
||||
|
||||
#ifndef QT_NO_OPENSSL
|
||||
QSslConfiguration sslConfiguration;
|
||||
bool pendingIgnoreAllSslErrors;
|
||||
QList<QSslError> pendingIgnoreSslErrorsList;
|
||||
#endif
|
||||
|
||||
|
||||
bool loadFromCacheIfAllowed(QHttpNetworkRequest &httpRequest);
|
||||
void invalidateCache();
|
||||
bool sendCacheContents(const QNetworkCacheMetaData &metaData);
|
||||
QNetworkCacheMetaData fetchCacheMetaData(const QNetworkCacheMetaData &metaData) const;
|
||||
|
||||
|
||||
void postRequest();
|
||||
|
||||
|
||||
|
||||
public:
|
||||
// From HTTP thread:
|
||||
void replyDownloadData(QByteArray);
|
||||
void replyFinished();
|
||||
void replyDownloadMetaData(QList<QPair<QByteArray,QByteArray> >,int,QString,bool,QSharedPointer<char>,qint64);
|
||||
void replyDownloadProgressSlot(qint64,qint64);
|
||||
void httpAuthenticationRequired(const QHttpNetworkRequest &request, QAuthenticator *auth);
|
||||
void httpError(QNetworkReply::NetworkError error, const QString &errorString);
|
||||
#ifndef QT_NO_OPENSSL
|
||||
void replySslErrors(const QList<QSslError> &, bool *, QList<QSslError> *);
|
||||
void replySslConfigurationChanged(const QSslConfiguration&);
|
||||
#endif
|
||||
#ifndef QT_NO_NETWORKPROXY
|
||||
void proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *auth);
|
||||
#endif
|
||||
|
||||
// From QNonContiguousByteDeviceThreadForwardImpl in HTTP thread:
|
||||
void resetUploadDataSlot(bool *r);
|
||||
void wantUploadDataSlot(qint64);
|
||||
void sentUploadDataSlot(qint64);
|
||||
|
||||
Q_DECLARE_PUBLIC(QNetworkReplyHttpImpl)
|
||||
};
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
#endif // QT_NO_HTTP
|
||||
|
||||
#endif
|
||||
|
|
@ -47,7 +47,6 @@
|
|||
#include "QtCore/qdatetime.h"
|
||||
#include "QtNetwork/qsslconfiguration.h"
|
||||
#include "QtNetwork/qnetworksession.h"
|
||||
#include "qnetworkaccesshttpbackend_p.h"
|
||||
#include "qnetworkaccessmanager_p.h"
|
||||
|
||||
#include <QtCore/QCoreApplication>
|
||||
|
|
@ -90,10 +89,10 @@ void QNetworkReplyImplPrivate::_q_startOperation()
|
|||
return;
|
||||
}
|
||||
|
||||
if (!backend->start()) {
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
if (!backend->start()) { // ### we should call that method even if bearer is not used
|
||||
// backend failed to start because the session state is not Connected.
|
||||
// QNetworkAccessManager will call reply->backend->start() again for us when the session
|
||||
// QNetworkAccessManager will call _q_startOperation again for us when the session
|
||||
// state changes.
|
||||
state = WaitingForSession;
|
||||
|
||||
|
|
@ -109,11 +108,20 @@ void QNetworkReplyImplPrivate::_q_startOperation()
|
|||
session->open();
|
||||
} else {
|
||||
qWarning("Backend is waiting for QNetworkSession to connect, but there is none!");
|
||||
state = Working;
|
||||
error(QNetworkReplyImpl::UnknownNetworkError,
|
||||
QCoreApplication::translate("QNetworkReply", "Network session error."));
|
||||
finished();
|
||||
}
|
||||
|
||||
#else
|
||||
qWarning("Backend start failed");
|
||||
state = Working;
|
||||
error(QNetworkReplyImpl::UnknownNetworkError,
|
||||
QCoreApplication::translate("QNetworkReply", "backend start error."));
|
||||
finished();
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (backend && backend->isSynchronous()) {
|
||||
state = Finished;
|
||||
|
|
@ -356,7 +364,7 @@ void QNetworkReplyImplPrivate::setup(QNetworkAccessManager::Operation op, const
|
|||
// for HTTP, we want to send out the request as fast as possible to the network, without
|
||||
// invoking methods in a QueuedConnection
|
||||
#ifndef QT_NO_HTTP
|
||||
if (qobject_cast<QNetworkAccessHttpBackend *>(backend) || (backend && backend->isSynchronous())) {
|
||||
if (backend && backend->isSynchronous()) {
|
||||
_q_startOperation();
|
||||
} else {
|
||||
QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
|
||||
|
|
@ -1043,11 +1051,7 @@ bool QNetworkReplyImplPrivate::migrateBackend()
|
|||
}
|
||||
|
||||
#ifndef QT_NO_HTTP
|
||||
if (qobject_cast<QNetworkAccessHttpBackend *>(backend)) {
|
||||
_q_startOperation();
|
||||
} else {
|
||||
QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
|
||||
}
|
||||
QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
|
||||
#else
|
||||
QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
|
||||
#endif // QT_NO_HTTP
|
||||
|
|
|
|||
|
|
@ -247,10 +247,13 @@ QT_BEGIN_NAMESPACE
|
|||
|
||||
\value AlwaysNetwork always load from network and do not
|
||||
check if the cache has a valid entry (similar to the
|
||||
"Reload" feature in browsers)
|
||||
"Reload" feature in browsers); in addition, force intermediate
|
||||
caches to re-validate.
|
||||
|
||||
\value PreferNetwork default value; load from the network
|
||||
if the cached entry is older than the network entry
|
||||
if the cached entry is older than the network entry. This will never
|
||||
return stale data from the cache, but revalidate resources that
|
||||
have become stale.
|
||||
|
||||
\value PreferCache load from cache if available,
|
||||
otherwise load from network. Note that this can return possibly
|
||||
|
|
|
|||
|
|
@ -385,8 +385,6 @@ void QNetworkConfigurationManagerPrivate::updateConfigurations()
|
|||
this, SLOT(configurationRemoved(QNetworkConfigurationPrivatePointer)));
|
||||
connect(engine, SIGNAL(configurationChanged(QNetworkConfigurationPrivatePointer)),
|
||||
this, SLOT(configurationChanged(QNetworkConfigurationPrivatePointer)));
|
||||
|
||||
QMetaObject::invokeMethod(engine, "initialize");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -410,8 +408,19 @@ void QNetworkConfigurationManagerPrivate::updateConfigurations()
|
|||
startPolling();
|
||||
}
|
||||
|
||||
if (firstUpdate)
|
||||
if (firstUpdate) {
|
||||
firstUpdate = false;
|
||||
QList<QBearerEngine*> enginesToInitialize = sessionEngines; //shallow copy the list in case it is modified when we unlock mutex
|
||||
Qt::ConnectionType connectionType;
|
||||
if (QCoreApplicationPrivate::mainThread() == QThread::currentThread())
|
||||
connectionType = Qt::DirectConnection;
|
||||
else
|
||||
connectionType = Qt::BlockingQueuedConnection;
|
||||
locker.unlock();
|
||||
foreach (QBearerEngine* engine, enginesToInitialize) {
|
||||
QMetaObject::invokeMethod(engine, "initialize", connectionType);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void QNetworkConfigurationManagerPrivate::performAsyncConfigurationUpdate()
|
||||
|
|
|
|||
|
|
@ -288,7 +288,7 @@ QHostInfo QHostInfoPrivate::fromName(const QString &name, QSharedPointer<QNetwor
|
|||
|
||||
#ifndef Q_OS_SYMBIAN
|
||||
// This function has a special implementation for symbian right now in qhostinfo_symbian.cpp but not on other OS.
|
||||
QHostInfo QHostInfoAgent::fromName(const QString &hostName, QSharedPointer<QNetworkSession> networkSession)
|
||||
QHostInfo QHostInfoAgent::fromName(const QString &hostName, QSharedPointer<QNetworkSession>)
|
||||
{
|
||||
return QHostInfoAgent::fromName(hostName);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -228,6 +228,10 @@
|
|||
#include "qmutex.h"
|
||||
#include "qurl.h"
|
||||
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
#include <QtNetwork/QNetworkConfiguration>
|
||||
#endif
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
class QSocks5SocketEngineHandler;
|
||||
|
|
@ -716,6 +720,9 @@ public:
|
|||
QUrl remote;
|
||||
int localPort;
|
||||
QNetworkProxyQuery::QueryType type;
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
QNetworkConfiguration config;
|
||||
#endif
|
||||
};
|
||||
|
||||
template<> void QSharedDataPointer<QNetworkProxyQueryPrivate>::detach()
|
||||
|
|
@ -777,6 +784,11 @@ template<> void QSharedDataPointer<QNetworkProxyQueryPrivate>::detach()
|
|||
like choosing an caching HTTP proxy for HTTP-based connections,
|
||||
but a more powerful SOCKSv5 proxy for all others.
|
||||
|
||||
The network configuration specifies which configuration to use,
|
||||
when bearer management is used. For example on a mobile phone
|
||||
the proxy settings are likely to be different for the cellular
|
||||
network vs WLAN.
|
||||
|
||||
Some of the criteria may not make sense in all of the types of
|
||||
query. The following table lists the criteria that are most
|
||||
commonly used, according to the type of query.
|
||||
|
|
@ -902,6 +914,68 @@ QNetworkProxyQuery::QNetworkProxyQuery(quint16 bindPort, const QString &protocol
|
|||
d->type = queryType;
|
||||
}
|
||||
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
/*!
|
||||
Constructs a QNetworkProxyQuery with the URL \a requestUrl and
|
||||
sets the query type to \a queryType. The specified \a networkConfiguration
|
||||
is used to resolve the proxy settings.
|
||||
|
||||
\sa protocolTag(), peerHostName(), peerPort(), networkConfiguration()
|
||||
*/
|
||||
QNetworkProxyQuery::QNetworkProxyQuery(const QNetworkConfiguration &networkConfiguration,
|
||||
const QUrl &requestUrl, QueryType queryType)
|
||||
{
|
||||
d->config = networkConfiguration;
|
||||
d->remote = requestUrl;
|
||||
d->type = queryType;
|
||||
}
|
||||
|
||||
/*!
|
||||
Constructs a QNetworkProxyQuery of type \a queryType and sets the
|
||||
protocol tag to be \a protocolTag. This constructor is suitable
|
||||
for QNetworkProxyQuery::TcpSocket queries, because it sets the
|
||||
peer hostname to \a hostname and the peer's port number to \a
|
||||
port. The specified \a networkConfiguration
|
||||
is used to resolve the proxy settings.
|
||||
|
||||
\sa networkConfiguration()
|
||||
*/
|
||||
QNetworkProxyQuery::QNetworkProxyQuery(const QNetworkConfiguration &networkConfiguration,
|
||||
const QString &hostname, int port,
|
||||
const QString &protocolTag,
|
||||
QueryType queryType)
|
||||
{
|
||||
d->config = networkConfiguration;
|
||||
d->remote.setScheme(protocolTag);
|
||||
d->remote.setHost(hostname);
|
||||
d->remote.setPort(port);
|
||||
d->type = queryType;
|
||||
}
|
||||
|
||||
/*!
|
||||
Constructs a QNetworkProxyQuery of type \a queryType and sets the
|
||||
protocol tag to be \a protocolTag. This constructor is suitable
|
||||
for QNetworkProxyQuery::TcpSocket queries because it sets the
|
||||
local port number to \a bindPort. The specified \a networkConfiguration
|
||||
is used to resolve the proxy settings.
|
||||
|
||||
Note that \a bindPort is of type quint16 to indicate the exact
|
||||
port number that is requested. The value of -1 (unknown) is not
|
||||
allowed in this context.
|
||||
|
||||
\sa localPort(), networkConfiguration()
|
||||
*/
|
||||
QNetworkProxyQuery::QNetworkProxyQuery(const QNetworkConfiguration &networkConfiguration,
|
||||
quint16 bindPort, const QString &protocolTag,
|
||||
QueryType queryType)
|
||||
{
|
||||
d->config = networkConfiguration;
|
||||
d->remote.setScheme(protocolTag);
|
||||
d->localPort = bindPort;
|
||||
d->type = queryType;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*!
|
||||
Constructs a QNetworkProxyQuery object that is a copy of \a other.
|
||||
*/
|
||||
|
|
@ -1116,6 +1190,30 @@ void QNetworkProxyQuery::setUrl(const QUrl &url)
|
|||
d->remote = url;
|
||||
}
|
||||
|
||||
#ifndef QT_NO_BEARERMANAGEMENT
|
||||
QNetworkConfiguration QNetworkProxyQuery::networkConfiguration() const
|
||||
{
|
||||
return d ? d->config : QNetworkConfiguration();
|
||||
}
|
||||
|
||||
/*!
|
||||
Sets the network configuration component of this QNetworkProxyQuery
|
||||
object to be \a networkConfiguration. The network configuration can
|
||||
be used to return different proxy settings based on the network in
|
||||
use, for example WLAN vs cellular networks on a mobile phone.
|
||||
|
||||
In the case of "user choice" or "service network" configurations,
|
||||
you should first start the QNetworkSession and obtain the active
|
||||
configuration from its properties.
|
||||
|
||||
\sa networkConfiguration
|
||||
*/
|
||||
void QNetworkProxyQuery::setNetworkConfiguration(const QNetworkConfiguration &networkConfiguration)
|
||||
{
|
||||
d->config = networkConfiguration;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*!
|
||||
\class QNetworkProxyFactory
|
||||
\brief The QNetworkProxyFactory class provides fine-grained proxy selection.
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue