Example usage for org.apache.wicket.ajax.markup.html AjaxLink setOutputMarkupId

List of usage examples for org.apache.wicket.ajax.markup.html AjaxLink setOutputMarkupId

Introduction

In this page you can find the example usage for org.apache.wicket.ajax.markup.html AjaxLink setOutputMarkupId.

Prototype

public final Component setOutputMarkupId(final boolean output) 

Source Link

Document

Sets whether or not component will output id attribute into the markup.

Usage

From source file:org.geoserver.importer.web.AdvancedDbParamPanel.java

License:Open Source License

Component toggleAdvanced() {
    final AjaxLink advanced = new AjaxLink("advancedLink") {

        @Override//from  www .  ja  v a  2s.c  o  m
        public void onClick(AjaxRequestTarget target) {
            advancedPanel.setVisible(!advancedPanel.isVisible());
            target.addComponent(advancedContainer);
            target.addComponent(this);
        }
    };
    advanced.add(new AttributeModifier("class", true, new AbstractReadOnlyModel() {

        @Override
        public Object getObject() {
            return advancedPanel.isVisible() ? "expanded" : "collapsed";
        }
    }));
    advanced.setOutputMarkupId(true);
    return advanced;
}

From source file:org.geoserver.importer.web.BasicDbParamPanel.java

License:Open Source License

/**
 * Toggles the connection pool param panel
 * /*w  w w  .j a v a 2s  . c o  m*/
 * @return
 */
Component toggleConnectionPoolLink() {
    AjaxLink connPoolLink = new AjaxLink("connectionPoolLink") {

        @Override
        public void onClick(AjaxRequestTarget target) {
            connPoolPanel.setVisible(!connPoolPanel.isVisible());
            target.addComponent(connPoolPanelContainer);
            target.addComponent(this);
        }
    };
    connPoolLink.add(new AttributeModifier("class", true, new AbstractReadOnlyModel() {

        @Override
        public Object getObject() {
            return connPoolPanel.isVisible() ? "expanded" : "collapsed";
        }
    }));
    connPoolLink.setOutputMarkupId(true);
    return connPoolLink;
}

From source file:org.geoserver.importer.web.ImportPage.java

License:Open Source License

