Coverage Report

Created: 2026-11-13 07:01

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qpdf/libqpdf/QPDFFormFieldObjectHelper.cc
Line
Count
Source
1
#include <qpdf/QPDFFormFieldObjectHelper.hh>
2
3
#include <qpdf/AcroForm.hh>
4
5
#include <qpdf/Pipeline_private.hh>
6
#include <qpdf/Pl_QPDFTokenizer.hh>
7
#include <qpdf/QIntC.hh>
8
#include <qpdf/QPDFAcroFormDocumentHelper.hh>
9
#include <qpdf/QPDFAnnotationObjectHelper.hh>
10
#include <qpdf/QPDFObjectHandle_private.hh>
11
#include <qpdf/QPDF_private.hh>
12
#include <qpdf/QTC.hh>
13
#include <qpdf/QUtil.hh>
14
#include <cstdlib>
15
16
#include <memory>
17
18
using namespace qpdf;
19
20
using FormNode = qpdf::impl::FormNode;
21
22
const QPDFObjectHandle FormNode::null_oh;
23
24
class QPDFFormFieldObjectHelper::Members: public FormNode
25
{
26
  public:
27
    Members(QPDFObjectHandle const& oh) :
28
117k
        FormNode(oh)
29
117k
    {
30
117k
    }
31
};
32
33
QPDFFormFieldObjectHelper::QPDFFormFieldObjectHelper(QPDFObjectHandle o) :
34
60.7k
    QPDFObjectHelper(o),
35
60.7k
    m(std::make_shared<Members>(oh()))
36
60.7k
{
37
60.7k
}
38
39
QPDFFormFieldObjectHelper::QPDFFormFieldObjectHelper() :
40
57.1k
    QPDFObjectHelper(Null::temp()),
41
57.1k
    m(std::make_shared<Members>(QPDFObjectHandle()))
