Example usage for com.google.gwt.view.client NoSelectionModel getLastSelectedObject

Introduction

In this page you can find the example usage for com.google.gwt.view.client NoSelectionModel getLastSelectedObject.

Prototype

public T getLastSelectedObject() 

Source Link

Document

Gets the object that was last selected.

Usage

From source file:com.google.gwt.sample.expenses.client.ExpenseList.java

License:Apache License

/**
 * Create the {@link CellTable}.//from  ww w . j  a  v a  2 s  .co  m
 */
private void createTable() {
    CellTable.Resources resources = GWT.create(TableResources.class);
    table = new CellTable<ReportProxy>(20, resources);
    table.setKeyboardSelectionPolicy(KeyboardSelectionPolicy.DISABLED);
    Styles.Common common = Styles.common();
    table.addColumnStyleName(0, common.spacerColumn());
    table.addColumnStyleName(1, common.expenseListPurposeColumn());
    table.addColumnStyleName(3, common.expenseListDepartmentColumn());
    table.addColumnStyleName(4, common.expenseListCreatedColumn());
    table.addColumnStyleName(5, common.spacerColumn());

    // Add a selection model.
    final NoSelectionModel<ReportProxy> selectionModel = new NoSelectionModel<ReportProxy>();
    table.setSelectionModel(selectionModel);
    selectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            Object selected = selectionModel.getLastSelectedObject();
            if (selected != null && listener != null) {
                listener.onReportSelected((ReportProxy) selected);
            }
        }
    });

    // Spacer column.
    table.addColumn(new SpacerColumn<ReportProxy>());

    // Purpose column.
    addColumn("Purpose", new HighlightCell(), new GetValue<ReportProxy, String>() {
        public String getValue(ReportProxy object) {
            return object.getPurpose();
        }
    }, "purpose");

    // Notes column.
    addColumn("Notes", new HighlightCell(), new GetValue<ReportProxy, String>() {
        public String getValue(ReportProxy object) {
            return object.getNotes();
        }
    }, "notes");

    // Department column.
    addColumn("Department", new TextCell(), new GetValue<ReportProxy, String>() {
        public String getValue(ReportProxy object) {
            return object.getDepartment();
        }
    }, "department");

    // Created column.
    addColumn("Created", new DateCell(DateTimeFormat.getFormat("MMM dd yyyy")),
            new GetValue<ReportProxy, Date>() {
                public Date getValue(ReportProxy object) {
                    return object.getCreated();
                }
            }, "created");

    // Spacer column.
    table.addColumn(new SpacerColumn<ReportProxy>());
}

---

From source file:com.google.gwt.sample.mobilewebapp.client.desktop.DesktopTaskListView.java

License:Apache License

/**
 * Construct a new {@link DesktopTaskListView}.
 *//*from  w  ww . j av a 2  s  . c om*/
public DesktopTaskListView() {

    // Create the CellTable.
    taskList = new DataGrid<TaskProxy>();
    taskList.setKeyboardSelectionPolicy(KeyboardSelectionPolicy.DISABLED);
    taskList.setWidth("100%");

    // Add the task name column.
    Column<TaskProxy, String> nameColumn = new TextColumn<TaskProxy>() {
        @Override
        public String getValue(TaskProxy object) {
            return (object == null) ? null : object.getName();
        }
    };
    taskList.addColumn(nameColumn, "Task");

    // Add the task notes column.
    Column<TaskProxy, String> notesColumn = new TextColumn<TaskProxy>() {
        @Override
        public String getValue(TaskProxy object) {
            return (object == null) ? "" : object.getNotes();
        }
    };
    taskList.addColumn(notesColumn, "Description");

    // Add the task due date column.
    Column<TaskProxy, Date> dateColumn = new Column<TaskProxy, Date>(new DateCell()) {
        @Override
        public Date getValue(TaskProxy object) {
            return (object == null) ? null : object.getDueDate();
        }
    };
    taskList.addColumn(dateColumn, "Due Date");

    /*
     * Inform the presenter when the user selects a task from the task list.
     */
    final NoSelectionModel<TaskProxy> selectionModel = new NoSelectionModel<TaskProxy>();
    taskList.setSelectionModel(selectionModel);
    selectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        @Override
        public void onSelectionChange(SelectionChangeEvent event) {
            // Edit the task.
            if (presenter != null) {
                presenter.selectTask(selectionModel.getLastSelectedObject());
            }
        }
    });

    // Initialize the widget.
    initWidget(taskList);
}

---

