Example usage for com.google.gwt.cell.client NumberCell NumberCell

Introduction

In this page you can find the example usage for com.google.gwt.cell.client NumberCell NumberCell.

Prototype

public NumberCell(SafeHtmlRenderer<String> renderer) 

Source Link

Document

Construct a new NumberCell using decimal format and the given SafeHtmlRenderer .

Usage

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

License:Apache License

private CellTable<ExpenseProxy> initTable() {
    CellTable.Resources resources = GWT.create(TableResources.class);
    table = new CellTable<ExpenseProxy>(100, resources, Expenses.EXPENSE_RECORD_KEY_PROVIDER);
    Styles.Common common = Styles.common();

    table.addColumnStyleName(0, common.spacerColumn());
    table.addColumnStyleName(1, common.expenseDetailsDateColumn());
    table.addColumnStyleName(3, common.expenseDetailsCategoryColumn());
    table.addColumnStyleName(4, common.expenseDetailsAmountColumn());
    table.addColumnStyleName(5, common.expenseDetailsApprovalColumn());
    table.addColumnStyleName(6, common.spacerColumn());

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

    // Created column.
    GetValue<ExpenseProxy, Date> createdGetter = new GetValue<ExpenseProxy, Date>() {
        public Date getValue(ExpenseProxy object) {
            return object.getCreated();
        }//from  w ww .  j  ava2  s  .c  o m
    };
    defaultComparator = createColumnComparator(createdGetter, false);
    Comparator<ExpenseProxy> createdDesc = createColumnComparator(createdGetter, true);
    addColumn(table, "Created", new DateCell(DateTimeFormat.getFormat("MMM dd yyyy")), createdGetter,
            defaultComparator, createdDesc);
    lastComparator = defaultComparator;

    // Description column.
    addColumn(table, "Description", new TextCell(), new GetValue<ExpenseProxy, String>() {
        public String getValue(ExpenseProxy object) {
            return object.getDescription();
        }
    });

    // Category column.
    addColumn(table, "Category", new TextCell(), new GetValue<ExpenseProxy, String>() {
        public String getValue(ExpenseProxy object) {
            return object.getCategory();
        }
    });

    // Amount column.
    final GetValue<ExpenseProxy, Double> amountGetter = new GetValue<ExpenseProxy, Double>() {
        public Double getValue(ExpenseProxy object) {
            return object.getAmount();
        }
    };
    Comparator<ExpenseProxy> amountAsc = createColumnComparator(amountGetter, false);
    Comparator<ExpenseProxy> amountDesc = createColumnComparator(amountGetter, true);
    addColumn(table, "Amount", new NumberCell(NumberFormat.getCurrencyFormat()),
            new GetValue<ExpenseProxy, Number>() {
                public Number getValue(ExpenseProxy object) {
                    return amountGetter.getValue(object);
                }
            }, amountAsc, amountDesc);

    // Dialog box to obtain a reason for a denial
    denialPopup.addCloseHandler(new CloseHandler<PopupPanel>() {
        public void onClose(CloseEvent<PopupPanel> event) {
            String reasonDenied = denialPopup.getReasonDenied();
            ExpenseProxy record = denialPopup.getExpenseRecord();
            if (reasonDenied == null || reasonDenied.length() == 0) {
                // Clear the view data.
                final Object key = items.getKey(record);
                approvalCell.clearViewData(key);

                // We need to redraw the table to reset the select box.
                syncCommit(record, null);
            } else {
                updateExpenseRecord(record, "Denied", reasonDenied);
            }

            // Return focus to the table.
            table.setFocus(true);
        }
    });

    // Approval column.
    approvalCell = new ApprovalCell();
    Column<ExpenseProxy, String> approvalColumn = addColumn(table, "Approval Status", approvalCell,
            new GetValue<ExpenseProxy, String>() {
                public String getValue(ExpenseProxy object) {
                    return object.getApproval();
                }
            });
    approvalColumn.setFieldUpdater(new FieldUpdater<ExpenseProxy, String>() {
        public void update(int index, final ExpenseProxy object, String value) {
            if ("Denied".equals(value)) {
                denialPopup.setExpenseRecord(object);
                denialPopup.setReasonDenied(object.getReasonDenied());
                denialPopup.popup();
            } else {
                updateExpenseRecord(object, value, "");
            }
        }
    });

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

    return table;
}

---

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

License:Apache License

