jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2021-2022, Matthew Olsson <mattco@serenityos.org>
3 * Copyright (c) 2021, Mustafa Quraish <mustafa@serenityos.org>
4 *
5 * SPDX-License-Identifier: BSD-2-Clause
6 */
7
8#include "PDFViewerWidget.h"
9#include <AK/Assertions.h>
10#include <AK/DeprecatedString.h>
11#include <AK/Format.h>
12#include <AK/HashMap.h>
13#include <AK/HashTable.h>
14#include <AK/Variant.h>
15#include <LibFileSystemAccessClient/Client.h>
16#include <LibGUI/Application.h>
17#include <LibGUI/BoxLayout.h>
18#include <LibGUI/FilePicker.h>
19#include <LibGUI/Forward.h>
20#include <LibGUI/InputBox.h>
21#include <LibGUI/Label.h>
22#include <LibGUI/Menu.h>
23#include <LibGUI/Menubar.h>
24#include <LibGUI/MessageBox.h>
25#include <LibGUI/Model.h>
26#include <LibGUI/SortingProxyModel.h>
27#include <LibGUI/Splitter.h>
28#include <LibGUI/TableView.h>
29#include <LibGUI/Toolbar.h>
30#include <LibGUI/ToolbarContainer.h>
31#include <LibPDF/Document.h>
32
33class PagedErrorsModel : public GUI::Model {
34
35 enum Columns {
36 Page = 0,
37 Message,
38 _Count
39 };
40
41 using PageErrors = AK::OrderedHashTable<DeprecatedString>;
42 using PagedErrors = HashMap<u32, PageErrors>;
43
44public:
45 int row_count(GUI::ModelIndex const& index) const override
46 {
47 // There are two levels: number of pages and number of errors in page
48 if (!index.is_valid()) {
49 return static_cast<int>(m_paged_errors.size());
50 }
51 if (!index.parent().is_valid()) {
52 return static_cast<int>(error_count_in_page(index));
53 }
54 return 0;
55 }
56
57 int column_count(GUI::ModelIndex const&) const override
58 {
59 return Columns::_Count;
60 }
61
62 int tree_column() const override
63 {
64 return Columns::Page;
65 }
66
67 DeprecatedString column_name(int index) const override
68 {
69 switch (index) {
70 case 0:
71 return "Page";
72 case 1:
73 return "Message";
74 default:
75 VERIFY_NOT_REACHED();
76 }
77 }
78
79 GUI::ModelIndex index(int row, int column, GUI::ModelIndex const& parent) const override
80 {
81 if (!parent.is_valid()) {
82 return create_index(row, column);
83 }
84 auto const& page = m_pages_with_errors[parent.row()];
85 return create_index(row, column, &page);
86 }
87
88 GUI::ModelIndex parent_index(GUI::ModelIndex const& index) const override
89 {
90 auto* const internal_data = index.internal_data();
91 if (internal_data == nullptr)
92 return {};
93 auto page = *static_cast<u32 const*>(internal_data);
94 auto page_idx = static_cast<int>(m_pages_with_errors.find_first_index(page).release_value());
95 return create_index(page_idx, index.column());
96 }
97
98 virtual GUI::Variant data(GUI::ModelIndex const& index, GUI::ModelRole) const override
99 {
100 if (!index.parent().is_valid()) {
101 switch (index.column()) {
102 case Columns::Page:
103 return m_pages_with_errors[index.row()] + 1;
104 case Columns::Message:
105 return DeprecatedString::formatted("{} errors", error_count_in_page(index));
106 default:
107 VERIFY_NOT_REACHED();
108 }
109 }
110
111 auto page = *static_cast<u32 const*>(index.internal_data());
112 switch (index.column()) {
113 case Columns::Page:
114 return "";
115 case Columns::Message: {
116 auto page_errors = m_paged_errors.get(page).release_value();
117 // dbgln("Errors on page {}: {}. Requesting data for index {},{}", page, page_errors.size(), index.row(), index.column());
118 auto it = page_errors.begin();
119 auto row = index.row();
120 for (int i = 0; i < row; ++i, ++it)
121 ;
122 return *it;
123 }
124 }
125 VERIFY_NOT_REACHED();
126 }
127
128 void add_errors(u32 page, PDF::Errors const& errors)
129 {
130 auto old_size = total_error_count();
131 if (!m_pages_with_errors.contains_slow(page)) {
132 m_pages_with_errors.append(page);
133 }
134 auto& page_errors = m_paged_errors.ensure(page);
135 for (auto const& error : errors.errors())
136 page_errors.set(error.message());
137 auto new_size = total_error_count();
138 if (old_size != new_size)
139 invalidate();
140 }
141
142private:
143 size_t total_error_count() const
144 {
145 size_t count = 0;
146 for (auto const& entry : m_paged_errors)
147 count += entry.value.size();
148 return count;
149 }
150
151 size_t error_count_in_page(GUI::ModelIndex const& index) const
152 {
153 VERIFY(!index.parent().is_valid());
154 auto page = m_pages_with_errors[index.row()];
155 return m_paged_errors.get(page).release_value().size();
156 }
157
158 Vector<u32> m_pages_with_errors;
159 PagedErrors m_paged_errors;
160};
161
162PDFViewerWidget::PDFViewerWidget()
163 : m_paged_errors_model(adopt_ref(*new PagedErrorsModel()))
164{
165 set_fill_with_background_color(true);
166 set_layout<GUI::VerticalBoxLayout>();
167
168 auto& toolbar_container = add<GUI::ToolbarContainer>();
169 auto& toolbar = toolbar_container.add<GUI::Toolbar>();
170
171 auto& h_splitter = add<GUI::HorizontalSplitter>();
172 h_splitter.layout()->set_spacing(4);
173
174 m_sidebar = h_splitter.add<SidebarWidget>();
175 m_sidebar->set_preferred_width(200);
176 m_sidebar->set_visible(false);
177 m_sidebar->on_destination_selected = [&](PDF::Destination const& destination) {
178 auto maybe_page = destination.page;
179 if (!maybe_page.has_value())
180 return;
181 auto page = maybe_page.release_value();
182 m_viewer->set_current_page(page);
183 };
184
185 auto& v_splitter = h_splitter.add<GUI::VerticalSplitter>();
186 v_splitter.layout()->set_spacing(4);
187
188 m_viewer = v_splitter.add<PDFViewer>();
189 m_viewer->on_page_change = [&](auto new_page) {
190 m_page_text_box->set_current_number(new_page + 1, GUI::AllowCallback::No);
191 m_go_to_prev_page_action->set_enabled(new_page > 0);
192 m_go_to_next_page_action->set_enabled(new_page < m_viewer->document()->get_page_count() - 1);
193 };
194 m_viewer->on_render_errors = [&](u32 page, PDF::Errors const& errors) {
195 verify_cast<PagedErrorsModel>(m_paged_errors_model.ptr())->add_errors(page, errors);
196 };
197
198 m_errors_tree_view = v_splitter.add<GUI::TreeView>();
199 m_errors_tree_view->set_preferred_height(10);
200 m_errors_tree_view->column_header().set_visible(true);
201 m_errors_tree_view->set_should_fill_selected_rows(true);
202 m_errors_tree_view->set_selection_behavior(GUI::AbstractView::SelectionBehavior::SelectRows);
203 m_errors_tree_view->set_model(MUST(GUI::SortingProxyModel::create(m_paged_errors_model)));
204 m_errors_tree_view->set_key_column(0);
205
206 initialize_toolbar(toolbar);
207}
208
209void PDFViewerWidget::initialize_menubar(GUI::Window& window)
210{
211 auto& file_menu = window.add_menu("&File");
212 file_menu.add_action(GUI::CommonActions::make_open_action([&](auto&) {
213 auto response = FileSystemAccessClient::Client::the().open_file(&window);
214 if (!response.is_error())
215 open_file(response.value().filename(), response.value().release_stream());
216 }));
217 file_menu.add_separator();
218 file_menu.add_action(GUI::CommonActions::make_quit_action([](auto&) {
219 GUI::Application::the()->quit();
220 }));
221
222 auto& view_menu = window.add_menu("&View");
223 view_menu.add_action(*m_toggle_sidebar_action);
224 view_menu.add_separator();
225 auto& view_mode_menu = view_menu.add_submenu("View &Mode");
226 view_mode_menu.add_action(*m_page_view_mode_single);
227 view_mode_menu.add_action(*m_page_view_mode_multiple);
228 view_menu.add_separator();
229 view_menu.add_action(*m_zoom_in_action);
230 view_menu.add_action(*m_zoom_out_action);
231 view_menu.add_action(*m_reset_zoom_action);
232
233 auto& help_menu = window.add_menu("&Help");
234 help_menu.add_action(GUI::CommonActions::make_command_palette_action(&window));
235 help_menu.add_action(GUI::CommonActions::make_about_action("PDF Viewer", GUI::Icon::default_icon("app-pdf-viewer"sv), &window));
236}
237
238void PDFViewerWidget::initialize_toolbar(GUI::Toolbar& toolbar)
239{
240 auto open_outline_action = GUI::Action::create(
241 "Toggle &Sidebar", { Mod_Ctrl, Key_S }, Gfx::Bitmap::load_from_file("/res/icons/16x16/sidebar.png"sv).release_value_but_fixme_should_propagate_errors(), [&](auto&) {
242 m_sidebar_open = !m_sidebar_open;
243 m_sidebar->set_visible(m_sidebar_open);
244 },
245 nullptr);
246 open_outline_action->set_enabled(false);
247 m_toggle_sidebar_action = open_outline_action;
248
249 toolbar.add_action(*open_outline_action);
250 toolbar.add_separator();
251
252 m_go_to_prev_page_action = GUI::Action::create("Go to &Previous Page", Gfx::Bitmap::load_from_file("/res/icons/16x16/go-up.png"sv).release_value_but_fixme_should_propagate_errors(), [&](auto&) {
253 VERIFY(m_viewer->current_page() > 0);
254 m_page_text_box->set_current_number(m_viewer->current_page());
255 });
256 m_go_to_prev_page_action->set_enabled(false);
257
258 m_go_to_next_page_action = GUI::Action::create("Go to &Next Page", Gfx::Bitmap::load_from_file("/res/icons/16x16/go-down.png"sv).release_value_but_fixme_should_propagate_errors(), [&](auto&) {
259 VERIFY(m_viewer->current_page() < m_viewer->document()->get_page_count() - 1);
260 m_page_text_box->set_current_number(m_viewer->current_page() + 2);
261 });
262 m_go_to_next_page_action->set_enabled(false);
263
264 toolbar.add_action(*m_go_to_prev_page_action);
265 toolbar.add_action(*m_go_to_next_page_action);
266
267 m_page_text_box = toolbar.add<NumericInput>();
268 m_page_text_box->set_enabled(false);
269 m_page_text_box->set_fixed_width(30);
270 m_page_text_box->set_min_number(1);
271
272 m_page_text_box->on_number_changed = [&](i32 number) {
273 auto page_count = m_viewer->document()->get_page_count();
274 auto new_page_number = static_cast<u32>(number);
275 VERIFY(new_page_number >= 1 && new_page_number <= page_count);
276 m_viewer->set_current_page(new_page_number - 1);
277 m_go_to_prev_page_action->set_enabled(new_page_number > 1);
278 m_go_to_next_page_action->set_enabled(new_page_number < page_count);
279 };
280
281 m_total_page_label = toolbar.add<GUI::Label>();
282 m_total_page_label->set_autosize(true, 5);
283 toolbar.add_separator();
284
285 m_zoom_in_action = GUI::CommonActions::make_zoom_in_action([&](auto&) {
286 m_viewer->zoom_in();
287 });
288
289 m_zoom_out_action = GUI::CommonActions::make_zoom_out_action([&](auto&) {
290 m_viewer->zoom_out();
291 });
292
293 m_reset_zoom_action = GUI::CommonActions::make_reset_zoom_action([&](auto&) {
294 m_viewer->reset_zoom();
295 });
296
297 m_rotate_counterclockwise_action = GUI::CommonActions::make_rotate_counterclockwise_action([&](auto&) {
298 m_viewer->rotate(-90);
299 });
300
301 m_rotate_clockwise_action = GUI::CommonActions::make_rotate_clockwise_action([&](auto&) {
302 m_viewer->rotate(90);
303 });
304
305 m_zoom_in_action->set_enabled(false);
306 m_zoom_out_action->set_enabled(false);
307 m_reset_zoom_action->set_enabled(false);
308 m_rotate_counterclockwise_action->set_enabled(false);
309 m_rotate_clockwise_action->set_enabled(false);
310
311 m_page_view_mode_single = GUI::Action::create_checkable("Single", [&](auto&) {
312 m_viewer->set_page_view_mode(PDFViewer::PageViewMode::Single);
313 });
314 m_page_view_mode_single->set_status_tip("Show single page at a time");
315
316 m_page_view_mode_multiple = GUI::Action::create_checkable("Multiple", [&](auto&) {
317 m_viewer->set_page_view_mode(PDFViewer::PageViewMode::Multiple);
318 });
319 m_page_view_mode_multiple->set_status_tip("Show multiple pages at a time");
320
321 if (m_viewer->page_view_mode() == PDFViewer::PageViewMode::Single) {
322 m_page_view_mode_single->set_checked(true);
323 } else {
324 m_page_view_mode_multiple->set_checked(true);
325 }
326
327 m_page_view_action_group.add_action(*m_page_view_mode_single);
328 m_page_view_action_group.add_action(*m_page_view_mode_multiple);
329 m_page_view_action_group.set_exclusive(true);
330 toolbar.add_action(*m_page_view_mode_single);
331 toolbar.add_action(*m_page_view_mode_multiple);
332 toolbar.add_separator();
333
334 toolbar.add_action(*m_zoom_in_action);
335 toolbar.add_action(*m_zoom_out_action);
336 toolbar.add_action(*m_reset_zoom_action);
337 toolbar.add_action(*m_rotate_counterclockwise_action);
338 toolbar.add_action(*m_rotate_clockwise_action);
339 toolbar.add_separator();
340
341 m_show_clipping_paths = toolbar.add<GUI::CheckBox>();
342 m_show_clipping_paths->set_text("Show clipping paths"_string.release_value_but_fixme_should_propagate_errors());
343 m_show_clipping_paths->set_checked(m_viewer->show_clipping_paths(), GUI::AllowCallback::No);
344 m_show_clipping_paths->on_checked = [&](auto checked) { m_viewer->set_show_clipping_paths(checked); };
345 m_show_images = toolbar.add<GUI::CheckBox>();
346 m_show_images->set_text("Show images"_string.release_value_but_fixme_should_propagate_errors());
347 m_show_images->set_checked(m_viewer->show_images(), GUI::AllowCallback::No);
348 m_show_images->on_checked = [&](auto checked) { m_viewer->set_show_images(checked); };
349}
350
351void PDFViewerWidget::open_file(StringView path, NonnullOwnPtr<Core::File> file)
352{
353 auto maybe_error = try_open_file(path, move(file));
354 if (maybe_error.is_error()) {
355 auto error = maybe_error.release_error();
356 warnln("{}", error.message());
357 auto user_error_message = DeprecatedString::formatted("Failed to load the document. Error:\n{}.", error.message());
358 GUI::MessageBox::show_error(nullptr, user_error_message.view());
359 }
360}
361
362PDF::PDFErrorOr<void> PDFViewerWidget::try_open_file(StringView path, NonnullOwnPtr<Core::File> file)
363{
364 window()->set_title(DeprecatedString::formatted("{} - PDF Viewer", path));
365
366 m_buffer = TRY(file->read_until_eof());
367 auto document = TRY(PDF::Document::create(m_buffer));
368
369 if (auto sh = document->security_handler(); sh && !sh->has_user_password()) {
370 DeprecatedString password;
371 while (true) {
372 auto result = GUI::InputBox::show(window(), password, "Password"sv, "Password required"sv, GUI::InputType::Password);
373 if (result == GUI::Dialog::ExecResult::OK
374 && document->security_handler()->try_provide_user_password(password))
375 break;
376 if (result == GUI::Dialog::ExecResult::Cancel)
377 return {};
378 }
379 }
380
381 TRY(document->initialize());
382 TRY(m_viewer->set_document(document));
383
384 m_total_page_label->set_text(DeprecatedString::formatted("of {}", document->get_page_count()));
385
386 m_page_text_box->set_enabled(true);
387 m_page_text_box->set_current_number(1, GUI::AllowCallback::No);
388 m_page_text_box->set_max_number(document->get_page_count());
389 m_go_to_prev_page_action->set_enabled(false);
390 m_go_to_next_page_action->set_enabled(document->get_page_count() > 1);
391 m_toggle_sidebar_action->set_enabled(true);
392 m_zoom_in_action->set_enabled(true);
393 m_zoom_out_action->set_enabled(true);
394 m_reset_zoom_action->set_enabled(true);
395 m_rotate_counterclockwise_action->set_enabled(true);
396 m_rotate_clockwise_action->set_enabled(true);
397 m_show_clipping_paths->set_checked(m_viewer->show_clipping_paths(), GUI::AllowCallback::No);
398
399 if (document->outline()) {
400 auto outline = document->outline();
401 TRY(m_sidebar->set_outline(outline.release_nonnull()));
402 m_sidebar->set_visible(true);
403 m_sidebar_open = true;
404 } else {
405 TRY(m_sidebar->set_outline({}));
406 m_sidebar->set_visible(false);
407 m_sidebar_open = false;
408 }
409
410 return {};
411}