fileselect.cpp

LINUX下

                           {
                              setColor(Colors::C_FILE);
                           }
                        mvwprintw(window_, scr_counter,   0, " %s%s", filename.c_str(), filename_spaces.c_str());
                        mvwprintw(window_, scr_counter+1, 0, " %s%s", path.c_str(),     path_spaces.c_str());
                        if (!iter->selected())
                           {
                              unSetColor(Colors::C_FILE);
                           }
                     }

                  // Display marked torrents with different color.
                  if (iter->selected())
                     {
                        unSetColor(Colors::C_MARK);
                     }

                  counter++;
                  scr_counter += linesPerFile;
               }
         }

         void fileSelect::moveDown()
         {
            const t_int list_max = selected_files_.size();

            if (currentPosition_ < (numberOfLines_-1))
               {
                  currentPosition_++;

                  if (selected_files_.size() > 0)
                     {
                        if (currentPosition_ > (list_max-1))
                           {
                              currentPosition_--;
                           }
                     }
               }
            else
               {
                  if (positionWindowEnd_ < list_max)
                     {
                        positionWindowStart_++;
                        positionWindowEnd_++;
                     }
               }

         }

         void fileSelect::moveUp()
         {
            if (currentPosition_ > 0)
               {
                  currentPosition_--;
               }
            else
               {
                  if ((positionWindowStart_-1) >= 0)
                     {
                        positionWindowStart_--;
                        positionWindowEnd_--;
                     }
               }


         }

         void fileSelect::handleMark()
         {
            if (selected_files_.size() == 0)
               {
                  return;
               }

            t_uint current = positionWindowStart_ + currentPosition_;

            std::vector<btg::core::selectedFileEntry>::iterator iter = selected_files_.begin();
            iter += current;
            
            if (iter != selected_files_.end())
               {
                  if (iter->selected())
                     {
                        iter->deSelect();
                     }
                  else
                     {
                        iter->select();
                     }
               }
         }

         void fileSelect::handleMarkAll()
         {
            std::vector<btg::core::selectedFileEntry>::iterator iter;
            for (iter = selected_files_.begin();
                 iter != selected_files_.end();
                 iter++)
               {
                  if (iter->selected())
                     {
                        iter->deSelect();
                     }
                  else
                     {
                        iter->select();
                     }  
               }
         }

         void fileSelect::toStart()
         {
            currentPosition_     = 0;
         }

         void fileSelect::toEnd()
         {
            currentPosition_ = (numberOfLines_-1);

            t_int max_position = selected_files_.size();
            if (max_position > 0)
               {
                  max_position--;
               }

            if (currentPosition_ > max_position)
               {
                  currentPosition_ = max_position;
               }
         }

         windowSize fileSelect::calculateDimenstions(windowSize const& _ws) const
         {
            // Use the parents dimensions.
            windowSize ws = _ws;

            return ws;
         }

         dialog::RESULT fileSelect::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_DOWN,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to move down");
               }


            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_UP,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to move up");
               }

            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_MARK,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to choose a file");
               }

            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_MARK_ALL,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to choose all files");
               }

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

            if (helpWindow::generateHelpForKey(kmap_,
                                               keyMapping::K_QUIT,
                                               "",
                                               keyDescr,
                                               false))
               {
                  helpText.push_back(keyDescr);
                  helpText.push_back("  to quit this display");
               }

            helpText.push_back(" ");

            helpWindow hw(kmap_, helpText);

            return hw.run();
         }

         void fileSelect::splitPath(std::string const& _input,
                                  std::string & _path,
                                  std::string & _filename) const
         {
            t_strList lst    = btg::core::Util::splitLine(_input, "/");
            t_strListCI iter = lst.begin();

            if (lst.size() <= 1)
               {
                  _path     = "./";
                  _filename = _input;
               }
            else
               {
                  t_strListCI iter_end = lst.end();
                  iter_end--;

                  // At least one "/".
                  for (iter = lst.begin();
                       iter != iter_end;
                       iter++)
                     {
                        _path += *iter;
                        _path += "/";
                     }

                  _filename = *iter;
               }
         }

         bool fileSelect::changed() const
         {
            if (original_files_ == selected_files_)
               {
                  return false;
               }

            return true;
         }

         bool fileSelect::pressed_select() const
         {
            return pressed_select_key_;
         }

         void fileSelect::getFiles(btg::core::selectedFileEntryList & _list)
         {
            _list.setFiles(selected_files_);
         }

         fileSelect::~fileSelect()
         {
            destroy();
            selected_files_.clear();
         }

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