Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2011 JBoss Inc
   *
   * Licensed under the Apache 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.apache.org/licenses/LICENSE-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.drools.workbench.screens.guided.dtable.client.widget;
 
 import java.util.List;
 import java.util.Set;
 
This is a configuration editor for a column in a the guided decision table.
 
 public class ConditionPopup extends FormStylePopup {
 
     private SmallLabel patternLabel = new SmallLabel();
     private TextBox fieldLabel = getFieldLabel();
     private TextBox binding = new BindingTextBox();
     private Label operatorLabel = new Label();
     private int limitedEntryValueAttributeIndex = -1;
     private TextBox valueListWidget = null;
     private SimplePanel defaultValueWidgetContainer = new SimplePanel();
     private int defaultValueWidgetContainerIndex = -1;
     private ImageButton editField;
     private ImageButton editOp;
 
     private RadioButton literal = new RadioButton"constraintValueType",
                                                    ..LiteralValue() );
     private RadioButton formula = new RadioButton"constraintValueType",
                                                    ..Formula() );
     private RadioButton predicate = new RadioButton"constraintValueType",
                                                      ..Predicate() );
 
     private CEPWindowOperatorsDropdown cwo;
     private TextBox entryPointName;
     private int cepWindowRowIndex;
 
     private final GuidedDecisionTable52 model;
    private final PackageDataModelOracle oracle;
    private final GuidedDecisionTableUtils utils;
    private final DTCellValueWidgetFactory factory;
    private final Validator validator;
    private final BRLRuleModel rm;
    private final DTCellValueUtilities utilities;
    private Pattern52 editingPattern;
    private ConditionCol52 editingCol;
    private final boolean isReadOnly;
    public ConditionPopupfinal PackageDataModelOracle oracle,
                           final GuidedDecisionTable52 model,
                           final ConditionColumnCommand refreshGrid,
                           final ConditionCol52 col,
                           final boolean isNew,
                           final boolean isReadOnly ) {
        this. = new BRLRuleModelmodel );
        this. = model.getPatterncol );
        this. = cloneConditionColumncol );
        this. = model;
        this. = oracle;
        this. = new GuidedDecisionTableUtilsoracle,
                                                   model );
        this. = isReadOnly;
        this. = new Validatormodel.getConditions() );
        this. = new DTCellValueUtilitiesmodel,
                                                   oracle );
        //Set-up a factory for value editors
         = DTCellValueWidgetFactory.getInstancemodel,
                                                        oracle,
                                                        isReadOnly,
                                                        allowEmptyValues() );
        setModalfalse );
        HorizontalPanel pattern = new HorizontalPanel();
        pattern.add );
        doPatternLabel();
        //Pattern selector
        ImageButton changePattern = new ImageButton..Edit(),
                                                     ..EditDisabled(),
                                                     ..ChooseAnExistingPatternThatThisColumnAddsTo(),
                                                     new ClickHandler() {
                                                         public void onClickClickEvent w ) {
                                                             showChangePatternw );
                                                         }
                                                     } );
        changePattern.setEnabled( !isReadOnly );
        pattern.addchangePattern );
                      pattern );
        //Radio buttons for Calculation Type
        switch ( model.getTableFormat() ) {
            case :
                HorizontalPanel valueTypes = new HorizontalPanel();
                valueTypes.add );
                valueTypes.add );
                valueTypes.add );
                              valueTypes );
                switch ( .getConstraintValueType() ) {
                    case .:
                        .setValuetrue );
                        .setEnabled( !isReadOnly );
                        break;
                    case .:
                        .setValuetrue );
                        .setEnabledfalse );
                        break;
                    case .:
                        .setValuetrue );
                        .setEnabledfalse );
                }
                if ( !isReadOnly ) {
                    .addClickHandlernew ClickHandler() {
                        public void onClickClickEvent w ) {
                            .setFactFieldnull );
                            applyConsTypeChange. );
                        }
                    } );
                }
                if ( !isReadOnly ) {
                    .addClickHandlernew ClickHandler() {
                        public void onClickClickEvent w ) {
                            .setFactFieldnull );
                            applyConsTypeChange. );
                        }
                    } );
                }
                if ( !isReadOnly ) {
                    .addClickHandlernew ClickHandler() {
                        public void onClickClickEvent w ) {
                            .setFactFieldnull );
                            applyConsTypeChange. );
                        }
                    } );
                }
                doCalculationType();
                break;
            case :
                .setEnabled( !isReadOnly );
        }
        //Fact field
        HorizontalPanel field = new HorizontalPanel();
        .setEnabled( !isReadOnly );
        field.add );
        field.add );
                                          ..EditDisabled(),
                                          ..EditTheFieldThatThisColumnOperatesOn(),
                                          new ClickHandler() {
                                              public void onClickClickEvent w ) {
                                                  showFieldChange();
                                              }
                                          } );
        .setEnabled( !isReadOnly );
        field.add );
                      field );
        doFieldLabel();
        //Operator
        HorizontalPanel operator = new HorizontalPanel();
        operator.add );
                                       ..EditDisabled(),
                                       ..EditTheOperatorThatIsUsedToCompareDataWithThisField(),
                                       new ClickHandler() {
                                           public void onClickClickEvent w ) {
                                               showOperatorChange();
                                           }
                                       } );
        .setEnabled( !isReadOnly );
        operator.add );
                      operator );
        doOperatorLabel();
        doImageButtons();
        //Add CEP fields for patterns containing Facts declared as Events
                                          createCEPWindowWidget ) );
        displayCEPOperators();
        //Entry point
         = new TextBox();
        .setEnabled( !isReadOnly );
        if ( !isReadOnly ) {
            .addChangeHandlernew ChangeHandler() {
                public void onChangeChangeEvent event ) {
                    .setEntryPointName.getText() );
                }
            } );
        }
                       );
        //Column header
        final TextBox header = new TextBox();
        header.setTextcol.getHeader() );
        header.setEnabled( !isReadOnly );
        if ( !isReadOnly ) {
            header.addChangeHandlernew ChangeHandler() {
                public void onChangeChangeEvent event ) {
                    .setHeaderheader.getText() );
                }
            } );
        }
                      header );
        //Optional value list
        if ( model.getTableFormat() == . ) {
             = new TextBox();
            .setText.getValueList() );
            .setEnabled( !isReadOnly );
            if ( !isReadOnly ) {
                //Copy value back to model
                .addChangeHandlernew ChangeHandler() {
                    public void onChangeChangeEvent event ) {
                        .setValueList.getText() );
                    }
                } );
                //Update Default Value widget if necessary
                .addBlurHandlernew BlurHandler() {
                    public void onBlurBlurEvent event ) {
                        assertDefaultValue();
                        makeDefaultValueWidget();
                    }
                    private void assertDefaultValue() {
                        final List<StringvalueList = Arrays.asList.getValueList ) );
                        if ( valueList.size() > 0 ) {
                            final String defaultValue = .asString.getDefaultValue() );
                            if ( !valueList.containsdefaultValue ) ) {
                                .getDefaultValue().clearValues();
                            }
                        } else {
                            //Ensure the Default Value has been updated to represent the column's data-type.
                            final DTCellValue52 defaultValue = .getDefaultValue();
                            final DataType.DataTypes dataType = .getDataType,
                                                                                        );
                            .assertDTCellValuedataType,
                                                         defaultValue );
                        }
                    }
                } );
            }
            HorizontalPanel vl = new HorizontalPanel();
            vl.add );
            vl.addnew InfoPopup..ValueList(),
                                   ..ValueListsExplanation() ) );
                          vl );
        }
        doValueList();
        //Default value
        if ( model.getTableFormat() == . ) {
                                                              );
            makeDefaultValueWidget();
        }
        //Limited entry value widget
        if ( model.getTableFormat() == . ) {
                                                             );
            makeLimitedValueWidget();
        }
        //Field Binding
        .setTextcol.getBinding() );
        if ( !isReadOnly ) {
            .addChangeHandlernew ChangeHandler() {
                public void onChangeChangeEvent event ) {
                    .setBinding.getText() );
                }
            } );
        }
                       );
        //Hide column tick-box
                      DTCellValueWidgetFactory.getHideColumnIndicator ) );
        //Apply button
        Button apply = new Button..ApplyChanges() );
        apply.addClickHandlernew ClickHandler() {
            public void onClickClickEvent w ) {
                if ( null == .getHeader() || "".equals.getHeader() ) ) {
                    Window.alert..YouMustEnterAColumnHeaderValueDescription() );
                    return;
                }
                if ( .getConstraintValueType() != . ) {
                    //Field mandatory for Literals and Formulae
                    if ( null == .getFactField() || "".equals.getFactField() ) ) {
                        Window.alert..PleaseSelectOrEnterField() );
                        return;
                    }
                    //Operator optional for Literals and Formulae
                    if ( null == .getOperator() || "".equals.getOperator() ) ) {
                        Window.alert..NotifyNoSelectedOperator() );
                    }
                } else {
                    //Clear operator for predicates, but leave field intact for interpolation of $param values
                    .setOperatornull );
                }
                //Check for unique binding
                if ( .isBound() && !isBindingUnique.getBinding() ) ) {
                    return;
                }
                //Check column header is unique
                if ( isNew ) {
                    if ( !unique.getHeader() ) ) {
                        Window.alert..ThatColumnNameIsAlreadyInUsePleasePickAnother() );
                        return;
                    }
                } else {
                    if ( !col.getHeader().equals.getHeader() ) ) {
                        if ( !unique.getHeader() ) ) {
                            Window.alert..ThatColumnNameIsAlreadyInUsePleasePickAnother() );
                            return;
                        }
                    }
                }
                //Clear binding if column is not a literal
                if ( .getConstraintValueType() != . ) {
                    .setBindingnull );
                }
                // Pass new\modified column back for handling
                refreshGrid.execute,
                                      );
                hide();
            }
        } );
        addAttribute"",
                      apply );
    }
    private boolean allowEmptyValues() {
        return this..getTableFormat() == .;
    }
        ConditionCol52 clone = null;
        if ( col instanceof LimitedEntryConditionCol52 ) {
            clone = new LimitedEntryConditionCol52();
            DTCellValue52 dcv = cloneLimitedEntryValue( ( (LimitedEntryColcol ).getValue() );
            ( (LimitedEntryColclone ).setValuedcv );
        } else {
            clone = new ConditionCol52();
        }
        clone.setConstraintValueTypecol.getConstraintValueType() );
        clone.setFactFieldcol.getFactField() );
        clone.setFieldTypecol.getFieldType() );
        clone.setHeadercol.getHeader() );
        clone.setOperatorcol.getOperator() );
        clone.setValueListcol.getValueList() );
        clone.setDefaultValuenew DTCellValue52col.getDefaultValue() ) );
        clone.setHideColumncol.isHideColumn() );
        clone.setParameterscol.getParameters() );
        clone.setWidthcol.getWidth() );
        clone.setBindingcol.getBinding() );
        return clone;
    }
        if ( dcv == null ) {
            return null;
        }
        DTCellValue52 clone = new DTCellValue52dcv );
        return clone;
    }
    private void makeLimitedValueWidget() {
        if ( !(  instanceof LimitedEntryConditionCol52 ) ) {
            return;
        }
        boolean doesOperatorNeedValue = .doesOperatorNeedValue );
        if ( !doesOperatorNeedValue ) {
                                    false );
            lec.setValuenull );
            return;
        }
                                true );
        if ( lec.getValue() == null ) {
            lec.setValue.makeNewValue,
                                                 ) );
        }
                                                                       ,
                                                                       lec.getValue() ) );
    }
    private void makeDefaultValueWidget() {
        if ( .getTableFormat() == . ) {
            return;
        }
        if ( nil.getFactField() ) ) {
                                    false );
            return;
        }
        //Don't show Default Value if operator does not require a value
        if ( !.doesOperatorNeedValue ) ) {
                                    false );
            return;
        }
                                true );
        if ( .getDefaultValue() == null ) {
                                                               ) );
        }
        //Ensure the Default Value has been updated to represent the column's 
        //data-type. Legacy Default Values are all String-based and need to be 
        //coerced to the correct type
        final DTCellValue52 defaultValue = .getDefaultValue();
        final DataType.DataTypes dataType = .getDataType,
                                                                    );
        .assertDTCellValuedataType,
                                     defaultValue );
                                                                  ,
                                                                  defaultValue ) );
    }
    private void applyConsTypeChangeint newType ) {
        .setConstraintValueTypenewType );
        .setEnablednewType == . && ! );
        doFieldLabel();
        doValueList();
        doOperatorLabel();
        doImageButtons();
        makeDefaultValueWidget();
    }
    private void doImageButtons() {
        int constraintType = .getConstraintValueType();
        this..setEnabledconstraintType != . && ! );
        this..setEnabledconstraintType != . && ! );
    }
    private boolean isBindingUniqueString binding ) {
        return !.isVariableNameUsedbinding );
    }
    private void doFieldLabel() {
            if ( this..getFactField() == null || this..getFactField().equals"" ) ) {
            } else {
                .setTextthis..getFactField() );
            }
            .setVisibletrue );
        } else if ( nil.getFactType() ) ) {
            .setVisiblefalse );
        } else if ( nil.getFactField() ) ) {
            .setVisiblefalse );
        } else {
            .setTextthis..getFactField() );
        }
    }
    private void doOperatorLabel() {
        } else if ( nil.getFactType() ) ) {
        } else if ( nil.getFactField() ) ) {
        } else if ( nil.getOperator() ) ) {
        } else {
            .setText( HumanReadable.getOperatorDisplayName(.getOperator()) );
        }
    }
    private void doPatternLabel() {
        if ( .getFactType() != null ) {
            StringBuilder patternLabel = new StringBuilder();
            String factType = .getFactType();
            String boundName = .getBoundName();
            if ( factType != null && factType.length() > 0 ) {
                if ( .isNegated() ) {
                    patternLabel.append..negatedPattern() ).append" " ).appendfactType );
                } else {
                    patternLabel.appendfactType ).append" [" ).appendboundName ).append"]" );
                }
            }
            this..setTextpatternLabel.toString() );
        }
        doFieldLabel();
        doOperatorLabel();
    }
    private TextBox getFieldLabel() {
        final TextBox box = new TextBox();
        box.addChangeHandlernew ChangeHandler() {
            public void onChangeChangeEvent event ) {
                .setFactFieldbox.getText() );
            }
        } );
        return box;
    }
    private InfoPopup getPredicateHint() {
                              ..PredicatesInfo() );
    }
    private void doValueList() {
        if ( .getTableFormat() == . ) {
            return;
        }
        //Don't show a Value List if either the Fact\Field is empty
        final String factType = .getFactType();
        final String factField = .getFactField();
        boolean enableValueList = !( ( factType == null || "".equalsfactType ) ) || ( factField == null || "".equalsfactField ) ) );
        //Don't show Value List if operator does not accept one
        if ( enableValueList ) {
            enableValueList = .doesOperatorAcceptValueList );
        }
        //Don't show a Value List if the Fact\Field has an enumeration
        if ( enableValueList ) {
            enableValueList = !.hasEnumsfactType,
                                                factField );
        }
        .setEnabledenableValueList );
        if ( !enableValueList ) {
            .setText"" );
        }
    }
    private void doCalculationType() {
        if ( .getTableFormat() == . ) {
            return;
        }
        //Disable Formula and Predicate if the Fact\Field has enums
        final String factType = .getFactType();
        final String factField = .getFactField();
        final boolean hasEnums = .hasEnumsfactType,
                                                  factField );
        this..setEnabledhasEnums || ! );
        this..setEnabled( !( hasEnums ||  ) );
        this..setEnabled( !( hasEnums ||  ) );
        //If Fact\Field has enums the Value Type has to be a literal
        if ( hasEnums ) {
        }
    }
    private ListBox loadPatterns() {
        Set<Stringvars = new HashSet<String>();
        ListBox patterns = new ListBox();
        for ( Pattern52 p : .getPatterns() ) {
            if ( !vars.containsp.getBoundName() ) ) {
                patterns.addItem( ( p.isNegated() ? ..negatedPattern() + " " : "" )
                                          + p.getFactType()
                                          + " [" + p.getBoundName() + "]",
                                  p.getFactType()
                                          + " " + p.getBoundName()
                                          + " " + p.isNegated() );
                vars.addp.getBoundName() );
            }
        }
        return patterns;
    }
    private boolean nilString s ) {
        return s == null || s.equals"" );
    }
    private void showOperatorChange() {
        final FormStylePopup pop = new FormStylePopup();
        pop.setModalfalse );
        final String factType = .getFactType();
        final String factField = .getFactField();
        String[] ops = this..getOperatorCompletionsfactType,
                                                           factField );
        //Operators "in" and "not in" are only allowed if the Calculation Type is a Literal
        final List<StringfilteredOps = new ArrayList<String>();
        for ( String op : ops ) {
            filteredOps.addop );
        }
            filteredOps.remove"in" );
            filteredOps.remove"not in" );
        }
        //Remove "in" and "not in" if the Fact\Field is enumerated
        if ( .hasEnumsfactType,
                              factField ) ) {
            filteredOps.remove"in" );
            filteredOps.remove"not in" );
        }
        final String[] displayOps = new StringfilteredOps.size() ];
        filteredOps.toArraydisplayOps );
        final CEPOperatorsDropdown box = new CEPOperatorsDropdowndisplayOps,
                                                                    );
                     "" );
                          box );
        Button b = new Button..OK() );
        pop.addAttribute"",
                          b );
        b.addClickHandlernew ClickHandler() {
            public void onClickClickEvent w ) {
                .setOperatorbox.getValuebox.getSelectedIndex() ) );
                makeLimitedValueWidget();
                makeDefaultValueWidget();
                doOperatorLabel();
                doValueList();
                pop.hide();
            }
        } );
        pop.show();
    }
    private boolean uniqueString header ) {
        for ( CompositeColumn<?> cc : .getConditions() ) {
            for ( int iChild = 0; iChild < cc.getChildColumns().size(); iChild++ ) {
                if ( cc.getChildColumns().getiChild ).getHeader().equalsheader ) ) {
                    return false;
                }
            }
        }
        return true;
    }
    protected void showChangePatternClickEvent w ) {
        final ListBox pats = this.loadPatterns();
        if ( pats.getItemCount() == 0 ) {
            showNewPatternDialog();
            return;
        }
        final FormStylePopup pop = new FormStylePopup();
        Button ok = new Button..OK() );
        HorizontalPanel hp = new HorizontalPanel();
        hp.addpats );
        hp.addok );
                          hp );
        pop.addAttribute"",
                          new HTML..ORwithEmphasis() ) );
        Button createPattern = new Button..CreateNewFactPattern() );
        createPattern.addClickHandlernew ClickHandler() {
            public void onClickClickEvent w ) {
                pop.hide();
                showNewPatternDialog();
            }
        } );
        pop.addAttribute"",
                          createPattern );
        ok.addClickHandlernew ClickHandler() {
            public void onClickClickEvent w ) {
                String[] val = pats.getValuepats.getSelectedIndex() ).split"\\s" );
                 = .getConditionPatternval[ 1 ] );
                //Clear Field and Operator when pattern changes
                .setFactFieldnull );
                .setOperatornull );
                //Set-up UI
                .setText.getEntryPointName() );
                .selectItem.getWindow().getOperator() );
                makeLimitedValueWidget();
                makeDefaultValueWidget();
                displayCEPOperators();
                doPatternLabel();
                doValueList();
                doCalculationType();
                pop.hide();
            }
        } );
        pop.show();
    }
    protected void showFieldChange() {
        final FormStylePopup pop = new FormStylePopup();
        pop.setModalfalse );
                                                           this..getFactType() );
        final ListBox box = new ListBox();
        switch ( this..getConstraintValueType() ) {
            case .:
                //Literals can be on any field
                for ( int i = 0; i < fields.lengthi++ ) {
                    box.addItemfieldsi ] );
                }
                break;
            case .:
                //Formulae can only consume fields that do not have enumerations
                for ( int i = 0; i < fields.lengthi++ ) {
                    if ( !.hasEnumsthis..getFactType(),
                                           fieldsi ] ) ) {
                        box.addItemfieldsi ] );
                    }
                }
                break;
            case .:
                //Predicates don't need a field (this should never be reachable as the
                //field selector is disabled when the Calculation Type is Predicate)
                break;
        }
                          box );
        Button b = new Button..OK() );
        pop.addAttribute"",
                          b );
        b.addClickHandlernew ClickHandler() {
            public void onClickClickEvent w ) {
                .setFactFieldbox.getItemTextbox.getSelectedIndex() ) );
                                                              .getFactField() ) );
                //Clear Operator when field changes
                .setOperatornull );
                //Setup UI
                doFieldLabel();
                doValueList();
                doCalculationType();
                makeLimitedValueWidget();
                makeDefaultValueWidget();
                doOperatorLabel();
                pop.hide();
            }
        } );
        pop.show();
    }
    protected void showNewPatternDialog() {
        final FormStylePopup pop = new FormStylePopup();
        final ListBox types = new ListBox();
        for ( int i = 0; i < .getFactTypes().lengthi++ ) {
            types.addItem.getFactTypes()[ i ] );
        }
                          types );