amass/qt6windows7
1
0
Fork 0
mirror of https://github.com/crystalidea/qt6windows7.git synced 2025-07-07 17:50:59 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

6.6.1 original

Browse Source
This commit is contained in:
kleuter
2023-12-04 18:42:35 +01:00
parent 9bf343ceed
commit 8490fae44c
607 changed files with 15608 additions and 14647 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
examples/corelib/tools/CMakeLists.txt
View File

@ -5,5 +5,3 @@ if(NOT TARGET Qt6::Widgets)
return()
endif()
qt_internal_add_example(contiguouscache)
qt_internal_add_example(customtype)
qt_internal_add_example(customtypesending)

37
examples/corelib/tools/customtype/CMakeLists.txt
View File

@ -1,37 +0,0 @@
# Copyright (C) 2022 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause
cmake_minimum_required(VERSION 3.16)
project(customtype LANGUAGES CXX)
if(NOT DEFINED INSTALL_EXAMPLESDIR)
set(INSTALL_EXAMPLESDIR "examples")
endif()
set(INSTALL_EXAMPLEDIR "${INSTALL_EXAMPLESDIR}/corelib/tools/customtype")
find_package(Qt6 REQUIRED COMPONENTS Core Gui Widgets)
qt_standard_project_setup()
qt_add_executable(customtype
main.cpp
message.cpp message.h
)
set_target_properties(customtype PROPERTIES
WIN32_EXECUTABLE TRUE
MACOSX_BUNDLE TRUE
)
target_link_libraries(customtype PRIVATE
Qt6::Core
Qt6::Gui
Qt6::Widgets
)
install(TARGETS customtype
RUNTIME DESTINATION "${INSTALL_EXAMPLEDIR}"
BUNDLE DESTINATION "${INSTALL_EXAMPLEDIR}"
LIBRARY DESTINATION "${INSTALL_EXAMPLEDIR}"
)

8
examples/corelib/tools/customtype/customtype.pro
View File

@ -1,8 +0,0 @@
HEADERS = message.h
SOURCES = main.cpp \
message.cpp
QT += widgets
# install
target.path = $$[QT_INSTALL_EXAMPLES]/corelib/tools/customtype
INSTALLS += target

37
examples/corelib/tools/customtype/main.cpp
View File

@ -1,37 +0,0 @@
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#include <QCoreApplication>
#include <QDebug>
#include <QVariant>
#include "message.h"
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
QStringList headers;
headers << "Subject: Hello World"
<< "From: address@example.com";
QString body = "This is a test.\r\n";
//! [printing a custom type]
Message message(body, headers);
qDebug() << "Original:" << message;
//! [printing a custom type]
//! [storing a custom value]
QVariant stored;
stored.setValue(message);
//! [storing a custom value]
qDebug() << "Stored:" << stored;
//! [retrieving a custom value]
Message retrieved = qvariant_cast<Message>(stored);
qDebug() << "Retrieved:" << retrieved;
retrieved = qvariant_cast<Message>(stored);
qDebug() << "Retrieved:" << retrieved;
//! [retrieving a custom value]
return 0;
}

38
examples/corelib/tools/customtype/message.cpp
View File

@ -1,38 +0,0 @@
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#include "message.h"
#include <QDebug>
Message::Message(const QString &body, const QStringList &headers)
: m_body(body), m_headers(headers)
{
}
//! [custom type streaming operator]
QDebug operator<<(QDebug dbg, const Message &message)
{
QDebugStateSaver saver(dbg);
QList<QStringView> pieces = message.body().split(u"\r\n", Qt::SkipEmptyParts);
if (pieces.isEmpty())
dbg.nospace() << "Message()";
else if (pieces.size() == 1)
dbg.nospace() << "Message(" << pieces.first() << ")";
else
dbg.nospace() << "Message(" << pieces.first() << " ...)";
return dbg;
}
//! [custom type streaming operator]
//! [getter functions]
QStringView Message::body() const
{
return m_body;
}
QStringList Message::headers() const
{
return m_headers;
}
//! [getter functions]

38
examples/corelib/tools/customtype/message.h
View File