From source file:com.google.gwt.sample.mobilewebapp.client.mobile.MobileTaskListView.java

License:Apache License

/**
 * Construct a new {@link MobileTaskListView}.
 *//*w  w w .  ja  va 2s. c  o m*/
public MobileTaskListView() {

    // Create the CellList.
    CellListResources cellListRes = GWT.create(CellListResources.class);
    taskList = new CellList<TaskProxy>(new TaskProxyCell(), cellListRes);
    taskList.setKeyboardSelectionPolicy(KeyboardSelectionPolicy.DISABLED);

    /*
     * Inform the presenter when the user selects a task from the task list. We
     * use a NoSelectionModel because we don't want the task to remain selected,
     * we just want to be notified of the selection event.
     */
    final NoSelectionModel<TaskProxy> selectionModel = new NoSelectionModel<TaskProxy>();
    taskList.setSelectionModel(selectionModel);
    selectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            // Edit the task.
            if (presenter != null) {
                presenter.selectTask(selectionModel.getLastSelectedObject());
            }
        }
    });

    // Initialize the widget.
    initWidget(uiBinder.createAndBindUi(this));
}

---

From source file:fr.mncc.gwttoolbox.datagrid.client.Grid.java

License:Open Source License

/**
 * Add a single row selection model to the grid.
 *//*w w w  .  ja  v a 2s . c  o m*/
public void addSelectionModel() {
    final NoSelectionModel<T> selectionModel = new NoSelectionModel<T>(Grid.<T>createKeyProvider());
    selectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        @Override
        public void onSelectionChange(SelectionChangeEvent event) {
            Grid.this.onSelectionChanged(selectionModel.getLastSelectedObject());
        }
    });
    setSelectionModel(selectionModel);
}

---

From source file:net.cbtltd.client.form.LeaseForm.java

private TableField<Task> createMaintenance() {

    //-----------------------------------------------
    // Maintenance selection handler
    //-----------------------------------------------
    final NoSelectionModel<Task> selectionModel = new NoSelectionModel<Task>();
    SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            TaskPopup.getInstance().show(selectionModel.getLastSelectedObject(), maintenanceTable);
        }//  www .  j  av  a 2 s .co  m
    };
    selectionModel.addSelectionChangeHandler(selectionHandler);

    //-----------------------------------------------
    // Maintenance table
    //-----------------------------------------------
    maintenanceTable = new TableField<Task>(this, null, new MaintenanceTaskTable(), selectionModel,
            MAINTENANCE_ROWS, tab++);

    maintenanceTable.setEmptyValue(maintenancetableEmpty());
    maintenanceTable.setOrderby(Task.DUEDATE);

    maintenanceTable.setTableError(new TableError() {
        @Override
        public boolean error() {
            return (leaseField.noValue());
        }
    });

    maintenanceTable.setTableExecutor(new TableExecutor<MaintenanceTaskTable>() {
        public void execute(MaintenanceTaskTable action) {
            action.setId(leaseField.getValue());
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Change button
    //-----------------------------------------------
    final Column<Task, Task> changeButton = new Column<Task, Task>(
            new ActionCell<Task>(AbstractField.CONSTANTS.allChange(),
                    AbstractField.CSS.cbtTableFieldChangeButton(), new Delegate<Task>() {
                        public void execute(Task task) {
                            TaskPopup.getInstance().show(task, maintenanceTable);
                        }
                    })) {
        public Task getValue(Task task) {
            return task;
        }//TODO: selectForm(row); 
    };

    //-----------------------------------------------
    // Create button
    //-----------------------------------------------
    final ActionHeader<Task> createButton = new ActionHeader<Task>(
            new ActionCell<Task>(AbstractField.CONSTANTS.allCreate(),
                    AbstractField.CSS.cbtTableFieldCreateButton(), new Delegate<Task>() {
                        public void execute(Task task) {
                            if (leaseField.noValue()) {
                                AbstractField.addMessage(Level.ERROR, CONSTANTS.leaseError(), leaseField);
                            }
                            //TODO:                        else {TaskPopup.getInstance().show(Task.Type.Maintenance, leaseentities, maintenanceTable);}
                        }
                    })) {
        public Task getValue(Task task) {
            return task;
        }
    };

    maintenanceTable.addColumn(changeButton, createButton);

    //-----------------------------------------------
    // Due Date column
    //-----------------------------------------------
    Column<Task, Date> date = new Column<Task, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(Task task) {
            return Time.getDateClient(task.getDuedate());
        }
    };
    maintenanceTable.addDateColumn(date, CONSTANTS.maintenanceHeaders()[col++], Task.DUEDATE);

    //-----------------------------------------------
    // Name column
    //-----------------------------------------------
    Column<Task, String> name = new Column<Task, String>(new TextCell()) {
        @Override
        public String getValue(Task task) {
            return task.getName();
        }
    };
    maintenanceTable.addStringColumn(name, CONSTANTS.maintenanceHeaders()[col++], Task.NAME);

    //-----------------------------------------------
    // Actor column
    //-----------------------------------------------
    Column<Task, String> actorname = new Column<Task, String>(new TextCell()) {
        @Override
        public String getValue(Task task) {
            return task.getActorname();
        }
    };
    maintenanceTable.addStringColumn(actorname, CONSTANTS.maintenanceHeaders()[col++], Task.ACTORNAME);

    //-----------------------------------------------
    // State column
    //-----------------------------------------------
    Column<Task, String> state = new Column<Task, String>(new TextCell()) {
        @Override
        public String getValue(Task task) {
            return task.getState();
        }
    };
    maintenanceTable.addStringColumn(state, CONSTANTS.maintenanceHeaders()[col++], Task.STATE);

    //-----------------------------------------------
    // Amount column
    //-----------------------------------------------
    Column<Task, Number> amount = new Column<Task, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(Task task) {
            return task.getAmount();
        }
    };
    maintenanceTable.addNumberColumn(amount, CONSTANTS.maintenanceHeaders()[col++], Task.AMOUNT);

    //-----------------------------------------------
    // Currency column
    //-----------------------------------------------
    Column<Task, String> currency = new Column<Task, String>(new TextCell()) {
        @Override
        public String getValue(Task task) {
            return task.getCurrency();
        }
    };
    maintenanceTable.addStringColumn(currency, CONSTANTS.maintenanceHeaders()[col++]);

    //-----------------------------------------------
    // Notes column
    //-----------------------------------------------
    Column<Task, String> notes = new Column<Task, String>(new TextCell()) {
        @Override
        public String getValue(Task task) {
            return task.getNotes();
        }
    };
    maintenanceTable.addStringColumn(notes, CONSTANTS.maintenanceHeaders()[col++], Task.NOTES);

    return maintenanceTable;
}

