Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
AlignViewController	47	180	74	0.00%	Show methods

Class AlignViewController

Class AlignViewController	Line # 47	Total Statements 180	Complexity 74	TOTAL Coverage 0.00%
AlignViewController(AlignViewControllerGuiI,AlignViewportI,AlignmentViewPanel)   AlignViewController(AlignViewControllerGuiI,AlignViewportI,AlignmentViewPanel)	5858	3.03	1.01	0.0 0.00%
setViewportAndAlignmentPanel(AlignViewportI,AlignmentViewPanel) : void   setViewportAndAlignmentPanel(AlignViewportI,AlignmentViewPanel) : void	6666	2.02	1.01	0.0 0.00%
makeGroupsFromSelection() : boolean   makeGroupsFromSelection() : boolean	7474	23.023	9.09	0.0 0.00%
createGroup() : boolean   createGroup() : boolean	125125	5.05	2.02	0.0 0.00%
unGroup() : boolean   unGroup() : boolean	138138	5.05	2.02	0.0 0.00%
deleteGroups() : boolean   deleteGroups() : boolean	150150	6.06	3.03	0.0 0.00%
markColumnsContainingFeatures(boolean,boolean,boolean,String) : boolean   markColumnsContainingFeatures(boolean,boolean,boolean,String) : boolean	164164	21.021	11.011	0.0 0.00%
findColumnsWithFeature(String,SequenceCollectionI,BitSet) : int   findColumnsWithFeature(String,SequenceCollectionI,BitSet) : int	236236	30.030	13.013	0.0 0.00%
sortAlignmentByFeatureDensity(List<String>) : void   sortAlignmentByFeatureDensity(List<String>) : void	314314	2.02	1.01	0.0 0.00%
sortByFeatures(List<String>,String,String) : void   sortByFeatures(List<String>,String,String) : void	333333	20.020	6.06	0.0 0.00%
sortAlignmentByFeatureScore(List<String>) : void   sortAlignmentByFeatureScore(List<String>) : void	372372	2.02	1.01	0.0 0.00%
parseFeaturesFile(Object,DataSourceType,boolean) : boolean   parseFeaturesFile(Object,DataSourceType,boolean) : boolean	379379	13.013	5.05	0.0 0.00%
markHighlightedColumns(boolean,boolean,boolean) : boolean   markHighlightedColumns(boolean,boolean,boolean) : boolean	414414	21.021	12.012	0.0 0.00%
copyHighlightedRegionsToClipboard() : boolean   copyHighlightedRegionsToClipboard() : boolean	476476	9.09	3.03	0.0 0.00%
justify_Region(boolean) : boolean   justify_Region(boolean) : boolean	504504	18.018	4.04	0.0 0.00%

 

Contributing tests

Source view

1		/*
2		* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3		* Copyright (C) $$Year-Rel$$ The Jalview Authors
4		*
5		* This file is part of Jalview.
6		*
7		* Jalview is free software: you can redistribute it and/or
8		* modify it under the terms of the GNU General Public License
9		* as published by the Free Software Foundation, either version 3
10		* of the License, or (at your option) any later version.
11		*
12		* Jalview is distributed in the hope that it will be useful, but
13		* WITHOUT ANY WARRANTY; without even the implied warranty
14		* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15		* PURPOSE. See the GNU General Public License for more details.
16		*
17		* You should have received a copy of the GNU General Public License
18		* along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19		* The Jalview Authors are detailed in the 'AUTHORS' file.
20		*/
21		package jalview.controller;
22
23		import java.awt.Color;
24		import java.util.BitSet;
25		import java.util.List;
26
27		import jalview.analysis.AlignmentSorter;
28		import jalview.api.AlignViewControllerGuiI;
29		import jalview.api.AlignViewControllerI;
30		import jalview.api.AlignViewportI;
31		import jalview.api.AlignmentViewPanel;
32		import jalview.api.FeatureRenderer;
33		import jalview.commands.OrderCommand;
34		import jalview.datamodel.AlignmentI;
35		import jalview.datamodel.ColumnSelection;
36		import jalview.datamodel.SearchResultsI;
37		import jalview.datamodel.SequenceCollectionI;
38		import jalview.datamodel.SequenceFeature;
39		import jalview.datamodel.SequenceGroup;
40		import jalview.datamodel.SequenceI;
41		import jalview.gui.Desktop;
42		import jalview.io.DataSourceType;
43		import jalview.io.FeaturesFile;
44		import jalview.schemes.ColourSchemeI;
45		import jalview.util.MessageManager;
46
		0% Uncovered Elements: 293 (293) Complexity: 74 Complexity Density: 0.41
