PDFViewer.cpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384
  1. /*
  2. * Copyright (c) 2021-2022, Matthew Olsson <mattco@serenityos.org>
  3. * Copyright (c) 2022, the SerenityOS developers.
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include "PDFViewer.h"
  8. #include <AK/Array.h>
  9. #include <AK/BinarySearch.h>
  10. #include <LibConfig/Client.h>
  11. #include <LibGUI/Action.h>
  12. #include <LibGUI/MessageBox.h>
  13. #include <LibGUI/Painter.h>
  14. #include <LibPDF/Renderer.h>
  15. static constexpr int PAGE_PADDING = 10;
  16. static constexpr Array zoom_levels = {
  17. 17,
  18. 21,
  19. 26,
  20. 33,
  21. 41,
  22. 51,
  23. 64,
  24. 80,
  25. 100,
  26. 120,
  27. 144,
  28. 173,
  29. 207,
  30. 249,
  31. 299,
  32. 358,
  33. 430
  34. };
  35. PDFViewer::PDFViewer()
  36. {
  37. set_should_hide_unnecessary_scrollbars(true);
  38. set_focus_policy(GUI::FocusPolicy::StrongFocus);
  39. set_scrollbars_enabled(true);
  40. start_timer(30'000);
  41. m_page_view_mode = static_cast<PageViewMode>(Config::read_i32("PDFViewer"sv, "Display"sv, "PageMode"sv, 0));
  42. m_rendering_preferences.show_clipping_paths = Config::read_bool("PDFViewer"sv, "Rendering"sv, "ShowClippingPaths"sv, false);
  43. }
  44. PDF::PDFErrorOr<void> PDFViewer::set_document(RefPtr<PDF::Document> document)
  45. {
  46. m_document = document;
  47. m_current_page_index = document->get_first_page_index();
  48. m_zoom_level = initial_zoom_level;
  49. m_rendered_page_list.clear();
  50. m_rendered_page_list.ensure_capacity(document->get_page_count());
  51. for (u32 i = 0; i < document->get_page_count(); i++)
  52. m_rendered_page_list.unchecked_append(HashMap<u32, RenderedPage>());
  53. TRY(cache_page_dimensions(true));
  54. update();
  55. return {};
  56. }
  57. PDF::PDFErrorOr<NonnullRefPtr<Gfx::Bitmap>> PDFViewer::get_rendered_page(u32 index)
  58. {
  59. auto key = m_zoom_level * (static_cast<int>(m_rendering_preferences.show_clipping_paths) + 1);
  60. auto& rendered_page_map = m_rendered_page_list[index];
  61. auto existing_rendered_page = rendered_page_map.get(key);
  62. if (existing_rendered_page.has_value() && existing_rendered_page.value().rotation == m_rotations)
  63. return existing_rendered_page.value().bitmap;
  64. auto rendered_page = TRY(render_page(index));
  65. rendered_page_map.set(key, { rendered_page, m_rotations });
  66. return rendered_page;
  67. }
  68. void PDFViewer::paint_event(GUI::PaintEvent& event)
  69. {
  70. GUI::Frame::paint_event(event);
  71. GUI::Painter painter(*this);
  72. painter.add_clip_rect(widget_inner_rect());
  73. painter.add_clip_rect(event.rect());
  74. painter.fill_rect(event.rect(), Color(0x80, 0x80, 0x80));
  75. if (!m_document)
  76. return;
  77. auto handle_error = [&](PDF::Error& error) {
  78. warnln("{}", error.message());
  79. GUI::MessageBox::show_error(nullptr, "Failed to render the page."sv);
  80. m_document.clear();
  81. };
  82. if (m_page_view_mode == PageViewMode::Single) {
  83. auto maybe_page = get_rendered_page(m_current_page_index);
  84. if (maybe_page.is_error()) {
  85. handle_error(maybe_page.error());
  86. return;
  87. }
  88. auto page = maybe_page.release_value();
  89. set_content_size(page->size());
  90. painter.translate(frame_thickness(), frame_thickness());
  91. painter.translate(-horizontal_scrollbar().value(), -vertical_scrollbar().value());
  92. int x = max(0, (width() - page->width()) / 2);
  93. int y = max(0, (height() - page->height()) / 2);
  94. painter.blit({ x, y }, *page, page->rect());
  95. return;
  96. }
  97. set_content_size({ m_page_dimension_cache.max_width, m_page_dimension_cache.total_height });
  98. size_t first_page_index = 0;
  99. size_t last_page_index = 0;
  100. binary_search(m_page_dimension_cache.render_info, vertical_scrollbar().value(), &first_page_index, [](int height, PageDimensionCache::RenderInfo const& render_info) {
  101. return height - render_info.total_height_before_this_page;
  102. });
  103. binary_search(m_page_dimension_cache.render_info, vertical_scrollbar().value() + height(), &last_page_index, [](int height, PageDimensionCache::RenderInfo const& render_info) {
  104. return height - render_info.total_height_before_this_page;
  105. });
  106. auto initial_offset = m_page_dimension_cache.render_info[first_page_index].total_height_before_this_page - vertical_scrollbar().value();
  107. painter.translate(frame_thickness(), frame_thickness());
  108. painter.translate(-horizontal_scrollbar().value(), initial_offset);
  109. auto middle = height() / 2;
  110. auto y_offset = initial_offset;
  111. for (size_t page_index = first_page_index; page_index <= last_page_index; page_index++) {
  112. auto maybe_page = get_rendered_page(page_index);
  113. if (maybe_page.is_error()) {
  114. handle_error(maybe_page.error());
  115. return;
  116. }
  117. auto page = maybe_page.release_value();
  118. auto x = max(0, (width() - page->width()) / 2);
  119. painter.blit({ x, PAGE_PADDING }, *page, page->rect());
  120. auto diff_y = page->height() + PAGE_PADDING * 2;
  121. painter.translate(0, diff_y);
  122. if (y_offset < middle && y_offset + diff_y >= middle)
  123. change_page(page_index);
  124. y_offset += diff_y;
  125. }
  126. }
  127. void PDFViewer::set_current_page(u32 current_page)
  128. {
  129. m_current_page_index = current_page;
  130. vertical_scrollbar().set_value(m_page_dimension_cache.render_info[current_page].total_height_before_this_page);
  131. update();
  132. }
  133. void PDFViewer::set_show_clipping_paths(bool show_clipping_paths)
  134. {
  135. m_rendering_preferences.show_clipping_paths = show_clipping_paths;
  136. Config::write_bool("PDFViewer"sv, "Rendering"sv, "ShowClippingPaths"sv, show_clipping_paths);
  137. update();
  138. }
  139. void PDFViewer::resize_event(GUI::ResizeEvent&)
  140. {
  141. for (auto& map : m_rendered_page_list)
  142. map.clear();
  143. if (m_document)
  144. MUST(cache_page_dimensions());
  145. update();
  146. }
  147. void PDFViewer::mousewheel_event(GUI::MouseEvent& event)
  148. {
  149. if (!m_document)
  150. return;
  151. bool scrolled_down = event.wheel_delta_y() > 0;
  152. if (event.ctrl()) {
  153. if (scrolled_down) {
  154. zoom_out();
  155. } else {
  156. zoom_in();
  157. }
  158. return;
  159. }
  160. auto& scrollbar = event.shift() ? horizontal_scrollbar() : vertical_scrollbar();
  161. auto delta = abs(event.wheel_delta_y() * 20);
  162. if (m_page_view_mode == PageViewMode::Multiple) {
  163. if (scrolled_down) {
  164. if (scrollbar.value() != scrollbar.max())
  165. scrollbar.increase_slider_by(delta);
  166. } else {
  167. if (scrollbar.value() > 0)
  168. scrollbar.decrease_slider_by(delta);
  169. }
  170. } else {
  171. if (scrolled_down) {
  172. if (scrollbar.value() == scrollbar.max()) {
  173. if (m_current_page_index < m_document->get_page_count() - 1) {
  174. change_page(m_current_page_index + 1);
  175. scrollbar.set_value(0);
  176. }
  177. } else {
  178. scrollbar.increase_slider_by(delta);
  179. }
  180. } else {
  181. if (scrollbar.value() == 0) {
  182. if (m_current_page_index > 0) {
  183. change_page(m_current_page_index - 1);
  184. scrollbar.set_value(scrollbar.max());
  185. }
  186. } else {
  187. scrollbar.decrease_slider_by(delta);
  188. }
  189. }
  190. }
  191. update();
  192. }
  193. void PDFViewer::mousedown_event(GUI::MouseEvent& event)
  194. {
  195. if (event.button() == GUI::MouseButton::Middle) {
  196. m_pan_starting_position = to_content_position(event.position());
  197. set_override_cursor(Gfx::StandardCursor::Drag);
  198. }
  199. }
  200. void PDFViewer::mouseup_event(GUI::MouseEvent&)
  201. {
  202. set_override_cursor(Gfx::StandardCursor::None);
  203. }
  204. void PDFViewer::mousemove_event(GUI::MouseEvent& event)
  205. {
  206. if (event.buttons() & GUI::MouseButton::Middle) {
  207. auto delta = to_content_position(event.position()) - m_pan_starting_position;
  208. horizontal_scrollbar().decrease_slider_by(delta.x());
  209. vertical_scrollbar().decrease_slider_by(delta.y());
  210. update();
  211. }
  212. }
  213. void PDFViewer::timer_event(Core::TimerEvent&)
  214. {
  215. // Clear the bitmap vector of all pages except the current page
  216. for (size_t i = 0; i < m_rendered_page_list.size(); i++) {
  217. if (i != m_current_page_index)
  218. m_rendered_page_list[i].clear();
  219. }
  220. }
  221. void PDFViewer::zoom_in()
  222. {
  223. if (m_zoom_level < zoom_levels.size() - 1) {
  224. m_zoom_level++;
  225. MUST(cache_page_dimensions());
  226. update();
  227. }
  228. }
  229. void PDFViewer::zoom_out()
  230. {
  231. if (m_zoom_level > 0) {
  232. m_zoom_level--;
  233. MUST(cache_page_dimensions());
  234. update();
  235. }
  236. }
  237. void PDFViewer::reset_zoom()
  238. {
  239. m_zoom_level = initial_zoom_level;
  240. MUST(cache_page_dimensions());
  241. update();
  242. }
  243. void PDFViewer::rotate(int degrees)
  244. {
  245. m_rotations = (m_rotations + degrees + 360) % 360;
  246. MUST(cache_page_dimensions());
  247. update();
  248. }
  249. void PDFViewer::set_page_view_mode(PageViewMode mode)
  250. {
  251. m_page_view_mode = mode;
  252. Config::write_i32("PDFViewer"sv, "Display"sv, "PageMode"sv, static_cast<i32>(mode));
  253. update();
  254. }
  255. PDF::PDFErrorOr<NonnullRefPtr<Gfx::Bitmap>> PDFViewer::render_page(u32 page_index)
  256. {
  257. auto page = TRY(m_document->get_page(page_index));
  258. auto& page_size = m_page_dimension_cache.render_info[page_index].size;
  259. auto bitmap = TRY(Gfx::Bitmap::try_create(Gfx::BitmapFormat::BGRA8888, page_size.to_type<int>()));
  260. TRY(PDF::Renderer::render(*m_document, page, bitmap, m_rendering_preferences));
  261. if (page.rotate + m_rotations != 0) {
  262. int rotation_count = ((page.rotate + m_rotations) / 90) % 4;
  263. if (rotation_count == 3) {
  264. bitmap = TRY(bitmap->rotated(Gfx::RotationDirection::CounterClockwise));
  265. } else {
  266. for (int i = 0; i < rotation_count; i++)
  267. bitmap = TRY(bitmap->rotated(Gfx::RotationDirection::Clockwise));
  268. }
  269. }
  270. return bitmap;
  271. }
  272. PDF::PDFErrorOr<void> PDFViewer::cache_page_dimensions(bool recalculate_fixed_info)
  273. {
  274. if (recalculate_fixed_info)
  275. m_page_dimension_cache.page_info.clear_with_capacity();
  276. if (m_page_dimension_cache.page_info.is_empty()) {
  277. m_page_dimension_cache.page_info.ensure_capacity(m_document->get_page_count());
  278. for (size_t i = 0; i < m_document->get_page_count(); i++) {
  279. auto page = TRY(m_document->get_page(i));
  280. auto box = page.media_box;
  281. m_page_dimension_cache.page_info.unchecked_append(PageDimensionCache::PageInfo {
  282. { box.width(), box.height() },
  283. page.rotate,
  284. });
  285. }
  286. }
  287. auto zoom_scale_factor = static_cast<float>(zoom_levels[m_zoom_level]) / 100.0f;
  288. m_page_dimension_cache.render_info.clear_with_capacity();
  289. m_page_dimension_cache.render_info.ensure_capacity(m_page_dimension_cache.page_info.size());
  290. float max_width = 0;
  291. float total_height = 0;
  292. for (size_t i = 0; i < m_page_dimension_cache.page_info.size(); i++) {
  293. auto& [size, rotation] = m_page_dimension_cache.page_info[i];
  294. rotation += m_rotations;
  295. auto page_scale_factor = size.height() / size.width();
  296. auto height = static_cast<float>(this->height() - 2 * frame_thickness()) * zoom_scale_factor - PAGE_PADDING * 2;
  297. auto width = height / page_scale_factor;
  298. if (rotation % 2)
  299. swap(width, height);
  300. max_width = max(max_width, width);
  301. m_page_dimension_cache.render_info.append({
  302. { width, height },
  303. total_height,
  304. });
  305. total_height += height;
  306. }
  307. m_page_dimension_cache.max_width = max_width;
  308. m_page_dimension_cache.total_height = total_height;
  309. return {};
  310. }
  311. void PDFViewer::change_page(u32 new_page)
  312. {
  313. m_current_page_index = new_page;
  314. if (on_page_change)
  315. on_page_change(m_current_page_index);
  316. }