{
objid = *ptr++; ++consumed_names;
- int left = track_container[objid].leftbase(r.left);
- int right = track_container[objid].rightbase(r.right);
+ int left = track_container[objid]->leftbase(r.left);
+ int right = track_container[objid]->rightbase(r.right);
// the static_cast should be ok, since basepairs line up on
// integral values
//TrackRegion track(objid, left, right);
{
return cur_ortho.left;
} else {
- vector<GlSequence>::const_iterator track_i = track_container.begin();
- left = track_i->x();
+ vector<boost::shared_ptr<GlSequence> >::const_iterator track_i = track_container.begin();
+ left = (*track_i)->x();
for( ; track_i != track_container.end(); ++track_i)
{
- if (track_i->x() < left) {
- left = track_i->x();
+ if ((*track_i)->x() < left) {
+ left = (*track_i)->x();
}
}
return left-border_width;
if (track_container.size() == 0) {
return cur_ortho.right;
} else {
- vector<GlSequence>::const_iterator track_i = track_container.begin();
- right = track_i->right();
+ vector<boost::shared_ptr<GlSequence> >::const_iterator track_i = track_container.begin();
+ right = (*track_i)->right();
for( ; track_i != track_container.end(); ++track_i) {
- if (track_i->right() > right)
- right = track_i->right();
+ if ((*track_i)->right() > right)
+ right = (*track_i)->right();
}
return right+border_width;
}
void GlSeqBrowser::push_sequence(boost::shared_ptr<Sequence> s)
{
- GlSequence gs(s, color_mapper);
+ boost::shared_ptr<GlSequence> gs(new GlSequence(s, color_mapper));
push_sequence(gs);
}
void GlSeqBrowser::push_sequence(GlSequence gs)
+{
+ boost::shared_ptr<GlSequence> new_gs(new GlSequence(gs));
+ push_sequence(new_gs);
+}
+
+void GlSeqBrowser::push_sequence(boost::shared_ptr<GlSequence> gs)
{
clear_links();
track_container.push_back(gs);
path_segments.push_back(pair_segment_map());
}
-const std::vector<GlSequence>& GlSeqBrowser::sequences() const
+const std::vector<boost::shared_ptr<GlSequence> >& GlSeqBrowser::sequences() const
{
return track_container;
}
pair_segment_map::iterator found_segment = path_segments[track_i].find(p);
if (found_segment == path_segments[track_i].end()) {
// not already found
- float y1 = track_container[track_i].y();
- y1 -= track_container[track_i].height()/2;
- float y2 = track_container[track_i+1].y();
- y2 += track_container[track_i+1].height()/2;
+ float y1 = track_container[track_i]->y();
+ y1 -= track_container[track_i]->height()/2;
+ float y2 = track_container[track_i+1]->y();
+ y2 += track_container[track_i+1]->height()/2;
bool rcFlag = (prev_rc or *rc_i) and !(prev_rc and *rc_i);
Segment s(prev_x, y1, *path_i, y2, rcFlag);
//! copy sequence from selected track using formating function
template<class Item>
void GlSeqBrowser::copySelectedTracks(std::list<Item>& result,
- Item (*formatter)(const Sequence& s, int left, int right))
+ Item (*formatter)(boost::shared_ptr<Sequence> s,
+ int left,
+ int right))
{
result.clear();
<< endl;
} else {
// we should be safe
- const Sequence& seq = track_container[track_index].sequence();
+ boost::shared_ptr<Sequence> seq = track_container[track_index]->sequence();
result.push_back(formatter(seq, track_i->left, track_i->right));
}
}
{
std::list<std::string> result;
struct AsFasta {
- static string formatter(const Sequence& seq, int left, int right)
+ static string formatter(boost::shared_ptr<Sequence> seq,
+ int left,
+ int right)
{
stringstream s;
- s << ">" << seq.get_fasta_header()
+ s << ">" << seq->get_fasta_header()
<< "|" << "subregion=" << left << "-" << right+1
<< std::endl
- << seq.subseq(left, right-left+1) << std::endl;
+ << seq->subseq(left, right-left+1) << std::endl;
return s.str();
}
};
void GlSeqBrowser::copySelectedTracksAsSequences(std::list<Sequence>& result)
{
struct AsSequence {
- static Sequence formatter(const Sequence& seq, int left, int right)
+ static Sequence formatter(boost::shared_ptr<Sequence> seq,
+ int left,
+ int right)
{
- return seq.subseq(left, right-left+1);
+ return seq->subseq(left, right-left+1);
}
};
copySelectedTracks(result, AsSequence::formatter);
std::list<SequenceLocation>& result)
{
struct AsSeqLocation {
- static SequenceLocation formatter(const Sequence& seq, int left, int right)
+ static SequenceLocation formatter(boost::shared_ptr<Sequence> seq,
+ int left,
+ int right)
{
return SequenceLocation(seq, left, right);
}
{
std::list<string> result;
struct AsString {
- static string formatter(const Sequence& seq, int left, int right)
+ static string formatter(boost::shared_ptr<Sequence> seq,
+ int left,
+ int right)
{
stringstream s;
- s << seq.subseq(left, right-left+1) << std::endl;
+ s << seq->subseq(left, right-left+1) << std::endl;
return s.str();
}
};
for(size_t track_i = 0; track_i != track_container.size(); ++track_i)
{
// -15 = shift more to the left
- track_container[track_i].setX((viewport_center-15) - paths[track_i]);
+ track_container[track_i]->setX((viewport_center-15) - paths[track_i]);
}
}
void GlSeqBrowser::update_layout()
{
- typedef std::vector<GlSequence>::iterator glseq_itor_type;
+ typedef std::vector<boost::shared_ptr<GlSequence> >::iterator glseq_itor_type;
float available_height = (float)cur_ortho.top - 2 * (float)border_width;
float max_base_pairs = 0;
size_t track_count = track_container.size();
seq_i != track_container.end();
++seq_i, y-=track_spacing)
{
- seq_i->setX(0);
- seq_i->setY(y);
- if (seq_i->size() > max_base_pairs)
- max_base_pairs = seq_i->size();
+ (*seq_i)->setX(0);
+ (*seq_i)->setY(y);
+ if ((*seq_i)->size() > max_base_pairs)
+ max_base_pairs = (*seq_i)->size();
}
} else if (track_count == 1) {
// center the single track
glseq_itor_type seq_i = track_container.begin();
- seq_i->setX(0);
- seq_i->setY(viewport_size.x /2);
- max_base_pairs = seq_i->size();
+ (*seq_i)->setX(0);
+ (*seq_i)->setY(viewport_size.x /2);
+ max_base_pairs = (*seq_i)->size();
} else {
// nothing to do as we're empty
return;
for(size_t track_i = 0; track_i != track_container.size(); ++track_i)
{
glPushName(track_i);
- track_container[track_i].draw(cur_ortho.left, cur_ortho.right);
+ track_container[track_i]->draw(cur_ortho.left, cur_ortho.right);
glPopName();
}
}
// save the multipart name for our segment
glPushName(path_index); glPushName(key.first); glPushName(key.second);
glBegin(GL_LINES);
- float seq_start_x = track_container[path_index].x();
- float seq_end_x = track_container[path_index+1].x();
+ float seq_start_x = track_container[path_index]->x();
+ float seq_end_x = track_container[path_index+1]->x();
glVertex3f(s.start.x + seq_start_x, s.start.y, -1);
glVertex3f(s.end.x + seq_end_x , s.end.y, -1);
glEnd();
void push_sequence(boost::shared_ptr<Sequence> s);
//! add a glsequence to the back of our track container
void push_sequence(GlSequence s);
+ //! add a glsequence to the back of our track container
+ void push_sequence(boost::shared_ptr<GlSequence> gs);
//! return our track container
- const std::vector<GlSequence>& sequences() const;
+ const std::vector<boost::shared_ptr<GlSequence> >& sequences() const;
//! clear all the line segments between all the sequences
void clear_links();
//! copy sequence from selected track using formating function
template<class Item>
void copySelectedTracks(std::list<Item>& result,
- Item (*format_track)(const Sequence& s, int left, int right));
+ Item (*format_track)(boost::shared_ptr<Sequence> s,
+ int left,
+ int right));
//! copy sequence from selected tracks as FASTA sequences
void copySelectedTracksAsFasta(std::string& copy_buffer);
//! copy sequence from selected tracks as a list of sequences
double zoom_level;
boost::shared_ptr<AnnotationColors> color_mapper;
//! container of all the GlSequences loaded into our scene
- std::vector<GlSequence> track_container;
+ std::vector<boost::shared_ptr<GlSequence> > track_container;
//! counter for each path added to us via connect
int pathid;
return *this;
}
-const Sequence& GlSequence::sequence() const
+boost::shared_ptr<Sequence> GlSequence::sequence()
{
- return *seq;
+ return seq;
}
void GlSequence::setX(GLfloat value)
*/
void draw(GLfloat left, GLfloat right) const;
- const Sequence& sequence() const;
+ boost::shared_ptr<Sequence> sequence();
//! set our starting x (horizontal) coordinate
void setX(GLfloat);
//! get our starting x (horizontal) coordinate
BOOST_CHECK_EQUAL( gt.right(), s0.size() + gt.border()-11 );
// aparently we end up with a different glsequence in the seqbrowser
- BOOST_CHECK( glseq1.x() != gt.sequences()[1].x() );
+ BOOST_CHECK( glseq1.x() != gt.sequences()[1]->x() );
- BOOST_CHECK_EQUAL( gt.sequences()[0].x(), (gt.viewportCenter()-15)-path[0] );
- BOOST_CHECK_EQUAL( gt.sequences()[1].x(), (gt.viewportCenter()-15)-path[1] );
- BOOST_CHECK_EQUAL( gt.sequences()[2].x(), (gt.viewportCenter()-15)-path[2] );
+ BOOST_CHECK_EQUAL( gt.sequences()[0]->x(), (gt.viewportCenter()-15)-path[0] );
+ BOOST_CHECK_EQUAL( gt.sequences()[1]->x(), (gt.viewportCenter()-15)-path[1] );
+ BOOST_CHECK_EQUAL( gt.sequences()[2]->x(), (gt.viewportCenter()-15)-path[2] );
}
BOOST_AUTO_TEST_CASE( setSelectedPaths )
boost::shared_ptr<Sequence> seq1(new Sequence(s1));
GlSequence glseq0(seq0, cm);
- BOOST_CHECK (glseq0.sequence() == s0);
+ BOOST_CHECK (*glseq0.sequence() == s0);
GlSequence glseq1(seq1, cm);
GlSequence glseq_copy0(glseq0);
BOOST_CHECK(glseq_copy0.sequence() == glseq0.sequence());
- BOOST_CHECK( &(glseq_copy0.sequence()) == &(glseq0.sequence()));
+ BOOST_CHECK( glseq_copy0.sequence() == glseq0.sequence());
glseq0 = glseq1;
- BOOST_CHECK( glseq0.sequence() == s1 );
+ BOOST_CHECK( *glseq0.sequence() == s1 );
}
BOOST_AUTO_TEST_CASE( glsequence_color )
>())
.def(init<GlSequence &>())
.def("draw", &GlSequence::draw)
- .def("sequence", &GlSequence::sequence,
- return_internal_reference<>())
+ .def("sequence", &GlSequence::sequence )
.add_property("x", &GlSequence::x, &GlSequence::setX)
.add_property("y", &GlSequence::y, &GlSequence::setY)
.add_property("size", &GlSequence::size)
updateAnalysis();
}
-MussaWindow::~MussaWindow()
-{
- if (analysis != 0) delete analysis;
- aligned_windows.clear();
- if (motif_editor != 0) delete motif_editor;
- if (progress_dialog != 0) delete progress_dialog;
-
- if (aboutAction != 0) delete aboutAction;
- if (closeAction != 0) delete closeAction;
- if (createNewAnalysisAction != 0) delete createNewAnalysisAction;
- if (createSubAnalysisAction != 0) delete createSubAnalysisAction;
- if (editMotifsAction != 0) delete editMotifsAction;
- if (loadMotifListAction != 0) delete loadMotifListAction;
- if (loadMupaAction != 0) delete loadMupaAction;
- if (loadSavedAnalysisAction != 0) delete loadSavedAnalysisAction;
- if (mussaManualAssistantAction != 0) delete mussaManualAssistantAction;
- if (newMussaWindowAction != 0) delete newMussaWindowAction;
- if (saveBrowserPixmapAction != 0) delete saveBrowserPixmapAction;
- if (saveMotifListAction != 0) delete saveMotifListAction;
- if (showMussaViewToolbarAction != 0) delete showMussaViewToolbarAction;
- if (toggleMotifsAction != 0) delete toggleMotifsAction;
- if (whatsThisAction != 0) delete whatsThisAction;
- if (viewMussaAlignmentAction != 0) delete viewMussaAlignmentAction;
-
- if (manualAssistant != 0) delete manualAssistant;
-
-}
-
void MussaWindow::setAnalysis(Mussa *new_analysis)
{
if (new_analysis != 0) {
public:
MussaWindow(Mussa* analysis=0, QWidget *parent=0);
- ~MussaWindow();
//! reset any attached window
void clear();
itor != model.end();
++itor)
{
+ // append_sequence from a const Sequence & will make a copy
+ // for the shared pointer.
m->append_sequence(itor->getSelectedSequence());
}
popupMenu.popup(point);
}
-void SequenceBrowser::push_sequence(const Sequence &s)
+void SequenceBrowser::push_sequence(boost::shared_ptr<Sequence> s)
{
GlSeqBrowser::push_sequence(s);
emit tracksChanged();
}
-void SequenceBrowser::push_sequence(GlSequence &gs)
+void SequenceBrowser::push_sequence(boost::shared_ptr<GlSequence> gs)
{
GlSeqBrowser::push_sequence(gs);
emit tracksChanged();
#include <vector>
#include <set>
+#include <boost/shared_ptr.hpp>
+
#include "alg/mussa.hpp"
#include "alg/glsequence.hpp"
#include "alg/glseqbrowser.hpp"
QSize sizeHint() const;
void clear();
- void push_sequence(const Sequence &s);
- void push_sequence(GlSequence &);
+ void push_sequence(boost::shared_ptr<Sequence> s);
+ void push_sequence(boost::shared_ptr<GlSequence>);
//! return the popup menu for the glcanvas (reference stored internally)
QMenu &getPopupMenu();
descriptions.clear();
}
-void SequenceBrowserSidebar::setSequences(vector<GlSequence>& sequences)
+void SequenceBrowserSidebar::setSequences(
+ vector<boost::shared_ptr<GlSequence> > sequences
+)
{
+ typedef vector<boost::shared_ptr<GlSequence> > vector_shared_glsequences;
clear();
- for (vector<GlSequence>::const_iterator track_i = sequences.begin();
+ for (vector_shared_glsequences::iterator track_i = sequences.begin();
track_i != sequences.end();
++track_i)
{
SequenceDescription *desc = new SequenceDescription(this);
- desc->setName(track_i->sequence().get_species());
- desc->setLength(track_i->sequence().length());
+ desc->setGlSequence(*track_i);
descriptions.push_back(desc);
layout.addWidget(desc);
if ((track_i+1) != sequences.end()) {
}
setLayout(&layout);
}
+
#include <vector>
+#include <boost/shared_ptr.hpp>
+
#include <QVBoxLayout>
#include <QWidget>
#include "qui/seqbrowser/SequenceBrowser.hpp"
//! clear our list of descriptions
void clear();
- void setSequences(std::vector<GlSequence>& );
+ void setSequences(std::vector<boost::shared_ptr<GlSequence> > );
std::vector<SequenceDescription *> descriptions;
public slots:
}
void SequenceBrowserWidget::setSequences(
- const std::vector< boost::shared_ptr<Sequence> >& sequences,
+ const std::vector<boost::shared_ptr<Sequence> >& sequences,
boost::shared_ptr<AnnotationColors> cm)
{
SequenceBrowser& browser = scrollable_browser.browser();
++seq_i)
{
boost::shared_ptr<GlSequence> gs(new GlSequence(*seq_i, cm));
- converted_sequences.push_back(*gs);
- browser.push_sequence(*gs);
+ converted_sequences.push_back(gs);
+ browser.push_sequence(gs);
}
left_sidebar.setSequences(converted_sequences);
right_sidebar.setSequences(converted_sequences);
+
+ // connect the text change signals to each other
+ vector<SequenceDescription *> left = left_sidebar.descriptions;
+ vector<SequenceDescription *> right = right_sidebar.descriptions;
+ for(size_t i = 0; i != sequences.size() and i != right.size(); ++i)
+ {
+ connect(left[i], SIGNAL(nameChanged(const QString &)),
+ right[i], SLOT(setName(const QString &)));
+ connect(right[i], SIGNAL(nameChanged(const QString &)),
+ left[i], SLOT(setName(const QString &)));
+ }
+
updatePosition();
}
-void SequenceBrowserWidget::setSequences(std::vector<GlSequence>& sequences)
+void SequenceBrowserWidget::setSequences(
+ std::vector<boost::shared_ptr<GlSequence> >& sequences
+)
{
SequenceBrowser& browser = scrollable_browser.browser();
clear();
- for(vector<GlSequence>::iterator seq_i = sequences.begin();
+ for(vector<boost::shared_ptr<GlSequence> >::iterator seq_i = sequences.begin();
seq_i != sequences.end();
++seq_i)
{
updatePosition();
}
-const vector<GlSequence>& SequenceBrowserWidget::sequences() const
+const vector<boost::shared_ptr<GlSequence> >& SequenceBrowserWidget::sequences() const
{
return scrollable_browser.browser().sequences();
}
void SequenceBrowserWidget::updatePosition()
{
const SequenceBrowser& browser = scrollable_browser.browser();
- const vector<GlSequence> &sequences = browser.sequences();
+ const vector<boost::shared_ptr<GlSequence> > &sequences = browser.sequences();
vector<SequenceDescription *> left = left_sidebar.descriptions;
vector<SequenceDescription *> right = right_sidebar.descriptions;
for(size_t i = 0; i != sequences.size() and i != right.size(); ++i)
{
- left[i]->setPosition(sequences[i].leftbase(browser.viewportLeft()));
- right[i]->setPosition(sequences[i].rightbase(browser.viewportRight()));
+ left[i]->setPosition(sequences[i]->leftbase(browser.viewportLeft()));
+ right[i]->setPosition(sequences[i]->rightbase(browser.viewportRight()));
}
scrollable_browser.browser().update();
scrollable_browser.updateScrollBar();
void setSequences(
const std::vector< boost::shared_ptr<Sequence> >& sequences,
boost::shared_ptr<AnnotationColors> cm);
- void setSequences(std::vector<GlSequence>& sequences);
- const std::vector<GlSequence>& sequences() const;
+ void setSequences(std::vector<boost::shared_ptr<GlSequence> >& sequences);
+ const std::vector<boost::shared_ptr<GlSequence> >& sequences() const;
//! reset just the links we're displaying
void clear_links();
//! sequences created by a setSequences(vector<Sequences>) call
/*! I need to save them so i can free them to avoid a memory leak
*/
- std::vector<GlSequence> converted_sequences;
+ std::vector<boost::shared_ptr<GlSequence> > converted_sequences;
};
#endif
#include <QVBoxLayout>
-
#include "qui/seqbrowser/SequenceDescription.hpp"
using namespace std;
createWidget();
}
-SequenceDescription::SequenceDescription(string name, int length,
- QWidget *parent)
- : QFrame(parent),
- pos(-1) // set pos to an invalid value so the setPos function will call
- // setText
+SequenceDescription::SequenceDescription(
+ boost::shared_ptr<GlSequence> glseq,
+ QWidget *parent
+) : QFrame(parent)
{
- setName(name);
- setLength(length);
- createWidget();
+ setGlSequence(glseq);
}
void SequenceDescription::createWidget()
layout->addWidget(&name_label);
layout->addWidget(&length_label);
layout->addWidget(&position_label);
+ name_label.setMaximumWidth(length_label.fontMetrics().width("01234567"));
setLayout(layout);
+
+ connect(&name_label, SIGNAL(textChanged(const QString& )),
+ this, SLOT(setName(const QString& )));
+}
+
+void SequenceDescription::setGlSequence(
+ boost::shared_ptr<GlSequence> glseq )
+{
+ if (glseq != glsequence_) {
+ glsequence_ = glseq;
+ setName(glsequence_->sequence()->get_species());
+ setLength(glsequence_->sequence()->length());
+ emit glsequenceChanged(glsequence_);
+ }
+}
+
+boost::shared_ptr<GlSequence> SequenceDescription::glsequence()
+{
+ return glsequence_;
}
void SequenceDescription::setName(std::string name)
{
- if (name != name_label.text().toStdString()) {
- name_label.setText(name.c_str());
- emit nameChanged(name);
+ setName(QString(name.c_str()));
+}
+
+void SequenceDescription::setName(const QString& name_)
+{
+ std::string std_name_ = name_.toStdString();
+
+ if (std_name_ != glsequence_->sequence()->get_species()) {
+ glsequence_->sequence()->set_species(std_name_);
+ emit nameChanged(name_);
+ }
+
+ // no need to setText again if its because of user editing
+ if (name_ != name_label.text()) {
+ name_label.setText(name_);
}
}
-void SequenceDescription::setLength(int length_)
+std::string SequenceDescription::name() const
+{
+ if (glsequence_)
+ return glsequence_->sequence()->get_species();
+ else
+ return string("");
+}
+
+void SequenceDescription::setLength(int length)
{
QString s;
- float short_length = length_;
- if (length_ != length) {
- if (short_length > 1000000) {
- short_length /= 1000000;
- s.setNum(short_length, 'f', 2);
- s += "mb";
- } if (short_length > 1000) {
- short_length /= 1000;
- s.setNum(short_length, 'f', 2);
- s += "kb";
- } else {
- s.setNum(short_length);
- s += "b";
- }
- length_label.setText(s);
- length = length_;
- emit lengthChanged(length);
+ float short_length = length;
+ if (short_length > 1000000) {
+ short_length /= 1000000;
+ s.setNum(short_length, 'f', 2);
+ s += "mb";
+ } if (short_length > 1000) {
+ short_length /= 1000;
+ s.setNum(short_length, 'f', 2);
+ s += "kb";
+ } else {
+ s.setNum(short_length);
+ s += "b";
}
+ length_label.setText(s);
+}
+
+int SequenceDescription::length() const
+{
+ return 0;
+
+ if (glsequence_)
+ return glsequence_->sequence()->size();
+ else
+ return 0;
}
void SequenceDescription::setPosition(int pos_)
emit positionChanged(pos);
}
}
+
+int SequenceDescription::position() const
+{
+ return pos;
+}
#ifndef _SEQUENCE_DESCRIPTION_H
#define _SEQUENCE_DESCRIPTION_H
+#include <boost/shared_ptr.hpp>
+
#include <string>
#include <QString>
#include <QLabel>
+#include <QLineEdit>
#include <QFrame>
+#include "alg/glsequence.hpp"
+
class SequenceDescription : public QFrame
{
Q_OBJECT
public:
SequenceDescription(QWidget *parent=0);
- SequenceDescription(std::string name, int length, QWidget *parent=0);
+ SequenceDescription(boost::shared_ptr<GlSequence>, QWidget *);
+ void setName(std::string name);
+
+ boost::shared_ptr<GlSequence> glsequence();
+ std::string name() const;
+ int length() const;
+ int position() const;
public slots:
- void setName(std::string name);
- void setLength(int length);
+ //! Display the passed GlSequence information
+ void setGlSequence(boost::shared_ptr<GlSequence>);
+ //! set the name for our sequence
+ void setName(const QString& name);
void setPosition(int pos);
signals:
- void nameChanged(std::string name);
- void lengthChanged(float length);
+ void glsequenceChanged(boost::shared_ptr<GlSequence>);
+ void nameChanged(const QString& name);
void positionChanged(int pos);
private:
- QLabel name_label;
+ QLineEdit name_label;
QLabel length_label;
QLabel position_label;
- int length;
+ boost::shared_ptr<GlSequence> glsequence_;
int pos;
void createWidget();
+ //! format the length and set the QLabel
+ void setLength(int length);
};
#endif
MAKE_UNITTEST(TestSequenceLocationModel)
MAKE_UNITTEST(TestSequenceBrowser)
+MAKE_UNITTEST(TestSequenceDescription)
MAKE_UNITTEST(TestColorSharing)
#include <vector>
#include <boost/assign.hpp>
+#include <boost/shared_ptr.hpp>
using namespace boost::assign;
private slots:
void testSimplePushSequence() {
- Sequence seq1("AAGGCCTT");
- Sequence seq2("GGCCTTAA");
+ boost::shared_ptr<Sequence> seq1(new Sequence("AAGGCCTT"));
+ boost::shared_ptr<Sequence> seq2(new Sequence("GGCCTTAA"));
SequenceBrowser browser;
QVERIFY(browser.sequences().size() == 0);
}
void testSelect() {
- Sequence seq1("AAGGCCTT");
- Sequence seq2("GGCCTTAA");
+ boost::shared_ptr<Sequence> seq1(new Sequence("AAGGCCTT"));
+ boost::shared_ptr<Sequence> seq2(new Sequence("GGCCTTAA"));
SequenceBrowser browser;
browser.push_sequence(seq1);
--- /dev/null
+#include <QtGui>
+#include <QtTest/QtTest>
+
+#include "alg/sequence.hpp"
+#include "alg/glsequence.hpp"
+#include "alg/annotation_colors.hpp"
+#include "qui/seqbrowser/SequenceDescription.hpp"
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+class TestSequenceDescription : public QObject
+{
+ Q_OBJECT
+
+private slots:
+ void testSimple() {
+ boost::shared_ptr<Sequence> seq1(new Sequence("AAGGCCTT"));
+ seq1->set_species("foo");
+ boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
+ boost::shared_ptr<GlSequence> glseq1(new GlSequence(seq1, cm));
+
+ SequenceDescription sd(glseq1, 0);
+ QVERIFY(sd.glsequence() == glseq1);
+ QVERIFY(sd.glsequence()->sequence()->get_species() == seq1->get_species());
+ sd.setName(std::string("bar"));
+ QVERIFY(sd.glsequence()->sequence()->get_species() == seq1->get_species());
+ QVERIFY(seq1->get_species() == "bar");
+ }
+ void testDeletedPointer() {
+ SequenceDescription sd;
+
+ {
+ boost::shared_ptr<Sequence> seq1(new Sequence("AAGGCCTT"));
+ Sequence m("AAGG");
+ seq1->find_motif(m);
+ seq1->set_species("foo");
+ boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
+ boost::shared_ptr<GlSequence> glseq1(new GlSequence(seq1, cm));
+ sd.setGlSequence(glseq1);
+ }
+
+ QVERIFY(sd.name() == "foo");
+ }
+};
+
+QTEST_MAIN(TestSequenceDescription)
+#include "moc_TestSequenceDescription.cxx"
projects / mussa.git / commitdiff