Coverage Report

 /**
  * Copyright 2010 The Kuali Foundation Licensed under the
  * Educational Community License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License. You may
  * obtain a copy of the License at
  *
  * http://www.osedu.org/licenses/ECL-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an "AS IS"
  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
 
 package org.kuali.student.common.ui.client.widgets.rules;
 
 import java.util.List;
 
 import org.kuali.student.common.ui.client.mvc.Callback;
 import org.kuali.student.common.ui.client.widgets.KSButton;
 import org.kuali.student.common.ui.client.widgets.KSLabel;
 import org.kuali.student.common.ui.client.widgets.KSPlaceholder;
 import org.kuali.student.common.ui.client.widgets.KSProgressIndicator;
 import org.kuali.student.common.ui.client.widgets.field.layout.element.SpanPanel;
 import org.kuali.student.common.ui.client.widgets.table.Node;
 import org.kuali.student.core.statement.dto.ReqComponentInfo;
 import org.kuali.student.core.statement.dto.StatementOperatorTypeKey;
 import org.kuali.student.core.statement.dto.StatementTreeViewInfo;
 
 import com.google.gwt.event.dom.client.ClickEvent;
 import com.google.gwt.event.dom.client.ClickHandler;
 import com.google.gwt.event.shared.HandlerRegistration;
 import com.google.gwt.user.client.Timer;
 import com.google.gwt.user.client.ui.FlowPanel;
 import com.google.gwt.user.client.ui.SimplePanel;
 import com.google.gwt.user.client.ui.HTMLTable.Cell;
 
 public class RuleTableManipulationWidget extends FlowPanel {
 
      //rule table manipulation buttons
     private KSButton btnMakeOR = new KSButton("OR");
     private KSButton btnMakeAND = new KSButton("AND");
     private KSButton btnAddToGroup = new KSButton("Group");
     private KSButton btnMoveRuleDown = new KSButton("Move Down");
     private KSButton btnMoveRuleUp = new KSButton("Move Up");
     private KSButton btnUndo = new KSButton("Undo");
     private KSButton btnRedo = new KSButton("Redo");
     private KSButton btnDelete = new KSButton("Delete");
     private SpanPanel separator1 = new SpanPanel(" | ");
     private SpanPanel separator2 = new SpanPanel(" | ");
     private FlowPanel topButtonsPanel = new FlowPanel();
     private FlowPanel ruleTablePanel = new FlowPanel();
 
     private KSProgressIndicator twiddler = new KSProgressIndicator();
 
     //rule table
     private RuleTable  ruleTable = new RuleTable(true);
     private ClickHandler ruleTableSelectionHandler = null;
     private ClickHandler ruleTableEditClauseHandler = null;
     private HandlerRegistration textClickHandler = null;
 
     //view's data
     private RuleInfo rule = new RuleInfo();
     private Callback reqCompEditCallback;
     private Callback ruleChangedCallback;
     private boolean isEnabled = true;
     private boolean isOperatorChecked = false;
 
     public RuleTableManipulationWidget() {
         createButtonsPanel();
 
         twiddler.setVisible(false);
         SimplePanel twiddlerPanel = new SimplePanel();
         twiddlerPanel.setHeight("30px");
         twiddlerPanel.setWidget(twiddler);
 
         add(topButtonsPanel);
 
         ruleTablePanel.setStyleName("KS-Program-Rule-ObjectView-RulePanel");
         ruleTablePanel.add(ruleTable);
         add(ruleTablePanel);
 
         setupHandlers();
     }
 
     private void setupHandlers() {
 
         ruleTableSelectionHandler = new ClickHandler() {
 
             @Override
             public void onClick(ClickEvent event) {
 
                 Cell cell = ruleTable.getCellForEvent(event);
                 if (cell == null) {
                     return;
                 }
 
                 RuleNodeWidget widget = (RuleNodeWidget) ruleTable.getWidget(cell.getRowIndex(), cell.getCellIndex());
 
                 //we don't want to select a cell if user clicked on 'edit' link or the table is disabled for editing
                 if (widget.isEditMode() || !isEnabled) {
                     widget.setEditMode(false);
                     return;
                 }
 
                 //select operator or rule
                 Object userObject = widget.getNode().getUserObject();
                 if (userObject instanceof StatementVO) {
                     StatementVO statementVO = (StatementVO) userObject;
                     statementVO.setCheckBoxOn(!statementVO.isCheckBoxOn());
                 } else if (userObject instanceof ReqComponentVO) {
                     ReqComponentVO reqComponentVO = (ReqComponentVO) userObject;
                     reqComponentVO.setCheckBoxOn(!reqComponentVO.isCheckBoxOn());
                 }
                 updateTable();
             }
         };
         textClickHandler = ruleTable.addTextClickHandler(ruleTableSelectionHandler);
 
         ruleTableEditClauseHandler = new ClickHandler() {
             @Override
             public void onClick(ClickEvent event) {
                 Cell cell = ruleTable.getCellForEvent(event);
                 if (cell == null) {
                     return;
                 }
 
                 RuleNodeWidget widget = (RuleNodeWidget) ruleTable.getWidget(cell.getRowIndex(), cell.getCellIndex());
                 Object userObject = widget.getNode().getUserObject();
                 if (userObject instanceof ReqComponentVO) {
                     widget.setEditMode(true);
                     final ReqComponentVO rule = (ReqComponentVO) userObject;
                     reqCompEditCallback.exec(rule.getReqComponentInfo());
                 }
             }
         };
 
         btnMoveRuleDown.addClickHandler(new ClickHandler() {
             public void onClick(ClickEvent event) {
                 StatementVO statementVO = rule.getStatementVO();
                 if (statementVO != null) {
                     //only allow moving up to 1 req. component but not operands
                     if (isAbletoMoveReqComp()) {
                         ReqComponentVO selectedReqCompVO = statementVO.getSelectedReqComponentVOs().get(0);
                         StatementVO enclosingStatementVO =  statementVO.getEnclosingStatementVO(statementVO, selectedReqCompVO);
                         enclosingStatementVO.shiftReqComponent("RIGHT", selectedReqCompVO);
                         rule.getEditHistory().save(statementVO);
                         redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
                     }
                 }
             }
         });
 
         btnMoveRuleUp.addClickHandler(new ClickHandler() {
             public void onClick(ClickEvent event) {
                 StatementVO statementVO = rule.getStatementVO();
                 if (statementVO != null) {
                     //only allow moving up to 1 req. component but not operands
                     if (isAbletoMoveReqComp()) {
                         ReqComponentVO selectedReqCompVO = statementVO.getSelectedReqComponentVOs().get(0);
                         StatementVO enclosingStatementVO =  statementVO.getEnclosingStatementVO(statementVO, selectedReqCompVO);
                         enclosingStatementVO.shiftReqComponent("LEFT", selectedReqCompVO);
                         rule.getEditHistory().save(statementVO);
                         redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
                     }
                 }
             }
         });
 
         btnMakeOR.addClickHandler(new ClickHandler() {
             public void onClick(ClickEvent event) {
 
                 //did user select an operand to change from OR to AND ?
                 if (isMatchingOperandSelected(Token.Or)) {
                     StatementVO statementVO = rule.getSelectedStatementVOs().get(0);
                     if (statementVO != null) {
                         statementVO.getStatementInfo().setOperator(StatementOperatorTypeKey.OR);
                         statementVO.toggleAndOr();
                     }
                 } else {
                     rule.insertOR();
                 }
 
                 // clone a copy of the unsimplified form for showing intermediate step on the UI
                 StatementVO unsimplified = RulesUtil.clone(rule.getStatementVO());
                 boolean structureChanged = rule.getStatementVO().simplify();
                 rule.getEditHistory().save(rule.getStatementVO());
 
                 // sets the statementVO to be the version that hasn't been simplified yet temporarily
                 if (structureChanged) {
                     showRuleBeforeSimplify(unsimplified);
                 } else {
                     redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
                 }
             }
         });
 
         btnMakeAND.addClickHandler(new ClickHandler() {
             public void onClick(ClickEvent event) {
 
                 //did user select an operand to change from AND to OR ?
                 if (isMatchingOperandSelected(Token.And)) {
                     StatementVO statementVO = rule.getSelectedStatementVOs().get(0);
                     if (statementVO != null) {
                         statementVO.getStatementInfo().setOperator(StatementOperatorTypeKey.AND);
                         statementVO.toggleAndOr();
                     }
                 } else {
                     rule.insertAND();
                 }
 
                 // clone a copy of the unsimplified form for showing intermediate step on the UI
                 StatementVO unsimplified = RulesUtil.clone(rule.getStatementVO());
                 boolean structureChanged = rule.getStatementVO().simplify();
                 rule.getEditHistory().save(rule.getStatementVO());
 
                 // sets the statementVO to be the version that hasn't been simplified yet temporarily
                 if (structureChanged) {
                     showRuleBeforeSimplify(unsimplified);
                 } else {
                     redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
                 }
             }
         });
 
         btnDelete.addClickHandler(new ClickHandler() {
             public void onClick(ClickEvent event) {
                 rule.deleteItem();
 
                 // clone a copy of the unsimplified form for showing intermediate step on the UI
                 StatementVO unsimplified = RulesUtil.clone(rule.getStatementVO());
                 boolean structureChanged = false;
                 if (rule.getStatementVO() != null) {
                     structureChanged = rule.getStatementVO().simplify();
                 }
 
                 rule.getEditHistory().save(rule.getStatementVO());
 
                 // sets the statementVO to be the version that hasn't been simplified yet temporarily
                 if (structureChanged) {
                     showRuleBeforeSimplify(unsimplified);
                 } else {
                     redraw((rule.getStatementVO() == null ? null : rule.getStatementVO().getStatementTreeViewInfo()), false, true);
                 }
             }
         });
 
         btnAddToGroup.addClickHandler(new ClickHandler() {
             public void onClick(ClickEvent event) {
                 rule.addToGroup();
 
                 // clone a copy of the unsimplified form for showing intermediate step on the UI
                 StatementVO unsimplified = RulesUtil.clone(rule.getStatementVO());
                 boolean structureChanged = false;
                 if (rule.getStatementVO() != null) {
                     structureChanged = rule.getStatementVO().simplify();
                 }
                 rule.getEditHistory().save(rule.getStatementVO());
 
                 // sets the statementVO to be the version that hasn't been simplified yet temporarily
                 if (structureChanged) {
                     showRuleBeforeSimplify(unsimplified);
                 } else {
                     redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
                 }
             }
         });
 
         btnUndo.addClickHandler(new ClickHandler() {
             public void onClick(ClickEvent event) {
                 StatementVO previousState = rule.getEditHistory().undo();
                 if (previousState != null) {
                     rule.setStatementVO(previousState);
                 }
                 redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
             }
         });
 
         btnRedo.addClickHandler(new ClickHandler() {
             public void onClick(ClickEvent event) {
                 StatementVO nextState = rule.getEditHistory().redo();
                 if (nextState != null) {
                     rule.setStatementVO(nextState);
                 }
                 redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
             }
         });
     }
 
     //called when user switches between Logic/Preview/Object view
     public void redraw() {
         updateTable();
     }
 
     // called by requirement display widget when user wants to edit a specific piece of rule
     public void redraw(StatementTreeViewInfo stmtTreeInfo, boolean newRule, Boolean ruleChanged) {
         rule.getStatementVO().clearStatementAndReqComponents();
         rule.getStatementVO().setStatementTreeViewInfo(stmtTreeInfo);    //TODO remove req. compon.t
         if (newRule) {
             rule.setEditHistory(new EditHistory(rule.getStatementVO()));
         }
 
         rule.getStatementVO().clearSelections();
         updateTable();
 
         if (ruleChanged != null) {
             ruleChangedCallback.exec(ruleChanged);
         }
     }
 
     private void updateTable() {
         setEnableButtons(true);
         ruleTable.clear();
         Node tree = rule.getStatementTree();
         if ((tree != null) && (rule.getStatementVO().getChildCount() > 0)) {
 
             //if we didn't have rule before, now we do so add back the rule table
             if (ruleTablePanel.getWidgetIndex(ruleTable) == -1) {
                 ruleTablePanel.clear();
                 ruleTablePanel.add(ruleTable);
             }
 
             if (rule.isSimplifying()) {
                 twiddler.setText("Simplifying...");
                 twiddler.setVisible(true);
             } else {
                 twiddler.setText("");
                 twiddler.setVisible(false);
             }
             ruleTable.buildTable(tree);
             textClickHandler.removeHandler();
             ruleTable.addTextClickHandler(ruleTableSelectionHandler);
             ruleTable.addEditClauseHandler(ruleTableEditClauseHandler);
         } else { //no rule exist so don't show rule table and show a message instead
             ruleTablePanel.clear();
             ruleTablePanel.add(new KSLabel("No rules have been added"));
         }
     }
 
     private void showRuleBeforeSimplify(StatementVO unsimplified) {
         rule.setStatementVO(unsimplified);
         rule.setSimplifying(true);
         redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, false);
         // sleep for a while to show the user how the rule looks like before simplification
         Timer simplifyingTimer = new Timer() {
             public void run() {
                 rule.setSimplifying(false);
                 rule.setStatementVO(rule.getEditHistory().getLastHistoricStmtVO());
                 redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
             }
         };
         simplifyingTimer.schedule(1000);
     }
 
     public void setEnabledView(boolean enabled) {
         setEnableButtons(enabled);
         ruleTable.setEnabled(enabled);
         isEnabled = enabled;
     }
 
     public void setEnableButtons(boolean enabled) {
         if (enabled) {
             btnMakeAND.setEnabled(isMatchingOperandSelected(Token.And) || rule.statementVOIsGroupAble());
             btnMakeOR.setEnabled(isMatchingOperandSelected(Token.Or) || rule.statementVOIsGroupAble());
             btnAddToGroup.setEnabled(rule.isAddToGroupOK());
             btnUndo.setEnabled(rule.getEditHistory().isUndoable());
             btnRedo.setEnabled(rule.getEditHistory().isRedoable());
             btnDelete.setEnabled(isAbleToDelete());
             btnMoveRuleUp.setEnabled(rule.getStatementVO().isNodeSelected() && !rule.getStatementVO().isFirstSelectedReqComp() && isAbletoMoveReqComp());
             btnMoveRuleDown.setEnabled(rule.getStatementVO().isNodeSelected() && !rule.getStatementVO().isLastSelectedReqComp() && isAbletoMoveReqComp());
         } else {
             btnMakeAND.setEnabled(false);
             btnMakeOR.setEnabled(false);
             btnAddToGroup.setEnabled(false);
             btnUndo.setEnabled(false);
             btnRedo.setEnabled(false);
             btnDelete.setEnabled(false);
             btnMoveRuleUp.setEnabled(false);
             btnMoveRuleDown.setEnabled(false);
         }
     }
 
     //right now only allow moving of up to 1 req. component but not operands
     private boolean isAbletoMoveReqComp() {
         List<ReqComponentVO> selectedRCs = rule.getStatementVO().getSelectedReqComponentVOs();
         List<StatementVO> selectedSs = rule.getStatementVO().getSelectedStatementVOs();
         int numSelectedRCs = (selectedRCs == null)? 0 : selectedRCs.size();
         int numSelectedSs = (selectedSs == null)? 0 : selectedSs.size();
         return (numSelectedRCs == 1 && numSelectedSs == 0);
     }
 
     //check whether user selected only 1 operator of opossite type
     private boolean isMatchingOperandSelected(int type) {
         List<StatementVO> selectedStmts = rule.getSelectedStatementVOs();
         if (((rule.getSelectedReqComponentVOs() == null) || (rule.getSelectedReqComponentVOs().isEmpty())) && (selectedStmts.size() == 1)
                 && (((StatementVO)selectedStmts.get(0)).getType() != type)) {
             return true;
         }
         return false;
     }
 
     private boolean isAbleToDelete() {
         //return ((rule.getSelectedStatementVOs().size() > 0) || (rule.getSelectedReqComponentVOs().size() > 0));
         if ((rule.getSelectedStatementVOs() == null || rule.getSelectedStatementVOs().size() == 0) && (rule.getSelectedReqComponentVOs().size() > 1)) {
             return true;
         }
 
         return rule.statementVOIsDegroupAble();
     }
 
     private void createButtonsPanel() {
         final String ruleEditButton = "KS-Program-Rule-ObjectView-Button";
 
         topButtonsPanel.setStyleName("KS-Program-Rule-ObjectView-ButtonPanel");
                 btnMakeAND.addStyleName(ruleEditButton);
         btnMakeAND.addStyleName("KS-Program-Rule-ObjectView-AND-Button");
         topButtonsPanel.add(btnMakeAND);
         btnMakeOR.addStyleName("KS-Program-Rule-ObjectView-OR-Button");
         btnMakeOR.addStyleName(ruleEditButton);
         topButtonsPanel.add(btnMakeOR);
         // topButtonsPanel.add(separator1);
 
         btnAddToGroup.addStyleName("KS-Program-Rule-ObjectView-Group-Button");
         btnAddToGroup.addStyleName(ruleEditButton);
         topButtonsPanel.add(btnAddToGroup);
         btnMoveRuleUp.addStyleName("KS-Program-Rule-ObjectView-Up-Button");
         btnMoveRuleUp.addStyleName(ruleEditButton);
         topButtonsPanel.add(btnMoveRuleUp);
         btnMoveRuleDown.addStyleName("KS-Program-Rule-ObjectView-Down-Button");
         btnMoveRuleDown.addStyleName(ruleEditButton);
         topButtonsPanel.add(btnMoveRuleDown);
         // topButtonsPanel.add(separator2);
 
         btnUndo.addStyleName("KS-Program-Rule-ObjectView-Undo-Button");
         btnUndo.addStyleName(ruleEditButton);
         topButtonsPanel.add(btnUndo);
         btnRedo.addStyleName("KS-Program-Rule-ObjectView-Redo-Button");
         btnRedo.addStyleName(ruleEditButton);
         topButtonsPanel.add(btnRedo);
         btnDelete.addStyleName("KS-Program-Rule-ObjectView-Delete-Button");
         btnDelete.addStyleName(ruleEditButton);
         topButtonsPanel.add(btnDelete);
     }
 
     public RuleInfo getRule() {
         return rule;
     }
 
     public void setRule(RuleInfo rule) {
         this.rule = rule;
     }
 
     public void addReqCompEditButtonClickCallback(Callback<ReqComponentInfo> callback) {
         reqCompEditCallback = callback;
     }
 
     public void addRuleChangedButtonClickCallback(Callback<Boolean> callback) {
         ruleChangedCallback = callback;
     }
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.common.ui.client.widgets.rules;
17
18		import java.util.List;
19
20		import org.kuali.student.common.ui.client.mvc.Callback;
21		import org.kuali.student.common.ui.client.widgets.KSButton;
22		import org.kuali.student.common.ui.client.widgets.KSLabel;
23		import org.kuali.student.common.ui.client.widgets.KSPlaceholder;
24		import org.kuali.student.common.ui.client.widgets.KSProgressIndicator;
25		import org.kuali.student.common.ui.client.widgets.field.layout.element.SpanPanel;
26		import org.kuali.student.common.ui.client.widgets.table.Node;
27		import org.kuali.student.core.statement.dto.ReqComponentInfo;
28		import org.kuali.student.core.statement.dto.StatementOperatorTypeKey;
29		import org.kuali.student.core.statement.dto.StatementTreeViewInfo;
30
31		import com.google.gwt.event.dom.client.ClickEvent;
32		import com.google.gwt.event.dom.client.ClickHandler;
33		import com.google.gwt.event.shared.HandlerRegistration;
34		import com.google.gwt.user.client.Timer;
35		import com.google.gwt.user.client.ui.FlowPanel;
36		import com.google.gwt.user.client.ui.SimplePanel;
37		import com.google.gwt.user.client.ui.HTMLTable.Cell;
38
39	0	public class RuleTableManipulationWidget extends FlowPanel {
40
41		//rule table manipulation buttons
42	0	private KSButton btnMakeOR = new KSButton("OR");
43	0	private KSButton btnMakeAND = new KSButton("AND");
44	0	private KSButton btnAddToGroup = new KSButton("Group");
45	0	private KSButton btnMoveRuleDown = new KSButton("Move Down");
46	0	private KSButton btnMoveRuleUp = new KSButton("Move Up");
47	0	private KSButton btnUndo = new KSButton("Undo");
48	0	private KSButton btnRedo = new KSButton("Redo");
49	0	private KSButton btnDelete = new KSButton("Delete");
50	0	private SpanPanel separator1 = new SpanPanel(" \| ");
51	0	private SpanPanel separator2 = new SpanPanel(" \| ");
52	0	private FlowPanel topButtonsPanel = new FlowPanel();
53	0	private FlowPanel ruleTablePanel = new FlowPanel();
54
55	0	private KSProgressIndicator twiddler = new KSProgressIndicator();
56
57		//rule table
58	0	private RuleTable ruleTable = new RuleTable(true);
59	0	private ClickHandler ruleTableSelectionHandler = null;
60	0	private ClickHandler ruleTableEditClauseHandler = null;
61	0	private HandlerRegistration textClickHandler = null;
62
63		//view's data
64	0	private RuleInfo rule = new RuleInfo();
65		private Callback reqCompEditCallback;
66		private Callback ruleChangedCallback;
67	0	private boolean isEnabled = true;
68	0	private boolean isOperatorChecked = false;
69
70	0	public RuleTableManipulationWidget() {
71	0	createButtonsPanel();
72
73	0	twiddler.setVisible(false);
74	0	SimplePanel twiddlerPanel = new SimplePanel();
75	0	twiddlerPanel.setHeight("30px");
76	0	twiddlerPanel.setWidget(twiddler);
77
78	0	add(topButtonsPanel);
79
80	0	ruleTablePanel.setStyleName("KS-Program-Rule-ObjectView-RulePanel");
81	0	ruleTablePanel.add(ruleTable);
82	0	add(ruleTablePanel);
83
84	0	setupHandlers();
85	0	}
86
87		private void setupHandlers() {
88
89	0	ruleTableSelectionHandler = new ClickHandler() {
90
91		@Override
92		public void onClick(ClickEvent event) {
93
94	0	Cell cell = ruleTable.getCellForEvent(event);
95	0	if (cell == null) {
96	0	return;
97		}
98
99	0	RuleNodeWidget widget = (RuleNodeWidget) ruleTable.getWidget(cell.getRowIndex(), cell.getCellIndex());
100
101		//we don't want to select a cell if user clicked on 'edit' link or the table is disabled for editing
102	0	if (widget.isEditMode() \|\| !isEnabled) {
103	0	widget.setEditMode(false);
104	0	return;
105		}
106
107		//select operator or rule
108	0	Object userObject = widget.getNode().getUserObject();
109	0	if (userObject instanceof StatementVO) {
110	0	StatementVO statementVO = (StatementVO) userObject;
111	0	statementVO.setCheckBoxOn(!statementVO.isCheckBoxOn());
112	0	} else if (userObject instanceof ReqComponentVO) {
113	0	ReqComponentVO reqComponentVO = (ReqComponentVO) userObject;
114	0	reqComponentVO.setCheckBoxOn(!reqComponentVO.isCheckBoxOn());
115		}
116	0	updateTable();
117	0	}
118		};
119	0	textClickHandler = ruleTable.addTextClickHandler(ruleTableSelectionHandler);
120
121	0	ruleTableEditClauseHandler = new ClickHandler() {
122		@Override
123		public void onClick(ClickEvent event) {
124	0	Cell cell = ruleTable.getCellForEvent(event);
125	0	if (cell == null) {
126	0	return;
127		}
128
129	0	RuleNodeWidget widget = (RuleNodeWidget) ruleTable.getWidget(cell.getRowIndex(), cell.getCellIndex());
130	0	Object userObject = widget.getNode().getUserObject();
131	0	if (userObject instanceof ReqComponentVO) {
132	0	widget.setEditMode(true);
133	0	final ReqComponentVO rule = (ReqComponentVO) userObject;
134	0	reqCompEditCallback.exec(rule.getReqComponentInfo());
135		}
136	0	}
137		};
138
139	0	btnMoveRuleDown.addClickHandler(new ClickHandler() {
140		public void onClick(ClickEvent event) {
141	0	StatementVO statementVO = rule.getStatementVO();
142	0	if (statementVO != null) {
143		//only allow moving up to 1 req. component but not operands
144	0	if (isAbletoMoveReqComp()) {
145	0	ReqComponentVO selectedReqCompVO = statementVO.getSelectedReqComponentVOs().get(0);
146	0	StatementVO enclosingStatementVO = statementVO.getEnclosingStatementVO(statementVO, selectedReqCompVO);
147	0	enclosingStatementVO.shiftReqComponent("RIGHT", selectedReqCompVO);
148	0	rule.getEditHistory().save(statementVO);
149	0	redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
150		}
151		}
152	0	}
153		});
154
155	0	btnMoveRuleUp.addClickHandler(new ClickHandler() {
156		public void onClick(ClickEvent event) {
157	0	StatementVO statementVO = rule.getStatementVO();
158	0	if (statementVO != null) {
159		//only allow moving up to 1 req. component but not operands
160	0	if (isAbletoMoveReqComp()) {
161	0	ReqComponentVO selectedReqCompVO = statementVO.getSelectedReqComponentVOs().get(0);
162	0	StatementVO enclosingStatementVO = statementVO.getEnclosingStatementVO(statementVO, selectedReqCompVO);
163	0	enclosingStatementVO.shiftReqComponent("LEFT", selectedReqCompVO);
164	0	rule.getEditHistory().save(statementVO);
165	0	redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
166		}
167		}
168	0	}
169		});
170
171	0	btnMakeOR.addClickHandler(new ClickHandler() {
172		public void onClick(ClickEvent event) {
173
174		//did user select an operand to change from OR to AND ?
175	0	if (isMatchingOperandSelected(Token.Or)) {
176	0	StatementVO statementVO = rule.getSelectedStatementVOs().get(0);
177	0	if (statementVO != null) {
178	0	statementVO.getStatementInfo().setOperator(StatementOperatorTypeKey.OR);
179	0	statementVO.toggleAndOr();
180		}
181	0	} else {
182	0	rule.insertOR();
183		}
184
185		// clone a copy of the unsimplified form for showing intermediate step on the UI
186	0	StatementVO unsimplified = RulesUtil.clone(rule.getStatementVO());
187	0	boolean structureChanged = rule.getStatementVO().simplify();
188	0	rule.getEditHistory().save(rule.getStatementVO());
189
190		// sets the statementVO to be the version that hasn't been simplified yet temporarily
191	0	if (structureChanged) {
192	0	showRuleBeforeSimplify(unsimplified);
193		} else {
194	0	redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
195		}
196	0	}
197		});
198
199	0	btnMakeAND.addClickHandler(new ClickHandler() {
200		public void onClick(ClickEvent event) {
201
202		//did user select an operand to change from AND to OR ?
203	0	if (isMatchingOperandSelected(Token.And)) {
204	0	StatementVO statementVO = rule.getSelectedStatementVOs().get(0);
205	0	if (statementVO != null) {
206	0	statementVO.getStatementInfo().setOperator(StatementOperatorTypeKey.AND);
207	0	statementVO.toggleAndOr();
208		}
209	0	} else {
210	0	rule.insertAND();
211		}
212
213		// clone a copy of the unsimplified form for showing intermediate step on the UI
214	0	StatementVO unsimplified = RulesUtil.clone(rule.getStatementVO());
215	0	boolean structureChanged = rule.getStatementVO().simplify();
216	0	rule.getEditHistory().save(rule.getStatementVO());
217
218		// sets the statementVO to be the version that hasn't been simplified yet temporarily
219	0	if (structureChanged) {
220	0	showRuleBeforeSimplify(unsimplified);
221		} else {
222	0	redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
223		}
224	0	}
225		});
226
227	0	btnDelete.addClickHandler(new ClickHandler() {
228		public void onClick(ClickEvent event) {
229	0	rule.deleteItem();
230
231		// clone a copy of the unsimplified form for showing intermediate step on the UI
232	0	StatementVO unsimplified = RulesUtil.clone(rule.getStatementVO());
233	0	boolean structureChanged = false;
234	0	if (rule.getStatementVO() != null) {
235	0	structureChanged = rule.getStatementVO().simplify();
236		}
237
238	0	rule.getEditHistory().save(rule.getStatementVO());
239
240		// sets the statementVO to be the version that hasn't been simplified yet temporarily
241	0	if (structureChanged) {
242	0	showRuleBeforeSimplify(unsimplified);
243		} else {
244	0	redraw((rule.getStatementVO() == null ? null : rule.getStatementVO().getStatementTreeViewInfo()), false, true);
245		}
246	0	}
247		});
248
249	0	btnAddToGroup.addClickHandler(new ClickHandler() {
250		public void onClick(ClickEvent event) {
251	0	rule.addToGroup();
252
253		// clone a copy of the unsimplified form for showing intermediate step on the UI
254	0	StatementVO unsimplified = RulesUtil.clone(rule.getStatementVO());
255	0	boolean structureChanged = false;
256	0	if (rule.getStatementVO() != null) {
257	0	structureChanged = rule.getStatementVO().simplify();
258		}
259	0	rule.getEditHistory().save(rule.getStatementVO());
260
261		// sets the statementVO to be the version that hasn't been simplified yet temporarily
262	0	if (structureChanged) {
263	0	showRuleBeforeSimplify(unsimplified);
264		} else {
265	0	redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
266		}
267	0	}
268		});
269
270	0	btnUndo.addClickHandler(new ClickHandler() {
271		public void onClick(ClickEvent event) {
272	0	StatementVO previousState = rule.getEditHistory().undo();
273	0	if (previousState != null) {
274	0	rule.setStatementVO(previousState);
275		}
276	0	redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
277	0	}
278		});
279
280	0	btnRedo.addClickHandler(new ClickHandler() {
281		public void onClick(ClickEvent event) {
282	0	StatementVO nextState = rule.getEditHistory().redo();
283	0	if (nextState != null) {
284	0	rule.setStatementVO(nextState);
285		}
286	0	redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
287	0	}
288		});
289	0	}
290
291		//called when user switches between Logic/Preview/Object view
292		public void redraw() {
293	0	updateTable();
294	0	}
295
296		// called by requirement display widget when user wants to edit a specific piece of rule
297		public void redraw(StatementTreeViewInfo stmtTreeInfo, boolean newRule, Boolean ruleChanged) {
298	0	rule.getStatementVO().clearStatementAndReqComponents();
299	0	rule.getStatementVO().setStatementTreeViewInfo(stmtTreeInfo); //TODO remove req. compon.t
300	0	if (newRule) {
301	0	rule.setEditHistory(new EditHistory(rule.getStatementVO()));
302		}
303
304	0	rule.getStatementVO().clearSelections();
305	0	updateTable();
306
307	0	if (ruleChanged != null) {
308	0	ruleChangedCallback.exec(ruleChanged);
309		}
310	0	}
311
312		private void updateTable() {
313	0	setEnableButtons(true);
314	0	ruleTable.clear();
315	0	Node tree = rule.getStatementTree();
316	0	if ((tree != null) && (rule.getStatementVO().getChildCount() > 0)) {
317
318		//if we didn't have rule before, now we do so add back the rule table
319	0	if (ruleTablePanel.getWidgetIndex(ruleTable) == -1) {
320	0	ruleTablePanel.clear();
321	0	ruleTablePanel.add(ruleTable);
322		}
323
324	0	if (rule.isSimplifying()) {
325	0	twiddler.setText("Simplifying...");
326	0	twiddler.setVisible(true);
327		} else {
328	0	twiddler.setText("");
329	0	twiddler.setVisible(false);
330		}
331	0	ruleTable.buildTable(tree);
332	0	textClickHandler.removeHandler();
333	0	ruleTable.addTextClickHandler(ruleTableSelectionHandler);
334	0	ruleTable.addEditClauseHandler(ruleTableEditClauseHandler);
335		} else { //no rule exist so don't show rule table and show a message instead
336	0	ruleTablePanel.clear();
337	0	ruleTablePanel.add(new KSLabel("No rules have been added"));
338		}
339	0	}
340
341		private void showRuleBeforeSimplify(StatementVO unsimplified) {
342	0	rule.setStatementVO(unsimplified);
343	0	rule.setSimplifying(true);
344	0	redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, false);
345		// sleep for a while to show the user how the rule looks like before simplification
346	0	Timer simplifyingTimer = new Timer() {
347		public void run() {
348	0	rule.setSimplifying(false);
349	0	rule.setStatementVO(rule.getEditHistory().getLastHistoricStmtVO());
350	0	redraw(rule.getStatementVO().getStatementTreeViewInfo(), false, true);
351	0	}
352		};
353	0	simplifyingTimer.schedule(1000);
354	0	}
355
356		public void setEnabledView(boolean enabled) {
357	0	setEnableButtons(enabled);
358	0	ruleTable.setEnabled(enabled);
359	0	isEnabled = enabled;
360	0	}
361
362		public void setEnableButtons(boolean enabled) {
363	0	if (enabled) {
364	0	btnMakeAND.setEnabled(isMatchingOperandSelected(Token.And) \|\| rule.statementVOIsGroupAble());
365	0	btnMakeOR.setEnabled(isMatchingOperandSelected(Token.Or) \|\| rule.statementVOIsGroupAble());
366	0	btnAddToGroup.setEnabled(rule.isAddToGroupOK());
367	0	btnUndo.setEnabled(rule.getEditHistory().isUndoable());
368	0	btnRedo.setEnabled(rule.getEditHistory().isRedoable());
369	0	btnDelete.setEnabled(isAbleToDelete());
370	0	btnMoveRuleUp.setEnabled(rule.getStatementVO().isNodeSelected() && !rule.getStatementVO().isFirstSelectedReqComp() && isAbletoMoveReqComp());
371	0	btnMoveRuleDown.setEnabled(rule.getStatementVO().isNodeSelected() && !rule.getStatementVO().isLastSelectedReqComp() && isAbletoMoveReqComp());
372		} else {
373	0	btnMakeAND.setEnabled(false);
374	0	btnMakeOR.setEnabled(false);
375	0	btnAddToGroup.setEnabled(false);
376	0	btnUndo.setEnabled(false);
377	0	btnRedo.setEnabled(false);
378	0	btnDelete.setEnabled(false);
379	0	btnMoveRuleUp.setEnabled(false);
380	0	btnMoveRuleDown.setEnabled(false);
381		}
382	0	}
383
384		//right now only allow moving of up to 1 req. component but not operands
385		private boolean isAbletoMoveReqComp() {
386	0	List<ReqComponentVO> selectedRCs = rule.getStatementVO().getSelectedReqComponentVOs();
387	0	List<StatementVO> selectedSs = rule.getStatementVO().getSelectedStatementVOs();
388	0	int numSelectedRCs = (selectedRCs == null)? 0 : selectedRCs.size();
389	0	int numSelectedSs = (selectedSs == null)? 0 : selectedSs.size();
390	0	return (numSelectedRCs == 1 && numSelectedSs == 0);
391		}
392
393		//check whether user selected only 1 operator of opossite type
394		private boolean isMatchingOperandSelected(int type) {
395	0	List<StatementVO> selectedStmts = rule.getSelectedStatementVOs();
396	0	if (((rule.getSelectedReqComponentVOs() == null) \|\| (rule.getSelectedReqComponentVOs().isEmpty())) && (selectedStmts.size() == 1)
397		&& (((StatementVO)selectedStmts.get(0)).getType() != type)) {
398	0	return true;
399		}
400	0	return false;
401		}
402
403		private boolean isAbleToDelete() {
404		//return ((rule.getSelectedStatementVOs().size() > 0) \|\| (rule.getSelectedReqComponentVOs().size() > 0));
405	0	if ((rule.getSelectedStatementVOs() == null \|\| rule.getSelectedStatementVOs().size() == 0) && (rule.getSelectedReqComponentVOs().size() > 1)) {
406	0	return true;
407		}
408
409	0	return rule.statementVOIsDegroupAble();
410		}
411
412		private void createButtonsPanel() {
413	0	final String ruleEditButton = "KS-Program-Rule-ObjectView-Button";
414
415	0	topButtonsPanel.setStyleName("KS-Program-Rule-ObjectView-ButtonPanel");
416	0	btnMakeAND.addStyleName(ruleEditButton);
417	0	btnMakeAND.addStyleName("KS-Program-Rule-ObjectView-AND-Button");
418	0	topButtonsPanel.add(btnMakeAND);
419	0	btnMakeOR.addStyleName("KS-Program-Rule-ObjectView-OR-Button");
420	0	btnMakeOR.addStyleName(ruleEditButton);
421	0	topButtonsPanel.add(btnMakeOR);
422		// topButtonsPanel.add(separator1);
423
424	0	btnAddToGroup.addStyleName("KS-Program-Rule-ObjectView-Group-Button");
425	0	btnAddToGroup.addStyleName(ruleEditButton);
426	0	topButtonsPanel.add(btnAddToGroup);
427	0	btnMoveRuleUp.addStyleName("KS-Program-Rule-ObjectView-Up-Button");
428	0	btnMoveRuleUp.addStyleName(ruleEditButton);
429	0	topButtonsPanel.add(btnMoveRuleUp);
430	0	btnMoveRuleDown.addStyleName("KS-Program-Rule-ObjectView-Down-Button");
431	0	btnMoveRuleDown.addStyleName(ruleEditButton);
432	0	topButtonsPanel.add(btnMoveRuleDown);
433		// topButtonsPanel.add(separator2);
434
435	0	btnUndo.addStyleName("KS-Program-Rule-ObjectView-Undo-Button");
436	0	btnUndo.addStyleName(ruleEditButton);
437	0	topButtonsPanel.add(btnUndo);
438	0	btnRedo.addStyleName("KS-Program-Rule-ObjectView-Redo-Button");
439	0	btnRedo.addStyleName(ruleEditButton);
440	0	topButtonsPanel.add(btnRedo);
441	0	btnDelete.addStyleName("KS-Program-Rule-ObjectView-Delete-Button");
442	0	btnDelete.addStyleName(ruleEditButton);
443	0	topButtonsPanel.add(btnDelete);
444	0	}
445
446		public RuleInfo getRule() {
447	0	return rule;
448		}
449
450		public void setRule(RuleInfo rule) {
451	0	this.rule = rule;
452	0	}
453
454		public void addReqCompEditButtonClickCallback(Callback<ReqComponentInfo> callback) {
455	0	reqCompEditCallback = callback;
456	0	}
457
458		public void addRuleChangedButtonClickCallback(Callback<Boolean> callback) {
459	0	ruleChangedCallback = callback;
460	0	}
461		}