src/curses/menu_impl.h

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2017 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #ifndef NCMPCPP_MENU_IMPL_H
  22 #define NCMPCPP_MENU_IMPL_H
  23
  24 #include "menu.h"
  25
  26 namespace NC {
  27
  28 template <typename ItemT>
  29 Menu<ItemT>::Menu()
  30 {
  31         m_items = &m_all_items;
  32 }
  33
  34 template <typename ItemT>
  35 Menu<ItemT>::Menu(size_t startx,
  36                   size_t starty,
  37                   size_t width,
  38                   size_t height,
  39                   const std::string &title,
  40                   Color color,
  41                   Border border)
  42         : Window(startx, starty, width, height, title, color, border)
  43         , m_item_displayer(nullptr)
  44         , m_filter_predicate(nullptr)
  45         , m_beginning(0)
  46         , m_highlight(0)
  47         , m_highlight_enabled(true)
  48         , m_cyclic_scroll_enabled(false)
  49         , m_autocenter_cursor(false)
  50 {
  51         auto fc = FormattedColor(m_base_color, {Format::Reverse});
  52         m_highlight_prefix << fc;
  53         m_highlight_suffix << FormattedColor::End<>(fc);
  54         m_items = &m_all_items;
  55 }
  56
  57 template <typename ItemT>
  58 Menu<ItemT>::Menu(const Menu &rhs)
  59         : Window(rhs)
  60         , m_item_displayer(rhs.m_item_displayer)
  61         , m_filter_predicate(rhs.m_filter_predicate)
  62         , m_beginning(rhs.m_beginning)
  63         , m_highlight(rhs.m_highlight)
  64         , m_highlight_enabled(rhs.m_highlight_enabled)
  65         , m_cyclic_scroll_enabled(rhs.m_cyclic_scroll_enabled)
  66         , m_autocenter_cursor(rhs.m_autocenter_cursor)
  67         , m_drawn_position(rhs.m_drawn_position)
  68         , m_highlight_prefix(rhs.m_highlight_prefix)
  69         , m_highlight_suffix(rhs.m_highlight_suffix)
  70         , m_selected_prefix(rhs.m_selected_prefix)
  71         , m_selected_suffix(rhs.m_selected_suffix)
  72 {
  73         // TODO: move filtered items
  74         m_all_items.reserve(rhs.m_all_items.size());
  75         for (const auto &item : rhs.m_all_items)
  76                 m_all_items.push_back(item.copy());
  77         m_items = &m_all_items;
  78 }
  79
  80 template <typename ItemT>
  81 Menu<ItemT>::Menu(Menu &&rhs)
  82         : Window(rhs)
  83         , m_item_displayer(std::move(rhs.m_item_displayer))
  84         , m_filter_predicate(std::move(rhs.m_filter_predicate))
  85         , m_all_items(std::move(rhs.m_all_items))
  86         , m_filtered_items(std::move(rhs.m_filtered_items))
  87         , m_beginning(rhs.m_beginning)
  88         , m_highlight(rhs.m_highlight)
  89         , m_highlight_enabled(rhs.m_highlight_enabled)
  90         , m_cyclic_scroll_enabled(rhs.m_cyclic_scroll_enabled)
  91         , m_autocenter_cursor(rhs.m_autocenter_cursor)
  92         , m_drawn_position(rhs.m_drawn_position)
  93         , m_highlight_prefix(std::move(rhs.m_highlight_prefix))
  94         , m_highlight_suffix(std::move(rhs.m_highlight_suffix))
  95         , m_selected_prefix(std::move(rhs.m_selected_prefix))
  96         , m_selected_suffix(std::move(rhs.m_selected_suffix))
  97 {
  98         if (rhs.m_items == &rhs.m_all_items)
  99                 m_items = &m_all_items;
 100         else
 101                 m_items = &m_filtered_items;
 102 }
 103
 104 template <typename ItemT>
 105 Menu<ItemT> &Menu<ItemT>::operator=(Menu rhs)
 106 {
 107         std::swap(static_cast<Window &>(*this), static_cast<Window &>(rhs));
 108         std::swap(m_item_displayer, rhs.m_item_displayer);
 109         std::swap(m_filter_predicate, rhs.m_filter_predicate);
 110         std::swap(m_all_items, rhs.m_all_items);
 111         std::swap(m_filtered_items, rhs.m_filtered_items);
 112         std::swap(m_beginning, rhs.m_beginning);
 113         std::swap(m_highlight, rhs.m_highlight);
 114         std::swap(m_highlight_enabled, rhs.m_highlight_enabled);
 115         std::swap(m_cyclic_scroll_enabled, rhs.m_cyclic_scroll_enabled);
 116         std::swap(m_autocenter_cursor, rhs.m_autocenter_cursor);
 117         std::swap(m_drawn_position, rhs.m_drawn_position);
 118         std::swap(m_highlight_prefix, rhs.m_highlight_prefix);
 119         std::swap(m_highlight_suffix, rhs.m_highlight_suffix);
 120         std::swap(m_selected_prefix, rhs.m_selected_prefix);
 121         std::swap(m_selected_suffix, rhs.m_selected_suffix);
 122         if (rhs.m_items == &rhs.m_all_items)
 123                 m_items = &m_all_items;
 124         else
 125                 m_items = &m_filtered_items;
 126         return *this;
 127 }
 128
 129 template <typename ItemT> template <typename ItemDisplayerT>
 130 void Menu<ItemT>::setItemDisplayer(ItemDisplayerT &&displayer)
 131 {
 132         m_item_displayer = std::forward<ItemDisplayerT>(displayer);
 133 }
 134
 135 template <typename ItemT>
 136 void Menu<ItemT>::resizeList(size_t new_size)
 137 {
 138         m_all_items.resize(new_size);
 139 }
 140
 141 template <typename ItemT>
 142 void Menu<ItemT>::addItem(ItemT item, Properties::Type properties)
 143 {
 144         m_all_items.push_back(Item(std::move(item), properties));
 145 }
 146
 147 template <typename ItemT>
 148 void Menu<ItemT>::addSeparator()
 149 {
 150         m_all_items.push_back(Item::mkSeparator());
 151 }
 152
 153 template <typename ItemT>
 154 void Menu<ItemT>::insertItem(size_t pos, ItemT item, Properties::Type properties)
 155 {
 156         m_all_items.insert(m_all_items.begin()+pos, Item(std::move(item), properties));
 157 }
 158
 159 template <typename ItemT>
 160 void Menu<ItemT>::insertSeparator(size_t pos)
 161 {
 162         m_all_items.insert(m_all_items.begin()+pos, Item::mkSeparator());
 163 }
 164
 165 template <typename ItemT>
 166 bool Menu<ItemT>::Goto(size_t y)
 167 {
 168         if (!isHighlightable(m_beginning+y))
 169                 return false;
 170         m_highlight = m_beginning+y;
 171         return true;
 172 }
 173
 174 template <typename ItemT>
 175 void Menu<ItemT>::refresh()
 176 {
 177         if (m_items->empty())
 178         {
 179                 Window::clear();
 180                 Window::refresh();
 181                 return;
 182         }
 183
 184         size_t max_beginning = 0;
 185         if (m_items->size() > m_height)
 186                 max_beginning = m_items->size() - m_height;
 187         m_beginning = std::min(m_beginning, max_beginning);
 188
 189         // if highlighted position is off the screen, make it visible
 190         m_highlight = std::min(m_highlight, m_beginning+m_height-1);
 191         // if highlighted position is invalid, correct it
 192         m_highlight = std::min(m_highlight, m_items->size()-1);
 193
 194         if (!isHighlightable(m_highlight))
 195         {
 196                 scroll(Scroll::Up);
 197                 if (!isHighlightable(m_highlight))
 198                         scroll(Scroll::Down);
 199         }
 200
 201         size_t line = 0;
 202         const size_t end_ = m_beginning+m_height;
 203         m_drawn_position = m_beginning;
 204         for (; m_drawn_position < end_; ++m_drawn_position, ++line)
 205         {
 206                 goToXY(0, line);
 207                 if (m_drawn_position >= m_items->size())
 208                 {
 209                         for (; line < m_height; ++line)
 210                                 mvwhline(m_window, line, 0, NC::Key::Space, m_width);
 211                         break;
 212                 }
 213                 if ((*m_items)[m_drawn_position].isSeparator())
 214                 {
 215                         mvwhline(m_window, line, 0, 0, m_width);
 216                         continue;
 217                 }
 218                 if (m_highlight_enabled && m_drawn_position == m_highlight)
 219                         *this << m_highlight_prefix;
 220                 if ((*m_items)[m_drawn_position].isSelected())
 221                         *this << m_selected_prefix;
 222                 *this << NC::TermManip::ClearToEOL;
 223                 if (m_item_displayer)
 224                         m_item_displayer(*this);
 225                 if ((*m_items)[m_drawn_position].isSelected())
 226                         *this << m_selected_suffix;
 227                 if (m_highlight_enabled && m_drawn_position == m_highlight)
 228                         *this << m_highlight_suffix;
 229         }
 230         Window::refresh();
 231 }
 232
 233 template <typename ItemT>
 234 void Menu<ItemT>::scroll(Scroll where)
 235 {
 236         if (m_items->empty())
 237                 return;
 238         size_t max_highlight = m_items->size()-1;
 239         size_t max_beginning = m_items->size() < m_height ? 0 : m_items->size()-m_height;
 240         size_t max_visible_highlight = m_beginning+m_height-1;
 241         switch (where)
 242         {
 243                 case Scroll::Up:
 244                 {
 245                         if (m_highlight <= m_beginning && m_highlight > 0)
 246                                 --m_beginning;
 247                         if (m_highlight == 0)
 248                         {
 249                                 if (m_cyclic_scroll_enabled)
 250                                         return scroll(Scroll::End);
 251                                 break;
 252                         }
 253                         else
 254                                 --m_highlight;
 255                         if (!isHighlightable(m_highlight))
 256                                 scroll(m_highlight == 0 && !m_cyclic_scroll_enabled ? Scroll::Down : Scroll::Up);
 257                         break;
 258                 }
 259                 case Scroll::Down:
 260                 {
 261                         if (m_highlight >= max_visible_highlight && m_highlight < max_highlight)
 262                                 ++m_beginning;
 263                         if (m_highlight == max_highlight)
 264                         {
 265                                 if (m_cyclic_scroll_enabled)
 266                                         return scroll(Scroll::Home);
 267                                 break;
 268                         }
 269                         else
 270                                 ++m_highlight;
 271                         if (!isHighlightable(m_highlight))
 272                                 scroll(m_highlight == max_highlight && !m_cyclic_scroll_enabled ? Scroll::Up : Scroll::Down);
 273                         break;
 274                 }
 275                 case Scroll::PageUp:
 276                 {
 277                         if (m_cyclic_scroll_enabled && m_highlight == 0)
 278                                 return scroll(Scroll::End);
 279                         if (m_highlight < m_height)
 280                                 m_highlight = 0;
 281                         else
 282                                 m_highlight -= m_height;
 283                         if (m_beginning < m_height)
 284                                 m_beginning = 0;
 285                         else
 286                                 m_beginning -= m_height;
 287                         if (!isHighlightable(m_highlight))
 288                                 scroll(m_highlight == 0 && !m_cyclic_scroll_enabled ? Scroll::Down : Scroll::Up);
 289                         break;
 290                 }
 291                 case Scroll::PageDown:
 292                 {
 293                         if (m_cyclic_scroll_enabled && m_highlight == max_highlight)
 294                                 return scroll(Scroll::Home);
 295                         m_highlight += m_height;
 296                         m_beginning += m_height;
 297                         m_beginning = std::min(m_beginning, max_beginning);
 298                         m_highlight = std::min(m_highlight, max_highlight);
 299                         if (!isHighlightable(m_highlight))
 300                                 scroll(m_highlight == max_highlight && !m_cyclic_scroll_enabled ? Scroll::Up : Scroll::Down);
 301                         break;
 302                 }
 303                 case Scroll::Home:
 304                 {
 305                         m_highlight = 0;
 306                         m_beginning = 0;
 307                         if (!isHighlightable(m_highlight))
 308                                 scroll(Scroll::Down);
 309                         break;
 310                 }
 311                 case Scroll::End:
 312                 {
 313                         m_highlight = max_highlight;
 314                         m_beginning = max_beginning;
 315                         if (!isHighlightable(m_highlight))
 316                                 scroll(Scroll::Up);
 317                         break;
 318                 }
 319         }
 320         if (m_autocenter_cursor)
 321                 highlight(m_highlight);
 322 }
 323
 324 template <typename ItemT>
 325 void Menu<ItemT>::reset()
 326 {
 327         m_highlight = 0;
 328         m_beginning = 0;
 329 }
 330
 331 template <typename ItemT>
 332 void Menu<ItemT>::clear()
 333 {
 334         // Don't clear filter related stuff here.
 335         m_all_items.clear();
 336         m_filtered_items.clear();
 337 }
 338
 339 template <typename ItemT>
 340 void Menu<ItemT>::highlight(size_t pos)
 341 {
 342         assert(pos < m_items->size());
 343         m_highlight = pos;
 344         size_t half_height = m_height/2;
 345         if (pos < half_height)
 346                 m_beginning = 0;
 347         else
 348                 m_beginning = pos-half_height;
 349 }
 350
 351 template <typename ItemT>
 352 size_t Menu<ItemT>::choice() const
 353 {
 354         assert(!empty());
 355         return m_highlight;
 356 }
 357
 358 template <typename ItemT> template <typename PredicateT>
 359 void Menu<ItemT>::applyFilter(PredicateT &&pred)
 360 {
 361         m_filter_predicate = std::forward<PredicateT>(pred);
 362         m_filtered_items.clear();
 363
 364         for (const auto &item : m_all_items)
 365                 if (m_filter_predicate(item))
 366                         m_filtered_items.push_back(item);
 367
 368         m_items = &m_filtered_items;
 369 }
 370
 371 template <typename ItemT>
 372 void Menu<ItemT>::reapplyFilter()
 373 {
 374         applyFilter(m_filter_predicate);
 375 }
 376
 377 template <typename ItemT> template <typename TargetT>
 378 const TargetT *Menu<ItemT>::filterPredicate() const
 379 {
 380         return m_filter_predicate.template target<TargetT>();
 381 }
 382
 383 template <typename ItemT>
 384 void Menu<ItemT>::clearFilter()
 385 {
 386         m_filter_predicate = nullptr;
 387         m_filtered_items.clear();
 388         m_items = &m_all_items;
 389 }
 390
 391 }
 392
 393 #endif // NCMPCPP_MENU_IMPL_H