Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
StructureManager	58	170	69	0.00%	Show methods
StructureManager.ModelType	93	0	0	-1.0 -	Show methods

Class StructureManager

Class StructureManager	Line # 58	Total Statements 170	Complexity 69	TOTAL Coverage 0.00%
StructureManager(boolean)   StructureManager(boolean)	119119	4.04	1.01	0.0 0.00%
getChimeraManager() : ChimeraManager   getChimeraManager() : ChimeraManager	128128	1.01	1.01	0.0 0.00%
openStructures(Collection<List<String>>,ModelType) : boolean   openStructures(Collection<List<String>>,ModelType) : boolean	133133	15.015	5.05	0.0 0.00%
closeStructures(Set<String>) : void   closeStructures(Set<String>) : void	273273	4.04	1.01	0.0 0.00%
saveChimeraImage() : File   saveChimeraImage() : File	291291	8.08	2.02	0.0 0.00%
closeModel(ChimeraModel) : void   closeModel(ChimeraModel) : void	310310	1.01	1.01	0.0 0.00%
exitChimera() : void   exitChimera() : void	387387	1.01	1.01	0.0 0.00%
clearOnChimeraExit() : void   clearOnChimeraExit() : void	401401	1.01	1.01	0.0 0.00%
updateCytoscapeSelection() : void   updateCytoscapeSelection() : void	428428	2.02	1.01	0.0 0.00%
cytoscapeSelectionChanged(Map<Long, Boolean>) : void   cytoscapeSelectionChanged(Map<Long, Boolean>) : void	499499	2.02	1.01	0.0 0.00%
updateChimeraSelection() : void   updateChimeraSelection() : void	541541	9.09	4.04	0.0 0.00%
chimeraSelectionChanged() : void   chimeraSelectionChanged() : void	570570	24.024	7.07	0.0 0.00%
selectFunctResidues(Collection<ChimeraModel>) : void   selectFunctResidues(Collection<ChimeraModel>) : void	639639	7.07	1.01	0.0 0.00%
getChimSelectionList() : List<ChimeraStructuralObject>   getChimSelectionList() : List<ChimeraStructuralObject>	672672	1.01	1.01	0.0 0.00%
getChimSelectionCount() : int   getChimSelectionCount() : int	677677	1.01	1.01	0.0 0.00%
addChimSelection(ChimeraStructuralObject) : void   addChimSelection(ChimeraStructuralObject) : void	689689	3.03	3.03	0.0 0.00%
removeChimSelection(ChimeraStructuralObject) : void   removeChimSelection(ChimeraStructuralObject) : void	706706	3.03	3.03	0.0 0.00%
clearSelectionList() : void   clearSelectionList() : void	719719	4.04	2.02	0.0 0.00%
updateModels() : void   updateModels() : void	740740	16.016	4.04	0.0 0.00%
launchModelNavigatorDialog() : void   launchModelNavigatorDialog() : void	816816	0.00	1.01	-1.0 -1.0 -
isMNDialogOpen() : boolean   isMNDialogOpen() : boolean	831831	1.01	1.01	0.0 0.00%
modelChanged() : void   modelChanged() : void	842842	0.00	1.01	-1.0 -1.0 -
selectionChanged() : void   selectionChanged() : void	852852	0.00	1.01	-1.0 -1.0 -
launchAlignDialog(boolean) : void   launchAlignDialog(boolean) : void	861861	6.06	2.02	0.0 0.00%
getAllStructureKeys() : List<String>   getAllStructureKeys() : List<String>	897897	1.01	1.01	0.0 0.00%
getAllChemStructKeys() : List<String>   getAllChemStructKeys() : List<String>	902902	1.01	1.01	0.0 0.00%
getAllResidueKeys() : List<String>   getAllResidueKeys() : List<String>	907907	1.01	1.01	0.0 0.00%
getAllChimeraResidueAttributes() : List<String>   getAllChimeraResidueAttributes() : List<String>	912912	3.03	1.01	0.0 0.00%
getChimeraPaths(boolean) : List<String>   getChimeraPaths(boolean) : List<String>	923923	46.046	14.014	0.0 0.00%
setChimeraPathProperty(String) : void   setChimeraPathProperty(String) : void	10651065	0.00	1.01	-1.0 -1.0 -
setStructureSettings(StructureSettings) : void   setStructureSettings(StructureSettings) : void	10721072	1.01	1.01	0.0 0.00%
getCurrentChimeraPath(Object) : String   getCurrentChimeraPath(Object) : String	10771077	3.03	2.02	0.0 0.00%

 

Class StructureManager.ModelType

Class StructureManager.ModelType	Line # 93	Total Statements 0	Complexity 0	TOTAL Coverage -1.0 -

 

Contributing tests

Source view

1		/* vim: set ts=2: */
2		/**
3		* Copyright (c) 2006 The Regents of the University of California.
4		* All rights reserved.
5		*
6		* Redistribution and use in source and binary forms, with or without
7		* modification, are permitted provided that the following conditions
8		* are met:
9		* 1. Redistributions of source code must retain the above copyright
10		* notice, this list of conditions, and the following disclaimer.
11		* 2. Redistributions in binary form must reproduce the above
12		* copyright notice, this list of conditions, and the following
13		* disclaimer in the documentation and/or other materials provided
14		* with the distribution.
15		* 3. Redistributions must acknowledge that this software was
16		* originally developed by the UCSF Computer Graphics Laboratory
17		* under support by the NIH National Center for Research Resources,
18		* grant P41-RR01081.
19		*
20		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
21		* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23		* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS BE LIABLE
24		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25		* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
26		* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27		* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28		* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29		* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30		* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31		*
32		*/
33		package ext.edu.ucsf.rbvi.strucviz2;
34
35		import java.io.File;
36		import java.io.IOException;
37		import java.util.ArrayList;
38		import java.util.Arrays;
39		import java.util.Collection;
40		import java.util.HashMap;
41		import java.util.List;
42		import java.util.Locale;
43		import java.util.Map;
44		import java.util.Properties;
45		import java.util.Set;
46
47		import org.slf4j.Logger;
48		import org.slf4j.LoggerFactory;
49
50		import jalview.bin.Cache;
51		import jalview.gui.Preferences;
52
53		/**
54		* This object maintains the relationship between Chimera objects and Cytoscape
55		* objects.
56		*/
57
		0% Uncovered Elements: 264 (264) Complexity: 69 Complexity Density: 0.41
