Example usage for org.apache.wicket.markup.html.form FormComponentLabel FormComponentLabel

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

Introduction

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

Prototype

public FormComponentLabel(String id, LabeledWebMarkupContainer component) 

Source Link

Document

Constructor

Usage

From source file:org.patientview.radar.web.components.YesNoRadioGroup.java

License:Open Source License

public YesNoRadioGroup(String id, boolean includeLabels, boolean includeUnknownOption) {
    super(id);//ww w.  ja  v a2s  . c  om

    // Option for yes and no
    Radio<Boolean> yes = new Radio<Boolean>("yes", new Model<Boolean>(Boolean.TRUE));
    Radio<Boolean> no = new Radio<Boolean>("no", new Model<Boolean>(Boolean.FALSE));
    add(yes, no);

    // Only put in labels if we're told to
    if (includeLabels) {
        add(yes, new FormComponentLabel("yesLabel", yes));
        add(no, new FormComponentLabel("noLabel", no));
    }

    if (includeUnknownOption) {
        // Option for unknown (null)
        Radio<Boolean> unknown = new Radio<Boolean>("unknown", new Model<Boolean>(null));
        add(unknown, new FormComponentLabel("unknownLabel", unknown));
    }
}

From source file:org.patientview.radar.web.panels.firstvisit.YesNoRadioGroupPanel.java

License:Open Source License

public YesNoRadioGroupPanel(String id, boolean addLabels, CompoundPropertyModel model, String property,
        AjaxFormChoiceComponentUpdatingBehavior toggleBehaviour) {
    super(id);/*www.  ja  v a  2s  .  co  m*/

    RadioGroup<Boolean> radioGroup = new RadioGroup<Boolean>("group", model.bind(property));
    if (toggleBehaviour != null) {
        radioGroup.add(toggleBehaviour);
    }
    add(radioGroup);

    // Yes, No
    Radio<Boolean> yes = new Radio<Boolean>("yes", new Model<Boolean>(Boolean.TRUE));
    Radio<Boolean> no = new Radio<Boolean>("no", new Model<Boolean>(Boolean.FALSE));
    radioGroup.add(yes, no);

    // If we're using labels add them too
    if (addLabels) {
        radioGroup.add(new FormComponentLabel("yesLabel", yes));
        radioGroup.add(new FormComponentLabel("noLabel", no));
    }
}

From source file:org.sakaiproject.attendance.tool.panels.AttendanceGradePanel.java

License:Educational Community License