void initComponents(final IModel<ImportContext> model) {
    add(new Label("id", new PropertyModel(model, "id")));

    ImportContextProvider provider = new ImportContextProvider() {
        @Override//from  w  w w . jav a 2 s  . co  m
        protected List<Property<ImportContext>> getProperties() {
            return Arrays.asList(STATE, CREATED, UPDATED);
        }

        @Override
        protected List<ImportContext> getItems() {
            return Collections.singletonList(model.getObject());
        }
    };

    add(new AjaxLink("raw") {
        @Override
        public void onClick(AjaxRequestTarget target) {
            dialog.setInitialHeight(500);
            dialog.setInitialWidth(700);
            dialog.showOkCancel(target, new DialogDelegate() {
                @Override
                protected Component getContents(String id) {
                    XStreamPersister xp = importer().createXStreamPersisterXML();
                    ByteArrayOutputStream bout = new ByteArrayOutputStream();
                    try {
                        xp.save(model.getObject(), bout);
                    } catch (IOException e) {
                        bout = new ByteArrayOutputStream();
                        LOGGER.log(Level.FINER, e.getMessage(), e);
                        e.printStackTrace(new PrintWriter(bout));
                    }

                    return new TextAreaPanel(id, new Model(new String(bout.toByteArray())));
                }

                @Override
                protected boolean onSubmit(AjaxRequestTarget target, Component contents) {
                    return true;
                }
            });
        }
    }.setVisible(ImporterWebUtils.isDevMode()));

    final ImportContextTable headerTable = new ImportContextTable("header", provider);

    headerTable.setOutputMarkupId(true);
    headerTable.setFilterable(false);
    headerTable.setPageable(false);
    add(headerTable);

    final ImportContext imp = model.getObject();
    boolean selectable = imp.getState() != ImportContext.State.COMPLETE;
    final ImportTaskTable taskTable = new ImportTaskTable("tasks", new ImportTaskProvider(model), selectable) {
        @Override
        protected void onSelectionUpdate(AjaxRequestTarget target) {
            updateImportLink((AjaxLink) ImportPage.this.get("import"), this, target);
        }
    }.setFeedbackPanel(feedbackPanel);
    taskTable.setOutputMarkupId(true);
    taskTable.setFilterable(false);
    add(taskTable);

    final AjaxLink<Long> importLink = new AjaxLink<Long>("import", new Model<Long>()) {
        @Override
        protected void disableLink(ComponentTag tag) {
            super.disableLink(tag);
            ImporterWebUtils.disableLink(tag);
        }

        @Override
        public void onClick(AjaxRequestTarget target) {
            ImportContext imp = model.getObject();

            BasicImportFilter filter = new BasicImportFilter();
            for (ImportTask t : taskTable.getSelection()) {
                filter.add(t);
            }

            //set running flag and update cancel link
            running.set(true);
            target.addComponent(cancelLink(this));

            final Long jobid = importer().runAsync(imp, filter, false);
            setDefaultModelObject(jobid);

            final AjaxLink self = this;

            // create a timer to update the table and reload the page when
            // necessary
            taskTable.add(new AbstractAjaxTimerBehavior(Duration.milliseconds(500)) {
                @Override
                protected void onTimer(AjaxRequestTarget target) {
                    Task<ImportContext> job = importer().getTask(jobid);
                    if (job == null || job.isDone()) {
                        // remove the timer
                        stop();

                        self.setEnabled(true);
                        target.addComponent(self);

                        running.set(false);
                        target.addComponent(cancelLink(self));

                        /*ImportContext imp = model.getObject();
                        if (imp.getState() == ImportContext.State.COMPLETE) {
                        // enable cancel, which will not be "done"
                        setLinkEnabled(cancelLink(self), true, target);
                        } else {
                        // disable cancel, import is not longer running, but
                        // also
                        // not complete
                        setLinkEnabled(cancelLink(self), false, target);
                        }*/
                    }

                    // update the table
                    target.addComponent(taskTable);
                    target.addComponent(headerTable);
                }
            });
            target.addComponent(taskTable);

            // disable import button
            setLinkEnabled(this, false, target);
            // enable cancel button
            //setLinkEnabled(cancelLink(this), true, target);
        }
    };
    importLink.setOutputMarkupId(true);
    importLink.setEnabled(doSelectReady(imp, taskTable, null));
    add(importLink);

    final AjaxLink cancelLink = new AjaxLink("cancel") {
        @Override
        protected void disableLink(ComponentTag tag) {
            super.disableLink(tag);
            ImporterWebUtils.disableLink(tag);
        }

        @Override
        public void onClick(AjaxRequestTarget target) {
            ImportContext imp = model.getObject();
            if (!running.get()) {
                //if (imp.getState() == ImportContext.State.COMPLETE) {
                setResponsePage(ImportDataPage.class);
                return;
            }

            Long jobid = importLink.getModelObject();
            if (jobid == null) {
                return;
            }

            Task<ImportContext> task = importer().getTask(jobid);
            if (task == null || task.isDone()) {
                return;
            }

            task.getMonitor().setCanceled(true);
            task.cancel(false);
            try {
                task.get();
            } catch (Exception e) {
            }

            // enable import button
            setLinkEnabled(importLink, true, target);
            // disable cancel button
            //setLinkEnabled(cancelLink(importLink), false, target);
        }

    };
    //cancelLink.setEnabled(imp.getState() == ImportContext.State.COMPLETE);
    cancelLink.add(new Label("text", new CancelTitleModel()));
    add(cancelLink);

    WebMarkupContainer selectPanel = new WebMarkupContainer("select");
    selectPanel.add(new AjaxLink<ImportContext>("select-all", model) {
        @Override
        public void onClick(AjaxRequestTarget target) {
            taskTable.selectAll();
            target.addComponent(taskTable);
            updateImportLink(importLink, taskTable, target);
        }
    });
    selectPanel.add(new AjaxLink<ImportContext>("select-none", model) {
        @Override
        public void onClick(AjaxRequestTarget target) {
            taskTable.clearSelection();
            target.addComponent(taskTable);
            updateImportLink(importLink, taskTable, target);
        }
    });
    selectPanel.add(new AjaxLink<ImportContext>("select-ready", model) {
        @Override
        public void onClick(AjaxRequestTarget target) {
            doSelectReady(getModelObject(), taskTable, target);
            target.addComponent(taskTable);
            updateImportLink(importLink, taskTable, target);
        }
    });
    add(selectPanel);

    add(new Icon("icon", new DataIconModel(imp.getData())));
    add(new Label("title", new DataTitleModel(imp))
            .add(new AttributeModifier("title", new DataTitleModel(imp, false))));

    add(dialog = new GeoServerDialog("dialog"));
}

From source file:org.geoserver.web.importer.BasicDbmsParamPanel.java

License:Open Source License

/**
 * Toggles the connection pool param panel
 * /*from  w ww. j a  v a2 s  .c  om*/
 * @return
 */
Component toggleConnectionPoolLink() {
    AjaxLink connPoolLink = new AjaxLink("connectionPoolLink") {

        @Override
        public void onClick(AjaxRequestTarget target) {
            connPool.setVisible(!connPool.isVisible());
            target.addComponent(connPoolParametersContainer);
            target.addComponent(this);
        }
    };
    connPoolLink.add(new AttributeModifier("class", true, new AbstractReadOnlyModel() {

        @Override
        public Object getObject() {
            return connPool.isVisible() ? "expanded" : "collapsed";
        }
    }));
    connPoolLink.setOutputMarkupId(true);
    return connPoolLink;
}

From source file:org.hippoecm.frontend.editor.plugins.linkpicker.FacetSelectTemplatePlugin.java

