Example usage for org.apache.wicket.markup.html.form Radio setLabel

List of usage examples for org.apache.wicket.markup.html.form Radio setLabel

Introduction

In this page you can find the example usage for org.apache.wicket.markup.html.form Radio setLabel.

Prototype

@Override
public Radio<T> setLabel(IModel<String> labelModel) 

Source Link

Document

The value will be made available to the validator property by means of ${label}.

Usage

From source file:com.fdorigo.rmfly.wicket.RecordPage.java

private void init() {
    add(new FeedbackPanel("feedback"));

    final DateTextField dateTextField = new DateTextField("arrivalDate");
    dateTextField.setRequired(true);//from   w  ww  .ja  v a  2s.c o  m

    DatePicker datePicker = new DatePicker() {
        @Override
        protected String getAdditionalJavaScript() {
            return "${calendar}.cfg.setProperty(\"navigator\",true,false); ${calendar}.render();";
        }
    };
    datePicker.setShowOnFieldClick(true);
    datePicker.setAutoHide(true);
    dateTextField.add(datePicker);

    final TextField<String> nNumberField = new TextField<>("nnumber");
    nNumberField.setRequired(true);
    if (validNnumber) {
        nNumberField.add(AttributeModifier.append("readonly", "true"));
    } else {
        nNumberField.add(AttributeModifier.append("placeholder", "Not Found"));
    }

    DropDownChoice<AirplaneType> listCategories = new DropDownChoice<>("category",
            new PropertyModel<>(this, "selected"), Arrays.asList(AirplaneType.values()));
    listCategories.setRequired(true);

    final TextField<String> firstNameField = new TextField<>("firstName");
    final TextField<String> lastNameField = new TextField<>("lastName");
    final TextField<String> primaryPhoneField = new TextField<>("primaryPhone");
    primaryPhoneField.setRequired(true);
    final TextField<String> secondaryPhoneField = new TextField<>("secondaryPhone");
    final TextField<String> addressOneField = new TextField<>("addressOne");
    final TextField<String> addressStateField = new TextField<>("addressState");
    final TextField<String> addressCityField = new TextField<>("addressCity");
    final TextField<String> addressZipField = new TextField<>("addressZip");
    final TextField<String> emailAddressField = new TextField<>("emailAddress");
    emailAddressField.add(EmailAddressValidator.getInstance());
    emailAddressField.setRequired(true);
    final TextField<String> airplaneMakeField = new TextField<>("airplaneMake");
    final TextField<String> airplaneModelField = new TextField<>("airplaneModel");
    final NumberTextField<Integer> manufactureYearField = new NumberTextField<>("manufactureYear");
    manufactureYearField.setType(Integer.class);
    int year = Calendar.getInstance().get(Calendar.YEAR);
    manufactureYearField.setMinimum(1903).setMaximum(year);

    RadioGroup<String> group = new RadioGroup<>("needJudging");
    group.setRequired(true);
    add(group);
    ListView<Boolean> radios = new ListView<Boolean>("radios", TRUE_FALSE) {
        @Override
        protected void populateItem(ListItem<Boolean> item) {
            Radio<Boolean> radio = new Radio<>("radio", item.getModel());
            radio.setLabel(new Model(item.getModelObject()));
            item.add(radio);
            item.add(new SimpleFormComponentLabel("boolval", radio));
        }
    }.setReuseItems(true);
    group.add(radios);

    Model<Record> recordModel = new Model<>(record);
    Form<Record> recordForm = new Form<>("recordForm", new CompoundPropertyModel<>(recordModel));

    final Button saveRecordButton = new Button("save") {
        @Override
        public void onSubmit() {
            record.setCategory(selected.toString());
            if (manufactureYearField.getInput() != null) {
                record.setManufactureYear(manufactureYearField.getInput());
            }
            recordFacade.edit(record);
            setResponsePage(HomePage.class);
        }
    };
    if (formControlsEnabled != true) {
        saveRecordButton.setVisible(false);
    }
    recordForm.add(saveRecordButton);

    final Button deleteRecordButton = new Button("delete") {
        @Override
        public void onSubmit() {
            recordFacade.remove(record);
            setResponsePage(HomePage.class);
        }
    };

    deleteRecordButton.setDefaultFormProcessing(false);
    if (formControlsEnabled != true) {
        deleteRecordButton.setVisible(false);
    }
    recordForm.add(deleteRecordButton);

    add(recordForm);

    recordForm.add(nNumberField);
    recordForm.add(firstNameField);
    recordForm.add(lastNameField);
    recordForm.add(secondaryPhoneField);
    recordForm.add(addressOneField);
    recordForm.add(addressStateField);
    recordForm.add(addressCityField);
    recordForm.add(addressZipField);
    recordForm.add(emailAddressField);
    recordForm.add(airplaneMakeField);
    recordForm.add(airplaneModelField);
    recordForm.add(manufactureYearField);

    /* Mandatory Fields */
    recordForm.add(dateTextField);
    recordForm.add(primaryPhoneField);
    recordForm.add(group);
    recordForm.add(listCategories);
    //        recordForm.add(new FormComponentFeedbackBorder("arrivalDateBorder").add(dateTextField));
    //        recordForm.add(new FormComponentFeedbackBorder("primaryPhoneBorder").add(primaryPhoneField));
    //        recordForm.add(new FormComponentFeedbackBorder("needJudgingBorder").add(group));
    //        recordForm.add(new FormComponentFeedbackBorder("categoryBorder").add(listCategories));
}

From source file:org.efaps.ui.wicket.components.values.BooleanField.java

License:Apache License

/**
 * @param _wicketId wicket id for this component
 * @param _value value of this component
 * @param _choices choices//  ww w  . j  a v a  2  s.co  m
 * @param _fieldConfiguration configuration for this field
 * @param _label label for this field
 */
public BooleanField(final String _wicketId, final Object _value, final IModel<Map<Object, Object>> _choices,
        final FieldConfiguration _fieldConfiguration, final String _label, final boolean _uniqueName) {
    super(_wicketId, new Model<Boolean>());
    setOutputMarkupId(true);
    setRequired(_fieldConfiguration.getField().isRequired());
    this.fieldConfiguration = _fieldConfiguration;
    this.label = _label;
    // make a unique name if in a fieldset
    this.inputName = _fieldConfiguration.getName()
            + (_uniqueName ? "_" + RandomStringUtils.randomAlphabetic(4) : "");
    final RadioGroup<Boolean> radioGroup = new RadioGroup<Boolean>("radioGroup") {

        /** The Constant serialVersionUID. */
        private static final long serialVersionUID = 1L;

        @Override
        public String getInputName() {
            return BooleanField.this.inputName;
        }
    };

    if (_value == null) {
        radioGroup.setDefaultModel(new Model<Boolean>());
    } else {
        radioGroup.setDefaultModel(Model.of((Boolean) _value));
    }
    add(radioGroup);
    final Iterator<Entry<Object, Object>> iter = _choices.getObject().entrySet().iterator();

    final Entry<Object, Object> first = iter.next();
    final Boolean firstVal = (Boolean) first.getValue();
    final Radio<Boolean> radio1 = new Radio<Boolean>("choice1", Model.of(firstVal), radioGroup) {

        /** The Constant serialVersionUID. */
        private static final long serialVersionUID = 1L;

        @Override
        public String getValue() {
            return firstVal.toString();
        }
    };
    radio1.setLabel(Model.of((String) first.getKey()));
    radioGroup.add(radio1);
    final String markupId1 = radio1.getMarkupId(true);
    radioGroup.add(new Label("label1", Model.of((String) first.getKey())) {

        private static final long serialVersionUID = 1L;

        @Override
        protected void onComponentTag(final ComponentTag _tag) {
            super.onComponentTag(_tag);
            _tag.put("for", markupId1);
        }
    });

    final Entry<Object, Object> second = iter.next();
    final Boolean secondVal = (Boolean) second.getValue();
    final Radio<Boolean> radio2 = new Radio<Boolean>("choice2", Model.of(secondVal), radioGroup) {
        /** The Constant serialVersionUID. */
        private static final long serialVersionUID = 1L;

        @Override
        public String getValue() {
            return secondVal.toString();
        }
    };
    radio2.setLabel(Model.of((String) second.getKey()));
    radioGroup.add(radio2);
    final String markupId2 = radio2.getMarkupId(true);
    radioGroup.add(new Label("label2", Model.of((String) second.getKey())) {

        private static final long serialVersionUID = 1L;

        @Override
        protected void onComponentTag(final ComponentTag _tag) {
            super.onComponentTag(_tag);
            _tag.put("for", markupId2);
        }
    });
}

