1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
//! Defines the [PdfPageText] struct, exposing functionality related to the
//! collection of Unicode characters visible in a single `PdfPage`.
use crate::bindgen::{FPDF_TEXTPAGE, FPDF_WCHAR};
use crate::bindings::PdfiumLibraryBindings;
use crate::page::{PdfPage, PdfRect};
use crate::page_annotation::PdfPageAnnotation;
use crate::page_annotation::PdfPageAnnotationCommon;
use crate::page_object::PdfPageObjectCommon;
use crate::page_object_private::internal::PdfPageObjectPrivate;
use crate::page_object_text::PdfPageTextObject;
use crate::page_text_chars::PdfPageTextChars;
use crate::page_text_segments::PdfPageTextSegments;
use crate::prelude::PdfiumError;
use crate::utils::mem::{create_byte_buffer, create_sized_buffer};
use crate::utils::utf16le::get_string_from_pdfium_utf16le_bytes;
use bytemuck::cast_slice;
use std::fmt::{Display, Formatter};
use std::ptr::null_mut;
/// The collection of Unicode characters visible in a single [PdfPage].
///
/// Use the [PdfPageText::all()] function to easily return all characters in the containing
/// [PdfPage] in the order in which they are defined in the PDF file.
///
/// In complex custom layouts, the order in which characters are defined in the document
/// and the order in which they appear visually during rendering (and thus the order in
/// which they are read by a user) may not necessarily match.
///
/// [PdfPageText] implements both the [ToString] and the [Display] traits.
pub struct PdfPageText<'a> {
handle: FPDF_TEXTPAGE,
page: &'a PdfPage<'a>,
bindings: &'a dyn PdfiumLibraryBindings,
}
impl<'a> PdfPageText<'a> {
pub(crate) fn from_pdfium(
handle: FPDF_TEXTPAGE,
page: &'a PdfPage<'a>,
bindings: &'a dyn PdfiumLibraryBindings,
) -> Self {
PdfPageText {
handle,
page,
bindings,
}
}
/// Returns the internal `FPDF_TEXTPAGE` handle for this [PdfPageText].
#[inline]
pub(crate) fn handle(&self) -> &FPDF_TEXTPAGE {
&self.handle
}
/// Returns the [PdfiumLibraryBindings] used by this [PdfPageText].
#[inline]
pub fn bindings(&self) -> &'a dyn PdfiumLibraryBindings {
self.bindings
}
/// Returns the total number of characters in all text segments in the containing [PdfPage].
///
/// The character count includes whitespace and newlines, and so may differ slightly
/// from the result of calling `PdfPageText::all().len()`.
#[inline]
pub fn len(&self) -> i32 {
self.bindings.FPDFText_CountChars(self.handle)
}
/// Returns `true` if there are no characters in any text box collection in the containing [PdfPage].
#[inline]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
/// Returns a collection of all the `PdfPageTextSegment` text segments in the containing [PdfPage].
#[inline]
pub fn segments(&self) -> PdfPageTextSegments {
PdfPageTextSegments::new(self, self.len(), self.bindings)
}
/// Returns a collection of all the `PdfPageTextChar` characters in the containing [PdfPage].
#[inline]
pub fn chars(&self) -> PdfPageTextChars {
PdfPageTextChars::new(self, 0, self.len(), self.bindings)
}
/// Returns a collection of all the `PdfPageTextChar` characters in the given [PdfPageTextObject].
///
/// The return result will be empty if the given [PdfPageTextObject] is not attached to the
/// containing [PdfPage].
#[inline]
pub fn chars_for_object(
&self,
object: &PdfPageTextObject,
) -> Result<PdfPageTextChars, PdfiumError> {
self.chars_inside_rect(object.bounds()?)
.map_err(|_| PdfiumError::NoCharsInPageObject)
}
/// Returns a collection of all the `PdfPageTextChar` characters in the given [PdfPageAnnotation].
///
/// The return result will be empty if the given [PdfPageAnnotation] is not attached to the
/// containing [PdfPage].
#[inline]
pub fn chars_for_annotation(
&self,
annotation: &PdfPageAnnotation,
) -> Result<PdfPageTextChars, PdfiumError> {
self.chars_inside_rect(annotation.bounds()?)
.map_err(|_| PdfiumError::NoCharsInAnnotation)
}
/// Returns a collection of all the `PdfPageTextChar` characters that lie within the bounds of
/// the given [PdfRect] in the containing [PdfPage].
pub fn chars_inside_rect(&self, rect: PdfRect) -> Result<PdfPageTextChars, PdfiumError> {
let tolerance_x = rect.width() / 2.0;
let tolerance_y = rect.height() / 2.0;
let center_height = rect.bottom + tolerance_y;
let chars = self.chars();
match (
chars.get_char_near_point(rect.left, tolerance_x, center_height, tolerance_y),
chars.get_char_near_point(rect.right, tolerance_x, center_height, tolerance_y),
) {
(Some(start), Some(end)) => Ok(PdfPageTextChars::new(
self,
start.index() as i32,
(end.index() - start.index() + 1) as i32,
self.bindings,
)),
_ => Err(PdfiumError::NoCharsInRect),
}
}
/// Returns all characters that lie within the containing [PdfPage], in the order in which
/// they are defined in the document, concatenated into a single string.
///
/// In complex custom layouts, the order in which characters are defined in the document
/// and the order in which they appear visually during rendering (and thus the order in
/// which they are read by a user) may not necessarily match.
pub fn all(&self) -> String {
self.inside_rect(self.page.page_size())
}
/// Returns all characters that lie within the bounds of the given [PdfRect] in the
/// containing [PdfPage], in the order in which they are defined in the document,
/// concatenated into a single string.
///
/// In complex custom layouts, the order in which characters are defined in the document
/// and the order in which they appear visually during rendering (and thus the order in
/// which they are read by a user) may not necessarily match.
pub fn inside_rect(&self, rect: PdfRect) -> String {
// Retrieving the bounded text from Pdfium is a two-step operation. First, we call
// FPDFText_GetBoundedText() with a null buffer; this will retrieve the length of
// the bounded text in _characters_ (not _bytes_!). If the length is zero, then there is
// no text within the given rectangle's boundaries.
// If the length is non-zero, then we reserve a buffer (sized in words rather than bytes,
// to allow for two bytes per character) and call FPDFText_GetBoundedText() again with a
// pointer to the buffer; this will write the bounded text to the buffer in UTF16-LE format.
let left = rect.left.value as f64;
let top = rect.top.value as f64;
let right = rect.right.value as f64;
let bottom = rect.bottom.value as f64;
let chars_count = self.bindings.FPDFText_GetBoundedText(
self.handle,
left,
top,
right,
bottom,
null_mut(),
0,
);
if chars_count == 0 {
// No text lies within the given rectangle.
return String::new();
}
let mut buffer = create_sized_buffer(chars_count as usize);
let result = self.bindings.FPDFText_GetBoundedText(
self.handle,
left,
top,
right,
bottom,
buffer.as_mut_ptr(),
chars_count,
);
assert_eq!(result, chars_count);
get_string_from_pdfium_utf16le_bytes(cast_slice(buffer.as_slice()).to_vec())
.unwrap_or_default()
}
/// Returns all characters assigned to the given [PdfPageTextObject] in this [PdfPageText] object,
/// concatenated into a single string.
pub fn for_object(&self, object: &PdfPageTextObject) -> String {
// Retrieving the string value from Pdfium is a two-step operation. First, we call
// FPDFTextObj_GetText() with a null buffer; this will retrieve the length of
// the text in bytes, assuming the page object exists. If the length is zero,
// then there is no text.
// If the length is non-zero, then we reserve a byte buffer of the given
// length and call FPDFTextObj_GetText() again with a pointer to the buffer;
// this will write the text for the page object into the buffer.
let buffer_length = self.bindings.FPDFTextObj_GetText(
*object.get_object_handle(),
self.handle,
null_mut(),
0,
);
if buffer_length == 0 {
// There is no text.
return String::new();
}
let mut buffer = create_byte_buffer(buffer_length as usize);
let result = self.bindings.FPDFTextObj_GetText(
*object.get_object_handle(),
self.handle,
buffer.as_mut_ptr() as *mut FPDF_WCHAR,
buffer_length,
);
assert_eq!(result, buffer_length);
get_string_from_pdfium_utf16le_bytes(buffer).unwrap_or_default()
}
/// Returns all characters that lie within the bounds of the given [PdfPageAnnotation] in the
/// containing [PdfPage], in the order in which they are defined in the document,
/// concatenated into a single string.
///
/// In complex custom layouts, the order in which characters are defined in the document
/// and the order in which they appear visually during rendering (and thus the order in
/// which they are read by a user) may not necessarily match.
#[inline]
pub fn for_annotation(&self, annotation: &PdfPageAnnotation) -> Result<String, PdfiumError> {
let bounds = annotation.bounds()?;
Ok(self.inside_rect(bounds))
}
}
impl<'a> Display for PdfPageText<'a> {
#[inline]
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.write_str(self.all().as_str())
}
}
impl<'a> Drop for PdfPageText<'a> {
/// Closes the [PdfPageText] collection, releasing held memory.
#[inline]
fn drop(&mut self) {
self.bindings.FPDFText_ClosePage(self.handle);
}
}