42
57.1k
{
43
57.1k
}
44
45
bool
46
QPDFFormFieldObjectHelper::isNull()
47
0
{
48
0
    return m->null();
49
0
}
50
51
QPDFFormFieldObjectHelper
52
QPDFFormFieldObjectHelper::getParent()
53
0
{
54
0
    return {Null::if_null(m->Parent().oh())};
55
0
}
56
57
QPDFFormFieldObjectHelper
58
QPDFFormFieldObjectHelper::getTopLevelField(bool* is_different)
59
0
{
60
0
    return Null::if_null(m->root_field(is_different).oh());
61
0
}
62
63
FormNode
64
FormNode::root_field(bool* is_different)
65
0
{
66
0
    if (is_different) {
67
0
        *is_different = false;
68
0
    }
69
0
    if (!obj) {
70
0
        return {};
71
0
    }
72
0
    auto rf = *this;
73
0
    size_t depth = 0; // Don't bother with loop detection until depth becomes suspicious
74
0
    QPDFObjGen::set seen;
75
0
    while (rf.Parent() && (++depth < 10 || seen.add(rf))) {
76
0
        rf = rf.Parent();
77
0
        if (is_different) {
78
0
            *is_different = true;
79
0
        }
80
0
    }
81
0
    return rf;
82
0
}
83
84
QPDFObjectHandle
85
QPDFFormFieldObjectHelper::getInheritableFieldValue(std::string const& name)
86
0
{
87
0
    return Null::if_null(m->inheritable_value<QPDFObjectHandle>(name));
88
0
}
89
90
QPDFObjectHandle const&
91
FormNode::inherited(std::string const& name, bool acroform) const
92
51.7k
{
93
51.7k
    if (!obj) {
94
1.52k
        return null_oh;
95
1.52k
    }
96
50.2k
    auto node = *this;
97
50.2k
    QPDFObjGen::set seen;
98
50.2k
    size_t depth = 0; // Don't bother with loop detection until depth becomes suspicious
99
79.9k
    while (node.Parent() && (++depth < 10 || seen.add(node))) {
100
36.6k
        node = node.Parent();
101
36.6k
        if (auto const& result = node[name]) {
102
6.95k
            return {result};
103
6.95k
        }
104
36.6k
    }
105
43.2k
    return acroform ? from_AcroForm(name) : null_oh;
106
50.2k
}
107
108
std::string
109
QPDFFormFieldObjectHelper::getInheritableFieldValueAsString(std::string const& name)
110
0
{
111
0
    return m->inheritable_string(name);
112
0
}
113
114
std::string
115
FormNode::inheritable_string(std::string const& name) const
116
22.8k
{
117
22.8k
    if (auto fv = inheritable_value<String>(name)) {
118
1.51k
        return fv.utf8_value();
119
1.51k
    }
120
21.3k
    return {};
121
22.8k
}
122
123
std::string
124
QPDFFormFieldObjectHelper::getInheritableFieldValueAsName(std::string const& name)
125
0
{
126
0
    if (auto fv = m->inheritable_value<Name>(name)) {
127
0
        return fv;
128
0
    }
129
0
    return {};
130
0
}
131
132
std::string
133
QPDFFormFieldObjectHelper::getFieldType()
134
32.3k
{
135
32.3k
    if (auto ft = m->FT()) {
136
29.9k
        return ft;
137
29.9k
    }
138
2.40k
    return {};
139
32.3k
}
140
141
std::string
142
QPDFFormFieldObjectHelper::getFullyQualifiedName()
143
0
{
144
0
    return m->fully_qualified_name();
145
0
}
146
147
std::string
148
FormNode::fully_qualified_name() const
149
15.9k
{
150
15.9k
    std::string result;
151
15.9k
    auto node = *this;
152
15.9k
    QPDFObjGen::set seen;
153
15.9k
    size_t depth = 0; // Don't bother with loop detection until depth becomes suspicious
154
83.0k
    while (node && (++depth < 10 || seen.add(node))) {
155
67.0k
        if (auto T = node.T()) {
156
61.1k
            if (!result.empty()) {
157
45.0k
                result.insert(0, 1, '.');
158
45.0k
            }
159
61.1k
            result.insert(0, T.utf8_value());
160
61.1k
        }
161
67.0k
        node = node.Parent();
162
67.0k
    }
163
15.9k
    return result;
164
15.9k
}
165
166
std::string
167
QPDFFormFieldObjectHelper::getPartialName()
168
0
{
169
0
    return m->partial_name();
170
0
}
171
172
std::string
173
FormNode::partial_name() const
174
0
{
175
0
    if (auto pn = T()) {
176
0
        return pn.utf8_value();
177
0
    }
178
0
    return {};
179
0
}
180
181
std::string
182
QPDFFormFieldObjectHelper::getAlternativeName()
183
0
{
184
0
    return m->alternative_name();
185
0
}
186
187
std::string
188
FormNode::alternative_name() const
189
0
{
190
0
    if (auto an = TU()) {
191
0
        return an.utf8_value();
192
0
    }
193
0
    return fully_qualified_name();
194
0
}
195
196
std::string
197
QPDFFormFieldObjectHelper::getMappingName()
198
0
{
199
0
    return m->mapping_name();
200
0
}
201
202
std::string
203
FormNode::mapping_name() const
204
0
{
205
0
    if (auto mn = TM()) {
206
0
        return mn.utf8_value();
207
0
    }
208
0
    return alternative_name();
209
0
}
210
211
QPDFObjectHandle
212
QPDFFormFieldObjectHelper::getValue()
213
1.86k
{
214
1.86k
    return Null::if_null(m->V<QPDFObjectHandle>());
215
1.86k
}
216
217
std::string
218
QPDFFormFieldObjectHelper::getValueAsString()
219
0
{
220
0
    return m->value();
221
0
}
222
223
std::string
224
FormNode::value() const
225
22.8k
{
226
22.8k
    return inheritable_string("/V");
227
22.8k
}
228
229
QPDFObjectHandle
230
QPDFFormFieldObjectHelper::getDefaultValue()
231
0
{
232
0
    return Null::if_null(m->DV());
233
0
}
234
235
std::string
236
QPDFFormFieldObjectHelper::getDefaultValueAsString()
237
0
{
238
0
    return m->default_value();
239
0
}
240
241
std::string
242
FormNode::default_value() const
243
0
{
244
0
    return inheritable_string("/DV");
245
0
}
246
247
QPDFObjectHandle
248
QPDFFormFieldObjectHelper::getDefaultResources()
249
25.9k
{
250
25.9k
    return Null::if_null(m->getDefaultResources());
251
25.9k
}
252
253
QPDFObjectHandle
254
FormNode::getDefaultResources()
255
41.1k
{
256
41.1k
    return from_AcroForm("/DR");
257
41.1k
}
258
259
std::string
260
QPDFFormFieldObjectHelper::getDefaultAppearance()
261
0
{
262
0
    return m->default_appearance();
263
0
}
264
265
std::string
266
FormNode::default_appearance() const
267
22.8k
{
268
22.8k
    if (auto DA = inheritable_value<String>("/DA")) {
269
18.5k
        return DA.utf8_value();
270
18.5k
    }
271
4.33k
    if (String DA = from_AcroForm("/DA")) {
272
583
        return DA.utf8_value();
273
583
    }
274
3.75k
    return {};
275
4.33k
}
276
277
int
278
QPDFFormFieldObjectHelper::getQuadding()
279
0
{
280
0
    return m->getQuadding();
281
0
}
282
283
int
284
FormNode::getQuadding()
285
0
{
286
0
    auto fv = inheritable_value<QPDFObjectHandle>("/Q");
287
0
    bool looked_in_acroform = false;
288
0
    if (!fv.isInteger()) {
289
0
        fv = from_AcroForm("/Q");
290
0
        looked_in_acroform = true;
291
0
    }
292
0
    if (fv.isInteger()) {
293
0
        QTC::TC("qpdf", "QPDFFormFieldObjectHelper Q present", looked_in_acroform ? 0 : 1);
294
0
        return QIntC::to_int(fv.getIntValue());
295
0
    }
296
0
    return 0;
297
0
}
298
299
int
300
QPDFFormFieldObjectHelper::getFlags()
301
0
{
302
0
    return m->getFlags();
303
0
}
304
305
int
306
FormNode::getFlags()
307
10.4k
{
308
10.4k
    auto f = inheritable_value<QPDFObjectHandle>("/Ff");
309
10.4k
    return f.isInteger() ? f.getIntValueAsInt() : 0;
310
10.4k
}
311
312
bool
313
QPDFFormFieldObjectHelper::isText()
314
0
{
315
0
    return m->isText();
316
0
}
317
318
bool
319
FormNode::isText()
320
0
{
321
0
    return FT() == "/Tx";
322
0
}
323
324
bool
325
QPDFFormFieldObjectHelper::isCheckbox()
326
1.32k
{
327
1.32k
    return m->isCheckbox();
328
1.32k
}
329
330
bool
331
FormNode::isCheckbox()
332
3.19k
{
333
3.19k
    return FT() == "/Btn" && (getFlags() & (ff_btn_radio | ff_btn_pushbutton)) == 0;
334
3.19k
}
335
336
bool
337
QPDFFormFieldObjectHelper::isChecked()
338
0
{
339
0
    return m->isChecked();
340
0
}
341
342
bool
343
FormNode::isChecked()
344
0
{
345
0
    return isCheckbox() && V<Name>() != "/Off";
346
0
}
347
348
bool
349
QPDFFormFieldObjectHelper::isRadioButton()
350
2.01k
{
351
2.01k
    return m->isRadioButton();
352
2.01k
}
353
354
bool
355
FormNode::isRadioButton()
356
3.31k
{
357
3.31k
    return FT() == "/Btn" && (getFlags() & ff_btn_radio) == ff_btn_radio;
358
3.31k
}
359
360
bool
361
QPDFFormFieldObjectHelper::isPushbutton()
362
0
{
363
0
    return m->isPushbutton();
364
0
}
365
366
bool
367
FormNode::isPushbutton()
368
0
{
369
0
    return FT() == "/Btn" && (getFlags() & ff_btn_pushbutton) == ff_btn_pushbutton;
370
0
}
371
372
bool
373
QPDFFormFieldObjectHelper::isChoice()
374
0
{
375
0
    return m->isChoice();
376
0
}
377
378
bool
379
FormNode::isChoice()
380
26.5k
{
381
26.5k
    return FT() == "/Ch";
382
26.5k
}
383
384
std::vector<std::string>
385
QPDFFormFieldObjectHelper::getChoices()
386
0
{
387
0
    return m->getChoices();
388
0
}
389
390
std::vector<std::string>
391
FormNode::getChoices()
392
3.66k
{
393
3.66k
    if (!isChoice()) {
394
0
        return {};
395
0
    }
396
3.66k
    std::vector<std::string> result;
397
210k
    for (auto const& item: inheritable_value<Array>("/Opt")) {
398
210k
        if (item.isString()) {
399
188k
            result.emplace_back(item.getUTF8Value());
400
188k
        } else if (item.size() == 2) {
401
482
            auto display = item.getArrayItem(1);
402
482
            if (display.isString()) {
403
333
                result.emplace_back(display.getUTF8Value());
404
333
            }
405
482
        }
406
210k
    }
407
3.66k
    return result;
408
3.66k
}
409
410
void
411
QPDFFormFieldObjectHelper::setFieldAttribute(std::string const& key, QPDFObjectHandle value)
412
0
{
413
0
    m->setFieldAttribute(key, value);
414
0
}
415
416
void
417
FormNode::setFieldAttribute(std::string const& key, QPDFObjectHandle value)
418
0
{
419
0
    replace(key, value);
420
0
}
421
422
void
423
FormNode::setFieldAttribute(std::string const& key, Name const& value)
424
666
{
425
666
    replace(key, value);
426
666
}
427
428
void
429
QPDFFormFieldObjectHelper::setFieldAttribute(std::string const& key, std::string const& utf8_value)
430
0
{
431
0
    m->setFieldAttribute(key, utf8_value);
432
0
}
433
434
void
435
FormNode::setFieldAttribute(std::string const& key, std::string const& utf8_value)
436
0
{
437
0
    replace(key, String::utf16(utf8_value));
438
0
}
439
440
void
441
QPDFFormFieldObjectHelper::setV(QPDFObjectHandle value, bool need_appearances)
442
1.86k
{
443
1.86k
    m->setV(value, need_appearances);
444
1.86k
}
445
446
void
447
FormNode::setV(QPDFObjectHandle value, bool need_appearances)
448
1.86k
{
449
1.86k
    if (FT() == "/Btn") {
450
1.86k
        Name name = value;
451
1.86k
        if (isCheckbox()) {
452
1.17k
            if (!name) {
453
508
                warn("ignoring attempt to set a checkbox field to a value whose type is not name");
454
508
                return;
455
508
            }
456
            // Accept any value other than /Off to mean checked. Files have been seen that use
457
            // /1 or other values.
458
666
            setCheckBoxValue(name != "/Off");
459
666
            return;
460
1.17k
        }
461
693
        if (isRadioButton()) {
462
693
            if (!name) {
463
89
                warn(
464
89
                    "ignoring attempt to set a radio button field to an object that is not a name");
465
89
                return;
466
89
            }
467
604
            setRadioButtonValue(name);
468
604
            return;
469
693
        }
470
0
        if (isPushbutton()) {
471
0
            warn("ignoring attempt set the value of a pushbutton field");
472
0
        }
473
0
        return;
474
693
    }
475
0
    if (value.isString()) {
476
0
        setFieldAttribute("/V", QPDFObjectHandle::newUnicodeString(value.getUTF8Value()));
477
0
    } else {
478
0
        setFieldAttribute("/V", value);
479
0
    }
480
0
    if (need_appearances) {
481
0
        QPDF& qpdf = oh().getQPDF(
482
0
            "QPDFFormFieldObjectHelper::setV called with need_appearances = "
483
0
            "true on an object that is not associated with an owning QPDF");
484
0
        qpdf.doc().acroform().setNeedAppearances(true);
485
0
    }
486
0
}
487
488
void
489
QPDFFormFieldObjectHelper::setV(std::string const& utf8_value, bool need_appearances)
490
0
{
491
0
    m->setV(utf8_value, need_appearances);
492
0
}
493
494
void
495
FormNode::setV(std::string const& utf8_value, bool need_appearances)
496
0
{
497
0
    setV(QPDFObjectHandle::newUnicodeString(utf8_value), need_appearances);
498
0
}
499
500
void
501
FormNode::setRadioButtonValue(Name const& name)
502
948
{
503
948
    qpdf_expect(name);
504
    // Set the value of a radio button field. This has the following specific behavior:
505
    // * If this is a node without /Kids, assume this is a individual radio button widget and call
506
    // itself on the parent
507
    // * If this is a radio button field with children, set /V to the given value. Then, for each
508
    //   child, if the child has the specified value as one of its keys in the /N subdictionary of
509
    //   its /AP (i.e. its normal appearance stream dictionary), set /AS to name; otherwise, if /Off
510
    //   is a member, set /AS to /Off.
511
948
    auto kids = Kids();
512
948
    if (!kids) {
513
        // This is most likely one of the individual buttons. Try calling on the parent.
514
444
        auto parent = Parent();
515
444
        if (parent.Kids()) {
516
344
            parent.setRadioButtonValue(name);
517
344
            return;
518
344
        }
519
444
    }
520
604
    if (!isRadioButton() || !kids) {
521
147
        warn("don't know how to set the value of this field as a radio button");
522
147
        return;
523
147
    }
524
457
    replace("/V", name);
525
7.19k
    for (FormNode kid: kids) {
526
7.19k
        auto ap = kid.AP();
527
7.19k
        QPDFObjectHandle annot;
528
7.19k
        if (!ap) {
529
            // The widget may be below. If there is more than one, just find the first one.
530
21.2k
            for (FormNode grandkid: kid.Kids()) {
531
21.2k
                ap = grandkid.AP();
532
21.2k
                if (ap) {
533
373
                    annot = grandkid;
534
373
                    break;
535
373
                }
536
21.2k
            }
537
6.35k
        } else {
538
838
            annot = kid;
539
838
        }
540
7.19k
        if (!annot) {
541
5.98k
            warn("unable to set the value of this radio button");
542
5.98k
            continue;
543
5.98k
        }
544
1.21k
        if (ap["/N"].contains(name.value())) {
545
218
            annot.replace("/AS", name);
546
993
        } else {
547
993
            annot.replace("/AS", Name("/Off"));
548
993
        }
549
1.21k
    }
550
457
}
551
552
void
553
FormNode::setCheckBoxValue(bool value)
554
666
{
555
666
    auto ap = AP();
556
666
    QPDFObjectHandle annot;
557
666
    if (ap) {
558
433
        annot = oh();
559
433
    } else {
560
        // The widget may be below. If there is more than one, just find the first one.
561
2.62k
        for (FormNode kid: Kids()) {
562
2.62k
            ap = kid.AP();
563
2.62k
            if (ap) {
564
47
                annot = kid;
565
47
                break;
566
47
            }
567
2.62k
        }
568
233
    }
569
666
    std::string on_value;
570
666
    if (value) {
571
        // Set the "on" value to the first value in the appearance stream's normal state dictionary
572
        // that isn't /Off. If not found, fall back to /Yes.
573
580
        if (ap) {
574
517
            for (auto const& item: Dictionary(ap["/N"])) {
575
517
                if (item.first != "/Off") {
576
322
                    on_value = item.first;
577
322
                    break;
578
322
                }
579
517
            }
580
425
        }
581
580
        if (on_value.empty()) {
582
258
            on_value = "/Yes";
583
258
        }
584
580
    }
585
586
    // Set /AS to the on value or /Off in addition to setting /V.
587
666
    auto name = Name(value ? on_value : "/Off");
588
666
    setFieldAttribute("/V", name);
589
666
    if (!annot) {
590
186
        warn("unable to set the value of this checkbox");
591
186
        return;
592
186
    }
593
480
    annot.replace("/AS", name);
594
480
}
595
596
void
597
QPDFFormFieldObjectHelper::generateAppearance(QPDFAnnotationObjectHelper& aoh)
598
30.2k
{
599
30.2k
    m->generateAppearance(aoh);
600
30.2k
}
601
602
void
603
FormNode::generateAppearance(QPDFAnnotationObjectHelper& aoh)
604
30.2k
{
605
    // Ignore field types we don't know how to generate appearances for. Button fields don't really
606
    // need them -- see code in QPDFAcroFormDocumentHelper::generateAppearancesIfNeeded.
607
30.2k
    auto ft = FT();
608
30.2k
    if (ft == "/Tx" || ft == "/Ch") {
609
27.6k
        generateTextAppearance(aoh);
610
27.6k
    }
611
30.2k
}
612
613
namespace
614
{
615
    class ValueSetter: public QPDFObjectHandle::TokenFilter
616
    {
617
      public:
618
        ValueSetter(
619
            std::string const& DA,
620
            std::string const& V,
621
            std::vector<std::string> const& opt,
622
            double tf,
623
            QPDFObjectHandle::Rectangle const& bbox);
624
22.8k
        ~ValueSetter() override = default;
625
        void handleToken(QPDFTokenizer::Token const&) override;
626
        void handleEOF() override;
627
        void writeAppearance();
628
629
      private:
630
        std::string DA;
631
        std::string V;
632
        std::vector<std::string> opt;
633
        double tf;
634
        QPDFObjectHandle::Rectangle bbox;
635
        enum { st_top, st_bmc, st_emc, st_end } state{st_top};
636
        bool replaced{false};
637
    };
638
} // namespace
639
640
ValueSetter::ValueSetter(
641
    std::string const& DA,
642
    std::string const& V,
643
    std::vector<std::string> const& opt,
644
    double tf,
645
    QPDFObjectHandle::Rectangle const& bbox) :