private CellTable<ExpenseProxy> initTable() {
    CellTable.Resources resources = GWT.create(TableResources.class);
    table = new CellTable<ExpenseProxy>(100, resources, new EntityProxyKeyProvider<ExpenseProxy>());
    Styles.Common common = Styles.common();

    table.addColumnStyleName(0, common.spacerColumn());
    table.addColumnStyleName(1, common.expenseDetailsDateColumn());
    table.addColumnStyleName(3, common.expenseDetailsCategoryColumn());
    table.addColumnStyleName(4, common.expenseDetailsAmountColumn());
    table.addColumnStyleName(5, common.expenseDetailsApprovalColumn());
    table.addColumnStyleName(6, common.spacerColumn());

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

    // Created column.
    GetValue<ExpenseProxy, Date> createdGetter = new GetValue<ExpenseProxy, Date>() {
        public Date getValue(ExpenseProxy object) {
            return object.getCreated();
        }//  ww w  . j  a  v  a 2s .c o m
    };
    defaultComparator = createColumnComparator(createdGetter, false);
    Comparator<ExpenseProxy> createdDesc = createColumnComparator(createdGetter, true);
    addColumn(table, "Created", new DateCell(DateTimeFormat.getFormat("MMM dd yyyy")), createdGetter,
            defaultComparator, createdDesc);
    lastComparator = defaultComparator;

    // Description column.
    addColumn(table, "Description", new TextCell(), new GetValue<ExpenseProxy, String>() {
        public String getValue(ExpenseProxy object) {
            return object.getDescription();
        }
    });

    // Category column.
    addColumn(table, "Category", new TextCell(), new GetValue<ExpenseProxy, String>() {
        public String getValue(ExpenseProxy object) {
            return object.getCategory();
        }
    });

    // Amount column.
    final GetValue<ExpenseProxy, Double> amountGetter = new GetValue<ExpenseProxy, Double>() {
        public Double getValue(ExpenseProxy object) {
            return object.getAmount();
        }
    };
    Comparator<ExpenseProxy> amountAsc = createColumnComparator(amountGetter, false);
    Comparator<ExpenseProxy> amountDesc = createColumnComparator(amountGetter, true);
    addColumn(table, "Amount", new NumberCell(NumberFormat.getCurrencyFormat()),
            new GetValue<ExpenseProxy, Number>() {
                public Number getValue(ExpenseProxy object) {
                    return amountGetter.getValue(object);
                }
            }, amountAsc, amountDesc);

    // Dialog box to obtain a reason for a denial
    denialPopup.addCloseHandler(new CloseHandler<PopupPanel>() {
        public void onClose(CloseEvent<PopupPanel> event) {
            String reasonDenied = denialPopup.getReasonDenied();
            ExpenseProxy record = denialPopup.getExpenseRecord();
            if (reasonDenied == null || reasonDenied.length() == 0) {
                // Clear the view data.
                final Object key = items.getKey(record);
                approvalCell.clearViewData(key);

                // We need to redraw the table to reset the select box.
                syncCommit(record, null);
            } else {
                updateExpenseRecord(record, "Denied", reasonDenied);
            }

            // Return focus to the table.
            table.setFocus(true);
        }
    });

    // Approval column.
    approvalCell = new ApprovalCell();
    Column<ExpenseProxy, String> approvalColumn = addColumn(table, "Approval Status", approvalCell,
            new GetValue<ExpenseProxy, String>() {
                public String getValue(ExpenseProxy object) {
                    return object.getApproval();
                }
            });
    approvalColumn.setFieldUpdater(new FieldUpdater<ExpenseProxy, String>() {
        public void update(int index, final ExpenseProxy object, String value) {
            if ("Denied".equals(value)) {
                denialPopup.setExpenseRecord(object);
                denialPopup.setReasonDenied(object.getReasonDenied());
                denialPopup.popup();
            } else {
                updateExpenseRecord(object, value, "");
            }
        }
    });

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

    return table;
}

---

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

