开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
style_manager.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：76k
源码类别：

生物技术

开发平台：

C/C++

style_manager.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: style_manager.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 18:29:44  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.84
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: style_manager.cpp,v 1000.2 2004/06/01 18:29:44 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Authors:  Paul Thiessen
  36. *
  37. * File Description:
  38. *      manager object to track drawing style of objects at various levels
  39. *
  40. * ===========================================================================
  41. */
  43. #ifdef _MSC_VER
  44. #pragma warning(disable:4018)   // disable signed/unsigned mismatch warning in MSVC
  45. #endif
  47. #include <ncbi_pch.hpp>
  48. #include <corelib/ncbistd.hpp>
  49. #include <corelib/ncbiobj.hpp>
  51. #include <objects/cn3d/Cn3d_backbone_style.hpp>
  52. #include <objects/cn3d/Cn3d_general_style.hpp>
  53. #include <objects/cn3d/Cn3d_backbone_label_style.hpp>
  54. #include <objects/cn3d/Cn3d_color.hpp>
  55. #include <objects/cn3d/Cn3d_style_table_item.hpp>
  56. #include <objects/cn3d/Cn3d_style_table_id.hpp>
  57. #include <objects/cn3d/Cn3d_user_annotation.hpp>
  58. #include <objects/cn3d/Cn3d_object_location.hpp>
  59. #include <objects/mmdb1/Biostruc_id.hpp>
  60. #include <objects/mmdb1/Mmdb_id.hpp>
  61. #include <objects/cn3d/Cn3d_molecule_location.hpp>
  62. #include <objects/cn3d/Cn3d_residue_range.hpp>
  63. #include <objects/mmdb1/Residue_id.hpp>
  64. #include <objects/mmdb1/Molecule_id.hpp>
  66. #include <memory>
  67. #include <string.h> // for memcpy()
  69. #include "style_manager.hpp"
  70. #include "structure_set.hpp"
  71. #include "chemical_graph.hpp"
  72. #include "residue.hpp"
  73. #include "periodic_table.hpp"
  74. #include "bond.hpp"
  75. #include "show_hide_manager.hpp"
  76. #include "object_3d.hpp"
  77. #include "alignment_manager.hpp"
  78. #include "messenger.hpp"
  79. #include "cn3d_colors.hpp"
  80. #include "style_dialog.hpp"
  81. #include "annotate_dialog.hpp"
  82. #include "molecule_identifier.hpp"
  83. #include "atom_set.hpp"
  84. #include "cn3d_tools.hpp"
  86. USING_NCBI_SCOPE;
  87. USING_SCOPE(objects);
  90. BEGIN_SCOPE(Cn3D)
  92. ///// StyleSettings stuff /////
  94. static void Vector2ASNColor(const Vector &vec, CCn3d_color *asnColor)
  95. {
  96.     static const int SCALE = 10000;
  97.     asnColor->SetScale_factor(SCALE);
  98.     asnColor->SetRed((int) (vec[0] * SCALE));
  99.     asnColor->SetGreen((int) (vec[1] * SCALE));
  100.     asnColor->SetBlue((int) (vec[2] * SCALE));
  101.     asnColor->SetAlpha(SCALE);  // no alpha in Cn3D's colors
  102. }
  104. static bool SaveBackboneStyleToASN(
  105.     const StyleSettings::BackboneStyle bbSettings, CCn3d_backbone_style *bbASN)
  106. {
  107.     // these casts rely on correspondence of enumerated values!
  108.     bbASN->SetType((ECn3d_backbone_type) bbSettings.type);
  109.     bbASN->SetStyle((ECn3d_drawing_style) bbSettings.style);
  110.     bbASN->SetColor_scheme((ECn3d_color_scheme) bbSettings.colorScheme);
  111.     Vector2ASNColor(bbSettings.userColor, &(bbASN->SetUser_color()));
  112.     return true;
  113. }
  115. static bool SaveGeneralStyleToASN(
  116.     const StyleSettings::GeneralStyle gSettings, CCn3d_general_style *gASN)
  117. {
  118.     // these casts rely on correspondence of enumerated values!
  119.     gASN->SetIs_on(gSettings.isOn);
  120.     gASN->SetStyle((ECn3d_drawing_style) gSettings.style);
  121.     gASN->SetColor_scheme((ECn3d_color_scheme) gSettings.colorScheme);
  122.     Vector2ASNColor(gSettings.userColor, &(gASN->SetUser_color()));
  123.     return true;
  124. }
  126. static bool SaveLabelStyleToASN(
  127.     const StyleSettings::LabelStyle lSettings, CCn3d_backbone_label_style *lASN)
  128. {
  129.     lASN->SetSpacing(lSettings.spacing);
  130.     // these casts rely on correspondence of enumerated values!
  131.     lASN->SetType((CCn3d_backbone_label_style::EType) lSettings.type);
  132.     lASN->SetNumber((CCn3d_backbone_label_style::ENumber) lSettings.numbering);
  133.     lASN->SetTermini(lSettings.terminiOn);
  134.     lASN->SetWhite(lSettings.white);
  135.     return true;
  136. }
  138. bool StyleSettings::SaveSettingsToASN(CCn3d_style_settings *styleASN) const
  139. {
  140.     styleASN->SetVirtual_disulfides_on(virtualDisulfidesOn);
  141.     Vector2ASNColor(virtualDisulfideColor, &(styleASN->SetVirtual_disulfide_color()));
  142.     styleASN->SetHydrogens_on(hydrogensOn);
  143.     Vector2ASNColor(backgroundColor, &(styleASN->SetBackground_color()));
  144.     styleASN->SetIon_labels(ionLabelsOn);
  146.     static const int SCALE = 10000;
  147.     styleASN->SetScale_factor(SCALE);
  148.     styleASN->SetSpace_fill_proportion((int) (spaceFillProportion * SCALE));
  149.     styleASN->SetBall_radius((int) (ballRadius * SCALE));
  150.     styleASN->SetStick_radius((int) (stickRadius * SCALE));
  151.     styleASN->SetTube_radius((int) (tubeRadius * SCALE));
  152.     styleASN->SetTube_worm_radius((int) (tubeWormRadius * SCALE));
  153.     styleASN->SetHelix_radius((int) (helixRadius * SCALE));
  154.     styleASN->SetStrand_width((int) (strandWidth * SCALE));
  155.     styleASN->SetStrand_thickness((int) (strandThickness * SCALE));
  157.     return (
  158.         SaveBackboneStyleToASN(proteinBackbone, &(styleASN->SetProtein_backbone())) &&
  159.         SaveBackboneStyleToASN(nucleotideBackbone, &(styleASN->SetNucleotide_backbone())) &&
  160.         SaveGeneralStyleToASN(proteinSidechains, &(styleASN->SetProtein_sidechains())) &&
  161.         SaveGeneralStyleToASN(nucleotideSidechains, &(styleASN->SetNucleotide_sidechains())) &&
  162.         SaveGeneralStyleToASN(heterogens, &(styleASN->SetHeterogens())) &&
  163.         SaveGeneralStyleToASN(solvents, &(styleASN->SetSolvents())) &&
  164.         SaveGeneralStyleToASN(connections, &(styleASN->SetConnections())) &&
  165.         SaveGeneralStyleToASN(helixObjects, &(styleASN->SetHelix_objects())) &&
  166.         SaveGeneralStyleToASN(strandObjects, &(styleASN->SetStrand_objects())) &&
  167.         SaveLabelStyleToASN(proteinLabels, &(styleASN->SetProtein_labels())) &&
  168.         SaveLabelStyleToASN(nucleotideLabels, &(styleASN->SetNucleotide_labels()))
  169.     );
  170. }
  172. static void ASNColor2Vector(const CCn3d_color& asnColor, Vector *vec)
  173. {
  174.     int SCALE = asnColor.GetScale_factor();
  175.     vec->Set(
  176.         1.0 * asnColor.GetRed() / SCALE,
  177.         1.0 * asnColor.GetGreen() / SCALE,
  178.         1.0 * asnColor.GetBlue() / SCALE
  179.     );
  180.     // no alpha in Cn3D's colors
  181. }
  183. static bool LoadBackboneStyleFromASN(
  184.     const CCn3d_backbone_style& bbASN, StyleSettings::BackboneStyle *bbSettings)
  185. {
  186.     // these casts rely on correspondence of enumerated values!
  187.     bbSettings->type = (StyleSettings::eBackboneType) bbASN.GetType();
  188.     bbSettings->style = (StyleSettings::eDrawingStyle) bbASN.GetStyle();
  189.     bbSettings->colorScheme = (StyleSettings::eColorScheme) bbASN.GetColor_scheme();
  190.     ASNColor2Vector(bbASN.GetUser_color(), &(bbSettings->userColor));
  191.     return true;
  192. }
  194. static bool LoadGeneralStyleFromASN(
  195.     const CCn3d_general_style& gASN, StyleSettings::GeneralStyle *gSettings)
  196. {
  197.     // these casts rely on correspondence of enumerated values!
  198.     gSettings->isOn = gASN.GetIs_on();
  199.     gSettings->style = (StyleSettings::eDrawingStyle) gASN.GetStyle();
  200.     gSettings->colorScheme = (StyleSettings::eColorScheme) gASN.GetColor_scheme();
  201.     ASNColor2Vector(gASN.GetUser_color(), &(gSettings->userColor));
  202.     return true;
  203. }
  205. static bool LoadLabelStyleFromASN(
  206.     const CCn3d_backbone_label_style& lASN, StyleSettings::LabelStyle *lSettings)
  207. {
  208.     lSettings->spacing = lASN.GetSpacing();
  209.     // these casts rely on correspondence of enumerated values!
  210.     lSettings->type = (StyleSettings::eLabelType) lASN.GetType();
  211.     lSettings->numbering = (StyleSettings::eNumberType) lASN.GetNumber();
  212.     lSettings->terminiOn = lASN.GetTermini();
  213.     lSettings->white = lASN.GetWhite();
  214.     return true;
  215. }
  217. static void SetDefaultLabelStyle(StyleSettings::LabelStyle *lStyle)
  218. {
  219.     lStyle->spacing = 0;
  220.     lStyle->type = StyleSettings::eThreeLetter;
  221.     lStyle->numbering = StyleSettings::eSequentialNumbering;
  222.     lStyle->terminiOn = false;
  223.     lStyle->white = true;
  224. }
  226. bool StyleSettings::LoadSettingsFromASN(const CCn3d_style_settings& styleASN)
  227. {
  228.     virtualDisulfidesOn = styleASN.GetVirtual_disulfides_on();
  229.     ASNColor2Vector(styleASN.GetVirtual_disulfide_color(), &virtualDisulfideColor);
  230.     hydrogensOn = styleASN.GetHydrogens_on();
  231.     ASNColor2Vector(styleASN.GetBackground_color(), &backgroundColor);
  233.     int SCALE = styleASN.GetScale_factor();
  234.     spaceFillProportion = 1.0 * styleASN.GetSpace_fill_proportion() / SCALE;
  235.     stickRadius = 1.0 * styleASN.GetStick_radius() / SCALE;
  236.     tubeRadius = 1.0 * styleASN.GetTube_radius() / SCALE;
  237.     tubeWormRadius = 1.0 * styleASN.GetTube_worm_radius() / SCALE;
  238.     helixRadius = 1.0 * styleASN.GetHelix_radius() / SCALE;
  239.     strandWidth = 1.0 * styleASN.GetStrand_width() / SCALE;
  240.     strandThickness = 1.0 * styleASN.GetStrand_thickness() / SCALE;
  242.     // label defaults (since they're optional in ASN spec)
  243.     if (styleASN.IsSetProtein_labels()) {
  244.         if (!LoadLabelStyleFromASN(styleASN.GetProtein_labels(), &proteinLabels)) return false;
  245.     } else
  246.         SetDefaultLabelStyle(&proteinLabels);
  247.     if (styleASN.IsSetNucleotide_labels()) {
  248.         if (!LoadLabelStyleFromASN(styleASN.GetNucleotide_labels(), &nucleotideLabels)) return false;
  249.     } else
  250.         SetDefaultLabelStyle(&nucleotideLabels);
  251.     // ion labels on by default
  252.     ionLabelsOn = (styleASN.IsSetIon_labels()) ? styleASN.GetIon_labels() : true;
  254.     return (
  255.         LoadBackboneStyleFromASN(styleASN.GetProtein_backbone(), &proteinBackbone) &&
  256.         LoadBackboneStyleFromASN(styleASN.GetNucleotide_backbone(), &nucleotideBackbone) &&
  257.         LoadGeneralStyleFromASN(styleASN.GetProtein_sidechains(), &proteinSidechains) &&
  258.         LoadGeneralStyleFromASN(styleASN.GetNucleotide_sidechains(), &nucleotideSidechains) &&
  259.         LoadGeneralStyleFromASN(styleASN.GetHeterogens(), &heterogens) &&
  260.         LoadGeneralStyleFromASN(styleASN.GetSolvents(), &solvents) &&
  261.         LoadGeneralStyleFromASN(styleASN.GetConnections(), &connections) &&
  262.         LoadGeneralStyleFromASN(styleASN.GetHelix_objects(), &helixObjects) &&
  263.         LoadGeneralStyleFromASN(styleASN.GetStrand_objects(), &strandObjects)
  264.     );
  265. }
  267. StyleSettings& StyleSettings::operator = (const StyleSettings& orig)
  268. {
  269.     memcpy(this, &orig, sizeof(StyleSettings));
  270.     return *this;
  271. }
  273. void StyleSettings::SetRenderingStyle(ePredefinedRenderingStyle style)
  274. {
  275.     // variable settings
  276.     switch (style) {
  278.         // set sidechains isOn only
  279.         case eToggleSidechainsShortcut:
  280.             proteinSidechains.isOn = !proteinSidechains.isOn;
  281.             nucleotideSidechains.isOn = !nucleotideSidechains.isOn;
  282.             return;
  284.         case eWormShortcut:
  285.             proteinBackbone.type = nucleotideBackbone.type = eTrace;
  286.             proteinBackbone.style = nucleotideBackbone.style = eTubeWorm;
  287.             proteinSidechains.isOn = nucleotideSidechains.isOn = false;
  288.             proteinSidechains.style = nucleotideSidechains.style = eWire;
  289.             heterogens.style = eBallAndStick;
  290.             solvents.isOn = false;
  291.             solvents.style = eBallAndStick;
  292.             connections.style = eTubes;
  293.             helixObjects.isOn = strandObjects.isOn = true;
  294.             helixObjects.style = strandObjects.style = eWithArrows;
  295.             break;
  297.         case eTubeShortcut:
  298.             proteinBackbone.type = nucleotideBackbone.type = eTrace;
  299.             proteinBackbone.style = nucleotideBackbone.style = eTubes;
  300.             proteinSidechains.isOn = nucleotideSidechains.isOn = false;
  301.             proteinSidechains.style = nucleotideSidechains.style = eWire;
  302.             heterogens.style = eBallAndStick;
  303.             solvents.isOn = false;
  304.             solvents.style = eBallAndStick;
  305.             connections.style = eTubes;
  306.             helixObjects.isOn = strandObjects.isOn = false;
  307.             helixObjects.style = strandObjects.style = eWithArrows;
  308.             break;
  310.         case eWireframeShortcut:
  311.             proteinBackbone.type = nucleotideBackbone.type = eComplete;
  312.             proteinBackbone.style = nucleotideBackbone.style = eWire;
  313.             proteinSidechains.isOn = nucleotideSidechains.isOn = true;
  314.             proteinSidechains.style = nucleotideSidechains.style = eWire;
  315.             heterogens.style = eWire;
  316.             solvents.isOn = false;
  317.             solvents.style = eBallAndStick;
  318.             connections.style = eWire;
  319.             helixObjects.isOn = strandObjects.isOn = false;
  320.             helixObjects.style = strandObjects.style = eWithArrows;
  321.             break;
  323.         case eBallAndStickShortcut:
  324.             proteinBackbone.type = nucleotideBackbone.type = eComplete;
  325.             proteinBackbone.style = nucleotideBackbone.style = eBallAndStick;
  326.             proteinSidechains.isOn = nucleotideSidechains.isOn = true;
  327.             proteinSidechains.style = nucleotideSidechains.style = eBallAndStick;
  328.             heterogens.style = eBallAndStick;
  329.             solvents.isOn = false;
  330.             solvents.style = eBallAndStick;
  331.             connections.style = eTubes;
  332.             helixObjects.isOn = strandObjects.isOn = false;
  333.             helixObjects.style = strandObjects.style = eWithArrows;
  334.             break;
  336.         case eSpacefillShortcut:
  337.             proteinBackbone.type = nucleotideBackbone.type = eComplete;
  338.             proteinBackbone.style = nucleotideBackbone.style = eSpaceFill;
  339.             proteinSidechains.isOn = nucleotideSidechains.isOn = true;
  340.             proteinSidechains.style = nucleotideSidechains.style = eSpaceFill;
  341.             heterogens.style = eSpaceFill;
  342.             solvents.isOn = false;
  343.             solvents.style = eSpaceFill;
  344.             connections.style = eTubes;
  345.             helixObjects.isOn = strandObjects.isOn = false;
  346.             helixObjects.style = strandObjects.style = eWithArrows;
  347.             break;
  348.     }
  350.     // common settings
  351.     heterogens.isOn = true;
  352.     connections.isOn = true;
  353.     virtualDisulfidesOn = true;
  354.     hydrogensOn = true;
  355.     helixRadius = 1.8;
  356.     strandWidth = 2.0;
  357.     strandThickness = 0.5;
  358.     spaceFillProportion = 1.0;
  359.     ballRadius = 0.4;
  360.     stickRadius = 0.2;
  361.     tubeRadius = 0.3;
  362.     tubeWormRadius = 0.3;
  363. }
  365. void StyleSettings::SetColorScheme(ePredefinedColorScheme scheme)
  366. {
  367.     // variable settings
  368.     switch (scheme) {
  369.         case eSecondaryStructureShortcut:
  370.             proteinBackbone.colorScheme = eSecondaryStructure;
  371.             nucleotideBackbone.colorScheme = eMolecule;
  372.             proteinSidechains.colorScheme = nucleotideSidechains.colorScheme = eElement;
  373.             heterogens.colorScheme = solvents.colorScheme = eElement;
  374.             helixObjects.colorScheme = strandObjects.colorScheme = eSecondaryStructure;
  375.             break;
  377.         case eAlignedShortcut: case eIdentityShortcut: case eVarietyShortcut:
  378.         case eWeightedVarietyShortcut: case eInformationContentShortcut:
  379.         case eFitShortcut: case eBlockFitShortcut: case eBlockZFitShortcut: case eBlockRowFitShortcut:
  380.             switch (scheme) {
  381.                 case eAlignedShortcut: proteinBackbone.colorScheme = eAligned; break;
  382.                 case eIdentityShortcut: proteinBackbone.colorScheme = eIdentity; break;
  383.                 case eVarietyShortcut: proteinBackbone.colorScheme = eVariety; break;
  384.                 case eWeightedVarietyShortcut: proteinBackbone.colorScheme = eWeightedVariety; break;
  385.                 case eInformationContentShortcut: proteinBackbone.colorScheme = eInformationContent; break;
  386.                 case eFitShortcut: proteinBackbone.colorScheme = eFit; break;
  387.                 case eBlockFitShortcut: proteinBackbone.colorScheme = eBlockFit; break;
  388.                 case eBlockZFitShortcut: proteinBackbone.colorScheme = eBlockZFit; break;
  389.                 case eBlockRowFitShortcut: proteinBackbone.colorScheme = eBlockRowFit; break;
  390.             }
  391.             nucleotideBackbone.colorScheme = eMolecule;
  392.             proteinSidechains.colorScheme = nucleotideSidechains.colorScheme = eElement;
  393.             heterogens.colorScheme = solvents.colorScheme = eElement;
  394.             helixObjects.colorScheme = strandObjects.colorScheme = eObject;
  395.             break;
  397.         case eObjectShortcut:
  398.             proteinBackbone.colorScheme = eObject;
  399.             nucleotideBackbone.colorScheme = eObject;
  400.             proteinSidechains.colorScheme = nucleotideSidechains.colorScheme = eObject;
  401.             heterogens.colorScheme = solvents.colorScheme = eObject;
  402.             helixObjects.colorScheme = strandObjects.colorScheme = eObject;
  403.             break;
  405.         case eDomainShortcut:
  406.             proteinBackbone.colorScheme = eDomain;
  407.             nucleotideBackbone.colorScheme = eDomain;
  408.             proteinSidechains.colorScheme = nucleotideSidechains.colorScheme = eElement;
  409.             heterogens.colorScheme = solvents.colorScheme = eElement;
  410.             helixObjects.colorScheme = strandObjects.colorScheme = eDomain;
  411.             break;
  413.         case eMoleculeShortcut:
  414.             proteinBackbone.colorScheme = eMolecule;
  415.             nucleotideBackbone.colorScheme = eMolecule;
  416.             proteinSidechains.colorScheme = nucleotideSidechains.colorScheme = eMolecule;
  417.             heterogens.colorScheme = solvents.colorScheme = eMolecule;
  418.             helixObjects.colorScheme = strandObjects.colorScheme = eMolecule;
  419.             break;
  421.         case eRainbowShortcut:
  422.             proteinBackbone.colorScheme = eRainbow;
  423.             nucleotideBackbone.colorScheme = eRainbow;
  424.             proteinSidechains.colorScheme = nucleotideSidechains.colorScheme = eRainbow;
  425.             heterogens.colorScheme = solvents.colorScheme = eElement;
  426.             helixObjects.colorScheme = strandObjects.colorScheme = eObject;
  427.             break;
  429.         case eHydrophobicityShortcut:
  430.             proteinBackbone.colorScheme = eHydrophobicity;
  431.             nucleotideBackbone.colorScheme = eMolecule;
  432.             proteinSidechains.colorScheme = eHydrophobicity;
  433.             nucleotideSidechains.colorScheme = eElement;
  434.             heterogens.colorScheme = solvents.colorScheme = eElement;
  435.             helixObjects.colorScheme = strandObjects.colorScheme = eObject;
  436.             break;
  438.         case eChargeShortcut:
  439.             proteinBackbone.colorScheme = eCharge;
  440.             nucleotideBackbone.colorScheme = eElement;
  441.             proteinSidechains.colorScheme = eCharge;
  442.             nucleotideSidechains.colorScheme = eElement;
  443.             heterogens.colorScheme = solvents.colorScheme = eElement;
  444.             helixObjects.colorScheme = strandObjects.colorScheme = eObject;
  445.             break;
  447.         case eTemperatureShortcut:
  448.             proteinBackbone.colorScheme = eTemperature;
  449.             nucleotideBackbone.colorScheme = eTemperature;
  450.             proteinSidechains.colorScheme = nucleotideSidechains.colorScheme = eTemperature;
  451.             heterogens.colorScheme = solvents.colorScheme = eTemperature;
  452.             helixObjects.colorScheme = strandObjects.colorScheme = eObject;
  453.             break;
  455.         case eElementShortcut:
  456.             proteinBackbone.colorScheme = eElement;
  457.             nucleotideBackbone.colorScheme = eElement;
  458.             proteinSidechains.colorScheme = nucleotideSidechains.colorScheme = eElement;
  459.             heterogens.colorScheme = eElement;
  460.             solvents.colorScheme = eElement;
  461.             helixObjects.colorScheme = strandObjects.colorScheme = eObject;
  462.             break;
  463.     }
  465.     // common settings
  466.     connections.colorScheme = eUserSelect;
  467.     connections.userColor.Set(0.9,0.9,1);
  468.     virtualDisulfideColor.Set(0.93,0.55,0.05);
  469.     backgroundColor.Set(0,0,0);
  471.     proteinSidechains.userColor = nucleotideSidechains.userColor =
  472.     proteinBackbone.userColor = nucleotideBackbone.userColor =
  473.     heterogens.userColor = solvents.userColor =
  474.     helixObjects.userColor = strandObjects.userColor = Vector(0.5,0.5,0.5);
  475. }
  477. void StyleSettings::SetDefaultLabeling(void)
  478. {
  479.     SetDefaultLabelStyle(&proteinLabels);
  480.     SetDefaultLabelStyle(&nucleotideLabels);
  481.     ionLabelsOn = true;
  482. }
  485. ///// StyleManager stuff /////
  487. StyleManager::StyleManager(const StructureSet *set) : structureSet(set)
  488. {
  489. }
  491. bool StyleManager::CheckGlobalStyleSettings()
  492. {
  493.     return CheckStyleSettings(&globalStyle);
  494. }
  496. // check for inconsistencies in style settings; returns false if there's an uncorrectable problem
  497. bool StyleManager::CheckStyleSettings(StyleSettings *settings)
  498. {
  499.     // can't do worm with partial or complete backbone
  500.     if (((settings->proteinBackbone.style == StyleSettings::eWireWorm ||
  501.           settings->proteinBackbone.style == StyleSettings::eTubeWorm) &&
  502.          (settings->proteinBackbone.type == StyleSettings::ePartial ||
  503.           settings->proteinBackbone.type == StyleSettings::eComplete))) {
  504.         settings->proteinBackbone.type = StyleSettings::eTrace;
  505.     }
  506.     if (((settings->nucleotideBackbone.style == StyleSettings::eWireWorm ||
  507.           settings->nucleotideBackbone.style == StyleSettings::eTubeWorm) &&
  508.          (settings->nucleotideBackbone.type == StyleSettings::ePartial ||
  509.           settings->nucleotideBackbone.type == StyleSettings::eComplete))) {
  510.         settings->nucleotideBackbone.type = StyleSettings::eTrace;
  511.     }
  513.     // can't do non-trace backbones for ncbi-backbone models
  514.     if (structureSet->isAlphaOnly) {
  515.         if (settings->proteinBackbone.type == StyleSettings::ePartial ||
  516.             settings->proteinBackbone.type == StyleSettings::eComplete) {
  517.             settings->proteinBackbone.type = StyleSettings::eTrace;
  518.         }
  519.         if (settings->nucleotideBackbone.type == StyleSettings::ePartial ||
  520.             settings->nucleotideBackbone.type == StyleSettings::eComplete) {
  521.             settings->nucleotideBackbone.type = StyleSettings::eTrace;
  522.         }
  523.     }
  525.     return true;
  526. }
  528. const double UNKNOWN_HYDROPHOBICITY = -1.0;
  530. // return a hydrophobicity value from [0..1]
  531. double GetHydrophobicity(char code)
  532. {
  533.     // Amino acid scale: Normalized consensus hydrophobicity scale.
  534.     // Author(s): Eisenberg D., Schwarz E., Komarony M., Wall R.
  535.     // Reference: J. Mol. Biol. 179:125-142(1984).
  536.     // Amino acid scale values: (normalized to [0..1])
  537.     switch (code) {
  538.         case 'A': return ( 0.620 + 2.530) / (1.380 + 2.530);
  539.         case 'R': return (-2.530 + 2.530) / (1.380 + 2.530);
  540.         case 'N': return (-0.780 + 2.530) / (1.380 + 2.530);
  541.         case 'D': return (-0.900 + 2.530) / (1.380 + 2.530);
  542.         case 'C': return ( 0.290 + 2.530) / (1.380 + 2.530);
  543.         case 'Q': return (-0.850 + 2.530) / (1.380 + 2.530);
  544.         case 'E': return (-0.740 + 2.530) / (1.380 + 2.530);
  545.         case 'G': return ( 0.480 + 2.530) / (1.380 + 2.530);
  546.         case 'H': return (-0.400 + 2.530) / (1.380 + 2.530);
  547.         case 'I': return ( 1.380 + 2.530) / (1.380 + 2.530);
  548.         case 'L': return ( 1.060 + 2.530) / (1.380 + 2.530);
  549.         case 'K': return (-1.500 + 2.530) / (1.380 + 2.530);
  550.         case 'M': return ( 0.640 + 2.530) / (1.380 + 2.530);
  551.         case 'F': return ( 1.190 + 2.530) / (1.380 + 2.530);
  552.         case 'P': return ( 0.120 + 2.530) / (1.380 + 2.530);
  553.         case 'S': return (-0.180 + 2.530) / (1.380 + 2.530);
  554.         case 'T': return (-0.050 + 2.530) / (1.380 + 2.530);
  555.         case 'W': return ( 0.810 + 2.530) / (1.380 + 2.530);
  556.         case 'Y': return ( 0.260 + 2.530) / (1.380 + 2.530);
  557.         case 'V': return ( 1.080 + 2.530) / (1.380 + 2.530);
  558.     }
  559.     return UNKNOWN_HYDROPHOBICITY;
  560. }
  562. int GetCharge(char code)
  563. {
  564.     switch (code) {
  565.         case 'R': case 'H': case 'K': return 1;
  566.         case 'D': case 'E': return -1;
  567.     }
  568.     return 0;
  569. }
  571. #define ATOM_NOT_DISPLAYED do { 
  572.     atomStyle->style = eNotDisplayed; 
  573.     return true; } while (0)
  575. // get display style for atom, including show/hide status.
  576. // May want to cache this eventually, since a
  577. // particular atom's style may be queried several times per render (once for
  578. // drawing atoms, and once for each bond to the atom).
  579. bool StyleManager::GetAtomStyle(const Residue *residue,
  580.     const AtomPntr& atom, const AtomCoord *coord,
  581.     AtomStyle *atomStyle,
  582.     const StyleSettings::BackboneStyle* *saveBackboneStyle,
  583.     const StyleSettings::GeneralStyle* *saveGeneralStyle) const
  584. {
  585.     if (!residue || !atomStyle) {
  586.         ERRORMSG("StyleManager::GetAtomStyle() got NULL residue or atomStyle");
  587.         return false;
  588.     }
  589.     atomStyle->isHighlighted = false; // queried sometimes even if atom not displayed
  591.     const Molecule *molecule;
  592.     if (!residue->GetParentOfType(&molecule)) return false;
  594.     const StructureObject *object;
  595.     if (!molecule->GetParentOfType(&object)) return false;
  597.     const StyleSettings& settings = GetStyleForResidue(object, atom.mID, atom.rID);
  598.     const Residue::AtomInfo *info = residue->GetAtomInfo(atom.aID);
  599.     if (!info)
  600.         ATOM_NOT_DISPLAYED;
  602.     // set up some pointers for more convenient access to style settings
  603.     const StyleSettings::BackboneStyle *backboneStyle = NULL;
  604.     const StyleSettings::GeneralStyle *generalStyle = NULL;
  605.     if (info->classification == Residue::eAlphaBackboneAtom ||
  606.         info->classification == Residue::ePartialBackboneAtom ||
  607.         info->classification == Residue::eCompleteBackboneAtom) {
  608.         if (residue->IsAminoAcid())
  609.             backboneStyle = &(settings.proteinBackbone);
  610.         else
  611.             backboneStyle = &(settings.nucleotideBackbone);
  613.     } else if (info->classification == Residue::eSideChainAtom) {
  614.         if (residue->IsAminoAcid())
  615.             generalStyle = &(settings.proteinSidechains);
  616.         else
  617.             generalStyle = &(settings.nucleotideSidechains);
  619.     } else { // Residue::eUnknownAtom
  620.         if (molecule->IsSolvent())
  621.             generalStyle = &(settings.solvents);
  622.         else if (molecule->IsHeterogen())
  623.             generalStyle = &(settings.heterogens);
  624.         else {
  625.             ERRORMSG("StyleManager::GetAtomStyle() - confused about molecule/atom classification");
  626.             return false;
  627.         }
  628.     }
  629.     if ((!backboneStyle && !generalStyle) || (backboneStyle && generalStyle)) {
  630.         ERRORMSG("StyleManager::GetAtomStyle() - confused about style settings");
  631.         return false;
  632.     }
  633.     if (saveBackboneStyle) *saveBackboneStyle = backboneStyle;
  634.     if (saveGeneralStyle) *saveGeneralStyle = generalStyle;
  636.     // first check whether this atom is visible, based on show/hide and backbone and sidechain settings
  637.     if (object->parentSet->showHideManager->IsHidden(residue))
  638.         ATOM_NOT_DISPLAYED;
  640.     if (info->atomicNumber == 1 && !settings.hydrogensOn)
  641.         ATOM_NOT_DISPLAYED;
  643.     if (info->classification == Residue::eSideChainAtom && !generalStyle->isOn)
  644.        ATOM_NOT_DISPLAYED;
  646.     if (info->classification == Residue::eAlphaBackboneAtom ||
  647.         info->classification == Residue::ePartialBackboneAtom ||
  648.         info->classification == Residue::eCompleteBackboneAtom) { // is backbone of some sort
  650.         // control presence of non CA/C1* backbone atoms
  651.         if ((residue->IsAminoAcid() && info->classification != Residue::eAlphaBackboneAtom) ||
  652.             (residue->IsNucleotide() && info->code != " C1*")) {
  654.             // skip if backbone off
  655.             if (backboneStyle->type == StyleSettings::eOff)
  656.                 ATOM_NOT_DISPLAYED;
  658.             // show only alpha atom if eTrace
  659.             if (backboneStyle->type == StyleSettings::eTrace &&
  660.                 info->classification != Residue::eAlphaBackboneAtom)
  661.                 ATOM_NOT_DISPLAYED;
  663.             // don't show complete backbone if set to partial
  664.             if (info->classification == Residue::eCompleteBackboneAtom &&
  665.                 backboneStyle->type == StyleSettings::ePartial)
  666.                 ATOM_NOT_DISPLAYED;
  667.         }
  669.         // if this is alpha/C1* and backbone is off, but sidechains are on, then
  670.         // let the atom be visible *and* take the style of the sidechain
  671.         else if (backboneStyle->type == StyleSettings::eOff ||
  672.                  (residue->IsNucleotide() && backboneStyle->type != StyleSettings::eComplete)) {
  674.             const StyleSettings::GeneralStyle *sidechainStyle = NULL;
  675.             if (residue->IsAminoAcid()) sidechainStyle = &(settings.proteinSidechains);
  676.             else if (residue->IsNucleotide()) sidechainStyle = &(settings.nucleotideSidechains);
  678.             if (sidechainStyle && sidechainStyle->isOn) {
  679.                 backboneStyle = NULL;
  680.                 generalStyle = sidechainStyle;
  681.             } else
  682.                 ATOM_NOT_DISPLAYED;
  683.         }
  684.     }
  686.     if (info->classification == Residue::eUnknownAtom && !generalStyle->isOn)
  687.         ATOM_NOT_DISPLAYED;
  689.     const Element *element = PeriodicTable.GetElement(info->atomicNumber);
  691.     // determine radius
  692.     switch (backboneStyle ? backboneStyle->style : generalStyle->style) {
  693.         case StyleSettings::eWire:
  694.         case StyleSettings::eWireWorm:
  695.         case StyleSettings::eTubeWorm:
  696.             // no atom, but don't do ATOM_NOT_DISPLAYED, because bonds to this atom
  697.             // still may be displayed and need style info about this atom
  698.             atomStyle->radius = 0.0;
  699.             break;
  700.         case StyleSettings::eTubes:
  701.             atomStyle->radius = settings.tubeRadius;
  702.             break;
  703.         case StyleSettings::eBallAndStick:
  704.             atomStyle->radius = settings.ballRadius;
  705.             break;
  706.         case StyleSettings::eSpaceFill:
  707.             atomStyle->radius = element->vdWRadius * settings.spaceFillProportion;
  708.             break;
  709.         default:
  710.             ERRORMSG("StyleManager::GetAtomStyle() - inappropriate style for atom");
  711.             return false;
  712.     }
  714.     // determine color
  715.     StyleSettings::eColorScheme
  716.         colorStyle = backboneStyle ? backboneStyle->colorScheme : generalStyle->colorScheme;
  717.     switch (colorStyle) {
  719.         case StyleSettings::eElement:
  720.             atomStyle->color = element->color;
  721.             break;
  723.         case StyleSettings::eAligned:
  724.         case StyleSettings::eIdentity:
  725.         case StyleSettings::eVariety:
  726.         case StyleSettings::eWeightedVariety:
  727.         case StyleSettings::eInformationContent:
  728.         case StyleSettings::eFit:
  729.         case StyleSettings::eBlockFit:
  730.         case StyleSettings::eBlockZFit:
  731.         case StyleSettings::eBlockRowFit:
  732.             if (molecule->sequence &&
  733.                 molecule->parentSet->alignmentManager->
  734.                     IsAligned(molecule->sequence, residue->id - 1)) { // assume seqIndex is rID - 1
  735.                 const Vector * color = molecule->parentSet->alignmentManager->
  736.                     GetAlignmentColor(molecule->sequence, residue->id - 1, colorStyle);
  737.                 if (color)
  738.                     atomStyle->color = *color;
  739.                 else
  740.                     atomStyle->color = GlobalColors()->Get(Colors::eUnaligned);
  741.                 break;
  742.             }
  743.             if (colorStyle != StyleSettings::eAligned) {
  744.                 atomStyle->color = GlobalColors()->Get(Colors::eUnaligned);
  745.                 break;
  746.             }
  747.             // if eAligned and not aligned, then fall through to use eObject coloring
  749.         case StyleSettings::eObject:
  750.             atomStyle->color = GlobalColors()->Get(Colors::eCycle1, object->id - 1);
  751.             break;
  753.         case StyleSettings::eDomain:
  754.             atomStyle->color =
  755.                 (molecule->residueDomains[residue->id - 1] == Molecule::NO_DOMAIN_SET) ?
  756.                     GlobalColors()->Get(Colors::eNoDomain) :
  757.                     GlobalColors()->Get(Colors::eCycle1, molecule->residueDomains[residue->id - 1] - 1);
  758.             break;
  760.         case StyleSettings::eMolecule:
  761.             atomStyle->color = GlobalColors()->Get(Colors::eCycle1, molecule->id - 1);
  762.             break;
  764.         case StyleSettings::eRainbow: {
  765.             double pos = 1.0;
  766.             if ((residue->IsAminoAcid() || residue->IsNucleotide()) && molecule->NResidues() > 1) {
  767.                 pos = 1.0 * (residue->id - 1) / (molecule->NResidues() - 1);
  768.             }
  769.             atomStyle->color = GlobalColors()->Get(Colors::eRainbowMap, pos);
  770.             break;
  771.         }
  773.         case StyleSettings::eSecondaryStructure:
  774.             if (molecule->IsResidueInHelix(residue->id))
  775.                 atomStyle->color = GlobalColors()->Get(Colors::eHelix);
  776.             else if (molecule->IsResidueInStrand(residue->id))
  777.                 atomStyle->color = GlobalColors()->Get(Colors::eStrand);
  778.             else
  779.                 atomStyle->color = GlobalColors()->Get(Colors::eCoil);
  780.             break;
  782.         case StyleSettings::eCharge: {
  783.             int charge = (residue->IsAminoAcid()) ? GetCharge(residue->code) : 0;
  784.             atomStyle->color = GlobalColors()->Get(
  785.                 (charge > 0) ? Colors::ePositive : ((charge < 0) ? Colors::eNegative : Colors::eNeutral));
  786.             break;
  787.         }
  789.         case StyleSettings::eTemperature:
  790.             atomStyle->color =
  791.                 (coord && coord->averageTemperature != AtomCoord::NO_TEMPERATURE &&
  792.  object->maxTemperature != object->minTemperature) ?
  793.                     GlobalColors()->Get(Colors::eTemperatureMap,
  794.                         (coord->averageTemperature - object->minTemperature) /
  795.                         (object->maxTemperature - object->minTemperature)) :
  796.                     GlobalColors()->Get(Colors::eNoTemperature);
  797.             break;
  799.         case StyleSettings::eHydrophobicity: {
  800.             double hydrophobicity = (residue->IsAminoAcid()) ?
  801.                 GetHydrophobicity(residue->code) : UNKNOWN_HYDROPHOBICITY;
  802.             atomStyle->color = (hydrophobicity != UNKNOWN_HYDROPHOBICITY) ?
  803.                 GlobalColors()->Get(Colors::eHydrophobicityMap, hydrophobicity) :
  804.                 GlobalColors()->Get(Colors::eNoHydrophobicity);
  805.             break;
  806.         }
  808.         case StyleSettings::eUserSelect:
  809.             if (backboneStyle)
  810.                 atomStyle->color = backboneStyle->userColor;
  811.             else
  812.                 atomStyle->color = generalStyle->userColor;
  813.             break;
  815.         default:
  816.             ERRORMSG("StyleManager::GetAtomStyle() - inappropriate color scheme for atom");
  817.             return false;
  818.     }
  820.     // determine transparency and metal ion labeling
  821.     atomStyle->centerLabel.erase();
  822.     if (molecule->IsSolvent())
  823.         atomStyle->style = eTransparentAtom;
  824.     else if (IsMetal(info->atomicNumber) ||
  825.              (molecule->NResidues() == 1 && residue->NAtomsInGraph() == 1)) {
  826.         atomStyle->style = eTransparentAtom;
  827.         // always big spheres for metals or isolated atoms
  828.         atomStyle->radius = element->vdWRadius * settings.spaceFillProportion;
  829.         if (settings.ionLabelsOn)
  830.             atomStyle->centerLabel = element->symbol;
  831.     } else
  832.         atomStyle->style = eSolidAtom;
  834.     // add transparency; scale by occupancy if transparent
  835.     if (atomStyle->style == eTransparentAtom) {
  836.         atomStyle->alpha = 0.6;
  837.         if (coord && coord->occupancy < 1 && coord->occupancy > 0)
  838.             atomStyle->alpha *= coord->occupancy;
  839.     } else
  840.         atomStyle->alpha = 1.0;
  842.     // determine whether it's highlighted, but *don't* set the color to the highlight
  843.     // color yet, since this is used by the sequence viewer where the residue letter is
  844.     // colored independently of the highlighted background
  845.     atomStyle->isHighlighted = GlobalMessenger()->IsHighlighted(molecule, residue->id);
  847.     atomStyle->name = info->glName;
  848.     return true;
  849. }
  851. // this is basically a map from StyleSettings enums to StyleManager enums;
  852. // sets bond radius, too
  853. static bool SetBondStyleFromResidueStyle(StyleSettings::eDrawingStyle style,
  854.     const StyleSettings& settings, BondStyle::EndStyle *end)
  855. {
  856.     switch (style) {
  857.         case StyleSettings::eWire:
  858.             end->style = StyleManager::eLineBond;
  859.             break;
  860.         case StyleSettings::eTubes:
  861.             end->style = StyleManager::eCylinderBond;
  862.             end->radius = settings.tubeRadius;
  863.             break;
  864.         case StyleSettings::eBallAndStick:
  865.             end->style = StyleManager::eCylinderBond;
  866.             end->radius = settings.stickRadius;
  867.             break;
  868.         case StyleSettings::eSpaceFill:
  869.             end->style = StyleManager::eLineBond;
  870.             break;
  871.         case StyleSettings::eWireWorm:
  872.             end->style = StyleManager::eLineWormBond;
  873.             break;
  874.         case StyleSettings::eTubeWorm:
  875.             end->style = StyleManager::eThickWormBond;
  876.             end->radius = settings.tubeWormRadius;
  877.             break;
  878.         default:
  879.             ERRORMSG("SetBondStyleFromResidueStyle() - invalid style for bond");
  880.             return false;
  881.     }
  882.     return true;
  883. }
  885. #define BOND_NOT_DISPLAYED do { 
  886.     bondStyle->end1.style = bondStyle->end2.style = eNotDisplayed; 
  887.     return true; } while (0)
  889. // Bond style is set by the residue style of the atoms at each end; the color
  890. // is taken from the atom style (GetAtomStyle()), as well as some convenience
  891. // style pointers (backboneStyle, generalStyle). Show/hide status is taken
  892. // from the atoms - if either is hidden, the bond isn't shown either.
  893. bool StyleManager::GetBondStyle(const Bond *bond,
  894.         const AtomPntr& atom1, const AtomCoord *coord1,
  895.         const AtomPntr& atom2, const AtomCoord *coord2,
  896.         double bondLength, BondStyle *bondStyle) const
  897. {
  898.     const StructureObject *object;
  899.     if (!bond->GetParentOfType(&object)) return false;
  901.     const Residue::AtomInfo
  902.         *info1 = object->graph->GetAtomInfo(atom1),
  903.         *info2 = object->graph->GetAtomInfo(atom2);
  904.     if (!info1 || !info2) BOND_NOT_DISPLAYED;
  906.     AtomStyle atomStyle1, atomStyle2;
  907.     const StyleSettings::BackboneStyle *backboneStyle1, *backboneStyle2;
  908.     const StyleSettings::GeneralStyle *generalStyle1, *generalStyle2;
  909.     if (!GetAtomStyle(info1->residue, atom1, coord1, &atomStyle1, &backboneStyle1, &generalStyle1) ||
  910.         !GetAtomStyle(info2->residue, atom2, coord2, &atomStyle2, &backboneStyle2, &generalStyle2))
  911.         return false;
  913.     // if both atoms are hidden, or either one doesn't have coordinates, don't show the bond
  914.     if ((atomStyle1.style == eNotDisplayed && atomStyle2.style == eNotDisplayed) || (!coord1 || !coord2))
  915.         BOND_NOT_DISPLAYED;
  917.      // defaults
  918.     bondStyle->end1.atomCap = bondStyle->end2.atomCap = false;
  919.     bondStyle->end1.name = info1->glName;
  920.     bondStyle->end2.name = info2->glName;
  921.     bondStyle->midCap = false;
  923.     // if one atom is hidden, check for special cases to see if bond is visible at all
  924.     if (atomStyle1.style == eNotDisplayed || atomStyle2.style == eNotDisplayed) {
  925.         bool isSpecial = false;
  927.         // is residue PRO, and bond is between CD and N?
  928.         if (info1->residue->IsAminoAcid() && info1->residue->nameGraph == "PRO" &&
  929.             atom1.mID == atom2.mID && atom1.rID == atom2.rID)
  930.         {
  931.             const Molecule *molecule;
  932.             if (!info1->residue->GetParentOfType(&molecule))
  933.                 return false;
  934.             // atom1 is CD and is visible, switch N (atom2) to side chain style
  935.             if (info1->code == " CD " && atomStyle1.style != eNotDisplayed && info2->code == " N  ")
  936.             {
  937.                 generalStyle2 = generalStyle1;
  938.                 backboneStyle2 = NULL;
  939.                 atomStyle2.isHighlighted = GlobalMessenger()->IsHighlighted(molecule, info2->residue->id);
  940.                 bondStyle->end2.atomCap = true;
  941.                 isSpecial = true;
  942.             }
  943.             // atom2 is CD and is visible
  944.             else if (info2->code == " CD " && atomStyle2.style != eNotDisplayed && info1->code == " N  ")
  945.             {
  946.                 generalStyle1 = generalStyle2;
  947.                 backboneStyle1 = NULL;
  948.                 atomStyle1.isHighlighted = GlobalMessenger()->IsHighlighted(molecule, info1->residue->id);
  949.                 bondStyle->end1.atomCap = true;
  950.                 isSpecial = true;
  951.             }
  952.         }
  954.         // will show half-bonds in trace backbones
  955.         if (bond->order == Bond::eVirtual)
  956.             isSpecial = true;   // will set up style stuff later
  958.         // otherwise, don't show the bond at all when one atom is hidden
  959.         if (!isSpecial)
  960.             BOND_NOT_DISPLAYED;
  961.     }
  963.     // use connection style if bond is between molecules
  964.     if (atom1.mID != atom2.mID && bond->order != Bond::eRealDisulfide && bond->order != Bond::eVirtualDisulfide) {
  965.         if (globalStyle.connections.isOn == false)
  966.             BOND_NOT_DISPLAYED;
  967.         bondStyle->end1.color = bondStyle->end2.color = globalStyle.connections.userColor;
  968.         if (globalStyle.connections.style == StyleSettings::eWire)
  969.             bondStyle->end1.style = bondStyle->end2.style = eLineBond;
  970.         else if (globalStyle.connections.style == StyleSettings::eTubes) {
  971.             bondStyle->end1.style = bondStyle->end2.style = eCylinderBond;
  972.             bondStyle->end1.radius = bondStyle->end2.radius = globalStyle.tubeRadius;
  973.             bondStyle->end1.atomCap = bondStyle->end2.atomCap = true;
  974.         } else {
  975.             ERRORMSG("StyleManager::GetBondStyle() - invalid connection style");
  976.             return false;
  977.         }
  978.     }
  980.     // otherwise, need to query atom style to figure bond style parameters
  981.     else {
  983.         const StyleSettings&
  984.             settings1 = GetStyleForResidue(object, atom1.mID, atom1.rID),
  985.             settings2 = GetStyleForResidue(object, atom2.mID, atom2.rID);
  987.         StyleSettings::eDrawingStyle style1;
  988.         if (backboneStyle1)
  989.             style1 = backboneStyle1->style;
  990.         else
  991.             style1 = generalStyle1->style;
  992.         if (!SetBondStyleFromResidueStyle(style1, settings1, &(bondStyle->end1)))
  993.             return false;
  995.         StyleSettings::eDrawingStyle style2;
  996.         if (backboneStyle2)
  997.             style2 = backboneStyle2->style;
  998.         else
  999.             style2 = generalStyle2->style;
  1000.         if (!SetBondStyleFromResidueStyle(style2, settings2, &(bondStyle->end2)))
  1001.             return false;
  1003.         // special handling of alpha virtual bonds
  1004.         if (bond->order == Bond::eVirtual) {
  1005.             if (backboneStyle1->type != StyleSettings::eTrace || atomStyle1.style == eNotDisplayed)
  1006.                 bondStyle->end1.style = eNotDisplayed;
  1007.             if (backboneStyle2->type != StyleSettings::eTrace || atomStyle2.style == eNotDisplayed)
  1008.                 bondStyle->end2.style = eNotDisplayed;
  1009.             if (atomStyle1.style == eNotDisplayed || atomStyle2.style == eNotDisplayed)
  1010.                 bondStyle->midCap = true;
  1011.             // set worm tension, tighter for smaller protein alpha-helix
  1012.             if (info1->residue->IsAminoAcid())
  1013.                 bondStyle->tension = -0.8;
  1014.             else
  1015.                 bondStyle->tension = -0.4;
  1016.         }
  1018.         // special case coloring and rendering for disulfides
  1019.         if (bond->order == Bond::eVirtualDisulfide) {
  1020.             if (backboneStyle1->type != StyleSettings::eTrace || backboneStyle2->type != StyleSettings::eTrace ||
  1021.                 !settings1.virtualDisulfidesOn || !settings2.virtualDisulfidesOn)
  1022.                     BOND_NOT_DISPLAYED;
  1023.             // don't use worms for disulfides
  1024.             if (bondStyle->end1.style == eLineWormBond) bondStyle->end1.style = eLineBond;
  1025.             else if (bondStyle->end1.style == eThickWormBond) bondStyle->end1.style = eCylinderBond;
  1026.             if (bondStyle->end2.style == eLineWormBond) bondStyle->end2.style = eLineBond;
  1027.             else if (bondStyle->end2.style == eThickWormBond) bondStyle->end2.style = eCylinderBond;
  1028.             bondStyle->end1.color = settings1.virtualDisulfideColor;
  1029.             bondStyle->end2.color = settings2.virtualDisulfideColor;
  1030.         }
  1032.         // use atom color for all else
  1033.         else {
  1034.             bondStyle->end1.color = atomStyle1.color;
  1035.             bondStyle->end2.color = atomStyle2.color;
  1036.         }
  1039.         // special case for bonds between side chain and residue - make whole bond
  1040.         // same style/color as side chain side, and add endCap if atom is of lesser radius
  1041.         if (info2->classification == Residue::eSideChainAtom &&
  1042.             (info1->classification == Residue::eAlphaBackboneAtom ||
  1043.              info1->classification == Residue::ePartialBackboneAtom ||
  1044.              info1->classification == Residue::eCompleteBackboneAtom)
  1045.            ) {
  1046.             bondStyle->end1.style = bondStyle->end2.style;
  1047.             bondStyle->end1.color = bondStyle->end2.color;
  1048.             bondStyle->end1.radius = bondStyle->end2.radius;
  1049.             if (atomStyle1.radius < bondStyle->end1.radius)
  1050.                 bondStyle->end1.atomCap = true;
  1051.         }
  1052.         else if (info1->classification == Residue::eSideChainAtom &&
  1053.                  (info2->classification == Residue::eAlphaBackboneAtom ||
  1054.                   info2->classification == Residue::ePartialBackboneAtom ||
  1055.                   info2->classification == Residue::eCompleteBackboneAtom)
  1056.                 ) {
  1057.             bondStyle->end2.style = bondStyle->end1.style;
  1058.             bondStyle->end2.color = bondStyle->end1.color;
  1059.             bondStyle->end2.radius = bondStyle->end1.radius;
  1060.             if (atomStyle2.radius < bondStyle->end2.radius)
  1061.                 bondStyle->end2.atomCap = true;
  1062.         }
  1064.         // add midCap if style or radius for two sides of bond is different;
  1065.         if (bondStyle->end1.style != bondStyle->end2.style || bondStyle->end1.radius != bondStyle->end2.radius)
  1066.             bondStyle->midCap = true;
  1068.         // atomCaps needed at ends of thick worms when at end of chain, or if internal residues
  1069.         // are hidden or of a different style, or when missing coords of prev/next bond
  1070.         if (bondStyle->end1.style == eThickWormBond || bondStyle->end2.style == eThickWormBond) {
  1072.             const Residue::AtomInfo *infoV;
  1073.             AtomStyle atomStyleV;
  1074.             const StyleSettings::BackboneStyle *backboneStyleV;
  1075.             const StyleSettings::GeneralStyle *generalStyleV;
  1076.             const AtomSet *atomSet;
  1077.             if (!coord1->GetParentOfType(&atomSet))
  1078.                 return false;
  1079.             bool overlayConfs = atomSet->parentSet->showHideManager->OverlayConfEnsembles();
  1081.             if (bondStyle->end1.style == eThickWormBond &&
  1082.                     (!bond->previousVirtual ||
  1083.                     !(infoV = object->graph->GetAtomInfo(bond->previousVirtual->atom1)) ||
  1084.                     !GetAtomStyle(infoV->residue, bond->previousVirtual->atom1, NULL,
  1085.                         &atomStyleV, &backboneStyleV, &generalStyleV) ||
  1086.                     atomStyleV.style == eNotDisplayed ||
  1087.                     backboneStyleV->style != style1 ||
  1088.                     !atomSet->GetAtom(bond->previousVirtual->atom1, overlayConfs, true)))
  1089.                 bondStyle->end1.atomCap = true;
  1090. //            if (bondStyle->end1.atomCap)
  1091. //                TRACEMSG("bondStyle->end1.atomCap true at rID " << atom1.rID);
  1093.             if (bondStyle->end2.style == eThickWormBond &&
  1094.                     (!bond->nextVirtual ||
  1095.                     !(infoV = object->graph->GetAtomInfo(bond->nextVirtual->atom2)) ||
  1096.                     !GetAtomStyle(infoV->residue, bond->nextVirtual->atom2, NULL,
  1097.                         &atomStyleV, &backboneStyleV, &generalStyleV) ||
  1098.                     atomStyleV.style == eNotDisplayed ||
  1099.                     backboneStyleV->style != style2 ||
  1100.                     !atomSet->GetAtom(bond->nextVirtual->atom2, overlayConfs, true)))
  1101.                 bondStyle->end2.atomCap = true;
  1102. //            if (bondStyle->end2.atomCap)
  1103. //                TRACEMSG("bondStyle->end2.atomCap true at rID " << atom2.rID);
  1104.         }
  1105.     }
  1107.     // if atom is larger than half bond length, don't show that half of the bond
  1108.     bondLength /= 2;
  1109.     if (atomStyle1.radius > bondLength) {
  1110.         bondStyle->end1.style = eNotDisplayed;
  1111.         bondStyle->midCap = true;
  1112.     }
  1113.     if (atomStyle2.radius > bondLength) {
  1114.         bondStyle->end2.style = eNotDisplayed;
  1115.         bondStyle->midCap = true;
  1116.     }
  1118.     // set highlighting color if necessary
  1119.     if (atomStyle1.isHighlighted) bondStyle->end1.color = GlobalColors()->Get(Colors::eHighlight);
  1120.     if (atomStyle2.isHighlighted) bondStyle->end2.color = GlobalColors()->Get(Colors::eHighlight);
  1122.     return true;
  1123. }
  1125. bool StyleManager::GetObjectStyle(const StructureObject *object, const Object3D& object3D,
  1126.     const StyleSettings::GeneralStyle& generalStyle, ObjectStyle *objectStyle) const
  1127. {
  1128.     // check to see if any residue covered by the object is visible
  1129.     bool anyResidueVisible = false;
  1130.     const Molecule *molecule = object->graph->molecules.find(object3D.moleculeID)->second;
  1131.     for (int r=object3D.fromResidueID; r<=object3D.toResidueID; ++r) {
  1132.         if (object->parentSet->showHideManager->IsVisible(molecule->residues.find(r)->second)) {
  1133.             anyResidueVisible = true;
  1134.             break;
  1135.         }
  1136.     }
  1137.     if (!anyResidueVisible) {
  1138.         objectStyle->style = eNotDisplayed;
  1139.         return true;
  1140.     }
  1142.     // set drawing style
  1143.     if (generalStyle.style == StyleSettings::eWithArrows) {
  1144.         objectStyle->style = eObjectWithArrow;
  1145.     } else if (generalStyle.style == StyleSettings::eWithoutArrows) {
  1146.         objectStyle->style = eObjectWithoutArrow;
  1147.     } else {
  1148.         WARNINGMSG("StyleManager::GetObjectStyle() - invalid 3d-object style");
  1149.         return false;
  1150.     }
  1152.     // set color
  1153.     switch (generalStyle.colorScheme) {
  1154.         case StyleSettings::eMolecule:
  1155.             objectStyle->color = GlobalColors()->Get(Colors::eCycle1, object3D.moleculeID - 1);
  1156.             break;
  1157.         case StyleSettings::eObject:
  1158.             objectStyle->color = GlobalColors()->Get(Colors::eCycle1, object->id - 1);
  1159.             break;
  1160.         case StyleSettings::eDomain:
  1161.             {
  1162.                 int domainID = molecule->residueDomains[object3D.fromResidueID - 1];
  1163.                 if (domainID == Molecule::NO_DOMAIN_SET)
  1164.                     objectStyle->color = GlobalColors()->Get(Colors::eNoDomain);
  1165.                 else
  1166.                     objectStyle->color = GlobalColors()->Get(Colors::eCycle1, domainID - 1);
  1167.             }
  1168.             break;
  1169.         case StyleSettings::eUserSelect:
  1170.             objectStyle->color = generalStyle.userColor;
  1171.             break;
  1172.         case StyleSettings::eSecondaryStructure:
  1173.             // set by caller
  1174.             break;
  1175.         default:
  1176.             ERRORMSG("StyleManager::GetObjectStyle() - inappropriate color scheme for 3d-object");
  1177.             return false;
  1178.     }
  1180.     return true;
  1181. }
  1183. bool StyleManager::GetHelixStyle(const StructureObject *object,
  1184.     const Helix3D& helix, HelixStyle *helixStyle) const
  1185. {
  1186.     // use style of first associated residue
  1187.     const StyleSettings&
  1188.         settings = GetStyleForResidue(object, helix.moleculeID, helix.fromResidueID);
  1190.     if (!settings.helixObjects.isOn) {
  1191.         helixStyle->style = eNotDisplayed;
  1192.         return true;
  1193.     }
  1195.     if (!GetObjectStyle(object, helix, settings.helixObjects, helixStyle))
  1196.         return false;
  1198.     // helix-specific settings
  1199.     helixStyle->radius = settings.helixRadius;
  1200.     if (settings.helixObjects.style == StyleSettings::eWithArrows) {
  1201.         helixStyle->arrowLength = 4.0;
  1202.         helixStyle->arrowBaseWidthProportion = 1.2;
  1203.         helixStyle->arrowTipWidthProportion = 0.4;
  1204.     }
  1205.     if (settings.helixObjects.colorScheme == StyleSettings::eSecondaryStructure)
  1206.         helixStyle->color = GlobalColors()->Get(Colors::eHelix);
  1208.     return true;
  1209. }
  1211. bool StyleManager::GetStrandStyle(const StructureObject *object,
  1212.     const Strand3D& strand, StrandStyle *strandStyle) const
  1213. {
  1214.     // use style of first associated residue
  1215.     const StyleSettings&
  1216.         settings = GetStyleForResidue(object, strand.moleculeID, strand.fromResidueID);
  1218.     if (!settings.strandObjects.isOn) {
  1219.         strandStyle->style = eNotDisplayed;
  1220.         return true;
  1221.     }
  1223.     if (!GetObjectStyle(object, strand, settings.strandObjects, strandStyle))
  1224.         return false;
  1226.     // strand-specific settings
  1227.     strandStyle->width = settings.strandWidth;
  1228.     strandStyle->thickness = settings.strandThickness;
  1229.     if (settings.strandObjects.style == StyleSettings::eWithArrows) {
  1230.         strandStyle->arrowLength = 2.8;
  1231.         strandStyle->arrowBaseWidthProportion = 1.6;
  1232.     }
  1233.     if (settings.strandObjects.colorScheme == StyleSettings::eSecondaryStructure)
  1234.         strandStyle->color = GlobalColors()->Get(Colors::eStrand);
  1236.     return true;
  1237. }
  1239. const StyleSettings& StyleManager::GetStyleForResidue(const StructureObject *object,
  1240.     int moleculeID, int residueID) const
  1241. {
  1242.     const Molecule *molecule = object->graph->molecules.find(moleculeID)->second;
  1244.     // find the highest priority (lowest index) annotation in the list of displayed annotations,
  1245.     // that also covers this residue
  1246.     const StyleSettings *style = &globalStyle;
  1248.     for (int d=0; d<userAnnotationsDisplayed.size(); ++d) {
  1249.         // check to see if the annotation covers this residue
  1250.         ResidueMap::const_iterator
  1251.             residues = userAnnotationsDisplayed[d]->residues.find(molecule->identifier);
  1252.         if (residues != userAnnotationsDisplayed[d]->residues.end() &&
  1253.             residues->second[residueID - 1] == true) {
  1254.             style = &(userStyles.find(userAnnotationsDisplayed[d]->styleID)->second);
  1255.             break;
  1256.         }
  1257.     }
  1259.     return *style;
  1260. }
  1262. const Vector& StyleManager::GetObjectColor(const Molecule *molecule) const
  1263. {
  1264.     static const Vector black(0,0,0);
  1265.     const StructureObject *object;
  1266.     if (!molecule || !molecule->GetParentOfType(&object)) return black;
  1267.     return GlobalColors()->Get(Colors::eCycle1, object->id - 1);
  1268. }
  1270. bool StyleManager::EditGlobalStyle(wxWindow *parent)
  1271. {
  1272.     StyleDialog dialog(parent, &globalStyle, structureSet);
  1273.     return (dialog.ShowModal() == wxOK);
  1274. }
  1276. CCn3d_style_dictionary * StyleManager::CreateASNStyleDictionary(void) const
  1277. {
  1278.     auto_ptr<CCn3d_style_dictionary> dictionary(new CCn3d_style_dictionary());
  1279.     if (!globalStyle.SaveSettingsToASN(&(dictionary->SetGlobal_style()))) return NULL;
  1281.     if (userStyles.size() > 0) {
  1283.         // create an ordered list of style id's
  1284.         typedef list < int > IntList;
  1285.         IntList keys;
  1286.         StyleMap::const_iterator s, se = userStyles.end();
  1287.         for (s=userStyles.begin(); s!=se; ++s) keys.push_back(s->first);
  1288.         keys.sort();
  1290.         // create a new style table entry for each user style
  1291.         IntList::const_iterator i, ie = keys.end();
  1292.         for (i=keys.begin(); i!=ie; ++i) {
  1293.             CRef < CCn3d_style_table_item > entry(new CCn3d_style_table_item());
  1294.             entry->SetId().Set(*i);
  1295.             if (!userStyles.find(*i)->second.SaveSettingsToASN(&(entry->SetStyle()))) return NULL;
  1296.             dictionary->SetStyle_table().push_back(entry);
  1297.         }
  1298.     }
  1300.     return dictionary.release();
  1301. }
  1303. bool StyleManager::LoadFromASNStyleDictionary(const CCn3d_style_dictionary& styleDictionary)
  1304. {
  1305.     if (!globalStyle.LoadSettingsFromASN(styleDictionary.GetGlobal_style())) return false;
  1307.     userStyles.clear();
  1308.     if (styleDictionary.IsSetStyle_table()) {
  1309.         CCn3d_style_dictionary::TStyle_table::const_iterator t, te = styleDictionary.GetStyle_table().end();
  1310.         for (t=styleDictionary.GetStyle_table().begin(); t!=te; ++t) {
  1311.             int id = (*t)->GetId().Get();
  1312.             if (userStyles.find(id) != userStyles.end()) {
  1313.                 ERRORMSG("repeated style table id in style dictionary");
  1314.                 return false;
  1315.             } else
  1316.                 if (!userStyles[id].LoadSettingsFromASN((*t)->GetStyle())) return false;
  1317.         }
  1318.     }
  1319.     return true;
  1320. }
  1322. bool StyleManager::EditUserAnnotations(wxWindow *parent)
  1323. {
  1324.     AnnotateDialog dialog(parent, this, structureSet);
  1325.     dialog.ShowModal();
  1326.     return false;
  1327. }
  1329. void StyleManager::GetUserAnnotations(AnnotationPtrList *annotationList)
  1330. {
  1331.     annotationList->resize(userAnnotations.size());
  1332.     AnnotationList::iterator a = userAnnotations.begin();
  1333.     for (int i=0; i<userAnnotations.size(); ++i)
  1334.         (*annotationList)[i] = &(*(a++));
  1335. }
  1337. bool StyleManager::AddUserStyle(int *id, StyleSettings **newStyle)
  1338. {
  1339.     // create a style with the lowest integer id (above zero) available
  1340.     static const int max = 10000;
  1341.     for (int i=1; i<max; ++i) {
  1342.         if (userStyles.find(i) == userStyles.end()) {
  1343.             *newStyle = &(userStyles[i]);
  1344.             *id = i;
  1345.             structureSet->SetDataChanged(StructureSet::eStyleData);
  1346.             return true;
  1347.         }
  1348.     }
  1349.     return false;
  1350. }
  1352. bool StyleManager::RemoveUserStyle(int id)
  1353. {
  1354.     StyleMap::iterator u = userStyles.find(id);
  1355.     if (u == userStyles.end()) return false;
  1356.     userStyles.erase(u);
  1357.     structureSet->SetDataChanged(StructureSet::eStyleData);
  1358.     return true;
  1359. }
  1361. StyleManager::UserAnnotation * StyleManager::AddUserAnnotation(void)
  1362. {
  1363.     userAnnotations.resize(userAnnotations.size() + 1);
  1364.     structureSet->SetDataChanged(StructureSet::eStyleData);
  1365.     return &(userAnnotations.back());
  1366. }
  1368. bool StyleManager::RemoveUserAnnotation(UserAnnotation *annotation)
  1369. {
  1370.     // remove annotation from displayed list
  1371.     AnnotationPtrList::iterator d, de = userAnnotationsDisplayed.end();
  1372.     for (d=userAnnotationsDisplayed.begin(); d!=de; ++d) {
  1373.         if (annotation == *d) {
  1374.             userAnnotationsDisplayed.erase(d);
  1375.             GlobalMessenger()->PostRedrawAllStructures();
  1376.             GlobalMessenger()->PostRedrawAllSequenceViewers();
  1377.             break;
  1378.         }
  1379.     }
  1381.     // remove annotation from available list
  1382.     AnnotationList::iterator u, ue = userAnnotations.end();
  1383.     int removedStyleID = -1;
  1384.     for (u=userAnnotations.begin(); u!=ue; ++u) {
  1385.         if (annotation == &(*u)) {
  1386.             removedStyleID = u->styleID;
  1387.             userAnnotations.erase(u);
  1388.             break;
  1389.         }
  1390.     }
  1391.     if (u == ue) return false;
  1393.     // also remove the style if it's not used by any other annotation
  1394.     for (u=userAnnotations.begin(); u!=ue; ++u)
  1395.         if (u->styleID == removedStyleID) break;
  1396.     if (u == ue) RemoveUserStyle(removedStyleID);
  1398.     structureSet->SetDataChanged(StructureSet::eStyleData);
  1399.     return true;
  1400. }
  1402. bool StyleManager::DisplayAnnotation(UserAnnotation *annotation, bool display)
  1403. {
  1404.     // first check to make sure this annotation is known
  1405.     AnnotationList::const_iterator a, ae = userAnnotations.end();
  1406.     for (a=userAnnotations.begin(); a!=ae; ++a)
  1407.         if (annotation == &(*a)) break;
  1408.     if (a == ae) return false;
  1410.     // then look for it in the list of displayed annotations
  1411.     AnnotationPtrList::iterator d, de = userAnnotationsDisplayed.end();
  1412.     for (d=userAnnotationsDisplayed.begin(); d!=de; ++d)
  1413.         if (annotation == *d) break;
  1415.     // finally, add or remove it from the displayed annotations
  1416.     bool changed = false;
  1417.     if (display && d == de) {
  1418.         userAnnotationsDisplayed.insert(userAnnotationsDisplayed.begin(), annotation);
  1419.         changed = true;
  1420.     } else if (!display && d != de) {
  1421.         userAnnotationsDisplayed.erase(d);
  1422.         changed = true;
  1423.     }
  1424.     if (changed) {  // need to redraw if displayed annotations list has changed
  1425.         GlobalMessenger()->PostRedrawAllStructures();
  1426.         GlobalMessenger()->PostRedrawAllSequenceViewers();
  1427.         structureSet->SetDataChanged(StructureSet::eStyleData);
  1428.     }
  1430.     return true;
  1431. }
  1433. bool StyleManager::ReprioritizeDisplayOrder(UserAnnotation *annotation, bool moveUp)
  1434. {
  1435.     // look for the annotation in the list of displayed annotations
  1436. int d;
  1437.     for (d=0; d<userAnnotationsDisplayed.size(); ++d)
  1438.         if (annotation == userAnnotationsDisplayed[d]) break;
  1439.     if (d == userAnnotationsDisplayed.size()) return false;
  1441.     bool changed = false;
  1442.     if (moveUp && d > 0) {
  1443.         userAnnotationsDisplayed[d] = userAnnotationsDisplayed[d - 1];
  1444.         userAnnotationsDisplayed[d - 1] = annotation;
  1445.         changed = true;
  1446.     } else if (!moveUp && d < userAnnotationsDisplayed.size() - 1) {
  1447.         userAnnotationsDisplayed[d] = userAnnotationsDisplayed[d + 1];
  1448.         userAnnotationsDisplayed[d + 1] = annotation;
  1449.         changed = true;
  1450.     }
  1451.     if (changed) {  // need to redraw if displayed annotations list has changed
  1452.         GlobalMessenger()->PostRedrawAllStructures();
  1453.         GlobalMessenger()->PostRedrawAllSequenceViewers();
  1454.         structureSet->SetDataChanged(StructureSet::eStyleData);
  1455.     }
  1457.     return true;
  1458. }
  1460. static bool CreateObjectLocation(
  1461.     CCn3d_user_annotation::TResidues *residuesASN,
  1462.     const StyleManager::ResidueMap& residueMap)
  1463. {
  1464.     residuesASN->clear();
  1466.     StyleManager::ResidueMap::const_iterator r, re = residueMap.end();
  1467.     for (r=residueMap.begin(); r!=re; ++r) {
  1469.         // find an existing object location that matches this MMDB ID
  1470.         CCn3d_user_annotation::TResidues::iterator l, le = residuesASN->end();
  1471.         for (l=residuesASN->begin(); l!=le; ++l)
  1472.             if ((*l)->GetStructure_id().GetMmdb_id().Get() == r->first->mmdbID) break;
  1474.         // if necessary, create new object location, with Biostruc-id from MMDB ID
  1475.         if (l == le) {
  1476.             CRef < CCn3d_object_location > loc(new CCn3d_object_location());
  1477.             if (r->first->mmdbID != MoleculeIdentifier::VALUE_NOT_SET) {
  1478.                 CMmdb_id *mmdbID = new CMmdb_id();
  1479.                 mmdbID->Set(r->first->mmdbID);
  1480.                 loc->SetStructure_id().SetMmdb_id(*mmdbID);
  1481.             } else {
  1482.                 ERRORMSG("CreateObjectLocation() - MoleculeIdentifier must (currently) have MMDB ID");
  1483.                 return false;
  1484.             }
  1485.             residuesASN->push_back(loc);
  1486.             l = residuesASN->end();
  1487.             --l;    // set iterator to the new object location
  1488.         }
  1490.         // set molecule location
  1491.         CRef < CCn3d_molecule_location > molecule(new CCn3d_molecule_location());
  1492.         molecule->SetMolecule_id().Set(r->first->moleculeID);
  1493.         (*l)->SetResidues().push_back(molecule);
  1495.         // check if covers whole molecule; if so, leave 'residues' field of Cn3d_molecule_location blank
  1496.         int i;
  1497.         for (i=0; i<r->second.size(); ++i)
  1498.             if (!r->second[i]) break;
  1500.         // else break list down into individual contiguous residue ranges
  1501.         if (i != r->second.size()) {
  1502.             int first = 0, last = 0;
  1503.             while (first < r->second.size()) {
  1504.                 // find first included residue
  1505.                 while (first < r->second.size() && !r->second[first]) ++first;
  1506.                 if (first >= r->second.size()) break;
  1507.                 // find last in contiguous stretch of included residues
  1508.                 last = first;
  1509.                 while (last + 1 < r->second.size() && r->second[last + 1]) ++last;
  1510.                 CRef < CCn3d_residue_range > range(new CCn3d_residue_range());
  1511.                 range->SetFrom().Set(first + 1);    // assume moleculeID = index + 1
  1512.                 range->SetTo().Set(last + 1);
  1513.                 molecule->SetResidues().push_back(range);
  1514.                 first = last + 2;
  1515.             }
  1516.             if (molecule->GetResidues().size() == 0) {
  1517.                 ERRORMSG("CreateObjectLocation() - no residue ranges found");
  1518.                 return false;
  1519.             }
  1520.         }
  1521.     }
  1523.     return true;
  1524. }
  1526. bool StyleManager::SaveToASNUserAnnotations(ncbi::objects::CCn3d_user_annotations *annotations) const
  1527. {
  1528.     if (!annotations) return false;
  1529.     annotations->ResetAnnotations();
  1530.     if (userAnnotations.size() == 0) return true;
  1532.     AnnotationList::const_iterator a, ae = userAnnotations.end();
  1533.     AnnotationPtrList::const_iterator d, de = userAnnotationsDisplayed.end();
  1534.     for (a=userAnnotations.begin(); a!=ae; ++a) {
  1536.         // fill out individual annotations
  1537.         CRef < CCn3d_user_annotation > annotation(new CCn3d_user_annotation());
  1538.         annotation->SetName(a->name);
  1539.         annotation->SetDescription(a->description);
  1540.         annotation->SetStyle_id().Set(a->styleID);
  1542.         // is this annotation on? check displayed annotations list
  1543.         for (d=userAnnotationsDisplayed.begin(); d!=de; ++d)
  1544.             if (*d == &(*a)) break;
  1545.         annotation->SetIs_on(d != de);
  1547.         // fill out residues list
  1548.         if (!CreateObjectLocation(&(annotation->SetResidues()), a->residues)) {
  1549.             ERRORMSG("StyleManager::CreateASNUserAnnotations() - error creating object location");
  1550.             return false;
  1551.         }
  1553.         annotations->SetAnnotations().push_back(annotation);
  1554.     }
  1556.     return true;
  1557. }
  1559. static bool ExtractObjectLocation(
  1560.     StyleManager::ResidueMap *residueMap,
  1561.     const CCn3d_user_annotation::TResidues& residuesASN)
  1562. {
  1563.     CCn3d_user_annotation::TResidues::const_iterator o, oe = residuesASN.end();
  1564.     for (o=residuesASN.begin(); o!=oe; ++o) {
  1565.         int mmdbID;
  1566.         if ((*o)->GetStructure_id().IsMmdb_id()) {
  1567.             mmdbID = (*o)->GetStructure_id().GetMmdb_id().Get();
  1568.         } else {
  1569.             ERRORMSG("ExtractObjectLocation() - can't handle non-MMDB identifiers (yet)");
  1570.             return false;
  1571.         }
  1573.         // extract molecules
  1574.         CCn3d_object_location::TResidues::const_iterator m, me = (*o)->GetResidues().end();
  1575.         for (m=(*o)->GetResidues().begin(); m!=me; ++m) {
  1576.             int moleculeID = (*m)->GetMolecule_id().Get();
  1578.             // get identifier for this molecule
  1579.             const MoleculeIdentifier *identifier = MoleculeIdentifier::FindIdentifier(mmdbID, moleculeID);
  1580.             if (!identifier) {
  1581.                 WARNINGMSG("ExtractObjectLocation() - can't find identifier for molecule location");
  1582.                 WARNINGMSG("structure MMDB ID " << mmdbID << " not loaded?");
  1583.                 continue;
  1584.             }
  1586.             // set residue ranges
  1587.             int i;
  1588.             vector < bool >& residueFlags = (*residueMap)[identifier];
  1589.             if (residueFlags.size() == 0)
  1590.                 residueFlags.resize(identifier->nResidues, false);
  1592.             if ((*m)->IsSetResidues()) {
  1593.                 // parse individual ranges
  1594.                 CCn3d_molecule_location::TResidues::const_iterator r, re = (*m)->GetResidues().end();
  1595.                 for (r=(*m)->GetResidues().begin(); r!=re; ++r) {
  1596.                     for (i=(*r)->GetFrom().Get(); i<=(*r)->GetTo().Get(); ++i) {
  1597.                         if (i > 0 && i <= residueFlags.size()) {
  1598.                             residueFlags[i - 1] = true;     // assume index = residue id - 1
  1599.                         } else {
  1600.                             ERRORMSG("ExtractObjectLocation() - residue from/to out of range");
  1601.                             return false;
  1602.                         }
  1603.                     }
  1604.                 }
  1605.             } else {
  1606.                 // assume all residues are included if none specified
  1607.                 for (i=0; i<residueFlags.size(); ++i) residueFlags[i] = true;
  1608.             }
  1609.         }
  1610.     }
  1611. return true;
  1612. }
  1614. bool StyleManager::LoadFromASNUserAnnotations(const ncbi::objects::CCn3d_user_annotations& annotations)
  1615. {
  1616.     if (!annotations.IsSetAnnotations()) return true;
  1618.     CCn3d_user_annotations::TAnnotations::const_iterator a, ae = annotations.GetAnnotations().end();
  1619.     for (a=annotations.GetAnnotations().begin(); a!=ae; ++a) {
  1620.         UserAnnotation *userAnnot = AddUserAnnotation();
  1622.         // fill out annotation parameters
  1623.         userAnnot->name = (*a)->GetName();
  1624.         if ((*a)->IsSetDescription())
  1625.             userAnnot->description = (*a)->GetDescription();
  1626.         userAnnot->styleID = (*a)->GetStyle_id().Get();
  1627.         DisplayAnnotation(userAnnot, (*a)->GetIs_on());
  1629.         // extract object locations
  1630.         if (!ExtractObjectLocation(&(userAnnot->residues), (*a)->GetResidues()))
  1631.             return false;
  1632.     }
  1634.     return true;
  1635. }
  1637. void StyleManager::SetGlobalColorScheme(StyleSettings::ePredefinedColorScheme scheme)
  1638. {
  1639.     globalStyle.SetColorScheme(scheme);
  1640. //    structureSet->SetDataChanged(StructureSet::eStyleData);
  1641. }
  1643. void StyleManager::SetGlobalRenderingStyle(StyleSettings::ePredefinedRenderingStyle style)
  1644. {
  1645.     globalStyle.SetRenderingStyle(style);
  1646. //    structureSet->SetDataChanged(StructureSet::eStyleData);
  1647. }
  1649. bool StyleManager::SetGlobalStyle(const ncbi::objects::CCn3d_style_settings& styleASN)
  1650. {
  1651.     bool okay = globalStyle.LoadSettingsFromASN(styleASN);
  1652.     if (okay) {
  1653.         CheckGlobalStyleSettings();
  1654. //        structureSet->SetDataChanged(StructureSet::eStyleData);
  1655.         GlobalMessenger()->PostRedrawAllStructures();
  1656.         GlobalMessenger()->PostRedrawAllSequenceViewers();
  1657.     }
  1658.     return okay;
  1659. }
  1661. END_SCOPE(Cn3D)
  1664. /*
  1665. * ---------------------------------------------------------------------------
  1666. * $Log: style_manager.cpp,v $
  1667. * Revision 1000.2  2004/06/01 18:29:44  gouriano
  1668. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.84
  1669. *
  1670. * Revision 1.84  2004/05/28 19:10:28  thiessen
  1671. * fix typos
  1672. *
  1673. * Revision 1.83  2004/05/27 13:40:50  thiessen
  1674. * more cleanup ; use residue rather than global style for disulfides
  1675. *
  1676. * Revision 1.82  2004/05/26 22:18:42  thiessen
  1677. * fix display of single residues with trace backbone
  1678. *
  1679. * Revision 1.81  2004/05/21 21:41:40  gorelenk
  1680. * Added PCH ncbi_pch.hpp
  1681. *
  1682. * Revision 1.80  2004/03/15 18:11:01  thiessen
  1683. * prefer prefix vs. postfix ++/-- operators
  1684. *
  1685. * Revision 1.79  2004/02/19 17:05:19  thiessen
  1686. * remove cn3d/ from include paths; add pragma to disable annoying msvc warning
  1687. *
  1688. * Revision 1.78  2004/01/19 17:27:14  thiessen
  1689. * add Proline CD-N bond for sidechain display
  1690. *
  1691. * Revision 1.77  2004/01/19 16:17:37  thiessen
  1692. * fix worm display problem when coords of prev/next alpha are missing
  1693. *
  1694. * Revision 1.76  2003/07/22 18:54:42  thiessen
  1695. * fix object access bug
  1696. *
  1697. * Revision 1.75  2003/06/21 08:18:58  thiessen
  1698. * show all atoms with coordinates, even if not in all coord sets
  1699. *
  1700. * Revision 1.74  2003/03/13 14:26:18  thiessen
  1701. * add file_messaging module; split cn3d_main_wxwin into cn3d_app, cn3d_glcanvas, structure_window, cn3d_tools
  1702. *
  1703. * Revision 1.73  2003/02/06 16:39:53  thiessen
  1704. * add block row fit coloring
  1705. *
  1706. * Revision 1.72  2003/02/03 19:20:08  thiessen
  1707. * format changes: move CVS Log to bottom of file, remove std:: from .cpp files, and use new diagnostic macros
  1708. *
  1709. * Revision 1.71  2003/01/30 14:00:23  thiessen
  1710. * add Block Z Fit coloring
  1711. *
  1712. * Revision 1.70  2003/01/28 21:07:56  thiessen
  1713. * add block fit coloring algorithm; tweak row dragging; fix style bug
  1714. *
  1715. * Revision 1.69  2002/11/18 20:49:11  thiessen
  1716. * move unaligned/no-coord colors into Colors class
  1717. *
  1718. * Revision 1.68  2002/11/10 01:26:16  thiessen
  1719. * tweak loading of style annotation residue ranges
  1720. *
  1721. * Revision 1.67  2002/08/15 22:13:18  thiessen
  1722. * update for wx2.3.2+ only; add structure pick dialog; fix MultitextDialog bug
  1723. *
  1724. * Revision 1.66  2002/04/27 16:32:15  thiessen
  1725. * fix small leaks/bugs found by BoundsChecker
  1726. *
  1727. * Revision 1.65  2002/04/12 01:54:43  thiessen
  1728. * tweaks to style stuff
  1729. *
  1730. * Revision 1.64  2002/04/11 17:50:28  thiessen
  1731. * fix domain coloring bug
  1732. *
  1733. * Revision 1.63  2002/04/11 16:39:56  thiessen
  1734. * fix style manager bug
  1735. *
  1736. * Revision 1.62  2002/02/22 20:46:57  thiessen
  1737. * more rigorous fix for same
  1738. *
  1739. * Revision 1.61  2002/02/22 20:17:24  thiessen
  1740. * fix feature range problems
  1741. *
  1742. * Revision 1.60  2002/01/19 02:34:50  thiessen
  1743. * fixes for changes in asn serialization API
  1744. *
  1745. * Revision 1.59  2001/12/12 14:04:15  thiessen
  1746. * add missing object headers after object loader change
  1747. *
  1748. * Revision 1.58  2001/12/06 23:13:46  thiessen
  1749. * finish import/align new sequences into single-structure data; many small tweaks
  1750. *
  1751. * Revision 1.57  2001/11/27 16:26:10  thiessen
  1752. * major update to data management system
  1753. *
  1754. * Revision 1.56  2001/10/24 17:13:46  thiessen
  1755. * skip style annotation if structure not loaded
  1756. *
  1757. * Revision 1.55  2001/10/17 17:46:22  thiessen
  1758. * save camera setup and rotation center in files
  1759. *
  1760. * Revision 1.54  2001/09/18 03:10:46  thiessen
  1761. * add preliminary sequence import pipeline
  1762. *
  1763. * Revision 1.53  2001/09/04 14:40:19  thiessen
  1764. * add rainbow and charge coloring
  1765. *
  1766. * Revision 1.52  2001/08/24 00:41:36  thiessen
  1767. * tweak conservation colors and opengl font handling
  1768. *
  1769. * Revision 1.51  2001/08/21 01:10:46  thiessen
  1770. * add labeling
  1771. *
  1772. * Revision 1.50  2001/08/13 22:30:59  thiessen
  1773. * add structure window mouse drag/zoom; add highlight option to render settings
  1774. *
  1775. * Revision 1.49  2001/08/10 15:01:58  thiessen
  1776. * fill out shortcuts; add update show/hide menu
  1777. *
  1778. * Revision 1.48  2001/08/09 19:07:14  thiessen
  1779. * add temperature and hydrophobicity coloring
  1780. *
  1781. * Revision 1.47  2001/08/03 13:41:33  thiessen
  1782. * add registry and style favorites
  1783. *
  1784. * Revision 1.46  2001/07/12 17:35:15  thiessen
  1785. * change domain mapping ; add preliminary cdd annotation GUI
  1786. *
  1787. * Revision 1.45  2001/07/04 19:39:17  thiessen
  1788. * finish user annotation system
  1789. *
  1790. * Revision 1.44  2001/06/29 18:54:46  thiessen
  1791. * fix mysterious CRef error in MSVC MT compile mode
  1792. *
  1793. * Revision 1.43  2001/06/29 18:13:58  thiessen
  1794. * initial (incomplete) user annotation system
  1795. *
  1796. * Revision 1.42  2001/06/21 02:02:34  thiessen
  1797. * major update to molecule identification and highlighting ; add toggle highlight (via alt)
  1798. *
  1799. * Revision 1.41  2001/06/15 14:06:40  thiessen
  1800. * save/load asn styles now complete
  1801. *
  1802. * Revision 1.40  2001/06/15 13:00:05  thiessen
  1803. * fix enumerated type casts fo unix compilers
  1804. *
  1805. * Revision 1.39  2001/06/15 02:23:00  thiessen
  1806. * fill code for settings<->asn
  1807. *
  1808. * Revision 1.38  2001/06/14 17:45:10  thiessen
  1809. * progress in styles<->asn ; add structure limits
  1810. *
  1811. * Revision 1.37  2001/06/14 00:34:02  thiessen
  1812. * asn additions
  1813. *
  1814. * Revision 1.36  2001/06/08 14:47:06  thiessen
  1815. * fully functional (modal) render settings panel
  1816. *
  1817. * Revision 1.35  2001/06/07 19:05:38  thiessen
  1818. * functional (although incomplete) render settings panel ; highlight title - not sequence - upon mouse click
  1819. *
  1820. * Revision 1.34  2001/06/01 13:01:00  thiessen
  1821. * fix wx-string problem again...
  1822. *
  1823. * Revision 1.33  2001/05/31 18:47:10  thiessen
  1824. * add preliminary style dialog; remove LIST_TYPE; add thread single and delete all; misc tweaks
  1825. *
  1826. * Revision 1.32  2001/05/15 23:48:38  thiessen
  1827. * minor adjustments to compile under Solaris/wxGTK
  1828. *
  1829. * Revision 1.31  2001/03/29 15:49:21  thiessen
  1830. * use disulfide color only for virtual disulfides
  1831. *
  1832. * Revision 1.30  2001/03/29 15:32:42  thiessen
  1833. * change disulfide, connection colors to not-yellow
  1834. *
  1835. * Revision 1.29  2001/03/23 23:31:56  thiessen
  1836. * keep atom info around even if coords not all present; mainly for disulfide parsing in virtual models
  1837. *
  1838. * Revision 1.28  2001/03/23 15:14:07  thiessen
  1839. * load sidechains in CDD's
  1840. *
  1841. * Revision 1.27  2001/03/23 04:18:53  thiessen
  1842. * parse and display disulfides
  1843. *
  1844. * Revision 1.26  2001/03/22 00:33:17  thiessen
  1845. * initial threading working (PSSM only); free color storage in undo stack
  1846. *
  1847. * Revision 1.25  2001/03/09 15:49:05  thiessen
  1848. * major changes to add initial update viewer
  1849. *
  1850. * Revision 1.24  2001/02/13 20:33:50  thiessen
  1851. * add information content coloring
  1852. *
  1853. * Revision 1.23  2001/02/08 23:01:51  thiessen
  1854. * hook up C-toolkit stuff for threading; working PSSM calculation
  1855. *
  1856. * Revision 1.22  2001/01/30 20:51:20  thiessen
  1857. * minor fixes
  1858. *
  1859. * Revision 1.21  2000/12/15 15:51:48  thiessen
  1860. * show/hide system installed
  1861. *
  1862. * Revision 1.20  2000/12/01 19:35:57  thiessen
  1863. * better domain assignment; basic show/hide mechanism
  1864. *
  1865. * Revision 1.19  2000/11/30 15:49:40  thiessen
  1866. * add show/hide rows; unpack sec. struc. and domain features
  1867. *
  1868. * Revision 1.18  2000/10/16 14:25:48  thiessen
  1869. * working alignment fit coloring
  1870. *
  1871. * Revision 1.17  2000/10/05 18:34:43  thiessen
  1872. * first working editing operation
  1873. *
  1874. * Revision 1.16  2000/09/20 22:22:30  thiessen
  1875. * working conservation coloring; split and center unaligned justification
  1876. *
  1877. * Revision 1.15  2000/09/15 19:24:22  thiessen
  1878. * allow repeated structures w/o different local id
  1879. *
  1880. * Revision 1.14  2000/09/11 22:57:34  thiessen
  1881. * working highlighting
  1882. *
  1883. * Revision 1.13  2000/09/11 14:06:30  thiessen
  1884. * working alignment coloring
  1885. *
  1886. * Revision 1.12  2000/09/08 20:16:55  thiessen
  1887. * working dynamic alignment views
  1888. *
  1889. * Revision 1.11  2000/08/24 23:40:19  thiessen
  1890. * add 'atomic ion' labels
  1891. *
  1892. * Revision 1.10  2000/08/24 18:43:52  thiessen
  1893. * tweaks for transparent sphere display
  1894. *
  1895. * Revision 1.9  2000/08/21 19:31:48  thiessen
  1896. * add style consistency checking
  1897. *
  1898. * Revision 1.8  2000/08/21 17:22:38  thiessen
  1899. * add primitive highlighting for testing
  1900. *
  1901. * Revision 1.7  2000/08/18 18:57:40  thiessen
  1902. * added transparent spheres
  1903. *
  1904. * Revision 1.6  2000/08/17 18:33:12  thiessen
  1905. * minor fixes to StyleManager
  1906. *
  1907. * Revision 1.5  2000/08/17 14:24:07  thiessen
  1908. * added working StyleManager
  1909. *
  1910. * Revision 1.4  2000/08/13 02:43:02  thiessen
  1911. * added helix and strand objects
  1912. *
  1913. * Revision 1.3  2000/08/11 12:58:31  thiessen
  1914. * added worm; get 3d-object coords from asn1
  1915. *
  1916. * Revision 1.2  2000/08/04 22:49:04  thiessen
  1917. * add backbone atom classification and selection feedback mechanism
  1918. *
  1919. * Revision 1.1  2000/08/03 15:13:59  thiessen
  1920. * add skeleton of style and show/hide managers
  1921. *
  1922. */