47		public class AlignViewController implements AlignViewControllerI
48		{
49		AlignViewportI viewport = null;
50
51		AlignmentViewPanel alignPanel = null;
52
53		/**
54		* the GUI container that is handling interactions with the user
55		*/
56		private AlignViewControllerGuiI avcg;
57
		0% Uncovered Elements: 3 (3) Complexity: 1 Complexity Density: 0.33
58	0	public AlignViewController(AlignViewControllerGuiI alignFrame,...
59		AlignViewportI vp, AlignmentViewPanel ap)
60		{
61	0	this.avcg = alignFrame;
62	0	this.viewport = vp;
63	0	this.alignPanel = ap;
64		}
65
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
66	0	@Override...
67		public void setViewportAndAlignmentPanel(AlignViewportI vp,
68		AlignmentViewPanel ap)
69		{
70	0	this.alignPanel = ap;
71	0	this.viewport = vp;
72		}
73
		0% Uncovered Elements: 35 (35) Complexity: 9 Complexity Density: 0.39
74	0	@Override...
75		public boolean makeGroupsFromSelection()
76		{
77	0	SequenceGroup sg = viewport.getSelectionGroup();
78	0	ColumnSelection cs = viewport.getColumnSelection();
79	0	SequenceGroup[] gps = null;
80	0	if (sg != null && (cs == null || cs.isEmpty()))
81		{
82	0	gps = jalview.analysis.Grouping.makeGroupsFrom(
83		viewport.getSequenceSelection(),
84		viewport.getAlignmentView(true)
85		.getSequenceStrings(viewport.getGapCharacter()),
86		viewport.getAlignment().getGroups());
87		}
88		else
89		{
90	0	if (cs != null)
91		{
92	0	gps = jalview.analysis.Grouping.makeGroupsFromCols(
93	0	(sg == null) ? viewport.getAlignment().getSequencesArray()
94		: sg.getSequences().toArray(new SequenceI[0]),
95		cs, viewport.getAlignment().getGroups());
96		}
97		}
98	0	if (gps != null)
99		{
100	0	viewport.getAlignment().deleteAllGroups();
101	0	viewport.clearSequenceColours();
102	0	viewport.setSelectionGroup(null);
103	0	ColourSchemeI colours = viewport.getGlobalColourScheme();
104		// set view properties for each group
105	0	for (int g = 0; g < gps.length; g++)
106		{
107		// gps[g].setShowunconserved(viewport.getShowUnconserved());
108	0	gps[g].setshowSequenceLogo(viewport.isShowSequenceLogo());
109	0	viewport.getAlignment().addGroup(gps[g]);
110	0	if (colours != null)
111		{
112	0	gps[g].setColourScheme(colours.getInstance(viewport, gps[g]));
113		}
114	0	Color col = new Color((int) (Math.random() * 255),
115		(int) (Math.random() * 255), (int) (Math.random() * 255));
116	0	gps[g].idColour = col;
117	0	viewport.setUpdateStructures(true);
118	0	viewport.addSequenceGroup(gps[g]);
119		}
120	0	return true;
121		}
122	0	return false;
123		}
124
		0% Uncovered Elements: 7 (7) Complexity: 2 Complexity Density: 0.4
125	0	@Override...
126		public boolean createGroup()
127		{
128
129	0	SequenceGroup sg = viewport.getSelectionGroup();
130	0	if (sg != null)
131		{
132	0	viewport.getAlignment().addGroup(sg);
133	0	return true;
134		}
135	0	return false;
136		}
137
		0% Uncovered Elements: 7 (7) Complexity: 2 Complexity Density: 0.4
138	0	@Override...
139		public boolean unGroup()
140		{
141	0	SequenceGroup sg = viewport.getSelectionGroup();
142	0	if (sg != null)
143		{
144	0	viewport.getAlignment().deleteGroup(sg);
145	0	return true;
146		}
147	0	return false;
148		}
149
		0% Uncovered Elements: 8 (8) Complexity: 3 Complexity Density: 0.5
150	0	@Override...
151		public boolean deleteGroups()
152		{
153	0	if (viewport.getAlignment().getGroups() != null
154		&& viewport.getAlignment().getGroups().size() > 0)
155		{
156	0	viewport.getAlignment().deleteAllGroups();
157	0	viewport.clearSequenceColours();
158	0	viewport.setSelectionGroup(null);
159	0	return true;
160		}
161	0	return false;
162		}
163
		0% Uncovered Elements: 39 (39) Complexity: 11 Complexity Density: 0.52
164	0	@Override...
165		public boolean markColumnsContainingFeatures(boolean invert,
166		boolean extendCurrent, boolean toggle, String featureType)
167		{
168		// JBPNote this routine could also mark rows, not just columns.
169		// need a decent query structure to allow all types of feature searches
170	0	BitSet bs = new BitSet();
171	0	boolean searchSelection = viewport.getSelectionGroup() != null
172		&& !extendCurrent;
173	0	SequenceCollectionI sqcol = searchSelection
174		? viewport.getSelectionGroup()
175		: viewport.getAlignment();
176
177	0	int nseq = findColumnsWithFeature(featureType, sqcol, bs);
178
179	0	ColumnSelection cs = viewport.getColumnSelection();
180	0	if (cs == null)
181		{
182	0	cs = new ColumnSelection();
183		}
184
185	0	if (bs.cardinality() > 0 || invert)
186		{
187	0	boolean changed = cs.markColumns(bs, sqcol.getStartRes(),
188		sqcol.getEndRes(), invert, extendCurrent, toggle);
189	0	if (changed)
190		{
191	0	viewport.setColumnSelection(cs);
192	0	alignPanel.paintAlignment(false, false);
193	0	int columnCount = invert
194		? (sqcol.getEndRes() - sqcol.getStartRes() + 1)
195		- bs.cardinality()
196		: bs.cardinality();
197	0	avcg.setStatus(MessageManager.formatMessage(
198		"label.view_controller_toggled_marked", new String[]
199	0	{ toggle ? MessageManager.getString("label.toggled")
200		: MessageManager.getString("label.marked"),
201		String.valueOf(columnCount),
202	0	invert ? MessageManager
203		.getString("label.not_containing")
204		: MessageManager.getString("label.containing"),
205		featureType, Integer.valueOf(nseq).toString() }));
206	0	return true;
207		}
208		}
209		else
210		{
211	0	String key = searchSelection ? "label.no_feature_found_selection"
212		: "label.no_feature_of_type_found";
213	0	avcg.setStatus(
214		MessageManager.formatMessage(key, new String[]
215		{ featureType }));
216	0	if (!extendCurrent)
217		{
218	0	cs.clear();
219	0	alignPanel.paintAlignment(false, false);
220		}
221		}
222	0	return false;
223		}
224
225		/**
226		* Sets a bit in the BitSet for each column (base 0) in the sequence
227		* collection which includes a visible feature of the specified feature type.
228		* Returns the number of sequences which have the feature visible in the
229		* selected range.
230		*
231		* @param featureType
232		* @param sqcol
233		* @param bs
234		* @return
235		*/
		0% Uncovered Elements: 50 (50) Complexity: 13 Complexity Density: 0.43
236	0	int findColumnsWithFeature(String featureType, SequenceCollectionI sqcol,...
237		BitSet bs)
238		{
239	0	FeatureRenderer fr = alignPanel == null ? null
240		: alignPanel.getFeatureRenderer();
241
242	0	final int startColumn = sqcol.getStartRes() + 1; // converted to base 1
243	0	final int endColumn = sqcol.getEndRes() + 1;
244	0	List<SequenceI> seqs = sqcol.getSequences();
245	0	int nseq = 0;
246	0	for (SequenceI sq : seqs)
247		{
248	0	if (sq != null)
249		{
250		// int ist = sq.findPosition(sqcol.getStartRes());
251	0	List<SequenceFeature> sfs = sq.findFeatures(startColumn, endColumn,
252		featureType);
253
254	0	boolean found = false;
255	0	for (SequenceFeature sf : sfs)
256		{
257	0	if (fr.getColour(sf) == null)
258		{
259	0	continue;
260		}
261	0	if (!found)
262		{
263	0	nseq++;
264		}
265	0	found = true;
266
267	0	int sfStartCol = sq.findIndex(sf.getBegin());
268	0	int sfEndCol = sq.findIndex(sf.getEnd());
269
270	0	if (sf.isContactFeature())
271		{
272		/*
273		* 'contact' feature - check for 'start' or 'end'
274		* position within the selected region
275		*/
276	0	if (sfStartCol >= startColumn && sfStartCol <= endColumn)
277		{
278	0	bs.set(sfStartCol - 1);
279		}
280	0	if (sfEndCol >= startColumn && sfEndCol <= endColumn)
281		{
282	0	bs.set(sfEndCol - 1);
283		}
284	0	continue;
285		}
286
287		/*
288		* contiguous feature - select feature positions (if any)
289		* within the selected region
290		*/
291	0	if (sfStartCol < startColumn)
292		{
293	0	sfStartCol = startColumn;
294		}
295		// not sure what the point of this is
296		// if (sfStartCol < ist)
297		// {
298		// sfStartCol = ist;
299		// }
300	0	if (sfEndCol > endColumn)
301		{
302	0	sfEndCol = endColumn;
303		}
304	0	for (; sfStartCol <= sfEndCol; sfStartCol++)
305		{
306	0	bs.set(sfStartCol - 1); // convert to base 0
307		}
308		}
309		}
310		}
311	0	return nseq;
312		}
313
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
314	0	@Override...
315		public void sortAlignmentByFeatureDensity(List<String> typ)
316		{
317	0	String methodText = MessageManager.getString("label.sort_by_density");
318	0	sortByFeatures(typ, methodText, AlignmentSorter.FEATURE_DENSITY);
319		}
320
321		/**
322		* Sorts the alignment (or current selection) by either average score or
323		* density of the specified feature types, and adds to the command history. If
324		* {@code types} is null, all visible feature types are used for the sort. If
325		* no feature types apply, does nothing.
326		*
327		* @param types
328		* @param methodText
329		* - text shown in Undo/Redo command
330		* @param method
331		* - passed to jalview.analysis.AlignmentSorter.sortByFeatures()
332		*/
		0% Uncovered Elements: 28 (28) Complexity: 6 Complexity Density: 0.3
333	0	protected void sortByFeatures(List<String> types, String methodText,...
334		final String method)
335		{
336	0	FeatureRenderer fr = alignPanel.getFeatureRenderer();
337	0	if (types == null && fr != null)
338		{
339	0	types = fr.getDisplayedFeatureTypes();
340		}
341	0	if (types.isEmpty())
342		{
343	0	return; // nothing to do
344		}
345	0	List<String> gps = null;
346	0	if (fr != null)
347		{
348	0	gps = fr.getDisplayedFeatureGroups();
349		}
350	0	AlignmentI al = viewport.getAlignment();
351
352	0	int start, stop;
353	0	SequenceGroup sg = viewport.getSelectionGroup();
354	0	if (sg != null)
355		{
356	0	start = sg.getStartRes();
357	0	stop = sg.getEndRes();
358		}
359		else
360		{
361	0	start = 0;
362	0	stop = al.getWidth();
363		}
364	0	SequenceI[] oldOrder = al.getSequencesArray();
365	0	AlignmentSorter.sortByFeature(types, gps, start, stop, al, method);
366	0	avcg.addHistoryItem(new OrderCommand(methodText, oldOrder,
367		viewport.getAlignment()));
368	0	alignPanel.paintAlignment(true, false);
369
370		}
371
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
372	0	@Override...
373		public void sortAlignmentByFeatureScore(List<String> typ)
374		{
375	0	String methodText = MessageManager.getString("label.sort_by_score");
376	0	sortByFeatures(typ, methodText, AlignmentSorter.FEATURE_SCORE);
377		}
378
		0% Uncovered Elements: 19 (19) Complexity: 5 Complexity Density: 0.38
379	0	@Override...
380		public boolean parseFeaturesFile(Object file, DataSourceType protocol,
381		boolean relaxedIdMatching)
382		{
383	0	boolean featuresAdded = false;
384	0	FeatureRenderer fr = alignPanel.getFeatureRenderer();
385	0	try
386		{
387	0	featuresAdded = new FeaturesFile(false, file, protocol).parse(
388		viewport.getAlignment().getDataset(), fr.getFeatureColours(),
389		fr.getFeatureFilters(), false, relaxedIdMatching);
390		} catch (Exception ex)
391		{
392	0	ex.printStackTrace();
393		}
394
395	0	if (featuresAdded)
396		{
397	0	avcg.refreshFeatureUI(true);
398	0	if (fr != null)
399		{
400		// update the min/max ranges where necessary
401	0	fr.findAllFeatures(true);
402		}
403	0	if (avcg.getFeatureSettingsUI() != null)
404		{
405	0	avcg.getFeatureSettingsUI().discoverAllFeatureData();
406		}
407	0	alignPanel.paintAlignment(true, true);
408		}
409
410	0	return featuresAdded;
411
412		}
413
		0% Uncovered Elements: 39 (39) Complexity: 12 Complexity Density: 0.57
414	0	@Override...
415		public boolean markHighlightedColumns(boolean invert,
416		boolean extendCurrent, boolean toggle)
417		{
418	0	if (!viewport.hasSearchResults())
419		{
420		// do nothing if no selection exists
421	0	return false;
422		}
423		// JBPNote this routine could also mark rows, not just columns.
424	0	BitSet bs = new BitSet();
425	0	SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null
426		|| extendCurrent) ? viewport.getAlignment()
427		: viewport.getSelectionGroup();
428
429		// this could be a lambda... - the remains of the method is boilerplate,
430		// except for the different messages for reporting selection.
431	0	int nseq = viewport.getSearchResults().markColumns(sqcol, bs);
432
433	0	ColumnSelection cs = viewport.getColumnSelection();
434	0	if (cs == null)
435		{
436	0	cs = new ColumnSelection();
437		}
438
439	0	if (bs.cardinality() > 0 || invert)
440		{
441	0	boolean changed = cs.markColumns(bs, sqcol.getStartRes(),
442		sqcol.getEndRes(), invert, extendCurrent, toggle);
443	0	if (changed)
444		{
445	0	viewport.setColumnSelection(cs);
446	0	alignPanel.paintAlignment(false, false);
447	0	int columnCount = invert
448		? (sqcol.getEndRes() - sqcol.getStartRes() + 1)
449		- bs.cardinality()
450		: bs.cardinality();
451	0	avcg.setStatus(MessageManager.formatMessage(
452		"label.view_controller_toggled_marked", new String[]
453	0	{ toggle ? MessageManager.getString("label.toggled")
454		: MessageManager.getString("label.marked"),
455		String.valueOf(columnCount),
456	0	invert ? MessageManager
457		.getString("label.not_containing")
458		: MessageManager.getString("label.containing"),
459		"Highlight", Integer.valueOf(nseq).toString() }));
460	0	return true;
461		}
462		}
463		else
464		{
465	0	avcg.setStatus(MessageManager
466		.getString("label.no_highlighted_regions_marked"));
467	0	if (!extendCurrent)
468		{
469	0	cs.clear();
470	0	alignPanel.paintAlignment(false, false);
471		}
472		}
473	0	return false;
474		}
475
		0% Uncovered Elements: 13 (13) Complexity: 3 Complexity Density: 0.33
