001: package org.enhydra.shark.swingclient.workflowadmin;
002:
003: import java.awt.BorderLayout;
004: import java.awt.Component;
005: import java.awt.Container;
006: import java.awt.event.ActionEvent;
007: import java.awt.event.ActionListener;
008: import java.awt.event.KeyEvent;
009: import java.util.ArrayList;
010: import java.util.Arrays;
011: import java.util.List;
012:
013: import javax.swing.AbstractAction;
014: import javax.swing.Action;
015: import javax.swing.ImageIcon;
016: import javax.swing.JButton;
017: import javax.swing.JComponent;
018: import javax.swing.JDialog;
019: import javax.swing.JEditorPane;
020: import javax.swing.JFrame;
021: import javax.swing.JOptionPane;
022: import javax.swing.JPanel;
023: import javax.swing.JScrollPane;
024: import javax.swing.JTabbedPane;
025: import javax.swing.KeyStroke;
026: import javax.swing.ScrollPaneConstants;
027: import javax.transaction.Status;
028: import javax.transaction.UserTransaction;
029:
030: import org.enhydra.shark.api.admin.UserGroupManagerAdmin;
031: import org.enhydra.shark.client.utilities.DeadlineChecker;
032: import org.enhydra.shark.client.utilities.SharkInterfaceWrapper;
033: import org.enhydra.shark.swingclient.ResourceManager;
034: import org.enhydra.shark.swingclient.SharkClient;
035: import org.enhydra.shark.swingclient.Utils;
036: import org.enhydra.shark.swingclient.workflowadmin.application.ApplicationMappingManagement;
037: import org.enhydra.shark.swingclient.workflowadmin.cache.CacheManagement;
038: import org.enhydra.shark.swingclient.workflowadmin.definition.PackageManagement;
039: import org.enhydra.shark.swingclient.workflowadmin.instantiation.ProcessInstantiationManagement;
040: import org.enhydra.shark.swingclient.workflowadmin.monitoring.ProcessMonitor;
041: import org.enhydra.shark.swingclient.workflowadmin.processlist.ProcesslistManagement;
042: import org.enhydra.shark.swingclient.workflowadmin.repository.RepositoryManagement;
043: import org.enhydra.shark.swingclient.workflowadmin.user.UserManagement;
044: import org.enhydra.shark.swingclient.workflowadmin.worklist.WorklistManagement;
045:
046: /**
047: * Application for administering shark engine.
048: *
049: * @author Sasa Bojanic
050: */
051: public class SharkAdmin extends SharkClient {
052:
053: protected JTabbedPane tabbedPane;
054:
055: protected EngineTreeModel engineTreeModel;
056:
057: protected RepositoryManagement repositoryManagement;
058:
059: protected PackageManagement packageManagement;
060:
061: protected ProcessInstantiationManagement processInstantiationManagement;
062:
063: protected ProcessMonitor processMonitor;
064:
065: protected UserManagement userManagement;
066:
067: protected ApplicationMappingManagement applicationMapping;
068:
069: protected CacheManagement cacheManagement;
070:
071: protected WorklistManagement worklistManagement;
072:
073: protected ProcesslistManagement processlistManagement;
074:
075: protected DeadlineChecker deadlineChecker;
076:
077: protected long deadlineCheckingTime = 30000;
078:
079: // ************************** CONSTRUCTOR ***************************
080: /** Creates instance of main application class. */
081: public SharkAdmin(JFrame frame) {
082: super (frame);
083: }
084:
085: protected void collectTabPermissions() {
086: String groupStr = SharkInterfaceWrapper.getProperties()
087: .getProperty("RepositoryManagement.GroupPermission",
088: "admin");
089: String[] groups = Utils.tokenize(groupStr, ",");
090: tabPermissions.put("RepositoryManagement", Arrays
091: .asList(groups));
092:
093: groupStr = SharkInterfaceWrapper.getProperties().getProperty(
094: "PackageManagement.GroupPermission", "admin");
095: groups = Utils.tokenize(groupStr, ",");
096: tabPermissions.put("PackageManagement", Arrays.asList(groups));
097:
098: groupStr = SharkInterfaceWrapper.getProperties().getProperty(
099: "ProcessInstantiationManagement.GroupPermission",
100: "admin");
101: groups = Utils.tokenize(groupStr, ",");
102: tabPermissions.put("ProcessInstantiationManagement", Arrays
103: .asList(groups));
104:
105: groupStr = SharkInterfaceWrapper.getProperties().getProperty(
106: "ProcessMonitor.GroupPermission", "admin");
107: groups = Utils.tokenize(groupStr, ",");
108: tabPermissions.put("ProcessMonitor", Arrays.asList(groups));
109:
110: groupStr = SharkInterfaceWrapper.getProperties().getProperty(
111: "UserManagement.GroupPermission", "admin");
112: groups = Utils.tokenize(groupStr, ",");
113: tabPermissions.put("UserManagement", Arrays.asList(groups));
114:
115: groupStr = SharkInterfaceWrapper.getProperties()
116: .getProperty(
117: "ApplicationMappingManagement.GroupPermission",
118: "admin");
119: groups = Utils.tokenize(groupStr, ",");
120: tabPermissions.put("ApplicationMappingManagement", Arrays
121: .asList(groups));
122:
123: groupStr = SharkInterfaceWrapper.getProperties().getProperty(
124: "CacheManagement.GroupPermission", "admin");
125: groups = Utils.tokenize(groupStr, ",");
126: tabPermissions.put("CacheManagement", Arrays.asList(groups));
127:
128: groupStr = SharkInterfaceWrapper.getProperties().getProperty(
129: "WorklistManagement.GroupPermission", "admin,allusers");
130: groups = Utils.tokenize(groupStr, ",");
131: tabPermissions.put("WorklistManagement", Arrays.asList(groups));
132:
133: groupStr = SharkInterfaceWrapper.getProperties().getProperty(
134: "WorklistManagement.SelectUser.GroupPermission",
135: "admin");
136: groups = Utils.tokenize(groupStr, ",");
137: tabPermissions.put("WorklistManagement.SelectUser", Arrays
138: .asList(groups));
139:
140: groupStr = SharkInterfaceWrapper.getProperties().getProperty(
141: "ProcesslistManagement.GroupPermission",
142: "admin,allusers");
143: groups = Utils.tokenize(groupStr, ",");
144: tabPermissions.put("ProcesslistManagement", Arrays
145: .asList(groups));
146:
147: groupStr = SharkInterfaceWrapper.getProperties().getProperty(
148: "ProcesslistManagement.SelectUser.GroupPermission",
149: "admin");
150: groups = Utils.tokenize(groupStr, ",");
151: tabPermissions.put("ProcesslistManagement.SelectUser", Arrays
152: .asList(groups));
153:
154: }
155:
156: // ************************* END OF WORKFLOWADMIN CONSTRUCTOR ********
157:
158: protected void createActions() {
159: super .createActions();
160:
161: List actions = Utils.getActions("SharkAdminActions",
162: "org.enhydra.shark.swingclient.workflowadmin.actions",
163: SharkAdmin.class, this );
164:
165: if (actions.size() > 0) {
166: Action[] newActions = new Action[defaultActions.length
167: + actions.size()];
168: System.arraycopy(defaultActions, 0, newActions, 0,
169: defaultActions.length);
170: for (int i = 0; i < actions.size(); i++) {
171: newActions[defaultActions.length + i] = (Action) actions
172: .get(i);
173: }
174: defaultActions = newActions;
175: }
176:
177: }
178:
179: protected Component createCenterComponent() {
180: // creating tabbed panel
181: tabbedPane = new JTabbedPane();
182: String cls = null;
183: try {
184: String defCl = "org.enhydra.shark.swingclient.workflowadmin.EngineTreeModelImpl";
185: if (getAdminVersion() != COMMUNITY_VERSION) {
186: defCl += "Ext";
187: }
188: cls = SharkInterfaceWrapper.getProperties().getProperty(
189: "EngineTreeModel.Class", defCl);
190: engineTreeModel = (EngineTreeModel) Class.forName(cls)
191: .getConstructor(new Class[] { SharkAdmin.class })
192: .newInstance(new Object[] { this });
193: } catch (Exception ex) {
194: }
195: try {
196: String defCl = "org.enhydra.shark.swingclient.workflowadmin.repository.RepositoryManagementImpl";
197: cls = SharkInterfaceWrapper.getProperties().getProperty(
198: "RepositoryManagement.Class", defCl);
199: repositoryManagement = (RepositoryManagement) Class
200: .forName(cls).getConstructor(
201: new Class[] { SharkAdmin.class })
202: .newInstance(new Object[] { this });
203: if (repositoryManagement != null) {
204: tabbedPane
205: .addTab(
206: ResourceManager
207: .getLanguageDependentString("RepositoryManagementKey"),
208: repositoryManagement);
209: }
210: } catch (Exception ex) {
211: }
212: try {
213: String defCl = "org.enhydra.shark.swingclient.workflowadmin.definition.PackageManagementImpl";
214: cls = SharkInterfaceWrapper.getProperties().getProperty(
215: "PackageManagement.Class", defCl);
216: packageManagement = (PackageManagement) Class.forName(cls)
217: .getConstructor(new Class[] { SharkAdmin.class })
218: .newInstance(new Object[] { this });
219: if (packageManagement != null) {
220: tabbedPane
221: .addTab(
222: ResourceManager
223: .getLanguageDependentString("PackageManagementKey"),
224: packageManagement);
225: }
226: } catch (Exception ex) {
227: }
228: if (engineTreeModel != null) {
229: try {
230: String defCl = "org.enhydra.shark.swingclient.workflowadmin.instantiation.ProcessInstantiationManagementImpl";
231: if (getAdminVersion() != COMMUNITY_VERSION) {
232: defCl += "Ext";
233: }
234: cls = SharkInterfaceWrapper.getProperties()
235: .getProperty(
236: "ProcessInstantiationManagement.Class",
237: defCl);
238: processInstantiationManagement = (ProcessInstantiationManagement) Class
239: .forName(cls).getConstructor(
240: new Class[] { SharkAdmin.class })
241: .newInstance(new Object[] { this });
242: if (processInstantiationManagement != null) {
243: tabbedPane
244: .addTab(
245: ResourceManager
246: .getLanguageDependentString("ProcessInstantiationManagementKey"),
247: processInstantiationManagement);
248: }
249: } catch (Exception ex) {
250: }
251:
252: try {
253: String defCl = "org.enhydra.shark.swingclient.workflowadmin.monitoring.ProcessMonitorImpl";
254: if (getAdminVersion() != COMMUNITY_VERSION) {
255: defCl += "Ext";
256: }
257: cls = SharkInterfaceWrapper.getProperties()
258: .getProperty("ProcessMonitor.Class", defCl);
259: processMonitor = (ProcessMonitor) Class.forName(cls)
260: .getConstructor(
261: new Class[] { SharkAdmin.class })
262: .newInstance(new Object[] { this });
263: if (processMonitor != null) {
264: tabbedPane
265: .addTab(
266: ResourceManager
267: .getLanguageDependentString("ProcessMonitorKey"),
268: processMonitor);
269: }
270: } catch (Exception ex) {
271: }
272: }
273: try {
274: String defCl = "org.enhydra.shark.swingclient.workflowadmin.user.UserManagementImpl";
275: cls = SharkInterfaceWrapper.getProperties().getProperty(
276: "UserManagement.Class", defCl);
277: userManagement = (UserManagement) Class.forName(cls)
278: .getConstructor(new Class[] { SharkAdmin.class })
279: .newInstance(new Object[] { this });
280: if (userManagement != null) {
281: tabbedPane
282: .addTab(
283: ResourceManager
284: .getLanguageDependentString("UserManagementKey"),
285: userManagement);
286: }
287: } catch (Exception ex) {
288: }
289: try {
290: String defCl = "org.enhydra.shark.swingclient.workflowadmin.application.ApplicationMappingManagementImpl";
291: cls = SharkInterfaceWrapper.getProperties().getProperty(
292: "ApplicationMappingManagement.Class", defCl);
293: applicationMapping = (ApplicationMappingManagement) Class
294: .forName(cls).getConstructor(
295: new Class[] { SharkAdmin.class })
296: .newInstance(new Object[] { this });
297:
298: if (applicationMapping != null) {
299: tabbedPane
300: .addTab(
301: ResourceManager
302: .getLanguageDependentString("ApplicationMappingKey"),
303: applicationMapping);
304: }
305: } catch (Exception ex) {
306: }
307: try {
308: String defCl = "org.enhydra.shark.swingclient.workflowadmin.cache.CacheManagementImpl";
309: cls = SharkInterfaceWrapper.getProperties().getProperty(
310: "CacheManagement.Class", defCl);
311: cacheManagement = (CacheManagement) Class.forName(cls)
312: .getConstructor(new Class[] { SharkAdmin.class })
313: .newInstance(new Object[] { this });
314: if (cacheManagement != null) {
315: tabbedPane
316: .addTab(
317: ResourceManager
318: .getLanguageDependentString("CacheManagementKey"),
319: cacheManagement);
320: }
321: } catch (Exception ex) {
322: }
323: try {
324: String defCl = "org.enhydra.shark.swingclient.workflowadmin.worklist.WorklistManagementImpl";
325: cls = SharkInterfaceWrapper.getProperties().getProperty(
326: "WorklistManagement.Class", defCl);
327: worklistManagement = (WorklistManagement) Class
328: .forName(cls).getConstructor(
329: new Class[] { SharkAdmin.class })
330: .newInstance(new Object[] { this });
331: if (worklistManagement != null) {
332: tabbedPane
333: .addTab(
334: ResourceManager
335: .getLanguageDependentString("WorklistManagementKey"),
336: worklistManagement);
337: }
338: } catch (Exception ex) {
339: }
340:
341: try {
342: String defCl = "org.enhydra.shark.swingclient.workflowadmin.processlist.ProcesslistManagementImpl";
343: cls = SharkInterfaceWrapper.getProperties().getProperty(
344: "ProcesslistManagement.Class", defCl);
345: processlistManagement = (ProcesslistManagement) Class
346: .forName(cls).getConstructor(
347: new Class[] { SharkAdmin.class })
348: .newInstance(new Object[] { this });
349: if (processlistManagement != null) {
350: tabbedPane
351: .addTab(
352: ResourceManager
353: .getLanguageDependentString("ProcesslistManagementKey"),
354: processlistManagement);
355: }
356: } catch (Exception ex) {
357: }
358:
359: tabbedPane.setVisible(false);
360:
361: collectTabPermissions();
362: return tabbedPane;
363: }
364:
365: /**
366: * The order of refreshment is important, first the engine tree model has to be
367: * refreshed. Also, the method must be synchronized because other instances uses
368: * EngineTreeModel.getRemovedAfterRefresh() and EngineTreeModel.getAddedAfterRefresh()
369: * methods
370: */
371: public synchronized void refresh(boolean mandatoryRefreshing) {
372: tabbedPane.setVisible(true);
373: UserTransaction ut = null;
374: try {
375: ut = SharkInterfaceWrapper.getUserTransaction();
376: } catch (Exception ex) {
377: }
378: try {
379: ut.begin();
380: if (engineTreeModel != null) {
381: engineTreeModel.refresh(mandatoryRefreshing, true);
382: }
383: if (packageManagement != null) {
384: packageManagement.refresh(mandatoryRefreshing);
385: }
386: ut.commit();
387: } catch (Exception ex) {
388: try {
389: if (ut.getStatus() != Status.STATUS_NO_TRANSACTION) {
390: ut.rollback();
391: }
392: } catch (Exception _) {
393:
394: }
395: }
396:
397: try {
398: ut.begin();
399: if (processInstantiationManagement != null) {
400: processInstantiationManagement
401: .refresh(mandatoryRefreshing);
402: }
403: if (processMonitor != null) {
404: processMonitor.refresh(mandatoryRefreshing);
405: }
406: if (worklistManagement != null) {
407: worklistManagement.refresh(mandatoryRefreshing);
408: }
409: if (processlistManagement != null) {
410: processlistManagement.refresh(mandatoryRefreshing);
411: }
412: ut.commit();
413: } catch (Exception ex) {
414: try {
415: if (ut.getStatus() != Status.STATUS_NO_TRANSACTION) {
416: ut.rollback();
417: }
418: } catch (Exception _) {
419:
420: }
421: }
422:
423: try {
424: ut.begin();
425: if (repositoryManagement != null) {
426: repositoryManagement.refresh(mandatoryRefreshing);
427: }
428: ut.commit();
429: } catch (Exception ex) {
430: try {
431: if (ut.getStatus() != Status.STATUS_NO_TRANSACTION) {
432: ut.rollback();
433: }
434: } catch (Exception _) {
435:
436: }
437: }
438:
439: try {
440: ut.begin();
441: if (userManagement != null) {
442: userManagement.refresh(mandatoryRefreshing);
443: }
444: ut.commit();
445: } catch (Exception ex) {
446: try {
447: if (ut.getStatus() != Status.STATUS_NO_TRANSACTION) {
448: ut.rollback();
449: }
450: } catch (Exception _) {
451:
452: }
453: }
454:
455: try {
456: ut.begin();
457: if (applicationMapping != null) {
458: applicationMapping.refresh(mandatoryRefreshing);
459: }
460: ut.commit();
461: } catch (Exception ex) {
462: try {
463: if (ut.getStatus() != Status.STATUS_NO_TRANSACTION) {
464: ut.rollback();
465: }
466: } catch (Exception _) {
467:
468: }
469: }
470:
471: try {
472: ut.begin();
473: if (cacheManagement != null) {
474: cacheManagement.refresh(mandatoryRefreshing);
475: }
476: ut.commit();
477: } catch (Exception ex) {
478: try {
479: if (ut.getStatus() != Status.STATUS_NO_TRANSACTION) {
480: ut.rollback();
481: }
482: } catch (Exception _) {
483:
484: }
485: }
486:
487: }
488:
489: /**
490: * The order of clearing is important, first the engine tree model has to be cleared.
491: */
492: public void clearComponents() {
493: try {
494: myFrame.setTitle(appTitle
495: + " - "
496: + ResourceManager
497: .getLanguageDependentString("NoneKey"));
498: tabbedPane.setVisible(false);
499: tabbedPane.setSelectedIndex(0);
500: stopRefresher();
501: // THIS IS PRECAUTION - the thread that refreshes admin can be
502: // running, so we wait until the refresher thread finishs its
503: // work, and then we clear the components
504: while (isRefresherActive()) {
505: }
506: if (engineTreeModel != null) {
507: engineTreeModel.clear();
508: }
509: if (repositoryManagement != null) {
510: repositoryManagement.clear();
511: }
512: if (packageManagement != null) {
513: packageManagement.clear();
514: }
515: if (processInstantiationManagement != null) {
516: processInstantiationManagement.clear();
517: }
518: if (processMonitor != null) {
519: processMonitor.clear();
520: }
521: if (userManagement != null) {
522: userManagement.clear();
523: }
524: if (applicationMapping != null) {
525: applicationMapping.clear();
526: }
527: if (cacheManagement != null) {
528: cacheManagement.clear();
529: }
530: if (worklistManagement != null) {
531: worklistManagement.clear();
532: }
533: if (processlistManagement != null) {
534: processlistManagement.clear();
535: }
536: } catch (Exception ex) {
537: ex.printStackTrace();
538: }
539: }
540:
541: protected String getAppTitleResourceString() {
542: return "WorkflowAdminTitle";
543: }
544:
545: protected String getLogoResourceString() {
546: return "workflowadminLogo";
547: }
548:
549: protected String getIconResourceString() {
550: return "workflowadminIcon";
551: }
552:
553: protected String getMenubarResourceString() {
554: return "adminmainmenubar";
555: }
556:
557: protected String getRefreshingRateString() {
558: return "RefreshingRateInSecondsForWorkflowAdmin";
559: }
560:
561: public EngineTreeModel getEngineTreeModel() {
562: return engineTreeModel;
563: }
564:
565: public RepositoryManagement getRepositoryManagement() {
566: return repositoryManagement;
567: }
568:
569: public PackageManagement getPackageManagement() {
570: return packageManagement;
571: }
572:
573: public ProcessInstantiationManagement getProcessInstantiationManagement() {
574: return processInstantiationManagement;
575: }
576:
577: public ProcessMonitor getProcessMonitor() {
578: return processMonitor;
579: }
580:
581: public UserManagement getUserManagement() {
582: return userManagement;
583: }
584:
585: public ApplicationMappingManagement getApplicationMapping() {
586: return applicationMapping;
587: }
588:
589: public CacheManagement getCacheManagement() {
590: return cacheManagement;
591: }
592:
593: public WorklistManagement getWorklistManagement() {
594: return worklistManagement;
595: }
596:
597: public ProcesslistManagement getProcesslistManagement() {
598: return processlistManagement;
599: }
600:
601: public void enableControls(boolean enable) {
602: super .enableControls(enable);
603: tabbedPane.setEnabled(enable);
604: if (!enable) {
605: return;
606: }
607: boolean selLast = false;
608: boolean hasOnePerm = false;
609: boolean excHappened = false;
610: UserTransaction ut = null;
611: UserGroupManagerAdmin uga = SharkInterfaceWrapper
612: .getUserGroupAdmin();
613: if (uga != null) {
614: List groups = new ArrayList();
615: try {
616: ut = SharkInterfaceWrapper.getUserTransaction();
617: ut.begin();
618: groups.addAll(Arrays.asList(uga
619: .getAllGroupnamesForUser(getSessionHandle(),
620: username)));
621: ut.commit();
622: } catch (Exception ex) {
623: excHappened = true;
624: }
625: for (int i = 0; i < tabbedPane.getTabCount(); i++) {
626: Component c = tabbedPane.getComponentAt(i);
627: List l = null;
628: List l2 = null;
629: if (c instanceof RepositoryManagement) {
630: l = (List) tabPermissions
631: .get("RepositoryManagement");
632: } else if (c instanceof PackageManagement) {
633: l = (List) tabPermissions.get("PackageManagement");
634: } else if (c instanceof ProcessInstantiationManagement) {
635: l = (List) tabPermissions
636: .get("ProcessInstantiationManagement");
637: } else if (c instanceof ProcessMonitor) {
638: l = (List) tabPermissions.get("ProcessMonitor");
639: } else if (c instanceof UserManagement) {
640: l = (List) tabPermissions.get("UserManagement");
641: } else if (c instanceof ApplicationMappingManagement) {
642: l = (List) tabPermissions
643: .get("ApplicationMappingManagement");
644: } else if (c instanceof CacheManagement) {
645: l = (List) tabPermissions.get("CacheManagement");
646: } else if (c instanceof WorklistManagement) {
647: l = (List) tabPermissions.get("WorklistManagement");
648: l2 = (List) tabPermissions
649: .get("WorklistManagement.SelectUser");
650: } else if (c instanceof ProcesslistManagement) {
651: l = (List) tabPermissions
652: .get("ProcesslistManagement");
653: l2 = (List) tabPermissions
654: .get("ProcesslistManagement.SelectUser");
655: }
656: boolean en = false;
657: if (l != null) {
658: if (l.contains("*")) {
659: en = true;
660: } else {
661: for (int j = 0; j < l.size(); j++) {
662: String gr = (String) l.get(j);
663: if (groups.contains(gr.trim())) {
664: en = true;
665: break;
666: }
667: }
668: }
669: } else {
670: en = true;
671: }
672: if (en) {
673: hasOnePerm = true;
674: }
675: tabbedPane.setEnabledAt(i, en);
676: if (i == 0 && !en) {
677: selLast = true;
678: }
679: if (l2 != null) {
680: en = false;
681: for (int j = 0; j < l2.size(); j++) {
682: String gr = (String) l2.get(j);
683: if (groups.contains(gr.trim())) {
684: en = true;
685: break;
686: }
687: }
688: if (c instanceof WorklistManagement) {
689: getWorklistManagement().setSuperUserPermission(
690: en);
691: } else {
692: getProcesslistManagement()
693: .setSuperUserPermission(en);
694: }
695: } else {
696: if (c instanceof WorklistManagement) {
697: getWorklistManagement().setSuperUserPermission(
698: true);
699: } else {
700: getProcesslistManagement()
701: .setSuperUserPermission(true);
702: }
703: }
704: }
705: } else {
706: hasOnePerm = true;
707: }
708: if (selLast) {
709: tabbedPane.setSelectedIndex(tabbedPane.getTabCount() - 1);
710: }
711: if (!hasOnePerm) {
712: String msg = "User "
713: + username
714: + " does not have permission to use this application!";
715: if (excHappened) {
716: msg = "Application might not be configured properly. Please check-out console output before closing this dialog!";
717: }
718: JOptionPane.showMessageDialog(myFrame, msg);
719: getAction("Exit").actionPerformed(null);
720: }
721:
722: }
723:
724: public void showXPDLErrorsReport(JDialog d, String xpdlErrors) {
725: try {
726: String title = ResourceManager
727: .getLanguageDependentString("XPDLErrorReportKey");
728: final JDialog report = new JDialog(d, title, true);
729: JEditorPane text = new JEditorPane("text/html", xpdlErrors);
730: text.setEditable(false);
731: text.getCaret().setDot(0);
732: JScrollPane sp = new JScrollPane(text);
733: sp
734: .setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
735: sp
736: .setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
737: report.getContentPane().setLayout(new BorderLayout());
738: report.getContentPane().add(sp);
739:
740: JPanel _buttonPanel = new JPanel();
741: _buttonPanel.setAlignmentX(Component.LEFT_ALIGNMENT);
742: _buttonPanel.setAlignmentY(Component.TOP_ALIGNMENT);
743:
744: JButton buttonOK = new JButton(ResourceManager
745: .getLanguageDependentString("OKKey"));
746: java.net.URL u = ResourceManager.getResource("OKImage");
747: if (u != null) {
748: buttonOK.setIcon(new ImageIcon(u));
749: }
750: _buttonPanel.add(buttonOK);
751:
752: Container cp = report.getContentPane();
753: cp.setLayout(new BorderLayout());
754: cp.add(sp, BorderLayout.CENTER);
755: cp.add(_buttonPanel, BorderLayout.SOUTH);
756:
757: // action listener for confirming
758: buttonOK.addActionListener(new ActionListener() {
759: public void actionPerformed(ActionEvent ae) {
760: report.dispose();
761: }
762: });
763:
764: buttonOK.setDefaultCapable(true);
765: report.getRootPane().setDefaultButton(buttonOK);
766:
767: report.getRootPane().getInputMap(
768: JComponent.WHEN_IN_FOCUSED_WINDOW)
769: .put(
770: KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE,
771: 0, false), "Cancel");
772: report.getRootPane().getActionMap().put("Cancel",
773: new AbstractAction() {
774: public void actionPerformed(ActionEvent e) {
775: report.dispose();
776: }
777: });
778:
779: report.pack();
780: Utils.center(report);
781:
782: report.setVisible(true);
783: } catch (Exception ex) {
784: ex.printStackTrace();
785: }
786: }
787:
788: public void setAutomaticDeadlineCheck(boolean checkAutomatically) {
789: if (deadlineChecker == null) {
790: deadlineChecker = new DeadlineChecker(username, null,
791: deadlineCheckingTime, 100, 10, false);
792: }
793: if (checkAutomatically) {
794: deadlineChecker.startChecker();
795: } else {
796: deadlineChecker.stopChecker();
797: }
798: }
799:
800: /** Main method. */
801: public static void main(String[] args) throws Exception {
802: // Checks if java version is >= 1.4.1
803: String vers = System.getProperty("java.version");
804: if (vers.compareTo("1.4") < 0) {
805: System.out
806: .println("!!!WARNING: Shark Workflow Administrator must be run with a "
807: + "1.4 or higher version VM!!!");
808: System.exit(1);
809: }
810: if (args != null && args.length > 0) {
811: configFileName = args[0];
812: }
813:
814: SharkAdmin sa = new SharkAdmin(new JFrame());
815:
816: // initialize deadline timer
817: if (args != null && args.length > 2) {
818: sa.deadlineCheckingTime = Long.parseLong(args[2]);
819: }
820:
821: }
822:
823: }
|