58		public class StructureManager
59		{
60		/*
61		* Version numbers to build Windows installation paths for
62		* Chimera https://www.cgl.ucsf.edu/chimera/download.html
63		* ChimeraX http://www.rbvi.ucsf.edu/chimerax/download.html#release
64		* https://www.rbvi.ucsf.edu/trac/ChimeraX/wiki/ChangeLog
65		* These are a fallback for Jalview users who don't save path in Preferences;
66		* these will need to be updated as new versions are released;
67		* deliberately not 'final' (so modifiable using Groovy).
68		*
69		* May 2020: 1.14 is Chimera latest, anticipating a few more...
70		* 0.93 is ChimeraX latest, 1.0 expected soon
71		*/
72		private static String[] CHIMERA_VERSIONS = new String[] { "1.18",
73		"1.17.4", "1.17.3", "1.17.2", "1.17.1", "1.17", "1.16.2", "1.16.1",
74		"1.16", "1.15.2", "1.15.1", "1.15", "1.14.2", "1.14.1", "1.14",
75		"1.13.1", "1.13", "1.12.2", "1.12.1", "1.12", "1.11.2", "1.11.2",
76		"1.11.1", "1.11" };
77
78		// Missing 1.1 as this has known bug see JAL-2422
79		private static String[] CHIMERAX_VERSIONS = new String[] { "1.7", "1.6.1",
80		"1.6", "1.5", "1.4", "1.3", "1.2.5", "1.0", "0.93", "0.92", "0.91",
81		"0.9" };
82
83		static final String[] defaultStructureKeys = { "Structure", "pdb",
84		"pdbFileName", "PDB ID", "structure", "biopax.xref.PDB", "pdb_ids",
85		"ModelName", "ModelNumber" };
86
87		static final String[] defaultChemStructKeys = { "Smiles", "smiles",
88		"SMILES" };
89
90		static final String[] defaultResidueKeys = { "FunctionalResidues",
91		"ResidueList", "Residues" };
92
		- Uncovered Elements: 0 (0) Complexity: 0 Complexity Density: -
93		public enum ModelType
94		{
95		PDB_MODEL, MODBASE_MODEL, SMILES
96		};
97
98		public static Properties pathProps;
99
100		private String chimeraCommandAttr = "ChimeraCommand";
101
102		private String chimeraOutputTable = "ChimeraTable";
103
104		private String chimeraOutputAttr = "ChimeraOutput";
105
106		private boolean haveGUI = true;
107
108		private ChimeraManager chimeraManager = null;
109
110		static private List<ChimeraStructuralObject> chimSelectionList;
111
112		private boolean ignoreCySelection = false;
113
114		private File configurationDirectory = null;
115
116		private static Logger logger = LoggerFactory
117		.getLogger(ext.edu.ucsf.rbvi.strucviz2.StructureManager.class);
118
		0% Uncovered Elements: 4 (4) Complexity: 1 Complexity Density: 0.25
119	0	public StructureManager(boolean haveGUI)...
120		{
121	0	this.haveGUI = haveGUI;
122		// Create the Chimera interface
123	0	chimeraManager = new ChimeraManager(this);
124	0	chimSelectionList = new ArrayList<>();
125	0	pathProps = new Properties();
126		}
127
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
128	0	public ChimeraManager getChimeraManager()...
129		{
130	0	return chimeraManager;
131		}
132
		0% Uncovered Elements: 23 (23) Complexity: 5 Complexity Density: 0.33
133	0	public boolean openStructures(Collection<List<String>> chimObjNames,...
134		ModelType type)
135		{
136		// new models
137	0	Map<String, List<ChimeraModel>> newModels = new HashMap<>();
138	0	if (chimObjNames.size() > 0)
139		{
140	0	List<String> names = chimObjNames.iterator().next();
141	0	if (names == null)
142		{
143	0	return false;
144		}
145	0	for (String chimObjName : names)
146		{
147		// get or open the corresponding models if they already exist
148	0	List<ChimeraModel> currentModels = chimeraManager
149		.getChimeraModels(chimObjName, type);
150	0	if (currentModels.size() == 0)
151		{
152		// open and return models
153	0	currentModels = chimeraManager.openModel(chimObjName, type);
154	0	if (currentModels == null)
155		{
156		// failed to open model, continue with next
157	0	continue;
158		}
159		// if (type == ModelType.SMILES) {
160		// newModels.put("smiles:" + chimObjName, currentModels);
161		// } else {
162	0	newModels.put(chimObjName, currentModels);
163		// }
164		// for each model
165	0	for (ChimeraModel currentModel : currentModels)
166		{
167		// if not RIN then associate new model with the Cytoscape
168		// node
169		// if (!currentChimMap.containsKey(currentModel)) {
170		// currentChimMap.put(currentModel, new HashSet<CyIdentifiable>());
171		// }
172		}
173		}
174		}
175		}
176		else
177		{
178	0	return false;
179		}
180		// update dialog
181		// if (mnDialog != null) {
182		// mnDialog.modelChanged();
183		// }
184		// aTask.associate();
185	0	return true;
186
187		}
188
189		// TODO: [Release] Handle case where one network is associated with two models
190		// that are opened
191		// at the same time
192		/*
193		* public boolean openStructures(CyNetwork network, Map<CyIdentifiable,
194		* List<String>> chimObjNames, ModelType type) { if
195		* (!chimeraManager.isChimeraLaunched() &&
196		* !chimeraManager.launchChimera(getChimeraPaths(network))) {
197		* logger.error("Chimera could not be launched."); return false; } else if
198		* (chimObjNames.size() == 0) { return false; } else if (network == null) {
199		* return openStructures(chimObjNames.values(), type); }
200		*
201		* // potential rins Set<CyNetwork> potentialRINs = new HashSet<CyNetwork>();
202		* // attributes List<String> attrsFound = new ArrayList<String>();
203		* attrsFound.
204		* addAll(CytoUtils.getMatchingAttributes(network.getDefaultNodeTable(),
205		* getCurrentStructureKeys(network)));
206		* attrsFound.addAll(CytoUtils.getMatchingAttributes
207		* (network.getDefaultNodeTable(), getCurrentChemStructKeys(network))); // new
208		* models Map<String, List<ChimeraModel>> newModels = new HashMap<String,
209		* List<ChimeraModel>>(); // for each node that has an associated structure
210		* for (CyIdentifiable cyObj : chimObjNames.keySet()) { // get possible res
211		* specs List<String> specsFound = null; if (cyObj instanceof CyNode) {
212		* specsFound = ChimUtils.getResidueKeys(network.getDefaultNodeTable(), cyObj,
213		* attrsFound); } // save node to track its selection and mapping to chimera
214		* objects if (!currentCyMap.containsKey(cyObj)) { currentCyMap.put(cyObj, new
215		* HashSet<ChimeraStructuralObject>()); } // save node to network mapping to
216		* keep track of selection events if (!networkMap.containsKey(cyObj)) {
217		* networkMap.put(cyObj, new HashSet<CyNetwork>()); }
218		* networkMap.get(cyObj).add(network); // for each structure that has to be
219		* opened for (String chimObjName : chimObjNames.get(cyObj)) { // get or open
220		* the corresponding models if they already exist List<ChimeraModel>
221		* currentModels = chimeraManager.getChimeraModels(chimObjName, type); if
222		* (currentModels.size() == 0) { // open and return models currentModels =
223		* chimeraManager.openModel(chimObjName, type); if (currentModels == null) {
224		* // failed to open model, continue with next continue; } // if (type ==
225		* ModelType.SMILES) { // newModels.put("smiles:" + chimObjName,
226		* currentModels); // } else { newModels.put(chimObjName, currentModels); // }
227		* // for each model for (ChimeraModel currentModel : currentModels) { //
228		* check if it is a RIN boolean foundRIN = false; if
229		* (currentModel.getModelType().equals(ModelType.PDB_MODEL)) { // go through
230		* all node annotations and check if any of them is a residue // or a chain if
231		* (cyObj instanceof CyNode && network.containsNode((CyNode) cyObj) &&
232		* specsFound != null && specsFound.size() > 0) { for (String resSpec :
233		* specsFound) { ChimeraStructuralObject res =
234		* ChimUtils.fromAttribute(resSpec, chimeraManager); if (res != null && (res
235		* instanceof ChimeraResidue || res instanceof ChimeraChain)) { // if so,
236		* assume it might be a RIN potentialRINs.add(network); foundRIN = true;
237		* break; } } } else if (cyObj instanceof CyNetwork) { // if cyObj is a
238		* network, check for residue/chain annotations in an // arbitrary node
239		* CyNetwork rinNet = (CyNetwork) cyObj; if (rinNet.getNodeList().size() > 0)
240		* { specsFound = ChimUtils.getResidueKeys( rinNet.getDefaultNodeTable(),
241		* rinNet.getNodeList().get(0), attrsFound); for (String resSpec : specsFound)
242		* { ChimeraStructuralObject res = ChimUtils.fromAttribute( resSpec,
243		* chimeraManager); if (res != null && (res instanceof ChimeraResidue || res
244		* instanceof ChimeraChain)) { potentialRINs.add(network); foundRIN = true;
245		* break; } } } } } if (foundRIN) { continue; } // if not RIN then associate
246		* new model with the Cytoscape // node if
247		* (!currentChimMap.containsKey(currentModel)) {
248		* currentChimMap.put(currentModel, new HashSet<CyIdentifiable>()); } String
249		* cyObjName = network.getRow(cyObj).get(CyNetwork.NAME, String.class); if
250		* (cyObjName != null && cyObjName.endsWith(currentModel.getModelName())) { //
251		* it is a modbase model, associate directly
252		* currentCyMap.get(cyObj).add(currentModel);
253		* currentChimMap.get(currentModel).add(cyObj);
254		* currentModel.addCyObject(cyObj, network); } else if (specsFound != null &&
255		* specsFound.size() > 0) { for (String resSpec : specsFound) {
256		* ChimeraStructuralObject specModel = ChimUtils.fromAttribute( resSpec,
257		* chimeraManager); if (specModel == null &&
258		* resSpec.equals(currentModel.getModelName())) { specModel =
259		* chimeraManager.getChimeraModel( currentModel.getModelNumber(),
260		* currentModel.getSubModelNumber()); } if (specModel != null &&
261		* currentModel.toSpec().equals(specModel.toSpec()) ||
262		* currentModel.getModelName().equals("smiles:" + resSpec)) {
263		* currentCyMap.get(cyObj).add(currentModel);
264		* currentChimMap.get(currentModel).add(cyObj);
265		* currentModel.addCyObject(cyObj, network);
266		* currentModel.setFuncResidues(ChimUtils.parseFuncRes(
267		* getResidueList(network, cyObj), chimObjName)); } } } } } } } // networks
268		* that contain nodes associated to newly opened models // this will usually
269		* be of length 1 for (CyNetwork net : potentialRINs) {
270		* addStructureNetwork(net); } // update dialog if (mnDialog != null) {
271		* mnDialog.modelChanged(); } aTask.associate(); return true; }
272		*/
		0% Uncovered Elements: 4 (4) Complexity: 1 Complexity Density: 0.25
273	0	public void closeStructures(Set<String> chimObjNames)...
274		{
275		// for each cytoscape object and chimera model pair
276	0	for (String modelName : chimObjNames)
277		{
278	0	List<ChimeraModel> models = chimeraManager
279		.getChimeraModels(modelName);
280	0	for (ChimeraModel model : models)
281		{
282	0	closeModel(model);
283		}
284		}
285		// if (mnDialog != null) {
286		// mnDialog.modelChanged();
287		// }
288		}
289
290		// TODO: [Optional] Can we make a screenshot of a single molecule?
		0% Uncovered Elements: 8 (8) Complexity: 2 Complexity Density: 0.25
291	0	public File saveChimeraImage()...
292		{
293	0	File tmpFile = null;
294	0	try
295		{
296		// Create the temp file name
297	0	tmpFile = File.createTempFile("structureViz", ".png");
298	0	chimeraManager.sendChimeraCommand("set bgTransparency", false);
299	0	chimeraManager.sendChimeraCommand(
300		"copy file " + tmpFile.getAbsolutePath() + " png", true);
301	0	chimeraManager.sendChimeraCommand("unset bgTransparency", false);
302		} catch (IOException ioe)
303		{
304		// Log error
305	0	logger.error("Error writing image", ioe);
306		}
307	0	return tmpFile;
308		}
309
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
310	0	public void closeModel(ChimeraModel model)...
311		{
312		// close model in Chimera
313	0	chimeraManager.closeModel(model);
314		// remove all associations
315		// if (currentChimMap.containsKey(model)) {
316		// for (CyIdentifiable cyObj : model.getCyObjects().keySet()) {
317		// if (cyObj == null) {
318		// continue;
319		// } else if (currentCyMap.containsKey(cyObj)) {
320		// currentCyMap.get(cyObj).remove(model);
321		// } else if (cyObj instanceof CyNetwork) {
322		// for (ChimeraResidue residue : model.getResidues()) {
323		// if (currentChimMap.containsKey(residue)) {
324		// for (CyIdentifiable cyObjRes : currentChimMap.get(residue)) {
325		// if (currentCyMap.containsKey(cyObjRes)) {
326		// currentCyMap.get(cyObjRes).remove(residue);
327		// }
328		// }
329		// currentChimMap.remove(residue);
330		// }
331		// }
332		// }
333		// }
334		// currentChimMap.remove(model);
335		// }
336		}
337
338		// public void addStructureNetwork(CyNetwork rin) {
339		// if (rin == null) {
340		// return;
341		// }
342		// ChimeraModel model = null;
343		// // the network is not added to the model in the currentChimMap
344		// List<String> attrsFound =
345		// CytoUtils.getMatchingAttributes(rin.getDefaultNodeTable(),
346		// getCurrentStructureKeys(rin));
347		// for (CyNode node : rin.getNodeList()) {
348		// if (!networkMap.containsKey(node)) {
349		// networkMap.put(node, new HashSet<CyNetwork>());
350		// }
351		// networkMap.get(node).add(rin);
352		// List<String> specsFound =
353		// ChimUtils.getResidueKeys(rin.getDefaultNodeTable(), node,
354		// attrsFound);
355		// for (String residueSpec : specsFound) {
356		// // if (!rin.getRow(node).isSet(ChimUtils.RESIDUE_ATTR)) {
357		// // continue;
358		// // }
359		// // String residueSpec = rin.getRow(node).get(ChimUtils.RESIDUE_ATTR,
360		// String.class);
361		// ChimeraStructuralObject chimObj = ChimUtils.fromAttribute(residueSpec,
362		// chimeraManager);
363		// // chimObj.getChimeraModel().addCyObject(node, rin);
364		// if (chimObj == null || chimObj instanceof ChimeraModel) {
365		// continue;
366		// }
367		// model = chimObj.getChimeraModel();
368		// if (!currentCyMap.containsKey(node)) {
369		// currentCyMap.put(node, new HashSet<ChimeraStructuralObject>());
370		// }
371		// currentCyMap.get(node).add(chimObj);
372		// if (!currentChimMap.containsKey(chimObj)) {
373		// currentChimMap.put(chimObj, new HashSet<CyIdentifiable>());
374		// }
375		// currentChimMap.get(chimObj).add(node);
376		// }
377		// }
378		// if (model != null) {
379		// model.addCyObject(rin, rin);
380		// if (!currentCyMap.containsKey(rin)) {
381		// currentCyMap.put(rin, new HashSet<ChimeraStructuralObject>());
382		// }
383		// currentCyMap.get(rin).add(model);
384		// }
385		// }
386
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
387	0	public void exitChimera()...
388		{
389		// // exit chimera, invokes clearOnExitChimera
390		// if (mnDialog != null) {
391		// mnDialog.setVisible(false);
392		// mnDialog = null;
393		// }
394		// if (alDialog != null) {
395		// alDialog.setVisible(false);
396		// }
397	0	chimeraManager.exitChimera();
398		}
399
400		// invoked by ChimeraManager whenever Chimera exits
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
401	0	public void clearOnChimeraExit()...
402		{
403		// // clear structures
404		// currentCyMap.clear();
405		// currentChimMap.clear();
406		// networkMap.clear();
407	0	chimSelectionList.clear();
408		// if (chimTable != null) {
409		// ((CyTableManager)
410		// getService(CyTableManager.class)).deleteTable(chimTable.getSUID());
411		// }
412		// if (mnDialog != null) {
413		// if (mnDialog.isVisible()) {
414		// mnDialog.lostChimera();
415		// mnDialog.setVisible(false);
416		// }
417		// mnDialog = null;
418		// if (alDialog != null) {
419		// alDialog.setVisible(false);
420		// }
421		// }
422		}
423
424		// We need to do this in two passes since some parts of a structure might be
425		// selected and some might not. Our selection model (unfortunately) only
426		// tells
427		// us that something has changed, not what...
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
428	0	public void updateCytoscapeSelection()...
429		{
430		// List<ChimeraStructuralObject> selectedChimObj
431	0	ignoreCySelection = true;
432		// System.out.println("update Cytoscape selection");
433		// find all possibly selected Cytoscape objects and unselect them
434		// Set<CyNetwork> networks = new HashSet<CyNetwork>();
435		// for (CyIdentifiable currentCyObj : currentCyMap.keySet()) {
436		// if (!networkMap.containsKey(currentCyObj)) {
437		// continue;
438		// }
439		// Set<CyNetwork> currentCyNetworks = networkMap.get(currentCyObj);
440		// if (currentCyNetworks == null || currentCyNetworks.size() == 0) {
441		//
442		// continue;
443		// }
444		// for (CyNetwork network : currentCyNetworks) {
445		// if ((currentCyObj instanceof CyNode && network.containsNode((CyNode)
446		// currentCyObj))
447		// || (currentCyObj instanceof CyEdge && network
448		// .containsEdge((CyEdge) currentCyObj))) {
449		// network.getRow(currentCyObj).set(CyNetwork.SELECTED, false);
450		// networks.add(network);
451		// }
452		// }
453		// }
454		//
455		// // select only those associated with selected Chimera objects
456		// Set<CyIdentifiable> currentCyObjs = new HashSet<CyIdentifiable>();
457		// for (ChimeraStructuralObject chimObj : chimSelectionList) {
458		// ChimeraModel currentSelModel = chimObj.getChimeraModel();
459		// if (currentChimMap.containsKey(currentSelModel)) {
460		// currentCyObjs.addAll(currentChimMap.get(currentSelModel));
461		// }
462		// if (currentChimMap.containsKey(chimObj)) {
463		// currentCyObjs.addAll(currentChimMap.get(chimObj));
464		// }
465		// // System.out.println(chimObj.toSpec() + ": " +
466		// // currentCyObjs.size());
467		// }
468		// for (CyIdentifiable cyObj : currentCyObjs) {
469		// // System.out.println(cyObj.toString());
470		// if (cyObj == null || !networkMap.containsKey(cyObj)) {
471		// continue;
472		// }
473		// Set<CyNetwork> currentCyNetworks = networkMap.get(cyObj);
474		// if (currentCyNetworks == null || currentCyNetworks.size() == 0) {
475		// continue;
476		// }
477		// for (CyNetwork network : currentCyNetworks) {
478		// if ((cyObj instanceof CyNode && network.containsNode((CyNode) cyObj))
479		// || (cyObj instanceof CyEdge && network.containsEdge((CyEdge) cyObj))) {
480		// network.getRow(cyObj).set(CyNetwork.SELECTED, true);
481		// networks.add(network);
482		// }
483		// }
484		// }
485		//
486		// CyNetworkViewManager cyNetViewManager = (CyNetworkViewManager)
487		// getService(CyNetworkViewManager.class);
488		// // Update network views
489		// for (CyNetwork network : networks) {
490		// Collection<CyNetworkView> views =
491		// cyNetViewManager.getNetworkViews(network);
492		// for (CyNetworkView view : views) {
493		// view.updateView();
494		// }
495		// }
496	0	ignoreCySelection = false;
497		}
498
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
499	0	public void cytoscapeSelectionChanged(Map<Long, Boolean> selectedRows)...
500		{
501		// if (ignoreCySelection || currentCyMap.size() == 0) {
502		// return;
503		// }
504		// // clearSelectionList();
505		// // System.out.println("cytoscape selection changed");
506		// // iterate over all cy objects with associated models
507		// for (CyIdentifiable cyObj : currentCyMap.keySet()) {
508		// if (cyObj instanceof CyNetwork ||
509		// !selectedRows.containsKey(cyObj.getSUID())) {
510		// continue;
511		// }
512		// for (ChimeraStructuralObject chimObj : currentCyMap.get(cyObj)) {
513		// if (selectedRows.get(cyObj.getSUID())) {
514		// addChimSelection(chimObj);
515		// if (chimObj instanceof ChimeraResidue) {
516		// if (chimObj.getChimeraModel().isSelected()) {
517		// removeChimSelection(chimObj.getChimeraModel());
518		// } else if (chimObj.getChimeraModel()
519		// .getChain(((ChimeraResidue) chimObj).getChainId()).isSelected()) {
520		// removeChimSelection(chimObj.getChimeraModel().getChain(
521		// ((ChimeraResidue) chimObj).getChainId()));
522		// }
523		// }
524		// } else {
525		// removeChimSelection(chimObj);
526		// if (chimObj.hasSelectedChildren() && chimObj instanceof ChimeraModel) {
527		// for (ChimeraResidue residue : ((ChimeraModel) chimObj)
528		// .getSelectedResidues()) {
529		// removeChimSelection(residue);
530		// }
531		// }
532		// }
533		// }
534		// }
535		// System.out.println("selection list: " + getChimSelectionCount());
536	0	updateChimeraSelection();
537	0	selectionChanged();
538		}
539
540		// Save models in a HashMap/Set for better performance?
		0% Uncovered Elements: 15 (15) Complexity: 4 Complexity Density: 0.44
541	0	public void updateChimeraSelection()...
542		{
543		// System.out.println("update Chimera selection");
544	0	String selSpec = "";
545	0	for (int i = 0; i < chimSelectionList.size(); i++)
546		{
547	0	ChimeraStructuralObject nodeInfo = chimSelectionList.get(i);
548		// we do not care about the model anymore
549	0	selSpec = selSpec.concat(nodeInfo.toSpec());
550	0	if (i < chimSelectionList.size() - 1)
551		{
552	0	selSpec.concat("|");
553		}
554		}
555	0	if (selSpec.length() > 0)
556		{
557	0	chimeraManager.select("sel " + selSpec);
558		}
559		else
560		{
561	0	chimeraManager.select("~sel");
562		}
563		}
564
565		/**
566		* This is called by the selectionListener to let us know that the user has
567		* changed their selection in Chimera. We need to go back to Chimera to find
568		* out what is currently selected and update our list.
569		*/
		0% Uncovered Elements: 32 (32) Complexity: 7 Complexity Density: 0.29
570	0	public void chimeraSelectionChanged()...
571		{
572		// System.out.println("Chimera selection changed");
573	0	clearSelectionList();
574		// Execute the command to get the list of models with selections
575	0	Map<Integer, ChimeraModel> selectedModelsMap = chimeraManager
576		.getSelectedModels();
577		// Now get the residue-level data
578	0	chimeraManager.getSelectedResidues(selectedModelsMap);
579		// Get the selected objects
580	0	try
581		{
582	0	for (ChimeraModel selectedModel : selectedModelsMap.values())
583		{
584	0	int modelNumber = selectedModel.getModelNumber();
585	0	int subModelNumber = selectedModel.getSubModelNumber();
586		// Get the corresponding "real" model
587	0	if (chimeraManager.hasChimeraModel(modelNumber, subModelNumber))
588		{
589	0	ChimeraModel dataModel = chimeraManager
590		.getChimeraModel(modelNumber, subModelNumber);
591	0	if (dataModel.getResidueCount() == selectedModel.getResidueCount()
592		|| dataModel
593		.getModelType() == StructureManager.ModelType.SMILES)
594		{
595		// Select the entire model
596	0	addChimSelection(dataModel);
597		// dataModel.setSelected(true);
598		}
599		else
600		{
601	0	for (ChimeraChain selectedChain : selectedModel.getChains())
602		{
603	0	ChimeraChain dataChain = dataModel
604		.getChain(selectedChain.getChainId());
605	0	if (selectedChain.getResidueCount() == dataChain
606		.getResidueCount())
607		{
608	0	addChimSelection(dataChain);
609		// dataChain.setSelected(true);
610		}
611		// else {
612		// Need to select individual residues
613	0	for (ChimeraResidue res : selectedChain.getResidues())
614		{
615	0	String residueIndex = res.getIndex();
616	0	ChimeraResidue residue = dataChain.getResidue(residueIndex);
617	0	if (residue == null)
618		{
619	0	continue;
620		}
621	0	addChimSelection(residue);
622		// residue.setSelected(true);
623		} // resIter.hasNext
624		// }
625		} // chainIter.hasNext()
626		}
627		}
628		} // modelIter.hasNext()
629		} catch (Exception ex)
630		{
631	0	logger.warn("Could not update selection", ex);
632		}
633		// System.out.println("selection list: " + getChimSelectionCount());
634		// Finally, update the navigator panel
635	0	selectionChanged();
636	0	updateCytoscapeSelection();
637		}
638
		0% Uncovered Elements: 7 (7) Complexity: 1 Complexity Density: 0.14
639	0	public void selectFunctResidues(Collection<ChimeraModel> models)...
640		{
641	0	clearSelectionList();
642	0	for (ChimeraModel model : models)
643		{
644	0	for (ChimeraResidue residue : model.getFuncResidues())
645		{
646	0	addChimSelection(residue);
647		}
648		}
649	0	updateChimeraSelection();
650	0	updateCytoscapeSelection();
651	0	selectionChanged();
652		}
653
654		// public void selectFunctResidues(CyNode node, CyNetwork network) {
655		// clearSelectionList();
656		// if (currentCyMap.containsKey(node)) {
657		// Set<ChimeraStructuralObject> chimObjects = currentCyMap.get(node);
658		// for (ChimeraStructuralObject obj : chimObjects) {
659		// if (obj instanceof ChimeraModel) {
660		// ChimeraModel model = (ChimeraModel) obj;
661		// for (ChimeraResidue residue : model.getFuncResidues()) {
662		// addChimSelection(residue);
663		// }
664		// }
665		// }
666		// }
667		// updateChimeraSelection();
668		// updateCytoscapeSelection();
669		// selectionChanged();
670		// }
671
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
672	0	public List<ChimeraStructuralObject> getChimSelectionList()...
673		{
674	0	return chimSelectionList;
675		}
676
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
677	0	public int getChimSelectionCount()...
678		{
679	0	return chimSelectionList.size();
680		}
681
682		/**
683		* Add a selection to the selection list. This is called primarily by the
684		* Model Navigator Dialog to keep the selections in sync
685		*
686		* @param selectionToAdd
687		* the selection to add to our list
688		*/
		0% Uncovered Elements: 5 (5) Complexity: 3 Complexity Density: 1
689	0	public void addChimSelection(ChimeraStructuralObject selectionToAdd)...
690		{
691	0	if (selectionToAdd != null
692		&& !chimSelectionList.contains(selectionToAdd))
693		{
694	0	chimSelectionList.add(selectionToAdd);
695	0	selectionToAdd.setSelected(true);
696		}
697		}
698
699		/**
700		* Remove a selection from the selection list. This is called primarily by the
701		* Model Navigator Dialog to keep the selections in sync
702		*
703		* @param selectionToRemove
704		* the selection to remove from our list
705		*/
		0% Uncovered Elements: 5 (5) Complexity: 3 Complexity Density: 1
706	0	public void removeChimSelection(ChimeraStructuralObject selectionToRemove)...
707		{
708	0	if (selectionToRemove != null
709		&& chimSelectionList.contains(selectionToRemove))
710		{
711	0	chimSelectionList.remove(selectionToRemove);
712	0	selectionToRemove.setSelected(false);
713		}
714		}
715
716		/**
717		* Clear the list of selected objects
718		*/
		0% Uncovered Elements: 6 (6) Complexity: 2 Complexity Density: 0.5
719	0	public void clearSelectionList()...
720		{
721	0	for (ChimeraStructuralObject cso : chimSelectionList)
722		{
723	0	if (cso != null)
724		{
725	0	cso.setSelected(false);
726		}
727		}
728	0	chimSelectionList.clear();
729		}
730
731		/**
732		* Associate a new network with the corresponding Chimera objects.
733		*
734		* @param network
735		*/
736
737		/**
738		* Dump and refresh all of our model/chain/residue info
739		*/
		0% Uncovered Elements: 22 (22) Complexity: 4 Complexity Density: 0.25
740	0	public void updateModels()...
741		{
742		// Stop all of our listeners while we try to handle this
743	0	chimeraManager.stopListening();
744
745		// Get all of the open models
746	0	List<ChimeraModel> newModelList = chimeraManager.getModelList();
747
748		// Match them up -- assume that the model #'s haven't changed
749	0	for (ChimeraModel newModel : newModelList)
750		{
751		// Get the color (for our navigator)
752	0	newModel.setModelColor(chimeraManager.getModelColor(newModel));
753
754		// Get our model info
755	0	int modelNumber = newModel.getModelNumber();
756	0	int subModelNumber = newModel.getSubModelNumber();
757
758		// If we already know about this model number, get the Structure,
759		// which tells us about the associated CyNode
760	0	if (chimeraManager.hasChimeraModel(modelNumber, subModelNumber))
761		{
762	0	ChimeraModel oldModel = chimeraManager.getChimeraModel(modelNumber,
763		subModelNumber);
764	0	chimeraManager.removeChimeraModel(modelNumber, subModelNumber);
765	0	newModel.setModelType(oldModel.getModelType());
766	0	if (oldModel.getModelType() == ModelType.SMILES)
767		{
768	0	newModel.setModelName(oldModel.getModelName());
769		}
770		// re-assign associations to cytoscape objects
771		// Map<CyIdentifiable, CyNetwork> oldModelCyObjs =
772		// oldModel.getCyObjects();
773		// for (CyIdentifiable cyObj : oldModelCyObjs.keySet()) {
774		// // add cy objects to the new model
775		// newModel.addCyObject(cyObj, oldModelCyObjs.get(cyObj));
776		// if (currentCyMap.containsKey(cyObj)) {
777		// currentCyMap.get(cyObj).add(newModel);
778		// if (currentCyMap.get(cyObj).contains(oldModel)) {
779		// currentCyMap.get(cyObj).remove(oldModel);
780		// }
781		// }
782		// }
783		// // add new model to the chimera objects map and remove old model
784		// if (currentChimMap.containsKey(oldModel)) {
785		// currentChimMap.put(newModel, currentChimMap.get(oldModel));
786		// currentChimMap.remove(oldModel);
787		// }
788		}
789		// add new model to ChimeraManager
790	0	chimeraManager.addChimeraModel(modelNumber, subModelNumber, newModel);
791
792		// Get the residue information
793	0	if (newModel.getModelType() != ModelType.SMILES)
794		{
795	0	chimeraManager.addResidues(newModel);
796		}
797		// for (CyIdentifiable cyObj : newModel.getCyObjects().keySet()) {
798		// if (cyObj != null && cyObj instanceof CyNetwork) {
799		// addStructureNetwork((CyNetwork) cyObj);
800		// } else if (cyObj != null && cyObj instanceof CyNode) {
801		// newModel.setFuncResidues(ChimUtils.parseFuncRes(
802		// getResidueList(newModel.getCyObjects().get(cyObj), cyObj),
803		// newModel.getModelName()));
804		// }
805		// }
806		}
807
808		// associate all models with any node or network
809		// aTask.associate();
810
811		// Restart all of our listeners
812	0	chimeraManager.startListening();
813		// Done
814		}
815
		- Uncovered Elements: 0 (0) Complexity: 1 Complexity Density: -
816	0	public void launchModelNavigatorDialog()...
817		{
818		// TODO: [Optional] Use haveGUI flag
819		// if (!haveGUI) {
820		// return;
821		// }
822		// if (mnDialog == null) {
823		// CySwingApplication cyApplication = (CySwingApplication)
824		// getService(CySwingApplication.class);
825		// mnDialog = new ModelNavigatorDialog(cyApplication.getJFrame(), this);
826		// mnDialog.pack();
827		// }
828		// mnDialog.setVisible(true);
829		}
830
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
831	0	public boolean isMNDialogOpen()...
832		{
833		// if (mnDialog != null && mnDialog.isVisible()) {
834		// return true;
835		// }
836	0	return false;
837		}
838
839		/**
840		* Invoked by the listener thread.
841		*/
		- Uncovered Elements: 0 (0) Complexity: 1 Complexity Density: -
842	0	public void modelChanged()...
843		{
844		// if (mnDialog != null) {
845		// mnDialog.modelChanged();
846		// }
847		}
848
849		/**
850		* Inform our interface that the selection has changed
851		*/
		- Uncovered Elements: 0 (0) Complexity: 1 Complexity Density: -
852	0	public void selectionChanged()...
853		{
854		// if (mnDialog != null) {
855		// // System.out.println("update dialog selection");
856		// mnDialog.updateSelection(new
857		// ArrayList<ChimeraStructuralObject>(chimSelectionList));
858		// }
859		}
860
		0% Uncovered Elements: 8 (8) Complexity: 2 Complexity Density: 0.33
861	0	public void launchAlignDialog(boolean useChains)...
862		{
863		// TODO: [Optional] Use haveGUI flag
864		// Sometimes it does not appear in Windows
865		// if (!haveGUI) {
866		// return;
867		// }
868		// if (alDialog != null) {
869		// alDialog.setVisible(false);
870		// alDialog.dispose();
871		// }
872		// System.out.println("launch align dialog");
873	0	List<ChimeraStructuralObject> chimObjectList = new ArrayList<>();
874	0	for (ChimeraModel model : chimeraManager.getChimeraModels())
875		{
876	0	if (useChains)
877		{
878	0	for (ChimeraChain chain : model.getChains())
879		{
880	0	chimObjectList.add(chain);
881		}
882		}
883		else
884		{
885	0	chimObjectList.add(model);
886		}
887		}
888		// Bring up the dialog
889		// CySwingApplication cyApplication = (CySwingApplication)
890		// getService(CySwingApplication.class);
891		// alDialog = new AlignStructuresDialog(cyApplication.getJFrame(), this,
892		// chimObjectList);
893		// alDialog.pack();
894		// alDialog.setVisible(true);
895		}
896
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
897	0	public List<String> getAllStructureKeys()...
898		{
899	0	return Arrays.asList(defaultStructureKeys);
900		}
901
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
902	0	public List<String> getAllChemStructKeys()...
903		{
904	0	return Arrays.asList(defaultChemStructKeys);
905		}
906
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
907	0	public List<String> getAllResidueKeys()...
908		{
909	0	return Arrays.asList(defaultResidueKeys);
910		}
911
		0% Uncovered Elements: 3 (3) Complexity: 1 Complexity Density: 0.33
912	0	public List<String> getAllChimeraResidueAttributes()...
913		{
914	0	List<String> attributes = new ArrayList<>();
915		// attributes.addAll(rinManager.getResAttrs());
916	0	attributes.addAll(chimeraManager.getAttrList());
917	0	return attributes;
918		}
919
920		StructureSettings defaultSettings = null;
921
922		// TODO: [Optional] Change priority of Chimera paths
		0% Uncovered Elements: 70 (70) Complexity: 14 Complexity Density: 0.3
923	0	public static List<String> getChimeraPaths(boolean isChimeraX)...
924		{
925	0	List<String> pathList = new ArrayList<>();
926
927		// if no network is available and the settings have been modified by the
928		// user, check for a
929		// path to chimera
930		//
931		// For Jalview, Preferences/Cache plays this role instead
932		// if (defaultSettings != null)
933		// {
934		// String defaultPath = defaultSettings.getChimeraPath();
935		// if (defaultPath != null && !defaultPath.equals(""))
936		// {
937		// pathList.add(defaultPath);
938		// return pathList;
939		// }
940		// }
941
942	0	String os = System.getProperty("os.name");
943	0	String userPath = Cache
944	0	.getDefault(isChimeraX ? Preferences.CHIMERAX_PATH
945		: Preferences.CHIMERA_PATH, null);
946
947		/*
948		* paths are based on getChimeraPaths() in
949		* Chimera:
950		* https://github.com/RBVI/structureViz2/blob/master/src/main/java/edu/ucsf/rbvi/structureViz2/internal/model/StructureManager.java
951		* ChimeraX:
952		* https://github.com/RBVI/structureVizX/blob/master/src/main/java/edu/ucsf/rbvi/structureVizX/internal/model/StructureManager.java
953		*/
954	0	String chimera = isChimeraX ? "ChimeraX" : "Chimera";
955	0	String chimeraExe = isChimeraX ? "ChimeraX" : "chimera";
956
957		/*
958		* Jalview addition: check if path set in user preferences
959		*/
960	0	if (userPath != null)
961		{
962		// in macos, deal with the user selecting the .app folder
963	0	boolean adjusted = false;
964	0	if (os.startsWith("Mac") && userPath.endsWith((".app")))
965		{
966	0	String possiblePath = String.format("%s/Contents/MacOS/%s",
967		userPath, chimeraExe);
968	0	if (new File(possiblePath).exists())
969		{
970	0	pathList.add(possiblePath);
971	0	adjusted = true;
972		}
973		}
974	0	if (!adjusted)
975		{
976	0	pathList.add(userPath);
977		}
978		}
979
980		// Add default installation paths
981	0	if (os.startsWith("Linux"))
982		{
983		// ChimeraX .deb and .rpm packages put symbolic link from
984		// /usr/bin/chimerax
985	0	pathList.add(String.format("/usr/bin/%s",
986		chimeraExe.toLowerCase(Locale.ROOT)));
987	0	pathList.add(String.format("/usr/bin/%s", chimeraExe));
988
989	0	pathList.add(String.format("/usr/local/bin/%s",
990		chimeraExe.toLowerCase(Locale.ROOT)));
991	0	pathList.add(String.format("/usr/local/bin/%s", chimeraExe));
992
993		// these paths also used by .deb and .rpm
994	0	pathList.add(String.format("/usr/lib/ucsf-%s/bin/%s",
995		chimera.toLowerCase(Locale.ROOT), chimeraExe));
996	0	pathList.add(String.format("/usr/libexec/UCSF-%s/bin/%s", chimera,
997		chimeraExe));
998
999	0	pathList.add(String.format("/usr/local/chimera/bin/%s", chimeraExe));
1000
1001		// user home paths
1002	0	pathList.add(
1003		String.format("%s/bin/%s", System.getProperty("user.home"),
1004		chimeraExe.toLowerCase(Locale.ROOT)));
1005	0	pathList.add(String.format("%s/bin/%s",
1006		System.getProperty("user.home"), chimeraExe));
1007	0	pathList.add(String.format("%s/opt/bin/%s",
1008		System.getProperty("user.home"),
1009		chimeraExe.toLowerCase(Locale.ROOT)));
1010	0	pathList.add(String.format("%s/opt/bin/%s",
1011		System.getProperty("user.home"), chimeraExe));
1012	0	pathList.add(String.format("%s/local/bin/%s",
1013		System.getProperty("user.home"),
1014		chimeraExe.toLowerCase(Locale.ROOT)));
1015	0	pathList.add(String.format("%s/local/bin/%s",
1016		System.getProperty("user.home"), chimeraExe));
1017		}
1018	0	else if (os.startsWith("Windows"))
1019		{
1020	0	for (String root : new String[] { "\\Program Files",
1021		"C:\\Program Files", "\\Program Files (x86)",
1022		"C:\\Program Files (x86)", String.format("%s\\AppData\\Local",
1023		System.getProperty("user.home")) })
1024		{
1025	0	String[] candidates = isChimeraX ? CHIMERAX_VERSIONS
1026		: CHIMERA_VERSIONS;
1027	0	for (String version : candidates)
1028		{
1029		// TODO original code doesn't include version in path; which is right?
1030	0	String path = String.format("%s\\%s %s\\bin\\%s", root, chimera,
1031		version, chimeraExe);
1032	0	pathList.add(path);
1033	0	pathList.add(path + ".exe");
1034		}
1035		// try without a version number too
1036	0	String path = String.format("%s\\%s\\bin\\%s", root, chimera,
1037		chimeraExe);
1038	0	pathList.add(path);
1039	0	pathList.add(path + ".exe");
1040		}
1041		}
1042	0	else if (os.startsWith("Mac"))
1043		{
1044		// check for installations with version numbers first
1045	0	String[] candidates = isChimeraX ? CHIMERAX_VERSIONS
1046		: CHIMERA_VERSIONS;
1047	0	for (String version : candidates)
1048		{
1049	0	pathList.add(
1050		String.format("/Applications/%s-%s.app/Contents/MacOS/%s",
1051		chimera, version, chimeraExe));
1052	0	pathList.add(
1053		String.format("%s/Applications/%s-%s.app/Contents/MacOS/%s",
1054		System.getProperty("user.home"), chimera, version,
1055		chimeraExe));
1056		}
1057	0	pathList.add(String.format("/Applications/%s.app/Contents/MacOS/%s",
1058		chimera, chimeraExe));
1059	0	pathList.add(String.format("%s/Applications/%s.app/Contents/MacOS/%s",
1060		System.getProperty("user.home"), chimera, chimeraExe));
1061		}
1062	0	return pathList;
1063		}
1064
		- Uncovered Elements: 0 (0) Complexity: 1 Complexity Density: -
1065	0	public void setChimeraPathProperty(String path)...
1066		{
1067		// CytoUtils.setDefaultChimeraPath(registrar, chimeraPropertyName,
1068		// chimeraPathPropertyKey,
1069		// path);
1070		}
1071
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
1072	0	public void setStructureSettings(StructureSettings structureSettings)...
1073		{
1074	0	this.defaultSettings = structureSettings;
1075		}
1076
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
1077	0	public String getCurrentChimeraPath(Object object)...
1078		{
1079	0	if (defaultSettings != null)
1080		{
1081	0	return defaultSettings.getChimeraPath();
1082		}
1083		else
1084		{
1085	0	return "";
1086		}
1087		}
1088
1089		// public void initChimTable() {
1090		// CyTableManager manager = (CyTableManager) getService(CyTableManager.class);
1091		// CyTableFactory factory = (CyTableFactory) getService(CyTableFactory.class);
1092		// for (CyTable table : manager.getGlobalTables()) {
1093		// if (table.getTitle().equals(chimeraOutputTable)) {
1094		// manager.deleteTable(table.getSUID());
1095		// }
1096		// }
1097		// chimTable = factory.createTable(chimeraOutputTable, chimeraCommandAttr,
1098		// String.class,
1099		// false, true);
1100		// manager.addTable(chimTable);
1101		// if (chimTable.getColumn(chimeraOutputAttr) == null) {
1102		// chimTable.createListColumn(chimeraOutputAttr, String.class, false);
1103		// }
1104		// }
1105
1106		// public void addChimReply(String command, List<String> reply) {
1107		// chimTable.getRow(command).set(chimeraOutputAttr, reply);
1108		// }
1109
1110		}