@ -1,38 +0,0 @@
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#ifndef MESSAGE_H
#define MESSAGE_H
#include <QMetaType>
#include <QStringList>
//! [custom type definition]
class Message
{
public:
Message() = default;
~Message() = default;
Message(const Message &) = default;
Message &operator=(const Message &) = default;
Message(const QString &body, const QStringList &headers);
QStringView body() const;
QStringList headers() const;
private:
QString m_body;
QStringList m_headers;
};
//! [custom type definition]
//! [custom type meta-type declaration]
Q_DECLARE_METATYPE(Message);
//! [custom type meta-type declaration]
//! [custom type streaming operator]
QDebug operator<<(QDebug dbg, const Message &message);
//! [custom type streaming operator]
#endif

38
examples/corelib/tools/customtypesending/CMakeLists.txt
View File

@ -1,38 +0,0 @@
# Copyright (C) 2022 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause
cmake_minimum_required(VERSION 3.16)
project(customtypesending LANGUAGES CXX)
if(NOT DEFINED INSTALL_EXAMPLESDIR)
set(INSTALL_EXAMPLESDIR "examples")
endif()
set(INSTALL_EXAMPLEDIR "${INSTALL_EXAMPLESDIR}/corelib/tools/customtypesending")
find_package(Qt6 REQUIRED COMPONENTS Core Gui Widgets)
qt_standard_project_setup()
qt_add_executable(customtypesending
main.cpp
message.cpp message.h
window.cpp window.h
)
set_target_properties(customtypesending PROPERTIES
WIN32_EXECUTABLE TRUE
MACOSX_BUNDLE TRUE
)
target_link_libraries(customtypesending PRIVATE
Qt6::Core
Qt6::Gui
Qt6::Widgets
)
install(TARGETS customtypesending
RUNTIME DESTINATION "${INSTALL_EXAMPLEDIR}"
BUNDLE DESTINATION "${INSTALL_EXAMPLEDIR}"
LIBRARY DESTINATION "${INSTALL_EXAMPLEDIR}"
)

10
examples/corelib/tools/customtypesending/customtypesending.pro
View File

@ -1,10 +0,0 @@
HEADERS = message.h \
window.h
SOURCES = main.cpp \
message.cpp \
window.cpp
QT += widgets
# install
target.path = $$[QT_INSTALL_EXAMPLES]/corelib/tools/customtypesending
INSTALLS += target

31
examples/corelib/tools/customtypesending/main.cpp
View File

@ -1,31 +0,0 @@
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#include <QApplication>
#include "message.h"
#include "window.h"
//! [main function]
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QStringList headers;
headers << "Subject: Hello World"
<< "From: address@example.com";
QString body = "This is a test.\r\n";
Message message(body, headers);
Window window1;
window1.setMessage(message);
Window window2;
QObject::connect(&window1, &Window::messageSent,
&window2, &Window::setMessage);
QObject::connect(&window2, &Window::messageSent,
&window1, &Window::setMessage);
window1.show();
window2.show();
return app.exec();
}
//! [main function]

19
examples/corelib/tools/customtypesending/message.cpp
View File

@ -1,19 +0,0 @@
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#include "message.h"
Message::Message(const QString &body, const QStringList &headers)
: m_body(body), m_headers(headers)
{
}
QString Message::body() const
{
return m_body;
}
QStringList Message::headers() const
{
return m_headers;
}

34
examples/corelib/tools/customtypesending/message.h
View File

@ -1,34 +0,0 @@
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#ifndef MESSAGE_H
#define MESSAGE_H
#include <QMetaType>
#include <QStringList>
//! [custom type definition]
class Message
{
public:
Message() = default;
~Message() = default;
Message(const Message &) = default;
Message &operator=(const Message &) = default;
Message(const QString &body, const QStringList &headers);
QString body() const;
QStringList headers() const;
private:
QString m_body;
QStringList m_headers;
};
//! [custom type definition]
//! [custom type meta-type declaration]
Q_DECLARE_METATYPE(Message);
//! [custom type meta-type declaration]
#endif

43
examples/corelib/tools/customtypesending/window.cpp
View File

@ -1,43 +0,0 @@
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#include <QtWidgets>
#include "window.h"
//! [Window constructor]
Window::Window(QWidget *parent)
: QWidget(parent), editor(new QTextEdit(this))
{
QPushButton *sendButton = new QPushButton(tr("&Send message"));
connect(sendButton, &QPushButton::clicked,
this, &Window::sendMessage);
QHBoxLayout *buttonLayout = new QHBoxLayout;
buttonLayout->addStretch();
buttonLayout->addWidget(sendButton);
buttonLayout->addStretch();
QVBoxLayout *layout = new QVBoxLayout(this);
layout->addWidget(editor);
layout->addLayout(buttonLayout);
setWindowTitle(tr("Custom Type Sending"));
}
//! [Window constructor]
//! [sending a message]
void Window::sendMessage()
{
thisMessage = Message(editor->toPlainText(), thisMessage.headers());
emit messageSent(thisMessage);
}
//! [sending a message]
//! [receiving a message]
void Window::setMessage(const Message &message)
{
thisMessage = message;
editor->setPlainText(thisMessage.body());
}
//! [receiving a message]