476	0	@Override...
477		public boolean copyHighlightedRegionsToClipboard()
478		{
479	0	if (!viewport.hasSearchResults())
480		{
481		// do nothing if no selection exists
482	0	return false;
483		}
484
485	0	SearchResultsI searchResults = viewport.getSearchResults();
486	0	if (searchResults.isEmpty())
487		{
488	0	return false; // shouldn't happen
489		}
490	0	List<SequenceI> seqs = searchResults.getMatchingSubSequences();
491
492		// TODO: pass in hiddenColumns according to intersection of searchResults
493		// and visible columns. Currently this isn't done, since each contig becomes
494		// a single subsequence
495	0	Desktop.jalviewClipboard = new Object[] {
496		seqs.toArray(new SequenceI[0]),
497		alignPanel.getAlignment().getDataset(), null };
498	0	avcg.setStatus(MessageManager.formatMessage(
499		"label.copied_sequences_to_clipboard", seqs.size()));
500		// Technically we should return false, since view has not changed
501	0	return false;
502		}
503
		0% Uncovered Elements: 24 (24) Complexity: 4 Complexity Density: 0.22
504	0	@Override...
505		public boolean justify_Region(boolean left)
506		{
507	0	AlignmentI al = viewport.getAlignment();
508	0	SequenceGroup reg = viewport.getSelectionGroup();
509	0	int from, to;
510	0	List<SequenceI> seqs;
511
512	0	from = 0;
513	0	to = al.getWidth() - 1;
514	0	seqs = al.getSequences();
515	0	if (reg != null)
516		{
517	0	seqs = reg.getSequences();
518	0	from = reg.getStartRes();
519	0	to = reg.getEndRes();
520		}
521
522	0	if ((to - from) < 1)
523		{
524	0	return false;
525		}
526
527	0	al.padGaps();
528	0	jalview.commands.JustifyLeftOrRightCommand finalEdit = new jalview.commands.JustifyLeftOrRightCommand(
529	0	"Justify " + (left ? "Left" : "Right"), left, seqs, from, to,
530		al);
531	0	avcg.addHistoryItem(finalEdit);
532	0	viewport.notifyAlignmentChanged();
533	0	return true;
534		}
535		}