├── LICENSE
├── README.md
├── libPDFium
├── libpdfium
│ ├── BUILD.gn
│ ├── libpdfium.cc
│ ├── libpdfium.def
│ ├── libpdfium.h
│ └── libpdfium.rc
├── out
│ └── args.gn
└── readme.md
├── printdlg.png
├── screenshot.png
└── src
├── DynamicButtons.pas
├── Execute.libPDFium.pas
├── Main.dfm
├── Main.pas
├── PDFium.Frame.dfm
├── PDFium.Frame.pas
├── PDFium.PrintDlg.dfm
├── PDFium.PrintDlg.pas
├── PDFium.SearchDlg.dfm
├── PDFium.SearchDlg.pas
├── PDFiumReader.dpr
├── PDFiumReader.dproj
└── PDFiumReader.res
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
5 | Everyone is permitted to copy and distribute verbatim copies
6 | of this license document, but changing it is not allowed.
7 |
8 | Preamble
9 |
10 | The GNU General Public License is a free, copyleft license for
11 | software and other kinds of works.
12 |
13 | The licenses for most software and other practical works are designed
14 | to take away your freedom to share and change the works. By contrast,
15 | the GNU General Public License is intended to guarantee your freedom to
16 | share and change all versions of a program--to make sure it remains free
17 | software for all its users. We, the Free Software Foundation, use the
18 | GNU General Public License for most of our software; it applies also to
19 | any other work released this way by its authors. You can apply it to
20 | your programs, too.
21 |
22 | When we speak of free software, we are referring to freedom, not
23 | price. Our General Public Licenses are designed to make sure that you
24 | have the freedom to distribute copies of free software (and charge for
25 | them if you wish), that you receive source code or can get it if you
26 | want it, that you can change the software or use pieces of it in new
27 | free programs, and that you know you can do these things.
28 |
29 | To protect your rights, we need to prevent others from denying you
30 | these rights or asking you to surrender the rights. Therefore, you have
31 | certain responsibilities if you distribute copies of the software, or if
32 | you modify it: responsibilities to respect the freedom of others.
33 |
34 | For example, if you distribute copies of such a program, whether
35 | gratis or for a fee, you must pass on to the recipients the same
36 | freedoms that you received. You must make sure that they, too, receive
37 | or can get the source code. And you must show them these terms so they
38 | know their rights.
39 |
40 | Developers that use the GNU GPL protect your rights with two steps:
41 | (1) assert copyright on the software, and (2) offer you this License
42 | giving you legal permission to copy, distribute and/or modify it.
43 |
44 | For the developers' and authors' protection, the GPL clearly explains
45 | that there is no warranty for this free software. For both users' and
46 | authors' sake, the GPL requires that modified versions be marked as
47 | changed, so that their problems will not be attributed erroneously to
48 | authors of previous versions.
49 |
50 | Some devices are designed to deny users access to install or run
51 | modified versions of the software inside them, although the manufacturer
52 | can do so. This is fundamentally incompatible with the aim of
53 | protecting users' freedom to change the software. The systematic
54 | pattern of such abuse occurs in the area of products for individuals to
55 | use, which is precisely where it is most unacceptable. Therefore, we
56 | have designed this version of the GPL to prohibit the practice for those
57 | products. If such problems arise substantially in other domains, we
58 | stand ready to extend this provision to those domains in future versions
59 | of the GPL, as needed to protect the freedom of users.
60 |
61 | Finally, every program is threatened constantly by software patents.
62 | States should not allow patents to restrict development and use of
63 | software on general-purpose computers, but in those that do, we wish to
64 | avoid the special danger that patents applied to a free program could
65 | make it effectively proprietary. To prevent this, the GPL assures that
66 | patents cannot be used to render the program non-free.
67 |
68 | The precise terms and conditions for copying, distribution and
69 | modification follow.
70 |
71 | TERMS AND CONDITIONS
72 |
73 | 0. Definitions.
74 |
75 | "This License" refers to version 3 of the GNU General Public License.
76 |
77 | "Copyright" also means copyright-like laws that apply to other kinds of
78 | works, such as semiconductor masks.
79 |
80 | "The Program" refers to any copyrightable work licensed under this
81 | License. Each licensee is addressed as "you". "Licensees" and
82 | "recipients" may be individuals or organizations.
83 |
84 | To "modify" a work means to copy from or adapt all or part of the work
85 | in a fashion requiring copyright permission, other than the making of an
86 | exact copy. The resulting work is called a "modified version" of the
87 | earlier work or a work "based on" the earlier work.
88 |
89 | A "covered work" means either the unmodified Program or a work based
90 | on the Program.
91 |
92 | To "propagate" a work means to do anything with it that, without
93 | permission, would make you directly or secondarily liable for
94 | infringement under applicable copyright law, except executing it on a
95 | computer or modifying a private copy. Propagation includes copying,
96 | distribution (with or without modification), making available to the
97 | public, and in some countries other activities as well.
98 |
99 | To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies. Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 |
103 | An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License. If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 |
112 | 1. Source Code.
113 |
114 | The "source code" for a work means the preferred form of the work
115 | for making modifications to it. "Object code" means any non-source
116 | form of a work.
117 |
118 | A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 |
123 | The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form. A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 |
134 | The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities. However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work. For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 |
147 | The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 |
151 | The Corresponding Source for a work in source code form is that
152 | same work.
153 |
154 | 2. Basic Permissions.
155 |
156 | All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met. This License explicitly affirms your unlimited
159 | permission to run the unmodified Program. The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work. This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 |
164 | You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force. You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright. Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 |
175 | Conveying under any other circumstances is permitted solely under
176 | the conditions stated below. Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 |
179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 |
181 | No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 |
187 | When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 |
195 | 4. Conveying Verbatim Copies.
196 |
197 | You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 |
205 | You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 |
208 | 5. Conveying Modified Source Versions.
209 |
210 | You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 |
214 | a) The work must carry prominent notices stating that you modified
215 | it, and giving a relevant date.
216 |
217 | b) The work must carry prominent notices stating that it is
218 | released under this License and any conditions added under section
219 | 7. This requirement modifies the requirement in section 4 to
220 | "keep intact all notices".
221 |
222 | c) You must license the entire work, as a whole, under this
223 | License to anyone who comes into possession of a copy. This
224 | License will therefore apply, along with any applicable section 7
225 | additional terms, to the whole of the work, and all its parts,
226 | regardless of how they are packaged. This License gives no
227 | permission to license the work in any other way, but it does not
228 | invalidate such permission if you have separately received it.
229 |
230 | d) If the work has interactive user interfaces, each must display
231 | Appropriate Legal Notices; however, if the Program has interactive
232 | interfaces that do not display Appropriate Legal Notices, your
233 | work need not make them do so.
234 |
235 | A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit. Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 |
245 | 6. Conveying Non-Source Forms.
246 |
247 | You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 |
252 | a) Convey the object code in, or embodied in, a physical product
253 | (including a physical distribution medium), accompanied by the
254 | Corresponding Source fixed on a durable physical medium
255 | customarily used for software interchange.
256 |
257 | b) Convey the object code in, or embodied in, a physical product
258 | (including a physical distribution medium), accompanied by a
259 | written offer, valid for at least three years and valid for as
260 | long as you offer spare parts or customer support for that product
261 | model, to give anyone who possesses the object code either (1) a
262 | copy of the Corresponding Source for all the software in the
263 | product that is covered by this License, on a durable physical
264 | medium customarily used for software interchange, for a price no
265 | more than your reasonable cost of physically performing this
266 | conveying of source, or (2) access to copy the
267 | Corresponding Source from a network server at no charge.
268 |
269 | c) Convey individual copies of the object code with a copy of the
270 | written offer to provide the Corresponding Source. This
271 | alternative is allowed only occasionally and noncommercially, and
272 | only if you received the object code with such an offer, in accord
273 | with subsection 6b.
274 |
275 | d) Convey the object code by offering access from a designated
276 | place (gratis or for a charge), and offer equivalent access to the
277 | Corresponding Source in the same way through the same place at no
278 | further charge. You need not require recipients to copy the
279 | Corresponding Source along with the object code. If the place to
280 | copy the object code is a network server, the Corresponding Source
281 | may be on a different server (operated by you or a third party)
282 | that supports equivalent copying facilities, provided you maintain
283 | clear directions next to the object code saying where to find the
284 | Corresponding Source. Regardless of what server hosts the
285 | Corresponding Source, you remain obligated to ensure that it is
286 | available for as long as needed to satisfy these requirements.
287 |
288 | e) Convey the object code using peer-to-peer transmission, provided
289 | you inform other peers where the object code and Corresponding
290 | Source of the work are being offered to the general public at no
291 | charge under subsection 6d.
292 |
293 | A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 |
297 | A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling. In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage. For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product. A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 |
310 | "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source. The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 |
318 | If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information. But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 |
329 | The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed. Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 |
337 | Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 |
343 | 7. Additional Terms.
344 |
345 | "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law. If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 |
354 | When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it. (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.) You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 |
361 | Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 |
365 | a) Disclaiming warranty or limiting liability differently from the
366 | terms of sections 15 and 16 of this License; or
367 |
368 | b) Requiring preservation of specified reasonable legal notices or
369 | author attributions in that material or in the Appropriate Legal
370 | Notices displayed by works containing it; or
371 |
372 | c) Prohibiting misrepresentation of the origin of that material, or
373 | requiring that modified versions of such material be marked in
374 | reasonable ways as different from the original version; or
375 |
376 | d) Limiting the use for publicity purposes of names of licensors or
377 | authors of the material; or
378 |
379 | e) Declining to grant rights under trademark law for use of some
380 | trade names, trademarks, or service marks; or
381 |
382 | f) Requiring indemnification of licensors and authors of that
383 | material by anyone who conveys the material (or modified versions of
384 | it) with contractual assumptions of liability to the recipient, for
385 | any liability that these contractual assumptions directly impose on
386 | those licensors and authors.
387 |
388 | All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10. If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term. If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 |
398 | If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 |
403 | Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 |
407 | 8. Termination.
408 |
409 | You may not propagate or modify a covered work except as expressly
410 | provided under this License. Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 |
415 | However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 |
422 | Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 |
429 | Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License. If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 |
435 | 9. Acceptance Not Required for Having Copies.
436 |
437 | You are not required to accept this License in order to receive or
438 | run a copy of the Program. Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance. However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work. These actions infringe copyright if you do
443 | not accept this License. Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 |
446 | 10. Automatic Licensing of Downstream Recipients.
447 |
448 | Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License. You are not responsible
451 | for enforcing compliance by third parties with this License.
452 |
453 | An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations. If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 |
463 | You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License. For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 |
471 | 11. Patents.
472 |
473 | A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based. The
475 | work thus licensed is called the contributor's "contributor version".
476 |
477 | A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version. For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 |
487 | Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 |
492 | In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement). To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 |
499 | If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients. "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 |
513 | If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 |
521 | A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License. You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 |
536 | Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 |
540 | 12. No Surrender of Others' Freedom.
541 |
542 | If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License. If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all. For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 |
552 | 13. Use with the GNU Affero General Public License.
553 |
554 | Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work. The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 |
563 | 14. Revised Versions of this License.
564 |
565 | The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time. Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 |
570 | Each version is given a distinguishing version number. If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation. If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 |
579 | If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 |
584 | Later license versions may give you additional or different
585 | permissions. However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 |
589 | 15. Disclaimer of Warranty.
590 |
591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 |
600 | 16. Limitation of Liability.
601 |
602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 |
612 | 17. Interpretation of Sections 15 and 16.
613 |
614 | If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 |
621 | END OF TERMS AND CONDITIONS
622 |
623 | How to Apply These Terms to Your New Programs
624 |
625 | If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 |
629 | To do so, attach the following notices to the program. It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 |
634 | {one line to give the program's name and a brief idea of what it does.}
635 | Copyright (C) {year} {name of author}
636 |
637 | This program is free software: you can redistribute it and/or modify
638 | it under the terms of the GNU General Public License as published by
639 | the Free Software Foundation, either version 3 of the License, or
640 | (at your option) any later version.
641 |
642 | This program is distributed in the hope that it will be useful,
643 | but WITHOUT ANY WARRANTY; without even the implied warranty of
644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
645 | GNU General Public License for more details.
646 |
647 | You should have received a copy of the GNU General Public License
648 | along with this program. If not, see .
649 |
650 | Also add information on how to contact you by electronic and paper mail.
651 |
652 | If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 |
655 | {project} Copyright (C) {year} {fullname}
656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 | This is free software, and you are welcome to redistribute it
658 | under certain conditions; type `show c' for details.
659 |
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License. Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 |
664 | You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | .
668 |
669 | The GNU General Public License does not permit incorporating your program
670 | into proprietary programs. If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library. If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License. But first, please read
674 | .
675 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # PDFiumReader
2 | Sample Delphi PDF reader based on PDFium
3 |
4 | I don't use PDFium.dll anymore, but my own libPDFium.dll library build from the original PDFium source code
5 |
6 | 
7 |
8 | since June 16, 2020, there's a custom print dialog box
9 |
10 | 
--------------------------------------------------------------------------------
/libPDFium/libpdfium/BUILD.gn:
--------------------------------------------------------------------------------
1 | shared_library("libpdfium") {
2 | cflags = []
3 | ldflags = []
4 | sources = [
5 | "libpdfium.h",
6 | "libpdfium.def",
7 | "libpdfium.cc",
8 | "libpdfium.rc"
9 | ]
10 | defines = [
11 | "PNG_PREFIX",
12 | "PNG_USE_READ_MACROS",
13 | ]
14 | deps = [
15 | "../:pdfium",
16 | "//build/win:default_exe_manifest",
17 | ]
18 | }
19 |
--------------------------------------------------------------------------------
/libPDFium/libpdfium/libpdfium.cc:
--------------------------------------------------------------------------------
1 | #include
2 | #include "public/fpdfview.h"
3 |
4 | #include "public/fpdf_annot.h"
5 | #include "public/fpdf_text.h"
6 | #include "public/fpdf_save.h"
7 | #include "public/fpdf_edit.h"
8 | #include "public/fpdf_doc.h"
9 |
10 | #include "libpdfium.h"
11 |
12 | #define IS_REF(i) (i && *i && (*i == &(*(*i))->Reference))
13 |
14 | //#define TRACE
15 | #ifdef TRACE
16 | #include
17 | DWORD wOut;
18 | #define LOG(s) \
19 | { \
20 | AllocConsole(); \
21 | WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), s, strlen(s), &wOut, 0); \
22 | }
23 | #define REF(i) \
24 | if (i == 0 /*|| !*i || (*i != (*i)->Reference)*/) \
25 | LOG("NULL Interface !!!\n") \
26 | if (*i == 0) \
27 | LOG("NULL Reference !!!\n") \
28 | if (*i != (*i)->Reference) \
29 | LOG("INVALID Reference\n") \
30 | if (!(*i)->Handle) \
31 | LOG("INVALID HANDLE\n")
32 | #else
33 | #define LOG(s)
34 | #define REF(i)
35 | #endif
36 |
37 | // DLL Main
38 |
39 | BOOL APIENTRY DllMain( HMODULE hModule,
40 | DWORD ul_reason_for_call,
41 | LPVOID lpReserved
42 | )
43 | {
44 | switch (ul_reason_for_call)
45 | {
46 | case DLL_PROCESS_ATTACH:
47 | case DLL_THREAD_ATTACH:
48 | case DLL_THREAD_DETACH:
49 | case DLL_PROCESS_DETACH:
50 | break;
51 | }
52 | return TRUE;
53 | }
54 |
55 | // dummy QueryInterface
56 |
57 | int WINAPI QueryInterface(void *self, void *rrid, void *out) {
58 | LOG("QueryInterface\n")
59 | return 0x80004001; // E_NOTIMPL
60 | }
61 |
62 | // generic function
63 | void WINAPI PDF_FreeHandle(IPDFium pdf) {
64 | // IUnknown->Release, can be used with any object
65 | LOG("FreeHandle\n")
66 | (*pdf)->Release(pdf);
67 | }
68 |
69 | // forward
70 | int WINAPI PDF_Free(IPDFium pdf);
71 | int WINAPI PDFPage_Free(IPDFPage page);
72 | int WINAPI PDFText_Free(IPDFText text);
73 | int WINAPI PDFSearchText_Free(IPDFSearchText search);
74 |
75 | // IPDFBookmark
76 |
77 | int InternalGetBookmark(IPDFium pdf, FPDF_BOOKMARK parent, IPDFBookmark *bookmark); // forward
78 |
79 | int WINAPI PDFBookmark_AddRef(IPDFBookmark bookmark) {
80 | LOG("PDFBookmark_AddRef\n")
81 | REF(bookmark)
82 | return ++(*bookmark)->RefCount;
83 | }
84 |
85 | int WINAPI PDFBookmark_Free(IPDFBookmark bookmark) {
86 | LOG("PDFBookmark_Free\n")
87 | REF(bookmark)
88 | int i =--(*bookmark)->RefCount;
89 | if (i == 0) {
90 | PDF_Free((*bookmark)->PDF);
91 | delete (*bookmark)->Reference;
92 | }
93 | return i;
94 | }
95 |
96 | int WINAPI PDFBookmark_GetPageNumber(IPDFBookmark bookmark) {
97 | LOG("PDFBookmark_GetPageNumber\n")
98 | REF(bookmark)
99 | FPDF_DOCUMENT doc = (*(*bookmark)->PDF)->Handle;
100 | FPDF_DEST dest = FPDFBookmark_GetDest(doc, (*bookmark)->Handle);
101 | if (dest) {
102 | return FPDFDest_GetDestPageIndex(doc, dest);
103 | }
104 | return -1;
105 | }
106 |
107 | int WINAPI PDFBookmark_GetTitle(IPDFBookmark bookmark, PChar title, unsigned long size) {
108 | LOG("PDFBookmark_GetTitle\n")
109 | REF(bookmark)
110 | return FPDFBookmark_GetTitle((*bookmark)->Handle, title, size);
111 | }
112 |
113 | int WINAPI PDFBookmark_GetFirstChild(IPDFBookmark bookmark, IPDFBookmark *child) {
114 | LOG("PDFBookmark_GetFirstChild\n")
115 | return InternalGetBookmark((*bookmark)->PDF, (*bookmark)->Handle, child);
116 | }
117 |
118 | int WINAPI PDFBookmark_GetNext(IPDFBookmark bookmark) {
119 | LOG("PDFBookmark_GetNext\n")
120 | REF(bookmark)
121 | FPDF_DOCUMENT doc = (*(*bookmark)->PDF)->Handle;
122 | FPDF_BOOKMARK next = FPDFBookmark_GetNextSibling(doc, (*bookmark)->Handle);
123 | if (next) {
124 | (*bookmark)->Handle = next;
125 | return 0;
126 | }
127 | return 1;
128 | }
129 |
130 | int InternalGetBookmark(IPDFium pdf, FPDF_BOOKMARK parent, IPDFBookmark *bookmark) {
131 | REF(pdf)
132 | if (IS_REF(bookmark))
133 | PDFBookmark_Free(*bookmark);
134 | FPDF_BOOKMARK Handle = FPDFBookmark_GetFirstChild((*pdf)->Handle, parent);
135 | if (Handle) {
136 | TPDFBookmark* PDFBookmark = new TPDFBookmark();
137 | // Internal
138 | (*pdf)->RefCount++;
139 | PDFBookmark->PDF = pdf;
140 | PDFBookmark->Handle = Handle;
141 | PDFBookmark->Reference = PDFBookmark;
142 | PDFBookmark->RefCount = 1;
143 | // IUnknown
144 | PDFBookmark->QueryInterface = QueryInterface;
145 | PDFBookmark->AddRef = PDFBookmark_AddRef;
146 | PDFBookmark->Release = PDFBookmark_Free;
147 | // IPDFBookmark
148 | PDFBookmark->GetPageNumber = PDFBookmark_GetPageNumber;
149 | PDFBookmark->GetTitle = PDFBookmark_GetTitle;
150 | PDFBookmark->GetFirstChild = PDFBookmark_GetFirstChild;
151 | PDFBookmark->GetNext = PDFBookmark_GetNext;
152 | // Result
153 | *bookmark = &PDFBookmark->Reference;
154 | return 0;
155 | }
156 | return 1;
157 | }
158 |
159 | // IPDFAnnotation
160 |
161 | int WINAPI PDFAnnotation_AddRef(IPDFAnnotation annotation) {
162 | LOG("PDFAnnotation_AddRef\n")
163 | REF(annotation)
164 | return ++(*annotation)->RefCount;
165 | }
166 |
167 | int WINAPI PDFAnnotation_Free(IPDFAnnotation annotation) {
168 | LOG("PDFAnnotation_Free\n")
169 | REF(annotation)
170 | int i = --(*annotation)->RefCount;
171 | if (i == 0) {
172 | if ((*annotation)->Handle)
173 | FPDFPage_CloseAnnot((*annotation)->Handle);
174 | PDFPage_Free((*annotation)->Page);
175 | LOG("delete annotation\n")
176 | delete (*annotation)->Reference;
177 | }
178 | return i;
179 | }
180 |
181 | int WINAPI PDFAnnotation_GetSubtype(IPDFAnnotation annotation) {
182 | LOG("PDFAnnotation_GetSubtype\n")
183 | REF(annotation)
184 | return FPDFAnnot_GetSubtype((*annotation)->Handle);
185 | }
186 |
187 | int WINAPI PDFAnnotation_GetRect(IPDFAnnotation annotation, TRectF *rect) {
188 | LOG("PDFAnnotation_GetRect\n")
189 | REF(annotation)
190 | return FPDFAnnot_GetRect((*annotation)->Handle, (FS_LPRECTF)rect);
191 | }
192 |
193 | int WINAPI PDFAnnotation_SetRect(IPDFAnnotation annotation, TRectF *rect) {
194 | LOG("PDFAnnotation_SetRect\n")
195 | REF(annotation)
196 | return FPDFAnnot_SetRect((*annotation)->Handle, (FS_LPRECTF)rect);
197 | }
198 |
199 | int WINAPI PDFAnnotation_GetString(IPDFAnnotation annotation, const PAnsiChar key, PChar str, int size) {
200 | LOG("PDFAnnotation_GetString\n")
201 | REF(annotation)
202 | return FPDFAnnot_GetStringValue((*annotation)->Handle, key, str, size);
203 | }
204 |
205 | int WINAPI PDFAnnotation_Remove(IPDFAnnotation annotation) {
206 | LOG("PDFAnnotation_Remove\n")
207 | REF(annotation)
208 | if (!(*annotation)->Handle) return 0;
209 | FPDFPage_CloseAnnot((*annotation)->Handle);
210 | (*annotation)->Handle = 0;
211 | return FPDFPage_RemoveAnnot((*(*annotation)->Page)->Handle, (*annotation)->Index);
212 | }
213 |
214 | // IPDFSearchText
215 |
216 | int WINAPI PDFSearchText_AddRef(IPDFSearchText search) {
217 | LOG("PDFSearchText_AddRef")
218 | REF(search)
219 | return ++(*search)->RefCount;
220 | }
221 |
222 | int WINAPI PDFSearchText_Free(IPDFSearchText search) {
223 | LOG("PDFSearchText_Free\n")
224 | REF(search)
225 | int i = --(*search)->RefCount;
226 | if (i == 0) {
227 | FPDFText_FindClose((*search)->Handle);
228 | PDFText_Free((*search)->Text);
229 | delete (*search)->Reference;
230 | }
231 | return i;
232 | }
233 |
234 | int WINAPI PDFSearchText_FindNext(IPDFSearchText search) {
235 | LOG("PDFSearchText_FindNext\n")
236 | REF(search)
237 | return FPDFText_FindNext((*search)->Handle);
238 | }
239 |
240 | int WINAPI PDFSearchText_FindPrev(IPDFSearchText search) {
241 | LOG("PDFSearchText_FindPrev\n")
242 | REF(search)
243 | return FPDFText_FindPrev((*search)->Handle);
244 | }
245 |
246 | int WINAPI PDFSearchText_GetPosition(IPDFSearchText search, int *start, int *length) {
247 | LOG("PDFSearchText_GetPosition\n")
248 | REF(search)
249 | *start = FPDFText_GetSchResultIndex((*search)->Handle);
250 | *length = FPDFText_GetSchCount((*search)->Handle);
251 | return 0;
252 | }
253 |
254 | // IPDFText
255 |
256 | int WINAPI PDFText_AddRef(IPDFText text) {
257 | LOG("PDFText_AddRef\n")
258 | REF(text)
259 | return ++(*text)->RefCount;
260 | }
261 |
262 | int WINAPI PDFText_Free(IPDFText text) {
263 | LOG("PDFText_Free\n")
264 | REF(text)
265 | int i = --(*text)->RefCount;
266 | if (i == 0) {
267 | FPDFText_ClosePage((*text)->Handle);
268 | PDFPage_Free((*text)->Page);
269 | LOG("delete text\n")
270 | delete (*text)->Reference;
271 | }
272 | return i;
273 | }
274 |
275 | int WINAPI PDFText_CharCount(IPDFText text) {
276 | REF(text)
277 | return FPDFText_CountChars((*text)->Handle);
278 | }
279 |
280 | int WINAPI PDFText_GetText(IPDFText text, int Start, int Length, PChar Text) {
281 | REF(text)
282 | return FPDFText_GetText((*text)->Handle, Start, Length, Text);
283 | }
284 |
285 | int WINAPI PDFText_CharIndexAtPos(IPDFText text, TPointsSize *size, int distance) {
286 | REF(text)
287 | return FPDFText_GetCharIndexAtPos((*text)->Handle, size->cx, size->cy, distance, distance);
288 | }
289 |
290 | int WINAPI PDFText_GetRectCount(IPDFText text, int Start, int Length) {
291 | REF(text)
292 | return FPDFText_CountRects((*text)->Handle, Start, Length);
293 | }
294 |
295 | int WINAPI PDFText_GetRect(IPDFText text, int Index, TRectD *rect) {
296 | REF(text)
297 | return FPDFText_GetRect((*text)->Handle, Index, &rect->Left, &rect->Top, &rect->Right, &rect->Bottom);
298 | }
299 |
300 | int WINAPI PDFText_Search(IPDFText text, const PChar what, unsigned long flags, int start_index, IPDFSearchText *search) {
301 | LOG("PDFText_Search\n")
302 | REF(text)
303 | if (IS_REF(search))
304 | PDFSearchText_Free(*search);
305 | FPDF_SCHHANDLE Handle = FPDFText_FindStart((*text)->Handle, (FPDF_WIDESTRING)what, flags, start_index);
306 | if (Handle) {
307 | TPDFSearchText* PDFSearchText = new TPDFSearchText();
308 | // Internal
309 | (*text)->RefCount++;
310 | PDFSearchText->Text = text;
311 | PDFSearchText->Handle = Handle;
312 | PDFSearchText->Reference = PDFSearchText;
313 | PDFSearchText->RefCount = 1;
314 | // IUnknown
315 | PDFSearchText->QueryInterface = QueryInterface;
316 | PDFSearchText->AddRef = PDFSearchText_AddRef;
317 | PDFSearchText->Release = PDFSearchText_Free;
318 | // IPDFSearchText
319 | PDFSearchText->FindNext = PDFSearchText_FindNext;
320 | PDFSearchText->FindPrev = PDFSearchText_FindPrev;
321 | PDFSearchText->GetPosition = PDFSearchText_GetPosition;
322 | // Result
323 | *search = &PDFSearchText->Reference;
324 | return 1;
325 | }
326 | return 0;
327 | }
328 |
329 | // IPDFBitmap
330 |
331 | int WINAPI PDFBitmap_AddRef(IPDFBitmap bitmap) {
332 | LOG("PDFBitmap_AddRef\n")
333 | REF(bitmap)
334 | return ++(*bitmap)->RefCount;
335 | }
336 |
337 | int WINAPI PDFBitmap_Free(IPDFBitmap bitmap) {
338 | LOG("PDFBitmap_Free\n")
339 | REF(bitmap)
340 | int i = --(*bitmap)->RefCount;
341 | if (i == 0) {
342 | FPDFBitmap_Destroy((*bitmap)->Handle);
343 | delete (*bitmap)->Reference;
344 | }
345 | return i;
346 | }
347 |
348 | int WINAPI PDFBitmap_Draw(IPDFBitmap bitmap, HDC dc, int x, int y) {
349 | LOG("PDFBitmap_Draw\n")
350 | REF(bitmap)
351 | if (!dc) return false;
352 | int w = FPDFBitmap_GetWidth((*bitmap)->Handle);
353 | int h = FPDFBitmap_GetHeight((*bitmap)->Handle);
354 | void* p = FPDFBitmap_GetBuffer((*bitmap)->Handle);
355 | BITMAPINFO bi;
356 | memset(&bi, 0, sizeof(bi));
357 | bi.bmiHeader.biSize = 40;
358 | bi.bmiHeader.biWidth = w;
359 | bi.bmiHeader.biHeight = -h;
360 | bi.bmiHeader.biPlanes = 1;
361 | bi.bmiHeader.biBitCount = 32;
362 | SetDIBitsToDevice(dc, x, y, w, h, 0, 0, 0, h, p, &bi, 0);
363 | return true;
364 | }
365 |
366 | int WINAPI PDFBitmap_GetInfo(IPDFBitmap bitmap, TPDFBitmapInfo* info) {
367 | LOG("PDFBitmap_GetInfo\n")
368 | REF(bitmap)
369 | if (!info) return false;
370 | info->Format = FPDFBitmap_GetFormat((*bitmap)->Handle);
371 | info->Width = FPDFBitmap_GetWidth((*bitmap)->Handle);
372 | info->Height = FPDFBitmap_GetHeight((*bitmap)->Handle);
373 | info->Stride = FPDFBitmap_GetStride((*bitmap)->Handle);
374 | info->Buffer = FPDFBitmap_GetBuffer((*bitmap)->Handle);
375 | return true;
376 | }
377 |
378 | // IPDFPage
379 |
380 | int WINAPI PDFPage_AddRef(IPDFPage page) {
381 | LOG("PDFPage_AddRef\n")
382 | REF(page)
383 | return ++(*page)->RefCount;
384 | }
385 |
386 | int WINAPI PDFPage_Free(IPDFPage page) {
387 | LOG("PDFPage_Free\n")
388 | REF(page)
389 | int i = --(*page)->RefCount;
390 | if (i == 0) {
391 | FPDF_ClosePage((*page)->Handle);
392 | PDF_Free((*page)->PDF);
393 | LOG("delete page\n")
394 | delete (*page)->Reference;
395 | }
396 | return i;
397 | }
398 |
399 | int WINAPI PDFPage_Render(IPDFPage page, HDC dc, TRect* rect, int rotation, int flags) {
400 | LOG("PDFPage_Render\n")
401 | REF(page)
402 | FPDF_RenderPage(dc, (*page)->Handle, rect->Left, rect->Top, rect->Right - rect->Left, rect->Bottom - rect->Top, rotation, flags);
403 | return 0;
404 | }
405 |
406 | int WINAPI PDFPage_GetAnnotationCount(IPDFPage page) {
407 | LOG("PDFPage_GetAnnotationCount\n")
408 | REF(page)
409 | return FPDFPage_GetAnnotCount((*page)->Handle);
410 | }
411 |
412 | int WINAPI PDFPage_GetAnnotation(IPDFPage page, int annotation_index, IPDFAnnotation *annotation) {
413 | LOG("PDFPage_GetAnnotation\n")
414 | REF(page)
415 | if (IS_REF(annotation))
416 | PDFAnnotation_Free(*annotation);
417 | FPDF_ANNOTATION Handle = FPDFPage_GetAnnot((*page)->Handle, annotation_index);
418 | if (Handle) {
419 | TPDFAnnotation *PDFAnnotation = new TPDFAnnotation();
420 | // Internal
421 | (*page)->RefCount++;
422 | PDFAnnotation->Page = page;
423 | PDFAnnotation->Index = annotation_index;
424 | PDFAnnotation->Handle = Handle;
425 | PDFAnnotation->Reference = PDFAnnotation;
426 | PDFAnnotation->RefCount = 1;
427 | // IUnknown
428 | PDFAnnotation->QueryInterface = QueryInterface;
429 | PDFAnnotation->AddRef = PDFAnnotation_AddRef;
430 | PDFAnnotation->Release = PDFAnnotation_Free;
431 | // IPDFAnnotation
432 | PDFAnnotation->GetSubtype = PDFAnnotation_GetSubtype;
433 | PDFAnnotation->GetRect = PDFAnnotation_GetRect;
434 | PDFAnnotation->SetRect = PDFAnnotation_SetRect;
435 | PDFAnnotation->GetString = PDFAnnotation_GetString;
436 | PDFAnnotation->Remove = PDFAnnotation_Remove;
437 | // Result
438 | *annotation = &PDFAnnotation->Reference;
439 | return 0;
440 | }
441 | return 1;
442 | }
443 |
444 | int WINAPI PDFPage_GetText(IPDFPage page, IPDFText *text) {
445 | LOG("PDFPage_GetText\n")
446 | REF(page)
447 | if (IS_REF(text))
448 | PDFText_Free(*text);
449 | FPDF_TEXTPAGE Handle = FPDFText_LoadPage((*page)->Handle);
450 | if (Handle) {
451 | TPDFText *PDFText = new TPDFText();
452 | // Internal
453 | (*page)->RefCount++;
454 | PDFText->Page = page;
455 | PDFText->Handle = Handle;
456 | PDFText->Reference = PDFText;
457 | PDFText->RefCount = 1;
458 | // IUnknown
459 | PDFText->QueryInterface = QueryInterface;
460 | PDFText->AddRef = PDFText_AddRef;
461 | PDFText->Release = PDFText_Free;
462 | // IPDFText
463 | PDFText->CharCount = PDFText_CharCount;
464 | PDFText->GetText = PDFText_GetText;
465 | PDFText->CharIndexAtPos = PDFText_CharIndexAtPos;
466 | PDFText->GetRectCount = PDFText_GetRectCount;
467 | PDFText->GetRect = PDFText_GetRect;
468 | PDFText->Search = PDFText_Search;
469 | // Result
470 | *text = &PDFText->Reference;
471 | return 0;
472 | }
473 | return 1;
474 | }
475 |
476 | void WINAPI PDFPage_DeviveToPage(IPDFPage page, TRect *rect, int x, int y, double *px, double *py) {
477 | REF(page)
478 | FPDF_DeviceToPage((*page)->Handle, rect->Left, rect->Top, rect->Right - rect->Left, rect->Bottom - rect->Top, 0, x, y, px, py);
479 | }
480 |
481 | void WINAPI PDFPage_PageToDevice(IPDFPage page, TRect *rect, double px, double py, int *x, int *y) {
482 | REF(page)
483 | FPDF_PageToDevice((*page)->Handle, rect->Left, rect->Top, rect->Right - rect->Left, rect->Bottom - rect->Top, 0, px, py, x, y);
484 | }
485 |
486 | int WINAPI PDFPage_GetRotation(IPDFPage page) {
487 | LOG("PDFPage_GetRotation\n")
488 | REF(page)
489 | return FPDFPage_GetRotation((*page)->Handle);
490 | }
491 |
492 | int WINAPI PDFPage_GetBitmap(IPDFPage page, TRect *pageRect, TRect *viewPort, int rotation, int flags, IPDFBitmap *bitmap) {
493 | LOG("PDFPage_GetBitmap\n")
494 | REF(page)
495 | if IS_REF(bitmap)
496 | PDFBitmap_Free(*bitmap);
497 | int width = viewPort->Right - viewPort->Left;
498 | int height = viewPort->Bottom - viewPort->Top;
499 | FPDF_BITMAP Handle = FPDFBitmap_Create(width, height, 0);
500 | if (!Handle) return false;
501 |
502 | FPDFBitmap_FillRect(Handle, 0, 0, width, height, 0xFFFFFFFF);
503 | int x = pageRect->Left - viewPort->Left;
504 | int y = pageRect->Top - viewPort->Top;
505 | int w = pageRect->Right - pageRect->Left;
506 | int h = pageRect->Bottom - pageRect->Top;
507 | FPDF_RenderPageBitmap(Handle, (*page)->Handle, x, y, w, h, rotation, flags);
508 |
509 | FPDF_DOCUMENT doc = (*(*page)->PDF)->Handle;
510 | FPDF_FORMFILLINFO info;
511 | memset(&info, 0, sizeof(info));
512 | info.version = 1;
513 | FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnvironment(doc, &info);
514 | FPDF_FFLDraw(form, Handle, (*page)->Handle, x, y, w, h, rotation, flags);
515 | FPDFDOC_ExitFormFillEnvironment(form);
516 |
517 | TPDFBitmap* PDFBitmap = new TPDFBitmap();
518 | // Internal
519 | PDFBitmap->Handle = Handle;
520 | PDFBitmap->Reference = PDFBitmap;
521 | PDFBitmap->RefCount = 1;
522 | // IUnknown
523 | PDFBitmap->QueryInterface = QueryInterface;
524 | PDFBitmap->AddRef = PDFBitmap_AddRef;
525 | PDFBitmap->Release = PDFBitmap_Free;
526 | // IPDFBitmap
527 | PDFBitmap->Draw = PDFBitmap_Draw;
528 | PDFBitmap->GetInfo = PDFBitmap_GetInfo;
529 | // Result
530 | *bitmap = &PDFBitmap->Reference;
531 | return true;
532 | }
533 |
534 | // IPDFium
535 |
536 | int __stdcall PDF_AddRef(IPDFium pdf) {
537 | LOG("PDF_AddRef\n")
538 | REF(pdf)
539 | return ++(*pdf)->RefCount;
540 | }
541 |
542 | int WINAPI PDF_Free(IPDFium pdf) {
543 | LOG("PDF_Free\n")
544 | REF(pdf)
545 | int i = --(*pdf)->RefCount;
546 | if (i == 0) {
547 | LOG("FPDF_CloseDocument\n")
548 | if ((*pdf)->Handle) FPDF_CloseDocument((*pdf)->Handle);
549 | LOG("delete pdf\n")
550 | delete (*pdf)->Reference;
551 | }
552 | return i;
553 | }
554 |
555 | int WINAPI PDF_GetVersion(IPDFium pdf) {
556 | LOG("PDF_GetVersion\n")
557 | REF(pdf)
558 | return (*pdf)->Version;
559 | }
560 |
561 | int WINAPI PDF_GetError(IPDFium pdf) {
562 | LOG("PDF_GetError\n")
563 | REF(pdf)
564 | return (int)FPDF_GetLastError();
565 | }
566 |
567 | int WINAPI PDF_CloseDocument(IPDFium pdf) {
568 | LOG("PDF_CloseDocument\n")
569 | REF(pdf)
570 | if ((*pdf)->Handle) FPDF_CloseDocument((*pdf)->Handle);
571 | (*pdf)->Handle = 0;
572 | return 0;
573 | }
574 |
575 | int WINAPI PDF_LoadFromFile(IPDFium pdf, PAnsiChar filename, PAnsiChar pwd) {
576 | LOG("PDF_LoadFromFile\n")
577 | REF(pdf)
578 | if ((*pdf)->Handle) FPDF_CloseDocument((*pdf)->Handle);
579 | (*pdf)->Handle = FPDF_LoadDocument(filename, pwd);
580 | return (*pdf)->Handle ? 0 : (int)FPDF_GetLastError();
581 | }
582 |
583 | int WINAPI PDF_LoadFromMemory(IPDFium pdf, void* data, int size, PAnsiChar pwd) {
584 | LOG("PDF_LoadFromMemory\n")
585 | REF(pdf)
586 | if ((*pdf)->Handle) FPDF_CloseDocument((*pdf)->Handle);
587 | (*pdf)->Handle = FPDF_LoadMemDocument(data, size, pwd);
588 | return (*pdf)->Handle ? 0 : (int)FPDF_GetLastError();
589 | }
590 |
591 | long WINAPI PDF_GetPermissions(IPDFium pdf) {
592 | REF(pdf)
593 | return FPDF_GetDocPermissions((*pdf)->Handle);
594 | }
595 |
596 | int WINAPI PDF_GetPageCount(IPDFium pdf) {
597 | LOG("PDF_GetPageCount\n")
598 | REF(pdf)
599 | return FPDF_GetPageCount((*pdf)->Handle);
600 | }
601 |
602 | int WINAPI PDF_GetPageSize(IPDFium pdf, int page_index, TPointsSizeF *size) {
603 | LOG("PDF_GetPageSize\n")
604 | REF(pdf)
605 | return FPDF_GetPageSizeByIndexF((*pdf)->Handle, page_index, (FS_SIZEF*)size);
606 | }
607 |
608 | int WINAPI PDF_GetPage(IPDFium pdf, int page_index, IPDFPage* page) {
609 | LOG("PDF_GetPage\n")
610 | REF(pdf)
611 | if (IS_REF(page))
612 | PDFPage_Free(*page);
613 | FPDF_PAGE Handle = FPDF_LoadPage((*pdf)->Handle, page_index);
614 | if (Handle) {
615 | TPDFPage *PDFPage = new TPDFPage();
616 | // Internal
617 | (*pdf)->RefCount++;
618 | PDFPage->PDF = pdf;
619 | PDFPage->Handle = Handle;
620 | PDFPage->Reference = PDFPage;
621 | PDFPage->RefCount = 1;
622 | // IUnknown
623 | PDFPage->QueryInterface = QueryInterface;
624 | PDFPage->AddRef = PDFPage_AddRef;
625 | PDFPage->Release = PDFPage_Free;
626 | // IPDFPage
627 | PDFPage->Render = PDFPage_Render;
628 | PDFPage->GetAnnotationCount = PDFPage_GetAnnotationCount;
629 | PDFPage->GetAnnotation = PDFPage_GetAnnotation;
630 | PDFPage->GetText = PDFPage_GetText;
631 | PDFPage->DeviveToPage = PDFPage_DeviveToPage;
632 | PDFPage->PageToDevice = PDFPage_PageToDevice;
633 | PDFPage->GetRotation = PDFPage_GetRotation;
634 | PDFPage->GetBitmap = PDFPage_GetBitmap;
635 | // Result
636 | *page = &PDFPage->Reference;
637 | return 0;
638 | }
639 | return 1;
640 | }
641 |
642 | typedef struct {
643 | FPDF_FILEWRITE FW;
644 | TWriteProc writeProc;
645 | IStream Stream;
646 | } TWriteStream, *PWriteStream;
647 |
648 | int WriteStream(struct FPDF_FILEWRITE_* pThis, const void* pData, unsigned long size) {
649 | ULONG pcbWritten;
650 | if ((*((PWriteStream)pThis)->Stream)->Write(((PWriteStream)pThis)->Stream, pData, size, &pcbWritten) == 0)
651 | return pcbWritten;
652 | return 0;
653 | }
654 |
655 | int WINAPI PDF_SaveToStream(IPDFium pdf, IStream stream) {
656 | LOG("PDF_SaveToStream\n")
657 | REF(pdf)
658 | TWriteStream WS;
659 | WS.FW.version = 1;
660 | WS.FW.WriteBlock = WriteStream;
661 | WS.Stream = stream;
662 | int ret = FPDF_SaveAsCopy((*pdf)->Handle, &WS.FW, 0);
663 | (*stream)->Release(stream);
664 | return ret;
665 | }
666 |
667 | typedef struct {
668 | FPDF_FILEWRITE FW;
669 | TWriteProc writeProc;
670 | void* userData;
671 | } TFileWrite, *PFileWrite;
672 |
673 | int WriteBlock(struct FPDF_FILEWRITE_* pThis, const void* pData, unsigned long size) {
674 | return ((PFileWrite)pThis)->writeProc(pData, size, ((PFileWrite)pThis)->userData);
675 | }
676 |
677 | int WINAPI PDF_SaveToProc(IPDFium pdf, TWriteProc writeProc, void *userData) {
678 | LOG("PDF_SaveToProc\n")
679 | REF(pdf)
680 | TFileWrite FW;
681 | FW.FW.version = 1;
682 | FW.FW.WriteBlock = WriteBlock;
683 | FW.writeProc = writeProc;
684 | FW.userData = userData;
685 | return FPDF_SaveAsCopy((*pdf)->Handle, &FW.FW, 0);
686 | }
687 |
688 | int WINAPI PDF_GetFirstBookmark(IPDFium pdf, IPDFBookmark *bookmark) {
689 | LOG("PDF_GetFirstBookmark\n")
690 | return InternalGetBookmark(pdf, NULL, bookmark);
691 | }
692 |
693 | int WINAPI PDF_GetMetaText(IPDFium pdf, const PAnsiChar name, PChar value, int valueSize) {
694 | LOG("PDF_GetMetaText\n")
695 | REF(pdf)
696 | return FPDF_GetMetaText((*pdf)->Handle, name, value, valueSize);
697 | }
698 |
699 | int initialized = 0;
700 |
701 | int WINAPI PDF_Create(int RequestedVersion, IPDFium* pdf) {
702 | LOG("PDF_Create\n")
703 | if (RequestedVersion != PDFIUM_VERSION) return -1;
704 | if (!initialized) {
705 | LOG("Initialization\n")
706 | initialized = 1;
707 | FPDF_InitLibrary();
708 | }
709 | if (IS_REF(pdf))
710 | PDF_Free(*pdf);
711 | TPDFium *PDF = new TPDFium();
712 | // Internal
713 | PDF->Version = PDFIUM_VERSION;
714 | PDF->Reference = PDF;
715 | PDF->RefCount = 1;
716 | PDF->Handle = 0;
717 | // IUnknown
718 | PDF->QueryInterface = QueryInterface;
719 | PDF->AddRef = PDF_AddRef;
720 | PDF->Release = PDF_Free;
721 | // IPDFInterface
722 | PDF->GetVersion = PDF_GetVersion;
723 | PDF->GetError = PDF_GetError;
724 | PDF->CloseDocument = PDF_CloseDocument;
725 | PDF->LoadFromFile = PDF_LoadFromFile;
726 | PDF->LoadFromMemory = PDF_LoadFromMemory;
727 | PDF->GetPermissions = PDF_GetPermissions;
728 | PDF->GetPageCount = PDF_GetPageCount;
729 | PDF->GetPageSize = PDF_GetPageSize;
730 | PDF->GetPage = PDF_GetPage;
731 | PDF->SaveToStream = PDF_SaveToStream;
732 | PDF->SaveToProc = PDF_SaveToProc;
733 | PDF->GetMetaText = PDF_GetMetaText;
734 | // Result
735 | *pdf = &PDF->Reference;
736 | return 0;
737 | }
738 |
--------------------------------------------------------------------------------
/libPDFium/libpdfium/libpdfium.def:
--------------------------------------------------------------------------------
1 | LIBRARY libpdfium.dll
2 |
3 | EXPORTS
4 | PDF_FreeHandle
5 | PDF_Create
6 | PDF_Free
7 | PDF_GetVersion
8 | PDF_GetError
9 | PDF_LoadFromFile
10 | PDF_LoadFromMemory
11 | PDF_GetPermissions
12 | PDF_GetPageCount
13 | PDF_GetPageSize
14 | PDF_GetPage
15 | PDF_SaveToStream
16 | PDF_SaveToProc
17 | PDFPage_Free
18 | PDFPage_Render
19 | PDFPage_GetAnnotationCount
20 | PDFPage_GetAnnotation
21 | PDFPage_GetText
22 | PDFPage_DeviveToPage
23 | PDFPage_PageToDevice
24 | PDFPage_GetRotation
25 | PDFText_Free
26 | PDFText_CharCount
27 | PDFText_GetText
28 | PDFText_CharIndexAtPos
29 | PDFText_GetRectCount
30 | PDFText_GetRect
31 | PDFAnnotation_Free
32 | PDFAnnotation_GetSubtype
33 | PDFAnnotation_GetRect
34 | PDFAnnotation_SetRect
35 | PDFAnnotation_GetString
36 | PDFAnnotation_Remove
--------------------------------------------------------------------------------
/libPDFium/libpdfium/libpdfium.h:
--------------------------------------------------------------------------------
1 | // libdfium v1.0.2 (c)2018-2023 Execute SARL
2 |
3 | #ifndef PUBLIC_FPDFVIEW_H_
4 | typedef void *FPDF_DOCUMENT;
5 | typedef void *FPDF_PAGE;
6 | typedef void *FPDF_TEXTPAGE;
7 | typedef void *FPDF_ANNOTATION;
8 | #endif
9 | #ifndef WINAPI
10 | typedef long ULONG;
11 | typedef int HDC;
12 | #endif
13 |
14 | #define PDFIUM_VERSION 4
15 |
16 | typedef int (__stdcall *TWriteProc)(const void *data, int size, void *UserData);
17 |
18 | typedef char *PAnsiChar;
19 | typedef unsigned short *PChar;
20 |
21 | typedef struct TStream TStream;
22 | typedef TStream *PStream;
23 | typedef TStream **IStream;
24 |
25 | typedef struct TPDFium TPDFium;
26 | typedef TPDFium *PPDFium;
27 | typedef TPDFium **IPDFium;
28 |
29 | typedef struct TPDFPage TPDFPage;
30 | typedef TPDFPage *PPDFPage;
31 | typedef TPDFPage **IPDFPage;
32 |
33 | typedef struct TPDFText TPDFText;
34 | typedef TPDFText *PPDFText;
35 | typedef TPDFText **IPDFText;
36 |
37 | typedef struct TPDFSearchText TPDFSearchText;
38 | typedef TPDFSearchText *PPDFSearchText;
39 | typedef TPDFSearchText **IPDFSearchText;
40 |
41 | typedef struct TPDFAnnotation TPDFAnnotation;
42 | typedef TPDFAnnotation *PPDFAnnotation;
43 | typedef TPDFAnnotation **IPDFAnnotation;
44 |
45 | typedef struct TPDFBookmark TPDFBookmark;
46 | typedef TPDFBookmark *PPDFBookmark;
47 | typedef TPDFBookmark **IPDFBookmark;
48 |
49 | typedef struct TPDFBitmap TPDFBitmap;
50 | typedef TPDFBitmap *PPDFBitmap;
51 | typedef TPDFBitmap **IPDFBitmap;
52 |
53 | typedef struct {
54 | int Format;
55 | int Width;
56 | int Height;
57 | int Stride;
58 | void* Buffer;
59 | } TPDFBitmapInfo;
60 |
61 | typedef struct {
62 | int Left;
63 | int Top;
64 | int Right;
65 | int Bottom;
66 | } TRect;
67 |
68 | typedef struct {
69 | float Left;
70 | float Top;
71 | float Right;
72 | float Bottom;
73 | } TRectF;
74 |
75 | typedef struct {
76 | double Left;
77 | double Top;
78 | double Right;
79 | double Bottom;
80 | } TRectD;
81 |
82 | typedef struct {
83 | double cx;
84 | double cy;
85 | } TPointsSize;
86 |
87 | typedef struct {
88 | float cx;
89 | float cy;
90 | } TPointsSizeF;
91 |
92 | struct TStream {
93 | // IUnknown
94 | int(__stdcall *QueryInterface)(void *intf, void *rrid, void*);
95 | int(__stdcall *AddRef)(IStream stream);
96 | int(__stdcall *Release)(IStream stream);
97 | // ISequentialStream
98 | int(__stdcall *Read)(IStream stream, const void *pv, ULONG cb, ULONG *pcbRead);
99 | int(__stdcall *Write)(IStream stream, const void *pv, ULONG cb, ULONG *pcbWritten);
100 | };
101 |
102 | struct TPDFBitmap {
103 | // IUnknwon
104 | int(__stdcall *QueryInterface)(void *intf, void *rrid, void*);
105 | int(__stdcall *AddRef)(IPDFBitmap bitmap);
106 | int(__stdcall *Release)(IPDFBitmap bitmap);
107 | // IDPFBitmap
108 | int(__stdcall *Draw)(IPDFBitmap bitmap, HDC dc, int x, int y);
109 | int(__stdcall *GetInfo)(IPDFBitmap bitmap, TPDFBitmapInfo* info);
110 | // Internal
111 | PPDFBitmap Reference;
112 | int RefCount;
113 | FPDF_BITMAP Handle;
114 | };
115 |
116 | struct TPDFBookmark {
117 | // IUnknwon
118 | int(__stdcall *QueryInterface)(void *intf, void *rrid, void*);
119 | int(__stdcall *AddRef)(IPDFBookmark bookmark);
120 | int(__stdcall *Release)(IPDFBookmark bookmark);
121 | // IPDFBookmark
122 | int(__stdcall *GetPageNumber)(IPDFBookmark bookmark);
123 | int(__stdcall *GetTitle)(IPDFBookmark bookmark, PChar title, unsigned long size);
124 | int(__stdcall *GetFirstChild)(IPDFBookmark bookmark, IPDFBookmark *child);
125 | int(__stdcall *GetNext)(IPDFBookmark bookmark);
126 | // Internal
127 | PPDFBookmark Reference;
128 | int RefCount;
129 | IPDFium PDF;
130 | FPDF_BOOKMARK Handle;
131 | };
132 |
133 | struct TPDFAnnotation {
134 | // IUnknown
135 | int(__stdcall *QueryInterface)(void *intf, void *rrid, void*);
136 | int(__stdcall *AddRef)(IPDFAnnotation annotation);
137 | int(__stdcall *Release)(IPDFAnnotation annotation);
138 | // IPDFAnnotation
139 | int(__stdcall *GetSubtype)(IPDFAnnotation annotation);
140 | int(__stdcall *GetRect)(IPDFAnnotation annotation, TRectF *rect);
141 | int(__stdcall *SetRect)(IPDFAnnotation annotation, TRectF *rect);
142 | int(__stdcall *GetString)(IPDFAnnotation annotation, const PAnsiChar key, PChar str, int size);
143 | int(__stdcall *Remove)(IPDFAnnotation annotation);
144 | // Internal
145 | PPDFAnnotation Reference;
146 | int RefCount;
147 | IPDFPage Page;
148 | int Index;
149 | FPDF_ANNOTATION Handle;
150 | };
151 |
152 | struct TPDFSearchText {
153 | // IUnknown
154 | int(__stdcall *QueryInterface)(void *intf, void *rrid, void *out);
155 | int(__stdcall *AddRef)(IPDFSearchText search);
156 | int(__stdcall *Release)(IPDFSearchText search);
157 | // IPDFSearchText
158 | int(__stdcall *FindNext)(IPDFSearchText search);
159 | int(__stdcall *FindPrev)(IPDFSearchText search);
160 | int(__stdcall *GetPosition)(IPDFSearchText search, int *Start, int *Length);
161 | // Internal
162 | PPDFSearchText Reference;
163 | int RefCount;
164 | IPDFText Text;
165 | FPDF_SCHHANDLE Handle;
166 | };
167 |
168 | struct TPDFText {
169 | // IUnknown
170 | int(__stdcall *QueryInterface)(void *intf, void *rrid, void *out);
171 | int(__stdcall *AddRef)(IPDFText text);
172 | int(__stdcall *Release)(IPDFText text);
173 | // IPDFText
174 | int(__stdcall *CharCount)(IPDFText text);
175 | int(__stdcall *GetText)(IPDFText text, int Start, int Length, PChar Text);
176 | int(__stdcall *CharIndexAtPos)(IPDFText text, TPointsSize *size, int distance);
177 | int(__stdcall *GetRectCount)(IPDFText text, int Start, int Length);
178 | int(__stdcall *GetRect)(IPDFText text, int Index, TRectD *rect);
179 | int(__stdcall *Search)(IPDFText text, const PChar what, unsigned long flags, int start_index, IPDFSearchText *search);
180 | // Internal
181 | PPDFText Reference;
182 | int RefCount;
183 | IPDFPage Page;
184 | FPDF_TEXTPAGE Handle;
185 | };
186 |
187 | struct TPDFPage {
188 | // IUnknown
189 | int(__stdcall *QueryInterface)(void *intf, void *rrid, void *out);
190 | int(__stdcall *AddRef)(IPDFPage page);
191 | int(__stdcall *Release)(IPDFPage page);
192 | // IPDFPage
193 | int(__stdcall *Render)(IPDFPage page, HDC dc, TRect *rect, int rotation, int flags);
194 | int(__stdcall *GetAnnotationCount)(IPDFPage page);
195 | int(__stdcall *GetAnnotation)(IPDFPage page, int annotation_index, IPDFAnnotation *annotation);
196 | int(__stdcall *GetText)(IPDFPage page, IPDFText *text);
197 | void(__stdcall *DeviveToPage)(IPDFPage page, TRect *rect, int x, int y, double *px, double *py);
198 | void(__stdcall *PageToDevice)(IPDFPage page, TRect *rect, double px, double py, int *x, int *y);
199 | int(__stdcall *GetRotation)(IPDFPage page);
200 | int(__stdcall *GetBitmap)(IPDFPage page, TRect *pageRect, TRect *viewPort, int rotation, int flags, IPDFBitmap* bitmap);
201 | // Internal
202 | PPDFPage Reference;
203 | int RefCount;
204 | IPDFium PDF;
205 | FPDF_PAGE Handle;
206 | };
207 |
208 | struct TPDFium {
209 | // IUnknown
210 | int(__stdcall *QueryInterface)(void *intf, void *rrid, void *out);
211 | int(__stdcall *AddRef)(IPDFium pdf);
212 | int(__stdcall *Release)(IPDFium pdf);
213 | // IPDFium
214 | int(__stdcall *GetVersion)(IPDFium pdf);
215 | int(__stdcall *GetError)(IPDFium pdf);
216 | int(__stdcall *CloseDocument)(IPDFium pdf);
217 | int(__stdcall *LoadFromFile)(IPDFium pdf, PAnsiChar filename, PAnsiChar pwd);
218 | int(__stdcall *LoadFromMemory)(IPDFium pdf, void *data, int size, PAnsiChar pwd);
219 | long(__stdcall *GetPermissions)(IPDFium pdf);
220 | int(__stdcall *GetPageCount)(IPDFium pdf);
221 | int(__stdcall *GetPageSize)(IPDFium pdf, int page_index, TPointsSizeF *size);
222 | int(__stdcall *GetPage)(IPDFium pdf, int page_index, IPDFPage *page);
223 | int(__stdcall *SaveToStream)(IPDFium pdf, IStream stream);
224 | int(__stdcall *SaveToProc)(IPDFium pdf, TWriteProc writeProc, void *userData);
225 | int(__stdcall *GetFirstBookmark)(IPDFium pdf, IPDFBookmark *bookmark);
226 | int(__stdcall *GetMetaText)(IPDFium pdf, const PAnsiChar name, PChar value, int valueSize);
227 | // Internal
228 | PPDFium Reference;
229 | int RefCount;
230 | int PageCount;
231 | int Version;
232 | FPDF_DOCUMENT Handle;
233 | };
234 |
235 | int __stdcall PDF_FreeHandle(void *handle);
236 |
237 | int __stdcall PDF_Create(int RequiredVersion, IPDFium *pdf);
238 | int __stdcall PDF_Free(IPDFium pdf);
239 | int __stdcall PDF_GetVersion(IPDFium pdf);
240 | int __stdcall PDF_GetError(IPDFium pdf);
241 | int __stdcall PDF_CloseDocument(IPDFium pdf);
242 | int __stdcall PDF_LoadFromFile(IPDFium pdf, char *filename, char *pwd);
243 | int __stdcall PDF_LoadFromMemory(IPDFium pdf, void *data, int size, char *pwd);
244 | long __stdcall PDF_GetPermissions(IPDFium pdf);
245 | int __stdcall PDF_GetPageCount(IPDFium pdf);
246 | int __stdcall PDF_GetPageSize(IPDFium pdf, int page_index, double *width, double *height);
247 | int __stdcall PDF_GetPage(IPDFium pdf, int page_index, IPDFPage *page);
248 | int __stdcall PDF_SaveToStream(IPDFium pdf, IStream stream);
249 | int __stdcall PDF_SaveToProc(IPDFium pdf, TWriteProc writeProc, void *userData);
250 |
251 | int __stdcall PDFPage_Free(IPDFPage page);
252 | int __stdcall PDFPage_Render(IPDFPage page, HDC dc, TRect *rect, int rotation, int flags);
253 | int __stdcall PDFPage_Paint(IPDFPage page, HDC dc, TRect *rect, int annotation);
254 | int __stdcall PDFPage_GetAnnotationCount(IPDFPage page);
255 | int __stdcall PDFPage_GetAnnotation(IPDFPage page, int annotation_index, IPDFAnnotation *annotation);
256 | int __stdcall PDFPage_GetText(IPDFPage page, IPDFText *text);
257 | void __stdcall PDFPage_DeviveToPage(IPDFPage page, TRect *rect, int x, int y, double *px, double *py);
258 | void __stdcall PDFPage_PageToDevice(IPDFPage page, TRect *rect, double px, double py, int *x, int *y);
259 | int __stdcall PDFPage_GetRotation(IPDFPage page);
260 |
261 | int __stdcall PDFText_Free(IPDFText text);
262 | int __stdcall PDFText_CharCount(IPDFText text);
263 | int __stdcall PDFText_GetText(IPDFText text, int Start, int Length, unsigned short *Text);
264 | int __stdcall PDFText_CharIndexAtPos(IPDFText text, TPointsSize *size, int distance);
265 | int __stdcall PDFText_GetRectCount(IPDFText text, int Start, int Length);
266 | int __stdcall PDFText_GetRect(IPDFText text, int Index, TRectD *rect);
267 |
268 | int __stdcall PDFAnnotation_Free(IPDFAnnotation annotation);
269 | int __stdcall PDFAnnotation_GetSubtype(IPDFAnnotation annotation);
270 | int __stdcall PDFAnnotation_GetRect(IPDFAnnotation annotation, TRectF *rect);
271 | int __stdcall PDFAnnotation_SetRect(IPDFAnnotation annotation, TRectF *rect);
272 | int __stdcall PDFAnnotation_GetString(IPDFAnnotation annotation, char *key, char *str, int size);
273 |
--------------------------------------------------------------------------------
/libPDFium/libpdfium/libpdfium.rc:
--------------------------------------------------------------------------------
1 | 1 VERSIONINFO
2 | FILEVERSION 2023,3,26,2269
3 | PRODUCTVERSION 1,0,3,0
4 | FILETYPE 1 {
5 | BLOCK "StringFileInfo"
6 | {
7 | BLOCK "040C04E4"
8 | {
9 | VALUE "CompanyName", "Execute SARL\0"
10 | VALUE "FileDescription", "libPDFium a COM wrapper for Google's PDFium\0"
11 | VALUE "FileVersion", "2023.3.26.2269\0"
12 | VALUE "LegalCopyright", "(c)2018-2023 Execute SARL. All Rights Reserved\0"
13 | VALUE "OriginalFilename", "libPDFium.dll\0"
14 | VALUE "ProductName", "libPDFium\0"
15 | VALUE "ProductVersion", "1.0.3.0\0"
16 | }
17 | }
18 | BLOCK "VarFileInfo"
19 | {
20 | VALUE "Translation", 0x40C, 0x04E4
21 | }
22 | }
--------------------------------------------------------------------------------
/libPDFium/out/args.gn:
--------------------------------------------------------------------------------
1 | # Build arguments go here.
2 | # See "gn args --list" for available build arguments.
3 |
4 | is_official_build = true
5 | chrome_pgo_phase=0
6 | is_debug = false
7 | symbol_level = 0
8 |
9 | # is_official_build = false
10 | # is_debug = true
11 |
12 | pdf_is_standalone = true
13 | pdf_enable_xfa = false
14 | pdf_enable_v8 = false
15 | is_component_build = false
16 |
17 | # default x64
18 | target_cpu = "x86"
--------------------------------------------------------------------------------
/libPDFium/readme.md:
--------------------------------------------------------------------------------
1 | # libPDFium (c)2018-2023 Execute SARL
2 |
3 | A PDFium Library designed for Delphi, by a Delphi developper.
4 |
5 | it's a x86/x64 Windows library that can be used by any langage afterall
6 |
7 | to get a IPDFium object, just call
8 | ```
9 | IPDFium pdf = 0;
10 | PDF_Create(1, &pdf)
11 | ```
12 | all the COM methods are exposed as a raw C API, so you can call
13 | ```
14 | (*pdf)->LoadFromFile("file.pdf", NULL);
15 | (*pdf)->Release();
16 | ```
17 | or
18 | ```
19 | PDF_LoadFromFile(pdf, "file.pdf", NULL);
20 | PDF_Free(pdf);
21 | ```
22 |
23 | I'm not a C developper, if you need a libpdfium.lib, sorry you'll have to do it yourself, or switch to Delphi and use Execute.libPDFium.pas :)
24 |
25 | I know, libpdfium.h exposes the internal members of my objects, but it's not my purpose to use this library from a C project, only from a Delphi one, so I don't care.
26 |
27 | I've found how to install rc.exe so I can compile libpdfium.rc !
28 | ````
29 | third_party/depot_tools/download_from_google_storage.bat -s build/toolchain/win/rc/win/rc.exe.sha1 --bucket chromium-browser-clang/rc
30 | ````
31 |
32 | ## Requirements to recompile libPDFium
33 | install [depot_tools](https://www.chromium.org/developers/how-tos/depottools)
34 | ````
35 | set path=%path%;
36 | set DEPOT_TOOLS_WIN_TOOLCHAIN=0
37 | set GCLIENT_PY3=0
38 | ````
39 | download PDFium source code
40 | ````
41 | md git
42 | cd git
43 | gclient config --unmanaged https://pdfium.googlesource.com/pdfium.git
44 | gclient sync
45 | ````
46 | install libPDFium
47 | 1. copy libpdfium/* files to pdfium/libpdfium/*
48 | 2. edit Google's pdfium/BUILD.gn to add libpdfium
49 |