35
examples/corelib/tools/customtypesending/window.h
View File

@ -1,35 +0,0 @@
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#ifndef WINDOW_H
#define WINDOW_H
#include <QWidget>
#include "message.h"
QT_FORWARD_DECLARE_CLASS(QTextEdit)
//! [Window class definition]
class Window : public QWidget
{
Q_OBJECT
public:
Window(QWidget *parent = nullptr);
signals:
void messageSent(const Message &message);
public slots:
void setMessage(const Message &message);
private slots:
void sendMessage();
private:
Message thisMessage;
QTextEdit *editor;
};
//! [Window class definition]
#endif

111
examples/corelib/tools/doc/src/customtype.qdoc
View File

@ -1,111 +0,0 @@
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
/*!
\example tools/customtype
\title Custom Type Example
\brief The Custom Type example shows how to integrate a custom type into Qt's
meta-object system.
Contents:
\tableofcontents
\section1 Overview
Qt provides a range of standard value types that are used to provide
rich and meaningful APIs. These types are integrated with the meta-object
system, enabling them to be stored in QVariant objects, written out in
debugging information and sent between components in signal-slot
communication.
Custom types can also be integrated with the meta-object system as long as
they are written to conform to some simple guidelines. In this example, we
introduce a simple \c Message class, we describe how we make it work with
QVariant, and we show how it can be extended to generate a printable
representation of itself for use in debugging output.
\section1 The Message Class Definition
The \c Message class is a simple value class that contains two pieces
of information (a QString and a QStringList), each of which can be read
using trivial getter functions:
\snippet tools/customtype/message.h custom type definition
The default constructor, copy constructor and destructor are
all required, and must be public, if the type is to be integrated into the
meta-object system. Other than this, we are free to implement whatever we
need to make the type do what we want, so we also include a constructor
that lets us set the type's data members.
To enable the type to be used with QVariant, we declare it using the
Q_DECLARE_METATYPE() macro:
\snippet tools/customtype/message.h custom type meta-type declaration
We do not need to write any additional code to accompany this macro.
To allow us to see a readable description of each \c Message object when it
is sent to the debug output stream, we define a streaming operator:
\snippet tools/customtype/message.h custom type streaming operator
This facility is useful if you need to insert tracing statements in your
code for debugging purposes.
\section1 The Message Class Implementation
The streaming operator is implemented in the following way:
\snippet tools/customtype/message.cpp custom type streaming operator
Here, we want to represent each value depending on how many lines are stored
in the message body. We stream text to the QDebug object passed to the
operator and return the QDebug object obtained from its maybeSpace() member
function; this is described in more detail in the
\l{Creating Custom Qt Types#Making the Type Printable}{Creating Custom Qt Types}
document.
We include the code for the getter functions for completeness:
\snippet tools/customtype/message.cpp getter functions
With the type fully defined, implemented, and integrated with the
meta-object system, we can now use it.
\section1 Using the Message
In the example's \c{main()} function, we show how a \c Message object can
be printed to the console by sending it to the debug stream:
\snippet tools/customtype/main.cpp printing a custom type
You can use the type with QVariant in exactly the same way as you would
use standard Qt value types. Here's how to store a value using the
QVariant::setValue() function:
\snippet tools/customtype/main.cpp storing a custom value
Alternatively, the QVariant::fromValue() function can be used if
you are using a compiler without support for member template
functions.
The value can be retrieved using the QVariant::value() member template
function:
\snippet tools/customtype/main.cpp retrieving a custom value
\section1 Further Reading
The custom \c Message type can also be used with direct signal-slot
connections.
To register a custom type for use with queued signals and slots, such as
those used in cross-thread communication, see the
\l{Queued Custom Type Example}.
More information on using custom types with Qt can be found in the
\l{Creating Custom Qt Types} document.
*/

4
examples/corelib/tools/tools.pro
View File

@ -1,6 +1,4 @@
requires(qtHaveModule(widgets))
TEMPLATE = subdirs
SUBDIRS = contiguouscache \
customtype \
customtypesending
SUBDIRS = contiguouscache