---

From source file:net.cbtltd.client.form.OrganizationForm.java

License:Open Source License

private ScrollPanel createActor() {
    ScrollPanel scroll = new ScrollPanel();
    HorizontalPanel panel = new HorizontalPanel();
    scroll.add(panel);/*  w  w  w  .  j a  va 2s.c o  m*/

    //-----------------------------------------------
    // Party Selection model
    //-----------------------------------------------
    final NoSelectionModel<Party> selectionModel = new NoSelectionModel<Party>();
    SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            actor = selectionModel.getLastSelectedObject();
            sessionTable.execute();
        }
    };
    selectionModel.addSelectionChangeHandler(selectionHandler);

    //-----------------------------------------------
    // Party table
    //-----------------------------------------------
    actorTable = new TableField<Party>(this, null, new OrganizationActorTable(), selectionModel, ACTOR_ROWS,
            tab++);

    actorTable.setEmptyValue(actortableEmpty());
    actorTable.addStyleName(CSS.actorStyle());

    actorTable.setTableError(new TableError() {
        @Override
        public boolean error() {
            return organizationField.noId();
        }
    });

    actorTable.setTableExecutor(new TableExecutor<OrganizationActorTable>() {
        public void execute(OrganizationActorTable action) {
            action.setId(organizationField.getId());
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Change button
    //-----------------------------------------------
    Column<Party, Party> changeButton = new Column<Party, Party>(
            new ActionCell<Party>(AbstractField.CONSTANTS.allChange(),
                    AbstractField.CSS.cbtTableFieldChangeButton(), new Delegate<Party>() {
                        public void execute(Party actor) {
                            ActorPopup.getInstance().show(actor, actorTable);
                        }
                    })) {
        public Party getValue(Party actor) {
            return actor;
        }
    };

    //-----------------------------------------------
    // Create button
    //-----------------------------------------------
    ActionHeader<Party> createButton = new ActionHeader<Party>(
            new ActionCell<Party>(AbstractField.CONSTANTS.allCreate(),
                    AbstractField.CSS.cbtTableFieldCreateButton(), new Delegate<Party>() {
                        public void execute(Party actor) {
                            ActorPopup.getInstance().show(actorTable);
                        }
                    })) {
        public Party getValue(Party actor) {
            return actor;
        }
    };

    actorTable.addColumn(changeButton, createButton);

    //-----------------------------------------------
    // Name column
    //-----------------------------------------------
    Column<Party, String> name = new Column<Party, String>(new TextCell()) {
        @Override
        public String getValue(Party actor) {
            return actor.getName(20);
        }
    };
    actorTable.addStringColumn(name, CONSTANTS.actortableHeaders()[col++], Party.NAME);

    //-----------------------------------------------
    // Email Address column
    //-----------------------------------------------
    Column<Party, String> emailaddress = new Column<Party, String>(new TextCell()) {
        @Override
        public String getValue(Party actor) {
            return actor.getEmailaddress();
        }
    };
    actorTable.addStringColumn(emailaddress, CONSTANTS.actortableHeaders()[col++], Party.EMAILADDRESS);

    //-----------------------------------------------
    // Phone column
    //-----------------------------------------------
    Column<Party, String> dayphone = new Column<Party, String>(new TextCell()) {
        @Override
        public String getValue(Party actor) {
            return actor.getDayphone();
        }
    };
    actorTable.addStringColumn(dayphone, CONSTANTS.actortableHeaders()[col++], Party.DAYPHONE);

    //-----------------------------------------------
    // Mobile Phone column
    //-----------------------------------------------
    Column<Party, String> mobilephone = new Column<Party, String>(new TextCell()) {
        @Override
        public String getValue(Party actor) {
            return actor.getMobilephone();
        }
    };
    actorTable.addStringColumn(mobilephone, CONSTANTS.actortableHeaders()[col++], Party.MOBILEPHONE);
    panel.add(actorTable);

    //-----------------------------------------------
    // Session table
    //-----------------------------------------------
    sessionTable = new TableField<Session>(this, null, new PartySessionTable(), SESSION_ROWS, tab++);

    sessionTable.setOrderby(Session.ID + HasTable.ORDER_BY_DESC);
    sessionTable.addStyleName(CSS.sessionStyle());
    sessionTable.setVisible(false);
    sessionTable.setTableError(new TableError() {
        @Override
        public boolean error() {
            return (actor == null || actor.noId());
        }
    });

    sessionTable.setTableExecutor(new TableExecutor<PartySessionTable>() {
        @Override
        public void execute(PartySessionTable action) {
            action.setId(actor.getId());
        }
    });

    col = 0;

    //-----------------------------------------------
    // ID column
    //-----------------------------------------------
    Column<Session, String> id = new Column<Session, String>(new TextCell()) {
        @Override
        public String getValue(Session session) {
            return session.getId();
        }
    };
    sessionTable.addStringColumn(id, CONSTANTS.sessiontableHeaders()[col++], Session.ID);

    //-----------------------------------------------
    // Login column
    //-----------------------------------------------
    Column<Session, Date> login = new Column<Session, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(Session session) {
            return Time.getDateClient(session.getLogin());
        }
    };
    sessionTable.addDateColumn(login, CONSTANTS.sessiontableHeaders()[col++], Session.LOGIN);

    //-----------------------------------------------
    // Logout column
    //-----------------------------------------------
    Column<Session, Date> logout = new Column<Session, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(Session session) {
            return Time.getDateClient(session.getLogout());
        }
    };
    sessionTable.addDateColumn(logout, CONSTANTS.sessiontableHeaders()[col++], Session.LOGOUT);

    panel.add(sessionTable);

    return scroll;
}