private TableField<Rule> createRule() {

    //-----------------------------------------------
    // Rule selection handler
    //-----------------------------------------------
    final NoSelectionModel<Rule> selectionModel = new NoSelectionModel<Rule>();
    SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            //TODO:            RulePopup.getInstance().show(selectionModel.getLastSelectedObject(), ruleTable);
        }//  w  ww.  jav a  2 s.c  o  m
    };
    selectionModel.addSelectionChangeHandler(selectionHandler);

    //-----------------------------------------------
    // Rule table
    //-----------------------------------------------
    ruleTable = new TableField<Rule>(this, null, new LeaseRuleTable(), selectionModel, RULE_ROWS, tab++);

    ruleTable.setEmptyValue(ruletableEmpty());
    //      ruleTable.setOrderby(Rule.DUEDATE);

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

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

    int col = 0;

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

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

    ruleTable.addColumn(changeButton, createButton);

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

    //-----------------------------------------------
    // Quantity column
    //-----------------------------------------------
    Column<Rule, Number> amount = new Column<Rule, Number>(new NumberCell(AbstractField.QF)) {
        @Override
        public Double getValue(Rule rule) {
            return rule.getQuantity();
        }
    };
    ruleTable.addNumberColumn(amount, CONSTANTS.ruleHeaders()[col++], Rule.QUANTITY);

    //-----------------------------------------------
    // Unit column
    //-----------------------------------------------
    Column<Rule, String> currency = new Column<Rule, String>(new TextCell()) {
        @Override
        public String getValue(Rule rule) {
            return rule.getUnit();
        }
    };
    ruleTable.addStringColumn(currency, CONSTANTS.ruleHeaders()[col++]);

    //-----------------------------------------------
    // Value column
    //-----------------------------------------------
    Column<Rule, Number> value = new Column<Rule, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(Rule rule) {
            return rule.getValue();
        }
    };
    ruleTable.addNumberColumn(value, CONSTANTS.ruleHeaders()[col++], Rule.VALUE);

    //-----------------------------------------------
    // From Date column
    //-----------------------------------------------
    Column<Rule, Date> fromdate = new Column<Rule, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(Rule rule) {
            return Time.getDateClient(rule.getFromdate());
        }
    };
    ruleTable.addDateColumn(fromdate, CONSTANTS.ruleHeaders()[col++], Rule.FROMDATE);

    //-----------------------------------------------
    // To Date column
    //-----------------------------------------------
    Column<Rule, Date> todate = new Column<Rule, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(Rule rule) {
            return Time.getDateClient(rule.getTodate());
        }
    };
    ruleTable.addDateColumn(todate, CONSTANTS.ruleHeaders()[col++], Rule.TODATE);

    return ruleTable;
}

