Okular

event.cpp
1 /*
2  SPDX-FileCopyrightText: 2018 Intevation GmbH <[email protected]>
3 
4  SPDX-License-Identifier: GPL-2.0-or-later
5 */
6 
7 #include "event_p.h"
8 #include <QApplication>
9 
10 #include "../form.h"
11 
12 using namespace Okular;
13 
14 class Event::Private
15 {
16 public:
17  explicit Private(EventType eventType)
18  : m_target(nullptr)
19  , m_targetPage(nullptr)
20  , m_source(nullptr)
21  , m_sourcePage(nullptr)
22  , m_eventType(eventType)
23  , m_returnCode(false)
24  , m_shiftModifier(false)
25  , m_willCommit(false)
26  {
27  }
28 
29  void *m_target;
30  Page *m_targetPage;
31  FormField *m_source;
32  Page *m_sourcePage;
33  EventType m_eventType;
34  QString m_targetName;
35  QVariant m_value;
36  bool m_returnCode;
37  bool m_shiftModifier;
38  bool m_willCommit;
39  QString m_change;
40 };
41 
42 Event::Event()
43  : d(new Private(UnknownEvent))
44 {
45 }
46 
47 Event::Event(EventType eventType)
48  : d(new Private(eventType))
49 {
50 }
51 
52 Event::EventType Event::eventType() const
53 {
54  return d->m_eventType;
55 }
56 
57 QString Event::name() const
58 {
59  switch (d->m_eventType) {
60  case (FieldCalculate):
61  return QStringLiteral("Calculate");
62  case (FieldFormat):
63  return QStringLiteral("Format");
64  case (FieldKeystroke):
65  return QStringLiteral("Keystroke");
66  case (FieldFocus):
67  return QStringLiteral("Focus");
68  case (FieldValidate):
69  return QStringLiteral("Validate");
70  case (UnknownEvent):
71  default:
72  return QStringLiteral("Unknown");
73  }
74 }
75 
76 QString Event::type() const
77 {
78  switch (d->m_eventType) {
79  case (FieldCalculate):
80  case (FieldFormat):
81  case (FieldKeystroke):
82  case (FieldFocus):
83  case (FieldValidate):
84  return QStringLiteral("Field");
85  case (UnknownEvent):
86  default:
87  return QStringLiteral("Unknown");
88  }
89 }
90 
91 QString Event::targetName() const
92 {
93  if (!d->m_targetName.isNull()) {
94  return d->m_targetName;
95  }
96 
97  return QStringLiteral("JavaScript for: ") + type() + name();
98 }
99 
100 void Event::setTargetName(const QString &val)
101 {
102  d->m_targetName = val;
103 }
104 
105 FormField *Event::source() const
106 {
107  return d->m_source;
108 }
109 
110 void Event::setSource(FormField *val)
111 {
112  d->m_source = val;
113 }
114 
115 Page *Event::sourcePage() const
116 {
117  return d->m_sourcePage;
118 }
119 
120 void Event::setSourcePage(Page *val)
121 {
122  d->m_sourcePage = val;
123 }
124 
125 void *Event::target() const
126 {
127  return d->m_target;
128 }
129 
130 void Event::setTarget(void *target)
131 {
132  d->m_target = target;
133 }
134 
135 Page *Event::targetPage() const
136 {
137  return d->m_targetPage;
138 }
139 
140 void Event::setTargetPage(Page *val)
141 {
142  d->m_targetPage = val;
143 }
144 
145 QVariant Event::value() const
146 {
147  return d->m_value;
148 }
149 
150 void Event::setValue(const QVariant &val)
151 {
152  d->m_value = val;
153 }
154 
155 bool Event::returnCode() const
156 {
157  return d->m_returnCode;
158 }
159 
160 void Event::setReturnCode(bool returnCode)
161 {
162  d->m_returnCode = returnCode;
163 }
164 
165 bool Event::shiftModifier() const
166 {
167  return d->m_shiftModifier;
168 }
169 
170 void Event::setShiftModifier(bool shiftModifier)
171 {
172  d->m_shiftModifier = shiftModifier;
173 }
174 
175 bool Event::willCommit() const
176 {
177  return d->m_willCommit;
178 }
179 
180 void Event::setWillCommit(bool willCommit)
181 {
182  d->m_willCommit = willCommit;
183 }
184 
185 QString Event::change() const
186 {
187  return d->m_change;
188 }
189 
190 void Event::setChange(const QString &change)
191 {
192  d->m_change = change;
193 }
194 
195 // static
196 std::shared_ptr<Event> Event::createFormCalculateEvent(FormField *target, Page *targetPage, FormField *source, Page *sourcePage, const QString &targetName)
197 {
198  std::shared_ptr<Event> ret(new Event(Event::FieldCalculate));
199  ret->setSource(source);
200  ret->setSourcePage(sourcePage);
201  ret->setTarget(target);
202  ret->setTargetPage(targetPage);
203  ret->setTargetName(targetName);
204 
205  FormFieldText *fft = dynamic_cast<FormFieldText *>(target);
206  if (fft) {
207  ret->setValue(QVariant(fft->text()));
208  }
209  return ret;
210 }
211 
212 // static
213 std::shared_ptr<Event> Event::createFormatEvent(FormField *target, Page *targetPage, const QString &targetName)
214 {
215  std::shared_ptr<Event> ret(new Event(Event::FieldFormat));
216  ret->setTarget(target);
217  ret->setTargetPage(targetPage);
218  ret->setTargetName(targetName);
219 
220  FormFieldText *fft = dynamic_cast<FormFieldText *>(target);
221  if (fft) {
222  ret->setValue(QVariant(fft->text()));
223  }
224  return ret;
225 }
226 
227 // static
228 std::shared_ptr<Event> Event::createKeystrokeEvent(FormField *target, Page *targetPage)
229 {
230  std::shared_ptr<Event> ret(new Event(Event::FieldKeystroke));
231  ret->setTarget(target);
232  ret->setTargetPage(targetPage);
233 
234  FormFieldText *fft = dynamic_cast<FormFieldText *>(target);
235  if (fft) {
236  ret->setReturnCode(true);
237  ret->setValue(QVariant(fft->text()));
238  }
239  return ret;
240 }
241 
242 std::shared_ptr<Event> Event::createFormFocusEvent(FormField *target, Page *targetPage, const QString &targetName)
243 {
244  std::shared_ptr<Event> ret(new Event(Event::FieldFocus));
245  ret->setTarget(target);
246  ret->setTargetPage(targetPage);
247  ret->setTargetName(targetName);
248  ret->setShiftModifier(QApplication::keyboardModifiers() & Qt::ShiftModifier);
249 
250  FormFieldText *fft = dynamic_cast<FormFieldText *>(target);
251  if (fft) {
252  ret->setValue(QVariant(fft->text()));
253  }
254  return ret;
255 }
256 
257 std::shared_ptr<Event> Event::createFormValidateEvent(FormField *target, Page *targetPage, const QString &targetName)
258 {
259  std::shared_ptr<Event> ret(new Event(Event::FieldValidate));
260  ret->setTarget(target);
261  ret->setTargetPage(targetPage);
262  ret->setTargetName(targetName);
263  ret->setShiftModifier(QApplication::keyboardModifiers() & Qt::ShiftModifier);
264 
265  FormFieldText *fft = dynamic_cast<FormFieldText *>(target);
266  if (fft) {
267  ret->setValue(QVariant(fft->text()));
268  ret->setReturnCode(true);
269  }
270  return ret;
271 }
Collector for all the data belonging to a page.
Definition: page.h:47
Qt::KeyboardModifiers keyboardModifiers()
The base interface of a form field.
Definition: form.h:39
The documentation to the global Okular namespace.
Definition: action.h:16
Type type(const QSqlDatabase &db)
Interface of a text form field.
Definition: form.h:260
Q_SCRIPTABLE Q_NOREPLY void setTargetName(const QString &newTargetName)
const char * name(StandardAction id)
virtual QString text() const =0
The text of text field.
void setTarget(const SkyPoint &targetCoord)
ShiftModifier
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Thu Mar 23 2023 04:04:24 by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.