1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
/*
SPDX-FileCopyrightText: 2017 Christoph Roick <chrisito@gmx.de>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#ifndef KDEVPLATFORM_SCOPEDDIALOG_H
#define KDEVPLATFORM_SCOPEDDIALOG_H
#include <QPointer>
#include <utility>
namespace KDevelop {
/// A tag that requests construction of a null ScopedDialog, avoids ambiguity with the variadic template constructor.
struct NullScopedDialog
{
// The explicit default constructor ensures that ambiguous code `ScopedDialog<QDialog> d{{}};` does not compile.
explicit constexpr NullScopedDialog() noexcept = default;
};
/**
* Wrapper class for QDialogs which should not be instantiated on stack.
*
* Parents of QDialogs may be unintentionally deleted during the execution of the
* dialog and automatically delete their children. When returning to the calling
* function they get intentionally deleted again, which will lead to a crash. This
* can be circumvented by using a QPointer which keeps track of the QDialogs validity.
* See this
* <a href="https://blogs.kde.org/2009/03/26/how-crash-almost-every-qtkde-application-and-how-fix-it-0">blog entry</a>
* for explanation. The ScopedDialog utility allows using the dialog like a
* common pointer.
*
* Instead of
* \code
QFileDialog dlg(this);
if (dlg.exec())
return;
\endcode
simply use
* \code
ScopedDialog<QFileDialog> dlg(this);
if (dlg->exec())
return;
\endcode
without need to manually clean up afterwards.
*/
// This class template is final, because inheriting it shouldn't be useful, and
// the forwarding-reference constructor would be invoked in places where slicing
// normally occurs.
template<typename DialogType>
class ScopedDialog final
{
Q_DISABLE_COPY_MOVE(ScopedDialog)
public:
// Explicitly delete unconventional overloads of copy and move constructors
// to prevent a compiler from using the forwarding-reference constructor in
// places where a copy or a move constructor are normally invoked.
ScopedDialog(ScopedDialog&) = delete;
ScopedDialog(const ScopedDialog&&) = delete;
/// Construct the dialog with any set of allowed arguments
/// for the construction of DialogType
template<typename ... Arguments>
explicit ScopedDialog(Arguments&& ... args)
: ptr{new DialogType(std::forward<Arguments>(args)...)}
{
}
/// Automatically deletes the dialog if it is still present
~ScopedDialog()
{
delete ptr;
}
/// Construct a null scoped dialog, i.e. don't create a DialogType but initialize the dialog pointer with nullptr
explicit ScopedDialog(NullScopedDialog)
{
}
/// Destroy the previous dialog if present, then create a dialog with arguments accepted by DialogType()
template<typename... Arguments>
void assign(Arguments&&... args)
{
delete ptr;
ptr = new DialogType(std::forward<Arguments>(args)...);
}
/// Access the raw pointer to the dialog
DialogType* data() const
{
return ptr;
}
/// Access members of the dialog
DialogType* operator->() const
{
return ptr;
}
/// Access the dialog
DialogType& operator*() const
{
return *ptr;
}
/// Return the corresponding pointer
operator DialogType*() const {
return ptr;
}
private:
QPointer<DialogType> ptr;
};
}
#endif // KDEVPLATFORM_SCOPEDDIALOG_H
|