646
22.8k
    DA(DA),
647
22.8k
    V(V),
648
22.8k
    opt(opt),
649
22.8k
    tf(tf),
650
22.8k
    bbox(bbox)
651
22.8k
{
652
22.8k
}
653
654
void
655
ValueSetter::handleToken(QPDFTokenizer::Token const& token)
656
1.65M
{
657
1.65M
    QPDFTokenizer::token_type_e ttype = token.getType();
658
1.65M
    std::string value = token.getValue();
659
1.65M
    bool do_replace = false;
660
1.65M
    switch (state) {
661
296k
    case st_top:
662
296k
        writeToken(token);
663
296k
        if (token.isWord("BMC")) {
664
18.6k
            state = st_bmc;
665
18.6k
        }
666
296k
        break;
667
668
37.5k
    case st_bmc:
669
37.5k
        if ((ttype == QPDFTokenizer::tt_space) || (ttype == QPDFTokenizer::tt_comment)) {
670
18.9k
            writeToken(token);
671
18.9k
        } else {
672
18.6k
            state = st_emc;
673
18.6k
        }
674
        // fall through to emc
675
676
1.32M
    case st_emc:
677
1.32M
        if (token.isWord("EMC")) {
678
18.4k
            do_replace = true;
679
18.4k
            state = st_end;
680
18.4k
        }
681
1.32M
        break;
682
683
36.3k
    case st_end:
684
36.3k
        writeToken(token);
685
36.3k
        break;
686
1.65M
    }
687
1.65M
    if (do_replace) {
688
18.4k
        writeAppearance();
689
18.4k
    }
690
1.65M
}
691
692
void
693
ValueSetter::handleEOF()
694
22.3k
{
695
22.3k
    if (!replaced) {
696
3.96k
        QTC::TC("qpdf", "QPDFFormFieldObjectHelper replaced BMC at EOF");
697
3.96k
        write("/Tx BMC\n");
698
3.96k
        writeAppearance();
699
3.96k
    }
700
22.3k
}
701
702
void
703
ValueSetter::writeAppearance()
704
22.3k
{
705
22.3k
    replaced = true;
706
707
    // This code does not take quadding into consideration because doing so requires font metric
708
    // information, which we don't have in many cases.
709
710
22.3k
    double tfh = 1.2 * tf;
711
22.3k
    int dx = 1;
712
713
    // Write one or more lines, centered vertically, possibly with one row highlighted.
714
715
22.3k
    auto max_rows = static_cast<size_t>((bbox.ury - bbox.lly) / tfh);
716
22.3k
    bool highlight = false;
717
22.3k
    size_t highlight_idx = 0;
718
719
22.3k
    std::vector<std::string> lines;
720
22.3k
    if (opt.empty() || (max_rows < 2)) {
721
20.8k
        lines.push_back(V);
722
20.8k
    } else {
723
        // Figure out what rows to write
724
1.47k
        size_t nopt = opt.size();
725
1.47k
        size_t found_idx = 0;
726
1.47k
        bool found = false;
727
125k
        for (found_idx = 0; found_idx < nopt; ++found_idx) {
728
124k
            if (opt.at(found_idx) == V) {
729
657
                found = true;
730
657
                break;
731
657
            }
732
124k
        }
733
1.47k
        if (found) {
734
            // Try to make the found item the second one, but adjust for under/overflow.
735
657
            int wanted_first = QIntC::to_int(found_idx) - 1;
736
657
            int wanted_last = QIntC::to_int(found_idx + max_rows) - 2;
737
657
            QTC::TC("qpdf", "QPDFFormFieldObjectHelper list found");
738
657
            if (wanted_first < 0) {
739
183
                QTC::TC("qpdf", "QPDFFormFieldObjectHelper list first too low");
740
183
                wanted_last -= wanted_first;
741
183
                wanted_first = 0;
742
183
            }
743
657
            if (wanted_last >= QIntC::to_int(nopt)) {
744
569
                QTC::TC("qpdf", "QPDFFormFieldObjectHelper list last too high");
745
569
                auto diff = wanted_last - QIntC::to_int(nopt) + 1;
746
569
                wanted_first = std::max(0, wanted_first - diff);
747
569
                wanted_last -= diff;
748
569
            }
749
657
            highlight = true;
750
657
            highlight_idx = found_idx - QIntC::to_size(wanted_first);
751
44.6k
            for (size_t i = QIntC::to_size(wanted_first); i <= QIntC::to_size(wanted_last); ++i) {
752
43.9k
                lines.push_back(opt.at(i));
753
43.9k
            }
754
814
        } else {
755
814
            QTC::TC("qpdf", "QPDFFormFieldObjectHelper list not found");
756
            // include our value and the first n-1 rows
757
814
            highlight_idx = 0;
758
814
            highlight = true;
759
814
            lines.push_back(V);
760
44.2k
            for (size_t i = 0; ((i < nopt) && (i < (max_rows - 1))); ++i) {
761
43.4k
                lines.push_back(opt.at(i));
762
43.4k
            }
763
814
        }
764
1.47k
    }
765
766
    // Write the lines centered vertically, highlighting if needed
767
22.3k
    size_t nlines = lines.size();
768
22.3k
    double dy = bbox.ury - ((bbox.ury - bbox.lly - (static_cast<double>(nlines) * tfh)) / 2.0);
769
22.3k
    if (highlight) {
770
1.42k
        write(
771
1.42k
            "q\n0.85 0.85 0.85 rg\n" + QUtil::double_to_string(bbox.llx) + " " +
772
1.42k
            QUtil::double_to_string(
773
1.42k
                bbox.lly + dy - (tfh * (static_cast<double>(highlight_idx + 1)))) +
774
1.42k
            " " + QUtil::double_to_string(bbox.urx - bbox.llx) + " " +
775
1.42k
            QUtil::double_to_string(tfh) + " re f\nQ\n");
776
1.42k
    }
777
22.3k
    dy -= tf;
778
22.3k
    write("q\nBT\n" + DA + "\n");
779
131k
    for (size_t i = 0; i < nlines; ++i) {
780
        // We could adjust Tm to translate to the beginning the first line, set TL to tfh, and use
781
        // T* for each subsequent line, but doing this would require extracting any Tm from DA,
782
        // which doesn't seem really worth the effort.
783
109k
        if (i == 0) {
784
22.3k
            write(
785
22.3k
                QUtil::double_to_string(bbox.llx + static_cast<double>(dx)) + " " +
786
22.3k
                QUtil::double_to_string(bbox.lly + static_cast<double>(dy)) + " Td\n");
787
86.8k
        } else {
788
86.8k
            write("0 " + QUtil::double_to_string(-tfh) + " Td\n");
789
86.8k
        }
790
109k
        write(QPDFObjectHandle::newString(lines.at(i)).unparse() + " Tj\n");
791
109k
    }
792
22.3k
    write("ET\nQ\nEMC");
793
22.3k
}
794
795
namespace
796
{
797
    class TfFinder final: public QPDFObjectHandle::TokenFilter
798
    {
799
      public:
800
22.8k
        TfFinder() = default;
801
22.8k
        ~TfFinder() final = default;
802
803
        void
804
        handleToken(QPDFTokenizer::Token const& token) final
805
1.58M
        {
806
1.58M
            auto ttype = token.getType();
807
1.58M
            auto const& value = token.getValue();
808
1.58M
            DA.emplace_back(token.getRawValue());
809
1.58M
            switch (ttype) {
810
349k
            case QPDFTokenizer::tt_integer:
811
393k
            case QPDFTokenizer::tt_real:
812
393k
                last_num = strtod(value.c_str(), nullptr);
813
393k
                last_num_idx = QIntC::to_int(DA.size() - 1);
814
393k
                break;
815
816
133k
            case QPDFTokenizer::tt_name:
817
133k
                last_name = value;
818
133k
                break;
819
820
254k
            case QPDFTokenizer::tt_word:
821
254k
                if (token.isWord("Tf")) {
822
18.4k
                    if ((last_num > 1.0) && (last_num < 1000.0)) {
823
                        // These ranges are arbitrary but keep us from doing insane things or
824
                        // suffering from over/underflow
825
15.4k
                        tf = last_num;
826
15.4k
                    }
827
18.4k
                    tf_idx = last_num_idx;
828
18.4k
                    font_name = last_name;
829
18.4k
                }
830
254k
                break;
831
832
804k
            default:
833
804k
                break;
834
1.58M
            }
835
1.58M
        }
836
837
        double
838
        getTf() const
839
22.8k
        {
840
22.8k
            return tf;
841
22.8k
        }
842
        std::string
843
        getFontName() const
844
22.8k
        {
845
22.8k
            return font_name;
846
22.8k
        }
847
848
        std::string
849
        getDA()
850
22.8k
        {
851
22.8k
            std::string result;
852
22.8k
            int i = -1;
853
1.58M
            for (auto const& cur: DA) {
854
1.58M
                if (++i == tf_idx) {
855
15.6k
                    double delta = strtod(cur.c_str(), nullptr) - tf;
856
15.6k
                    if (delta > 0.001 || delta < -0.001) {
857
                        // tf doesn't match the font size passed to Tf, so substitute.
858
1.36k
                        QTC::TC("qpdf", "QPDFFormFieldObjectHelper fallback Tf");
859
1.36k
                        result += QUtil::double_to_string(tf);
860
1.36k
                        continue;
861
1.36k
                    }
862
15.6k
                }
863
1.58M
                result += cur;
864
1.58M
            }
865
22.8k
            return result;
866
22.8k
        }
867
868
      private:
869
        double tf{11.0};
870
        int tf_idx{-1};
871
        std::string font_name;
872
        double last_num{0.0};
873
        int last_num_idx{-1};
874
        std::string last_name;
875
        std::vector<std::string> DA;
876
    };
877
} // namespace
878
879
void
880
FormNode::generateTextAppearance(QPDFAnnotationObjectHelper& aoh)
881
27.6k
{
882
27.6k
    no_ci_warn_if(
883
27.6k
        !Dictionary(aoh), // There is no guarantee that aoh is a dictionary
884
27.6k
        "cannot generate appearance for non-dictionary annotation" //
885
27.6k
    );
886
27.6k
    Stream AS = aoh.getAppearanceStream("/N"); // getAppearanceStream returns a stream or null.
887
27.6k
    if (!AS) {
888
11.5k
        QPDFObjectHandle::Rectangle rect = aoh.getRect(); // may silently be invalid / all zeros
889
11.5k
        QPDFObjectHandle::Rectangle bbox(0, 0, rect.urx - rect.llx, rect.ury - rect.lly);
890
11.5k
        auto* pdf = qpdf();
891
11.5k
        no_ci_stop_damaged_if(!pdf, "unable to get owning QPDF for appearance generation");
892
11.5k
        AS = pdf->newStream("/Tx BMC\nEMC\n");
893
11.5k
        AS.replaceDict(Dictionary(
894
11.5k
            {{"/BBox", QPDFObjectHandle::newFromRectangle(bbox)},
895
11.5k
             {"/Resources", Dictionary({{"/ProcSet", Array({Name("/PDF"), Name("/Text")})}})},
896
11.5k
             {"/Type", Name("/XObject")},
897
11.5k
             {"/Subtype", Name("/Form")}}));
898
11.5k
        if (auto ap = AP()) {
899
1.92k
            ap.replace("/N", AS);
900
9.58k
        } else {
901
9.58k
            aoh.replace("/AP", Dictionary({{"/N", AS}}));
902
9.58k
        }
903
11.5k
    }
904
905
27.6k
    if (AS.obj_sp().use_count() > 3) {
906
        // Ensures that the appearance stream is not shared by copying it if the threshold of 3 is
907
        // exceeded. The threshold is based on the current implementation details:
908
        // - One reference from the local variable AS
909
        // - One reference from the appearance dictionary (/AP)
910
        // - One reference from the object table
911
        // If use_count() is greater than 3, it means the appearance stream is shared elsewhere,
912
        // and updating it could have unintended side effects. This threshold may need to be updated
913
        // if the internal reference counting changes in the future.
914
        //
915
        // There is currently no explicit CI test for this code. It has been manually tested by
916
        // running it through CI with a threshold of 0, unconditionally copying streams.
917
5.21k
        auto data = AS.getStreamData(qpdf_dl_all);
918
5.21k
        AS = AS.copy();
919
5.21k
        AS.replaceStreamData(std::move(data), Null::temp(), Null::temp());
920
5.21k
        if (Dictionary AP = aoh.getAppearanceDictionary()) {
921
2.14k
            AP.replace("/N", AS);
922
3.06k
        } else {
923
3.06k
            aoh.replace("/AP", Dictionary({{"/N", AS}}));
924
            // aoh is a dictionary, so insertion will succeed. No need to check by retrieving it.
925
3.06k
        }
926
5.21k
    }
927
27.6k
    QPDFObjectHandle bbox_obj = AS.getDict()["/BBox"];
928
27.6k
    if (!bbox_obj.isRectangle()) {
929
1.71k
        aoh.warn("unable to get appearance stream bounding box");
930
1.71k
        return;
931
1.71k
    }
932
25.9k
    QPDFObjectHandle::Rectangle bbox = bbox_obj.getArrayAsRectangle();
933
25.9k
    std::string DA = default_appearance();
934
25.9k
    std::string V = value();
935
936
25.9k
    TfFinder tff;
937
25.9k
    Pl_QPDFTokenizer tok("tf", &tff);
938
25.9k
    tok.writeString(DA);
939
25.9k
    tok.finish();
940
25.9k
    double tf = tff.getTf();
941
25.9k
    DA = tff.getDA();
942
943
25.9k
    std::string (*encoder)(std::string const&, char) = &QUtil::utf8_to_ascii;
944
25.9k
    std::string font_name = tff.getFontName();
945
25.9k
    if (!font_name.empty()) {
946
        // See if the font is encoded with something we know about.
947
15.6k
        Dictionary resources = AS.getDict()["/Resources"];
948
15.6k
        Dictionary font = resources["/Font"][font_name];
949
15.6k
        if (!font) {
950
15.2k
            font = getDefaultResources()["/Font"][font_name];
951
15.2k
            if (resources) {
952
10.6k
                if (resources.indirect()) {
953
455
                    resources = resources.qpdf()->makeIndirectObject(resources.copy());
954
455
                    AS.getDict().replace("/Resources", resources);
955
455
                }
956
                // Use mergeResources to force /Font to be local
957
10.6k
                QPDFObjectHandle res = resources;
958
10.6k
                res.mergeResources(Dictionary({{"/Font", Dictionary::empty()}}));
959
10.6k
                res.getKey("/Font").replace(font_name, font);
960
10.6k
            }
961
15.2k
        }
962
963
15.6k
        if (Name Encoding = font["/Encoding"]) {
964
1.50k
            if (Encoding == "/WinAnsiEncoding") {
965
493
                encoder = &QUtil::utf8_to_win_ansi;
966
1.01k
            } else if (Encoding == "/MacRomanEncoding") {
967
78
                encoder = &QUtil::utf8_to_mac_roman;
968
78
            }
969
1.50k
        }
970
15.6k
    }
971
972
25.9k
    V = (*encoder)(V, '?');
973
974
25.9k
    std::vector<std::string> opt;
975
25.9k
    if (isChoice() && (getFlags() & ff_ch_combo) == 0) {
976
3.66k
        opt = getChoices();
977
189k
        for (auto& o: opt) {
978
189k
            o = (*encoder)(o, '?');
979
189k
        }
980
3.66k
    }
981
982
25.9k
    std::string result;
983
25.9k
    pl::String pl(result);
984
25.9k
    ValueSetter vs(DA, V, opt, tf, bbox);
985
25.9k
    Pl_QPDFTokenizer vs_tok("", &vs, &pl);
986
25.9k
    vs_tok.writeString(AS.getStreamData(qpdf_dl_all));
987
25.9k
    vs_tok.finish();
988
25.9k
    AS.replaceStreamData(std::move(result), Null::temp(), Null::temp());
989
25.9k
}