From source file:org.hippoecm.frontend.widgets.RadioGroupWidget.java

License:Apache License

/**
 * Instantiates a new radio group widget.
 * /*  w ww  . j  av  a  2s.com*/
 * @param id 
 *      The widget id
 * @param choices 
 *      List containing {@link Radio} model objects
 * @param model the model
 *      Model that represents selected {@link Radio} item  
 *      
 */
public RadioGroupWidget(String id, List<? extends T> choices, IModel<T> model) {
    super(id);

    final RadioGroup<T> group = new RadioGroup<T>("widget", model);
    group.setRenderBodyOnly(false);

    group.add(new ListView<T>("choices", choices) {
        private static final long serialVersionUID = 1L;

        @Override
        protected void populateItem(ListItem<T> item) {

            final Radio<T> radio = new Radio<T>("radio", item.getModel());
            radio.add(new AjaxEventBehavior("onchange") {
                private static final long serialVersionUID = 1L;

                @Override
                protected void onEvent(AjaxRequestTarget target) {
                    group.processInput();
                    onChange(target, group.getModelObject());
                }

                /*
                @Override
                protected CharSequence getEventHandler() {
                return generateCallbackScript(new AppendingStringBuffer("wicketAjaxPost('").append(
                        getCallbackUrl()).append(
                        "', wicketSerialize(document.getElementById('" + radio.getMarkupId() + "'))"));
                }*/
            });
            item.add(radio);

            String label = item.getDefaultModelObjectAsString();
            radio.setLabel(new Model<String>(getLocalizer().getString(label, this, label)));
            item.add(new SimpleFormComponentLabel("label", radio));

            RadioGroupWidget.this.populateItem(item);
        }
    });

    add(group);
}

From source file:org.obiba.onyx.quartz.core.wicket.layout.impl.standard.QuestionCategoryRadioPanel.java

License:Open Source License

/**
 * Constructor.//from   www . j a va 2s  .  co  m
 * 
 * @param id
 * @param questionModel
 * @param questionCategoryModel
 * @param radioLabelVisible
 */
@SuppressWarnings("serial")
public QuestionCategoryRadioPanel(String id, IModel<Question> questionModel,
        IModel<QuestionCategory> questionCategoryModel, RadioGroup<QuestionCategory> radioGroup,
        boolean radioLabelVisible) {
    super(id, questionModel, questionCategoryModel);
    this.radioGroup = radioGroup;

    // previous answer or default selection
    QuestionCategory questionCategory = (QuestionCategory) questionCategoryModel.getObject();
    Question question = (Question) questionModel.getObject();

    Radio<QuestionCategory> radio = new Radio<QuestionCategory>("radio", questionCategoryModel);
    radio.setLabel(new QuestionnaireStringResourceModel(questionCategoryModel, "label"));
    // persist selection on change event
    // and make sure there is no active open field previously selected
    if (!activeQuestionnaireAdministrationService.isQuestionnaireDevelopmentMode()) {
        radio.add(new AjaxEventBehavior("onchange") {

            @Override
            protected void onEvent(AjaxRequestTarget target) {

                // make the radio group active for the selection
                QuestionCategoryRadioPanel.this.radioGroup.setModel(getQuestionCategoryModel());

                // exclusive choice, only one answer per question
                activeQuestionnaireAdministrationService.deleteAnswers(getQuestion());
                activeQuestionnaireAdministrationService.answer(getQuestion(), getQuestionCategory());

                // make sure a previously selected open field is not asked for
                resetOpenAnswerDefinitionPanels(target, QuestionCategoryRadioPanel.this.radioGroup,
                        getQuestionCategoryModel());

                updateFeedbackPanel(target);

                fireQuestionCategorySelection(target, getQuestionModel(), getQuestionCategoryModel(), true);
            }

        });
    }

    FormComponentLabel radioLabel = new FormComponentLabel("categoryLabel", radio);
    add(radioLabel);
    radioLabel.add(radio);
    radioLabel.add(new Label("label", radio.getLabel()).setRenderBodyOnly(true).setVisible(radioLabelVisible)
            .setEscapeModelStrings(false));

    if (questionCategory.getCategory().getOpenAnswerDefinition() != null) {
        // there is an open field
        openField = newOpenAnswerDefinitionPanel("open");
        add(openField);

        // make radio associated to open answer optionally visible using css styling
        radio.add(new AttributeAppender("class", new Model<String>("radio-open"), " "));
        radioLabel.add(new AttributeModifier("class", new Model<String>("label-open")));

    } else {
        // no open answer
        add(new EmptyPanel("open").setVisible(false));
    }

    // previous answer or default selection
    if (!activeQuestionnaireAdministrationService.isQuestionnaireDevelopmentMode()) {
        CategoryAnswer previousAnswer = activeQuestionnaireAdministrationService.findAnswer(question,
                questionCategory);

        if (previousAnswer != null) {
            radioGroup.setModel(questionCategoryModel);
        }
    }

}

From source file:org.obiba.onyx.quartz.editor.category.CategoriesPanel.java

License:Open Source License

public CategoriesPanel(String id, final IModel<EditedQuestion> model,
        final IModel<Questionnaire> questionnaireModel, final IModel<LocaleProperties> localePropertiesModel,
        FeedbackPanel feedbackPanel, FeedbackWindow feedbackWindow) {
    super(id, model);

    final RadioGroup<Layout> radioLayout = new RadioGroup<Layout>("layout",
            new PropertyModel<Layout>(model, "layout"));
    radioLayout.setLabel(new ResourceModel("Layout"));
    add(radioLayout);/*w w  w  .  jav  a 2 s . com*/

    Radio<Layout> defaultColumnLayout = new Radio<Layout>("defaultColumnLayout", new Model<Layout>(null));
    defaultColumnLayout.setLabel(new ResourceModel("Layout.default"));
    radioLayout.add(defaultColumnLayout);
    radioLayout.add(new SimpleFormComponentLabel("defaultColumnLayoutLabel", defaultColumnLayout));

    Radio<Layout> singleColumnLayout = new Radio<Layout>("singleColumnLayout",
            new Model<Layout>(Layout.SINGLE_COLUMN));
    singleColumnLayout.setLabel(new ResourceModel("Layout.single"));
    radioLayout.add(singleColumnLayout);
    radioLayout.add(new SimpleFormComponentLabel("singleColumnLayoutLabel", singleColumnLayout));

    final Radio<Layout> gridLayout = new Radio<Layout>("gridLayout", new Model<Layout>(Layout.GRID));
    gridLayout.setLabel(new ResourceModel("Layout.grid"));
    radioLayout.add(gridLayout);
    radioLayout.add(new SimpleFormComponentLabel("gridLayoutLabel", gridLayout));

    TextField<Integer> nbRowsField = new TextField<Integer>("nbRows",
            new PropertyModel<Integer>(model, "nbRows")) {
        @Override
        public boolean isRequired() {
            return StringUtils.equals(radioLayout.getInput(), gridLayout.getValue());
        }
    };
    nbRowsField.setLabel(new ResourceModel("NbRows"));
    add(nbRowsField);

    add(new MultipleChoiceCategoryHeaderPanel("headerMultipleChoice", questionnaireModel, model));

    add(new CategoryListPanel("categories", model, questionnaireModel, localePropertiesModel, feedbackPanel,
            feedbackWindow, this));
}

From source file:org.obiba.onyx.quartz.editor.openAnswer.autocomplete.AutoCompleteOpenAnswerPanel.java

License:Open Source License