---

From source file:net.cbtltd.client.form.OrganizationForm.java

License:Open Source License

private ScrollPanel createTax() {
    final ScrollPanel panel = new ScrollPanel();
    //-----------------------------------------------
    // Selection model
    //-----------------------------------------------
    final NoSelectionModel<Tax> selectionModel = new NoSelectionModel<Tax>();
    SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            TaxPopup.getInstance().show(NameId.Type.Party.name(), AbstractRoot.getOrganizationid(),
                    selectionModel.getLastSelectedObject(), taxTable);
        }/*from  w  w w.  j ava  2 s .  c om*/
    };
    selectionModel.addSelectionChangeHandler(selectionHandler);

    //-----------------------------------------------
    // Tax table
    //-----------------------------------------------
    taxTable = new TableField<Tax>(this, null, new TaxTable(), TAX_ROWS, tab++);

    taxTable.setEmptyValue(taxtableEmpty());
    taxTable.setOrderby(Tax.DATE);

    taxTable.setTableError(new TableError() {
        @Override
        public boolean error() {
            return (AbstractRoot.noOrganizationid());
        }
    });

    taxTable.setTableExecutor(new TableExecutor<TaxTable>() {
        public void execute(TaxTable action) {
            //            action.setPartyid(AbstractRoot.getOrganizationid());
            action.setEntitytype(NameId.Type.Party.name());
            action.setEntityid(AbstractRoot.getOrganizationid());
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Change button
    //-----------------------------------------------
    final Column<Tax, Tax> changeButton = new Column<Tax, Tax>(
            new ActionCell<Tax>(AbstractField.CONSTANTS.allChange(),
                    AbstractField.CSS.cbtTableFieldChangeButton(), new Delegate<Tax>() {
                        public void execute(Tax tax) {
                            TaxPopup.getInstance().show(NameId.Type.Party.name(),
                                    AbstractRoot.getOrganizationid(), tax, taxTable);
                        }
                    })) {
        public Tax getValue(Tax price) {
            return price;
        }
    };

    //-----------------------------------------------
    // Create button
    //-----------------------------------------------
    final ActionHeader<Tax> createButton = new ActionHeader<Tax>(
            new ActionCell<Tax>(AbstractField.CONSTANTS.allCreate(),
                    AbstractField.CSS.cbtTableFieldCreateButton(), new Delegate<Tax>() {
                        public void execute(Tax price) {
                            if (AbstractRoot.noOrganizationid()) {
                                AbstractField.addMessage(Level.TERSE, CONSTANTS.organizationError(),
                                        organizationField);
                            } else {
                                TaxPopup.getInstance().show(NameId.Type.Party.name(),
                                        AbstractRoot.getOrganizationid(), taxTable);
                            }
                        }
                    })) {
        public Tax getValue(Tax price) {
            return price;
        }
    };

    taxTable.addColumn(changeButton, createButton);

    //-----------------------------------------------
    // Jurisdiction column
    //-----------------------------------------------
    Column<Tax, String> party = new Column<Tax, String>(new TextCell()) {
        @Override
        public String getValue(Tax tax) {
            return tax.getPartyname();
        }
    };
    taxTable.addStringColumn(party, CONSTANTS.taxtableHeaders()[col++]);

    //-----------------------------------------------
    // Name column
    //-----------------------------------------------
    Column<Tax, String> name = new Column<Tax, String>(new TextCell()) {
        @Override
        public String getValue(Tax tax) {
            return tax.getName();
        }
    };
    taxTable.addStringColumn(name, CONSTANTS.taxtableHeaders()[col++]);

    //-----------------------------------------------
    // Type column
    //-----------------------------------------------
    Column<Tax, String> type = new Column<Tax, String>(new TextCell()) {
        @Override
        public String getValue(Tax tax) {
            return tax.getType();
        }
    };
    taxTable.addStringColumn(type, CONSTANTS.taxtableHeaders()[col++]);

    //-----------------------------------------------
    // From Date column
    //-----------------------------------------------
    Column<Tax, Date> date = new Column<Tax, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(Tax tax) {
            return Time.getDateClient(tax.getDate());
        }
    };
    taxTable.addDateColumn(date, CONSTANTS.taxtableHeaders()[col++], Tax.DATE);

    //-----------------------------------------------
    // Amount column
    //-----------------------------------------------
    Column<Tax, Number> amount = new Column<Tax, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(Tax tax) {
            return tax.getAmount();
        }
    };
    taxTable.addNumberColumn(amount, CONSTANTS.taxtableHeaders()[col++], Tax.AMOUNT);

    //-----------------------------------------------
    // Threshold column
    //-----------------------------------------------
    //      Column<Tax, Number> threshold = new Column<Tax, Number>(new NumberCell(AbstractField.AF)) {
    //         @Override
    //         public Integer getValue( Tax tax ) {return tax.getThreshold();}
    //      };
    //      taxTable.addNumberColumn( threshold, CONSTANTS.taxtableHeaders()[col++], Tax.THRESHOLD);

    //-----------------------------------------------
    // Notes column
    //-----------------------------------------------
    Column<Tax, String> notes = new Column<Tax, String>(new TextCell()) {
        @Override
        public String getValue(Tax tax) {
            return tax.getNotes();
        }
    };
    taxTable.addStringColumn(notes, CONSTANTS.taxtableHeaders()[col++]);

    panel.add(taxTable);
    return panel;
}

