Debian Codegraph @

qt6/src/poppler-optcontent.cc

raw
1 /* poppler-optcontent.cc: qt interface to poppler
2 *
3 * Copyright (C) 2007, Brad Hards <[email protected]>
4 * Copyright (C) 2008, 2014, Pino Toscano <[email protected]>
5 * Copyright (C) 2008, Carlos Garcia Campos <[email protected]>
6 * Copyright (C) 2015-2019, 2025, Albert Astals Cid <[email protected]>
7 * Copyright (C) 2017, Hubert Figuière <[email protected]>
8 * Copyright (C) 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <[email protected]>. Work sponsored by the LiMux project of the city of Munich
9 * Copyright (C) 2018 Adam Reichold <[email protected]>
10 * Copyright (C) 2019, 2020 Oliver Sander <[email protected]>
11 * Copyright (C) 2025 g10 Code GmbH, Author: Sune Stolborg Vuorela <[email protected]>
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2, or (at your option)
16 * any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
26 */
27
28 #include "poppler-optcontent.h"
29
30 #include "poppler-optcontent-private.h"
31
32 #include "poppler-private.h"
33 #include "poppler-link-private.h"
34
35 #include <QtCore/QDebug>
36 #include <QtCore/QtAlgorithms>
37
38 #include "poppler/OptionalContent.h"
39 #include "poppler/Link.h"
40
41 namespace Poppler {
42 RadioButtonGroup::RadioButtonGroup(OptContentModelPrivate *ocModel, Array *rbarray)
43 {
44 itemsInGroup.reserve(rbarray->getLength());
45 for (int i = 0; i < rbarray->getLength(); ++i) {
46 const Object &ref = rbarray->getNF(i);
47 if (!ref.isRef()) {
48 qDebug() << "expected ref, but got:" << ref.getType();
49 }
50 OptContentItem *item = ocModel->itemFromRef(QString::number(ref.getRefNum()));
51 itemsInGroup.append(item);
52 }
53 for (OptContentItem *item : std::as_const(itemsInGroup)) {
54 item->appendRBGroup(this);
55 }
56 }
57
58 RadioButtonGroup::~RadioButtonGroup() = default;
59
60 QSet<OptContentItem *> RadioButtonGroup::setItemOn(OptContentItem *itemToSetOn)
61 {
62 QSet<OptContentItem *> changedItems;
63 for (OptContentItem *thisItem : std::as_const(itemsInGroup)) {
64 if (thisItem != itemToSetOn) {
65 QSet<OptContentItem *> newChangedItems;
66 thisItem->setState(OptContentItem::Off, false /*obeyRadioGroups*/, newChangedItems);
67 changedItems += newChangedItems;
68 }
69 }
70 return changedItems;
71 }
72
73 OptContentItem::OptContentItem(OptionalContentGroup *group)
74 {
75 m_group = group;
76 m_parent = nullptr;
77 m_name = UnicodeParsedString(group->getName());
78 if (group->getState() == OptionalContentGroup::On) {
79 m_state = OptContentItem::On;
80 } else {
81 m_state = OptContentItem::Off;
82 }
83 m_stateBackup = m_state;
84 m_enabled = true;
85 }
86
87 OptContentItem::OptContentItem(const QString &label)
88 {
89 m_parent = nullptr;
90 m_name = label;
91 m_group = nullptr;
92 m_state = OptContentItem::HeadingOnly;
93 m_stateBackup = m_state;
94 m_enabled = true;
95 }
96
97 OptContentItem::OptContentItem() : m_parent(nullptr), m_enabled(true) { }
98
99 OptContentItem::~OptContentItem() = default;
100
101 void OptContentItem::appendRBGroup(RadioButtonGroup *rbgroup)
102 {
103 m_rbGroups.append(rbgroup);
104 }
105
106 void OptContentItem::setState(ItemState state, bool obeyRadioGroups, QSet<OptContentItem *> &changedItems)
107 {
108 if (state == m_state) {
109 return;
110 }
111
112 m_state = state;
113 m_stateBackup = m_state;
114 changedItems.insert(this);
115 QSet<OptContentItem *> empty;
116 Q_FOREACH (OptContentItem *child, m_children) {
117 ItemState oldState = child->m_stateBackup;
118 child->setState(state == OptContentItem::On ? child->m_stateBackup : OptContentItem::Off, true /*obeyRadioGroups*/, empty);
119 child->m_enabled = state == OptContentItem::On;
120 child->m_stateBackup = oldState;
121 }
122 if (!m_group) {
123 return;
124 }
125 if (state == OptContentItem::On) {
126 m_group->setState(OptionalContentGroup::On);
127 if (obeyRadioGroups) {
128 for (RadioButtonGroup *rbgroup : std::as_const(m_rbGroups)) {
129 changedItems += rbgroup->setItemOn(this);
130 }
131 }
132 } else if (state == OptContentItem::Off) {
133 m_group->setState(OptionalContentGroup::Off);
134 }
135 }
136
137 void OptContentItem::addChild(OptContentItem *child)
138 {
139 m_children += child;
140 child->setParent(this);
141 }
142
143 QSet<OptContentItem *> OptContentItem::recurseListChildren(bool includeMe) const
144 {
145 QSet<OptContentItem *> ret;
146 if (includeMe) {
147 ret.insert(const_cast<OptContentItem *>(this));
148 }
149 Q_FOREACH (OptContentItem *child, m_children) {
150 ret += child->recurseListChildren(true);
151 }
152 return ret;
153 }
154
155 OptContentModelPrivate::OptContentModelPrivate(OptContentModel *qq, const OCGs *optContent) : q(qq)
156 {
157 m_rootNode = new OptContentItem();
158 const auto &ocgs = optContent->getOCGs();
159
160 for (const auto &ocg : ocgs) {
161 OptContentItem *node = new OptContentItem(ocg.second.get());
162 m_optContentItems.insert(QString::number(ocg.first.num), node);
163 }
164
165 if (optContent->getOrderArray() == nullptr) {
166 // no Order array, so drop them all at the top level
167 QMapIterator<QString, OptContentItem *> i(m_optContentItems);
168 while (i.hasNext()) {
169 i.next();
170 addChild(m_rootNode, i.value());
171 }
172 } else {
173 parseOrderArray(m_rootNode, optContent->getOrderArray());
174 }
175
176 parseRBGroupsArray(optContent->getRBGroupsArray());
177 }
178
179 OptContentModelPrivate::~OptContentModelPrivate()
180 {
181 qDeleteAll(m_optContentItems);
182 qDeleteAll(m_rbgroups);
183 qDeleteAll(m_headerOptContentItems);
184 delete m_rootNode;
185 }
186
187 void OptContentModelPrivate::parseOrderArray(OptContentItem *parentNode, const Array *orderArray)
188 {
189 OptContentItem *lastItem = parentNode;
190 for (int i = 0; i < orderArray->getLength(); ++i) {
191 Object orderItem = orderArray->get(i);
192 if (orderItem.isDict()) {
193 const Object &item = orderArray->getNF(i);
194 if (item.isRef()) {
195 OptContentItem *ocItem = m_optContentItems.value(QString::number(item.getRefNum()));
196 if (ocItem) {
197 addChild(parentNode, ocItem);
198 lastItem = ocItem;
199 } else {
200 qDebug() << "could not find group for object" << item.getRefNum();
201 }
202 }
203 } else if ((orderItem.isArray()) && (orderItem.arrayGetLength() > 0)) {
204 parseOrderArray(lastItem, orderItem.getArray());
205 } else if (orderItem.isString()) {
206 const GooString *label = orderItem.getString();
207 OptContentItem *header = new OptContentItem(UnicodeParsedString(label));
208 m_headerOptContentItems.append(header);
209 addChild(parentNode, header);
210 parentNode = header;
211 lastItem = header;
212 } else {
213 qDebug() << "something unexpected";
214 }
215 }
216 }
217
218 void OptContentModelPrivate::parseRBGroupsArray(const Array *rBGroupArray)
219 {
220 if (!rBGroupArray) {
221 return;
222 }
223 // This is an array of array(s)
224 for (int i = 0; i < rBGroupArray->getLength(); ++i) {
225 Object rbObj = rBGroupArray->get(i);
226 if (!rbObj.isArray()) {
227 qDebug() << "expected inner array, got:" << rbObj.getType();
228 return;
229 }
230 Array *rbarray = rbObj.getArray();
231 RadioButtonGroup *rbg = new RadioButtonGroup(this, rbarray);
232 m_rbgroups.append(rbg);
233 }
234 }
235
236 OptContentModel::OptContentModel(const OCGs *optContent, QObject *parent) : QAbstractItemModel(parent)
237 {
238 d = new OptContentModelPrivate(this, optContent);
239 }
240
241 OptContentModel::~OptContentModel()
242 {
243 delete d;
244 }
245
246 void OptContentModelPrivate::setRootNode(OptContentItem *node)
247 {
248 q->beginResetModel();
249 delete m_rootNode;
250 m_rootNode = node;
251 q->endResetModel();
252 }
253
254 QModelIndex OptContentModel::index(int row, int column, const QModelIndex &parent) const
255 {
256 if (row < 0 || column != 0) {
257 return QModelIndex();
258 }
259
260 OptContentItem *parentNode = d->nodeFromIndex(parent);
261 if (row < parentNode->childList().count()) {
262 return createIndex(row, column, parentNode->childList().at(row));
263 }
264 return QModelIndex();
265 }
266
267 QModelIndex OptContentModel::parent(const QModelIndex &child) const
268 {
269 OptContentItem *childNode = d->nodeFromIndex(child);
270 if (!childNode) {
271 return QModelIndex();
272 }
273 return d->indexFromItem(childNode->parent(), child.column());
274 }
275
276 QModelIndex OptContentModelPrivate::indexFromItem(OptContentItem *node, int column) const
277 {
278 if (!node) {
279 return QModelIndex();
280 }
281 OptContentItem *parentNode = node->parent();
282 if (!parentNode) {
283 return QModelIndex();
284 }
285 const int row = parentNode->childList().indexOf(node);
286 return q->createIndex(row, column, node);
287 }
288
289 int OptContentModel::rowCount(const QModelIndex &parent) const
290 {
291 OptContentItem *parentNode = d->nodeFromIndex(parent);
292 if (!parentNode) {
293 return 0;
294 } else {
295 return parentNode->childList().count();
296 }
297 }
298
299 int OptContentModel::columnCount(const QModelIndex & /*parent*/) const
300 {
301 return 1;
302 }
303
304 QVariant OptContentModel::data(const QModelIndex &index, int role) const
305 {
306 OptContentItem *node = d->nodeFromIndex(index, true);
307 if (!node) {
308 return QVariant();
309 }
310
311 switch (role) {
312 case Qt::DisplayRole:
313 return node->name();
314 break;
315 case Qt::EditRole:
316 if (node->state() == OptContentItem::On) {
317 return true;
318 } else if (node->state() == OptContentItem::Off) {
319 return false;
320 }
321 break;
322 case Qt::CheckStateRole:
323 if (node->state() == OptContentItem::On) {
324 return Qt::Checked;
325 } else if (node->state() == OptContentItem::Off) {
326 return Qt::Unchecked;
327 }
328 break;
329 }
330
331 return QVariant();
332 }
333
334 bool OptContentModel::setData(const QModelIndex &index, const QVariant &value, int role)
335 {
336 OptContentItem *node = d->nodeFromIndex(index, true);
337 if (!node) {
338 return false;
339 }
340
341 switch (role) {
342 case Qt::CheckStateRole: {
343 const bool newvalue = value.toBool();
344 QSet<OptContentItem *> changedItems;
345 node->setState(newvalue ? OptContentItem::On : OptContentItem::Off, true /*obeyRadioGroups*/, changedItems);
346
347 if (!changedItems.isEmpty()) {
348 changedItems += node->recurseListChildren(false);
349 QModelIndexList indexes;
350 Q_FOREACH (OptContentItem *item, changedItems) {
351 indexes.append(d->indexFromItem(item, 0));
352 }
353 std::stable_sort(indexes.begin(), indexes.end()); // NOLINT(modernize-use-ranges) We need Qt 6.8 for QModelIndexList to support ranges and our minimum requirement is 6.2
354 Q_FOREACH (const QModelIndex &changedIndex, indexes) {
355 Q_EMIT dataChanged(changedIndex, changedIndex);
356 }
357 return true;
358 }
359 break;
360 }
361 }
362
363 return false;
364 }
365
366 Qt::ItemFlags OptContentModel::flags(const QModelIndex &index) const
367 {
368 OptContentItem *node = d->nodeFromIndex(index);
369 Qt::ItemFlags itemFlags = Qt::ItemIsSelectable | Qt::ItemIsUserCheckable;
370 if (node->isEnabled()) {
371 itemFlags |= Qt::ItemIsEnabled;
372 }
373 return itemFlags;
374 }
375
376 QVariant OptContentModel::headerData(int section, Qt::Orientation orientation, int role) const
377 {
378 return QAbstractItemModel::headerData(section, orientation, role);
379 }
380
381 void OptContentModel::applyLink(LinkOCGState *link)
382 {
383 LinkOCGStatePrivate *linkPrivate = link->d_func();
384
385 QSet<OptContentItem *> changedItems;
386
387 const std::vector<::LinkOCGState::StateList> &statesList = linkPrivate->stateList;
388 for (const ::LinkOCGState::StateList &stateList : statesList) {
389 const std::vector<Ref> &refsList = stateList.list;
390 for (const Ref &ref : refsList) {
391 OptContentItem *item = d->itemFromRef(QString::number(ref.num));
392
393 if (stateList.st == ::LinkOCGState::On) {
394 item->setState(OptContentItem::On, linkPrivate->preserveRB, changedItems);
395 } else if (stateList.st == ::LinkOCGState::Off) {
396 item->setState(OptContentItem::Off, linkPrivate->preserveRB, changedItems);
397 } else {
398 OptContentItem::ItemState newState = item->state() == OptContentItem::On ? OptContentItem::Off : OptContentItem::On;
399 item->setState(newState, linkPrivate->preserveRB, changedItems);
400 }
401 }
402 }
403
404 if (!changedItems.isEmpty()) {
405 QSet<OptContentItem *> aux;
406 Q_FOREACH (OptContentItem *item, aux) {
407 changedItems += item->recurseListChildren(false);
408 }
409
410 QModelIndexList indexes;
411 Q_FOREACH (OptContentItem *item, changedItems) {
412 indexes.append(d->indexFromItem(item, 0));
413 }
414 std::stable_sort(indexes.begin(), indexes.end()); // NOLINT(modernize-use-ranges) We need Qt 6.8 for QModelIndexList to support ranges and our minimum requirement is 6.2
415 Q_FOREACH (const QModelIndex &changedIndex, indexes) {
416 Q_EMIT dataChanged(changedIndex, changedIndex);
417 }
418 }
419 }
420
421 void OptContentModelPrivate::addChild(OptContentItem *parent, OptContentItem *child)
422 {
423 parent->addChild(child);
424 }
425
426 OptContentItem *OptContentModelPrivate::itemFromRef(const QString &ref) const
427 {
428 return m_optContentItems.value(ref);
429 }
430
431 OptContentItem *OptContentModelPrivate::nodeFromIndex(const QModelIndex &index, bool canBeNull) const
432 {
433 if (index.isValid()) {
434 return static_cast<OptContentItem *>(index.internalPointer());
435 } else {
436 return canBeNull ? nullptr : m_rootNode;
437 }
438 }
439 }