NCBI C++ ToolKit
common_commands.cpp
Go to the documentation of this file.

Go to the SVN repository for this file.

1 /* $Id: common_commands.cpp 44490 2020-01-03 16:14:20Z filippov $
2  * ===========================================================================
3  *
4  * PUBLIC DOMAIN NOTICE
5  * National Center for Biotechnology Information
6  *
7  * This software/database is a "United States Government Work" under the
8  * terms of the United States Copyright Act. It was written as part of
9  * the author's official duties as a United States Government employee and
10  * thus cannot be copyrighted. This software/database is freely available
11  * to the public for use. The National Library of Medicine and the U.S.
12  * Government have not placed any restriction on its use or reproduction.
13  *
14  * Although all reasonable efforts have been taken to ensure the accuracy
15  * and reliability of the software and data, the NLM and the U.S.
16  * Government do not and cannot warrant the performance or results that
17  * may be obtained by using this software or data. The NLM and the U.S.
18  * Government disclaim all warranties, express or implied, including
19  * warranties of performance, merchantability or fitness for any particular
20  * purpose.
21  *
22  * Please cite the author in any work or product based on this material.
23  *
24  * ===========================================================================
25  *
26  * Authors: Igor Filippov
27  */
28 
29 
30 #include <ncbi_pch.hpp>
57 
59 
60 #include <array>
61 
62 // For compilers that support precompilation, includes "wx/wx.h".
63 #include "wx/wxprec.h"
64 
65 #ifdef __BORLANDC__
66 #pragma hdrstop
67 #endif
68 
69 #ifndef WX_PRECOMP
70 #include "wx/wx.h"
71 #endif
72 
73 ////@begin includes
74 #include "wx/imaglist.h"
75 #include <wx/display.h>
76 ////@end includes
77 
78 #include <wx/filename.h>
79 
80 ////@begin XPM images
81 ////@end XPM images
82 
84 BEGIN_SCOPE(valedit)
85 
87 {
88  CWorkbench* wb_frame = dynamic_cast<CWorkbench*>(wb);
89  if (!wb_frame)
90  return NULL;
91 
93  if (!srv)
94  return NULL;
95 
96  CRef<CGBWorkspace> ws = srv->GetGBWorkspace();
97  if (!ws)
98  return NULL;
99 
100  CGBDocument* doc = dynamic_cast<CGBDocument*>(ws->GetProjectFromScope(scope));
101  if (!doc)
102  return NULL;
103  ICommandProccessor* cmdProcessor = &doc->GetUndoManager();
104  return cmdProcessor;
105 }
106 
107 
109 {
110  wxWindow* main_window = NULL;
111  CWorkbench* wb_frame = dynamic_cast<CWorkbench*>(wb);
112  if (wb_frame)
113  main_window = wb_frame->GetMainWindow();
114  return main_window;
115 }
116 
117 
119 {
120  CWorkbench* wb_frame = dynamic_cast<CWorkbench*>(wb);
121  if (!wb_frame)
122  return wxEmptyString;
123 
125  _ASSERT(srv);
126  CRef<CGBWorkspace> ws = srv->GetGBWorkspace();
127  CGBDocument* doc = 0;
128  if (ws)
129  doc = dynamic_cast<CGBDocument*>(ws->GetProjectFromScope(scope));
130 
131  if (doc) {
132  return doc->GetWorkDir();
133  } else {
134  return wxEmptyString;
135  }
136 }
137 
138 
139 void LaunchDescEditor(CRef<CSeqdesc> seqdesc, CSeq_entry_Handle seh, ICommandProccessor* cmdProcessor, const wxString& workDir)
140 {
141  CIRef<IEditObject> editor(new CEditObjectSeq_desc(*seqdesc, seh, seh.GetScope(), true));
142  CEditObjViewDlg* edit_dlg = new CEditObjViewDlg(NULL, true);
143  edit_dlg->SetUndoManager(cmdProcessor);
144  wxWindow* editorWindow = editor->CreateWindow(edit_dlg);
145  edit_dlg->SetEditorWindow(editorWindow);
146  edit_dlg->SetEditor(editor);
147  edit_dlg->SetWorkDir(workDir);
148  edit_dlg->Show(true);
149 }
150 
151 
153 (CRef<CSeqdesc> seqdesc,
154  const objects::CBioseq& bioseq,
155  ICommandProccessor* cmdProcessor,
156  CScope& scope,
157  const wxString& workDir)
158 {
159  CBioseq_Handle bsh = scope.GetBioseqHandle(bioseq);
161  LaunchDescEditor(seqdesc, seh, cmdProcessor, workDir);
162 }
163 
164 
166 {
167  CRef<CSeqdesc> seqdesc(new CSeqdesc());
168  seqdesc->SetMolinfo();
169  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
170  const wxString& workDir = GetWorkDirFromWorkbench(wb, seh.GetScope());
171  LaunchDescEditor(seqdesc, seh, cmdProcessor, workDir);
172 }
173 
174 
176 {
177  CRef<CSeqdesc> seqdesc(new CSeqdesc());
178  seqdesc->SetSource();
179  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
180  const wxString& workDir = GetWorkDirFromWorkbench(wb, seh.GetScope());
181  LaunchDescEditor(seqdesc, seh, cmdProcessor, workDir);
182 }
183 
185 {
186  if (!seh.IsSeq()) {
187  return;
188  }
189  wxWindow* main_window = MainWindowFromWorkbench(wb);
191 
192  CRemoveSequencesDlg dlg(main_window, seh.GetTopLevelEntry());
193  dlg.ChooseSequence(seh.GetSeq());
194  if (dlg.ShowModal() == wxID_OK) {
196  if (cmd) {
197  cmd_proc->Execute(cmd);
198  }
199  }
200 }
201 
203 {
204  if (wxYES != wxMessageBox(wxT("Would you like to trim terminal regions with a high percentage of ambiguous characters from the sequences?"), wxT("Trim Ns"), wxYES_NO | wxICON_QUESTION)) {
205  return;
206  }
207 
208  wxWindow* main_window = MainWindowFromWorkbench(wb);
210  const wxString& workDir = GetWorkDirFromWorkbench(wb, seh.GetScope());
211 
212  CTrimN worker;
213  worker.apply(seh.GetTopLevelEntry(), cmd_proc, "Trim Ns Rich", main_window, workDir);
214 }
215 
216 
217 void OfferToDeleteDescriptor(const string& label, CSeq_entry_Handle seh, const CSeqdesc& seqDesc, ICommandProccessor* cmdProcessor)
218 {
219  if (wxYES == wxMessageBox(wxT("Would you like to delete " + ToWxString(label) + wxT("?")), wxT("Remove descriptors"), wxYES_NO | wxICON_QUESTION)) {
220  CIRef<IEditCommand> cmd(new CCmdDelDesc(seh, seqDesc));
221  cmdProcessor->Execute(cmd);
222  }
223 }
224 
226 {
227  wxWindow* main_window = MainWindowFromWorkbench(wb);
228  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
229  CAlignmentAssistant *dlg = NULL;
230  try
231  {
232  dlg = new CAlignmentAssistant( main_window, seh, cmdProcessor, ConstRef(align));
233  dlg->Show(true);
234  } catch (CException&)
235  {
236  if (dlg)
237  dlg->Destroy();
238  wxMessageBox(wxT("Unable to load the alignment"), wxT("Error"), wxOK | wxICON_ERROR);
239  }
240 }
241 
243 {
244  CBioseq_Handle bsh;
245  if (seh.IsSeq())
246  bsh = seh.GetSeq();
247  if (bsh)
248  {
249  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
250  CEditSequence *dlg = NULL;
251  try
252  {
253  dlg = new CEditSequence( nullptr, bsh.GetRangeSeq_loc(0,0).GetPointer(), seh.GetScope(), cmdProcessor, 0);
254  dlg->Show(true);
255  } catch (CException&)
256  {
257  if (dlg)
258  dlg->Destroy();
259  wxMessageBox(wxT("No bioseq selected"), wxT("Error"), wxOK | wxICON_ERROR);
260  }
261  }
262 }
263 
265 {
266  const CObject* object = &obj;
267  const CSeq_align *align = dynamic_cast<const CSeq_align *>(object);
268  const CBioseq *bioseq = dynamic_cast<const CBioseq *>(object);
269 
270  if (align)
271  {
272  LaunchAlignmentAssistant(seh, wb, align);
273  return;
274  }
275  if (bioseq)
276  {
277  LaunchBioseqEditor(seh, wb);
278  return;
279  }
280 
281  CIRef<IEditObject> editor = CreateEditorForObject(ConstRef(object), seh, false);
282  if (!editor)
283  return;
284  wxWindow* main_window = MainWindowFromWorkbench(wb);
285  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
286  CEditObjViewDlg* edit_dlg = new CEditObjViewDlg(main_window, false);
287  wxWindow* editorWindow = editor->CreateWindow(edit_dlg);
288  edit_dlg->SetUndoManager(cmdProcessor);
289  edit_dlg->SetEditorWindow(editorWindow);
290  edit_dlg->SetEditor(editor);
291  editorWindow->TransferDataToWindow();
292  edit_dlg->Show(true);
293 }
294 
295 using handler=void(*)(CSeq_entry_Handle seh, IWorkbench* wb, const CSerialObject& obj);
296 static std::array<handler, eErr_MAX> valerr_to_handler{};
297 
298 #define REGISTER_HANDLER(code) \
299  static void handler_##code (CSeq_entry_Handle seh, IWorkbench* wb, const CSerialObject& obj); \
300  static int dummy_##code = (valerr_to_handler[code] = handler_##code, 0); \
301  void handler_##code (CSeq_entry_Handle seh, IWorkbench* wb, const CSerialObject& obj) \
302 
304 {
305  CRef<CSeqdesc> seqdesc(new CSeqdesc());
306  seqdesc->SetPub();
307  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
308  const wxString& workDir = GetWorkDirFromWorkbench(wb, seh.GetScope());
309  LaunchDescEditor(seqdesc, seh, cmdProcessor, workDir);
310 }
311 
313 {
314  CRef<CSeqdesc> seqdesc(new CSeqdesc());
315  seqdesc->SetPub();
316  CRef<CPub> pub(new CPub());
317  pub->SetSub();
318  seqdesc->SetPub().SetPub().Set().push_back(pub);
319  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
320  const wxString& workDir = GetWorkDirFromWorkbench(wb, seh.GetScope());
321  LaunchDescEditor(seqdesc, seh, cmdProcessor, workDir);
322 }
323 
325 {
326  LaunchSrcEditor(seh, wb);
327 }
328 
330 {
331  LaunchSrcEditor(seh, wb);
332 }
333 
335 {
336  LaunchMolInfoEditor(seh, wb);
337 }
338 
340 {
341  LaunchMolInfoEditor(seh, wb);
342 }
343 
345 {
346  wxWindow* main_window = MainWindowFromWorkbench(wb);
347  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
348 
349  CSeq_entry_Handle tseh = seh.GetTopLevelEntry();
350 
351  string msg;
353 
354  if (cmd)
355  {
356  cmdProcessor->Execute(cmd);
357  }
358 
359  if (!msg.empty())
360  {
361  CGenericReportDlg* report = new CGenericReportDlg(main_window);
362  report->SetTitle(wxT("TPA Alignment Assembly Problems"));
363  report->SetText(wxString(msg));
364  report->Show(true);
365  }
366 }
367 
369 {
370  if (!seh.IsSeq()) {
371  return;
372  }
373  wxWindow* main_window = MainWindowFromWorkbench(wb);
375  try
376  {
377  CEditHistory dlg(main_window, seh.GetSeq());
378 
379  if (dlg.ShowModal() == wxID_OK)
380  {
382  if (cmd)
383  {
384  cmd_proc->Execute(cmd);
385  }
386  }
387  } catch (CException&) {
388  }
389 }
390 
392 {
393  RemoveSequence(seh, wb);
394 }
395 
397 {
398  if (wxYES != wxMessageBox(wxT("Remove all orphaned proteins?"), wxT("Remove"), wxYES_NO | wxICON_QUESTION))
399  {
400  return;
401  }
404  if (cmd)
405  {
406  cmd_proc->Execute(cmd);
407  }
408 }
409 
411 {
412  if (wxYES != wxMessageBox(wxT("Would you like to trim ambiguous characters from the ends of the sequences?"), wxT("Trim Ns"), wxYES_NO | wxICON_QUESTION)) {
413  return;
414  }
415 
416  wxWindow* main_window = MainWindowFromWorkbench(wb);
418  const wxString& workDir = GetWorkDirFromWorkbench(wb, seh.GetScope());
419 
421  trim_rules.push_back(CSequenceAmbigTrimmer::STrimRule{ 1, 0 });
422 
423  CTrimN worker;
424  worker.apply(seh.GetTopLevelEntry(), cmd_proc, "Trim Ns Terminal", main_window, workDir, trim_rules);
425 }
426 
428 {
429  TrimTerminalNRichRegions(seh, wb);
430 }
431 
433 {
434  TrimTerminalNRichRegions(seh, wb);
435 }
436 
438 {
439  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
440  const CSeqdesc* d = dynamic_cast<const CSeqdesc *>(&obj);
441  OfferToDeleteDescriptor("the title descriptor", seh, *d, cmdProcessor);
442 }
443 
445 {
446  if (wxYES != wxMessageBox(wxT("Remove duplicate structured comments?"), wxT("Remove"), wxYES_NO | wxICON_QUESTION)) {
447  return;
448  }
450  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
451  worker.apply(seh.GetTopLevelEntry(), cmdProcessor,"Remove Duplicate Structured Comment");
452 }
453 
455 {
456  seh = seh.GetTopLevelEntry();
457  wxWindow* main_window = MainWindowFromWorkbench(wb);
459  CApplyGCode dlg(main_window, seh);
460  if (dlg.ShowModal() == wxID_OK)
461  {
463  if (cmd)
464  {
465  cmd_proc->Execute(cmd);
466  CRef<CCmdComposite> cleanup = CleanupCommand(seh, true, false);
467  if (cleanup)
468  cmd_proc->Execute(cleanup);
469  string error;
471  if (retranslate)
472  cmd_proc->Execute(retranslate);
473  }
474  }
475 }
476 
478 {
479  if (wxYES != wxMessageBox(wxT("Would you like to remove protein titles?"), wxT("Remove"), wxYES_NO | wxICON_QUESTION)) {
480  return;
481  }
482  CRemProtTitles worker;
483  ICommandProccessor* cmdProcessor = CommandProcessorFromWorkbench(wb, seh.GetScope());
484  worker.apply(seh.GetTopLevelEntry(), cmdProcessor,"Remove Protein Titles");
485 }
486 
488 {
489  RemoveSequence(seh, wb);
490 }
491 
493 {
494  if (!seh.IsSeq()) {
495  return;
496  }
497  wxWindow* main_window = MainWindowFromWorkbench(wb);
499 
500  CRawSeqToDeltaByN dlg(main_window);
501  if (dlg.ShowModal() == wxID_OK)
502  {
503  dlg.apply(seh.GetTopLevelEntry(), cmd_proc, "Raw Sequences to Delta by Ns");
504  }
505 }
506 
507 void LaunchEditor(int err_code, const CSerialObject& obj, CSeq_entry_Handle seh, IWorkbench* wb)
508 {
509  if (valerr_to_handler[err_code])
510  {
511  valerr_to_handler[err_code](seh, wb, obj);
512  return;
513  }
514  LaunchDefaultEditor(seh, wb, obj);
515 }
516 
517 bool IsEditable(int err_code, const CSerialObject& obj, CSeq_entry_Handle seh)
518 {
519  if (valerr_to_handler[err_code])
520  {
521  return true;
522  }
523  const CObject* object = &obj;
524  const CSeq_align *align = dynamic_cast<const CSeq_align *>(object);
525  const CBioseq *bioseq = dynamic_cast<const CBioseq *>(object);
526 
527  if (align)
528  {
529  return true;
530  }
531  if (bioseq)
532  {
533  return true;
534  }
535 
536  CIRef<IEditObject> editor = CreateEditorForObject(ConstRef(object), seh, false);
537  if (editor)
538  return true;
539  return false;
540 }
541 
542 END_SCOPE(valedit)
543 
545 
User-defined methods of the data storage class.
@ eErr_SEQ_INST_ShortSeq
@ eErr_GENERIC_MissingPubRequirement
@ eErr_SEQ_INST_HistoryGiCollision
@ eErr_SEQ_DESCR_InconsistentProteinTitle
@ eErr_SEQ_DESCR_NoMolInfoFound
@ eErr_SEQ_PKG_OrphanedProtein
@ eErr_SEQ_FEAT_GenCodeMismatch
@ eErr_SEQ_INST_AllNs
@ eErr_SEQ_INST_HighNpercent3Prime
@ eErr_SEQ_DESCR_NoPubFound
@ eErr_SEQ_INST_MolNuclAcid
@ eErr_SEQ_DESCR_TitleNotAppropriateForSet
@ eErr_SEQ_DESCR_MultipleStrucComms
@ eErr_SEQ_INST_MitoMetazoanTooLong
@ eErr_SEQ_DESCR_NoSourceDescriptor
@ eErr_SEQ_INST_HistAssemblyMissing
@ eErr_SEQ_INST_InternalNsInSeqRaw
@ eErr_SEQ_INST_TerminalNs
@ eErr_SEQ_INST_HighNpercent5Prime
CIRef< IEditObject > CreateEditorForObject(CConstRef< CObject > obj, objects::CSeq_entry_Handle seh, bool create)
CRef< CCmdComposite > GetCommand()
CBioseq_Handle –.
static CRef< CCmdComposite > GetCreateSeqHistFromTpaCommand(CSeq_entry_Handle tse, string &msg, double word_size, double expect_value)
CRef< CCmdComposite > GetCommand()
void SetEditorWindow(wxWindow *editorWindow)
void SetEditor(CIRef< IEditObject > editor)
virtual void SetWorkDir(const wxString &workDir)
virtual void SetUndoManager(ICommandProccessor *cmdProccessor)
CGBDocument.
Definition: document.hpp:113
wxString GetWorkDir() const
Definition: document.cpp:1364
CUndoManager & GetUndoManager()
Definition: document.hpp:158
void SetText(const wxString &text)
CObject –.
Definition: ncbiobj.hpp:180
CProjectService - a service providing API for operations with Workspaces and Projects.
Definition: Pub.hpp:56
void apply(objects::CSeq_entry_Handle tse, ICommandProccessor *cmdProcessor, string title)
CRef –.
Definition: ncbiobj.hpp:618
bool apply(CSeq_entry_Handle tse, ICommandProccessor *cmdProcessor, string title)
static CRef< CCmdComposite > OrphanedProteins(objects::CSeq_entry_Handle seh)
CRef< CCmdComposite > GetCommand()
void ChooseSequence(CBioseq_Handle bsh)
bool apply(CSeq_entry_Handle tse, ICommandProccessor *cmdProcessor, string title)
static CRef< CCmdComposite > GetCommand(objects::CSeq_entry_Handle seh, string title, ERetranslateMethod method, string &error)
CScope –.
Definition: scope.hpp:92
CSeq_entry_Handle –.
Base class for all serializable objects.
Definition: serialbase.hpp:150
bool apply(CSeq_entry_Handle tse, ICommandProccessor *cmdProcessor, string title, wxWindow *parent, const wxString &workDir, const CSequenceAmbigTrimmer::TTrimRuleVec &trim_rules=CSequenceAmbigTrimmer::GetDefaultTrimRules())
Definition: trim_n.cpp:50
CWorkbench - default implementation of IWorkbench.
Undo/Redo interface for editing operations.
virtual void Execute(IEditCommand *command, wxWindow *window=0)=0
IWorkbench is the central interface in the application framework.
Definition: workbench.hpp:113
void LaunchDefaultEditor(CSeq_entry_Handle seh, IWorkbench *wb, const CSerialObject &obj)
bool IsEditable(int err_code, const CSerialObject &obj, CSeq_entry_Handle seh)
wxString GetWorkDirFromWorkbench(IWorkbench *wb, CScope &scope)
ICommandProccessor * CommandProcessorFromWorkbench(IWorkbench *wb, CScope &scope)
static std::array< handler, eErr_MAX > valerr_to_handler
void(*)(CSeq_entry_Handle seh, IWorkbench *wb, const CSerialObject &obj) handler
void RemoveSequence(CSeq_entry_Handle seh, IWorkbench *wb)
void TrimTerminalNRichRegions(CSeq_entry_Handle seh, IWorkbench *wb)
wxWindow * MainWindowFromWorkbench(IWorkbench *wb)
void LaunchBioseqEditor(CSeq_entry_Handle seh, IWorkbench *wb)
void OfferToDeleteDescriptor(const string &label, CSeq_entry_Handle seh, const CSeqdesc &seqDesc, ICommandProccessor *cmdProcessor)
void LaunchMolInfoEditor(CSeq_entry_Handle seh, IWorkbench *wb)
void LaunchAlignmentAssistant(CSeq_entry_Handle seh, IWorkbench *wb, const CSeq_align *align)
void LaunchSrcEditor(CSeq_entry_Handle seh, IWorkbench *wb)
void LaunchEditor(int err_code, const CSerialObject &obj, CSeq_entry_Handle seh, IWorkbench *wb)
void LaunchDescEditorForSeq(CRef< CSeqdesc > seqdesc, const objects::CBioseq &bioseq, ICommandProccessor *cmdProcessor, CScope &scope, const wxString &workDir)
#define REGISTER_HANDLER(code)
void LaunchDescEditor(CRef< CSeqdesc > seqdesc, CSeq_entry_Handle seh, ICommandProccessor *cmdProcessor, const wxString &workDir)
static CS_COMMAND * cmd
Definition: ct_dynamic.c:26
static void cleanup(void)
Definition: ct_dynamic.c:30
#define NULL
Definition: ncbistd.hpp:225
CIRef< T > GetServiceByType()
retrieves a typed reference to a service, the name of C++ type is used as the name of the service.
Definition: service.hpp:91
virtual wxFrame * GetMainWindow()
returns a pointer to the main application frame window
vector< STrimRule > TTrimRuleVec
Multiple STrimRules are allowed, which are applied from smallest bases_to_check to largest bases_to_c...
Definition: sequence.hpp:1322
CBioseq_Handle GetBioseqHandle(const CSeq_id &id)
Get bioseq handle by seq-id.
Definition: scope.cpp:95
CSeq_entry_Handle GetSeq_entry_Handle(void) const
Get parent Seq-entry handle.
TSeq GetSeq(void) const
CSeq_entry_Handle GetTopLevelEntry(void) const
Get top level Seq-entry handle.
CScope & GetScope(void) const
Get scope this handle belongs to.
CRef< CSeq_loc > GetRangeSeq_loc(TSeqPos start, TSeqPos stop, ENa_strand strand=eNa_strand_unknown) const
Return CSeq_loc referencing the given range and strand on the bioseq If start == 0,...
bool IsSeq(void) const
CConstRef< C > ConstRef(const C *object)
Template function for conversion of const object pointer to CConstRef.
Definition: ncbiobj.hpp:2024
TObjectType * GetPointer(void) THROWS_NONE
Get pointer,.
Definition: ncbiobj.hpp:998
#define END_NCBI_SCOPE
End previously defined NCBI scope.
Definition: ncbistl.hpp:103
#define END_SCOPE(ns)
End the previously defined scope.
Definition: ncbistl.hpp:75
#define BEGIN_NCBI_SCOPE
Define ncbi namespace.
Definition: ncbistl.hpp:100
#define BEGIN_SCOPE(ns)
Define a new scope.
Definition: ncbistl.hpp:72
static const char label[]
TSub & SetSub(void)
Select the variant.
Definition: Pub_.cpp:195
void SetPub(TPub &value)
Assign a value to Pub data member.
Definition: Pubdesc_.cpp:72
TPub & SetPub(void)
Select the variant.
Definition: Seqdesc_.cpp:362
TSource & SetSource(void)
Select the variant.
Definition: Seqdesc_.cpp:572
TMolinfo & SetMolinfo(void)
Select the variant.
Definition: Seqdesc_.cpp:594
#define wxT(x)
Definition: muParser.cpp:41
For example, if bases_to_check is 10 and max_bases_allowed_to_be_ambig is 5, then on each iteration w...
Definition: sequence.hpp:1314
#define _ASSERT
CRef< CCmdComposite > CleanupCommand(objects::CSeq_entry_Handle orig_seh, bool extended, bool do_tax)
wxString ToWxString(const string &s)
Definition: wx_utils.hpp:173
Modified on Mon May 27 04:36:33 2024 by modify_doxy.py rev. 669887