public AutoCompleteOpenAnswerPanel(String id, IModel<OpenAnswerDefinition> model,
        IModel<Category> categoryModel, IModel<Question> questionModel,
        final IModel<Questionnaire> questionnaireModel, IModel<LocaleProperties> localePropertiesModel,
        FeedbackPanel feedbackPanel, FeedbackWindow feedbackWindow) {
    super(id, model);

    this.questionnaireModel = questionnaireModel;
    this.localePropertiesModel = localePropertiesModel;
    this.feedbackPanel = feedbackPanel;
    this.feedbackWindow = feedbackWindow;

    final Question question = questionModel.getObject();
    final Category category = categoryModel.getObject();
    final OpenAnswerDefinition openAnswer = model.getObject();

    initialName = openAnswer.getName();/*from w  ww .j  a  v a2 s .co m*/
    final TextField<String> name = new TextField<String>("name", new PropertyModel<String>(model, "name"));
    name.setLabel(new ResourceModel("Name"));
    name.add(new RequiredFormFieldBehavior());
    name.add(new PatternValidator(QuartzEditorPanel.ELEMENT_NAME_PATTERN));
    name.add(new AbstractValidator<String>() {

        @Override
        protected void onValidate(IValidatable<String> validatable) {
            if (!StringUtils.equals(initialName, validatable.getValue())) {
                boolean alreadyContains = false;
                if (category != null) {
                    Map<String, OpenAnswerDefinition> openAnswerDefinitionsByName = category
                            .getOpenAnswerDefinitionsByName();
                    alreadyContains = openAnswerDefinitionsByName.containsKey(validatable.getValue())
                            && openAnswerDefinitionsByName.get(validatable.getValue()) != openAnswer;
                }
                QuestionnaireFinder questionnaireFinder = QuestionnaireFinder
                        .getInstance(questionnaireModel.getObject());
                questionnaireModel.getObject().setQuestionnaireCache(null);
                OpenAnswerDefinition findOpenAnswerDefinition = questionnaireFinder
                        .findOpenAnswerDefinition(validatable.getValue());
                if (alreadyContains
                        || findOpenAnswerDefinition != null && findOpenAnswerDefinition != openAnswer) {
                    error(validatable, "OpenAnswerAlreadyExists");
                }
            }
        }
    });
    add(name).add(new SimpleFormComponentLabel("nameLabel", name));
    add(new HelpTooltipPanel("nameHelp", new ResourceModel("Name.Tooltip")));

    variable = new TextField<String>("variable", new MapModel<String>(
            new PropertyModel<Map<String, String>>(model, "variableNames"), question.getName()));
    variable.setLabel(new ResourceModel("Variable"));
    add(variable).add(new SimpleFormComponentLabel("variableLabel", variable));
    add(new HelpTooltipPanel("variableHelp", new ResourceModel("Variable.Tooltip")));

    if (category == null) {
        variableNameBehavior = new VariableNameBehavior(name, variable, question.getParentQuestion(), question,
                null) {

            @Override
            @SuppressWarnings("hiding")
            protected String generateVariableName(Question parentQuestion, Question question, Category category,
                    String name) {
                if (StringUtils.isBlank(name))
                    return "";
                if (category != null) {
                    return super.generateVariableName(parentQuestion, question, category, name);
                }
                String variableName = parentQuestion == null ? "" : parentQuestion.getName() + ".";
                if (question != null) {
                    variableName += question.getName() + "." + question.getName() + ".";
                }
                return variableName + StringUtils.trimToEmpty(name);
            }
        };
    } else {
        variableNameBehavior = new VariableNameBehavior(name, variable, question.getParentQuestion(), question,
                category);
    }

    add(variableNameBehavior);

    TextField<String> unit = new TextField<String>("unit", new PropertyModel<String>(model, "unit"));
    unit.setLabel(new ResourceModel("Unit"));
    add(unit).add(new SimpleFormComponentLabel("unitLabel", unit));
    add(new HelpTooltipPanel("unitHelp", new ResourceModel("Unit.Tooltip")));

    TextField<Integer> sizeField = new TextField<Integer>("size",
            new PropertyModel<Integer>(model, "inputSize"), Integer.class);
    sizeField.setLabel(new ResourceModel("SizeLabel"));
    add(sizeField).add(new SimpleFormComponentLabel("sizeLabel", sizeField));

    OpenAnswerDefinitionSuggestion openAnswerSuggestion = new OpenAnswerDefinitionSuggestion(openAnswer);

    TextField<Integer> maxCountField = new TextField<Integer>("maxCount", new PropertyModel<Integer>(
            new Model<OpenAnswerDefinitionSuggestion>(openAnswerSuggestion), "maxCount"), Integer.class);
    maxCountField.setLabel(new ResourceModel("MaxCount"));
    add(maxCountField).add(new SimpleFormComponentLabel("maxCountLabel", maxCountField));

    Source source = openAnswerSuggestion.getSuggestionSource();

    final WebMarkupContainer sourceConfigContainer = new WebMarkupContainer("sourceConfigContainer");
    sourceConfigContainer.setOutputMarkupId(true);
    add(sourceConfigContainer);
    sourceConfigContainer.add(showSuggestionConfig(source, false));

    final RadioGroup<Source> radioSource = new RadioGroup<Source>("source", new Model<Source>(source));
    radioSource.setLabel(new ResourceModel("SourceOfSuggestions"));
    radioSource.add(new AjaxFormChoiceComponentUpdatingBehavior() {
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            sourceConfigContainer.addOrReplace(showSuggestionConfig(radioSource.getModelObject(), true));
            target.addComponent(sourceConfigContainer);
        }
    });
    add(radioSource);

    Radio<Source> sourceItems = new Radio<Source>("sourceItems", new Model<Source>(Source.ITEMS_LIST));
    sourceItems.setLabel(new ResourceModel("listOfItems"));
    radioSource.add(sourceItems);
    radioSource.add(new SimpleFormComponentLabel("sourceItemsLabel", sourceItems));

    Radio<Source> sourceVariable = new Radio<Source>("sourceVariable",
            new Model<Source>(Source.VARIABLE_VALUES));
    sourceVariable.setLabel(new ResourceModel("variableValues"));
    radioSource.add(sourceVariable);
    radioSource.add(new SimpleFormComponentLabel("sourceVariableLabel", sourceVariable));

    localePropertiesUtils.load(localePropertiesModel.getObject(), questionnaireModel.getObject(), openAnswer);
    Map<String, Boolean> visibleStates = new HashMap<String, Boolean>();
    if (openAnswer.isSuggestionAnswer()) {
        for (String item : new OpenAnswerDefinitionSuggestion(openAnswer).getSuggestionItems()) {
            visibleStates.put(item, false);
        }
    }
    add(new LabelsPanel("labels", localePropertiesModel, model, feedbackPanel, feedbackWindow, null,
            visibleStates));

    final WebMarkupContainer validationContainer = new WebMarkupContainer("validationContainer");
    validationContainer.setOutputMarkupId(true);
    add(validationContainer);

    CheckBox requiredCheckBox = new CheckBox("required", new PropertyModel<Boolean>(model, "required"));
    requiredCheckBox.setLabel(new ResourceModel("AnswerRequired"));
    validationContainer.add(requiredCheckBox);
    validationContainer.add(new SimpleFormComponentLabel("requiredLabel", requiredCheckBox));

    final RadioGroup<Boolean> newValueGroup = new RadioGroup<Boolean>("newValueGroup",
            new PropertyModel<Boolean>(new Model<OpenAnswerDefinitionSuggestion>(openAnswerSuggestion),
                    "newValueAllowed"));
    validationContainer.add(newValueGroup);

    Radio<Boolean> newValueNotAllowed = new Radio<Boolean>("newValueNotAllowed",
            new Model<Boolean>(Boolean.FALSE));
    newValueNotAllowed.setLabel(new ResourceModel("AllowSuggestedTextOnly"));
    newValueGroup.add(newValueNotAllowed)
            .add(new SimpleFormComponentLabel("newValueNotAllowedLabel", newValueNotAllowed));

    Radio<Boolean> newValueAllowed = new Radio<Boolean>("newValueAllowed", new Model<Boolean>(Boolean.TRUE));
    newValueAllowed.setLabel(new ResourceModel("AllowOpenText"));
    newValueGroup.add(newValueAllowed)
            .add(new SimpleFormComponentLabel("newValueAllowedLabel", newValueAllowed));

    final TextField<String> pattern = new TextField<String>("pattern", new PropertyModel<String>(
            new Model<OpenAnswerDefinitionSuggestion>(openAnswerSuggestion), "newValuePattern"));
    pattern.setLabel(new ResourceModel("Pattern"));
    pattern.setVisible(openAnswerSuggestion.getNewValueAllowed());
    validationContainer.add(pattern).add(new SimpleFormComponentLabel("patternLabel", pattern));

    newValueGroup.add(new AjaxFormChoiceComponentUpdatingBehavior() {
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            boolean showPattern = newValueGroup.getModelObject();
            if (!showPattern)
                pattern.setModelObject(null);
            pattern.setVisible(showPattern);
            target.addComponent(validationContainer);
        }
    });
}

From source file:org.obiba.onyx.quartz.editor.openAnswer.validation.ValidationDataSourceWindow.java

License:Open Source License

