qui/seqbrowser/SequenceBrowserWidget.cpp

   1 #include <iostream>
   2
   3 #include <QLabel>
   4 #include <QScrollBar>
   5 #include <QSpacerItem>
   6 #include <QSplitter>
   7 #include <QVBoxLayout>
   8 #include <QWidget>
   9
  10 #include "qui/seqbrowser/SequenceBrowserWidget.hpp"
  11 #include "qui/seqbrowser/SequenceBrowser.hpp"
  12 #include "qui/seqbrowser/ScrollableSequenceBrowser.hpp"
  13 #include "qui/seqbrowser/SequenceDescription.hpp"
  14 #include "qui/ImageSaveDialog.hpp"
  15
  16 #include "alg/glsequence.hpp"
  17
  18 #include <math.h>
  19 using namespace std;
  20
  21 SequenceBrowserWidget::SequenceBrowserWidget(
  22     boost::shared_ptr<QDir> default_dir_,
  23     QWidget *parent
  24 )
  25   : QScrollArea(parent),
  26     default_dir(default_dir_),
  27     left_sidebar(new SequenceBrowserSidebar),
  28     scrollable_browser(new ScrollableSequenceBrowser),
  29     right_sidebar(new SequenceBrowserSidebar),
  30     layout(new QHBoxLayout),
  31     layout_container(new QWidget(this))
  32 {
  33   layout->addWidget(left_sidebar, 0);
  34   layout->addWidget(scrollable_browser, 1);
  35   layout->addWidget(right_sidebar, 0);
  36
  37   layout_container->setLayout(layout);
  38   setWidget(layout_container);
  39   setWidgetResizable(true);
  40
  41   // update position values when something in the SequenceBrowser changes
  42   connect(&(scrollable_browser->browser()), SIGNAL(viewportChanged()),
  43           this, SLOT(updatePosition()));
  44   connect(&(scrollable_browser->browser()), SIGNAL(basepairsCopied(size_t)),
  45           this, SIGNAL(basepairsCopied(size_t)));
  46 }
  47
  48 QSize SequenceBrowserWidget::sizeHint() const
  49 {
  50   // don't trust the layouts size computation
  51   // use some heavy handed brute force to compute
  52   // the correct size so our stupid scrollable_browser
  53   // will show the full viewport.
  54   QSize left = left_sidebar->sizeHint();
  55   QSize center = scrollable_browser->sizeHint();
  56   QSize right = right_sidebar->sizeHint();
  57
  58   int width = left.width()+center.width()+right.width();
  59   width += 2 * layout->margin();
  60   if (layout->spacing() > 0) {
  61     width += layout->spacing() * 3;
  62   }
  63   return QSize(width, center.height());
  64 }
  65
  66
  67 void SequenceBrowserWidget::clear()
  68 {
  69   converted_sequences.clear();
  70   scrollable_browser->browser().clear();
  71
  72   SequenceBrowserSidebar::collection left = left_sidebar->descriptions;
  73   SequenceBrowserSidebar::collection right = right_sidebar->descriptions;
  74   for(size_t i = 0; i != left_sidebar->size(); ++i)
  75   {
  76     disconnect(left[i], SIGNAL(nameChanged(const QString &)),
  77                right[i], SLOT(setName(const QString &)));
  78     disconnect(right[i], SIGNAL(nameChanged(const QString &)),
  79                left[i], SLOT(setName(const QString &)));
  80   }
  81   left_sidebar->clear();
  82   right_sidebar->clear();
  83 }
  84
  85 QMenu *SequenceBrowserWidget::getPopupMenu()
  86 {
  87   return scrollable_browser->browser().getPopupMenu();
  88 }
  89
  90 QAction *SequenceBrowserWidget::getCopySelectedSequenceAsStringAction()
  91 {
  92   return scrollable_browser->browser().getCopySelectedSequenceAsStringAction();
  93 }
  94
  95 QAction *SequenceBrowserWidget::getCopySelectedSequenceAsFastaAction()
  96 {
  97   return scrollable_browser->browser().getCopySelectedSequenceAsFastaAction();
  98 }
  99
 100 void SequenceBrowserWidget::copySelectedSequenceAsFasta()
 101 {
 102   scrollable_browser->browser().copySelectedSequenceAsFasta();
 103 }
 104
 105 void SequenceBrowserWidget::copySelectedTracksAsSeqLocation(
 106     std::list<SequenceLocation>& locations
 107 )
 108 {
 109   scrollable_browser->browser().copySelectedTracksAsSeqLocation(locations);
 110 }
 111
 112 void SequenceBrowserWidget::setSequences(
 113     const std::vector<boost::shared_ptr<Sequence> >& sequences,
 114     boost::shared_ptr<AnnotationColors> cm)
 115 {
 116   SequenceBrowser& browser = scrollable_browser->browser();
 117   clear();
 118   for(Mussa::vector_sequence_type::const_iterator seq_i = sequences.begin();
 119       seq_i != sequences.end();
 120       ++seq_i)
 121   {
 122     boost::shared_ptr<GlSequence> gs(new GlSequence(*seq_i, cm));
 123     converted_sequences.push_back(gs);
 124     browser.push_sequence(gs);
 125   }
 126   left_sidebar->setSequences(converted_sequences);
 127   right_sidebar->setSequences(converted_sequences);
 128
 129   // connect the text change signals to each other
 130   SequenceBrowserSidebar::collection left = left_sidebar->descriptions;
 131   SequenceBrowserSidebar::collection right = right_sidebar->descriptions;
 132   for(size_t i = 0; i != sequences.size() and i != right.size(); ++i)
 133   {
 134     connect(left[i], SIGNAL(nameChanged(const QString &)),
 135             right[i], SLOT(setName(const QString &)));
 136     connect(right[i], SIGNAL(nameChanged(const QString &)),
 137             left[i], SLOT(setName(const QString &)));
 138   }
 139
 140   updatePosition();
 141 }
 142
 143 void SequenceBrowserWidget::setSequences(
 144   std::vector<boost::shared_ptr<GlSequence> >& sequences
 145 )
 146 {
 147   SequenceBrowser& browser = scrollable_browser->browser();
 148   clear();
 149   for(vector<boost::shared_ptr<GlSequence> >::iterator seq_i = sequences.begin();
 150       seq_i != sequences.end();
 151       ++seq_i)
 152   {
 153     browser.push_sequence(*seq_i);
 154   }
 155   left_sidebar->setSequences(sequences);
 156   right_sidebar->setSequences(sequences);
 157   updatePosition();
 158 }
 159
 160 const vector<boost::shared_ptr<GlSequence> >& SequenceBrowserWidget::sequences() const
 161 {
 162   return scrollable_browser->browser().sequences();
 163 }
 164
 165 void SequenceBrowserWidget::clear_links()
 166 {
 167   scrollable_browser->browser().clear_links();
 168 }
 169
 170 void SequenceBrowserWidget::link(const std::vector<int>& path,
 171                                  const std::vector<bool>& isRC,
 172                                  int length)
 173 {
 174   scrollable_browser->browser().link(path, isRC, length);
 175   scrollable_browser->browser().update();
 176 }
 177
 178 const std::set<int> SequenceBrowserWidget::selectedPaths() const
 179 {
 180   return scrollable_browser->browser().selectedPaths();
 181 }
 182
 183 void SequenceBrowserWidget::centerOnPath(const vector<int>& paths)
 184 {
 185   scrollable_browser->browser().centerOnPath(paths);
 186   updatePosition();
 187 }
 188
 189 /* This could theoretically be pushed down to some set
 190  * of signals and slots connecting SequenceDescriptions and
 191  * some signal emitted by the browser's viewportChanged code
 192  * but evertime I tried to figure it out, I got confused about
 193  * how the descriptions in one of the sidebars was supposed to know
 194  * if it was mapping the rightbase or the leftbase.
 195  * And so though this could be better the typical use cases
 196  * can just talk to the SequenceBrowserWidget for rendering
 197  * or mussa output
 198  */
 199 void SequenceBrowserWidget::updatePosition()
 200 {
 201   const SequenceBrowser& browser = scrollable_browser->browser();
 202   const vector<boost::shared_ptr<GlSequence> > &sequences = browser.sequences();
 203   SequenceBrowserSidebar::collection left = left_sidebar->descriptions;
 204   SequenceBrowserSidebar::collection right = right_sidebar->descriptions;
 205   for(size_t i = 0; i != sequences.size() and i != right.size(); ++i)
 206   {
 207     left[i]->setPosition(sequences[i]->leftbase(browser.viewportLeft()));
 208     right[i]->setPosition(sequences[i]->rightbase(browser.viewportRight()));
 209   }
 210   scrollable_browser->browser().update();
 211   scrollable_browser->updateScrollBar();
 212 }
 213
 214 void SequenceBrowserWidget::promptSaveBrowserPixmap()
 215 {
 216   QSize size;
 217   size = scrollable_browser->browser().size();
 218   //Image Save Dialog
 219   ImageSaveDialog imageSaveDialog(default_dir, scrollable_browser, this);
 220   imageSaveDialog.setSize(size.width(), size.height());
 221   imageSaveDialog.exec();
 222 }
 223
 224 double SequenceBrowserWidget::zoom()
 225 {
 226   return scrollable_browser->browser().zoom();
 227 }
 228
 229 double SequenceBrowserWidget::zoomOut()
 230 {
 231   double zoom_level = scrollable_browser->browser().zoomOut();
 232   scrollable_browser->updateScrollBar();
 233   return zoom_level;
 234 }
 235
 236 double SequenceBrowserWidget::zoomToSequence()
 237 {
 238   double zoom_level = scrollable_browser->browser().zoomToSequence();
 239   scrollable_browser->updateScrollBar();
 240   return zoom_level;
 241 }
 242
 243 void SequenceBrowserWidget::setZoom(double z)
 244 {
 245   scrollable_browser->browser().setZoom(z);
 246 }
 247
 248 void SequenceBrowserWidget::update()
 249 {
 250   QWidget::update();
 251   scrollable_browser->browser().update();
 252 }