---

From source file:net.cbtltd.client.form.OrganizationForm.java

License:Open Source License

private ScrollPanel createPartner() {
    ScrollPanel panel = new ScrollPanel();

    //-----------------------------------------------
    // Selection model
    //-----------------------------------------------
    final NoSelectionModel<Partner> selectionModel = new NoSelectionModel<Partner>();
    SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            PartnerPopup.getInstance().show(selectionModel.getLastSelectedObject(), partnerTable);
        }// w ww.j av a2 s  .  c  o  m
    };
    selectionModel.addSelectionChangeHandler(selectionHandler);

    //-----------------------------------------------
    // Partner table
    //-----------------------------------------------
    partnerTable = new TableField<Partner>(this, null, new PartnerTable(), PARTNER_ROWS, tab++);

    partnerTable.setEmptyValue(partnertableEmpty());
    partnerTable.setOrderby(Partner.PARTYNAME);

    partnerTable.setTableError(new TableError() {
        @Override
        public boolean error() {
            return (AbstractRoot.noOrganizationid());
        }
    });

    partnerTable.setTableExecutor(new TableExecutor<PartnerTable>() {
        public void execute(PartnerTable action) {
            action.setOrganizationid(AbstractRoot.getOrganizationid());
            action.setState(null);
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Change button
    //-----------------------------------------------
    final Column<Partner, Partner> changeButton = new Column<Partner, Partner>(
            new ActionCell<Partner>(AbstractField.CONSTANTS.allChange(),
                    AbstractField.CSS.cbtTableFieldChangeButton(), new Delegate<Partner>() {
                        public void execute(Partner partner) {
                            PartnerPopup.getInstance().show(partner, partnerTable);
                        }
                    })) {
        public Partner getValue(Partner partner) {
            return partner;
        }
    };

    //-----------------------------------------------
    // Create button
    //-----------------------------------------------
    final ActionHeader<Partner> createButton = new ActionHeader<Partner>(
            new ActionCell<Partner>(AbstractField.CONSTANTS.allCreate(),
                    AbstractField.CSS.cbtTableFieldCreateButton(), new Delegate<Partner>() {
                        public void execute(Partner partner) {
                            if (organizationField.noValue()) {
                                AbstractField.addMessage(Level.TERSE, CONSTANTS.organizationError(),
                                        organizationField);
                            } else {
                                PartnerPopup.getInstance().show(partnerTable);
                            }
                        }
                    })) {
        public Partner getValue(Partner partner) {
            return partner;
        }
    };

    partnerTable.addColumn(changeButton, createButton);

    //-----------------------------------------------
    // Partner Name column
    //-----------------------------------------------
    Column<Partner, String> partyname = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getPartyname();
        }
    };
    partnerTable.addStringColumn(partyname, CONSTANTS.partnertableHeaders()[col++], Partner.PARTYNAME);

    //-----------------------------------------------
    // State column
    //-----------------------------------------------
    Column<Partner, String> state = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getState();
        }
    };
    partnerTable.addStringColumn(state, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Currency column
    //-----------------------------------------------
    Column<Partner, String> currency = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getCurrency();
        }
    };
    partnerTable.addStringColumn(currency, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Date Format column
    //-----------------------------------------------
    Column<Partner, String> dateformat = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getDateformat();
        }
    };
    partnerTable.addStringColumn(dateformat, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Commission column
    //-----------------------------------------------
    Column<Partner, Number> commission = new Column<Partner, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(Partner partner) {
            return partner.getCommission();
        }
    };
    partnerTable.addNumberColumn(commission, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Discount column
    //-----------------------------------------------
    Column<Partner, Number> discount = new Column<Partner, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(Partner partner) {
            return partner.getDiscount();
        }
    };
    partnerTable.addNumberColumn(discount, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Alert CRON column
    //-----------------------------------------------
    Column<Partner, String> alertcron = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getAlertcron();
        }
    };
    partnerTable.addStringColumn(alertcron, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Price CRON column
    //-----------------------------------------------
    Column<Partner, String> pricecron = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getPricecron();
        }
    };
    partnerTable.addStringColumn(pricecron, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Product CRON column
    //-----------------------------------------------
    Column<Partner, String> productcron = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getProductcron();
        }
    };
    partnerTable.addStringColumn(productcron, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Schedule CRON column
    //-----------------------------------------------
    Column<Partner, String> schedulecron = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getSchedulecron();
        }
    };
    partnerTable.addStringColumn(schedulecron, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Special CRON column
    //-----------------------------------------------
    Column<Partner, String> specialcron = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getSpecialcron();
        }
    };
    partnerTable.addStringColumn(specialcron, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Default Web Address column
    //-----------------------------------------------
    Column<Partner, String> webaddress = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getWebaddress();
        }
    };
    partnerTable.addStringColumn(webaddress, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Book Email Address column
    //-----------------------------------------------
    Column<Partner, String> bookemailaddress = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getBookemailaddress();
        }
    };
    partnerTable.addStringColumn(bookemailaddress, CONSTANTS.partnertableHeaders()[col++]);

    //-----------------------------------------------
    // Book Web Address column
    //-----------------------------------------------
    Column<Partner, String> bookwebaddress = new Column<Partner, String>(new TextCell()) {
        @Override
        public String getValue(Partner partner) {
            return partner.getBookwebaddress();
        }
    };
    partnerTable.addStringColumn(bookwebaddress, CONSTANTS.partnertableHeaders()[col++]);

    panel.add(partnerTable);
    return panel;
}

