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

Introduction

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

Prototype

@SuppressWarnings("unchecked")
default T getModelObject() 

Source Link

Document

Typesafe getter for the model's object

Usage

From source file:com.evolveum.midpoint.web.page.admin.resources.CapabilitiesPanel.java

License:Apache License

private void createCapabilityButton(String id) {
    AjaxLink<Boolean> button = new AjaxLink<Boolean>(id, new PropertyModel<Boolean>(getModel(), id)) {

        @Override/*from ww w.j a  va2 s .c  o m*/
        public void onClick(AjaxRequestTarget target) {
            // TODO:
        }

    };

    button.add(new AttributeModifier("class",
            button.getModelObject() ? "btn btn-app btn-resource-capability bg-light-blue"
                    : "btn btn-app btn-resource-capability bg-gray text-light-blue"));

    button.add(new Label("label", new ResourceModel("CapabilitiesType." + id)));

    add(button);
}

---

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  ww  .j  a  va 2s.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.security.web.SecurityNamedServiceNewPage.java

License:Open Source License

public SecurityNamedServiceNewPage(Class<S> serviceClass) {
    //keys that allow us to dynamically set the page title and description based on 
    // type of service class / extension point
    add(new Label("title1", createTitleModel(serviceClass).getString()));
    add(new Label("title2", createTitleModel(serviceClass).getString()));

    List<SecurityNamedServicePanelInfo> panelInfos = lookupPanelInfos(serviceClass);

    AjaxLinkGroup<SecurityNamedServicePanelInfo> serviceLinks = new AjaxLinkGroup<SecurityNamedServicePanelInfo>(
            "services", panelInfos) {

        @Override/*from  w  w  w .j a v  a 2  s  .c om*/
        protected void populateItem(ListItem<SecurityNamedServicePanelInfo> item) {
            SecurityNamedServicePanelInfo panelInfo = item.getModelObject();
            item.add(newLink("link", item.getModel()).add(new Label("title", createShortTitleModel(panelInfo)))
                    .setEnabled(item.getIndex() > 0));
            item.add(new Label("description", createDescriptionModel(panelInfo)));
        }

        @Override
        protected void onClick(AjaxLink<SecurityNamedServicePanelInfo> link, AjaxRequestTarget target) {
            updatePanel(link.getModelObject(), target);
        }
    };

    add(new WebMarkupContainer("servicesContainer").add(serviceLinks).setOutputMarkupId(true));

    add(form = new Form<T>("form"));

    //add a container for the actual panel, since we will dynamically update it
    form.add(panelContainer = new WebMarkupContainer("panel"));
    panelContainer.setOutputMarkupId(true);

    form.add(new SubmitLink("save", form) {
        @Override
        public void onSubmit() {
            handleSubmit(getForm());
        }
    });
    form.add(new Link("cancel") {
        @Override
        public void onClick() {
            doReturn();
        }
    });

    updatePanel(panelInfos.get(0), null);
}

---