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

Go to the SVN repository for this file.

1 /* $Id: show_hide_manager.cpp 97253 2022-06-29 17:35:29Z dzhang $
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: Paul Thiessen
27 *
28 * File Description:
29 * manager object to track show/hide status of objects at various levels
30 *
31 * ===========================================================================
32 */
33 
34 #include <ncbi_pch.hpp>
35 #include <corelib/ncbistd.hpp>
36 
38 
39 #include "show_hide_manager.hpp"
40 #include "structure_set.hpp"
41 #include "molecule.hpp"
42 #include "residue.hpp"
43 #include "chemical_graph.hpp"
44 #include "messenger.hpp"
45 #include "alignment_manager.hpp"
46 #include "opengl_renderer.hpp"
47 #include "cn3d_tools.hpp"
48 #include "molecule_identifier.hpp"
49 
50 #include <corelib/ncbistre.hpp>
51 #include <vector>
52 
54 
55 
56 BEGIN_SCOPE(Cn3D)
57 
58 
59 // ShowHideInfo is a generic container class to help organize the list of things that can be
60 // shown/hidden; stuff derived from it allows various types of objects to be shown/hidden
61 
63 
65 {
66 protected:
67  string label;
68 public:
69  virtual ~ShowHideInfo(void) { }
70  vector < int > parentIndexes;
71  void GetLabel(string *str) const { *str = label; }
72  virtual bool IsVisible(const ShowHideManager *shm) const = 0;
73  virtual void Show(ShowHideManager *shm, bool isShown) const = 0;
74 };
75 
77 {
78 private:
80 public:
81  ShowHideObject(const StructureObject *o) : object(o) { label = o->GetPDBID(); }
82  virtual ~ShowHideObject(void) { }
83  bool IsVisible(const ShowHideManager *shm) const { return shm->IsVisible(object); }
84  void Show(ShowHideManager *shm, bool isShown) const { shm->Show(object, isShown); }
85 };
86 
88 {
89 private:
91 public:
93  {
94  label = indent + m->identifier->pdbID;
95  if (m->identifier->pdbChain != " ") {
96  label += '_';
97  label += m->identifier->pdbChain;
98  }
99  }
100  virtual ~ShowHideMolecule(void) { }
101  bool IsVisible(const ShowHideManager *shm) const { return shm->IsVisible(molecule); }
102  void Show(ShowHideManager *shm, bool isShown) const { shm->Show(molecule, isShown); }
103 };
104 
106 {
107 private:
109  int domainID;
110 public:
111  ShowHideDomain(const Molecule *m, int d, int labelNum) : molecule(m), domainID(d)
112  {
113  CNcbiOstrstream oss;
114  oss << indent << indent << m->identifier->pdbID;
115  if (m->identifier->pdbChain != " ") oss << '_' << m->identifier->pdbChain.c_str();
116  oss << " d" << labelNum;
118  }
119  virtual ~ShowHideDomain(void) { }
120  bool IsVisible(const ShowHideManager *shm) const
121  {
122  bool isVisible = false;
123  for (unsigned int i=0; i<molecule->NResidues(); ++i) {
124  if (molecule->residueDomains[i] == domainID &&
125  shm->IsVisible(molecule->residues.find(i+1)->second)) {
126  isVisible = true; // return true if any residue from this domain is visible
127  break;
128  }
129  }
130  return isVisible;
131  }
132  void Show(ShowHideManager *shm, bool isShown) const
133  {
134  for (unsigned int i=0; i<molecule->NResidues(); ++i)
136  shm->Show(molecule->residues.find(i+1)->second, isShown);
137  }
138 };
139 
140 
141 ///// the ShowHideManager class /////
142 
144 {
145  for (unsigned int i=0; i<structureInfo.size(); ++i) delete structureInfo[i];
146 }
147 
148 static void PostRedrawEntity(const StructureObject *object, const Molecule *molecule, const Residue *residue)
149 {
150  if (residue) {
151  const Molecule *m;
152  if (residue->GetParentOfType(&m))
154  }
155 
156  else if (molecule) {
157  GlobalMessenger()->PostRedrawMolecule(molecule);
158  }
159 
160  else if (object) {
161  // redraw all prot/nuc molecules
162  ChemicalGraph::MoleculeMap::const_iterator m, me = object->graph->molecules.end();
163  for (m=object->graph->molecules.begin(); m!=me; ++m) {
164  if (m->second->IsProtein() || m->second->IsNucleotide())
165  GlobalMessenger()->PostRedrawMolecule(m->second);
166  }
167  }
168 
170 }
171 
172 void ShowHideManager::Show(const StructureBase *entity, bool isShown)
173 {
174  // make sure this is a valid entity
175  const StructureObject *object = dynamic_cast<const StructureObject *>(entity);
176  const Molecule *molecule = dynamic_cast<const Molecule *>(entity);
177  const Residue *residue = dynamic_cast<const Residue *>(entity);
178  if (!entity || !(object || molecule || residue)) {
179  ERRORMSG("ShowHideManager::Show() - must be a StructureObject, Molecule, or Residue");
180  return;
181  }
182 
183  EntitiesHidden::iterator e = entitiesHidden.find(entity);
184 
185  // hide an entity that's not already hidden
186  if (!isShown && e == entitiesHidden.end()) {
187  entitiesHidden[entity] = true;
188  PostRedrawEntity(object, molecule, residue);
189  entity->parentSet->renderer->ShowAllFrames();
190  }
191 
192  // show an entity that's currently hidden
193  else if (isShown && e != entitiesHidden.end()) {
194  UnHideEntityAndChildren(entity);
195  PostRedrawEntity(object, molecule, residue);
196  entity->parentSet->renderer->ShowAllFrames();
197  }
198 }
199 
201 {
202  if (!entity || !IsHidden(entity)) return;
203  const StructureObject *object = dynamic_cast<const StructureObject *>(entity);
204  const Molecule *molecule = dynamic_cast<const Molecule *>(entity);
205  const Residue *residue = dynamic_cast<const Residue *>(entity);
206 
207  // if entity is residue, just remove it from the list if present
208  if (residue) {
209  EntitiesHidden::iterator h = entitiesHidden.find(residue);
210  if (h != entitiesHidden.end()) entitiesHidden.erase(h);
211  return;
212  }
213 
214  // otherwise, make sure entity and its descendents are visible
215  // if it isn't already visible, then unhide this entity and all of its children
216  EntitiesHidden::iterator h, he = entitiesHidden.end();
217  for (h=entitiesHidden.begin(); h!=he; ) {
218 
219  const StructureObject *hObj = dynamic_cast<const StructureObject *>(h->first);
220  if (object && !hObj)
221  h->first->GetParentOfType(&hObj);
222  const Molecule *hMol = dynamic_cast<const Molecule *>(h->first);
223  if (molecule && hObj != h->first && !hMol) // if not StructureObject or Molecule
224  h->first->GetParentOfType(&hMol); // must be residue
225 
226  if (entity == h->first || // unhide the entity itself
227  (object && hObj == object) || // unhide children of a StructureObject
228  (molecule && hMol == molecule)) // unhide children of a Molecule
229  {
230  EntitiesHidden::iterator d(h);
231  ++h;
232  entitiesHidden.erase(d);
233  } else {
234  ++h;
235  }
236  }
237  PostRedrawEntity(object, molecule, residue);
238  entity->parentSet->renderer->ShowAllFrames();
239 }
240 
241 bool ShowHideManager::IsHidden(const StructureBase *entity) const
242 {
243  if (entitiesHidden.size() == 0) return false;
244 
245  const StructureObject *object;
246  const Molecule *molecule;
247  const Residue *residue;
248 
249  EntitiesHidden::const_iterator e = entitiesHidden.find(entity);
250 
251  if ((object = dynamic_cast<const StructureObject *>(entity)) != NULL) {
252  return (e != entitiesHidden.end());
253  }
254 
255  else if ((molecule = dynamic_cast<const Molecule *>(entity)) != NULL) {
256  if (!molecule->GetParentOfType(&object)) return false;
257  return (entitiesHidden.find(object) != entitiesHidden.end() ||
258  e != entitiesHidden.end());
259  }
260 
261  else if ((residue = dynamic_cast<const Residue *>(entity)) != NULL) {
262  if (!residue->GetParentOfType(&molecule) ||
263  !molecule->GetParentOfType(&object)) return false;
264  return (entitiesHidden.find(object) != entitiesHidden.end() ||
265  entitiesHidden.find(molecule) != entitiesHidden.end() ||
266  e != entitiesHidden.end());
267  }
268 
269  ERRORMSG("ShowHideManager::IsHidden() - must be a StructureObject, Molecule, or Residue");
270  return false;
271 }
272 
274 {
276  int objectIndex, moleculeIndex;
277 
278  StructureSet::ObjectList::const_iterator o, oe = structureSet->objects.end();
279  for (o=structureSet->objects.begin(); o!=oe; ++o) {
280 
281  objectIndex = structureInfo.size();
282  structureInfo.push_back(new ShowHideObject(*o));
283 
284  // list interesting (prot/nuc) chains
285  ChemicalGraph::MoleculeMap::const_iterator m, me = (*o)->graph->molecules.end();
286  for (m=(*o)->graph->molecules.begin(); m!=me; ++m) {
287  int nDom = 1; // # domains in this chain
288 
289  if (m->second->IsProtein() || m->second->IsNucleotide()) {
290  moleculeIndex = structureInfo.size();
291  info = new ShowHideMolecule(m->second);
292  info->parentIndexes.push_back(objectIndex);
293  structureInfo.push_back(info);
294 
295  // if there at least one domain, enumerate them
296  if (m->second->nDomains >= 1) {
297  StructureObject::DomainMap::const_iterator d, de = (*o)->domainMap.end();
298  for (d=(*o)->domainMap.begin(); d!=de; ++d) {
299  if (d->second == m->second) {
300  info = new ShowHideDomain(m->second, d->first, nDom++);
301  info->parentIndexes.push_back(objectIndex);
302  info->parentIndexes.push_back(moleculeIndex);
303  structureInfo.push_back(info);
304  }
305  }
306  }
307  }
308  }
309  }
310 }
311 
313  vector < string > *names, vector < bool > *visibilities) const
314 {
315  names->resize(structureInfo.size());
316  visibilities->resize(structureInfo.size());
317  for (unsigned int i=0; i<structureInfo.size(); ++i) {
318  structureInfo[i]->GetLabel(&((*names)[i]));
319  (*visibilities)[i] = structureInfo[i]->IsVisible(this);
320  }
321 }
322 
323 void ShowHideManager::ShowHideCallbackFunction(const vector < bool >& itemsEnabled)
324 {
325  if (itemsEnabled.size() != structureInfo.size()) {
326  ERRORMSG("ShowHideManager::ShowHideCallbackFunction() - wrong size list");
327  return;
328  }
329 
330  for (unsigned int i=0; i<itemsEnabled.size(); ++i)
331  structureInfo[i]->Show(this, itemsEnabled[i]);
332  TRACEMSG("entities hidden: " << entitiesHidden.size());
333 }
334 
336  const vector < bool >& original, vector < bool >& itemsEnabled)
337 {
338  // count number of changes
339  unsigned int i, nChanges = 0, itemChanged = 0, nEnabled = 0, itemEnabled = 0;
340  for (i=0; i<itemsEnabled.size(); ++i) {
341  if (itemsEnabled[i] != original[i]) {
342  ++nChanges;
343  itemChanged = i;
344  }
345  if (itemsEnabled[i]) {
346  ++nEnabled;
347  itemEnabled = i;
348  }
349  }
350 
351  // if change was a single de/selection, then turn off/on the children of that item
352  bool anyChange = false;
353  if (nChanges == 1 || nEnabled == 1) {
354  int item = (nChanges == 1) ? itemChanged : itemEnabled;
355  for (i=item+1; i<structureInfo.size(); ++i) {
356  for (unsigned int j=0; j<structureInfo[i]->parentIndexes.size(); ++j) {
357  if (structureInfo[i]->parentIndexes[j] == item) {
358  if (itemsEnabled[i] != itemsEnabled[item]) {
359  itemsEnabled[i] = itemsEnabled[item];
360  anyChange = true;
361  }
362  }
363  }
364  }
365  }
366 
367  // check all items to make sure that when an object is on, its parents are also on
368  for (i=0; i<itemsEnabled.size(); ++i) {
369  if (itemsEnabled[i]) {
370  for (unsigned int j=0; j<structureInfo[i]->parentIndexes.size(); ++j) {
371  if (!itemsEnabled[structureInfo[i]->parentIndexes[j]]) {
372  itemsEnabled[structureInfo[i]->parentIndexes[j]] = true;
373  anyChange = true;
374  }
375  }
376  }
377  }
378 
379  return anyChange;
380 }
381 
383 {
384  while (entitiesHidden.size() > 0) Show(entitiesHidden.begin()->first, true);
385 }
386 
388 {
389  MakeAllVisible();
390  StructureSet::ObjectList::const_iterator o, oe = set->objects.end();
391  for (o=set->objects.begin(); o!=oe; ++o) {
392  ChemicalGraph::MoleculeMap::const_iterator m, me = (*o)->graph->molecules.end();
393  for (m=(*o)->graph->molecules.begin(); m!=me; ++m) {
394 
395  if (m->second->IsNucleotide()) { // hide all nucleotides
396  Show(m->second, false);
397  continue;
398  }
399 
400  if (!m->second->IsProtein()) continue; // but leave all hets/solvents visible
401 
402  if (!set->alignmentManager->IsInAlignment(m->second->sequence)) {
403  Show(m->second, false);
404  continue;
405  }
406 
407  map < int, bool > domains;
408  Molecule::ResidueMap::const_iterator r, re = m->second->residues.end();
409 
410  // first pass determines which domains have any aligned residues
411  for (r=m->second->residues.begin(); r!=re; ++r)
412  if (set->alignmentManager->IsAligned(m->second->sequence, r->first - 1))
413  domains[m->second->residueDomains[r->first - 1]] = true;
414 
415  // second pass does hides domains not represented
416  for (r=m->second->residues.begin(); r!=re; ++r)
417  if (domains.find(m->second->residueDomains[r->first - 1]) == domains.end())
418  Show(r->second, false);
419  }
420  }
421 }
422 
424 {
425  MakeAllVisible();
426  StructureSet::ObjectList::const_iterator o, oe = set->objects.end();
427  for (o=set->objects.begin(); o!=oe; ++o) {
428  ChemicalGraph::MoleculeMap::const_iterator m, me = (*o)->graph->molecules.end();
429  for (m=(*o)->graph->molecules.begin(); m!=me; ++m) {
430 
431  if (!(m->second->IsProtein() || m->second->IsNucleotide()))
432  continue; // but leave all hets/solvents visible
433 
434  if (!(set->alignmentManager->IsInAlignment(m->second->sequence) || set->styleManager->MoleculeHasUserStyle(*o, m->second->id))) {
435  Show(m->second, false);
436  continue;
437  }
438 
439  map < int, bool > domains;
440  Molecule::ResidueMap::const_iterator r, re = m->second->residues.end();
441 
442  // first pass determines which domains have any aligned or annotated residues
443  for (r=m->second->residues.begin(); r!=re; ++r)
444  if (set->alignmentManager->IsAligned(m->second->sequence, r->first - 1) || set->styleManager->ResidueHasUserStyle(*o, m->second->id, r->first))
445  domains[m->second->residueDomains[r->first - 1]] = true;
446 
447  // second pass does hides domains not represented
448  for (r=m->second->residues.begin(); r!=re; ++r)
449  if (domains.find(m->second->residueDomains[r->first - 1]) == domains.end())
450  Show(r->second, false);
451  }
452  }
453 }
454 
456 {
457  MakeAllVisible();
458  StructureSet::ObjectList::const_iterator o, oe = set->objects.end();
459  for (o=set->objects.begin(); o!=oe; ++o) {
460  ChemicalGraph::MoleculeMap::const_iterator m, me = (*o)->graph->molecules.end();
461  for (m=(*o)->graph->molecules.begin(); m!=me; ++m) {
462 
463  // hide all nucleotides but leave all aligned proteins + hets/solvents visible
464  if (m->second->IsNucleotide() ||
465  (m->second->IsProtein() && !set->alignmentManager->IsInAlignment(m->second->sequence)))
466  {
467  Show(m->second, false);
468  }
469  }
470  }
471 }
472 
474 {
475  StructureSet::ObjectList::const_iterator o, oe = set->objects.end();
476  for (o=set->objects.begin(); o!=oe; ++o) {
477  ChemicalGraph::MoleculeMap::const_iterator m, me = (*o)->graph->molecules.end();
478  for (m=(*o)->graph->molecules.begin(); m!=me; ++m) {
479 
480  if (m->second->IsNucleotide()) { // hide all nucleotides
481  Show(m->second, false);
482  continue;
483  }
484  if (!m->second->IsProtein()) continue; // but leave all hets/solvents visible
485 
486  if (!set->alignmentManager->IsInAlignment(m->second->sequence)) {
487  if (showAligned) Show(m->second, false);
488  continue;
489  }
490 
491  Molecule::ResidueMap::const_iterator r, re = m->second->residues.end();
492  for (r=m->second->residues.begin(); r!=re; ++r) {
493  bool aligned = set->alignmentManager->IsAligned(m->second->sequence, r->first - 1);
494  if ((showAligned && !aligned) || (!showAligned && aligned))
495  Show(r->second, false);
496  }
497  }
498  }
499 }
500 
501 void ShowHideManager::ShowResidues(const StructureSet *set, bool showAligned)
502 {
503  MakeAllVisible();
504  PrivateShowResidues(set, showAligned);
505 }
506 
508 {
510  PrivateShowResidues(set, false);
511 }
512 
514 {
515  MakeAllVisible();
516  if (!GlobalMessenger()->IsAnythingHighlighted()) return;
517 
518  StructureSet::ObjectList::const_iterator o, oe = set->objects.end();
519  for (o=set->objects.begin(); o!=oe; ++o) {
520  bool anyResidueInObjectVisible = false;
521  ChemicalGraph::MoleculeMap::const_iterator m, me = (*o)->graph->molecules.end();
522  for (m=(*o)->graph->molecules.begin(); m!=me; ++m) {
523  Molecule::ResidueMap::const_iterator r, re = m->second->residues.end();
524  bool anyResidueInMoleculeVisible = false;
525  for (r=m->second->residues.begin(); r!=re; ++r) {
526  if (!GlobalMessenger()->IsHighlighted(m->second, r->first))
527  Show(r->second, false);
528  else
529  anyResidueInMoleculeVisible = anyResidueInObjectVisible = true;
530  }
531  if (!anyResidueInMoleculeVisible) {
532  for (r=m->second->residues.begin(); r!=re; ++r)
533  Show(r->second, true); // un-flag individual residues
534  Show(m->second, false); // flag whole molecule as hidden
535  }
536  }
537  if (!anyResidueInObjectVisible) {
538  for (m=(*o)->graph->molecules.begin(); m!=me; ++m)
539  Show(m->second, true); // un-flag individual molecules
540  Show(*o, false); // flag whole object as hidden
541  }
542  }
543 }
544 
546 {
547  // first, show all highlighted stuff
548  MakeAllVisible();
549  if (!GlobalMessenger()->IsAnythingHighlighted()) return;
551 
552  // then, also show all domains that contain highlighted residues
553  StructureSet::ObjectList::const_iterator o, oe = set->objects.end();
554  for (o=set->objects.begin(); o!=oe; ++o) {
555  ChemicalGraph::MoleculeMap::const_iterator m, me = (*o)->graph->molecules.end();
556  for (m=(*o)->graph->molecules.begin(); m!=me; ++m) {
557  Molecule::ResidueMap::const_iterator r, re = m->second->residues.end();
558 
559  // find domains in this molecule that have highlights
560  map < int , bool > domains;
561  int domain;
562  for (r=m->second->residues.begin(); r!=re; ++r) {
563  if (GlobalMessenger()->IsHighlighted(m->second, r->first)) {
564  domain = m->second->residueDomains[r->first - 1];
565  if (domain != Molecule::NO_DOMAIN_SET)
566  domains[domain] = true;
567  }
568  }
569 
570  // now show all residues in these domains
571  for (r=m->second->residues.begin(); r!=re; ++r) {
572  domain = m->second->residueDomains[r->first - 1];
573  if (domain != Molecule::NO_DOMAIN_SET && domains.find(domain) != domains.end())
574  Show(r->second, true);
575  }
576  }
577  }
578 }
579 
580 END_SCOPE(Cn3D)
CNcbiOstrstreamToString class helps convert CNcbiOstrstream to a string Sample usage:
Definition: ncbistre.hpp:802
MoleculeMap molecules
void PostRedrawMolecule(const Molecule *molecule)
Definition: messenger.cpp:85
void PostRedrawAllSequenceViewers(void)
Definition: messenger.cpp:90
std::vector< int > residueDomains
Definition: molecule.hpp:105
static const int NO_DOMAIN_SET
Definition: molecule.hpp:98
const MoleculeIdentifier * identifier
Definition: molecule.hpp:86
unsigned int NResidues(void) const
Definition: molecule.hpp:121
ResidueMap residues
Definition: molecule.hpp:89
void ShowAllFrames(void)
virtual ~ShowHideDomain(void)
void Show(ShowHideManager *shm, bool isShown) const
bool IsVisible(const ShowHideManager *shm) const
const Molecule * molecule
ShowHideDomain(const Molecule *m, int d, int labelNum)
virtual void Show(ShowHideManager *shm, bool isShown) const =0
virtual bool IsVisible(const ShowHideManager *shm) const =0
void GetLabel(string *str) const
vector< int > parentIndexes
virtual ~ShowHideInfo(void)
void ShowDomainsWithHighlights(const StructureSet *set)
std::vector< const ShowHideInfo * > structureInfo
void ShowSelectedResidues(const StructureSet *set)
void ShowResidues(const StructureSet *set, bool showAligned)
void ShowHideCallbackFunction(const std::vector< bool > &itemsEnabled)
void ConstructShowHideArray(const StructureSet *structureSet)
void UnHideEntityAndChildren(const StructureBase *entity)
void Show(const StructureBase *entity, bool isShown)
bool IsHidden(const StructureBase *entity) const
EntitiesHidden entitiesHidden
void ShowAlignedDomains(const StructureSet *set)
void ShowAlignedOrAnnotatedDomains(const StructureSet *set)
void PrivateShowResidues(const StructureSet *set, bool showAligned)
bool SelectionChangedCallback(const std::vector< bool > &original, std::vector< bool > &itemsEnabled)
void ShowAlignedChains(const StructureSet *set)
void ShowUnalignedResiduesInAlignedDomains(const StructureSet *set)
bool IsVisible(const StructureBase *entity) const
void GetShowHideInfo(std::vector< std::string > *names, std::vector< bool > *visibilities) const
ShowHideMolecule(const Molecule *m)
const Molecule * molecule
void Show(ShowHideManager *shm, bool isShown) const
bool IsVisible(const ShowHideManager *shm) const
virtual ~ShowHideMolecule(void)
void Show(ShowHideManager *shm, bool isShown) const
virtual ~ShowHideObject(void)
ShowHideObject(const StructureObject *o)
const StructureObject * object
bool IsVisible(const ShowHideManager *shm) const
StructureSet * parentSet
bool GetParentOfType(const T **ptr, bool warnIfNotFound=true) const
std::string GetPDBID(char separator='_') const
const ChemicalGraph * graph
ObjectList objects
OpenGLRenderer * renderer
const_iterator end() const
Definition: map.hpp:152
const_iterator find(const key_type &key) const
Definition: map.hpp:153
Definition: map.hpp:338
Definition: set.hpp:45
const_iterator begin() const
Definition: set.hpp:135
const_iterator end() const
Definition: set.hpp:136
#define TRACEMSG(stream)
Definition: cn3d_tools.hpp:83
#define ERRORMSG(stream)
Definition: cn3d_tools.hpp:86
Include a standard set of the NCBI C++ Toolkit most basic headers.
static const struct name_t names[]
static const char * str(char *buf, int n)
Definition: stats.c:84
string
Definition: cgiapp.hpp:687
#define NULL
Definition: ncbistd.hpp:225
#define END_SCOPE(ns)
End the previously defined scope.
Definition: ncbistl.hpp:75
#define BEGIN_SCOPE(ns)
Define a new scope.
Definition: ncbistl.hpp:72
static const char label[]
int i
static MDB_envinfo info
Definition: mdb_load.c:37
Messenger * GlobalMessenger(void)
Definition: messenger.cpp:73
NCBI C++ stream class wrappers for triggering between "new" and "old" C++ stream libraries.
double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)
string indent(" ")
static void PostRedrawEntity(const StructureObject *object, const Molecule *molecule, const Residue *residue)
USING_NCBI_SCOPE
Modified on Wed May 22 11:27:10 2024 by modify_doxy.py rev. 669887