---

From source file:net.cbtltd.client.form.PartyForm.java

/**
 * //from www.  j a v a2 s . com
 *
 * @return 
 */
private ScrollPanel createContact() {
    ScrollPanel panel = new ScrollPanel();

    //-----------------------------------------------
    // Contact selection handler
    //-----------------------------------------------
    final NoSelectionModel<Contact> selectionModel = new NoSelectionModel<Contact>();
    final SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            if (partyField.noValue()) {
                AbstractField.addMessage(Level.ERROR, CONSTANTS.partyError(), partyField);
            } else {
                ContactPopup.getInstance().show(NameId.Type.Party, partyField.getValue(),
                        selectionModel.getLastSelectedObject(), contactTable);
            }
        }
    };
    selectionModel.addSelectionChangeHandler(selectionHandler);

    //-----------------------------------------------
    // Contact table
    //-----------------------------------------------
    contactTable = new TableField<Contact>(this, null, new ContactTable(), selectionModel, CONTACT_ROWS, tab++);

    contactTable.setTableError(new TableError() {
        @Override
        public boolean error() {
            return partyField.noValue();
        }
    });

    contactTable.setTableExecutor(new TableExecutor<ContactTable>() {
        public void execute(ContactTable action) {
            action.setActivity(NameId.Type.Party.name());
            action.setId(partyField.getValue());
        }
    });

    contactTable.setEmptyValue(contacttableEmpty());
    contactTable.setOrderby(Contact.DATE);

    int col = 0;

    //-----------------------------------------------
    // Change button
    //-----------------------------------------------
    final Column<Contact, Contact> changeButton = new Column<Contact, Contact>(
            new ActionCell<Contact>(AbstractField.CONSTANTS.allChange(),
                    AbstractField.CSS.cbtTableFieldChangeButton(), new Delegate<Contact>() {
                        public void execute(Contact contact) {
                            if (partyField.noValue()) {
                                AbstractField.addMessage(Level.ERROR, CONSTANTS.partyError(), partyField);
                            } else {
                                ContactPopup.getInstance().show(NameId.Type.Party, partyField.getValue(),
                                        contact, contactTable);
                            }
                        }
                    })) {
        public Contact getValue(Contact contact) {
            return contact;
        }
    };

    //-----------------------------------------------
    // Create button
    //-----------------------------------------------
    final ActionHeader<Contact> createButton = new ActionHeader<Contact>(
            new ActionCell<Contact>(AbstractField.CONSTANTS.allCreate(),
                    AbstractField.CSS.cbtTableFieldCreateButton(), new Delegate<Contact>() {
                        public void execute(Contact contact) {
                            if (partyField.noValue()) {
                                AbstractField.addMessage(Level.ERROR, CONSTANTS.partyError(), partyField);
                            } else {
                                ContactPopup.getInstance().show(NameId.Type.Party, partyField.getValue(),
                                        contactTable);
                            }
                        }
                    })) {
        public Contact getValue(Contact contact) {
            return contact;
        }
    };

    contactTable.addColumn(changeButton, createButton);

    //-----------------------------------------------
    // Date column
    //-----------------------------------------------
    Column<Contact, Date> date = new Column<Contact, Date>(new DateCell(AbstractRoot.getDTF())) {
        @Override
        public Date getValue(Contact contact) {
            return Time.getDateClient(contact.getDate());
        }
    };
    contactTable.addDateColumn(date, CONSTANTS.contactHeaders()[col++], Contact.DATE);

    //-----------------------------------------------
    // Addressee column
    //-----------------------------------------------
    Column<Contact, String> name = new Column<Contact, String>(new TextCell()) {
        @Override
        public String getValue(Contact contact) {
            return contact.getName(30);
        }
    };
    contactTable.addStringColumn(name, CONSTANTS.contactHeaders()[col++], Contact.NAME);

    //-----------------------------------------------
    // Medium column
    //-----------------------------------------------
    Column<Contact, String> type = new Column<Contact, String>(new TextCell()) {
        @Override
        public String getValue(Contact contact) {
            return contact.getType();
        }
    };
    contactTable.addStringColumn(type, CONSTANTS.contactHeaders()[col++], Contact.TYPE);

    //-----------------------------------------------
    // Notes column
    //-----------------------------------------------
    Column<Contact, String> notes = new Column<Contact, String>(new TextCell()) {
        @Override
        public String getValue(Contact contact) {
            return contact.getNotes(80);
        }
    };
    contactTable.addStringColumn(notes, CONSTANTS.contactHeaders()[col++], Contact.NOTES);

    panel.add(contactTable);
    return panel;
}