public ValidationDataSourceWindow(String id, IModel<ComparingDataSource> model,
        final IModel<Question> questionModel, final IModel<Questionnaire> questionnaireModel,
        final DataType dataType, final ModalWindow modalWindow) {
    super(id, model);
    this.dataType = dataType;

    final ValueType valueType = VariableUtils.convertToValueType(dataType);

    add(CSSPackageResource.getHeaderContribution(ValidationDataSourceWindow.class,
            "ValidationDataSourceWindow.css"));

    variableWindow = new ModalWindow("variableWindow");
    variableWindow.setCssClassName("onyx");
    variableWindow.setInitialWidth(950);
    variableWindow.setInitialHeight(540);
    variableWindow.setResizable(true);/*from w w w .  j a v  a 2  s  .c  om*/
    variableWindow.setTitle(new ResourceModel("Variable"));
    add(variableWindow);

    final Questionnaire questionnaire = questionnaireModel.getObject();

    final OpenAnswerValidator validator = new OpenAnswerValidator();
    if (model.getObject() != null) {
        ComparingDataSource comparingDataSource = model.getObject();
        validator.setOperator(comparingDataSource.getComparisonOperator());
        IDataSource dataSourceRight = comparingDataSource.getDataSourceRight();
        if (dataSourceRight instanceof VariableDataSource) {
            VariableDataSource variableDataSource = (VariableDataSource) dataSourceRight;
            if (questionnaire.getName().equals(variableDataSource.getTableName())) {
                try {
                    validator.setVariable(questionnaire.getVariable(variableDataSource.getVariableName()));
                    validator.setType(Type.VARIABLE);
                } catch (IllegalArgumentException e) {
                    // not found in this questionnaire
                }
            }
            if (validator.getType() == null) { // not found yet
                Variable variable = variableUtils.findVariable(variableDataSource);
                if (variable != null) {
                    try {
                        validator.setVariable(questionnaire.getVariable(variable.getName()));
                        validator.setType(Type.VARIABLE);
                    } catch (IllegalArgumentException e) {
                        // not found
                        Question question = VariableUtils.findQuestion(variable,
                                QuestionnaireFinder.getInstance(questionnaire));
                        validator.setType(Type.QUESTION_CATEGORY);
                        validator.setQuestion(question);
                        Category category = VariableUtils.findCategory(variable, question);
                        validator.setCategory(category);
                        validator.setOpenAnswer(VariableUtils.findOpenAnswer(variable, category));
                    }
                }
            }
        } else if (dataSourceRight instanceof JavascriptDataSource) {
            JavascriptDataSource javascriptDataSource = (JavascriptDataSource) dataSourceRight;
            validator.setType(JAVASCRIPT);
            validator.setScript(javascriptDataSource.getScript());
        }
    }

    feedbackPanel = new FeedbackPanel("content");
    feedbackWindow = new FeedbackWindow("feedback");
    feedbackWindow.setOutputMarkupId(true);

    add(feedbackWindow);

    add(form = new Form<OpenAnswerValidator>("form", new Model<OpenAnswerValidator>(validator)));
    form.setMultiPart(false);

    IChoiceRenderer<ComparisonOperator> operatorRenderer = new IChoiceRenderer<ComparisonOperator>() {
        @Override
        public String getIdValue(ComparisonOperator operator, int index) {
            return operator.name();
        }

        @Override
        public Object getDisplayValue(ComparisonOperator operator) {
            return new StringResourceModel("Operator." + operator, ValidationDataSourceWindow.this, null)
                    .getString();
        }
    };

    List<ComparisonOperator> comparisonOperatorAsList = null;
    if (dataType == DataType.TEXT) {
        comparisonOperatorAsList = Arrays.asList(ComparisonOperator.eq, ComparisonOperator.ne,
                ComparisonOperator.in);
    } else {
        comparisonOperatorAsList = Arrays.asList(ComparisonOperator.values());
    }
    final DropDownChoice<ComparisonOperator> operator = new DropDownChoice<ComparisonOperator>("operator",
            new PropertyModel<ComparisonOperator>(form.getModel(), "operator"), comparisonOperatorAsList,
            operatorRenderer);
    form.add(operator.setLabel(new ResourceModel("Operator")).setRequired(true))
            .add(new SimpleFormComponentLabel("operatorLabel", operator));

    final RadioGroup<Type> validationType = new RadioGroup<Type>("validationType",
            new PropertyModel<Type>(form.getModel(), "type"));
    form.add(validationType.setLabel(new ResourceModel("Variable")).setRequired(true));

    final Radio<Type> questionType = new Radio<Type>("questionType", new Model<Type>(QUESTION_CATEGORY));
    questionType.setLabel(new ResourceModel("QuestionType"));
    validationType.add(questionType).add(new SimpleFormComponentLabel("questionTypeLabel", questionType));

    final WebMarkupContainer questionTypeContainer = new WebMarkupContainer("questionTypeContainer");
    questionTypeContainer.setOutputMarkupId(true);
    validationType.add(questionTypeContainer);

    final WebMarkupContainer questionConditionContainer = new WebMarkupContainer("questionConditionContainer");
    questionConditionContainer.setVisible(validator.getType() == QUESTION_CATEGORY);
    questionTypeContainer.add(questionConditionContainer);

    if (questionnaire.getQuestionnaireCache() == null) {
        QuestionnaireFinder.getInstance(questionnaire).buildQuestionnaireCache();
    }

    List<Question> questions = new ArrayList<Question>(
            questionnaire.getQuestionnaireCache().getQuestionCache().values());
    Collections.sort(questions, new QuestionnaireElementComparator());
    final Multimap<Question, Category> questionCategories = LinkedHashMultimap.create();
    final Multimap<Category, OpenAnswerDefinition> categoryOpenAnswer = LinkedHashMultimap.create();
    for (Question q : questions) {
        if (!q.equals(questionModel.getObject()) && q.getType() != QuestionType.BOILER_PLATE) {
            final List<Category> findCategories = findCategories(q);
            for (Category category : findCategories) {
                categoryOpenAnswer.putAll(category, category.getOpenAnswerDefinitionsByName().values());
            }
            questionCategories.putAll(q, findCategories);
        }
    }

    final DropDownChoice<Question> questionName = new DropDownChoice<Question>("question",
            new PropertyModel<Question>(form.getModel(), "question"),
            new ArrayList<Question>(questionCategories.keySet()), new QuestionnaireElementNameRenderer()) {
        @Override
        public boolean isRequired() {
            return validationType.getModelObject() == QUESTION_CATEGORY;
        }
    };

    questionName.setLabel(new ResourceModel("Question"));
    questionConditionContainer.add(questionName)
            .add(new SimpleFormComponentLabel("questionLabel", questionName));

    final List<Category> categories = questionName.getModelObject() == null ? new ArrayList<Category>()
            : new ArrayList<Category>(questionCategories.get(questionName.getModelObject()));

    final DropDownChoice<Category> categoryName = new DropDownChoice<Category>("category",
            new PropertyModel<Category>(form.getModel(), "category"), categories,
            new QuestionnaireElementNameRenderer()) {
        @Override
        public boolean isRequired() {
            return validationType.getModelObject() == QUESTION_CATEGORY;
        }
    };
    categoryName.setLabel(new ResourceModel("Category"));
    questionConditionContainer.add(categoryName)
            .add(new SimpleFormComponentLabel("categoryLabel", categoryName));

    final List<OpenAnswerDefinition> openAnswers = categoryName.getModelObject() == null
            ? new ArrayList<OpenAnswerDefinition>()
            : new ArrayList<OpenAnswerDefinition>(categoryOpenAnswer.get(categoryName.getModelObject()));

    final DropDownChoice<OpenAnswerDefinition> openAnswerName = new DropDownChoice<OpenAnswerDefinition>(
            "openAnswer", new PropertyModel<OpenAnswerDefinition>(form.getModel(), "openAnswer"), openAnswers,
            new QuestionnaireElementNameRenderer()) {
        @Override
        public boolean isRequired() {
            return validationType.getModelObject() == QUESTION_CATEGORY;
        }
    };

    questionName.add(new OnChangeAjaxBehavior() {
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            categories.clear();
            openAnswers.clear();
            categories.addAll(questionName.getModelObject() == null ? new ArrayList<Category>()
                    : new ArrayList<Category>(questionCategories.get(questionName.getModelObject())));
            openAnswers.addAll(categories.isEmpty() ? new ArrayList<OpenAnswerDefinition>()
                    : new ArrayList<OpenAnswerDefinition>(categoryOpenAnswer.get(categories.get(0))));
            target.addComponent(categoryName);
            target.addComponent(openAnswerName);
        }
    });

    categoryName.add(new OnChangeAjaxBehavior() {

        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            openAnswers.clear();
            openAnswers.addAll(categoryName.getModelObject() == null ? new ArrayList<OpenAnswerDefinition>()
                    : new ArrayList<OpenAnswerDefinition>(
                            categoryOpenAnswer.get(categoryName.getModelObject())));
            target.addComponent(openAnswerName);
        }
    });

    openAnswerName.setLabel(new ResourceModel("OpenAnswer"));
    questionConditionContainer.add(openAnswerName)
            .add(new SimpleFormComponentLabel("openAnswerLabel", openAnswerName));

    Radio<Type> variableType = new Radio<Type>("variableType", new Model<Type>(VARIABLE));
    variableType.setLabel(new ResourceModel("Variable"));
    validationType.add(variableType).add(new SimpleFormComponentLabel("variableTypeLabel", variableType));

    final WebMarkupContainer variableTypeContainer = new WebMarkupContainer("variableTypeContainer");
    variableTypeContainer.setOutputMarkupId(true);
    validationType.add(variableTypeContainer);

    final WebMarkupContainer variableContainer = new WebMarkupContainer("variableContainer");
    variableContainer.setVisible(validator.getType() == VARIABLE);
    variableTypeContainer.add(variableContainer);

    final List<Variable> variables = new ArrayList<Variable>(
            Collections2.filter(questionnaire.getVariables(), new Predicate<Variable>() {
                @Override
                public boolean apply(Variable v) {
                    // Filter for text when the operator is 'IN'
                    if (validator.getOperator() != null
                            && validator.getOperator().equals(ComparisonOperator.in)) {
                        return v.getValueType().equals(VariableUtils.convertToValueType(DataType.TEXT));
                    }
                    return v.getValueType().equals(valueType);
                }
            }));

    final DropDownChoice<Variable> variableDropDown = new DropDownChoice<Variable>("variable",
            new PropertyModel<Variable>(form.getModel(), "variable"), variables, new VariableRenderer()) {
        @Override
        public boolean isRequired() {
            return validationType.getModelObject() == VARIABLE;
        }
    };
    variableDropDown.setLabel(new ResourceModel("Variable")).setOutputMarkupId(true);
    variableContainer.add(variableDropDown);

    final WebMarkupContainer previewVariableVisibility = new WebMarkupContainer("previewVariableVisibility");
    variableContainer.add(previewVariableVisibility.setOutputMarkupId(true));

    final Image previewVariable = new Image("previewVariable", Images.ZOOM);
    previewVariable.add(new AttributeModifier("title", true, new ResourceModel("Preview")));
    previewVariable.setVisible(variableDropDown.getModelObject() != null);
    previewVariableVisibility.add(previewVariable);

    final Label previewScript = new Label("previewScript", variableDropDown.getModelObject() == null ? ""
            : variableDropDown.getModelObject().getAttributeStringValue("script"));
    previewScript.add(new SyntaxHighlighterBehavior());
    previewScript.add(new AttributeAppender("style", true, new Model<String>("display: none;"), " "));
    previewVariableVisibility.add(previewScript);

    final Map<String, Object> tooltipCfg = new HashMap<String, Object>();
    tooltipCfg.put("delay", 100);
    tooltipCfg.put("showURL", false);
    tooltipCfg.put("top", -30);
    tooltipCfg.put("bodyHandler",
            "function() { return $(\"#" + previewScript.getMarkupId(true) + "\").html(); }");
    previewVariable.add(new TooltipBehavior(null, tooltipCfg));

    variableContainer.add(new AjaxLink<Void>("newVariable") {
        @Override
        public void onClick(AjaxRequestTarget target) {

            @SuppressWarnings({ "rawtypes", "unchecked" })
            VariablePanel variablePanel = new VariablePanel("content", new Model(null), questionnaireModel,
                    valueType) {
                @Override
                public void onSave(@SuppressWarnings("hiding") AjaxRequestTarget target,
                        Variable createdVariable) {
                    variables.add(createdVariable);
                    questionnaire.addVariable(createdVariable);
                    variableDropDown.setModelObject(createdVariable);
                    previewVariable.setVisible(true);
                    previewScript.setDefaultModelObject(createdVariable.getAttributeStringValue("script"));
                    variableWindow.close(target);
                    target.addComponent(variableDropDown);
                    target.addComponent(previewVariableVisibility);
                }

                @Override
                public void onCancel(@SuppressWarnings("hiding") AjaxRequestTarget target) {
                    variableWindow.close(target);
                }
            };
            variableWindow.setContent(variablePanel);
            variableWindow.show(target);
        }
    }.add(new Image("newVariableImg", Images.ADD))
            .add(new AttributeModifier("title", true, new ResourceModel("NewVariable"))));

    variableDropDown.add(new OnChangeAjaxBehavior() {
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            Variable variable = variableDropDown.getModelObject();
            previewVariable.setVisible(variable != null);
            previewScript.setDefaultModelObject(
                    variable == null ? null : variable.getAttributeStringValue("script"));
            target.addComponent(previewVariableVisibility);
        }
    });

    Radio<Type> javascriptType = new Radio<Type>("javascriptType", new Model<Type>(JAVASCRIPT));
    javascriptType.setLabel(new ResourceModel("JavascriptType"));
    validationType.add(javascriptType).add(new SimpleFormComponentLabel("javascriptTypeLabel", javascriptType));

    final TextArea<String> javascriptField = new TextArea<String>("javascriptField",
            new PropertyModel<String>(validator, "script"));
    javascriptField.setOutputMarkupPlaceholderTag(true);
    javascriptField.setVisible(validator.getType() == JAVASCRIPT);
    validationType.add(javascriptField);

    javascriptField.add(new IValidator<String>() {

        @Override
        public void validate(final IValidatable<String> validatable) {
            JavascriptUtils.compile(validatable.getValue(), questionModel.getObject().getName(),
                    ValidationDataSourceWindow.this, form);
        }
    });

    validationType.add(new AjaxFormChoiceComponentUpdatingBehavior() {
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            Type type = validationType.getModelObject();
            switch (type) {
            case QUESTION_CATEGORY:
                variableDropDown.setModelObject(null);
                javascriptField.setModelObject(null);
                break;
            case VARIABLE:
                questionName.setModelObject(null);
                categoryName.setModelObject(null);
                openAnswerName.setModelObject(null);
                javascriptField.setModelObject(null);
                break;
            case JAVASCRIPT:
                variableDropDown.setModelObject(null);
                questionName.setModelObject(null);
                categoryName.setModelObject(null);
                openAnswerName.setModelObject(null);
                break;
            }
            questionConditionContainer.setVisible(type == QUESTION_CATEGORY);
            variableContainer.setVisible(type == VARIABLE);
            javascriptField.setVisible(type == JAVASCRIPT);
            target.addComponent(questionTypeContainer);
            target.addComponent(variableTypeContainer);
            target.addComponent(javascriptField);
        }
    });

    form.add(new SaveCancelPanel("saveCancel", form) {
        @Override
        protected void onSave(AjaxRequestTarget target, Form<?> form1) {

            IDataSource dataSource = null;
            switch (validator.getType()) {
            case QUESTION_CATEGORY:
                Question question = validator.getQuestion();
                OpenAnswerDefinition openAnswer = validator.getOpenAnswer();
                String variableName = openAnswer.getVariableName(question.getName());
                if (StringUtils.isNotBlank(variableName)) {
                    dataSource = new VariableDataSource(questionnaire.getName() + ":" + variableName);
                } else {
                    dataSource = new VariableDataSource(questionnaire.getName() + ":" + question.getName() + "."
                            + validator.getCategory().getName() + "." + openAnswer.getName());
                }
                break;
            case VARIABLE:
                dataSource = new VariableDataSource(
                        questionnaire.getName() + ":" + validator.getVariable().getName());
                break;
            case JAVASCRIPT:
                dataSource = new JavascriptDataSource(validator.getScript(),
                        VariableUtils.convertToValueType(dataType).getName(), questionnaire.getName());
                ((JavascriptDataSource) dataSource)
                        .setSequence(validator.getOperator() == ComparisonOperator.in);
                break;
            }

            ComparingDataSource comparingDataSource = new ComparingDataSource(null, validator.getOperator(),
                    dataSource);
            ValidationDataSourceWindow.this.onSave(target, comparingDataSource);
            modalWindow.close(target);
        }

        @Override
        protected void onCancel(AjaxRequestTarget target, @SuppressWarnings("hiding") Form<?> form) {
            modalWindow.close(target);
        }

        @Override
        protected void onError(AjaxRequestTarget target, @SuppressWarnings("hiding") Form<?> form) {
            feedbackWindow.setContent(feedbackPanel);
            feedbackWindow.show(target);
        }
    });

}