private Form<AttendanceGrade> createGradeForm() {
    Form<AttendanceGrade> gForm = new Form<AttendanceGrade>("attendance-grade", this.agIModel) {
        @Override//from   ww  w  .  java  2  s.c  om
        public void onSubmit() {
            AttendanceGrade aG = (AttendanceGrade) getDefaultModelObject();

            boolean result;

            if (Boolean.TRUE.equals(attendanceSite.getUseAutoGrading())
                    && Boolean.FALSE.equals(aG.getOverride())) {
                result = attendanceLogic.regrade(aG, true) != null;
            } else {
                result = attendanceLogic.updateAttendanceGrade(aG);
            }

            String displayName = sakaiProxy.getUserSortName(aG.getUserID());

            if (result) {
                String grade = aG.getGrade() == null ? "null" : aG.getGrade().toString();
                getSession().info(new StringResourceModel("attendance.grade.update.success", null,
                        new String[] { grade, displayName }).getString());
            } else {
                getSession().error(new StringResourceModel("attendance.grade.update.failure", null,
                        new String[] { displayName }).getString());
            }

        }
    };

    final Double maximumGrade = this.attendanceSite.getMaximumGrade();

    NumberTextField<Double> points = new NumberTextField<Double>("grade") {
        @Override
        public boolean isEnabled() {
            return maximumGrade != null && (Boolean.FALSE.equals(attendanceSite.getUseAutoGrading())
                    || Boolean.TRUE.equals(agIModel.getObject().getOverride()));
        }
    };
    points.setMinimum(0.0);
    points.setStep(0.1);

    points.add(new AjaxFormSubmitBehavior(gForm, "input") {
        @Override
        protected void onError(AjaxRequestTarget target) {
            target.add(pageFeedbackPanel);
        }

        @Override
        protected void onSubmit(AjaxRequestTarget target) {
            if (target != null) {
                target.add(pageFeedbackPanel);
            }
        }
    });

    Label maximum;

    if (maximumGrade == null) {
        maximum = new Label("maximum", "/ -");
        points.add(new AttributeModifier("title", new StringResourceModel("attendance.grade.tooltip.disabled",
                null, new String[] { new ResourceModel("settings.link.label").getObject() })));
    } else {
        maximum = new Label("maximum", "/ " + maximumGrade.toString());
    }
    maximum.setVisible(!this.isEnabled());

    final CheckBox override = new CheckBox("override", new PropertyModel<>(gForm.getModelObject(), "override"));
    override.setVisible(this.attendanceSite.getUseAutoGrading() && this.isEnabled());
    override.add(new AjaxFormSubmitBehavior(gForm, "change") {
        @Override
        protected void onSubmit(AjaxRequestTarget target) {
            if (target != null) {
                target.add(pageFeedbackPanel);
                target.add(points);
            }
        }

        @Override
        protected void onError(AjaxRequestTarget target) {
            target.add(pageFeedbackPanel);
        }
    });
    gForm.add(override);

    final FormComponentLabel overrideLabel = new FormComponentLabel("overrideLabel", override);
    overrideLabel.setVisible(this.attendanceSite.getUseAutoGrading() && this.isEnabled());
    gForm.add(overrideLabel);

    gForm.add(maximum);
    gForm.add(points);

    return gForm;
}

From source file:org.sakaiproject.delegatedaccess.tool.pages.SearchAccessPage.java

License:Educational Community License

