AbstractTableView.cpp 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/StringBuilder.h>
  7. #include <AK/Vector.h>
  8. #include <LibGUI/AbstractTableView.h>
  9. #include <LibGUI/Action.h>
  10. #include <LibGUI/Button.h>
  11. #include <LibGUI/HeaderView.h>
  12. #include <LibGUI/Menu.h>
  13. #include <LibGUI/Model.h>
  14. #include <LibGUI/Painter.h>
  15. #include <LibGUI/Scrollbar.h>
  16. #include <LibGUI/Window.h>
  17. #include <LibGfx/Palette.h>
  18. namespace GUI {
  19. AbstractTableView::AbstractTableView()
  20. {
  21. set_selection_behavior(SelectionBehavior::SelectRows);
  22. m_corner_button = add<Button>();
  23. m_corner_button->move_to_back();
  24. m_corner_button->set_background_role(Gfx::ColorRole::ThreedShadow1);
  25. m_corner_button->set_fill_with_background_color(true);
  26. m_column_header = add<HeaderView>(*this, Gfx::Orientation::Horizontal);
  27. m_column_header->move_to_back();
  28. m_column_header->on_resize_doubleclick = [this](auto column) {
  29. auto_resize_column(column);
  30. };
  31. m_row_header = add<HeaderView>(*this, Gfx::Orientation::Vertical);
  32. m_row_header->move_to_back();
  33. m_row_header->set_visible(false);
  34. set_should_hide_unnecessary_scrollbars(true);
  35. }
  36. AbstractTableView::~AbstractTableView()
  37. {
  38. }
  39. void AbstractTableView::select_all()
  40. {
  41. selection().clear();
  42. for (int item_index = 0; item_index < item_count(); ++item_index) {
  43. auto index = model()->index(item_index);
  44. selection().add(index);
  45. }
  46. }
  47. void AbstractTableView::auto_resize_column(int column)
  48. {
  49. if (!model())
  50. return;
  51. if (!column_header().is_section_visible(column))
  52. return;
  53. auto& model = *this->model();
  54. int row_count = model.row_count();
  55. int header_width = m_column_header->font().width(model.column_name(column));
  56. if (column == m_key_column && model.is_column_sortable(column))
  57. header_width += font().width(" \xE2\xAC\x86");
  58. int column_width = header_width;
  59. bool is_empty = true;
  60. for (int row = 0; row < row_count; ++row) {
  61. auto cell_data = model.index(row, column).data();
  62. int cell_width = 0;
  63. if (cell_data.is_icon()) {
  64. cell_width = cell_data.as_icon().bitmap_for_size(16)->width();
  65. } else if (cell_data.is_bitmap()) {
  66. cell_width = cell_data.as_bitmap().width();
  67. } else if (cell_data.is_valid()) {
  68. cell_width = font().width(cell_data.to_string());
  69. }
  70. if (is_empty && cell_width > 0)
  71. is_empty = false;
  72. column_width = max(column_width, cell_width);
  73. }
  74. auto default_column_size = column_header().default_section_size(column);
  75. if (is_empty && column_header().is_default_section_size_initialized(column))
  76. column_header().set_section_size(column, default_column_size);
  77. else
  78. column_header().set_section_size(column, column_width);
  79. }
  80. void AbstractTableView::update_column_sizes()
  81. {
  82. if (!model())
  83. return;
  84. auto& model = *this->model();
  85. int column_count = model.column_count();
  86. int row_count = model.row_count();
  87. for (int column = 0; column < column_count; ++column) {
  88. if (!column_header().is_section_visible(column))
  89. continue;
  90. int header_width = m_column_header->font().width(model.column_name(column));
  91. if (column == m_key_column && model.is_column_sortable(column))
  92. header_width += font().width(" \xE2\xAC\x86"); // UPWARDS BLACK ARROW
  93. int column_width = header_width;
  94. for (int row = 0; row < row_count; ++row) {
  95. auto cell_data = model.index(row, column).data();
  96. int cell_width = 0;
  97. if (cell_data.is_icon()) {
  98. cell_width = cell_data.as_icon().bitmap_for_size(16)->width();
  99. } else if (cell_data.is_bitmap()) {
  100. cell_width = cell_data.as_bitmap().width();
  101. } else if (cell_data.is_valid()) {
  102. cell_width = font().width(cell_data.to_string());
  103. }
  104. column_width = max(column_width, cell_width);
  105. }
  106. column_header().set_section_size(column, max(m_column_header->section_size(column), column_width));
  107. }
  108. }
  109. void AbstractTableView::update_row_sizes()
  110. {
  111. if (!model())
  112. return;
  113. auto& model = *this->model();
  114. int row_count = model.row_count();
  115. for (int row = 0; row < row_count; ++row) {
  116. if (!row_header().is_section_visible(row))
  117. continue;
  118. row_header().set_section_size(row, row_height());
  119. }
  120. }
  121. void AbstractTableView::update_content_size()
  122. {
  123. if (!model())
  124. return set_content_size({});
  125. int content_width = 0;
  126. int column_count = model()->column_count();
  127. for (int i = 0; i < column_count; ++i) {
  128. if (column_header().is_section_visible(i))
  129. content_width += column_width(i) + horizontal_padding() * 2;
  130. }
  131. int content_height = item_count() * row_height();
  132. set_content_size({ content_width, content_height });
  133. set_size_occupied_by_fixed_elements({ row_header().width(), column_header().height() });
  134. layout_headers();
  135. }
  136. TableCellPaintingDelegate* AbstractTableView::column_painting_delegate(int column) const
  137. {
  138. // FIXME: This should return a const pointer I think..
  139. return const_cast<TableCellPaintingDelegate*>(m_column_painting_delegate.get(column).value_or(nullptr));
  140. }
  141. void AbstractTableView::set_column_painting_delegate(int column, OwnPtr<TableCellPaintingDelegate> delegate)
  142. {
  143. if (!delegate)
  144. m_column_painting_delegate.remove(column);
  145. else
  146. m_column_painting_delegate.set(column, move(delegate));
  147. }
  148. int AbstractTableView::column_width(int column_index) const
  149. {
  150. if (!model())
  151. return 0;
  152. return m_column_header->section_size(column_index);
  153. }
  154. void AbstractTableView::set_column_width(int column, int width)
  155. {
  156. column_header().set_section_size(column, width);
  157. }
  158. Gfx::TextAlignment AbstractTableView::column_header_alignment(int column_index) const
  159. {
  160. if (!model())
  161. return Gfx::TextAlignment::CenterLeft;
  162. return m_column_header->section_alignment(column_index);
  163. }
  164. void AbstractTableView::set_column_header_alignment(int column, Gfx::TextAlignment alignment)
  165. {
  166. column_header().set_section_alignment(column, alignment);
  167. }
  168. void AbstractTableView::mousedown_event(MouseEvent& event)
  169. {
  170. m_tab_moves = 0;
  171. if (!model())
  172. return AbstractView::mousedown_event(event);
  173. if (event.button() != MouseButton::Left)
  174. return AbstractView::mousedown_event(event);
  175. bool is_toggle;
  176. auto index = index_at_event_position(event.position(), is_toggle);
  177. if (index.is_valid() && is_toggle && model()->row_count(index)) {
  178. toggle_index(index);
  179. return;
  180. }
  181. AbstractView::mousedown_event(event);
  182. }
  183. ModelIndex AbstractTableView::index_at_event_position(const Gfx::IntPoint& position, bool& is_toggle) const
  184. {
  185. is_toggle = false;
  186. if (!model())
  187. return {};
  188. auto adjusted_position = this->adjusted_position(position);
  189. for (int row = 0, row_count = model()->row_count(); row < row_count; ++row) {
  190. if (!row_rect(row).contains(adjusted_position))
  191. continue;
  192. for (int column = 0, column_count = model()->column_count(); column < column_count; ++column) {
  193. if (!content_rect(row, column).contains(adjusted_position))
  194. continue;
  195. return model()->index(row, column);
  196. }
  197. return model()->index(row, 0);
  198. }
  199. return {};
  200. }
  201. ModelIndex AbstractTableView::index_at_event_position(const Gfx::IntPoint& position) const
  202. {
  203. bool is_toggle;
  204. auto index = index_at_event_position(position, is_toggle);
  205. return is_toggle ? ModelIndex() : index;
  206. }
  207. int AbstractTableView::item_count() const
  208. {
  209. if (!model())
  210. return 0;
  211. return model()->row_count();
  212. }
  213. void AbstractTableView::move_cursor_relative(int vertical_steps, int horizontal_steps, SelectionUpdate selection_update)
  214. {
  215. if (!model())
  216. return;
  217. auto& model = *this->model();
  218. ModelIndex new_index;
  219. if (cursor_index().is_valid()) {
  220. new_index = model.index(cursor_index().row() + vertical_steps, cursor_index().column() + horizontal_steps);
  221. } else {
  222. new_index = model.index(0, 0);
  223. }
  224. if (new_index.is_valid()) {
  225. set_cursor(new_index, selection_update);
  226. }
  227. }
  228. void AbstractTableView::scroll_into_view(const ModelIndex& index, bool scroll_horizontally, bool scroll_vertically)
  229. {
  230. Gfx::IntRect rect;
  231. switch (selection_behavior()) {
  232. case SelectionBehavior::SelectItems:
  233. rect = content_rect(index);
  234. break;
  235. case SelectionBehavior::SelectRows:
  236. rect = row_rect(index.row());
  237. break;
  238. }
  239. AbstractScrollableWidget::scroll_into_view(rect, scroll_horizontally, scroll_vertically);
  240. }
  241. void AbstractTableView::context_menu_event(ContextMenuEvent& event)
  242. {
  243. if (!model())
  244. return;
  245. bool is_toggle;
  246. auto index = index_at_event_position(event.position(), is_toggle);
  247. if (index.is_valid()) {
  248. if (!selection().contains(index))
  249. selection().set(index);
  250. } else {
  251. selection().clear();
  252. }
  253. if (on_context_menu_request)
  254. on_context_menu_request(index, event);
  255. }
  256. Gfx::IntRect AbstractTableView::content_rect(int row, int column) const
  257. {
  258. auto row_rect = this->row_rect(row);
  259. int x = 0;
  260. for (int i = 0; i < column; ++i)
  261. x += column_width(i) + horizontal_padding() * 2;
  262. return { row_rect.x() + x, row_rect.y(), column_width(column) + horizontal_padding() * 2, row_height() };
  263. }
  264. Gfx::IntRect AbstractTableView::content_rect(const ModelIndex& index) const
  265. {
  266. return content_rect(index.row(), index.column());
  267. }
  268. Gfx::IntRect AbstractTableView::row_rect(int item_index) const
  269. {
  270. return { row_header().is_visible() ? row_header().width() : 0,
  271. (column_header().is_visible() ? column_header().height() : 0) + (item_index * row_height()),
  272. max(content_size().width(), width()),
  273. row_height() };
  274. }
  275. Gfx::IntPoint AbstractTableView::adjusted_position(const Gfx::IntPoint& position) const
  276. {
  277. return position.translated(horizontal_scrollbar().value() - frame_thickness(), vertical_scrollbar().value() - frame_thickness());
  278. }
  279. void AbstractTableView::model_did_update(unsigned flags)
  280. {
  281. AbstractView::model_did_update(flags);
  282. update_row_sizes();
  283. update_column_sizes();
  284. update_content_size();
  285. update();
  286. }
  287. void AbstractTableView::resize_event(ResizeEvent& event)
  288. {
  289. AbstractView::resize_event(event);
  290. layout_headers();
  291. }
  292. void AbstractTableView::header_did_change_section_size(Badge<HeaderView>, Gfx::Orientation, int, int)
  293. {
  294. update_content_size();
  295. update();
  296. }
  297. void AbstractTableView::header_did_change_section_visibility(Badge<HeaderView>, Gfx::Orientation, int, bool)
  298. {
  299. update_content_size();
  300. update();
  301. }
  302. void AbstractTableView::set_default_column_width(int column, int width)
  303. {
  304. column_header().set_default_section_size(column, width);
  305. }
  306. void AbstractTableView::set_column_visible(int column, bool visible)
  307. {
  308. column_header().set_section_visible(column, visible);
  309. }
  310. void AbstractTableView::set_column_headers_visible(bool visible)
  311. {
  312. column_header().set_visible(visible);
  313. }
  314. void AbstractTableView::did_scroll()
  315. {
  316. AbstractView::did_scroll();
  317. layout_headers();
  318. }
  319. void AbstractTableView::layout_headers()
  320. {
  321. if (column_header().is_visible()) {
  322. int row_header_width = row_header().is_visible() ? row_header().width() : 0;
  323. int vertical_scrollbar_width = vertical_scrollbar().is_visible() ? vertical_scrollbar().width() : 0;
  324. int x = frame_thickness() + row_header_width - horizontal_scrollbar().value();
  325. int y = frame_thickness();
  326. int width = max(content_width(), rect().width() - frame_thickness() * 2 - row_header_width - vertical_scrollbar_width);
  327. column_header().set_relative_rect(x, y, width, column_header().min_size().height());
  328. }
  329. if (row_header().is_visible()) {
  330. int column_header_height = column_header().is_visible() ? column_header().height() : 0;
  331. int horizontal_scrollbar_height = horizontal_scrollbar().is_visible() ? horizontal_scrollbar().height() : 0;
  332. int x = frame_thickness();
  333. int y = frame_thickness() + column_header_height - vertical_scrollbar().value();
  334. int height = max(content_height(), rect().height() - frame_thickness() * 2 - column_header_height - horizontal_scrollbar_height);
  335. row_header().set_relative_rect(x, y, row_header().min_size().width(), height);
  336. }
  337. if (row_header().is_visible() && column_header().is_visible()) {
  338. m_corner_button->set_relative_rect(frame_thickness(), frame_thickness(), row_header().width(), column_header().height());
  339. m_corner_button->set_visible(true);
  340. } else {
  341. m_corner_button->set_visible(false);
  342. }
  343. }
  344. void AbstractTableView::keydown_event(KeyEvent& event)
  345. {
  346. if (is_tab_key_navigation_enabled()) {
  347. if (!event.modifiers() && event.key() == KeyCode::Key_Tab) {
  348. move_cursor(CursorMovement::Right, SelectionUpdate::Set);
  349. event.accept();
  350. ++m_tab_moves;
  351. return;
  352. } else if (is_navigation(event)) {
  353. if (event.key() == KeyCode::Key_Return) {
  354. move_cursor_relative(0, -m_tab_moves, SelectionUpdate::Set);
  355. }
  356. m_tab_moves = 0;
  357. }
  358. if (event.modifiers() == KeyModifier::Mod_Shift && event.key() == KeyCode::Key_Tab) {
  359. move_cursor(CursorMovement::Left, SelectionUpdate::Set);
  360. event.accept();
  361. return;
  362. }
  363. }
  364. AbstractView::keydown_event(event);
  365. }
  366. bool AbstractTableView::is_navigation(GUI::KeyEvent& event)
  367. {
  368. switch (event.key()) {
  369. case KeyCode::Key_Tab:
  370. case KeyCode::Key_Left:
  371. case KeyCode::Key_Right:
  372. case KeyCode::Key_Up:
  373. case KeyCode::Key_Down:
  374. case KeyCode::Key_Return:
  375. case KeyCode::Key_Home:
  376. case KeyCode::Key_End:
  377. case KeyCode::Key_PageUp:
  378. case KeyCode::Key_PageDown:
  379. return true;
  380. default:
  381. return false;
  382. }
  383. }
  384. }