---

From source file:net.cbtltd.client.form.PartyForm.java

/**
 * //from  www .  ja  v  a2  s  .c om
 *
 * @return 
 */
private ScrollPanel createRelation() {
    ScrollPanel panel = new ScrollPanel();

    //-----------------------------------------------
    // Relationship Selection model
    //-----------------------------------------------
    final NoSelectionModel<Party> selectionModel = new NoSelectionModel<Party>();
    SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            Party party = selectionModel.getLastSelectedObject();
            partyField.setValue(party.getId());
            partyRead.execute(true);
        }
    };
    selectionModel.addSelectionChangeHandler(selectionHandler);

    //-----------------------------------------------
    // Relationship table
    //-----------------------------------------------
    relationTable = new TableField<Party>(this, null, new PartyRelationTable(), selectionModel, RELATION_ROWS,
            tab++);

    relationTable.setEmptyValue(relationtableEmpty());
    reservationTable.setOrderby(Party.STATE); // + HasTable.ORDER_BY_DESC);
    //      relationTable.addStyleName(CSS.relationStyle());

    relationTable.setTableError(new TableError() {
        @Override
        public boolean error() {
            return partyField.noValue();
        }
    });

    relationTable.setTableExecutor(new TableExecutor<PartyRelationTable>() {
        public void execute(PartyRelationTable action) {
            action.setId(partyField.getValue());
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Rank column
    //-----------------------------------------------
    Column<Party, Number> rank = new Column<Party, Number>(new NumberCell(AbstractField.IF)) {
        @Override
        public Integer getValue(Party relation) {
            return relation.getRank();
        }
    };
    relationTable.addNumberColumn(rank, CONSTANTS.relationtableHeaders()[col++]);

    //-----------------------------------------------
    // Relationship column
    //-----------------------------------------------
    Column<Party, String> state = new Column<Party, String>(new TextCell()) {
        @Override
        public String getValue(Party relation) {
            return relation.getState();
        }
    };
    relationTable.addStringColumn(state, CONSTANTS.relationtableHeaders()[col++]);

    //-----------------------------------------------
    // Name column
    //-----------------------------------------------
    Column<Party, String> name = new Column<Party, String>(new TextCell()) {
        @Override
        public String getValue(Party relation) {
            return relation.getName(20);
        }
    };
    relationTable.addStringColumn(name, CONSTANTS.relationtableHeaders()[col++]);

    //-----------------------------------------------
    // Emailaddress column
    //-----------------------------------------------
    Column<Party, String> emailaddress = new Column<Party, String>(new TextCell()) {
        @Override
        public String getValue(Party relation) {
            return relation.getEmailaddress();
        }
    };
    relationTable.addStringColumn(emailaddress, CONSTANTS.relationtableHeaders()[col++]);

    //-----------------------------------------------
    // Phone column
    //-----------------------------------------------
    Column<Party, String> dayphone = new Column<Party, String>(new TextCell()) {
        @Override
        public String getValue(Party relation) {
            return relation.getDayphone();
        }
    };
    relationTable.addStringColumn(dayphone, CONSTANTS.relationtableHeaders()[col++]);

    //-----------------------------------------------
    // Mobile Phone column
    //-----------------------------------------------
    Column<Party, String> mobilephone = new Column<Party, String>(new TextCell()) {
        @Override
        public String getValue(Party relation) {
            return relation.getMobilephone();
        }
    };
    relationTable.addStringColumn(mobilephone, CONSTANTS.relationtableHeaders()[col++]);
    panel.add(relationTable);

    return panel;
}

---

• «
• 1
• 2
• 3
• »