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