License:Apache License

public FacetSelectTemplatePlugin(final IPluginContext context, IPluginConfig config) {
    super(context, config);

    Node node = getModelObject();
    try {//from  w ww . j  av a 2  s .c  o m
        if (!node.hasProperty("hippo:docbase")) {
            node.setProperty("hippo:docbase", node.getSession().getRootNode().getUUID());
        }
        if (!node.hasProperty("hippo:facets")) {
            node.setProperty("hippo:facets", new String[0]);
        }
        if (!node.hasProperty("hippo:values")) {
            node.setProperty("hippo:values", new String[0]);
        }
        if (!node.hasProperty("hippo:modes")) {
            node.setProperty("hippo:modes", new String[0]);
        }
    } catch (ValueFormatException e) {
        log.error(e.getMessage());
    } catch (PathNotFoundException e) {
        log.error(e.getMessage());
    } catch (RepositoryException e) {
        log.error(e.getMessage());
    }

    final IModel<String> displayModel = new LoadableDetachableModel<String>() {
        private static final long serialVersionUID = 1L;

        @Override
        protected String load() {
            Node node = FacetSelectTemplatePlugin.this.getModelObject();
            try {
                if (node != null && node.hasProperty("hippo:docbase")) {
                    String docbaseUUID = node.getProperty("hippo:docbase").getString();
                    if (docbaseUUID == null || docbaseUUID.equals("") || docbaseUUID.startsWith("cafebabe-")) {
                        return EMPTY_LINK_TEXT;
                    }
                    return node.getSession().getNodeByUUID(docbaseUUID).getPath();
                }
            } catch (ValueFormatException e) {
                log.warn("Invalid value format for docbase " + e.getMessage());
                log.debug("Invalid value format for docbase ", e);
            } catch (PathNotFoundException e) {
                log.warn("Docbase not found " + e.getMessage());
                log.debug("Docbase not found ", e);
            } catch (RepositoryException e) {
                log.error("Invalid docbase" + e.getMessage(), e);
            }
            return EMPTY_LINK_TEXT;
        }
    };

    mode = IEditor.Mode.fromString(config.getString("mode"), IEditor.Mode.VIEW);
    try {
        IDataProvider<Integer> provider = new IDataProvider<Integer>() {
            private static final long serialVersionUID = 1L;

            @Override
            public Iterator<Integer> iterator(long first, long count) {
                return new Iterator<Integer>() {
                    int current = 0;

                    public boolean hasNext() {
                        try {
                            Node node = ((JcrNodeModel) FacetSelectTemplatePlugin.this.getDefaultModel())
                                    .getNode();
                            return current < node.getProperty("hippo:facets").getValues().length;
                        } catch (RepositoryException ex) {
                            return false;
                        }
                    }

                    public Integer next() {
                        if (hasNext()) {
                            return Integer.valueOf(current++);
                        } else {
                            throw new NoSuchElementException();
                        }
                    }

                    public void remove() {
                        throw new UnsupportedOperationException();
                    }
                };
            }

            @Override
            public long size() {
                try {
                    Node node = ((JcrNodeModel) FacetSelectTemplatePlugin.this.getDefaultModel()).getNode();
                    return node.getProperty("hippo:facets").getValues().length;
                } catch (RepositoryException ex) {
                    return 0;
                }
            }

            @Override
            public IModel<Integer> model(Integer object) {
                return new Model<Integer>(object);
            }

            @Override
            public void detach() {
            }
        };
        if (IEditor.Mode.EDIT == mode) {
            final JcrPropertyValueModel<String> docbaseModel = new JcrPropertyValueModel<String>(
                    new JcrPropertyModel<String>(node.getProperty("hippo:docbase")));

            IDialogFactory dialogFactory = new IDialogFactory() {
                private static final long serialVersionUID = 1L;

                public AbstractDialog<String> createDialog() {
                    final IPluginConfig dialogConfig = LinkPickerDialogConfig
                            .fromPluginConfig(getPluginConfig(), docbaseModel);
                    return new LinkPickerDialog(context, dialogConfig, new IChainingModel<String>() {
                        private static final long serialVersionUID = 1L;

                        public String getObject() {
                            return docbaseModel.getObject();
                        }

                        public void setObject(String object) {
                            docbaseModel.setObject(object);
                            redraw();
                        }

                        public IModel<String> getChainedModel() {
                            return docbaseModel;
                        }

                        public void setChainedModel(IModel<?> model) {
                            throw new UnsupportedOperationException("Value model cannot be changed");
                        }

                        public void detach() {
                            docbaseModel.detach();
                        }
                    });
                }
            };

            add(new ClearableDialogLink("docbase", displayModel, dialogFactory, getDialogService()) {
                private static final long serialVersionUID = 1L;

                @Override
                public void onClear() {
                    Node node = ((JcrNodeModel) FacetSelectTemplatePlugin.this.getDefaultModel()).getNode();
                    try {
                        node.setProperty("hippo:docbase", node.getSession().getRootNode().getUUID());
                    } catch (RepositoryException e) {
                        log.error("Unable to reset docbase to rootnode uuid", e);
                    }
                    redraw();
                }

                @Override
                public boolean isClearVisible() {
                    // Checking for string literals ain't pretty. It's probably better to create a better display model.
                    return !EMPTY_LINK_TEXT.equals((String) displayModel.getObject());
                }
            });

            add(new DataView<Integer>("arguments", provider) {
                private static final long serialVersionUID = 1L;

                @Override
                public void populateItem(final Item<Integer> item) {
                    Node node = FacetSelectTemplatePlugin.this.getModelObject();
                    final int index = item.getModelObject().intValue();
                    try {
                        item.add(new TextFieldWidget("facet", new JcrPropertyValueModel<String>(index,
                                new JcrPropertyModel<String>(node.getProperty("hippo:facets")))));
                        item.add(new TextFieldWidget("mode", new JcrPropertyValueModel<String>(index,
                                new JcrPropertyModel<String>(node.getProperty("hippo:modes")))));
                        item.add(new TextFieldWidget("value", new JcrPropertyValueModel<String>(index,
                                new JcrPropertyModel<String>(node.getProperty("hippo:values")))));
                        AjaxLink<Void> removeButton;
                        item.add(removeButton = new AjaxLink<Void>("remove") {
                            private static final long serialVersionUID = 1L;

                            @Override
                            public void onClick(AjaxRequestTarget target) {
                                Node node = ((JcrNodeModel) FacetSelectTemplatePlugin.this.getDefaultModel())
                                        .getNode();
                                for (String property : new String[] { "hippo:facets", "hippo:modes",
                                        "hippo:values" }) {
                                    try {
                                        Value[] oldValues = node.getProperty(property).getValues();
                                        Value[] newValues = new Value[oldValues.length - 1];
                                        System.arraycopy(oldValues, 0, newValues, 0, index);
                                        System.arraycopy(oldValues, index + 1, newValues, 0,
                                                oldValues.length - index - 1);
                                        node.setProperty(property, newValues);
                                    } catch (RepositoryException ex) {
                                        log.error("cannot add new facet select line", ex);
                                    }
                                }
                                FacetSelectTemplatePlugin.this.redraw();
                            }
                        });
                        removeButton.setOutputMarkupId(true);
                    } catch (RepositoryException ex) {
                        log.error("cannot read facet select line", ex);
                    }
                }
            });
            AjaxLink<Void> addButton;
            add(addButton = new AjaxLink<Void>("add") {
                private static final long serialVersionUID = 1L;

                @Override
                public void onClick(AjaxRequestTarget target) {
                    Node node = ((JcrNodeModel) FacetSelectTemplatePlugin.this.getDefaultModel()).getNode();
                    for (String property : new String[] { "hippo:facets", "hippo:modes", "hippo:values" }) {
                        try {
                            Value[] oldValues = node.getProperty(property).getValues();
                            Value[] newValues = new Value[oldValues.length + 1];
                            System.arraycopy(oldValues, 0, newValues, 0, oldValues.length);
                            newValues[newValues.length - 1] = node.getSession().getValueFactory()
                                    .createValue("");
                            node.setProperty(property, newValues);
                        } catch (RepositoryException ex) {
                            log.error("cannot add new facet select line", ex);
                        }
                    }
                    FacetSelectTemplatePlugin.this.redraw();
                }
            });
            addButton.setOutputMarkupId(true);
        } else {
            add(new Label("docbase", displayModel));
            add(new DataView<Integer>("arguments", provider) {
                private static final long serialVersionUID = 1L;

                @Override
                public void populateItem(final Item<Integer> item) {
                    try {
                        Node node = FacetSelectTemplatePlugin.this.getModelObject();
                        int index = item.getModelObject().intValue();
                        item.add(new Label("facet",
                                node.getProperty("hippo:facets").getValues()[index].getString()));
                        item.add(new Label("mode",
                                node.getProperty("hippo:modes").getValues()[index].getString()));
                        item.add(new Label("value",
                                node.getProperty("hippo:values").getValues()[index].getString()));
                        Label removeButton;
                        item.add(removeButton = new Label("remove"));
                        removeButton.setVisible(false);
                    } catch (RepositoryException ex) {
                        log.error("cannot read facet select line", ex);
                    }
                }
            });
            Label addButton;
            add(addButton = new Label("add"));
            addButton.setVisible(false);
        }
    } catch (PathNotFoundException ex) {
        log.error("failed to read existing facet select", ex);
    } catch (ValueFormatException ex) {
        log.error("failed to read existing facet select", ex);
    } catch (RepositoryException ex) {
        log.error("failed to read existing facet select", ex);
    }

    setOutputMarkupId(true);
}