---

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);
        }/* w  ww.j  a va 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.LeaseForm.java

private FlowPanel createFinancial() {

    final FlowPanel panel = new FlowPanel();
    panel.add(createFinancialcommands());

    //-----------------------------------------------
    // Financial Transaction selection handler
    //-----------------------------------------------
    final NoSelectionModel<EventJournal> selectionModel = new NoSelectionModel<EventJournal>();
    SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            //TODO:            JournalPopup.getInstance().show(selectionModel.getLastSelectedObject(), leaseentities, eventjournalTable);
        }//from  ww w.  j a  v  a  2s.  c  o  m
    };
    selectionModel.addSelectionChangeHandler(selectionHandler);

    //-----------------------------------------------
    // Financial Transaction table
    //-----------------------------------------------
    eventjournalTable = new TableField<EventJournal>(this, null, new LeaseEventJournalTable(), selectionModel,
            EVENTJOURNAL_ROWS, tab++);

    eventjournalTable.setEmptyValue(eventactiontableEmpty());

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

    eventjournalTable.setTableExecutor(new TableExecutor<LeaseEventJournalTable>() {
        public void execute(LeaseEventJournalTable action) {
            action.setId(leaseField.getValue());
            leaseBalance.execute(true);
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Change button
    //-----------------------------------------------
    Column<EventJournal, EventJournal> changeButton = new Column<EventJournal, EventJournal>(
            new ActionCell<EventJournal>(AbstractField.CONSTANTS.allChange(),
                    AbstractField.CSS.cbtTableFieldChangeButton(), new Delegate<EventJournal>() {
                        public void execute(EventJournal eventaction) {
                            //TODO:                  JournalPopup.getInstance().show(eventaction, leaseentities, eventjournalTable);
                        }
                    })) {
        public EventJournal getValue(EventJournal eventjournal) {
            return eventjournal;
        }//TODO: selectForm(row); 
    };

    eventjournalTable.addColumn(changeButton);

    //-----------------------------------------------
    // Process column
    //-----------------------------------------------
    Column<EventJournal, String> process = new Column<EventJournal, String>(new TextCell()) {
        @Override
        public String getValue(EventJournal eventjournal) {
            return eventjournal.getProcess();
        }
    };
    eventjournalTable.addStringColumn(process, CONSTANTS.eventjournalHeaders()[col++], EventJournal.PROCESS);

    //-----------------------------------------------
    // Entity column
    //-----------------------------------------------
    Column<EventJournal, String> entity = new Column<EventJournal, String>(new TextCell()) {
        @Override
        public String getValue(EventJournal eventjournal) {
            return eventjournal.getEntityname(15);
        }
    };
    eventjournalTable.addStringColumn(entity, CONSTANTS.eventjournalHeaders()[col++], EventJournal.STATE);

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

    //-----------------------------------------------
    // Date column
    //-----------------------------------------------
    Column<EventJournal, Date> date = new Column<EventJournal, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(EventJournal eventjournal) {
            return Time.getDateClient(eventjournal.getDate());
        }
    };
    eventjournalTable.addDateColumn(date, CONSTANTS.eventjournalHeaders()[col++], EventJournal.DATE);

    //-----------------------------------------------
    // Debit Amount column
    //-----------------------------------------------
    Column<EventJournal, Number> debitAmount = new Column<EventJournal, Number>(
            new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(EventJournal eventjournal) {
            return eventjournal.getDebitamount();
        }
    };
    eventjournalTable.addNumberColumn(debitAmount, CONSTANTS.eventjournalHeaders()[col++],
            EventJournal.DEBITAMOUNT);

    //-----------------------------------------------
    // Credit Amount column
    //-----------------------------------------------
    Column<EventJournal, Number> creditAmount = new Column<EventJournal, Number>(
            new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(EventJournal eventjournal) {
            return eventjournal.getCreditamount();
        }
    };
    eventjournalTable.addNumberColumn(creditAmount, CONSTANTS.eventjournalHeaders()[col++],
            EventJournal.CREDITAMOUNT);

    //-----------------------------------------------
    // Currency column
    //-----------------------------------------------
    Column<EventJournal, String> currency = new Column<EventJournal, String>(new TextCell()) {
        @Override
        public String getValue(EventJournal eventjournal) {
            return eventjournal.getCurrency();
        }
    };
    eventjournalTable.addStringColumn(currency, CONSTANTS.eventjournalHeaders()[col++], EventJournal.UNIT);

    //-----------------------------------------------
    // Description column
    //-----------------------------------------------
    Column<EventJournal, String> description = new Column<EventJournal, String>(new TextCell()) {
        @Override
        public String getValue(EventJournal eventjournal) {
            return eventjournal.getDescription();
        }
    };
    eventjournalTable.addStringColumn(description, CONSTANTS.eventjournalHeaders()[col++],
            EventJournal.DESCRIPTION);
    eventjournalTable.addStyleName(CSS.eventactionStyle());

    final ScrollPanel scroll = new ScrollPanel();
    scroll.addStyleName(CSS.scrollStyle());
    scroll.add(eventjournalTable); //TODO:
    panel.add(scroll);
    return panel;
}

---

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

License:Open Source License

private ScrollPanel createContracttable() {
    final ScrollPanel panel = new ScrollPanel();
    panel.addStyleName(CSS.actorStyle());

    contractTable = new TableField<Contract>(this, null, new ContractTable(), 200, tab++);

    contractTable.setEmptyValue(contracttableEmpty());
    contractTable.setOrderby(Contract.PARTY);

    contractTable.setTableError(new TableError() {
        @Override/* www  .  j  a va 2  s .c o m*/
        public boolean error() {
            return organizationField.noId();
        }
    });

    contractTable.setTableExecutor(new TableExecutor<ContractTable>() {
        @Override
        public void execute(ContractTable action) {
            action.setId(organizationField.getId());
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Change / Create buttons
    //-----------------------------------------------
    Column<Contract, Contract> changeButton = new Column<Contract, Contract>(
            new ActionCell<Contract>(AbstractField.CONSTANTS.allChange(),
                    AbstractField.CSS.cbtTableFieldChangeButton(), new Delegate<Contract>() {
                        public void execute(Contract contract) {
                            ContractPopup.getInstance().show(contract, contractTable);
                        }
                    })) {
        public Contract getValue(Contract contract) {
            return contract;
        }
    };

    ActionHeader<Contract> createButton = new ActionHeader<Contract>(
            new ActionCell<Contract>(AbstractField.CONSTANTS.allCreate(),
                    AbstractField.CSS.cbtTableFieldCreateButton(), new Delegate<Contract>() {
                        public void execute(Contract contract) {
                            ContractPopup.getInstance().show(Contract.Type.Reservation, contractTable);
                        }
                    })) {
        public Contract getValue(Contract contract) {
            return contract;
        }
    };

    contractTable.addColumn(changeButton, createButton);

    //-----------------------------------------------
    // Party column
    //-----------------------------------------------
    Column<Contract, String> partyname = new Column<Contract, String>(new TextCell()) {
        @Override
        public String getValue(Contract contract) {
            return contract.getPartyname();
        }
    };
    contractTable.addStringColumn(partyname, CONSTANTS.contracttableHeaders()[col++], Contract.PARTY);

    //-----------------------------------------------
    // Date column
    //-----------------------------------------------
    Column<Contract, Date> date = new Column<Contract, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(Contract contract) {
            return Time.getDateClient(contract.getDate());
        }
    };
    contractTable.addDateColumn(date, CONSTANTS.contracttableHeaders()[col++], Contract.DATE);

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

    //-----------------------------------------------
    // Discount column
    //-----------------------------------------------
    Column<Contract, Number> discount = new Column<Contract, Number>(new NumberCell(AbstractField.QF)) {
        @Override
        public Integer getValue(Contract contract) {
            return contract.getDiscount();
        }
    };
    contractTable.addNumberColumn(discount, CONSTANTS.contracttableHeaders()[col++], Contract.DISCOUNT);

    //-----------------------------------------------
    // Notes column
    //-----------------------------------------------
    Column<Contract, String> notes = new Column<Contract, String>(new TextCell()) {
        @Override
        public String getValue(Contract contract) {
            return contract.getNotes(100);
        }
    };
    contractTable.addStringColumn(notes, CONSTANTS.contracttableHeaders()[col++], Contract.PARTY);

    panel.add(contractTable);
    return panel;
}

---

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

License:Open Source License

private ScrollPanel createDiscounttable() {
    final ScrollPanel panel = new ScrollPanel();
    panel.addStyleName(CSS.actorStyle());

    discountTable = new TableField<Contract>(this, null, new DiscountTable(), 200, tab++);

    discountTable.setEmptyValue(getDiscountEmpty());
    discountTable.setOrderby(Contract.PARTY);

    discountTable.setTableError(new TableError() {
        @Override/*from  w w w  .  j  a  va  2 s.c  o m*/
        public boolean error() {
            return organizationField.noId();
        }
    });

    discountTable.setTableExecutor(new TableExecutor<DiscountTable>() {
        @Override
        public void execute(DiscountTable action) {
            action.setId(organizationField.getId());
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Party column
    //-----------------------------------------------
    Column<Contract, String> partyname = new Column<Contract, String>(new TextCell()) {
        @Override
        public String getValue(Contract contract) {
            return contract.getPartyname();
        }
    };
    discountTable.addStringColumn(partyname, CONSTANTS.contracttableHeaders()[col++], Contract.PARTY);

    //-----------------------------------------------
    // Date column
    //-----------------------------------------------
    Column<Contract, Date> date = new Column<Contract, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(Contract contract) {
            return Time.getDateClient(contract.getDate());
        }
    };
    discountTable.addDateColumn(date, CONSTANTS.contracttableHeaders()[col++], Contract.DATE);

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

    //-----------------------------------------------
    // Discount column
    //-----------------------------------------------
    Column<Contract, Number> discount = new Column<Contract, Number>(new NumberCell(AbstractField.QF)) {
        @Override
        public Integer getValue(Contract contract) {
            return contract.getDiscount();
        }
    };
    discountTable.addNumberColumn(discount, CONSTANTS.contracttableHeaders()[col++], Contract.DISCOUNT);

    panel.add(discountTable);
    return panel;
}

---

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 ww  .  ja va  2s.c o  m
    };
    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 createLicence() {
    final ScrollPanel panel = new ScrollPanel();
    panel.addStyleName(CSS.actorStyle());

    licenseTable = new TableField<License>(this, null, new LicenseTable(), 200, tab++);

    licenseTable.setEmptyValue(licensetableEmpty());
    licenseTable.setOrderby(License.FROMDATE);

    licenseTable.setTableError(new TableError() {
        @Override// w w  w . j a  v  a2  s .com
        public boolean error() {
            return organizationField.noId();
        }
    });

    licenseTable.setTableExecutor(new TableExecutor<LicenseTable>() {
        @Override
        public void execute(LicenseTable action) {
            action.setUpstreamid(organizationField.getId());
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Change / Create buttons
    //-----------------------------------------------
    Column<License, License> changeButton = new Column<License, License>(
            new ActionCell<License>(AbstractField.CONSTANTS.allChange(),
                    AbstractField.CSS.cbtTableFieldChangeButton(), new Delegate<License>() {
                        public void execute(License license) {
                            LicensePopup.getInstance().show(license, licenseTable);
                        }
                    })) {
        public License getValue(License license) {
            return license;
        }
    };

    ActionHeader<License> createButton = new ActionHeader<License>(
            new ActionCell<License>(AbstractField.CONSTANTS.allCreate(),
                    AbstractField.CSS.cbtTableFieldCreateButton(), new Delegate<License>() {
                        public void execute(License license) {
                            LicensePopup.getInstance().show(licenseTable);
                        }
                    })) {
        public License getValue(License license) {
            return license;
        }
    };

    licenseTable.addColumn(changeButton, createButton);

    //-----------------------------------------------
    // Downstream Party column
    //-----------------------------------------------
    Column<License, String> partyname = new Column<License, String>(new TextCell()) {
        @Override
        public String getValue(License license) {
            return license.getDownstreamname();
        }
    };
    licenseTable.addStringColumn(partyname, CONSTANTS.licensetableHeaders()[col++], License.PARTY);

    //-----------------------------------------------
    // Product column
    //-----------------------------------------------
    Column<License, String> productname = new Column<License, String>(new TextCell()) {
        @Override
        public String getValue(License license) {
            return license.getProductname();
        }
    };
    licenseTable.addStringColumn(productname, CONSTANTS.licensetableHeaders()[col++], License.PRODUCT);

    //-----------------------------------------------
    // From Date column
    //-----------------------------------------------
    Column<License, Date> fromdate = new Column<License, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(License license) {
            return Time.getDateClient(license.getFromdate());
        }
    };
    licenseTable.addDateColumn(fromdate, CONSTANTS.licensetableHeaders()[col++], License.FROMDATE);

    //-----------------------------------------------
    // To Date column
    //-----------------------------------------------
    Column<License, Date> todate = new Column<License, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(License license) {
            return Time.getDateClient(license.getFromdate());
        }
    };
    licenseTable.addDateColumn(todate, CONSTANTS.licensetableHeaders()[col++], License.TODATE);

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

    //-----------------------------------------------
    // Subscription column
    //-----------------------------------------------
    Column<License, Number> discount = new Column<License, Number>(new NumberCell(AbstractField.IF)) {
        @Override
        public Double getValue(License license) {
            return license.getSubscription();
        }
    };
    licenseTable.addNumberColumn(discount, CONSTANTS.licensetableHeaders()[col++], License.SUBSCRIPTION);

    //-----------------------------------------------
    // Transaction column
    //-----------------------------------------------
    Column<License, Number> transaction = new Column<License, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(License license) {
            return license.getTransaction();
        }
    };
    licenseTable.addNumberColumn(transaction, CONSTANTS.licensetableHeaders()[col++], License.TRANSACTION);

    //-----------------------------------------------
    // Upstream column
    //-----------------------------------------------
    Column<License, Number> upstream = new Column<License, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(License license) {
            return license.getUpstream();
        }
    };
    licenseTable.addNumberColumn(upstream, CONSTANTS.licensetableHeaders()[col++], License.UPSTREAM);

    //-----------------------------------------------
    // Downstream column
    //-----------------------------------------------
    Column<License, Number> downsteam = new Column<License, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(License license) {
            return license.getDownstream();
        }
    };
    licenseTable.addNumberColumn(downsteam, CONSTANTS.licensetableHeaders()[col++], License.DOWNSTREAM);

    //-----------------------------------------------
    // Notes column
    //-----------------------------------------------
    Column<License, String> notes = new Column<License, String>(new TextCell()) {
        @Override
        public String getValue(License license) {
            return license.getNotes(100);
        }
    };
    licenseTable.addStringColumn(notes, CONSTANTS.licensetableHeaders()[col++], License.PARTY);

    panel.add(licenseTable);
    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);
        }//from   w  ww .  j av a  2  s  .  c  om
    };
    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;
}

---

• «
• 1
• 2
• 3
• »