limitwindow.cpp

LINUX下

                  mvwprintw(window_, counter_, 0, "%d", _value);
               }

            if (_type == choice_)
               {
                  ::wattroff(window_, A_REVERSE);
                  // Hightlight off.
               }

            if (_changed)
               {
                  setColor(Colors::C_NORMAL);
                  unSetColor(Colors::C_MARK);
               }

            counter_++;
         }

         void limitWindow::nextChoice()
         {
            switch (choice_)
               {
               case limitWindow::COUNTER1:
                  choice_ = limitWindow::COUNTER2;
                  break;
               case limitWindow::COUNTER2:
                  choice_ = limitWindow::COUNTER3;
                  break;
               case limitWindow::COUNTER3:
                  choice_ = limitWindow::COUNTER4;
                  break;
               case limitWindow::COUNTER4:
                  choice_ = limitWindow::COUNTER1;
                  break;
               }
         }

         void limitWindow::prevChoice()
         {
            switch (choice_)
               {
               case limitWindow::COUNTER1:
                  choice_ = limitWindow::COUNTER4;
                  break;
               case limitWindow::COUNTER2:
                  choice_ = limitWindow::COUNTER1;
                  break;
               case limitWindow::COUNTER3:
                  choice_ = limitWindow::COUNTER2;
                  break;
               case limitWindow::COUNTER4:
                  choice_ = limitWindow::COUNTER3;
                  break;
               }
         }

         void limitWindow::incValue(t_int const _increment)
         {
            switch (choice_)
               {
               case limitWindow::COUNTER1:
                  genInc(_increment, 
                         counters_[COUNTER1].value, 
                         counters_[COUNTER1].maximum);
                  break;
               case limitWindow::COUNTER2:
                  genInc(_increment, 
                         counters_[COUNTER2].value, 
                         counters_[COUNTER2].maximum);
                  break;
               case limitWindow::COUNTER3:
                  genInc(_increment, 
                         counters_[COUNTER3].value, 
                         counters_[COUNTER3].maximum);
                  break;
               case limitWindow::COUNTER4:
                  genInc(_increment, 
                         counters_[COUNTER4].value, 
                         counters_[COUNTER4].maximum);
                  break;
               }
         }

         void limitWindow::decValue(t_int const _increment)
         {
            switch (choice_)
               {
               case limitWindow::COUNTER1:
                  genDec(_increment, 
                         counters_[COUNTER1].value, 
                         counters_[COUNTER1].minimum);
                  break;
               case limitWindow::COUNTER2:
                  genDec(_increment, 
                         counters_[COUNTER2].value, 
                         counters_[COUNTER2].minimum);
                  break;
               case limitWindow::COUNTER3:
                  genDec(_increment, 
                         counters_[COUNTER3].value, 
                         counters_[COUNTER3].minimum);
                  break;
               case limitWindow::COUNTER4:
                  genDec(_increment, 
                         counters_[COUNTER4].value, 
                         counters_[COUNTER4].minimum);
                  break;
               }
         }

         void limitWindow::genInc(t_int const _increment, t_int & _value, t_int const _max) const
         {
            if (_value == -1)
               {
                  _value = 1;
               }
            else
               {
                  _value += _increment;
               }

            if (_value > _max)
               {
                  _value = _max;
               }
         }

         void limitWindow::genDec(t_int const _increment, t_int & _value, t_int const _min) const
         {
            if (_value == 1)
               {
                  _value = -1;
               }
            else
               {
                  _value -= _increment;
               }

            if (_value < _min)
               {
                  _value = _min;
               }
         }

         windowSize limitWindow::calculateDimenstions(windowSize const& _ws) const
         {
            // Use the same dimensions as the parent.
            windowSize ws = _ws;

            return ws;
         }

         bool limitWindow::showHelp()
         {
            // Show a help window on the middle of the screen.
            std::vector<std::string> helpText;

            helpText.push_back("Help");
            helpText.push_back("----");
            helpText.push_back("    ");

            std::string keyDescr;

            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_NEXT,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to move to the next limit");
               }

            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_PREV,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to move to the previous limit");
               }

            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_DOWN,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to dec. the currently selected limit by one");
               }


            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_UP,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to inc. the currently selected limit by one");
               }

            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_LIST_START,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to inc. the currently selected limit by 100");
               }

            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_LIST_END,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to dec. the currently selected limit by 100");
               }

            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_SELECT,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to set the choosen limits");
               }

            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_QUIT,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to abort setting limits");
               }

            helpText.push_back(" ");

            helpWindow hw(kmap_, helpText);

            dialog::RESULT res = hw.run();

            bool resized = false;
            if (res == dialog::R_RESIZE)
               {
                  resized = true;
               }

            return resized;
         }

         limitWindow::~limitWindow()
         {
            destroy();
         }

      } // namespace cli
   } // namespace UI
} // namespace btg