From source file:org.hippoecm.frontend.editor.plugins.linkpicker.MirrorTemplatePlugin.java

License:Apache License

private void addOpenLink() {
    AjaxLink openLink = new AjaxLink("openLink") {

        @Override//  w w  w.  j  ava2 s  .  c  o  m
        public boolean isVisible() {
            return hasFilledDocbase();
        }

        @Override
        public void onClick(AjaxRequestTarget target) {
            open();
        }
    };
    openLink.add(new Label("value", getLocalizedNameModel()));
    openLink.add(TitleAttribute.set(getPathModel()));
    openLink.setOutputMarkupId(true);
    fragment.add(openLink);
}

From source file:org.hippoecm.frontend.editor.plugins.linkpicker.MirrorTemplatePlugin.java

License:Apache License

private void addOpenButton() {
    final AjaxLink openButton = new AjaxLink("open") {
        @Override/*ww w .  j  a  v  a2 s  .  c  om*/
        public boolean isVisible() {
            return hasFilledDocbase();
        }

        @Override
        public void onClick(AjaxRequestTarget target) {
            open();
        }
    };
    openButton.setOutputMarkupId(true);
    fragment.add(openButton);
}

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

License:Open Source License

public OpenAnswerPanel(String id, IModel<OpenAnswerDefinition> model, IModel<Category> categoryModel,
        final IModel<Question> questionModel, final IModel<Questionnaire> questionnaireModel,
        IModel<LocaleProperties> localePropertiesModel, final FeedbackPanel feedbackPanel,
        final FeedbackWindow feedbackWindow) {
    super(id, model);
    this.questionModel = questionModel;
    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();

    validatorWindow = new ModalWindow("validatorWindow");
    validatorWindow.setCssClassName("onyx");
    validatorWindow.setInitialWidth(850);
    validatorWindow.setInitialHeight(300);
    validatorWindow.setResizable(true);//from ww  w. j av  a 2s.  co m
    validatorWindow.setTitle(new ResourceModel("Validator"));
    add(validatorWindow);

    initialName = model.getObject().getName();
    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);

    List<DataType> typeChoices = new ArrayList<DataType>(Arrays.asList(DataType.values()));
    typeChoices.remove(DataType.BOOLEAN);
    typeChoices.remove(DataType.DATA);
    dataTypeDropDown = new DropDownChoice<DataType>("dataType", new PropertyModel<DataType>(model, "dataType"),
            typeChoices, new IChoiceRenderer<DataType>() {
                @Override
                public Object getDisplayValue(DataType type) {
                    return new StringResourceModel("DataType." + type, OpenAnswerPanel.this, null).getString();
                }

                @Override
                public String getIdValue(DataType type, int index) {
                    return type.name();
                }
            });

    dataTypeDropDown.setLabel(new ResourceModel("DataType"));
    dataTypeDropDown.add(new RequiredFormFieldBehavior());
    dataTypeDropDown.setNullValid(false);

    add(dataTypeDropDown).add(new SimpleFormComponentLabel("dataTypeLabel", dataTypeDropDown));
    // add(new HelpTooltipPanel("dataTypeHelp", new ResourceModel("DataType.Tooltip")));

    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")));

    PatternValidator numericPatternValidator = new PatternValidator("\\d*");
    // ui Arguments
    Integer size = openAnswer.getInputSize();
    sizeField = new TextField<String>("size", new Model<String>(size == null ? null : String.valueOf(size)));
    sizeField.add(numericPatternValidator);
    sizeField.setLabel(new ResourceModel("SizeLabel"));
    add(new SimpleFormComponentLabel("sizeLabel", sizeField));
    add(sizeField);

    Integer rows = openAnswer.getInputNbRows();
    rowsField = new TextField<String>("rows", new Model<String>(rows == null ? null : String.valueOf(rows)));
    rowsField.add(numericPatternValidator);
    rowsField.setLabel(new ResourceModel("RowsLabel"));
    add(new SimpleFormComponentLabel("rowsLabel", rowsField));
    add(rowsField);

    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(labelsPanel = new LabelsPanel("labels", localePropertiesModel, model, feedbackPanel, feedbackWindow,
            null, visibleStates));

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

    // min/max validators
    String maxValue = null, minValue = null, patternValue = null;
    for (IDataValidator<?> dataValidator : openAnswer.getDataValidators()) {
        IValidator<?> validator = dataValidator.getValidator();
        if (validator instanceof RangeValidator<?>) {
            RangeValidator<?> rangeValidator = (RangeValidator<?>) validator;
            Object minimum = rangeValidator.getMinimum();
            Object maximum = rangeValidator.getMaximum();
            if (dataValidator.getDataType() == DataType.DATE) {
                if (minimum != null)
                    minValue = onyxSettings.getDateFormat().format((Date) minimum);
                if (maximum != null)
                    maxValue = onyxSettings.getDateFormat().format((Date) maximum);
            } else {
                if (minimum != null)
                    minValue = String.valueOf(minimum);
                if (maximum != null)
                    maxValue = String.valueOf(maximum);
            }
        } else if (validator instanceof StringValidator.MaximumLengthValidator) {
            int maximum = ((StringValidator.MaximumLengthValidator) validator).getMaximum();
            if (maximum > 0)
                maxValue = String.valueOf(maximum);
        } else if (validator instanceof MaximumValidator<?>) {
            Object maximum = ((MaximumValidator<?>) validator).getMaximum();
            if (dataValidator.getDataType() == DataType.DATE) {
                if (maximum != null)
                    maxValue = onyxSettings.getDateFormat().format((Date) maximum);
            } else {
                if (maximum != null)
                    maxValue = String.valueOf(maximum);
            }
        } else if (validator instanceof StringValidator.MinimumLengthValidator) {
            int minimum = ((StringValidator.MinimumLengthValidator) validator).getMinimum();
            if (minimum > 0)
                minValue = String.valueOf(minimum);
        } else if (validator instanceof MinimumValidator<?>) {
            Object minimum = ((MinimumValidator<?>) validator).getMinimum();
            if (dataValidator.getDataType() == DataType.DATE) {
                if (minimum != null)
                    minValue = onyxSettings.getDateFormat().format((Date) minimum);
            } else {
                if (minimum != null)
                    minValue = String.valueOf(minimum);
            }
        } else if (validator instanceof PatternValidator) {
            patternValue = ((PatternValidator) validator).getPattern().toString();
        }
    }

    patternField = new TextField<String>("patternValidator", new Model<String>(patternValue));
    patternField.setLabel(new ResourceModel("PatternLabel"));
    patternField.setOutputMarkupId(true);
    add(new SimpleFormComponentLabel("patternLabel", patternField));
    add(patternField);

    minMaxContainer = new WebMarkupContainer("minMaxContainer");
    minMaxContainer.setOutputMarkupId(true);
    add(minMaxContainer);

    minLength = new TextField<String>("minLength", new Model<String>(minValue), String.class);
    minLength.setLabel(new ResourceModel("Minimum.length"));
    minMaxContainer.add(minLength);

    maxLength = new TextField<String>("maxLength", new Model<String>(maxValue), String.class);
    maxLength.setLabel(new ResourceModel("Maximum.length"));
    minMaxContainer.add(maxLength);

    minNumeric = new TextField<String>("minNumeric", new Model<String>(minValue), String.class);
    minNumeric.setLabel(new ResourceModel("Minimum"));
    minNumeric.add(numericPatternValidator);
    minMaxContainer.add(minNumeric);

    maxNumeric = new TextField<String>("maxNumeric", new Model<String>(maxValue), String.class);
    maxNumeric.setLabel(new ResourceModel("Maximum"));
    maxNumeric.add(numericPatternValidator);
    minMaxContainer.add(maxNumeric);

    PatternValidator decimalPatternValidator = new PatternValidator("\\d*(\\.\\d+)?");
    minDecimal = new TextField<String>("minDecimal", new Model<String>(minValue), String.class);
    minDecimal.setLabel(new ResourceModel("Minimum"));
    minDecimal.add(decimalPatternValidator);
    minMaxContainer.add(minDecimal);

    maxDecimal = new TextField<String>("maxDecimal", new Model<String>(maxValue), String.class);
    maxDecimal.setLabel(new ResourceModel("Maximum"));
    maxDecimal.add(decimalPatternValidator);
    minMaxContainer.add(maxDecimal);

    String patternStr = onyxSettings.getDateFormat().toPattern();

    beforeDate = new TextField<String>("beforeDate", new Model<String>(maxValue), String.class);
    beforeDate.setLabel(new Model<String>(
            new StringResourceModel("Before", this, null).getObject() + " (" + patternStr + ")"));
    minMaxContainer.add(beforeDate);

    afterDate = new TextField<String>("afterDate", new Model<String>(minValue), String.class);
    afterDate.setLabel(new Model<String>(
            new StringResourceModel("After", this, null).getObject() + " (" + patternStr + ")"));
    minMaxContainer.add(afterDate);

    minMaxContainer.add(minimumLabel = new SimpleFormComponentLabel("minimumLabel", minLength));
    minMaxContainer.add(maximumLabel = new SimpleFormComponentLabel("maximumLabel", maxLength));

    setMinMaxLabels(dataTypeDropDown.getModelObject());

    add(validators = new OnyxEntityList<ComparingDataSource>("validators", new ValidationDataSourcesProvider(),
            new ValidationDataSourcesColumnProvider(), new ResourceModel("Validators")));

    AjaxLink<Void> addValidator = new AjaxLink<Void>("addValidator") {
        @Override
        public void onClick(AjaxRequestTarget target) {
            if (dataTypeDropDown.getModelObject() == null) {
                info(new StringResourceModel("SelectDataTypeFirst", OpenAnswerPanel.this, null).getString());
                feedbackWindow.setContent(feedbackPanel);
                feedbackWindow.show(target);
            } else {
                validatorWindow.setContent(new ValidationDataSourceWindow("content",
                        new Model<ComparingDataSource>(), questionModel, questionnaireModel,
                        dataTypeDropDown.getModelObject(), validatorWindow) {
                    @Override
                    protected void onSave(@SuppressWarnings("hiding") AjaxRequestTarget target,
                            ComparingDataSource comparingDataSource) {
                        openAnswer.addValidationDataSource(comparingDataSource);
                        target.addComponent(validators);
                    }
                });
                validatorWindow.show(target);
            }
        }
    };
    addValidator.setOutputMarkupId(true);
    add(addValidator.add(new Image("img", Images.ADD)));

    dataTypeDropDown.add(new OnChangeAjaxBehavior() {

        @SuppressWarnings("incomplete-switch")
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            setFieldType();
            String value = dataTypeDropDown.getValue(); // use value because model is not set if validation error
            DataType valueOf = DataType.valueOf(value);
            if (value != null) {
                OpenAnswerDefinition openAnswerDefinition = (OpenAnswerDefinition) getDefaultModelObject();
                for (Data data : openAnswerDefinition.getDefaultValues()) {

                    switch (valueOf) {
                    case DATE:
                        try {
                            onyxSettings.getDateFormat().parse(data.getValueAsString());
                        } catch (ParseException nfe) {
                            error(new StringResourceModel("InvalidCastType", OpenAnswerPanel.this, null)
                                    .getObject());
                            showFeedbackErrorAndReset(target);
                            return;
                        }
                        break;
                    case DECIMAL:
                        try {
                            Double.parseDouble(data.getValueAsString());
                        } catch (NumberFormatException nfe) {
                            error(new StringResourceModel("InvalidCastType", OpenAnswerPanel.this, null)
                                    .getObject());
                            showFeedbackErrorAndReset(target);
                            return;
                        }
                        break;
                    case INTEGER:
                        if (data.getType() == DataType.DECIMAL) {
                            Double d = data.getValue();
                            if (d != d.longValue()) {
                                error(new StringResourceModel("InvalidCastType", OpenAnswerPanel.this, null)
                                        .getObject());
                                showFeedbackErrorAndReset(target);
                                return;
                            }
                        } else {
                            try {
                                Long.parseLong(data.getValueAsString());
                            } catch (NumberFormatException nfe) {
                                error(new StringResourceModel("InvalidCastType", OpenAnswerPanel.this, null)
                                        .getObject());
                                showFeedbackErrorAndReset(target);
                                return;
                            }
                        }
                        break;
                    case TEXT:
                        break;
                    }
                }
                for (Data data : openAnswerDefinition.getDefaultValues()) {
                    switch (valueOf) {
                    case DATE:
                        try {
                            data.setTypeAndValue(valueOf,
                                    onyxSettings.getDateFormat().parse(data.getValueAsString()));
                        } catch (ParseException e) {
                            throw new RuntimeException(e);
                        }
                        break;
                    case DECIMAL:
                        data.setTypeAndValue(valueOf, Double.parseDouble(data.getValueAsString()));
                        break;
                    case INTEGER:
                        if (data.getType() == DataType.DECIMAL) {
                            data.setTypeAndValue(valueOf, ((Double) data.getValue()).longValue());
                        } else {
                            data.setTypeAndValue(valueOf, Integer.parseInt(data.getValueAsString()));
                        }
                        break;
                    case TEXT:
                        data.setTypeAndValue(valueOf,
                                data.getType() == DataType.DATE
                                        ? onyxSettings.getDateFormat().format(data.getValue())
                                        : data.getValueAsString());
                        break;
                    }
                }
            }
            setMinMaxLabels(value == null ? null : valueOf);
            target.addComponent(minMaxContainer);
            target.addComponent(patternField);
            defaultValuesList.refreshList(target);
        }

        private void showFeedbackErrorAndReset(AjaxRequestTarget target) {
            dataTypeDropDown.setModelObject(openAnswer.getDefaultValues().get(0).getType());
            target.addComponent(dataTypeDropDown);
            OpenAnswerPanel.this.feedbackWindow.setContent(OpenAnswerPanel.this.feedbackPanel);
            OpenAnswerPanel.this.feedbackWindow.show(target);
        }
    });

    final IModel<String> addDefaultValuesModel = new Model<String>();

    List<ITab> tabs = new ArrayList<ITab>();
    tabs.add(new AbstractTab(new ResourceModel("Add.simple")) {
        @Override
        public Panel getPanel(String panelId) {
            return new SimpleAddPanel(panelId, addDefaultValuesModel);
        }
    });
    tabs.add(new AbstractTab(new ResourceModel("Add.bulk")) {
        @Override
        public Panel getPanel(String panelId) {
            return new BulkAddPanel(panelId, addDefaultValuesModel);
        }
    });
    add(new AjaxTabbedPanel("addTabs", tabs));

    defaultValuesList = new SortableList<Data>("defaultValues", openAnswer.getDefaultValues(), true) {

        @Override
        public Component getItemTitle(@SuppressWarnings("hiding") String id, Data data) {
            return new Label(id,
                    data.getType() == DataType.DATE ? onyxSettings.getDateFormat().format(data.getValue())
                            : data.getValueAsString());
        }

        @Override
        public void editItem(Data t, AjaxRequestTarget target) {

        }

        @SuppressWarnings("unchecked")
        @Override
        public void deleteItem(final Data data, AjaxRequestTarget target) {
            ((OpenAnswerDefinition) OpenAnswerPanel.this.getDefaultModelObject()).removeDefaultData(data);
            for (Locale locale : OpenAnswerPanel.this.localePropertiesModel.getObject().getLocales()) {
                List<KeyValue> list = OpenAnswerPanel.this.localePropertiesModel.getObject()
                        .getElementLabels(openAnswer).get(locale);
                Collection<KeyValue> toDelete = Collections2.filter(list, new Predicate<KeyValue>() {

                    @Override
                    public boolean apply(KeyValue input) {
                        return input.getKey().equals(data.getValue().toString());
                    }

                });
                list.remove(toDelete.iterator().next());
            }
            OpenAnswerPanel.this.addOrReplace(
                    labelsPanel = new LabelsPanel("labels", OpenAnswerPanel.this.localePropertiesModel,
                            (IModel<OpenAnswerDefinition>) OpenAnswerPanel.this.getDefaultModel(),
                            OpenAnswerPanel.this.feedbackPanel, OpenAnswerPanel.this.feedbackWindow));
            target.addComponent(labelsPanel);
            refreshList(target);
        }

        @Override
        public Button[] getButtons() {
            return null;
        }

    };
    add(defaultValuesList);
    add(new HelpTooltipPanel("defaultValuesHelp", new ResourceModel("DefaultValues.Tooltip")));
}