From source file:org.obiba.onyx.quartz.editor.question.condition.ConditionPanel.java

License:Open Source License

public ConditionPanel(String id, final IModel<Question> questionModel,
        final IModel<Questionnaire> questionnaireModel) {
    super(id);//from w  w w. j av  a  2 s .co m
    this.questionModel = questionModel;
    this.questionnaireModel = questionnaireModel;

    add(CSSPackageResource.getHeaderContribution(ConditionPanel.class, "ConditionPanel.css"));

    variableWindow = new ModalWindow("variableWindow");
    variableWindow.setCssClassName("onyx");
    variableWindow.setInitialWidth(950);
    variableWindow.setInitialHeight(540);
    variableWindow.setResizable(true);
    variableWindow.setTitle(new ResourceModel("Variable"));
    add(variableWindow);

    add(new MultiLineLabel("explain", new ResourceModel("Explain")));

    Condition condition = new Condition();

    final Question question = questionModel.getObject();

    final Questionnaire questionnaire = questionnaireModel.getObject();
    QuestionnaireFinder questionnaireFinder = QuestionnaireFinder.getInstance(questionnaire);
    questionnaireFinder.buildQuestionnaireCache(); // need a fresh cache

    final IDataSource initialCondition = question.getCondition();
    if (initialCondition != null) {
        if (initialCondition instanceof VariableDataSource) {
            VariableDataSource variableDataSource = (VariableDataSource) initialCondition;
            if (questionnaire.getName().equals(variableDataSource.getTableName())) {
                try {
                    condition.setVariable(questionnaire.getVariable(variableDataSource.getVariableName()));
                    condition.setType(Type.VARIABLE);
                } catch (IllegalArgumentException e) {
                    // not found in this questionnaire
                }
            }
            if (condition.getType() == NONE) { // not found yet
                Variable variable = variableUtils.findVariable(variableDataSource);
                if (variable != null) {
                    try {
                        condition.setVariable(questionnaire.getVariable(variable.getName()));
                        condition.setType(Type.VARIABLE);
                    } catch (IllegalArgumentException e) {
                        // not found
                        Question questionCondition = VariableUtils.findQuestion(variable, questionnaireFinder);
                        condition.setType(Type.QUESTION_CATEGORY);
                        condition.setQuestion(questionCondition);
                        condition.setCategory(VariableUtils.findCategory(variable, questionCondition));
                    }
                }
            }
        } else if (initialCondition instanceof JavascriptDataSource) {
            condition.setType(JAVASCRIPT);
            condition.setScript(((JavascriptDataSource) initialCondition).getScript());
        }
    }

    Model<Condition> model = new Model<Condition>(condition);
    setDefaultModel(model);

    final Form<Void> form = new Form<Void>("form");
    add(form);

    final RadioGroup<Type> conditionType = new RadioGroup<Type>("conditionType",
            new PropertyModel<Type>(model, "type"));
    conditionType.setLabel(new ResourceModel("ConditionType")).setRequired(true);
    form.add(conditionType);

    final Radio<Type> noneType = new Radio<Type>("none", new Model<Type>(NONE));
    noneType.setLabel(new ResourceModel("NoCondition"));
    conditionType.add(noneType).add(new SimpleFormComponentLabel("noneLabel", noneType));

    final Radio<Type> questionType = new Radio<Type>("questionType", new Model<Type>(QUESTION_CATEGORY));
    questionType.setLabel(new ResourceModel("QuestionType"));
    conditionType.add(questionType).add(new SimpleFormComponentLabel("questionTypeLabel", questionType));

    final WebMarkupContainer questionTypeContainer = new WebMarkupContainer("questionTypeContainer");
    questionTypeContainer.setOutputMarkupId(true);
    conditionType.add(questionTypeContainer);

    final WebMarkupContainer questionConditionContainer = new WebMarkupContainer("questionConditionContainer");
    questionConditionContainer.setVisible(condition.getType() == QUESTION_CATEGORY);
    questionTypeContainer.add(questionConditionContainer);

    final List<Question> questions = new ArrayList<Question>(Collections2.filter(
            questionnaire.getQuestionnaireCache().getQuestionCache().values(), new Predicate<Question>() {
                @Override
                public boolean apply(Question q) {
                    return !q.equals(question) && q.getType() != QuestionType.BOILER_PLATE;
                }
            }));
    Collections.sort(questions, new QuestionnaireElementComparator());

    questionName = new DropDownChoice<Question>("question", new PropertyModel<Question>(model, "question"),
            questions, new QuestionnaireElementNameRenderer()) {
        @Override
        public boolean isRequired() {
            return conditionType.getModelObject() == QUESTION_CATEGORY;
        }
    };

    questionName.setLabel(new ResourceModel("Question"));
    questionName.setNullValid(false);
    questionConditionContainer.add(questionName)
            .add(new SimpleFormComponentLabel("questionLabel", questionName));

    final List<Category> categories = findCategories();
    final DropDownChoice<Category> categoryName = new DropDownChoice<Category>("category",
            new PropertyModel<Category>(model, "category"), categories,
            new QuestionnaireElementNameRenderer()) {
        @Override
        public boolean isRequired() {
            return conditionType.getModelObject() == QUESTION_CATEGORY;
        }
    };
    categoryName.setLabel(new ResourceModel("Category"));
    categoryName.setNullValid(false);
    questionConditionContainer.add(categoryName)
            .add(new SimpleFormComponentLabel("categoryLabel", categoryName));

    questionName.add(new OnChangeAjaxBehavior() {
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            categories.clear();
            categories.addAll(findCategories());
            target.addComponent(categoryName);
        }
    });

    Radio<Type> variableType = new Radio<Type>("variableType", new Model<Type>(VARIABLE));
    variableType.setLabel(new ResourceModel("VariableType"));
    conditionType.add(variableType).add(new SimpleFormComponentLabel("variableTypeLabel", variableType));

    final WebMarkupContainer variableTypeContainer = new WebMarkupContainer("variableTypeContainer");
    variableTypeContainer.setOutputMarkupId(true);
    conditionType.add(variableTypeContainer);

    final WebMarkupContainer variableContainer = new WebMarkupContainer("variableContainer");
    variableContainer.setVisible(condition.getType() == VARIABLE);
    variableTypeContainer.add(variableContainer);

    final List<Variable> variables = new ArrayList<Variable>(
            Collections2.filter(questionnaire.getVariables(), new Predicate<Variable>() {
                @Override
                public boolean apply(Variable v) {
                    return v.getValueType().equals(BooleanType.get());
                }
            }));

    final DropDownChoice<Variable> variableDropDown = new DropDownChoice<Variable>("variable",
            new PropertyModel<Variable>(model, "variable"), variables, new VariableRenderer()) {
        @Override
        public boolean isRequired() {
            return conditionType.getModelObject() == VARIABLE;
        }
    };
    variableDropDown.setLabel(new ResourceModel("Variable")).setOutputMarkupId(true);
    variableContainer.add(variableDropDown);

    final WebMarkupContainer previewVariableVisibility = new WebMarkupContainer("previewVariableVisibility");
    variableContainer.add(previewVariableVisibility.setOutputMarkupId(true));

    final Image previewVariable = new Image("previewVariable", Images.ZOOM);
    previewVariable.add(new AttributeModifier("title", true, new ResourceModel("Preview")));
    previewVariable.setVisible(variableDropDown.getModelObject() != null);
    previewVariableVisibility.add(previewVariable);

    final Label previewScript = new Label("previewScript", variableDropDown.getModelObject() == null ? ""
            : variableDropDown.getModelObject().getAttributeStringValue("script"));
    previewScript.add(new SyntaxHighlighterBehavior());
    previewScript.add(new AttributeAppender("style", true, new Model<String>("display: none;"), " "));
    previewVariableVisibility.add(previewScript);

    final Map<String, Object> tooltipCfg = new HashMap<String, Object>();
    tooltipCfg.put("delay", 100);
    tooltipCfg.put("showURL", false);
    tooltipCfg.put("top", -30);
    tooltipCfg.put("bodyHandler",
            "function() { return $(\"#" + previewScript.getMarkupId(true) + "\").html(); }");
    previewVariable.add(new TooltipBehavior(null, tooltipCfg));

    variableContainer.add(new AjaxLink<Void>("newVariable") {
        @Override
        public void onClick(AjaxRequestTarget target) {

            @SuppressWarnings({ "rawtypes", "unchecked" })
            VariablePanel variablePanel = new VariablePanel("content", new Model(null), questionnaireModel,
                    BooleanType.get()) {
                @Override
                public void onSave(@SuppressWarnings("hiding") AjaxRequestTarget target,
                        Variable createdVariable) {
                    variables.add(createdVariable);
                    questionnaire.addVariable(createdVariable);
                    variableDropDown.setModelObject(createdVariable);
                    previewVariable.setVisible(true);
                    previewScript.setDefaultModelObject(createdVariable.getAttributeStringValue("script"));
                    variableWindow.close(target);
                    target.addComponent(variableDropDown);
                    target.addComponent(previewVariableVisibility);
                }

                @Override
                public void onCancel(@SuppressWarnings("hiding") AjaxRequestTarget target) {
                    variableWindow.close(target);
                }
            };

            variableWindow.setContent(variablePanel);
            variableWindow.show(target);
        }
    }.add(new Image("newVariableImg", Images.ADD))
            .add(new AttributeModifier("title", true, new ResourceModel("NewVariable"))));

    variableDropDown.add(new OnChangeAjaxBehavior() {
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            Variable variable = variableDropDown.getModelObject();
            previewVariable.setVisible(variable != null);
            previewScript.setDefaultModelObject(
                    variable == null ? null : variable.getAttributeStringValue("script"));
            target.addComponent(previewVariableVisibility);
        }
    });

    Radio<Type> javascriptType = new Radio<Type>("javascriptType", new Model<Type>(JAVASCRIPT));
    javascriptType.setLabel(new ResourceModel("JavascriptType"));
    conditionType.add(javascriptType).add(new SimpleFormComponentLabel("javascriptTypeLabel", javascriptType));

    final TextArea<String> javascriptField = new TextArea<String>("javascriptField",
            new PropertyModel<String>(condition, "script"));
    javascriptField.setOutputMarkupPlaceholderTag(true);
    javascriptField.setVisible(condition.getType() == JAVASCRIPT);
    conditionType.add(javascriptField);

    javascriptField.add(new IValidator<String>() {

        @Override
        public void validate(final IValidatable<String> validatable) {
            JavascriptUtils.compile(validatable.getValue(), question.getName(), ConditionPanel.this, form);
        }
    });

    conditionType.add(new AjaxFormChoiceComponentUpdatingBehavior() {
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            Type type = conditionType.getModelObject();
            switch (type) {
            case NONE:
                questionName.setModelObject(null);
                categoryName.setModelObject(null);
                variableDropDown.setModelObject(null);
                javascriptField.setModelObject(null);
                break;
            case QUESTION_CATEGORY:
                variableDropDown.setModelObject(null);
                javascriptField.setModelObject(null);
                break;
            case VARIABLE:
                questionName.setModelObject(null);
                categoryName.setModelObject(null);
                javascriptField.setModelObject(null);
                break;
            case JAVASCRIPT:
                questionName.setModelObject(null);
                categoryName.setModelObject(null);
                variableDropDown.setModelObject(null);
                break;
            }
            questionConditionContainer.setVisible(type == QUESTION_CATEGORY);
            variableContainer.setVisible(type == VARIABLE);
            javascriptField.setVisible(type == JAVASCRIPT);
            target.addComponent(questionTypeContainer);
            target.addComponent(variableTypeContainer);
            target.addComponent(javascriptField);
        }
    });

}

