Example usage for org.apache.wicket.markup.html.basic Label getMarkupId

List of usage examples for org.apache.wicket.markup.html.basic Label getMarkupId

Introduction

In this page you can find the example usage for org.apache.wicket.markup.html.basic Label getMarkupId.

Prototype

public String getMarkupId(boolean createIfDoesNotExist) 

Source Link

Document

Retrieves id by which this component is represented within the markup.

Usage

From source file:org.hippoecm.frontend.plugins.gallery.editor.ImageCropEditorDialog.java

License:Apache License

public ImageCropEditorDialog(IModel<Node> jcrImageNodeModel, GalleryProcessor galleryProcessor) {
    super(jcrImageNodeModel);

    setSize(DIALOG_SIZE);/*from ww  w.j a  va 2s. c o m*/
    setTitleKey(DIALOG_TITLE);

    this.galleryProcessor = galleryProcessor;
    Node thumbnailImageNode = jcrImageNodeModel.getObject();

    HiddenField<String> regionField = new HiddenField<>("region", new PropertyModel<>(this, "region"));
    regionField.setOutputMarkupId(true);
    add(regionField);

    Component originalImage, imgPreview;
    try {
        Node originalImageNode = thumbnailImageNode.getParent()
                .getNode(HippoGalleryNodeType.IMAGE_SET_ORIGINAL);
        originalImageDimension = new Dimension(
                (int) originalImageNode.getProperty(HippoGalleryNodeType.IMAGE_WIDTH).getLong(),
                (int) originalImageNode.getProperty(HippoGalleryNodeType.IMAGE_HEIGHT).getLong());

        JcrNodeModel originalNodeModel = new JcrNodeModel(originalImageNode);
        originalImage = new JcrImage("image", new JcrResourceStream(originalNodeModel));
        imgPreview = new JcrImage("imagepreview", new JcrResourceStream(originalNodeModel));

    } catch (RepositoryException e) {
        log.error("Cannot retrieve original image", e);
        error(e);
        originalImage = new EmptyPanel("image");
        imgPreview = new EmptyPanel("imagepreview");
    }

    WebMarkupContainer imagePreviewContainer = new WebMarkupContainer("previewcontainer");
    imagePreviewContainer.setOutputMarkupId(true);
    try {
        configuredDimension = galleryProcessor.getDesiredResourceDimension(thumbnailImageNode);
        thumbnailDimension = handleZeroValueInDimension(originalImageDimension, configuredDimension);

        final double previewCropFactor = determinePreviewScalingFactor(thumbnailDimension.getWidth(),
                thumbnailDimension.getHeight());
        final double previewWidth = Math.floor(previewCropFactor * thumbnailDimension.getWidth());
        final double previewHeight = Math.floor(previewCropFactor * thumbnailDimension.getHeight());

        imagePreviewContainer
                .add(new AttributeAppender("style", Model.of("width:" + previewWidth + "px"), ";"));
        imagePreviewContainer
                .add(new AttributeAppender("style", Model.of("height:" + previewHeight + "px"), ";"));

    } catch (RepositoryException | GalleryException e) {
        log.error("Cannot retrieve thumbnail dimensions", e);
        error(e);
    }

    boolean isUpscalingEnabled = true;
    try {
        isUpscalingEnabled = galleryProcessor.isUpscalingEnabled(thumbnailImageNode);
    } catch (GalleryException | RepositoryException e) {
        log.error("Cannot retrieve Upscaling configuration option", e);
        error(e);
    }

    Label thumbnailSize = new Label("thumbnail-size", new StringResourceModel("thumbnail-size", this, null));
    thumbnailSize.setOutputMarkupId(true);
    add(thumbnailSize);
    //
    cropSettings = new ImageCropSettings(regionField.getMarkupId(), imagePreviewContainer.getMarkupId(),
            originalImageDimension, configuredDimension, thumbnailDimension, isUpscalingEnabled, false,
            thumbnailSize.getMarkupId(true));

    if (configuredDimension.width > originalImageDimension.width
            || configuredDimension.height > originalImageDimension.height) {
        final double cropFactor = determineScalingFactor(configuredDimension.getWidth(),
                configuredDimension.getHeight(), originalImageDimension.getWidth(),
                originalImageDimension.getHeight());
        cropSettings.setInitialWidth((int) Math.floor(cropFactor * configuredDimension.getWidth()));
        cropSettings.setInitialHeight((int) Math.floor(cropFactor * configuredDimension.getHeight()));
    }

    final ImageCropBehavior imageCropBehavior = new ImageCropBehavior(cropSettings);
    final IModel<Boolean> fitViewModel = new PropertyModel<>(this.cropSettings, "fitView");
    final AjaxCheckBox fitViewCheckbox = new AjaxCheckBox("fit-view", fitViewModel) {
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            executeFitInView(target, imageCropBehavior);
        }
    };
    fitViewCheckbox.setOutputMarkupId(true);
    add(fitViewCheckbox);

    originalImage.add(imageCropBehavior);
    originalImage.setOutputMarkupId(true);

    add(originalImage);
    imgPreview.add(new AttributeAppender("style", Model.of("position:absolute"), ";"));
    imagePreviewContainer.add(imgPreview);
    imagePreviewContainer.setVisible(cropSettings.isPreviewVisible());
    add(imagePreviewContainer);

    add(new Label("preview-description",
            cropSettings.isPreviewVisible() ? new StringResourceModel("preview-description-enabled", this, null)
                    : new StringResourceModel("preview-description-disabled", this, null)));

    compressionQuality = 1.0f;
    try {
        compressionQuality = galleryProcessor.getScalingParametersMap().get(thumbnailImageNode.getName())
                .getCompressionQuality();
    } catch (RepositoryException e) {
        log.info("Cannot retrieve compression quality.", e);
    }
}

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 av  a  2s  .  com
    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);/*  w  w w .j  a v  a 2  s .c o  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);
        }
    });

}