implement "typical" save and close conventions.
[mussa.git] / qui / MussaWindow.cpp
1 #include "py/python.hpp"
2 #include "qui/MussaWindow.hpp"
3 #include "mussa_exceptions.hpp"
4
5 #include <QAction>
6 #include <QApplication>
7 #include <QAssistantClient>
8 #include <QCloseEvent>
9 #include <QDir>
10 #include <QFileDialog>
11 #include <QHBoxLayout>
12 #include <QIcon>
13 #include <QMenuBar>
14 #include <QMessageBox>
15 #include <QScrollBar>
16 #include <QStatusBar>
17 #include <QString>
18 #include <QStringList>
19 #include <QWhatsThis>
20
21 #include <memory>
22 #include <iterator>
23 #include <iostream>
24
25 #include <boost/filesystem/path.hpp>
26 #include <boost/filesystem/operations.hpp>
27 namespace fs = boost::filesystem;
28 #include <boost/bind.hpp>
29
30 using namespace std;
31
32 MussaWindow::MussaWindow(Mussa *analysis_, QWidget *parent) :
33   QMainWindow(parent),
34   analysis(analysis_),
35   motif_editor(0),
36   setup_analysis_dialog(this),
37   browser(this),
38   mussaViewTB("Path Views"),
39   zoom(),
40   threshold(),
41   progress_dialog(0),
42   aboutAction(0),
43   closeAction(0),
44   createNewAnalysisAction(0),
45   createSubAnalysisAction(0),
46   editMotifsAction(0),
47   loadMotifListAction(0),
48   loadMupaAction(0),
49   loadSavedAnalysisAction(0),
50   mussaManualAssistantAction(0),
51   newMussaWindowAction(0),
52   saveMotifListAction(0),
53   showMussaViewToolbarAction(0),
54   toggleMotifsAction(0),
55   saveBrowserPixmapAction(0),
56   whatsThisAction(0),
57   viewMussaAlignmentAction(0),
58   manualAssistant(0)
59 {
60   setupActions();
61   setupMainMenu();
62   setupAssistant();
63
64   //This next setWhatsThis function prevents
65   // a segfault when using WhatsThis feature with 
66   // opengl widget.
67   //scene->setWhatsThis(tr("Mussa in OpenGL!"));
68   setCentralWidget(&browser);
69   // well updatePosition isn't quite right as we really just need
70   // to call update()
71   connect(this, SIGNAL(changedAnnotations()), &browser, SLOT(update()));
72
73   //mussaViewTB.addAction(toggleMotifsAction);
74   mussaViewTB.addWidget(&zoom);
75   
76   connect(&zoom, SIGNAL(valueChanged(double)), 
77           &browser, SLOT(setZoom(double)));
78   
79   // threshold range is set in updateAnalysis
80   
81   //scene->setClipPlane(20);
82   // FIXME: for when we get the paths drawn at the appropriate depth
83   //connect(&threshold, SIGNAL(thresholdChanged(int)),
84   //        this, SLOT(setClipPlane(int)));
85   connect(&threshold, SIGNAL(thresholdChanged(int)),
86           this, SLOT(setSoftThreshold(int)));
87   mussaViewTB.addWidget(&threshold);
88
89   addToolBar(&mussaViewTB);
90
91   statusBar()->showMessage("Welcome to mussa", 2000);
92   connect(analysis, SIGNAL(progress(const std::string&, int, int)),
93           this, SLOT(updateProgress(const std::string&, int, int)));
94   updateAnalysis();
95 }
96
97 void MussaWindow::setAnalysis(Mussa *new_analysis)
98 {
99   if (new_analysis != 0) {
100     // only switch mussas if we loaded without error
101     clear();
102     delete analysis;
103     analysis = new_analysis;
104     setWindowTitle(analysis->get_name().c_str());
105     updateAnalysis();
106   }
107 }
108
109 void MussaWindow::setupActions()
110 {
111   // we really don't want to run this more than once.
112   assert (closeAction == 0);
113
114   // the ever popular about box
115   aboutAction = new QAction(tr("&About"), this);
116   connect(aboutAction, SIGNAL(triggered()), this, SLOT(about()));
117   aboutAction->setIcon(QIcon(":/icons/info.png"));
118
119   // add exit
120   closeAction = new QAction(tr("&Close"), this);
121   closeAction->setStatusTip(tr("Close this window"));
122   connect(closeAction, SIGNAL(triggered()), this, SLOT(close()));
123   closeAction->setIcon(QIcon(":/icons/exit.png"));
124   
125   createNewAnalysisAction = new QAction(tr("Create Analysis"), this);
126   connect(createNewAnalysisAction, SIGNAL(triggered()), 
127           this, SLOT(createNewAnalysis()));
128   createNewAnalysisAction->setIcon(QIcon(":/icons/filenew.png"));
129   
130   createSubAnalysisAction = new QAction(tr("Add to Subanalysis"), this);
131   connect(createSubAnalysisAction, SIGNAL(triggered()), 
132           this, SLOT(createSubAnalysis()));
133
134   saveAnalysisAction = new QAction(tr("&Save Analysis"), this);
135   connect(saveAnalysisAction, SIGNAL(triggered()), 
136           this, SLOT(saveAnalysis()));
137   saveAnalysisAction->setIcon(QIcon(":/icons/filesave.png"));
138
139   saveAnalysisAsAction = new QAction(tr("Save Analysis &As"), this);
140   connect(saveAnalysisAsAction, SIGNAL(triggered()), 
141           this, SLOT(saveAnalysisAs()));
142   saveAnalysisAsAction->setIcon(QIcon(":/icons/filesave.png"));
143
144   editMotifsAction = new QAction(tr("Edit Motifs"), this);;
145   connect(editMotifsAction, SIGNAL(triggered()), this, SLOT(editMotifs()));
146   
147   loadMotifListAction = new QAction(tr("Load Motif List"), this);
148   connect(loadMotifListAction, SIGNAL(triggered()), 
149           this, SLOT(loadMotifList()));
150   loadMotifListAction->setIcon(QIcon(":/icons/fileopen.png"));
151   
152   loadMupaAction = new QAction(tr("Create Analysis from File"), this);
153   connect(loadMupaAction, SIGNAL(triggered()), 
154           this, SLOT(loadMupa()));
155   loadMupaAction->setIcon(QIcon(":/icons/fileopen.png"));
156
157   loadSavedAnalysisAction = new QAction(tr("Load Existing &Analysis"), this);
158   connect(loadSavedAnalysisAction, SIGNAL(triggered()), 
159           this, SLOT(loadSavedAnalysis()));
160   loadSavedAnalysisAction->setIcon(QIcon(":/icons/fileopen.png"));
161
162   mussaManualAssistantAction = new QAction(tr("Mussagl Manual..."), this);
163   mussaManualAssistantAction->setIcon(QIcon(":/icons/contents.png"));
164   connect(mussaManualAssistantAction, SIGNAL(triggered()),
165           this, SLOT(showManual()));
166
167   newMussaWindowAction = new QAction(tr("&New Mussa Window"), this);
168   newMussaWindowAction->setStatusTip("open another mussa window to allow comparing results");
169   connect(newMussaWindowAction, SIGNAL(triggered()), 
170           this, SLOT(newMussaWindow()));
171   newMussaWindowAction->setIcon(QIcon(":/icons/window_new.png"));
172
173   saveMotifListAction = new QAction(tr("Save Motifs"), this);
174   connect(saveMotifListAction, SIGNAL(triggered()), 
175           this, SLOT(saveMotifList()));
176   saveMotifListAction->setIcon(QIcon(":/icons/filesave.png"));
177
178   showMussaViewToolbarAction = new QAction(tr("Show Toolbar"), this);
179   connect(showMussaViewToolbarAction, SIGNAL(triggered()), 
180           this, SLOT(showMussaToolbar()));
181   showMussaViewToolbarAction->setCheckable(true);
182   showMussaViewToolbarAction->setChecked(true);
183
184   toggleMotifsAction = new QAction(tr("Toggle Motifs"), this);
185   connect(toggleMotifsAction, SIGNAL(triggered()), 
186           this, SLOT(toggleMotifs()));
187   toggleMotifsAction->setCheckable(true);
188   toggleMotifsAction->setIcon(QIcon(":/icons/motif_icon.png"));
189   toggleMotifsAction->setWhatsThis(tr("Toggle motif annotations on/off\n\n"
190                                    "You can load motif annotations via "
191                                    "'File->Load Motif List' menu option."));
192
193   //Save pixel map action
194   saveBrowserPixmapAction = new QAction(tr("Save to image..."), this);
195   connect(saveBrowserPixmapAction, (SIGNAL(triggered())),
196           &browser, SLOT(promptSaveBrowserPixmap()));
197   saveBrowserPixmapAction->setIcon(QIcon(":/icons/image2.png"));
198
199   viewMussaAlignmentAction = new QAction(tr("View sequence alignment"), this);
200   connect(viewMussaAlignmentAction, SIGNAL(triggered()),
201           this, SLOT(viewMussaAlignment() ));
202   viewMussaAlignmentAction->setWhatsThis(tr("Create a zoomed in window "
203                                             "showing alignment of the seqcomp "
204                                             "defined paths"));
205
206   whatsThisAction = QWhatsThis::createAction(this);
207   whatsThisAction->setIcon(QIcon(":/icons/help.png"));
208
209
210 }
211
212 void MussaWindow::closeEvent(QCloseEvent *event)
213 {
214   if(isClearingAnalysisSafe()) {
215     event->accept();
216   } else {
217     event->ignore();
218   }
219 }
220
221 void MussaWindow::setupMainMenu()
222 {
223   // we need to run setupActions first
224   assert (closeAction != 0);
225
226   QMenu *newMenu = menuBar()->addMenu(tr("&File"));
227   
228   newMenu->addAction(newMussaWindowAction);
229   newMenu->addAction(createNewAnalysisAction);
230   newMenu->addAction(loadMupaAction);
231   newMenu->addAction(loadSavedAnalysisAction);
232   newMenu->addAction(saveAnalysisAction);
233   newMenu->addAction(saveAnalysisAsAction);
234   newMenu->addSeparator();
235   newMenu->addAction(loadMotifListAction);
236   newMenu->addAction(saveMotifListAction);
237   newMenu->addSeparator();
238   newMenu->addAction(saveBrowserPixmapAction);
239   newMenu->addSeparator();
240   newMenu->addAction(closeAction);
241
242   newMenu = menuBar()->addMenu(tr("&Edit"));
243   newMenu->addAction(editMotifsAction);
244   newMenu->addAction(&browser.getCopySelectedSequenceAsFastaAction());
245   newMenu->addAction(createSubAnalysisAction);
246  
247   newMenu = menuBar()->addMenu(tr("&View"));
248   newMenu->addAction(viewMussaAlignmentAction);
249   newMenu->addAction(showMussaViewToolbarAction);
250
251   newMenu = menuBar()->addMenu(tr("&Help"));
252   newMenu->addAction(mussaManualAssistantAction);
253   newMenu->addAction(whatsThisAction);
254   newMenu->addSeparator();
255   newMenu->addAction(aboutAction);
256
257   // add some extra features to the context menu
258   QMenu& popupMenu = browser.getPopupMenu();
259   popupMenu.addAction(viewMussaAlignmentAction);
260   popupMenu.addAction(createSubAnalysisAction);
261 }
262
263 void MussaWindow::setupAssistant()
264 {
265 #if defined(QT_ASSISTANT_FOUND)
266   QStringList manualAssistantArgs;
267   manualAssistantArgs = QStringList();
268   manualAssistantArgs << "-profile" << "./doc/manual/mussagl_manual.adp";
269   manualAssistant = new QAssistantClient("assistant", this);
270   manualAssistant->setArguments(manualAssistantArgs);
271   connect(manualAssistant, SIGNAL(error(QString)),
272           this, SLOT(assistantError(QString)));
273 #endif
274 }
275   
276 void MussaWindow::about()
277 {
278   QString msg("Welcome to Multiple Species Sequence Analysis\n"
279               "(c) 2005-2006 California Institute of Technology\n"
280               "Tristan De Buysscher, Diane Trout\n");
281    msg += "\n\r";
282    msg += "Path: ";
283    msg += QDir::currentPath();
284    msg += "\n";
285    msg += "OpenGL: ";
286    msg += (char *)glGetString(GL_VERSION);
287    msg += "\n";
288    QMessageBox::about(this, tr("About mussa"), msg);
289 }
290
291 void MussaWindow::clear()
292 {
293   aligned_windows.clear();
294   browser.clear();
295 }
296
297 void MussaWindow::createNewAnalysis()
298 {
299   try {
300     if (setup_analysis_dialog.exec()) {
301       Mussa *m = 0;
302       m = setup_analysis_dialog.getMussa();
303       setAnalysis(m);
304     } else {
305       std::cout << "New mussa exp. aborted!\n";
306     }
307   } catch(mussa_error e) {
308     QString msg(e.what());
309     QMessageBox::warning(this, tr("Create New Analysis"), msg);
310   }
311 }
312
313 void MussaWindow::createSubAnalysis()
314 {
315   list<SequenceLocation> result;
316   SequenceLocationModel& model = subanalysis_window.getModel();
317   browser.copySelectedTracksAsSeqLocation(result);
318   for(list<SequenceLocation>::iterator result_itor = result.begin();
319       result_itor != result.end();
320       ++result_itor)
321   {
322     model.push_back(*result_itor);
323   }
324
325   if (not subanalysis_window.isVisible()) {
326     subanalysis_window.show();
327   }
328 }
329
330 void MussaWindow::saveAnalysis()
331 {
332   // if we've got an analysis
333   if (analysis and not analysis->empty()) {
334     // if it doesn't have a name we need to pick one
335     if (analysis->get_analysis_path().empty()) {
336       saveAnalysisAs();
337     }      
338     // if we've got a name, has it changed any?
339     else if (analysis->is_dirty()) {
340       analysis->save();
341     }
342   }
343 }
344
345 void MussaWindow::saveAnalysisAs()
346 {
347   std::auto_ptr<QFileDialog> dialog(new QFileDialog(this));
348   dialog->setAcceptMode(QFileDialog::AcceptSave);
349   dialog->setFileMode(QFileDialog::AnyFile);
350
351   QStringList fileNames;
352   if (not dialog->exec()) {
353     return;
354   }
355   fileNames = dialog->selectedFiles();
356    
357   if (fileNames.size() != 1) {
358     return;
359   }
360
361   fs::path save_path(fileNames[0].toStdString());
362   // do you want to overwrite?
363   if (fs::exists(save_path) and 
364       QMessageBox::question(
365         this,
366         tr("Overwrite File? -- Mussa"),
367         tr("A file called %1 already exists"
368            "do you want to overwrite it?")
369            .arg(fileNames[0]),
370         tr("&Yes"), tr("&No"),
371         QString(), 0, 1)
372       ) {
373     return;
374   }
375   analysis->save(save_path);
376 }
377
378 bool MussaWindow::isClearingAnalysisSafe()
379 {
380   if (analysis and not analysis->empty() and analysis->is_dirty()) {
381     switch (QMessageBox::question(
382       this,
383       tr("Save Unsaved Changes -- Mussa"),
384       tr("There are unsaved changes,\ndo you want to save?"),
385       tr("&Yes"), tr("&No"), tr("&Cancel"),
386       0, 2)) {
387     case 0:
388       // save
389       saveAnalysis();
390       break;
391     case 1:
392       // don't save
393       break;
394     case 2:
395       // don't replace 
396       return false;
397       break;
398     default:
399       // error
400       throw runtime_error("isClearingAnalysis QMesageBox failure");
401     }
402   } 
403   // if we're here we've been saved and can replace
404   return true;
405 }
406
407 void MussaWindow::editMotifs()
408 {
409   if (motif_editor != 0) {
410     motif_editor->hide();
411     delete motif_editor;
412   }
413   motif_editor = new MotifEditor(analysis);
414   connect(motif_editor, SIGNAL(changedMotifs()), 
415           this, SLOT(updateAnnotations()));
416   motif_editor->show();
417 }
418
419 void MussaWindow::loadMotifList()
420 {
421   QString caption("Load a motif list");
422   QString filter("Motif list(*.txt *.mtl)");
423   QString path = QFileDialog::getOpenFileName(this,
424                                                    caption, 
425                                                    QDir::currentPath(),
426                                                    filter);
427   // user hit cancel?
428   if (path.isNull()) 
429     return;
430   // try to load safely
431   try {
432     fs::path converted_path(path.toStdString(), fs::native);
433     analysis->load_motifs(converted_path);
434   } catch (runtime_error e) {
435     QString msg("Unable to load ");
436     msg += path;
437     msg += "\n";
438     msg += e.what();
439     QMessageBox::warning(this, "Load Motifs", msg);
440   }
441   assert (analysis != 0);
442 }
443
444 void MussaWindow::saveMotifList()
445 {
446   NotImplementedBox();
447 }
448
449 void MussaWindow::loadMupa()
450 {
451   QString caption("Load a mussa parameter file");
452   QString filter("Mussa Parameters (*.mupa)");
453   QString mupa_path = QFileDialog::getOpenFileName(this,
454                                                    caption, 
455                                                    QDir::currentPath(),
456                                                    filter);
457   // user hit cancel?
458   if (mupa_path.isNull()) 
459     return;
460   // try to load safely
461   try {
462     Mussa *m = new Mussa;
463     fs::path converted_path(mupa_path.toStdString(), fs::native);
464     connect(m, SIGNAL(progress(const std::string&, int, int)),
465             this, SLOT(updateProgress(const std::string&, int, int)));
466     m->load_mupa_file(converted_path);
467     m->analyze();
468     setAnalysis(m);
469     setWindowTitle(converted_path.native_file_string().c_str());
470   } catch (mussa_load_error e) {
471     QString msg("Unable to load ");
472     msg += mupa_path;
473     msg += "\n";
474     msg += e.what();
475     QMessageBox::warning(this, "Load Parameter", msg);
476   }
477   assert (analysis != 0);
478 }
479
480 void MussaWindow::loadSavedAnalysis()
481 {
482   QString caption("Load a previously run analysis");
483   QString muway_dir = QFileDialog::getExistingDirectory(this,
484                                                         caption, 
485                                                         QDir::currentPath());
486   // user hit cancel?
487   if (muway_dir.isNull()) 
488     return;
489   // try to safely load
490   try {
491     Mussa *m = new Mussa;
492     fs::path converted_path(muway_dir.toStdString(), fs::native);
493     connect(m, SIGNAL(progress(const std::string&, int, int)),
494             this, SLOT(updateProgress(const std::string&, int, int)));
495     m->load(converted_path);
496     // only switch mussas if we loaded without error
497     setAnalysis(m);
498     setWindowTitle(converted_path.native_file_string().c_str());
499   } catch (mussa_load_error e) {
500     QString msg("Unable to load ");
501     msg += muway_dir;
502     msg += "\n";
503     msg += e.what();
504     QMessageBox::warning(this, "Load Parameter", msg);
505   }
506   assert (analysis != 0);
507 }
508
509 void MussaWindow::newMussaWindow()
510 {
511   Mussa *a = new Mussa();
512   MussaWindow *win = new MussaWindow(a);
513   win->show();
514 }
515
516 void MussaWindow::setSoftThreshold(int threshold)
517 {
518   if (analysis->get_soft_threshold() != threshold) {
519     analysis->set_soft_threshold(threshold);
520     analysis->nway();
521     updateLinks();
522     update();
523   }
524 }
525
526 void MussaWindow::showMussaToolbar()
527 {
528   if (mussaViewTB.isVisible())
529     mussaViewTB.hide();
530   else
531     mussaViewTB.show();
532 }
533
534 void MussaWindow::toggleMotifs()
535 {
536   NotImplementedBox();
537 }
538
539 void MussaWindow::showManual()
540 {
541 #if QT_QTASSISTANT_FOUND
542   manualAssistant->openAssistant();
543 #else
544   try {
545     boost::python::object webopen = get_py()["webbrowser.open"];
546     webopen("http://woldlab.caltech.edu/~king/mussagl_manual/");
547   } catch( boost::python::error_already_set ) {
548     PyErr_Print();
549   }
550 #endif //QT_QTASSISTANT_FOUND
551 }
552
553 void MussaWindow::assistantError(QString message)
554 {
555   //std::cout << "QAssistantError: " << message.toStdString() << "\n";
556   QMessageBox::warning ( this, "Warning: Mussagl Manual", message, 
557                          QMessageBox::Ok, 
558                          QMessageBox::NoButton);
559 }
560
561 void MussaWindow::NotImplementedBox()
562 {
563   QMessageBox::warning(this, QObject::tr("mussa"), QObject::tr("Not implemented yet"));
564 }      
565
566 void MussaWindow::viewMussaAlignment()
567 {
568   const set<int>& selected_paths = browser.selectedPaths();
569   if (selected_paths.size() == 0 ) {
570     QMessageBox::warning(this, 
571                          QObject::tr("mussa"),
572                          QObject::tr("you should probably select some paths "
573                                      "first"));
574   } else {
575     boost::shared_ptr<MussaAlignedWindow> ma_win( 
576       new MussaAlignedWindow(*analysis, selected_paths)
577     );
578
579     aligned_windows.push_back(ma_win);
580     connect(this, SIGNAL(changedAnnotations()), 
581             aligned_windows.back().get(), SLOT(update()));
582     aligned_windows.back()->show();
583   }
584 }
585                         
586 void MussaWindow::updateAnalysis()
587 {
588   threshold.setRange(analysis->get_threshold(),analysis->get_window());
589
590   const Mussa::vector_sequence_type& seqs = analysis->sequences();
591   browser.setSequences(seqs, analysis->colorMapper());
592   updateLinks();
593   browser.zoomOut();
594   zoom.setValue(browser.zoom());
595 }
596
597 void MussaWindow::updateAnnotations()
598 {
599   // motifs were changed in the sequences by 
600   // Mussa::update_sequences_motifs
601   emit changedAnnotations();
602   browser.update();
603 }
604
605 void MussaWindow::updateLinks()
606 {
607   browser.clear_links();
608   bool reversed = false;
609   const NwayPaths& nway = analysis->paths();
610
611   typedef list<ConservedPath> conserved_paths;
612   typedef conserved_paths::const_iterator const_conserved_paths_itor;
613   for(const_conserved_paths_itor path_itor = nway.refined_pathz.begin();
614       path_itor != nway.refined_pathz.end();
615       ++path_itor)
616   {
617     // since we were drawing to the start of a window, and opengl lines
618     // are centered around the two connecting points our lines were slightly
619     // offset. the idea of window_offset is to adjust them to the
620     // right for forward compliment or left for reverse compliment
621     // FIXME: figure out how to unit test these computations
622     //GLfloat window_offset = (path_itor->window_size)/2.0;
623
624     size_t track_len = path_itor->track_indexes.size();
625     vector<int> normalized_path;
626     normalized_path.reserve(track_len);
627     vector<bool> rc_flags(false, track_len);
628     for (size_t track_i=0; track_i != track_len; ++track_i)
629     {
630       int x = path_itor->track_indexes[track_i];
631       // at some point when we modify the pathz data structure to keep
632       // track of the score we can put grab the depth here.
633       //
634       // are we reverse complimented?
635       if ( x>=0) {
636         reversed = false;
637       } else {
638         reversed = true;
639         // make positive 
640         x = -x;
641       }
642       normalized_path.push_back(x);
643       rc_flags.push_back(reversed);
644     }
645     browser.link(normalized_path, rc_flags, path_itor->window_size);
646   }
647   browser.update();
648 }
649
650 void 
651 MussaWindow::updateProgress(const string& description, int current, int max)
652 {  
653   // if we're done  
654   if (current == max) {
655     if (progress_dialog != 0) {
656       progress_dialog->hide();
657       delete progress_dialog;
658       progress_dialog = 0;
659     }
660   } else {
661     // if we're starting, create the dialog
662     if (progress_dialog == 0) {
663       QString desc(description.c_str());
664       QString cancel("Cancel");
665       progress_dialog = new QProgressDialog(desc, cancel, current, max, this);
666       progress_dialog->show();
667     } else {
668       // just update the dialog
669       progress_dialog->setValue(current);
670     }
671   }
672   qApp->processEvents();
673 }