001: /*
002: The contents of this file are subject to the Common Public Attribution License
003: Version 1.0 (the "License"); you may not use this file except in compliance with
004: the License. You may obtain a copy of the License at
005: http://www.projity.com/license . The License is based on the Mozilla Public
006: License Version 1.1 but Sections 14 and 15 have been added to cover use of
007: software over a computer network and provide for limited attribution for the
008: Original Developer. In addition, Exhibit A has been modified to be consistent
009: with Exhibit B.
010:
011: Software distributed under the License is distributed on an "AS IS" basis,
012: WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the
013: specific language governing rights and limitations under the License. The
014: Original Code is OpenProj. The Original Developer is the Initial Developer and
015: is Projity, Inc. All portions of the code written by Projity are Copyright (c)
016: 2006, 2007. All Rights Reserved. Contributors Projity, Inc.
017:
018: Alternatively, the contents of this file may be used under the terms of the
019: Projity End-User License Agreeement (the Projity License), in which case the
020: provisions of the Projity License are applicable instead of those above. If you
021: wish to allow use of your version of this file only under the terms of the
022: Projity License and not to allow others to use your version of this file under
023: the CPAL, indicate your decision by deleting the provisions above and replace
024: them with the notice and other provisions required by the Projity License. If
025: you do not delete the provisions above, a recipient may use your version of this
026: file under either the CPAL or the Projity License.
027:
028: [NOTE: The text of this license may differ slightly from the text of the notices
029: in Exhibits A and B of the license at http://www.projity.com/license. You should
030: use the latest text at http://www.projity.com/license for your modifications.
031: You may not remove this license text from the source files.]
032:
033: Attribution Information: Attribution Copyright Notice: Copyright © 2006, 2007
034: Projity, Inc. Attribution Phrase (not exceeding 10 words): Powered by OpenProj,
035: an open source solution from Projity. Attribution URL: http://www.projity.com
036: Graphic Image as provided in the Covered Code as file: openproj_logo.png with
037: alternatives listed on http://www.projity.com/logo
038:
039: Display of Attribution Information is required in Larger Works which are defined
040: in the CPAL as a work which combines Covered Code or portions thereof with code
041: not governed by the terms of the CPAL. However, in addition to the other notice
042: obligations, all copies of the Covered Code in Executable and Source Code form
043: distributed must, as a form of attribution of the original author, include on
044: each user interface screen the "OpenProj" logo visible to all users. The
045: OpenProj logo should be located horizontally aligned with the menu bar and left
046: justified on the top left of the screen adjacent to the File menu. The logo
047: must be at least 100 x 25 pixels. When users click on the "OpenProj" logo it
048: must direct them back to http://www.projity.com.
049: */
050: package com.projity.grouping.core.transform;
051:
052: import java.util.ArrayList;
053: import java.util.EventListener;
054: import java.util.List;
055: import java.util.StringTokenizer;
056:
057: import javax.swing.event.EventListenerList;
058:
059: import org.apache.commons.collections.Closure;
060:
061: import com.projity.grouping.core.transform.filtering.NodeFilter;
062: import com.projity.grouping.core.transform.grouping.NodeGrouper;
063: import com.projity.grouping.core.transform.sorting.NodeSorter;
064: import com.projity.grouping.core.transform.transformer.NodeTransformer;
065:
066: /**
067: *
068: */
069: public class ViewTransformer {
070: public static final String FILTER_NONE_ID = "Filter.None";
071: public static final String SORTER_NONE_ID = "Sorter.None";
072: public static final String GROUPER_NONE_ID = "Grouper.None";
073:
074: protected List filters = null;
075: protected List sorters = null;
076: protected List groupers = null;
077:
078: protected NodeFilter hiddenFilter;
079: protected NodeFilter userFilter;
080: protected NodeSorter hiddenSorter;
081: protected NodeTransformer transformer;
082: protected NodeSorter userSorter;
083: protected NodeGrouper hiddenGrouper;
084: protected NodeGrouper userGrouper;
085:
086: protected String hiddenFilterId;
087: protected String userFilterId = FILTER_NONE_ID;
088: protected String hiddenSorterId;
089: protected String userSorterId = SORTER_NONE_ID;
090: protected String hiddenGrouperId;
091: protected String userGrouperId = GROUPER_NONE_ID;
092: protected String transformerId;
093:
094: protected boolean hiddenFilterIdDirty = false;
095: protected boolean userFilterIdDirty = false;
096: protected boolean hiddenSorterIdDirty = false;
097: protected boolean userSorterIdDirty = false;
098: protected boolean hiddenGrouperIdDirty = false;
099: protected boolean userGrouperIdDirty = false;
100: protected boolean transformerIdDirty = false;
101:
102: public List getFilterList() {
103: return filters;
104: }
105:
106: public void setFilters(String slist) {
107: StringTokenizer st = new StringTokenizer(slist, ";, \t");
108: filters = new ArrayList();
109: while (st.hasMoreTokens())
110: filters.add(st.nextToken());
111: }
112:
113: public List getSorterList() {
114: return sorters;
115: }
116:
117: public void setSorters(String slist) {
118: StringTokenizer st = new StringTokenizer(slist, ";, \t");
119: sorters = new ArrayList();
120: while (st.hasMoreTokens())
121: sorters.add(st.nextToken());
122: }
123:
124: public List getGrouperList() {
125: return groupers;
126: }
127:
128: public void setGroupers(String slist) {
129: StringTokenizer st = new StringTokenizer(slist, ";, \t");
130: groupers = new ArrayList();
131: while (st.hasMoreTokens())
132: groupers.add(st.nextToken());
133: }
134:
135: private Closure redefinition = new Closure() {
136: public void execute(Object o) {
137: fireTransformerChanged(o);
138: }
139: };
140:
141: public void setFilterId(TransformId id) {
142: if (id.isHidden()) {
143: hiddenFilterId = id.getId();
144: hiddenFilterIdDirty = true;
145: } else {
146: userFilterId = id.getId();
147: userFilterIdDirty = true;
148: }
149: }
150:
151: public void setSorterId(TransformId id) {
152: if (id.isHidden()) {
153: hiddenSorterId = id.getId();
154: hiddenSorterIdDirty = true;
155: } else {
156: userSorterId = id.getId();
157: userSorterIdDirty = true;
158: }
159: }
160:
161: public void setGrouperId(TransformId id) {
162: if (id.isHidden()) {
163: hiddenGrouperId = id.getId();
164: hiddenGrouperIdDirty = true;
165: } else {
166: userGrouperId = id.getId();
167: userGrouperIdDirty = true;
168: }
169: }
170:
171: public void setTransformerId(TransformId id) {
172: transformerId = id.getId();
173: transformerIdDirty = true;
174: }
175:
176: public String getHiddenFilterId() {
177: return hiddenFilterId;
178: }
179:
180: public void setHiddenFilterId(String hiddenFilterId) {
181: this .hiddenFilterId = hiddenFilterId;
182: hiddenFilterIdDirty = true;
183: fireTransformerChanged(this );
184: }
185:
186: public String getHiddenGrouperId() {
187: return hiddenGrouperId;
188: }
189:
190: public void setHiddenGrouperId(String hiddenGrouperId) {
191: this .hiddenGrouperId = hiddenGrouperId;
192: hiddenGrouperIdDirty = true;
193: fireTransformerChanged(this );
194: }
195:
196: public String getHiddenSorterId() {
197: return hiddenSorterId;
198: }
199:
200: public void setHiddenSorterId(String hiddenSorterId) {
201: this .hiddenSorterId = hiddenSorterId;
202: hiddenSorterIdDirty = true;
203: fireTransformerChanged(this );
204: }
205:
206: public String getUserFilterId() {
207: return userFilterId;
208: }
209:
210: public void setUserFilterId(String userFilterId) {
211: this .userFilterId = userFilterId;
212: userFilterIdDirty = true;
213: fireTransformerChanged(this );
214: }
215:
216: public String getUserGrouperId() {
217: return userGrouperId;
218: }
219:
220: public void setUserGrouperId(String userGrouperId) {
221: this .userGrouperId = userGrouperId;
222: userGrouperIdDirty = true;
223: fireTransformerChanged(this );
224: }
225:
226: public String getUserSorterId() {
227: return userSorterId;
228: }
229:
230: public void setUserSorterId(String userSorterId) {
231: this .userSorterId = userSorterId;
232: userSorterIdDirty = true;
233: fireTransformerChanged(this );
234: }
235:
236: public String getTransformerId() {
237: return transformerId;
238: }
239:
240: public void setTransformerId(String transformerId) {
241: this .transformerId = transformerId;
242: transformerIdDirty = true;
243: fireTransformerChanged(this );
244: }
245:
246: public void update() {
247: fireTransformerChanged(this );
248: }
249:
250: private CommonTransform getTransform(String listName, String id) {
251: TransformList list = TransformList.getInstance(listName);
252: if (list == null)
253: return null;
254: CommonTransform transform = (CommonTransform) list
255: .getTransform(id);
256: if (transform != null)
257: transform.askForParameters();
258: return transform;
259: }
260:
261: public NodeFilter getHiddenFilter() {
262: if (hiddenFilterIdDirty) {
263: hiddenFilter = (NodeFilter) getTransform("hidden_filters",
264: hiddenFilterId);
265: hiddenFilter.setRedefinitionCallBack(redefinition);
266: hiddenFilterIdDirty = false;
267: }
268: return hiddenFilter;
269: }
270:
271: public void setHiddenFilter(NodeFilter hiddenFilter) {
272: this .hiddenFilter = hiddenFilter;
273: }
274:
275: public NodeGrouper getHiddenGrouper() {
276: if (hiddenGrouperIdDirty) {
277: hiddenGrouper = (NodeGrouper) getTransform(
278: "hidden_groupers", hiddenGrouperId);
279: hiddenGrouper.setRedefinitionCallBack(redefinition);
280: hiddenGrouperIdDirty = false;
281: }
282: return hiddenGrouper;
283: }
284:
285: public void setHiddenGrouper(NodeGrouper hiddenGrouper) {
286: this .hiddenGrouper = hiddenGrouper;
287: }
288:
289: public NodeSorter getHiddenSorter() {
290: if (hiddenSorterIdDirty) {
291: hiddenSorter = (NodeSorter) getTransform("hidden_sorters",
292: hiddenSorterId);
293: hiddenSorter.setRedefinitionCallBack(redefinition);
294: hiddenSorterIdDirty = false;
295: }
296: return hiddenSorter;
297: }
298:
299: public void setHiddenSorter(NodeSorter hiddenSorter) {
300: this .hiddenSorter = hiddenSorter;
301: }
302:
303: public NodeFilter getUserFilter() {
304: if (userFilterIdDirty) {
305: userFilter = (NodeFilter) getTransform("user_filters",
306: userFilterId);
307: userFilterIdDirty = false;
308: }
309: return userFilter;
310: }
311:
312: public void setUserFilter(NodeFilter userFilter) {
313: this .userFilter = userFilter;
314: }
315:
316: public NodeGrouper getUserGrouper() {
317: if (userGrouperIdDirty) {
318: userGrouper = (NodeGrouper) getTransform("user_groupers",
319: userGrouperId);
320: userGrouperIdDirty = false;
321: }
322: return userGrouper;
323: }
324:
325: public void setUserGrouper(NodeGrouper userGrouper) {
326: this .userGrouper = userGrouper;
327: }
328:
329: public NodeSorter getUserSorter() {
330: if (userSorterIdDirty) {
331: userSorter = (NodeSorter) getTransform("user_sorters",
332: userSorterId);
333: userSorterIdDirty = false;
334: }
335: return userSorter;
336: }
337:
338: public void setUserSorter(NodeSorter userSorter) {
339: this .userSorter = userSorter;
340: }
341:
342: public NodeTransformer getTransformer() {
343: if (transformerIdDirty) {
344: transformer = (NodeTransformer) getTransform(
345: "transformers", transformerId);
346: //hiddenFilter.setRedefinitionCallBack(redefinition);
347: transformerIdDirty = false;
348: }
349: return transformer;
350: }
351:
352: public void settransformer(NodeTransformer transformer) {
353: this .transformer = transformer;
354: }
355:
356: public boolean isShowSummary() {
357: if (!isShowSummary(getHiddenFilter()))
358: return false;
359: if (!isShowSummary(getUserFilter()))
360: return false;
361: if (!isShowSummary(getHiddenSorter()))
362: return false;
363: if (!isShowSummary(getUserSorter()))
364: return false;
365: if (!isShowSummary(getHiddenGrouper()))
366: return false;
367: if (!isShowSummary(getUserGrouper()))
368: return false;
369: return true;
370: }
371:
372: private boolean isShowSummary(CommonTransform t) {
373: return (t == null) ? true : t.isShowSummary();
374: }
375:
376: public boolean isPreserveHierarchy() {
377: if (!isPreserveHierarchy(getHiddenFilter()))
378: return false;
379: if (!isPreserveHierarchy(getUserFilter()))
380: return false;
381: if (!isPreserveHierarchy(getHiddenSorter()))
382: return false;
383: if (!isPreserveHierarchy(getUserSorter()))
384: return false;
385: if (!isPreserveHierarchy(getHiddenGrouper()))
386: return false;
387: if (!isPreserveHierarchy(getUserGrouper()))
388: return false;
389: return true;
390: }
391:
392: private boolean isPreserveHierarchy(CommonTransform t) {
393: return (t == null) ? true : t.isPreserveHierarchy();
394: }
395:
396: public boolean isShowAssignments() {
397: if (!isShowAssignments(getHiddenFilter()))
398: return false;
399: if (!isShowAssignments(getUserFilter()))
400: return false;
401: if (!isShowAssignments(getHiddenSorter()))
402: return false;
403: if (!isShowAssignments(getUserSorter()))
404: return false;
405: if (!isShowAssignments(getHiddenGrouper()))
406: return false;
407: if (!isShowAssignments(getUserGrouper()))
408: return false;
409: return true;
410: }
411:
412: private boolean isShowAssignments(CommonTransform t) {
413: return (t == null) ? true : t.isShowAssignments();
414: }
415:
416: public boolean isShowEmptyLines() {
417: if (!isNoneSorter())
418: return false;
419: if (!isNoneGrouper())
420: return false;
421: if (!isShowEmptyLines(getHiddenFilter()))
422: return false;
423: if (!isShowEmptyLines(getUserFilter()))
424: return false;
425: // if (!isShowEmptyLines(getHiddenSorter())) return false;
426: // if (!isShowEmptyLines(getUserSorter())) return false;
427: // if (!isShowEmptyLines(getHiddenGrouper())) return false;
428: // if (!isShowEmptyLines(getUserGrouper())) return false;
429: return true;
430: }
431:
432: private boolean isShowEmptyLines(CommonTransform t) {
433: return (t == null) ? true : t.isShowEmptyLines();
434: }
435:
436: public boolean isShowEndEmptyLines() {
437: if (!isNoneSorter())
438: return false;
439: if (!isNoneGrouper())
440: return false;
441: if (!isShowEndEmptyLines(getHiddenFilter()))
442: return false;
443: if (!isShowEndEmptyLines(getUserFilter()))
444: return false;
445: // if (!isShowEndEmptyLines(getHiddenSorter())) return false;
446: // if (!isShowEndEmptyLines(getUserSorter())) return false;
447: return true;
448: }
449:
450: private boolean isShowEndEmptyLines(CommonTransform t) {
451: return (t == null) ? true : t.isShowEndEmptyLines();
452: }
453:
454: public boolean isShowEmptySummaries() {
455: if (!isShowEmptySummaries(getHiddenFilter()))
456: return false;
457: if (!isShowEmptySummaries(getUserFilter()))
458: return false;
459: // if (!isShowEmptyLines(getHiddenSorter())) return false;
460: // if (!isShowEmptyLines(getUserSorter())) return false;
461: // if (!isShowEmptyLines(getHiddenGrouper())) return false;
462: // if (!isShowEmptyLines(getUserGrouper())) return false;
463: return true;
464: }
465:
466: private boolean isShowEmptySummaries(CommonTransform t) {
467: return (t == null) ? true : t.isShowEmptySummaries();
468: }
469:
470: public boolean isTreatAssignmentsAsTasks() {
471: return false;
472: }
473:
474: public boolean isNoneFilter() {
475: return userFilterId == null
476: || FILTER_NONE_ID.equals(userFilterId);
477: }
478:
479: public boolean isNoneSorter() {
480: return userSorterId == null
481: || SORTER_NONE_ID.equals(userSorterId);
482: }
483:
484: public boolean isNoneGrouper() {
485: return userGrouperId == null
486: || GROUPER_NONE_ID.equals(userGrouperId);
487: }
488:
489: protected EventListenerList listenerList = new EventListenerList();
490:
491: public void addViewTransformerListener(ViewTransformerListener l) {
492: listenerList.add(ViewTransformerListener.class, l);
493: }
494:
495: public void removeViewTransformerListener(ViewTransformerListener l) {
496: listenerList.remove(ViewTransformerListener.class, l);
497: }
498:
499: public ViewTransformerListener[] getTimeScaleListeners() {
500: return (ViewTransformerListener[]) listenerList
501: .getListeners(ViewTransformerListener.class);
502: }
503:
504: protected void fireTransformerChanged(Object source) {
505: Object[] listeners = listenerList.getListenerList();
506: ViewTransformerEvent e = null;
507: for (int i = listeners.length - 2; i >= 0; i -= 2) {
508: if (listeners[i] == ViewTransformerListener.class) {
509: if (e == null) {
510: e = new ViewTransformerEvent(source);
511: }
512: ((ViewTransformerListener) listeners[i + 1])
513: .transformerChanged(e);
514: }
515: }
516: }
517:
518: public EventListener[] getListeners(Class listenerType) {
519: return listenerList.getListeners(listenerType);
520: }
521:
522: }
|