1use std::path::Path;
2use std::ptr;
3
4use crate::document_delegate::PdfDocumentDelegateHandle;
5use crate::error::{PdfKitError, Result};
6use crate::ffi;
7use crate::handle::ObjectHandle;
8use crate::outline::PdfOutline;
9use crate::page::PdfPage;
10use crate::selection::PdfSelection;
11use crate::types::{PdfDocumentAttributes, PdfDocumentInfo, PdfDocumentWriteOptions, PdfPoint};
12use crate::util::{c_string, parse_json, path_to_c_string, required_handle, take_string};
13
14#[derive(Debug, Clone)]
15pub struct PdfDocument {
16 handle: ObjectHandle,
17}
18
19impl PdfDocument {
20 pub(crate) fn from_handle(handle: ObjectHandle) -> Self {
21 Self { handle }
22 }
23
24 pub fn new() -> Result<Self> {
25 let mut out_document = ptr::null_mut();
26 let mut out_error = ptr::null_mut();
27 let status = unsafe { ffi::pdf_document_new(&mut out_document, &mut out_error) };
28 crate::util::status_result(status, out_error)?;
29 Ok(Self::from_handle(required_handle(
30 out_document,
31 "PDFDocument",
32 )?))
33 }
34
35 pub fn from_url(path: impl AsRef<Path>) -> Result<Self> {
36 let path = path_to_c_string(path.as_ref())?;
37 let mut out_document = ptr::null_mut();
38 let mut out_error = ptr::null_mut();
39 let status = unsafe {
40 ffi::pdf_document_new_with_url(path.as_ptr(), &mut out_document, &mut out_error)
41 };
42 crate::util::status_result(status, out_error)?;
43 Ok(Self::from_handle(required_handle(
44 out_document,
45 "PDFDocument",
46 )?))
47 }
48
49 pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
50 let mut out_document = ptr::null_mut();
51 let mut out_error = ptr::null_mut();
52 let status = unsafe {
53 ffi::pdf_document_new_with_data(
54 bytes.as_ptr(),
55 bytes.len(),
56 &mut out_document,
57 &mut out_error,
58 )
59 };
60 crate::util::status_result(status, out_error)?;
61 Ok(Self::from_handle(required_handle(
62 out_document,
63 "PDFDocument",
64 )?))
65 }
66
67 pub fn info(&self) -> Result<PdfDocumentInfo> {
68 parse_json(
69 unsafe { ffi::pdf_document_info_json(self.handle.as_ptr()) },
70 "PDFDocument",
71 )
72 }
73
74 pub fn attributes(&self) -> Result<PdfDocumentAttributes> {
75 parse_json(
76 unsafe { ffi::pdf_document_attributes_json(self.handle.as_ptr()) },
77 "PDFDocument attributes",
78 )
79 }
80
81 #[must_use]
82 pub fn string(&self) -> Option<String> {
83 take_string(unsafe { ffi::pdf_document_string(self.handle.as_ptr()) })
84 }
85
86 #[must_use]
87 pub fn page_count(&self) -> usize {
88 unsafe { ffi::pdf_document_page_count(self.handle.as_ptr()) as usize }
89 }
90
91 #[must_use]
92 pub fn page(&self, index: usize) -> Option<PdfPage> {
93 let ptr = unsafe { ffi::pdf_document_page_at(self.handle.as_ptr(), index as u64) };
94 unsafe { ObjectHandle::from_retained_ptr(ptr) }.map(PdfPage::from_handle)
95 }
96
97 #[must_use]
98 pub fn pages(&self) -> Vec<PdfPage> {
99 (0..self.page_count())
100 .filter_map(|index| self.page(index))
101 .collect()
102 }
103
104 #[must_use]
105 pub fn page_index(&self, page: &PdfPage) -> Option<usize> {
106 let index = unsafe { ffi::pdf_document_index_for_page(self.handle.as_ptr(), page.as_handle_ptr()) };
107 (index != u64::MAX).then_some(index as usize)
108 }
109
110 #[must_use]
111 pub fn outline_root(&self) -> Option<PdfOutline> {
112 let ptr = unsafe { ffi::pdf_document_outline_root(self.handle.as_ptr()) };
113 unsafe { ObjectHandle::from_retained_ptr(ptr) }.map(PdfOutline::from_handle)
114 }
115
116 pub fn set_outline_root(&self, outline: Option<&PdfOutline>) -> Result<()> {
117 let mut out_error = ptr::null_mut();
118 let status = unsafe {
119 ffi::pdf_document_set_outline_root(
120 self.handle.as_ptr(),
121 outline.map_or(ptr::null_mut(), PdfOutline::as_handle_ptr),
122 &mut out_error,
123 )
124 };
125 crate::util::status_result(status, out_error)
126 }
127
128 #[must_use]
129 pub fn outline_item_for_selection(&self, selection: &PdfSelection) -> Option<PdfOutline> {
130 let ptr = unsafe {
131 ffi::pdf_document_outline_item_for_selection(
132 self.handle.as_ptr(),
133 selection.as_handle_ptr(),
134 )
135 };
136 unsafe { ObjectHandle::from_retained_ptr(ptr) }.map(PdfOutline::from_handle)
137 }
138
139 #[must_use]
140 pub fn selection_for_entire_document(&self) -> Option<PdfSelection> {
141 let ptr = unsafe { ffi::pdf_document_selection_for_entire_document(self.handle.as_ptr()) };
142 unsafe { ObjectHandle::from_retained_ptr(ptr) }.map(PdfSelection::from_handle)
143 }
144
145 #[must_use]
146 pub fn selection_from_page_points(
147 &self,
148 start_page: &PdfPage,
149 start_point: PdfPoint,
150 end_page: &PdfPage,
151 end_point: PdfPoint,
152 ) -> Option<PdfSelection> {
153 let ptr = unsafe {
154 ffi::pdf_document_selection_from_pages_points(
155 self.handle.as_ptr(),
156 start_page.as_handle_ptr(),
157 start_point.x,
158 start_point.y,
159 end_page.as_handle_ptr(),
160 end_point.x,
161 end_point.y,
162 )
163 };
164 unsafe { ObjectHandle::from_retained_ptr(ptr) }.map(PdfSelection::from_handle)
165 }
166
167 #[must_use]
168 pub fn selection_from_page_characters(
169 &self,
170 start_page: &PdfPage,
171 start_character: usize,
172 end_page: &PdfPage,
173 end_character: usize,
174 ) -> Option<PdfSelection> {
175 let ptr = unsafe {
176 ffi::pdf_document_selection_from_pages_characters(
177 self.handle.as_ptr(),
178 start_page.as_handle_ptr(),
179 start_character as u64,
180 end_page.as_handle_ptr(),
181 end_character as u64,
182 )
183 };
184 unsafe { ObjectHandle::from_retained_ptr(ptr) }.map(PdfSelection::from_handle)
185 }
186
187 pub fn unlock(&self, password: &str) -> Result<bool> {
188 let password = c_string(password)?;
189 Ok(unsafe { ffi::pdf_document_unlock(self.handle.as_ptr(), password.as_ptr()) != 0 })
190 }
191
192 pub fn set_delegate(&self, delegate: Option<&PdfDocumentDelegateHandle>) -> Result<()> {
193 let mut out_error = ptr::null_mut();
194 let status = unsafe {
195 ffi::pdf_document_set_delegate(
196 self.handle.as_ptr(),
197 delegate.map_or(ptr::null_mut(), PdfDocumentDelegateHandle::as_handle_ptr),
198 &mut out_error,
199 )
200 };
201 crate::util::status_result(status, out_error)
202 }
203
204 pub fn write_to_url(&self, path: impl AsRef<Path>) -> Result<()> {
205 let path = path_to_c_string(path.as_ref())?;
206 let mut out_error = ptr::null_mut();
207 let status = unsafe {
208 ffi::pdf_document_write_to_url(self.handle.as_ptr(), path.as_ptr(), &mut out_error)
209 };
210 crate::util::status_result(status, out_error)
211 }
212
213 pub fn write_to_url_with_options(
214 &self,
215 path: impl AsRef<Path>,
216 options: &PdfDocumentWriteOptions,
217 ) -> Result<()> {
218 let path = path_to_c_string(path.as_ref())?;
219 let options_json = serde_json::to_string(options).map_err(|error| {
220 PdfKitError::new(
221 ffi::status::FRAMEWORK,
222 format!("failed to encode PDFDocument write options: {error}"),
223 )
224 })?;
225 let options_json = c_string(&options_json)?;
226 let mut out_error = ptr::null_mut();
227 let status = unsafe {
228 ffi::pdf_document_write_to_url_with_options(
229 self.handle.as_ptr(),
230 path.as_ptr(),
231 options_json.as_ptr(),
232 &mut out_error,
233 )
234 };
235 crate::util::status_result(status, out_error)
236 }
237
238 pub fn insert_page(&self, page: &PdfPage, index: usize) -> Result<()> {
239 let mut out_error = ptr::null_mut();
240 let status = unsafe {
241 ffi::pdf_document_insert_page(
242 self.handle.as_ptr(),
243 page.as_handle_ptr(),
244 index as u64,
245 &mut out_error,
246 )
247 };
248 crate::util::status_result(status, out_error)
249 }
250
251 pub fn remove_page(&self, index: usize) -> Result<()> {
252 let mut out_error = ptr::null_mut();
253 let status = unsafe {
254 ffi::pdf_document_remove_page_at(self.handle.as_ptr(), index as u64, &mut out_error)
255 };
256 crate::util::status_result(status, out_error)
257 }
258
259 pub fn exchange_pages(&self, index_a: usize, index_b: usize) -> Result<()> {
260 let mut out_error = ptr::null_mut();
261 let status = unsafe {
262 ffi::pdf_document_exchange_pages(
263 self.handle.as_ptr(),
264 index_a as u64,
265 index_b as u64,
266 &mut out_error,
267 )
268 };
269 crate::util::status_result(status, out_error)
270 }
271
272 pub(crate) fn as_handle_ptr(&self) -> *mut core::ffi::c_void {
273 self.handle.as_ptr()
274 }
275}