lookup python code with c++
use boost::algorithm::split to split our python namespace
reference.

Validate motif input
ticket:149
To reduce the chances that someone will manage to make an unloadable
motif file, prevent the user from entering bad data.
e.g. " in motif names, or non-iupac symbols in the sequence in
MotifEditorDelegate::createEditor

add Mussa::save_motif()
necessary for ticket:133
This adds the low level motif saving code to Mussa. To make things
work a bit more reliably, the parse code can understand the alpha
channel now (so I can save hidden motifs), and can parse a
motif name that is quoted like "foo asdf". I added that as I expect
users will put spaces in their motif names.

Although things'll probably break if someone puts a " in a motif name.
see ticket:149

throw errors when spirit parsing fails
ticket:126
this patch adds code to throw errors (and give some rough idea
where the error was) when the spirit parser fails. (Currently
either loading motifs, or loading sequence annotations).

Also I added a typedef to shorten std::set<Sequence> to motif_set

use spinboxes for the setup analysis dialog
ticket:148
the easiest way of making sure that threshold was less than window
size was to use spin boxes.

Also I updated the dialog box to use dynamically allocated Qt widgets.

a title of path("/my/silly/path") doesn't work on windows
since it doesn't really matter what it is just make sure
its the same length.

use lines if a quad would be smaller than a pixel
closes ticket:147
Mussa looks nicer when there's a minimum width to segments
connecting tracks.

initialize the motif_editor with analysis motifs
ticket:139 the motif editor dialog wasn't actually looking at the
motifs stored in the analysis to initialize its model with. So
when one either closed the window or tried initializing from a file
the dialog wouldn't reflect what was actually on the screen.

implement alphabet for sequence
in order to fix ticket:144 when motifs were changed to be
sequences I needed someway of specifying what alphabet a particular
sequence is using.

This patch changes things so a sequences default sequence alphabet
is a "AGCTUN" AKA reduced nucleic alphabet.

Motifs however use the full IUPAC nucleic alphabet.

(Or at least I hope they do I tested the sequence class, but GUI
testing is harder).

Another change is that instead of building a fixed reverse complement
table, there's a function which creates the table and understands
that at least for reduced_rna_alphabet (currently the only specifically RNA
alphabet) the reverse of A should be a.

Sequence is no longer case sensitive, all of the comparisons
are now done in an insensitive manner.

Finally I found a bug in the motif scanning code that was due to a typo
from long before I inherited the code. Aparently that code branch in
motif_scan had never been executed before.

length 1 segments should be drawn as lines
I also tried to center both the line and the character glyph a bit.
No I don't know why I needed to divide by 4.0 instead of 2.0. But
it looked better--so there.

draw link lines with a width
ticket:134
Segments connecting two sequence locations together now have a "length"
field which is drawn as a width across the screen.

The problem with this patch is that on the sequence view, where you want
a narrow line, it's drawing something the width of the base pair.

perhaps that's ok, or perhaps in that case I can have a length of 0,
or perhaps lenghts of 1 could also be drawn as a line, or perhaps
the edges of one of these rectangles should be shrunk a bit.