private void main() {
    disableLink(searchAccessLink);/*from w  w w  . j  ava2s  .c  om*/

    final AbstractReadOnlyModel resultModel = new AbstractReadOnlyModel<String>() {

        @Override
        public String getObject() {
            if (firstLoad) {
                return "";
            } else {
                if (provider.getData().size() == 0) {
                    if (searchTypeEid.equals(selectedSearchType)) {
                        if (eid == null || "".equals(eid.trim())) {
                            return new StringResourceModel("noEidEntered", null).getObject();
                        } else {
                            User u = getUser();
                            if (u == null) {
                                return new StringResourceModel("eidDoesNotExist", null).getObject();
                            } else {
                                return new StringResourceModel("noResultsUser", null).getObject();
                            }
                        }
                    } else {
                        return new StringResourceModel("noResultsHierarchy", null).getObject();
                    }
                } else {
                    return "";
                }
            }
        }

    };
    add(new Label("resultInfo", resultModel) {
        @Override
        public boolean isVisible() {
            return !"".equals(resultModel.getObject());
        }
    });

    //create form
    final Form<?> form = new Form("form") {
        protected void onSubmit() {
            super.onSubmit();
            firstLoad = false;
            if (provider != null) {
                provider.detachManually();
            }
        }
    };
    form.setOutputMarkupId(true);

    //search by label:
    form.add(new Label("searchByLabel", new StringResourceModel("searchByLabel", null)));

    //setup radio buttons for search type:
    final RadioGroup group = new RadioGroup("searchGroup",
            new PropertyModel<String>(this, "selectedSearchType"));

    final Radio hierarchyRadio = new Radio("searchByHierarchy", new Model<String>(searchTypeHierarchy));
    FormComponentLabel hierarchyLabel = new FormComponentLabel("searchByHierarchyLabel", hierarchyRadio);
    hierarchyLabel.add(
            new Label("searchByHierarchyLabelText", new StringResourceModel("searchByHierarchyLabel", null)));
    group.add(hierarchyRadio);
    group.add(hierarchyLabel);
    group.add(hierarchyRadio.add(new AjaxEventBehavior("onchange") {
        @Override
        protected void onEvent(AjaxRequestTarget arg0) {
            selectedSearchType = searchTypeHierarchy;
        }
    }));

    Radio eidRadio = new Radio("searchByEid", new Model<String>(searchTypeEid));
    FormComponentLabel eidRadioLabel = new FormComponentLabel("searchByEidLabel", eidRadio);
    eidRadioLabel.add(new Label("searchByEidLabelText", new StringResourceModel("searchByEidLabel", null)));
    group.add(eidRadio);
    group.add(eidRadioLabel);
    group.add(eidRadio.add(new AjaxEventBehavior("onchange") {
        @Override
        protected void onEvent(AjaxRequestTarget arg0) {
            selectedSearchType = searchTypeEid;
        }
    }));

    form.add(group);

    //input for hierarchy fields:
    WebMarkupContainer hierarchyDiv = new WebMarkupContainer("hierarchyFields") {
        @Override
        protected void onComponentTag(ComponentTag tag) {
            if (!selectedSearchType.equals(searchTypeHierarchy)) {
                //set to hidden
                tag.put("style", "display:none");
            }
        }
    };
    final Comparator<SelectOption> optionComparator = new SelectOptionComparator();
    if (hierarchySelectOptions == null || hierarchySelectOptions.size() == 0) {
        hierarchySelectOptions = new HashMap<String, List<SelectOption>>();
        HierarchyNodeSerialized rootNode = projectLogic.getRootNodeId();
        nodeSelects = new HashMap<String, SelectOption>();
        nodeSelectOrder = new ArrayList<String>();
        if (rootNode != null && rootNode.id != null && !"".equals(rootNode.id)) {
            Set<HierarchyNodeSerialized> nodes = projectLogic.getDirectNodes(rootNode.id);
            List<SelectOption> options = new ArrayList<SelectOption>();
            if (nodes != null) {
                for (HierarchyNodeSerialized node : nodes) {
                    options.add(new SelectOption(node.description, node.id));
                }
            }
            Collections.sort(options, optionComparator);
            hierarchySelectOptions.put(rootNode.id, options);

            //since nothing is selected, set the node selection to null
            nodeSelects.put(rootNode.id, null);
            //add the root node as the first selection            
            nodeSelectOrder.add(rootNode.id);
        }
    }
    final ChoiceRenderer choiceRenderer = new ChoiceRenderer("label", "value");
    DataView dropdowns = new DataView("hierarchyDropdowns", new IDataProvider<String>() {

        @Override
        public void detach() {

        }

        @Override
        public Iterator<? extends String> iterator(int first, int count) {
            return nodeSelectOrder.subList(first, first + count).iterator();
        }

        @Override
        public IModel<String> model(final String arg0) {
            return new AbstractReadOnlyModel<String>() {
                private static final long serialVersionUID = 1L;

                @Override
                public String getObject() {
                    return arg0;
                }
            };
        }

        @Override
        public int size() {
            return nodeSelectOrder.size();
        }

    }) {

        @Override
        protected void populateItem(Item item) {
            final String itemNodeId = item.getModelObject().toString();
            final DropDownChoice choice = new DropDownChoice("hierarchyLevel", new NodeSelectModel(itemNodeId),
                    hierarchySelectOptions.get(itemNodeId), choiceRenderer);
            //keeps the null option (choose one) after a user selects an option
            choice.setNullValid(true);
            choice.add(new AjaxFormComponentUpdatingBehavior("onchange") {
                protected void onUpdate(AjaxRequestTarget target) {
                    List<String> newOrder = new ArrayList<String>();
                    for (String nodeId : nodeSelectOrder) {
                        newOrder.add(nodeId);
                        if (nodeId.equals(itemNodeId)) {
                            break;
                        }
                    }
                    if (choice.getModelObject() != null
                            && !"".equals(((SelectOption) choice.getModelObject()).getValue())) {
                        String value = ((SelectOption) choice.getModelObject()).getValue();
                        //check if options list exist for newly selected node
                        if (!hierarchySelectOptions.containsKey(value)) {
                            Set<HierarchyNodeSerialized> nodes = projectLogic.getDirectNodes(value);
                            List<SelectOption> options = new ArrayList<SelectOption>();
                            if (nodes != null) {
                                for (HierarchyNodeSerialized node : nodes) {
                                    options.add(new SelectOption(node.description, node.id));
                                }
                                Collections.sort(options, optionComparator);
                            }
                            hierarchySelectOptions.put(value, options);
                        }
                        //check to see if there are any additional direct children, or if
                        //this is the last node
                        if (hierarchySelectOptions.containsKey(value)
                                && hierarchySelectOptions.get(value).size() > 0) {
                            //update node select order
                            newOrder.add(value);
                        }
                    }
                    nodeSelectOrder = newOrder;
                    //refresh everything:
                    target.addComponent(form);
                }
            });
            item.add(choice);
        }

    };
    hierarchyDiv.add(dropdowns);

    //include lower perms checkbox:
    CheckBox checkbox = new CheckBox("includeLowerPerms", new PropertyModel(this, "includeLowerPerms"));
    FormComponentLabel checkboxLabel = new FormComponentLabel("includeLowerPermsLabel", checkbox);
    checkboxLabel.add(
            new Label("includeLowerPermsLabelText", new StringResourceModel("includeLowerPermsLabel", null)));
    hierarchyDiv.add(checkboxLabel);
    hierarchyDiv.add(checkbox);

    form.add(hierarchyDiv);

    //input for eid fields:
    WebMarkupContainer eidDiv = new WebMarkupContainer("eidFields") {
        @Override
        protected void onComponentTag(ComponentTag tag) {
            if (!selectedSearchType.equals(searchTypeEid)) {
                //set to hidden
                tag.put("style", "display:none");
            }
        }
    };
    final PropertyModel<String> eidModel = new PropertyModel<String>(this, "eid");
    TextField<String> eidText = new TextField<String>("eid", eidModel);
    eidDiv.add(eidText);

    form.add(eidDiv);

    add(form);

    //Display Results:

    //Headers:
    Link<Void> userIdSort = new Link<Void>("userIdSortLink") {
        private static final long serialVersionUID = 1L;

        public void onClick() {
            changeOrder(DelegatedAccessConstants.SEARCH_COMPARE_EID);
        }

        @Override
        public boolean isVisible() {
            return provider.size() > 0 && searchTypeHierarchy.equals(selectedSearchType);
        }
    };
    add(userIdSort);
    Link<Void> nameSort = new Link<Void>("nameSortLink") {
        private static final long serialVersionUID = 1L;

        public void onClick() {
            changeOrder(DelegatedAccessConstants.SEARCH_COMPARE_SORT_NAME);
        }

        @Override
        public boolean isVisible() {
            return provider.size() > 0 && searchTypeHierarchy.equals(selectedSearchType);
        }
    };
    add(nameSort);
    Link<Void> typeSort = new Link<Void>("typeSortLink") {
        private static final long serialVersionUID = 1L;

        public void onClick() {
            changeOrder(DelegatedAccessConstants.SEARCH_COMPARE_TYPE);
        }

        @Override
        public boolean isVisible() {
            return provider.size() > 0;
        }
    };
    add(typeSort);
    Link<Void> levelSort = new Link<Void>("levelSortLink") {
        private static final long serialVersionUID = 1L;

        public void onClick() {
            changeOrder(DelegatedAccessConstants.SEARCH_COMPARE_LEVEL);
        }

        @Override
        public boolean isVisible() {
            return provider.size() > 0;
        }
    };
    add(levelSort);
    Link<Void> accessSort = new Link<Void>("accessSortLink") {
        private static final long serialVersionUID = 1L;

        public void onClick() {
            changeOrder(DelegatedAccessConstants.SEARCH_COMPARE_ACCESS);
        }
    };
    add(accessSort);
    Label restrictedToolsHeader = new Label("restrictedToolsHeader",
            new StringResourceModel("restrictedToolsHeader", null)) {
        @Override
        public boolean isVisible() {
            return provider.size() > 0;
        }
    };
    add(restrictedToolsHeader);
    Label hierarchyHeader = new Label("hierarchyHeader", new StringResourceModel("hierarchyHeader", null)) {
        @Override
        public boolean isVisible() {
            return provider.size() > 0;
        }
    };
    add(hierarchyHeader);

    //Display user (if available)
    final AbstractReadOnlyModel userModel = new AbstractReadOnlyModel() {
        @Override
        public Object getObject() {
            if (searchTypeEid.equals(selectedSearchType) && eid != null && !"".equals(eid.trim())) {
                User u = getUser();
                if (u != null) {
                    return u.getDisplayName();
                }
            }
            return "";
        }
    };
    Label userName = new Label("userName", userModel) {
        @Override
        public boolean isVisible() {
            return searchTypeEid.equals(selectedSearchType) && eid != null && !"".equals(eid)
                    && !"".equals(userModel.getObject());
        }
    };
    add(userName);

    add(new Link("editUserLink") {
        private static final long serialVersionUID = 1L;

        public void onClick() {
            User u = getUser();
            if (u != null) {
                setResponsePage(new UserEditPage(u.getId(), u.getDisplayName()));
            }
        }
    });

    Link removeAllPermsLink = new Link("removeAllPerms") {
        private static final long serialVersionUID = 1L;

        public void onClick() {
            User u = getUser();
            if (u != null) {
                projectLogic.removeAllPermsForUser(u.getId());
                provider.detachManually();
            }
        }

        @Override
        public boolean isVisible() {
            return sakaiProxy.isSuperUser();
        }
    };
    String confirm = new StringResourceModel("confirmRemoveAll", null).getObject();
    removeAllPermsLink.add(new SimpleAttributeModifier("onclick", "return confirm('" + confirm + "');"));
    add(removeAllPermsLink);

    //tool id=>title map:
    final Map<String, String> toolTitleMap = new HashMap<String, String>();
    final List<ListOptionSerialized> blankRestrictedTools = projectLogic.getEntireToolsList();
    for (ListOptionSerialized opt : blankRestrictedTools) {
        toolTitleMap.put(opt.getId(), opt.getName());
    }

    //Data
    String[] tmpHierarchy = sakaiProxy
            .getServerConfigurationStrings(DelegatedAccessConstants.HIERARCHY_SITE_PROPERTIES);
    if (tmpHierarchy == null || tmpHierarchy.length == 0) {
        tmpHierarchy = DelegatedAccessConstants.DEFAULT_HIERARCHY;
    }
    final String[] hierarchy = new String[tmpHierarchy.length + 1];
    //include the root as part of the hierarchy:
    hierarchy[0] = sakaiProxy.getRootName();
    for (int i = 1; i < hierarchy.length; i++) {
        hierarchy[i] = tmpHierarchy[i - 1];
    }
    provider = new AccessSearchResultDataProvider();
    dataView = new DataView<AccessSearchResult>("searchResult", provider) {
        @Override
        public void populateItem(final Item item) {
            final AccessSearchResult searchResult = (AccessSearchResult) item.getModelObject();
            item.add(new Label("userId", searchResult.getEid()) {
                @Override
                public boolean isVisible() {
                    return searchTypeHierarchy.equals(selectedSearchType);
                }
            });
            item.add(new Label("name", searchResult.getSortName()));
            item.add(new Label("type", new StringResourceModel("accessType" + searchResult.getType(), null)));
            String level = "";
            if (hierarchy != null && searchResult.getLevel() < hierarchy.length) {
                level = hierarchy[searchResult.getLevel()];
            } else {
                level = new StringResourceModel("site", null).getObject();
            }
            item.add(new Label("level", level));
            AbstractReadOnlyModel<String> accessModel = new AbstractReadOnlyModel<String>() {
                @Override
                public String getObject() {
                    String returnVal = "";
                    if (searchResult.getAccess() != null && searchResult.getAccess().length == 2) {
                        returnVal = searchResult.getAccess()[0] + ":" + searchResult.getAccess()[1];
                        if (":".equals(returnVal)) {
                            returnVal = "";
                        }
                    }
                    return returnVal;
                }
            };
            item.add(new Label("access", accessModel));
            item.add(new ListView<String>("restrictedTools", searchResult.getRestrictedTools()) {

                @Override
                protected void populateItem(ListItem<String> arg0) {
                    String toolTitle = arg0.getDefaultModelObject().toString();
                    if (toolTitleMap.containsKey(toolTitle)) {
                        toolTitle = toolTitleMap.get(toolTitle);
                    }
                    arg0.add(new Label("restrictedTool", toolTitle));
                }
            });
            item.add(new ListView<String>("hierarchy", searchResult.getHierarchyNodes()) {

                @Override
                protected void populateItem(ListItem<String> arg0) {
                    String hierarchyStr = "|-";
                    for (String hierarchyLevel : searchResult.getHierarchyNodes()) {
                        if (hierarchyLevel.equals(arg0.getDefaultModelObject())) {
                            break;
                        }
                        hierarchyStr += "-";
                    }
                    hierarchyStr += arg0.getDefaultModelObject();
                    arg0.add(new Label("hierarchyTitle", hierarchyStr));
                }

            });
            Link<Void> viewLink = new Link("view") {
                private static final long serialVersionUID = 1L;

                public void onClick() {
                    setResponsePage(new SearchAccessPage(false, searchResult.getEid()));
                }

                @Override
                public boolean isVisible() {
                    return searchTypeHierarchy.equals(selectedSearchType);
                }
            };
            item.add(viewLink);
            Link<Void> userIdLink = new Link("edit") {
                private static final long serialVersionUID = 1L;

                public void onClick() {
                    setResponsePage(new UserEditPage(searchResult.getId(), searchResult.getDisplayName()));
                }

                @Override
                public boolean isVisible() {
                    return searchTypeHierarchy.equals(selectedSearchType);
                }
            };
            item.add(userIdLink);
            Link<Void> removeLink = new Link("remove") {
                @Override
                public void onClick() {
                    projectLogic.removeAccess(searchResult.getNodeId(), searchResult.getId(),
                            searchResult.getType());
                    provider.detachManually();
                }

                @Override
                public boolean isVisible() {
                    return searchResult.isCanEdit();
                }
            };
            String confirm = new StringResourceModel("confirmRemove", null).getObject();
            removeLink.add(new SimpleAttributeModifier("onclick", "return confirm('" + confirm + "');"));
            item.add(removeLink);

            //add css class
            if (rowIndex == 100) {
                rowIndex = 0;
            }
            item.add(new AttributeAppender("class", true, new Model<String>(rowIndex % 2 == 0 ? "even" : "odd"),
                    ";"));
            rowIndex++;
        }

        @Override
        public boolean isVisible() {
            return provider.size() > 0;
        }

        @Override
        protected void onComponentTag(ComponentTag arg0) {

        }

    };
    dataView.setOutputMarkupId(true);
    dataView.setItemReuseStrategy(new DefaultItemReuseStrategy());
    dataView.setItemsPerPage(DelegatedAccessConstants.SEARCH_RESULTS_PAGE_SIZE);
    add(dataView);
    //Navigation
    //add a pager to our table, only visible if we have more than SEARCH_RESULTS_PAGE_SIZE items
    add(new PagingNavigator("navigatorTop", dataView) {

        @Override
        public boolean isVisible() {
            if (provider.size() > DelegatedAccessConstants.SEARCH_RESULTS_PAGE_SIZE) {
                return true;
            }
            return false;
        }

        @Override
        public void onBeforeRender() {
            super.onBeforeRender();

            //clear the feedback panel messages
            clearFeedback(feedbackPanel);
        }
    });
    add(new PagingNavigator("navigatorBottom", dataView) {

        @Override
        public boolean isVisible() {
            if (provider.size() > DelegatedAccessConstants.SEARCH_RESULTS_PAGE_SIZE) {
                return true;
            }
            return false;
        }

        @Override
        public void onBeforeRender() {
            super.onBeforeRender();

            //clear the feedback panel messages
            clearFeedback(feedbackPanel);
        }
    });

}