From source file:org.obiba.onyx.quartz.editor.question.CopyQuestionPanel.java

License:Open Source License

public CopyQuestionPanel(String id, final IModel<Question> model,
        final IModel<Questionnaire> questionnaireModel, final ModalWindow modalWindow) {
    super(id, model);
    this.questionnaireModel = questionnaireModel;

    final Questionnaire questionnaire = questionnaireModel.getObject();
    final QuestionnaireFinder questionnaireFinder = QuestionnaireFinder.getInstance(questionnaire);
    questionnaire.setQuestionnaireCache(null);

    feedbackPanel = new FeedbackPanel("content");
    feedbackWindow = new FeedbackWindow("feedback");
    feedbackWindow.setOutputMarkupId(true);
    add(feedbackWindow);//  w  w w . j av  a2s  .  co  m

    Form<?> form = new Form<Void>("form");
    form.setMultiPart(false);

    final Question question = model.getObject();
    String newName = new StringResourceModel(COPY_OF, CopyQuestionPanel.this, null,
            new Object[] { question.getName() }).getString();
    name = new TextField<String>("name", new Model<String>(newName));
    name.setLabel(new ResourceModel("Name"));
    name.add(new RequiredFormFieldBehavior());
    name.add(new PatternValidator(QuartzEditorPanel.ELEMENT_NAME_PATTERN));
    name.add(new AbstractValidator<String>() {
        @Override
        protected void onValidate(IValidatable<String> validatable) {
            if (questionnaireFinder.findQuestion(validatable.getValue()) != null) {
                error(validatable, "QuestionAlreadyExists");
            }
        }
    });
    form.add(name);
    form.add(new SimpleFormComponentLabel("nameLabel", name));
    form.add(new HelpTooltipPanel("nameHelp", new ResourceModel("Name.Tooltip")));

    categories = new RadioGroup<CategoryAction>("categories", new Model<CategoryAction>(CategoryAction.SHARE));
    categories.setLabel(new ResourceModel("Categories")).setRequired(true);
    form.add(categories);

    final Radio<CategoryAction> copyCategories = new Radio<CategoryAction>("copyCategories",
            new Model<CategoryAction>(CategoryAction.COPY));
    copyCategories.setLabel(new ResourceModel("Categories.Copy"));
    categories.add(copyCategories).add(new SimpleFormComponentLabel("copyCategoriesLabel", copyCategories));

    final Radio<CategoryAction> shareCategories = new Radio<CategoryAction>("shareCategories",
            new Model<CategoryAction>(CategoryAction.SHARE));
    shareCategories.setLabel(new ResourceModel("Categories.Share"));
    categories.add(shareCategories).add(new SimpleFormComponentLabel("shareCategoriesLabel", shareCategories));

    final DropDownChoice<Page> pageDropDown = new DropDownChoice<Page>("page",
            new Model<Page>(question.getPage()), questionnaire.getPages(),
            new QuestionnaireElementNameRenderer());
    pageDropDown.setRequired(true);
    pageDropDown.setNullValid(false);
    pageDropDown.setLabel(new ResourceModel("Page"));
    form.add(pageDropDown).add(new SimpleFormComponentLabel("pageLabel", pageDropDown));
    form.add(new HelpTooltipPanel("pageHelp", new ResourceModel("Page.Tooltip")));

    form.add(new SaveCancelPanel("saveCancel", form) {
        @Override
        protected void onSave(AjaxRequestTarget target, @SuppressWarnings("hiding") Form<?> form) {
            LocaleProperties localeProperties = new LocaleProperties();
            Question copy = copyQuestion(localeProperties);
            pageDropDown.getModelObject().addQuestion(copy);
            try {
                questionnairePersistenceUtils.persist(questionnaire, localeProperties);
                questionnaire.setQuestionnaireCache(null);
                CopyQuestionPanel.this.onSave(target, copy);
                modalWindow.close(target);
            } catch (Exception e) {
                log.error("Cannot persist questionnaire", e);
                error(e.getClass() + ": " + e.getMessage());
                feedbackWindow.setContent(feedbackPanel);
                feedbackWindow.show(target);
            }
        }

        @Override
        protected void onCancel(AjaxRequestTarget target, @SuppressWarnings("hiding") Form<?> form) {
            modalWindow.close(target);
        }

        @Override
        protected void onError(AjaxRequestTarget target, @SuppressWarnings("hiding") Form<?> form) {
            feedbackWindow.setContent(feedbackPanel);
            feedbackWindow.show(target);
        }
    });

    add(form);
}

