src/menu.h

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2010 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 _MENU_H
  22 #define _MENU_H
  23
  24 #include <regex.h>
  25 #include <algorithm>
  26 #include <set>
  27
  28 #include "error.h"
  29 #include "window.h"
  30 #include "strbuffer.h"
  31
  32 namespace NCurses
  33 {
  34         /// List class is an interface for Menu class
  35         ///
  36         class List
  37         {
  38                 public:
  39                         /// @see Menu::Select()
  40                         ///
  41                         virtual void Select(int pos, bool state) = 0;
  42
  43                         /// @see Menu::isSelected()
  44                         ///
  45                         virtual bool isSelected(int pos = -1) const = 0;
  46
  47                         /// @see Menu::hasSelected()
  48                         ///
  49                         virtual bool hasSelected() const = 0;
  50
  51                         /// @see Menu::GetSelected()
  52                         ///
  53                         virtual void GetSelected(std::vector<size_t> &v) const = 0;
  54
  55                         /// Highlights given position
  56                         /// @param pos position to be highlighted
  57                         ///
  58                         virtual void Highlight(size_t pos) = 0;
  59
  60                         /// @return currently highlighted position
  61                         ///
  62                         virtual size_t Choice() const = 0;
  63
  64                         /// @see Menu::Empty()
  65                         ///
  66                         virtual bool Empty() const = 0;
  67
  68                         /// @see Menu::Size()
  69                         ///
  70                         virtual size_t Size() const = 0;
  71
  72                         /// @see Menu::Search()
  73                         ///
  74                         virtual bool Search(const std::string &constraint, size_t beginning = 0, int flags = 0) = 0;
  75
  76                         /// @see Menu::GetSearchConstraint()
  77                         ///
  78                         virtual const std::string &GetSearchConstraint() = 0;
  79
  80                         /// @see Menu::NextFound()
  81                         ///
  82                         virtual void NextFound(bool wrap) = 0;
  83
  84                         /// @see Menu::PrevFound()
  85                         ///
  86                         virtual void PrevFound(bool wrap) = 0;
  87
  88                         /// @see Menu::ApplyFilter()
  89                         ///
  90                         virtual void ApplyFilter(const std::string &filter, size_t beginning = 0, int flags = 0) = 0;
  91
  92                         /// @see Menu::GetFilter()
  93                         ///
  94                         virtual const std::string &GetFilter() = 0;
  95
  96                         /// @see Menu::isFiltered()
  97                         ///
  98                         virtual bool isFiltered() = 0;
  99         };
 100
 101         /// This template class is generic menu, that has holds
 102         /// any values that are std::vector compatible.
 103         ///
 104         template <typename T> class Menu : public Window, public List
 105         {
 106                 /// Function helper prototype used to display each option on the screen.
 107                 /// If not set by SetItemDisplayer(), menu won't display anything.
 108                 /// @see SetItemDisplayer()
 109                 ///
 110                 typedef void (*ItemDisplayer)(const T &, void *, Menu<T> *);
 111
 112                 /// Function helper prototype used for converting items to strings.
 113                 /// If not set by SetGetStringFunction(), searching and filtering
 114                 /// won't work (note that Menu<std::string> doesn't need this)
 115                 /// @see SetGetStringFunction()
 116                 ///
 117                 typedef std::string (*GetStringFunction)(const T &, void *);
 118
 119                 /// Struct that holds each item in the list and its attributes
 120                 ///
 121                 struct Option
 122                 {
 123                         Option() : isBold(0), isSelected(0), isStatic(0) { }
 124                         Option(const T &t, bool is_bold, bool is_static) :
 125                         Item(t), isBold(is_bold), isSelected(0), isStatic(is_static) { }
 126
 127                         T Item;
 128                         bool isBold;
 129                         bool isSelected;
 130                         bool isStatic;
 131                 };
 132
 133                 /// Functor that wraps around the functor passed to Sort()
 134                 /// to fit to internal container structure
 135                 ///
 136                 template <typename Comparison> class InternalSorting
 137                 {
 138                         Comparison cmp;
 139
 140                         public:
 141                                 bool operator()(Option *a, Option *b)
 142                                 {
 143                                         return cmp(a->Item, b->Item);
 144                                 }
 145                 };
 146
 147                 typedef typename std::vector<Option *>::iterator option_iterator;
 148                 typedef typename std::vector<Option *>::const_iterator option_const_iterator;
 149
 150                 public:
 151
 152                         /// Constructs an empty menu with given parameters
 153                         /// @param startx X position of left upper corner of constructed menu
 154                         /// @param starty Y position of left upper corner of constructed menu
 155                         /// @param width width of constructed menu
 156                         /// @param height height of constructed menu
 157                         /// @param title title of constructed menu
 158                         /// @param color base color of constructed menu
 159                         /// @param border border of constructed menu
 160                         ///
 161                         Menu(size_t startx, size_t starty, size_t width, size_t height,
 162                              const std::string &title, Color color, Border border);
 163
 164                         /// Copies the menu
 165                         /// @param m copied menu
 166                         ///
 167                         Menu(const Menu &m);
 168
 169                         /// Destroys the object and frees memory
 170                         ///
 171                         virtual ~Menu();
 172
 173                         /// Sets helper function that is responsible for displaying items
 174                         /// @param ptr function pointer that matches the ItemDisplayer prototype
 175                         ///
 176                         void SetItemDisplayer(ItemDisplayer ptr) { itsItemDisplayer = ptr; }
 177
 178                         /// Sets optional user data, that is passed to
 179                         /// ItemDisplayer function each time it's invoked
 180                         /// @param data void pointer to userdata
 181                         ///
 182                         void SetItemDisplayerUserData(void *data) { itsItemDisplayerUserdata = data; }
 183
 184                         /// Sets helper function that is responsible for converting items to strings
 185                         /// @param f function pointer that matches the GetStringFunction prototype
 186                         ///
 187                         void SetGetStringFunction(GetStringFunction f) { itsGetStringFunction = f; }
 188
 189                         /// Sets optional user data, that is passed to
 190                         /// GetStringFunction function each time it's invoked
 191                         /// @param data void pointer to user data
 192                         ///
 193                         void SetGetStringFunctionUserData(void *data) { itsGetStringFunctionUserData = data; }
 194
 195                         /// Reserves the size for internal container (this just calls std::vector::reserve())
 196                         /// @param size requested size
 197                         ///
 198                         void Reserve(size_t size);
 199
 200                         /// Resizes the list to given size (adequate to std::vector::resize())
 201                         /// @param size requested size
 202                         ///
 203                         void ResizeList(size_t size);
 204
 205                         /// Adds new option to list
 206                         /// @param item object that has to be added
 207                         /// @param is_bold defines the initial state of bold attribute
 208                         /// @param is_static defines the initial state of static attribute
 209                         ///
 210                         void AddOption(const T &item, bool is_bold = 0, bool is_static = 0);
 211
 212                         /// Adds separator to list
 213                         ///
 214                         void AddSeparator();
 215
 216                         /// Inserts new option to list at given position
 217                         /// @param pos initial position of inserted item
 218                         /// @param item object that has to be inserted
 219                         /// @param is_bold defines the initial state of bold attribute
 220                         /// @param is_static defines the initial state of static attribute
 221                         ///
 222                         void InsertOption(size_t pos, const T &Item, bool is_bold = 0, bool is_static = 0);
 223
 224                         /// Inserts separator to list at given position
 225                         /// @param pos initial position of inserted separator
 226                         ///
 227                         void InsertSeparator(size_t pos);
 228
 229                         /// Deletes item from given position
 230                         /// @param pos given position of item to be deleted
 231                         ///
 232                         void DeleteOption(size_t pos);
 233
 234                         /// Converts the option into separator
 235                         /// @param pos position of item to be converted
 236                         ///
 237                         void IntoSeparator(size_t pos);
 238
 239                         /// Swaps the content of two items
 240                         /// @param one position of first item
 241                         /// @param two position of second item
 242                         ///
 243                         void Swap(size_t one, size_t two);
 244
 245                         /// Moves requested item from one position to another
 246                         /// @param from the position of item that has to be moved
 247                         /// @param to the position that indicates where the object has to be moved
 248                         ///
 249                         void Move(size_t from, size_t to);
 250
 251                         /// Moves the highlighted position to the given line of window
 252                         /// @param y Y position of menu window to be highlighted
 253                         /// @return true if the position is reachable, false otherwise
 254                         ///
 255                         bool Goto(size_t y);
 256
 257                         /// Checks if the given position has bold attribute set.
 258                         /// @param pos position to be checked. -1 = currently highlighted position
 259                         /// @return true if the bold is set, false otherwise
 260                         ///
 261                         bool isBold(int pos = -1);
 262
 263                         /// Sets bols attribute for given position
 264                         /// @param pos position of item to be bolded/unbolded
 265                         /// @param state state of bold attribute
 266                         ///
 267                         void Bold(int pos, bool state);
 268
 269                         /// Makes given position static/active.
 270                         /// Static positions cannot be highlighted.
 271                         /// @param pos position in list
 272                         /// @param state state of activity
 273                         ///
 274                         void Static(int pos, bool state);
 275
 276                         /// Checks whether given position is static or active
 277                         /// @param pos position to be checked, -1 checks currently highlighted position
 278                         /// @return true if position is static, false otherwise
 279                         ///
 280                         bool isStatic(int pos = -1) const;
 281
 282                         /// Selects/deselects given position
 283                         /// @param pos position in list
 284                         /// @param state state of selection
 285                         ///
 286                         virtual void Select(int pos, bool state);
 287
 288                         /// Checks if given position is selected
 289                         /// @param pos position to be checked, -1 checks currently highlighted position
 290                         /// @return true if position is selected, false otherwise
 291                         ///
 292                         virtual bool isSelected(int pos = -1) const;
 293
 294                         /// Checks whether list contains selected positions
 295                         /// @return true if it contains them, false otherwise
 296                         ///
 297                         virtual bool hasSelected() const;
 298
 299                         /// Gets positions of items that are selected
 300                         /// @param v vector to be filled with selected positions numbers
 301                         ///
 302                         virtual void GetSelected(std::vector<size_t> &v) const;
 303
 304                         /// Reverses selection of all items in list
 305                         /// @param beginning beginning of range that has to be reversed
 306                         ///
 307                         void ReverseSelection(size_t beginning = 0);
 308
 309                         /// Highlights given position
 310                         /// @param pos position to be highlighted
 311                         ///
 312                         void Highlight(size_t pos);
 313
 314                         /// @return currently highlighted position
 315                         ///
 316                         size_t Choice() const;
 317
 318                         /// @return real current positions, i.e it doesn't
 319                         /// count positions that are static or separators
 320                         ///
 321                         size_t RealChoice() const;
 322
 323                         /// Searches the list for a given contraint. It uses GetStringFunction to convert stored items
 324                         /// into strings and then performs pattern matching. Note that this supports regular expressions.
 325                         /// @param constraint a search constraint to be used
 326                         /// @param beginning beginning of range that has to be searched through
 327                         /// @param flags regex flags (REG_EXTENDED, REG_ICASE, REG_NOSUB, REG_NEWLINE)
 328                         /// @return true if at least one item matched the given pattern, false otherwise
 329                         ///
 330                         virtual bool Search(const std::string &constraint, size_t beginning = 0, int flags = 0);
 331
 332                         /// @return const reference to currently used search constraint
 333                         ///
 334                         virtual const std::string &GetSearchConstraint() { return itsSearchConstraint; }
 335
 336                         /// Moves current position in the list to the next found one
 337                         /// @param wrap if true, this function will go to the first
 338                         /// found pos after the last one, otherwise it'll do nothing.
 339                         ///
 340                         virtual void NextFound(bool wrap);
 341
 342                         /// Moves current position in the list to the previous found one
 343                         /// @param wrap if true, this function will go to the last
 344                         /// found pos after the first one, otherwise it'll do nothing.
 345                         ///
 346                         virtual void PrevFound(bool wrap);
 347
 348                         /// Filters the list, showing only the items that matches the pattern. It uses
 349                         /// GetStringFunction to convert stored items into strings and then performs
 350                         /// pattern matching. Note that this supports regular expressions.
 351                         /// @param filter a pattern to be used in pattern matching
 352                         /// @param beginning beginning of range that has to be filtered
 353                         /// @param flags regex flags (REG_EXTENDED, REG_ICASE, REG_NOSUB, REG_NEWLINE)
 354                         ///
 355                         virtual void ApplyFilter(const std::string &filter, size_t beginning = 0, int flags = 0);
 356
 357                         /// @return const reference to currently used filter
 358                         ///
 359                         virtual const std::string &GetFilter();
 360
 361                         /// @return true if list is currently filtered, false otherwise
 362                         ///
 363                         virtual bool isFiltered() { return itsOptionsPtr == &itsFilteredOptions; }
 364
 365                         /// Turns off filtering
 366                         ///
 367                         void ShowAll() { itsOptionsPtr = &itsOptions; }
 368
 369                         /// Turns on filtering
 370                         ///
 371                         void ShowFiltered() { itsOptionsPtr = &itsFilteredOptions; }
 372
 373                         /// Converts given position in list to string using GetStringFunction
 374                         /// if specified and an empty string otherwise
 375                         /// @param pos position to be converted
 376                         /// @return item converted to string
 377                         /// @see SetItemDisplayer()
 378                         ///
 379                         std::string GetOption(size_t pos);
 380
 381                         /// Refreshes the menu window
 382                         /// @see Window::Refresh()
 383                         ///
 384                         virtual void Refresh();
 385
 386                         /// Scrolls by given amount of lines
 387                         /// @param where indicated where exactly one wants to go
 388                         /// @see Window::Scroll()
 389                         ///
 390                         virtual void Scroll(Where where);
 391
 392                         /// Cleares all options, used filters etc. It doesn't reset highlighted position though.
 393                         /// @see Reset()
 394                         ///
 395                         virtual void Clear();
 396
 397                         /// Sets the highlighted position to 0
 398                         ///
 399                         void Reset();
 400
 401                         /// Sorts all items using Comparison object with defined operator()
 402                         /// @param beginning beginning of range that has to be sorted
 403                         ///
 404                         template <typename Comparison> void Sort(size_t beginning = 0, size_t end = -1)
 405                         {
 406                                 if (itsOptions.empty())
 407                                         return;
 408                                 sort(itsOptions.begin()+beginning, end == size_t(-1) ? itsOptions.end() : itsOptions.begin()+end, InternalSorting<Comparison>());
 409                                 if (isFiltered())
 410                                         ApplyFilter(itsFilter);
 411                         }
 412
 413                         /// Sets prefix, that is put before each selected item to indicate its selection
 414                         /// Note that the passed variable is not deleted along with menu object.
 415                         /// @param b pointer to buffer that contains the prefix
 416                         ///
 417                         void SetSelectPrefix(Buffer *b) { itsSelectedPrefix = b; }
 418
 419                         /// Sets suffix, that is put after each selected item to indicate its selection
 420                         /// Note that the passed variable is not deleted along with menu object.
 421                         /// @param b pointer to buffer that contains the suffix
 422                         ///
 423                         void SetSelectSuffix(Buffer *b) { itsSelectedSuffix = b; }
 424
 425                         /// Sets custom color of highlighted position
 426                         /// @param col custom color
 427                         ///
 428                         void HighlightColor(Color color) { itsHighlightColor = color; }
 429
 430                         /// @return state of highlighting
 431                         ///
 432                         bool isHighlighted() { return highlightEnabled; }
 433
 434                         /// Turns on/off highlighting
 435                         /// @param state state of hihglighting
 436                         ///
 437                         void Highlighting(bool state) { highlightEnabled = state; }
 438
 439                         /// Turns on/off cyclic scrolling
 440                         /// @param state state of cyclic scrolling
 441                         ///
 442                         void CyclicScrolling(bool state) { useCyclicScrolling = state; }
 443
 444                         /// Turns on/off centered cursor
 445                         /// @param state state of centered cursor
 446                         ///
 447                         void CenteredCursor(bool state) { useCenteredCursor = state; }
 448
 449                         /// Checks if list is empty
 450                         /// @return true if list is empty, false otherwise
 451                         ///
 452                         virtual bool Empty() const { return itsOptionsPtr->empty(); }
 453
 454                         /// @return size of the list
 455                         ///
 456                         virtual size_t Size() const;
 457
 458                         /// @return position of currently drawed item. The result is
 459                         /// defined only within drawing function that is called by Refresh()
 460                         /// @see Refresh()
 461                         ///
 462                         size_t CurrentlyDrawedPosition() const { return itsCurrentlyDrawedPosition; }
 463
 464                         /// @return reference to last item on the list
 465                         /// @throw List::InvalidItem if requested item is separator
 466                         ///
 467                         T &Back();
 468
 469                         /// @return const reference to last item on the list
 470                         /// @throw List::InvalidItem if requested item is separator
 471                         ///
 472                         const T &Back() const;
 473
 474                         /// @return reference to curently highlighted object
 475                         /// @throw List::InvalidItem if requested item is separator
 476                         ///
 477                         T &Current();
 478
 479                         /// @return const reference to curently highlighted object
 480                         /// @throw List::InvalidItem if requested item is separator
 481                         ///
 482                         const T &Current() const;
 483
 484                         /// @param pos requested position
 485                         /// @return reference to item at given position
 486                         /// @throw std::out_of_range if given position is out of range
 487                         /// @throw List::InvalidItem if requested item is separator
 488                         ///
 489                         T &at(size_t pos);
 490
 491                         /// @param pos requested position
 492                         /// @return const reference to item at given position
 493                         /// @throw std::out_of_range if given position is out of range
 494                         /// @throw List::InvalidItem if requested item is separator
 495                         ///
 496                         const T &at(size_t pos) const;
 497
 498                         /// @param pos requested position
 499                         /// @return const reference to item at given position
 500                         /// @throw List::InvalidItem if requested item is separator
 501                         ///
 502                         const T &operator[](size_t pos) const;
 503
 504                         /// @param pos requested position
 505                         /// @return const reference to item at given position
 506                         /// @throw List::InvalidItem if requested item is separator
 507                         ///
 508                         T &operator[](size_t pos);
 509
 510                 protected:
 511                         /// Clears filter, filtered data etc.
 512                         ///
 513                         void ClearFiltered();
 514
 515                         ItemDisplayer itsItemDisplayer;
 516                         void *itsItemDisplayerUserdata;
 517                         GetStringFunction itsGetStringFunction;
 518                         void *itsGetStringFunctionUserData;
 519
 520                         std::string itsFilter;
 521                         std::string itsSearchConstraint;
 522
 523                         std::vector<Option *> *itsOptionsPtr;
 524                         std::vector<Option *> itsOptions;
 525                         std::vector<Option *> itsFilteredOptions;
 526                         std::vector<size_t> itsFilteredRealPositions;
 527                         std::set<size_t> itsFound;
 528
 529                         int itsBeginning;
 530                         int itsHighlight;
 531
 532                         Color itsHighlightColor;
 533                         bool highlightEnabled;
 534                         bool useCyclicScrolling;
 535
 536                         bool useCenteredCursor;
 537
 538                         size_t itsCurrentlyDrawedPosition;
 539
 540                         Buffer *itsSelectedPrefix;
 541                         Buffer *itsSelectedSuffix;
 542         };
 543
 544         /// Specialization of Menu<T>::GetOption for T = std::string, it's obvious
 545         /// that if strings are stored, we don't need extra function to convert
 546         /// them to strings by default
 547         template <> std::string Menu<std::string>::GetOption(size_t pos);
 548 }
 549
 550 template <typename T> NCurses::Menu<T>::Menu(size_t startx,
 551                                         size_t starty,
 552                                         size_t width,
 553                                         size_t height,
 554                                         const std::string &title,
 555                                         Color color,
 556                                         Border border)
 557                                         : Window(startx, starty, width, height, title, color, border),
 558                                         itsItemDisplayer(0),
 559                                         itsItemDisplayerUserdata(0),
 560                                         itsGetStringFunction(0),
 561                                         itsGetStringFunctionUserData(0),
 562                                         itsOptionsPtr(&itsOptions),
 563                                         itsBeginning(0),
 564                                         itsHighlight(0),
 565                                         itsHighlightColor(itsBaseColor),
 566                                         highlightEnabled(1),
 567                                         useCyclicScrolling(0),
 568                                         useCenteredCursor(0),
 569                                         itsSelectedPrefix(0),
 570                                         itsSelectedSuffix(0)
 571 {
 572 }
 573
 574 template <typename T> NCurses::Menu<T>::Menu(const Menu &m) : Window(m),
 575                                         itsItemDisplayer(m.itsItemDisplayer),
 576                                         itsItemDisplayerUserdata(m.itsItemDisplayerUserdata),
 577                                         itsGetStringFunction(m.itsGetStringFunction),
 578                                         itsGetStringFunctionUserData(m.itsGetStringFunctionUserData),
 579                                         itsOptionsPtr(m.itsOptionsPtr),
 580                                         itsBeginning(m.itsBeginning),
 581                                         itsHighlight(m.itsHighlight),
 582                                         itsHighlightColor(m.itsHighlightColor),
 583                                         highlightEnabled(m.highlightEnabled),
 584                                         useCyclicScrolling(m.useCyclicScrolling),
 585                                         useCenteredCursor(m.useCenteredCursor),
 586                                         itsSelectedPrefix(m.itsSelectedPrefix),
 587                                         itsSelectedSuffix(m.itsSelectedSuffix)
 588 {
 589         itsOptions.reserve(m.itsOptions.size());
 590         for (option_const_iterator it = m.itsOptions.begin(); it != m.itsOptions.end(); ++it)
 591                 itsOptions.push_back(new Option(**it));
 592 }
 593
 594 template <typename T> NCurses::Menu<T>::~Menu()
 595 {
 596         for (option_iterator it = itsOptions.begin(); it != itsOptions.end(); ++it)
 597                 delete *it;
 598 }
 599
 600 template <typename T> void NCurses::Menu<T>::Reserve(size_t size)
 601 {
 602         itsOptions.reserve(size);
 603 }
 604
 605 template <typename T> void NCurses::Menu<T>::ResizeList(size_t size)
 606 {
 607         if (size > itsOptions.size())
 608         {
 609                 itsOptions.resize(size);
 610                 for (size_t i = 0; i < size; ++i)
 611                         if (!itsOptions[i])
 612                                 itsOptions[i] = new Option();
 613         }
 614         else if (size < itsOptions.size())
 615         {
 616                 for (size_t i = size; i < itsOptions.size(); ++i)
 617                         delete itsOptions[i];
 618                 itsOptions.resize(size);
 619         }
 620 }
 621
 622 template <typename T> void NCurses::Menu<T>::AddOption(const T &item, bool is_bold, bool is_static)
 623 {
 624         itsOptions.push_back(new Option(item, is_bold, is_static));
 625 }
 626
 627 template <typename T> void NCurses::Menu<T>::AddSeparator()
 628 {
 629         itsOptions.push_back(static_cast<Option *>(0));
 630 }
 631
 632 template <typename T> void NCurses::Menu<T>::InsertOption(size_t pos, const T &item, bool is_bold, bool is_static)
 633 {
 634         itsOptions.insert(itsOptions.begin()+pos, new Option(item, is_bold, is_static));
 635 }
 636
 637 template <typename T> void NCurses::Menu<T>::InsertSeparator(size_t pos)
 638 {
 639         itsOptions.insert(itsOptions.begin()+pos, 0);
 640 }
 641
 642 template <typename T> void NCurses::Menu<T>::DeleteOption(size_t pos)
 643 {
 644         if (itsOptionsPtr->empty())
 645                 return;
 646         if (itsOptionsPtr == &itsFilteredOptions)
 647         {
 648                 delete itsOptions.at(itsFilteredRealPositions[pos]);
 649                 itsOptions.erase(itsOptions.begin()+itsFilteredRealPositions[pos]);
 650                 itsFilteredOptions.erase(itsFilteredOptions.begin()+pos);
 651                 itsFilteredRealPositions.erase(itsFilteredRealPositions.begin()+pos);
 652                 for (size_t i = pos; i < itsFilteredRealPositions.size(); ++i)
 653                         itsFilteredRealPositions[i]--;
 654         }
 655         else
 656         {
 657                 delete itsOptions.at(pos);
 658                 itsOptions.erase(itsOptions.begin()+pos);
 659         }
 660         itsFound.clear();
 661         if (itsOptionsPtr->empty())
 662                 Window::Clear();
 663 }
 664
 665 template <typename T> void NCurses::Menu<T>::IntoSeparator(size_t pos)
 666 {
 667         delete itsOptionsPtr->at(pos);
 668         (*itsOptionsPtr)[pos] = 0;
 669 }
 670
 671 template <typename T> void NCurses::Menu<T>::Bold(int pos, bool state)
 672 {
 673         if (!itsOptionsPtr->at(pos))
 674                 return;
 675         (*itsOptionsPtr)[pos]->isBold = state;
 676 }
 677
 678 template <typename T> void NCurses::Menu<T>::Swap(size_t one, size_t two)
 679 {
 680         std::swap(itsOptions.at(one), itsOptions.at(two));
 681 }
 682
 683 template <typename T> void NCurses::Menu<T>::Move(size_t from, size_t to)
 684 {
 685         int diff = from-to;
 686         if (diff > 0)
 687         {
 688                 for (size_t i = from; i > to; --i)
 689                         std::swap(itsOptions.at(i), itsOptions.at(i-1));
 690         }
 691         else if (diff < 0)
 692         {
 693                 for (size_t i = from; i < to; ++i)
 694                         std::swap(itsOptions.at(i), itsOptions.at(i+1));
 695         }
 696 }
 697
 698 template <typename T> bool NCurses::Menu<T>::Goto(size_t y)
 699 {
 700         if (!itsOptionsPtr->at(itsBeginning+y) || itsOptionsPtr->at(itsBeginning+y)->isStatic)
 701                 return false;
 702         itsHighlight = itsBeginning+y;
 703         return true;
 704 }
 705
 706 template <typename T> void NCurses::Menu<T>::Refresh()
 707 {
 708         if (itsOptionsPtr->empty())
 709         {
 710                 Window::Refresh();
 711                 return;
 712         }
 713         int MaxBeginning = itsOptionsPtr->size() < itsHeight ? 0 : itsOptionsPtr->size()-itsHeight;
 714
 715         if (itsBeginning < itsHighlight-int(itsHeight)+1) // highlighted position is off the screen
 716                 itsBeginning = itsHighlight-itsHeight+1;
 717
 718         if (itsBeginning < 0)
 719                 itsBeginning = 0;
 720         else if (itsBeginning > MaxBeginning)
 721                 itsBeginning = MaxBeginning;
 722
 723         if (!itsOptionsPtr->empty() && itsHighlight > int(itsOptionsPtr->size())-1)
 724                 itsHighlight = itsOptionsPtr->size()-1;
 725
 726         if (!(*itsOptionsPtr)[itsHighlight] || (*itsOptionsPtr)[itsHighlight]->isStatic) // it shouldn't be here
 727         {
 728                 Scroll(wUp);
 729                 if (!(*itsOptionsPtr)[itsHighlight] || (*itsOptionsPtr)[itsHighlight]->isStatic)
 730                         Scroll(wDown);
 731         }
 732
 733         size_t line = 0;
 734         for (size_t &i = (itsCurrentlyDrawedPosition = itsBeginning); i < itsBeginning+itsHeight; ++i)
 735         {
 736                 GotoXY(0, line);
 737                 if (i >= itsOptionsPtr->size())
 738                 {
 739                         for (; line < itsHeight; ++line)
 740                                 mvwhline(itsWindow, line, 0, 32, itsWidth);
 741                         break;
 742                 }
 743                 if (!(*itsOptionsPtr)[i]) // separator
 744                 {
 745                         mvwhline(itsWindow, line++, 0, 0, itsWidth);
 746                         continue;
 747                 }
 748                 if ((*itsOptionsPtr)[i]->isBold)
 749                         *this << fmtBold;
 750                 if (highlightEnabled && int(i) == itsHighlight)
 751                 {
 752                         *this << fmtReverse;
 753                         *this << itsHighlightColor;
 754                 }
 755                 mvwhline(itsWindow, line, 0, 32, itsWidth);
 756                 if ((*itsOptionsPtr)[i]->isSelected && itsSelectedPrefix)
 757                         *this << *itsSelectedPrefix;
 758                 if (itsItemDisplayer)
 759                         itsItemDisplayer((*itsOptionsPtr)[i]->Item, itsItemDisplayerUserdata, this);
 760                 if ((*itsOptionsPtr)[i]->isSelected && itsSelectedSuffix)
 761                         *this << *itsSelectedSuffix;
 762                 if (highlightEnabled && int(i) == itsHighlight)
 763                 {
 764                         *this << clEnd;
 765                         *this << fmtReverseEnd;
 766                 }
 767                 if ((*itsOptionsPtr)[i]->isBold)
 768                         *this << fmtBoldEnd;
 769                 line++;
 770         }
 771         Window::Refresh();
 772 }
 773
 774 template <typename T> void NCurses::Menu<T>::Scroll(Where where)
 775 {
 776         if (itsOptionsPtr->empty())
 777                 return;
 778         int MaxHighlight = itsOptionsPtr->size()-1;
 779         int MaxBeginning = itsOptionsPtr->size() < itsHeight ? 0 : itsOptionsPtr->size()-itsHeight;
 780         int MaxCurrentHighlight = itsBeginning+itsHeight-1;
 781         switch (where)
 782         {
 783                 case wUp:
 784                 {
 785                         if (itsHighlight <= itsBeginning && itsHighlight > 0)
 786                         {
 787                                 itsBeginning--;
 788                         }
 789                         if (itsHighlight == 0)
 790                         {
 791                                 if (useCyclicScrolling)
 792                                         return Scroll(wEnd);
 793                                 break;
 794                         }
 795                         else
 796                         {
 797                                 itsHighlight--;
 798                         }
 799                         if (!(*itsOptionsPtr)[itsHighlight] || (*itsOptionsPtr)[itsHighlight]->isStatic)
 800                         {
 801                                 Scroll(itsHighlight == 0 && !useCyclicScrolling ? wDown : wUp);
 802                         }
 803                         break;
 804                 }
 805                 case wDown:
 806                 {
 807                         if (itsHighlight >= MaxCurrentHighlight && itsHighlight < MaxHighlight)
 808                         {
 809                                 itsBeginning++;
 810                         }
 811                         if (itsHighlight == MaxHighlight)
 812                         {
 813                                 if (useCyclicScrolling)
 814                                         return Scroll(wHome);
 815                                 break;
 816                         }
 817                         else
 818                         {
 819                                 itsHighlight++;
 820                         }
 821                         if (!(*itsOptionsPtr)[itsHighlight] || (*itsOptionsPtr)[itsHighlight]->isStatic)
 822                         {
 823                                 Scroll(itsHighlight == MaxHighlight && !useCyclicScrolling ? wUp : wDown);
 824                         }
 825                         break;
 826                 }
 827                 case wPageUp:
 828                 {
 829                         if (useCyclicScrolling && itsHighlight == 0)
 830                                 return Scroll(wEnd);
 831                         itsHighlight -= itsHeight;
 832                         itsBeginning -= itsHeight;
 833                         if (itsBeginning < 0)
 834                         {
 835                                 itsBeginning = 0;
 836                                 if (itsHighlight < 0)
 837                                         itsHighlight = 0;
 838                         }
 839                         if (!(*itsOptionsPtr)[itsHighlight] || (*itsOptionsPtr)[itsHighlight]->isStatic)
 840                         {
 841                                 Scroll(itsHighlight == 0 && !useCyclicScrolling ? wDown : wUp);
 842                         }
 843                         break;
 844                 }
 845                 case wPageDown:
 846                 {
 847                         if (useCyclicScrolling && itsHighlight == MaxHighlight)
 848                                 return Scroll(wHome);
 849                         itsHighlight += itsHeight;
 850                         itsBeginning += itsHeight;
 851                         if (itsBeginning > MaxBeginning)
 852                         {
 853                                 itsBeginning = MaxBeginning;
 854                                 if (itsHighlight > MaxHighlight)
 855                                         itsHighlight = MaxHighlight;
 856                         }
 857                         if (!(*itsOptionsPtr)[itsHighlight] || (*itsOptionsPtr)[itsHighlight]->isStatic)
 858                         {
 859                                 Scroll(itsHighlight == MaxHighlight && !useCyclicScrolling ? wUp : wDown);
 860                         }
 861                         break;
 862                 }
 863                 case wHome:
 864                 {
 865                         itsHighlight = 0;
 866                         itsBeginning = 0;
 867                         if (!(*itsOptionsPtr)[itsHighlight] || (*itsOptionsPtr)[itsHighlight]->isStatic)
 868                         {
 869                                 Scroll(itsHighlight == 0 ? wDown : wUp);
 870                         }
 871                         break;
 872                 }
 873                 case wEnd:
 874                 {
 875                         itsHighlight = MaxHighlight;
 876                         itsBeginning = MaxBeginning;
 877                         if (!(*itsOptionsPtr)[itsHighlight] || (*itsOptionsPtr)[itsHighlight]->isStatic)
 878                         {
 879                                 Scroll(itsHighlight == MaxHighlight ? wUp : wDown);
 880                         }
 881                         break;
 882                 }
 883         }
 884         if (useCenteredCursor)
 885                 Highlight(itsHighlight);
 886 }
 887
 888 template <typename T> void NCurses::Menu<T>::Reset()
 889 {
 890         itsHighlight = 0;
 891         itsBeginning = 0;
 892 }
 893
 894 template <typename T> void NCurses::Menu<T>::ClearFiltered()
 895 {
 896         itsFilteredOptions.clear();
 897         itsFilteredRealPositions.clear();
 898         itsOptionsPtr = &itsOptions;
 899 }
 900
 901 template <typename T> void NCurses::Menu<T>::Clear()
 902 {
 903         for (option_iterator it = itsOptions.begin(); it != itsOptions.end(); ++it)
 904                 delete *it;
 905         itsOptions.clear();
 906         itsFound.clear();
 907         itsFilter.clear();
 908         ClearFiltered();
 909         itsOptionsPtr = &itsOptions;
 910         Window::Clear();
 911 }
 912
 913 template <typename T> bool NCurses::Menu<T>::isBold(int pos)
 914 {
 915         pos = pos == -1 ? itsHighlight : pos;
 916         if (!itsOptionsPtr->at(pos))
 917                 return 0;
 918         return (*itsOptionsPtr)[pos]->isBold;
 919 }
 920
 921 template <typename T> void NCurses::Menu<T>::Select(int pos, bool state)
 922 {
 923         if (!itsOptionsPtr->at(pos))
 924                 return;
 925         (*itsOptionsPtr)[pos]->isSelected = state;
 926 }
 927
 928 template <typename T> void NCurses::Menu<T>::Static(int pos, bool state)
 929 {
 930         if (!itsOptionsPtr->at(pos))
 931                 return;
 932         (*itsOptionsPtr)[pos]->isStatic = state;
 933 }
 934
 935 template <typename T> bool NCurses::Menu<T>::isSelected(int pos) const
 936 {
 937         pos = pos == -1 ? itsHighlight : pos;
 938         if (!itsOptionsPtr->at(pos))
 939                 return 0;
 940         return (*itsOptionsPtr)[pos]->isSelected;
 941 }
 942
 943 template <typename T> bool NCurses::Menu<T>::isStatic(int pos) const
 944 {
 945         pos = pos == -1 ? itsHighlight : pos;
 946         if (!itsOptionsPtr->at(pos))
 947                 return 1;
 948         return (*itsOptionsPtr)[pos]->isStatic;
 949 }
 950
 951 template <typename T> bool NCurses::Menu<T>::hasSelected() const
 952 {
 953         for (option_const_iterator it = itsOptionsPtr->begin(); it != itsOptionsPtr->end(); ++it)
 954                 if (*it && (*it)->isSelected)
 955                         return true;
 956         return false;
 957 }
 958
 959 template <typename T> void NCurses::Menu<T>::GetSelected(std::vector<size_t> &v) const
 960 {
 961         for (size_t i = 0; i < itsOptionsPtr->size(); ++i)
 962                 if ((*itsOptionsPtr)[i] && (*itsOptionsPtr)[i]->isSelected)
 963                         v.push_back(i);
 964 }
 965
 966 template <typename T> void NCurses::Menu<T>::Highlight(size_t pos)
 967 {
 968         itsHighlight = pos;
 969         itsBeginning = pos-itsHeight/2;
 970 }
 971
 972 template <typename T> size_t NCurses::Menu<T>::Size() const
 973 {
 974         return itsOptionsPtr->size();
 975 }
 976
 977 template <typename T> size_t NCurses::Menu<T>::Choice() const
 978 {
 979         return itsHighlight;
 980 }
 981
 982 template <typename T> size_t NCurses::Menu<T>::RealChoice() const
 983 {
 984         size_t result = 0;
 985         for (option_const_iterator it = itsOptionsPtr->begin(); it != itsOptionsPtr->begin()+itsHighlight; ++it)
 986                 if (*it && !(*it)->isStatic)
 987                         result++;
 988         return result;
 989 }
 990
 991 template <typename T> void NCurses::Menu<T>::ReverseSelection(size_t beginning)
 992 {
 993         option_iterator it = itsOptionsPtr->begin()+beginning;
 994         for (size_t i = beginning; i < Size(); ++i, ++it)
 995                 (*it)->isSelected = !(*it)->isSelected && !(*it)->isStatic;
 996 }
 997
 998 template <typename T> bool NCurses::Menu<T>::Search(const std::string &constraint, size_t beginning, int flags)
 999 {
1000         itsFound.clear();
1001         itsSearchConstraint.clear();
1002         if (constraint.empty())
1003                 return false;
1004         itsSearchConstraint = constraint;
1005         regex_t rx;
1006         if (regcomp(&rx, itsSearchConstraint.c_str(), flags) == 0)
1007         {
1008                 for (size_t i = beginning; i < itsOptionsPtr->size(); ++i)
1009                 {
1010                         if (regexec(&rx, GetOption(i).c_str(), 0, 0, 0) == 0)
1011                                 itsFound.insert(i);
1012                 }
1013         }
1014         regfree(&rx);
1015         return !itsFound.empty();
1016 }
1017
1018 template <typename T> void NCurses::Menu<T>::NextFound(bool wrap)
1019 {
1020         if (itsFound.empty())
1021                 return;
1022         std::set<size_t>::iterator next = itsFound.upper_bound(itsHighlight);
1023         if (next != itsFound.end())
1024                 Highlight(*next);
1025         else if (wrap)
1026                 Highlight(*itsFound.begin());
1027 }
1028
1029 template <typename T> void NCurses::Menu<T>::PrevFound(bool wrap)
1030 {
1031         if (itsFound.empty())
1032                 return;
1033         std::set<size_t>::iterator prev = itsFound.lower_bound(itsHighlight);
1034         if (prev != itsFound.begin())
1035                 Highlight(*--prev);
1036         else if (wrap)
1037                 Highlight(*itsFound.rbegin());
1038 }
1039
1040 template <typename T> void NCurses::Menu<T>::ApplyFilter(const std::string &filter, size_t beginning, int flags)
1041 {
1042         itsFound.clear();
1043         ClearFiltered();
1044         itsFilter = filter;
1045         if (itsFilter.empty())
1046                 return;
1047         for (size_t i = 0; i < beginning; ++i)
1048         {
1049                 itsFilteredRealPositions.push_back(i);
1050                 itsFilteredOptions.push_back(itsOptions[i]);
1051         }
1052         regex_t rx;
1053         if (regcomp(&rx, itsFilter.c_str(), flags) == 0)
1054         {
1055                 for (size_t i = beginning; i < itsOptions.size(); ++i)
1056                 {
1057                         if (regexec(&rx, GetOption(i).c_str(), 0, 0, 0) == 0)
1058                         {
1059                                 itsFilteredRealPositions.push_back(i);
1060                                 itsFilteredOptions.push_back(itsOptions[i]);
1061                         }
1062                 }
1063         }
1064         regfree(&rx);
1065         itsOptionsPtr = &itsFilteredOptions;
1066         if (itsOptionsPtr->empty()) // oops, we didn't find anything
1067                 Window::Clear();
1068 }
1069
1070 template <typename T> const std::string &NCurses::Menu<T>::GetFilter()
1071 {
1072         return itsFilter;
1073 }
1074
1075 template <typename T> std::string NCurses::Menu<T>::GetOption(size_t pos)
1076 {
1077         if (itsOptionsPtr->at(pos) && itsGetStringFunction)
1078                 return itsGetStringFunction((*itsOptionsPtr)[pos]->Item, itsGetStringFunctionUserData);
1079         else
1080                 return "";
1081 }
1082
1083 template <typename T> T &NCurses::Menu<T>::Back()
1084 {
1085         if (!itsOptionsPtr->back())
1086                 FatalError("Menu::Back() has requested separator!");
1087         return itsOptionsPtr->back()->Item;
1088 }
1089
1090 template <typename T> const T &NCurses::Menu<T>::Back() const
1091 {
1092         if (!itsOptionsPtr->back())
1093                 FatalError("Menu::Back() has requested separator!");
1094         return itsOptionsPtr->back()->Item;
1095 }
1096
1097 template <typename T> T &NCurses::Menu<T>::Current()
1098 {
1099         if (!itsOptionsPtr->at(itsHighlight))
1100                 FatalError("Menu::Current() has requested separator!");
1101         return (*itsOptionsPtr)[itsHighlight]->Item;
1102 }
1103
1104 template <typename T> const T &NCurses::Menu<T>::Current() const
1105 {
1106         if (!itsOptionsPtr->at(itsHighlight))
1107                 FatalError("Menu::Current() const has requested separator!");
1108         return (*itsOptionsPtr)[itsHighlight]->Item;
1109 }
1110
1111 template <typename T> T &NCurses::Menu<T>::at(size_t pos)
1112 {
1113         if (!itsOptionsPtr->at(pos))
1114                 FatalError("Menu::at() has requested separator!");
1115         return (*itsOptionsPtr)[pos]->Item;
1116 }
1117
1118 template <typename T> const T &NCurses::Menu<T>::at(size_t pos) const
1119 {
1120         if (!itsOptions->at(pos))
1121                 FatalError("Menu::at() const has requested separator!");
1122         return (*itsOptionsPtr)[pos]->Item;
1123 }
1124
1125 template <typename T> const T &NCurses::Menu<T>::operator[](size_t pos) const
1126 {
1127         if (!(*itsOptionsPtr)[pos])
1128                 FatalError("Menu::operator[] const has requested separator!");
1129         return (*itsOptionsPtr)[pos]->Item;
1130 }
1131
1132 template <typename T> T &NCurses::Menu<T>::operator[](size_t pos)
1133 {
1134         if (!(*itsOptionsPtr)[pos])
1135                 FatalError("Menu::operator[] has requested separator!");
1136         return (*itsOptionsPtr)[pos]->Item;
1137 }
1138
1139 #endif
1140