(that might also make things look a bit more centered.

add --motifs
ticket:143 this patch allows one to specify a motifs file to annotate
an analysis with.

trigger motif update from loadMotifList

fixes for Mussa::load_motif
If you're using references to pass variables from the boost::spirit parser
via a functor class, it might be useful to actually make sure the
class constructors parameters are references too.

This does improve how a motif file is parsed.

colors should default to being visible
alpha of 1 is visible, 0 is invisible. having a default of invisible
is confusing.

Add window titles
this patch adds window titles to most of the windows that Mussa will
popup. I refactored the code that figured out a reasonble title name
from MussaWindow and put it into Mussa.

This did mean that the SubanalysisWindow now needed its own copy
of a MussaRef so it could ask the analysis for its name.

fix wrong parent for scrollable_browser

Add ReadOnly ThresholdWidget to MussaAlignedWindow
The simplest way of report the threshold was to reuse the current
threshold widget. However since it makes no sense to change the threshold
at on the aligned sequence level view, I added the ability to make
the widget read only.

Use pointers in ThresholdWidget
Change threshold widget to use dynamically allocated objects
instead of statically allocated objects. I think Qt prefers this, but
now I'm less sure.

Allow MussaAlignedWindows to create subanalyses
I passed a shared_ptr reference for the subanalysis window
from MussaWindow to MussaAlignedWindow so either window can be used
to customize the same subanalysis.

Death to stupid mussa pointers
Long live smart pointers like boost::shared_ptr
Go through mussa and replace references to Mussa * or Mussa & with
a typedef MussaRef which is defined as boost::shared_ptr<Mussa>

add updateTitle
localize the code for updating the MussaWindow title.

Make MussaWindow UI objects pointers
It appears to me that Qt seems to like UI widgets that are attached to
it to be pointers as it'll sometimes handle freeing said pointer, which is
bad when its a statically allocated member of a class.

So this patch tries to make most of the UI objects associated with
MussaWindow pointers (I had to convert some elements of the
SequenceBrowserWidget as MussaWindow was storing references to them.)

better motif editor
ticket:122
This patch uses a QTableView for the motif editor which provides
both a better looking editor and supports adding an arbitrary number of
motifs.

Tool for inserting changelog into rst documents (i.e. manual)

Mussagl Manual: Status Section

Win32 SaveAs Patch

If we don't need any python link libraries don't produce output
this is to fix an issue brandon found

Mussagl Manual: Spelling and Grammar Fixes

 * Made some spelling and error fixes thanks... Thanks Erich!

catch possible segfault with get_sequence()

need a cassert

Remember to include Platform to get PYTHON_LINK_LIBARIES
ticket:125
I forgot to include Platform in the base CMakeLists.txt to get the
definition of PYTHON_LINK_LIBRARIES. With that everything builds correctly.

ask python what libraries we need to link with
ticket:125 (hopefully fixes)
distutils has some nice variables that will tell us what system libraries
we need to link with.

This patch includes a small python wrapper that makes it easy for cmake
to extract that information.

Load saved analysis can open new windows
ticket:105
this makes mussa behave a bit more like a traditional gui app, in that
saved analyses will replace empty windows, but will create new windows
if there's already something loaded.

Also new windows will copy the default_dir from the parent window.

if you need to do a save as, you really don't need to save too
when you comment out an else if, perhaps you should leave in the else
part.

remember the last directory we were did something in
and then default new operations to that directory.

AKA if we open a mupa file /this/path/to.mupa the next time we open a dialog
to do some IO it will default to /this/path

remove reporting the current path from the about box
that was mostly in there for debugging and isn't needed anymore

use the loaded analysis path as the default save path
if no save location is specified for an analysis and we happen to have
an analysis location that we were loaded from, default to saving to the
same location.

always save
the mussa dirty flag isn't updated in enough situations, like if you
change a sequences meta data, the mussa dirty flag isn't updated.

Might make sense that once glsequence is a subclass of sequence to
put a dirty flag there.

keep track of a subsequences parent
fixes ticket:129
I needed to know the parent offset inorder to get the start/stop sizes
to be relative to its parent in a "sequence" tree.

report our "start/stop" location on a subsequence
this should be useful for trying to use sequences as a replacement
for the annotation class.

of course ticket:129 is a problem. I need to figure out how to get
the start/stop coordinates to be relative to the immediate parent, not
relative to the base sequence. (Or perhaps i should be able to retrieve
both versions)

use an enum instead of a bool for strandedness
I wanted to track more than +/- strand, I wanted to know if an annotation
was "unknown" or perhaps applied to both strands.

make our Color class serializable
this is part of an idea to move the color of a sequence into
the sequence class, instead of living in glsequence or the
AnnotationColor mapper.

do a better job of erasing the browser sidebars
ticket:127
the previous sidebar clearing code didn't remove the spacers between
the various widgets. This will do that (though for some reason
QLayout::removeItem wouldn't properly destroy my widgets, I had to use
QLayout;:removeWidget on them, which is why there are two loops in
SequenceBrowserSidebar::clear.

I also defined some typedefs in SequenceBrowserSidebar to abstract out
the exact type being used to store the sidebar detail widgets
(SequenceDescription) in case I want to switch to a boost::shared_ptr in case I want to switch to a boost::shared_ptr in case I want to switch to a boost::shared_ptr in case I want to switch to a boost::shared_ptr

make sure we show the start of our sequence name
fixes ticket:128

Implement an optional name in the motif parser
ticket:116
Using the spirit parser the motif file now takes a sequence, optional name,
and the RGB float colors.

The down side to this is I don't currently know how to get spirit to report
parse errors.

Mussa Manual: Todo comments

MussaSetupDialog remembers previous load directory
Implements ticket:101
Basically the setup dialog kept using the current directory, this
patch stores a "default_directory" in the SequenceSetupFrame so the
various SequenceSetupWidgets have a place to grab a default directory.

It starts off set to the "current" path, but whill remember whatever
you pick after that. (Perhaps it should default to the home directory?)

default saveAnalysisAs to users home directory

warn the user if we're going to replace an analysis
though users would prefer a new window when they pick load, that causes
problems because I don't have an easy way for the new window to be
responsible for the Mussa::analyze() call.

So currently the create new window mode will occasionally cause mussa to
hang. As a result I loading will replace the current window.

implement "typical" save and close conventions.
After running an analysis if it hasn't been saved, and you try to close
the window, mussa will ask if you want to save, not save, or cancel the close.
Saving also uses the recently implemented tracking the analysis_path to
determine if it should just offer to save or to use save as.

the only real issue is the dirty flag might get tripped for things
that aren't actually being saved yet.

track where our analysis is saved and if the analysis is empty
This will be useful for getting typical office application like save/save as
conventions working.

implement analysis save as dialog
this does seem to let you save an analysis. So I need to get the autosaving
to turn off.

and it defaults to the app "current" directory which isn't ideal.

add seq_forward
its one more step toward getting a sequence to have all of its necessary
sequence location information.

I also changed the test in set_filtered_sequence for the count from 0 to
npos.

make really sure load_mupa has a file to parse.
Fixes ticket:121
This includes more filesystem checks to make sure we're reading something
that's a file, and instead of doing fstream.eof() this uses the more
general bool converter for the stream. Which I think is equivalent to
fstream::good() (a more general test than fstream::eof() )

subsequences now use offsets into the shared_ptr seq_string
A subsequence created with the Sequence::subseq call will use
the creating sequences shared_ptr, and then just maintains
a seq_start and seq_count to indicate the start and number of bytes
in the subseq. (Yes this means that sometiems the c_str will let you
read more than you should actually be able to. But try not to depend
on that).

catch a few more potential unchecked shared_ptr dereferences.

remove commented out string conversion
and prevet a possible shared_ptr dereference in c_str()

Figured out how to serialize a shared_ptr<string>
My previous efforts at serializing a std::string stored as a shared_ptr
appear to have been foiled because the default shared_ptr serializaiton code
was expecting the class serializaiton code to be part of the class member
and alas std::string has out of class serialization.

So the simple solution was to make a subclass of std::string whose only
contribution was to define the serialization code. Also it turns out
there were some problems with the BOOST_SERIALIZATION_BASE_NVP macro
for the seq_string class, however when I expanded it manually, everything
seemed to work.

go back to using const char * in seqcomp
it appears that the string iterator version is about half as fast
as just using raw const char * pointers.

Hopefully the string pointers won't get moved around behind the scenes
while seqcomp is running. (Currently shouldn't as once a sequence is
set it's supposed to be constant.

use shared_ptr to store the sequence string
on the plus side this means there only needs to be one copy of a sequence
string loaded.
on the minus side this currently breaks the boost::serialization code
as I don't know how to get it to serialize a shared_ptr properly.

put basepair alphabets into the Sequence class
thanks to google i found the proper way to initialize a static const string.
I also added the protein 1-letter alphabet. At some point it should be possible
to initialize different alphabets for a sequence.

go back to sequence being its own class
So my first attempt at getting the sequence tree hierarchy working
ended up imploding in too much complexity. So I decided to try again
in smaller steps. This version just switches back to sequence not being a
string.

one other problem is that iterators didn't seem to be serializable.
so there might be some problem writing a sequence with a tree
of annotated subsequences attached to it out.

There's something wrong with the Qt tests, skip for the moment
the CMake code to generate the moc_ files seems broken with newer versions
of cmake

fedora needs -lutil for python to build

need to #include <cassert> if i'm going to use asserts

forgot namespace declaration on some conditional code

start trying to figure out where the documentation is
on os x determine the bundle path as a first step to finding where we might
have stored qtassistent and the documentation tree.

currently being ignored as i can more easly just launch a webbrowser to
our website.

update sequence serialization to support the xml archive

Allow changing the name for a sequence in the sequence browser.
Doing this required being much more thorough about always using
boost::shared_ptr<>s for GlSequences and Sequences.

When you initalize a shared pointer from something that wasn't specially
allocated for it using new, bad things happen.

This is more of me learning that if one has a temptation to store a reference
don't. Instead use a shared_ptr or similar.

catch the other spurious class decoration

remove unnecessary class member decoration

Mussa Icon: Windows .ico version

Fix merge issues with the win32 library patch

Reorder libraries for win32
Also remove the stuff that conditionally compiled python since we
now pretty strongly depend on it.

And remember mingw32 really needs the library with the most dependencies
to be listed first.

Tell unittests to use native file convention for EXAMPLE_DIR
C:/stuff/asdf wasn't parsable by boost::filesystem::path I (diane) couldn't
figure out how to specify platform independent paths, so I hacked
the CMakeLists.txt file to shove enough backslashes into define and told
boost::filesystem::path to use native file paths.

Update SequenceDescription to have signal/slots
I'm trying to figure out how to make the sequence name editable and it
seemed like it would be useful to have a sequence description be able
to emit if its name changed.

do a better job of grouping seqbrowser sidebar information.
Add a stretch region so the sequence description information isn't as
spread out over the sidebar.

Try alpha blending the conservation paths
It was too easy to lose selected tracks behind other, later drawn, tracks.
Perhaps alpha blending will let us see them better.

remove the useless hide motif button.

Let the annotation parser skip html tags
Since we're telling people to download annotation pages from websites
to cut down on support requests I extended the parser to skip <html></html>
tags. (basically anything of the form "space* <[!>+> space*"

Implement serialize for sequence
This manages to save Sequence, motif, and annot using boost::serialization.

I added a serialize_simple to test_sequence.cpp

On the down side with this patch mussa now depends on boost::serialize
libraries.

(And it was harder to get working than I'd expected. I missed the fact
that there seems to be limits about sending non-const objects to an
archive class. I also found it useful to put the
template<class Archive> serialize() function into the header with
and to mark the class with BOOST_CLASS_EXPORT(). If one includes
the boost/archive/*archive classes before including sequence.hpp,
the BOOST_CLASS_EXPORT will force the appropriate template to be
instantiated.)

start breaking save out from Mussa::analyze()
This patch changes Mussa::save() to take a boost::filesystem::path
so we have some hope of saving to a specified location.

However so the application will continue to work while I go try
the boost::serialize path, I left the save() call in analyze(), so
it will continue to auto-save.

For this to work I'll need to add a save option to the gui and
remove the save call in analyze.

(Though I did leave the save() call in parse_option that will
force saving a run when launched from the command line.

Add documentation about Mussa::soft_threshold

remove mck3test.museq and .muway
those shouldn't exist as they should be generated by running
the app?

Add serialization library to FindBoost
and sort the boost library names.

add dirty flag
Before we can have Mussa track if it needs to be saved we need some
flag to indicate when we have unsaved changes.

change from cout to clog in some commented out debugging messages.

Define analysis scroll area implementation

 * Define analysis now uses a scroll area so when you add more than 3 SequenceWidgets it automatically scrolls, allowing many more sequences to be added.
 * See ticket:56 for more information.

set mussa analysis name in MussaSetupWidget
Without an analysis name the save code wouldn't save anything. This
also throws an error message when there isn't an analysis name.

And as a hack one can put a filename in the analysis name and actually
have it save to that location.

update osxdist to point to qt 4.1.4

fix ticket:115 display sequences in order added
Somewhere the sequences were being reversed in the sequence of setups from
extracting from the dialog and attaching them to mussa. For a really
lazy solution I just changed one of the iterators to a reverse iterator
and dealt with it. (Hopefully this won't now end up on
http://thedailywtf.com/

Use CMAKE_BINARY_DIR instead of the very wrong MUSSA_BINARY_DIR

Since building with cmake 2.2 didn't work up the required version

set current doc url

Implement a convienence class for accessing python interpreter
MussaPython provides a couple of convienence functions to make
it easy to grab python objects out of the python interpreter
and play with them at the C++ layer.

I used this to let the help action call webbrowser.open to go
to our documentation. (or at least our website).

Also to make my life a little safer I also wrote a simple unit test
for that python interface.

The one unfortuante problem is that I ended up with a cyclic library
dependency which meant I needed to remove the Qt gui python wrapping
code from my current python library. Hopefully I can resolve that later.

rename glseq.width to glseq.size in gl.py

update gl.py to show how to add an annotation

add annot and motif classes to python interface
this also involved renaming annot.start to annot.begin to be a bit
more consistent with the begin/end convention used by C++.
I also added some more of the sequence class api to the python layer.
(so there's some hope that one could add annotations)

update gl.py glut example code