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

use QT_QTASSISTANT_FOUND when detecting QtAssistant

fix problems instantiating mussa.GlSequence
with the switch to shared_ptr in the C++ code the original boost::python
GlSequence was wrong--it needed to be updated from references to shared_ptrs
and boost::python needed to be told that it's ok to have shared_ptrs to
Sequence and AnnotationColors.

And I also needed to tell boost::python about AnnotationColors, not that
I defined enough of a wrapper to use it.

make it possible to build mussa with python
(well actually this patch will now default to building with python)

Getting this to work required popping the qui/mussagl target down to the
root of the CMakeLists.txt because the executable depended on both the
mussa_qui library and the mussa_py library and the mussa_py code depended
on the mussa_qui library. Which meant that the simple linear ADD_DIRECTORY
structure wouldn't work. ADD_DIRECTORY(py) had to be between building
the qui library and the executable.

as a bonus this actually puts the executable in a more comprehensible
place.

Use BOOST_PYTHON_LIBRARY as python library guard
condition instead of BOOST_PYTHON_LIB (AKA I changed the name at some point
and forgot to update it.)

universal ld wrapper script
On OS X ld can't handle multiple architectures, this wrapper script
will parse the command line for multiple -arch statements and
compile each architecture seperately and glue them together with
lipo.

Build universal binaries on OS X
This large chunk of updates to mussa will build a universal on
OS X machines. This means that Qt and Boost will also need to be built as
universal binaries.

I suppose it might be nice to include some option for turning this off?

Windows XP support patch by Diane

Provide an app icon on OS X
derived from the nice SVG icon created with Inkscape.

include images used for bioinformatics journal club presentation

start the trivial sequence filter
repeatmasker is annoying because it is slow as a webservice and
depends on a bunch of hard to access components when run locally.

So the idea was how much of an improvment to mussa would there be if
we caught just the absolute simplest repeats?

ignore another build name

update os x building tools
to include network for qtassistant, and more space for the disk image.

Test for RST2HTML and BOOST_PYTHON_LIB

fix spelling error

Presentation for bioinformatics club.

start of presentation for bioinformatics journal club 2006 july 10

Manual: Motif update

 * Updated screenshots and text to reflect changes to the motif dialog box.

Manual: UCSC Update, Copy sequence, Sub-analysis

 * Added more screenshots
 * Updated UCSC Genome Browser sequence retrieval information
 * Copy sequence to clipboard section added
 * Subanalysis section added

Empty Subanalyses should not be run
brandon found a problem ticket:110 where clicking run with an empty
set of sequences caused a segfault. This patch disables the run button
when the model is empty.

Write cmake scripts for building the html manual
this is also the start of some docutils CMAKE support

SequenceLocationModel::clear should actually clear the model.
a cut-n-paste error meant that it actually just removed one element.

remove MotifDetail:: from function in class declaration

SequenceLocation was being intialized with left,right
not left,count. this made the getSubsequence rather wrong when the
'right' side was being used as a count.

make sure subsequences have a species name
copy species name from our source sequence

make subanalysis window editable
one can now edit the left and right sequence positions for the subanalysis
mode.