From source file:org.obiba.onyx.webapp.administration.page.AdministrationPage.java

License:Open Source License

public AdministrationPage() {

    AjaxLink<?> userTab = new AdminTab("userTab") {

        @Override//from   w w  w. j  a  va2s . com
        public Component getTabComponent() {
            return new UserSearchPanel(getContentId());
        }

    };
    add(userTab.setOutputMarkupId(true));
    links.add(userTab);

    AjaxLink<?> dataTab = new AdminTab("dataTab") {

        @Override
        public Component getTabComponent() {
            return new DataManagementPanel(getContentId());
        }

    };
    add(dataTab.setOutputMarkupId(true));
    links.add(dataTab);

    AjaxLink<?> editorTab = new EditorTab("editorTab") {

        @Override
        public Component getTabComponent() {
            for (Module module : moduleRegistry.getModules()) {
                Component editorComponent = module.getEditorPanel(getContentId());
                if (editorComponent != null)
                    return editorComponent;
            }
            return null;
        }

    };
    add(editorTab.setOutputMarkupId(true));
    links.add(editorTab);

    AjaxLink<?> devTab = new AdminTab("devTab") {

        @Override
        public Component getTabComponent() {
            return new DevelopersPanel(getContentId());
        }

        @Override
        public boolean isVisible() {
            return ((OnyxApplication) WebApplication.get()).isDevelopmentMode();
        }
    };
    add(devTab.setOutputMarkupId(true));
    links.add(devTab);

    // Display first permitted tab
    for (AjaxLink<?> link : links) {
        if (link.isActionAuthorized(new Action(Action.RENDER))) {
            Component tabComponent = ((Link) link).getTabComponent();
            add(tabComponent.setOutputMarkupId(true));
            link.add(new AttributeModifier("class", true,
                    new Model<String>("obiba-button ui-corner-all selected")));
            break;
        }
    }

}

From source file:org.obiba.onyx.wicket.wizard.WizardForm.java

License:Open Source License

public WizardForm(String id, IModel model) {
    super(id, model);

    setOutputMarkupId(true);//from   w w w . ja  va 2 s . c o  m

    IBehavior buttonStyleBehavior = new AttributeAppender("class", new Model("ui-corner-all"), " ");

    // finish button
    AjaxButton finish = createFinish();
    finish.add(buttonStyleBehavior);
    finish.setVisible(false);
    finish.setOutputMarkupId(true);
    finish.setOutputMarkupPlaceholderTag(true);
    add(finish);

    // previous button
    AjaxLink link = createPrevious();
    link.setVisible(false);
    link.setOutputMarkupId(true);
    link.setOutputMarkupPlaceholderTag(true);
    link.add(buttonStyleBehavior);
    add(link);

    // next button
    AjaxButton button = createNext();
    button.setOutputMarkupId(true);
    button.setOutputMarkupPlaceholderTag(true);
    button.add(buttonStyleBehavior);
    add(button);

    // cancel button
    AjaxLink cancelLink = createCancel();
    cancelLink.add(buttonStyleBehavior);
    add(cancelLink);

    add(new LanguageStyleBehavior());
}