From source file:org.obiba.onyx.quartz.editor.questionnaire.QuestionnairePanel.java

License:Open Source License

public QuestionnairePanel(String id, final IModel<Questionnaire> model, boolean newQuestionnaire) {
    super(id, model);
    final Questionnaire questionnaire = model.getObject();

    add(CSSPackageResource.getHeaderContribution(QuestionnairePanel.class, "QuestionnairePanel.css"));

    feedbackPanel = new FeedbackPanel("content");
    feedbackWindow = new FeedbackWindow("feedback");
    feedbackWindow.setOutputMarkupId(true);
    add(feedbackWindow);//from w  ww .  java2 s  .c om

    Form<Questionnaire> form = new Form<Questionnaire>("form", model);
    add(form);

    TextField<String> name = new TextField<String>("name", new PropertyModel<String>(form.getModel(), "name"));
    name.setLabel(new ResourceModel("Name"));
    name.setEnabled(newQuestionnaire);
    name.add(new RequiredFormFieldBehavior());
    name.add(new PatternValidator(QuartzEditorPanel.ELEMENT_NAME_PATTERN));
    name.add(new AbstractValidator<String>() {
        @Override
        protected void onValidate(final IValidatable<String> validatable) {
            boolean isNewName = Iterables.all(questionnaireBundleManager.bundles(),
                    new Predicate<QuestionnaireBundle>() {
                        @Override
                        public boolean apply(QuestionnaireBundle input) {
                            return !input.getName().equals(validatable.getValue());
                        }
                    });
            if (!isNewName && !validatable.getValue().equals(questionnaire.getName())) {
                error(validatable, "NameAlreadyExist");
            }
        }
    });
    form.add(name).add(new SimpleFormComponentLabel("nameLabel", name))
            .add(new HelpTooltipPanel("nameHelp", new ResourceModel("Name.Tooltip")));

    TextField<String> version = new TextField<String>("version",
            new PropertyModel<String>(form.getModel(), "version"));
    version.setLabel(new ResourceModel("Version"));
    version.add(new RequiredFormFieldBehavior());
    form.add(version).add(new SimpleFormComponentLabel("versionLabel", version));

    CheckBox commentable = new CheckBox("commentable",
            new PropertyModel<Boolean>(questionnaire, "commentable"));
    commentable.setLabel(new ResourceModel("Commentable"));
    form.add(commentable);
    form.add(new SimpleFormComponentLabel("commentableLabel", commentable));
    form.add(new HelpTooltipPanel("commentableHelp", new ResourceModel("Commentable.Tooltip")));

    QuestionnaireFinder.getInstance(questionnaire).buildQuestionnaireCache();
    guessUIType(questionnaire);

    RadioGroup<String> uiType = new RadioGroup<String>("uiType",
            new PropertyModel<String>(form.getModel(), "uiType"));
    uiType.setLabel(new ResourceModel("UIType"));
    uiType.setRequired(true);
    form.add(uiType);

    Radio<String> standardUiType = new Radio<String>("standard", new Model<String>(Questionnaire.STANDARD_UI));
    standardUiType.setLabel(new ResourceModel("UIType.standard"));
    uiType.add(standardUiType).add(new SimpleFormComponentLabel("standardLabel", standardUiType));

    Radio<String> simplifiedUiType = new Radio<String>("simplified",
            new Model<String>(Questionnaire.SIMPLIFIED_UI));
    simplifiedUiType.setLabel(new ResourceModel("UIType.simplified"));
    uiType.add(simplifiedUiType).add(new SimpleFormComponentLabel("simplifiedLabel", simplifiedUiType));
    form.add(new HelpTooltipPanel("uiHelp", new ResourceModel("UIType.Tooltip")));

    form.add(new HelpTooltipPanel("labelsHelp", new ResourceModel("LanguagesProperties.Tooltip")));

    Map<String, IModel<String>> labelsTooltips = new HashMap<String, IModel<String>>();
    labelsTooltips.put("label", new ResourceModel("Questionnaire.Tooltip.label"));
    labelsTooltips.put("description", new ResourceModel("Questionnaire.Tooltip.description"));
    labelsTooltips.put("labelNext", new ResourceModel("Questionnaire.Tooltip.otherNavigation"));
    labelsTooltips.put("labelPrevious", new ResourceModel("Questionnaire.Tooltip.otherNavigation"));
    labelsTooltips.put("labelStart", new ResourceModel("Questionnaire.Tooltip.otherNavigation"));
    labelsTooltips.put("labelFinish", new ResourceModel("Questionnaire.Tooltip.otherNavigation"));
    labelsTooltips.put("labelInterrupt", new ResourceModel("Questionnaire.Tooltip.otherNavigation"));
    labelsTooltips.put("labelResume", new ResourceModel("Questionnaire.Tooltip.otherNavigation"));
    labelsTooltips.put("labelCancel", new ResourceModel("Questionnaire.Tooltip.otherNavigation"));

    localePropertiesModel = new Model<LocaleProperties>(
            newQuestionnaire ? LocaleProperties.createForNewQuestionnaire(questionnaire)
                    : localePropertiesUtils.load(questionnaire, questionnaire));
    final LabelsPanel labelsPanel = new LabelsPanel("labels", localePropertiesModel, model, feedbackPanel,
            feedbackWindow, labelsTooltips, null);
    form.add(labelsPanel);

    final Locale userLocale = Session.get().getLocale();
    IChoiceRenderer<Locale> renderer = new IChoiceRenderer<Locale>() {
        @Override
        public String getIdValue(Locale locale, int index) {
            return locale.toString();
        }

        @Override
        public Object getDisplayValue(Locale locale) {
            return locale.getDisplayLanguage(userLocale);
        }
    };

    IModel<List<Locale>> localeChoices = new LoadableDetachableModel<List<Locale>>() {
        @Override
        protected List<Locale> load() {
            List<Locale> locales = new ArrayList<Locale>();
            for (String language : Locale.getISOLanguages()) {
                locales.add(new Locale(language));
            }
            Collections.sort(locales, new Comparator<Locale>() {
                @Override
                public int compare(Locale locale1, Locale locale2) {
                    return locale1.getDisplayLanguage(userLocale)
                            .compareTo(locale2.getDisplayLanguage(userLocale));
                }
            });
            return locales;
        }
    };

    Palette<Locale> localesPalette = new Palette<Locale>("languages",
            new PropertyModel<List<Locale>>(model.getObject(), "locales"), localeChoices, renderer, 5, false) {

        @Override
        protected Recorder<Locale> newRecorderComponent() {
            Recorder<Locale> recorder = super.newRecorderComponent();
            recorder.setLabel(new ResourceModel("Languages"));
            recorder.add(new AjaxFormComponentUpdatingBehavior("onchange") {

                @Override
                protected void onUpdate(AjaxRequestTarget target) {
                    LocaleProperties localeProperties = localePropertiesModel.getObject();
                    Collection<Locale> selectedLocales = getModelCollection();
                    @SuppressWarnings("unchecked")
                    Collection<Locale> removedLocales = CollectionUtils.subtract(localeProperties.getLocales(),
                            selectedLocales);
                    for (Locale locale : removedLocales) {
                        localeProperties.removeLocale(questionnaire, locale);
                    }
                    for (Locale locale : selectedLocales) {
                        if (!localeProperties.getLocales().contains(locale)) {
                            localeProperties.addLocale(questionnaire, locale);
                        }
                    }
                    labelsPanel.onModelChange(target);
                }
            });
            return recorder;
        }
    };

    form.add(localesPalette);

    form.add(new SaveCancelPanel("saveCancel", form) {
        @Override
        protected void onSave(AjaxRequestTarget target, Form<?> form1) {
            try {
                if (questionnaire.getLocales().isEmpty()) {
                    error(new StringResourceModel("LanguagesRequired", QuestionnairePanel.this, null)
                            .getString());
                    feedbackWindow.setContent(feedbackPanel);
                    feedbackWindow.show(target);
                    return;
                }
                prepareSave(target, questionnaire);
                questionnairePersistenceUtils.persist(questionnaire, localePropertiesModel.getObject());
                QuestionnairePanel.this.onSave(target, questionnaire);
            } catch (Exception e) {
                log.error("Cannot persist questionnaire", e);
                error("Cannot persist questionnaire: " + e.getMessage());
                feedbackWindow.setContent(feedbackPanel);
                feedbackWindow.show(target);
            }
        }

        @Override
        protected void onCancel(AjaxRequestTarget target, @SuppressWarnings("hiding") Form<?> form) {
            QuestionnairePanel.this.onCancel(target);
        }

        @Override
        protected void onError(AjaxRequestTarget target, @SuppressWarnings("hiding") Form<?> form) {
            feedbackWindow.setContent(feedbackPanel);
            feedbackWindow.show(target);
        }
    });

}