Example usage for com.google.gwt.user.cellview.client Column Column

List of usage examples for com.google.gwt.user.cellview.client Column Column

  1. HOME
  2. Java
  3. com.google.gwt
  4. com.google.gwt.user.cellview.client.*
  5. Column
  6. Column

Introduction

In this page you can find the example usage for com.google.gwt.user.cellview.client Column Column.

Prototype

public Column(Cell<C> cell)

Source Link

Document

Construct a new Column with a given Cell .

Usage

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

private TableField<AvailableItem> createAvailableTable() {

    availableSelectionModel = new TableSelectionModel<AvailableItem>();
    SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
        }/*www. j a v  a2 s.co m*/
    };
    availableSelectionModel.addSelectionChangeHandler(selectionHandler);

    //-----------------------------------------------
    // The key provider that allows keys to be formed from row values.
    // This is used to pass a style to StyledCells.
    //-----------------------------------------------
    final ProvidesKey<AvailableItem> keyProvider = new ProvidesKey<AvailableItem>() {
        public String getKey(AvailableItem item) {
            if (item.isSpecial(0.85)) {
                return "color: red;";
            }
            if (item.isSpecial(1.0)) {
                return "color: orange;";
            } else {
                return "color: black;";
            }
        }
    };

    availableTable = new TableField<AvailableItem>(this, null, new LookBook(), availableSelectionModel,
            keyProvider, TABLE_ROWS, tab++);

    availableTable.addStyleName(CSS.tableStyle());
    availableTable.setEmptyValue(availabletableEmpty());
    availableTable.setOrderby(AvailableItem.RANK);

    availableTable.setTableError(new TableError() {
        @Override
        public boolean error() {
            return (specialField.getValue() || mapField.noValue() || distanceField.noValue()
                    || fromtodateField.noValue() || countField.noValue() || countunitField.noValue()
                    || pricerangeField.noValue() || priceunitField.noValue() || currencyField.noValue()
                    || ratingField.noValue() || commissionField.noValue());
        }
    });

    availableTable.setTableExecutor(new TableExecutor<LookBook>() {
        public void execute(LookBook action) {
            getValue(action);
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Product column
    //-----------------------------------------------
    Column<AvailableItem, String> productname = new Column<AvailableItem, String>(new TextCell()) {
        @Override
        public String getValue(AvailableItem availableitem) {
            return availableitem.getProductname(28);
        }
    };
    availableTable.addStringColumn(productname, CONSTANTS.availableHeader()[col++], AvailableItem.PRODUCTNAME);

    //-----------------------------------------------
    // Product Info column
    //-----------------------------------------------
    Column<AvailableItem, AvailableItem> productinfo = new Column<AvailableItem, AvailableItem>(
            new ImageCell<AvailableItem>(AbstractField.PRODUCTS, AbstractField.CSS.cbtInfoButton(),
                    new ImageCell.Delegate<AvailableItem>() {
                        public void execute(AvailableItem availableitem) {
                            BrochurePopup.getInstance().show(availableitem);
                        }
                    })) {
        @Override
        public AvailableItem getValue(AvailableItem availableitem) {
            return availableitem;
        }
    };
    availableTable.addColumn(productinfo, CONSTANTS.availableHeader()[col++], AvailableItem.PRODUCTNAME);

    //-----------------------------------------------
    // Supplier column
    //-----------------------------------------------
    Column<AvailableItem, String> suppliername = new Column<AvailableItem, String>(new TextCell()) {
        @Override
        public String getValue(AvailableItem availableitem) {
            return availableitem.getSuppliername(12);
        }
    };
    availableTable.addStringColumn(suppliername, CONSTANTS.availableHeader()[col++],
            AvailableItem.SUPPLIERNAME);

    //-----------------------------------------------
    // Supplier Info column
    //-----------------------------------------------
    if (isWidget()) {
        col++;
    } else {
        Column<AvailableItem, AvailableItem> supplierinfo = new Column<AvailableItem, AvailableItem>(
                new ImageCell<AvailableItem>(AbstractField.BUNDLE.info(), AbstractField.CSS.cbtInfoButton(),
                        new ImageCell.Delegate<AvailableItem>() {
                            public void execute(AvailableItem availableitem) {
                                if (availableitem.hasRank()) {
                                    PartyPopup.getInstance().show(availableitem.getSupplierid());
                                } else {
                                    AbstractField.addMessage(Level.VERBOSE, CONSTANTS.productRank(),
                                            offlineField);
                                }
                            }
                        })) {
            @Override
            public AvailableItem getValue(AvailableItem availableitem) {
                return availableitem;
            }
        };
        availableTable.addColumn(supplierinfo, CONSTANTS.availableHeader()[col++], AvailableItem.PRODUCTNAME);
    }

    //-----------------------------------------------
    // Room Count column
    //-----------------------------------------------
    Column<AvailableItem, Number> room = new Column<AvailableItem, Number>(new NumberCell(AbstractField.IF)) {
        @Override
        public Integer getValue(AvailableItem availableitem) {
            return availableitem.getRoom();
        }
    };
    availableTable.addNumberColumn(room, CONSTANTS.availableHeader()[col++], AvailableItem.ROOM);

    //-----------------------------------------------
    // Quote column
    //-----------------------------------------------
    Column<AvailableItem, Number> quote = new Column<AvailableItem, Number>(
            new StyledNumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(AvailableItem availableitem) {
            return availableitem.getQuote();
        }
    };
    availableTable.addNumberColumn(quote, CONSTANTS.availableHeader()[col++], AvailableItem.QUOTE);

    //-----------------------------------------------
    // STO column
    //-----------------------------------------------
    //      Column<AvailableItem, Number> cost = new Column<AvailableItem, Number>(new NumberCell(AbstractField.AF)) {
    //         @Override
    //         public Double getValue( AvailableItem availableitem ) {return availableitem.getCost();}
    //      };
    //      availableTable.addNumberColumn( cost, CONSTANTS.availableHeader()[col++], AvailableItem.COST);

    //-----------------------------------------------
    // Commission column
    //-----------------------------------------------
    Column<AvailableItem, Number> commission = new Column<AvailableItem, Number>(
            new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(AvailableItem availableitem) {
            return availableitem.getCommission();
        }
    };
    availableTable.addNumberColumn(commission, CONSTANTS.availableHeader()[col++], AvailableItem.COMMISSION);

    //-----------------------------------------------
    // Price column
    //-----------------------------------------------
    Column<AvailableItem, Number> rack = new Column<AvailableItem, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(AvailableItem availableitem) {
            return availableitem.getPrice();
        }
    };
    availableTable.addNumberColumn(rack, CONSTANTS.availableHeader()[col++], AvailableItem.PRICE);

    //-----------------------------------------------
    // Rating column
    //-----------------------------------------------
    Column<AvailableItem, Integer> rating = new Column<AvailableItem, Integer>(
            new ImageCell<Integer>(AbstractField.STARS, CSS.ratingStyle())) {
        @Override
        public Integer getValue(AvailableItem availableitem) {
            return availableitem.getKey();
        }
    };
    availableTable.addColumn(rating, CONSTANTS.availableHeader()[col++], AvailableItem.RATING);

    return availableTable;
}

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

private TableField<AvailableItem> createSpecialTable() {

    specialSelectionModel = new TableSelectionModel<AvailableItem>();
    SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
        }//from  ww w.j  a v  a 2 s.  co  m
    };
    specialSelectionModel.addSelectionChangeHandler(selectionHandler);

    specialTable = new TableField<AvailableItem>(this, null, new LookBookSpecial(), specialSelectionModel,
            TABLE_ROWS, tab++);

    specialTable.addStyleName(CSS.tableStyle());
    specialTable.setEmptyValue(availabletableEmpty());

    specialTable.setTableError(new TableError() {
        @Override
        public boolean error() {
            return (!specialField.getValue() || mapField.noValue() || distanceField.noValue()
                    || fromtodateField.noValue() || countField.noValue() || countunitField.noValue()
                    || pricerangeField.noValue() || priceunitField.noValue() || currencyField.noValue()
                    || ratingField.noValue() || commissionField.noValue());
        }
    });

    specialTable.setTableExecutor(new TableExecutor<LookBookSpecial>() {
        public void execute(LookBookSpecial action) {
            getValue(action);
        }
    });

    int col = 0;

    //-----------------------------------------------
    // Product column
    //-----------------------------------------------
    Column<AvailableItem, String> name = new Column<AvailableItem, String>(new TextCell()) {
        @Override
        public String getValue(AvailableItem availableitem) {
            return availableitem.getProductname(20);
        }
    };
    specialTable.addStringColumn(name, CONSTANTS.specialHeader()[col++], AvailableItem.PRODUCTNAME);

    //-----------------------------------------------
    // Product Info column
    //-----------------------------------------------
    Column<AvailableItem, AvailableItem> productinfo = new Column<AvailableItem, AvailableItem>(
            new ImageCell<AvailableItem>(AbstractField.BUNDLE.info(), AbstractField.CSS.cbtInfoButton(),
                    new ImageCell.Delegate<AvailableItem>() {
                        public void execute(AvailableItem availableitem) {
                            BrochurePopup.getInstance().show(availableitem);
                        }
                    })) {
        @Override
        public AvailableItem getValue(AvailableItem availableitem) {
            return availableitem;
        }
    };
    specialTable.addColumn(productinfo, CONSTANTS.specialHeader()[col++], AvailableItem.PRODUCTNAME);

    //-----------------------------------------------
    // Supplier column
    //-----------------------------------------------
    Column<AvailableItem, String> supplier = new Column<AvailableItem, String>(new TextCell()) {
        @Override
        public String getValue(AvailableItem availableitem) {
            return availableitem.getSuppliername(15);
        }
    };
    specialTable.addStringColumn(supplier, CONSTANTS.specialHeader()[col++], AvailableItem.SUPPLIERNAME);

    //-----------------------------------------------
    // Supplier Info column
    //-----------------------------------------------
    Column<AvailableItem, AvailableItem> supplierinfo = new Column<AvailableItem, AvailableItem>(
            new ImageCell<AvailableItem>(AbstractField.BUNDLE.info(), AbstractField.CSS.cbtInfoButton(),
                    new ImageCell.Delegate<AvailableItem>() {
                        public void execute(AvailableItem availableitem) {
                            if (availableitem.hasRank()) {
                                PartyPopup.getInstance().show(availableitem.getSupplierid());
                            }
                        }
                    })) {
        @Override
        public AvailableItem getValue(AvailableItem availableitem) {
            return availableitem;
        }
    };
    specialTable.addColumn(supplierinfo, CONSTANTS.specialHeader()[col++], AvailableItem.PRODUCTNAME);

    //-----------------------------------------------
    // Days column
    //-----------------------------------------------
    Column<AvailableItem, Number> days = new Column<AvailableItem, Number>(new NumberCell(AbstractField.SIF)) {
        @Override
        public Double getValue(AvailableItem availableitem) {
            return availableitem.getDuration(Time.DAY);
        }
    };
    specialTable.addNumberColumn(days, CONSTANTS.specialHeader()[col++], AvailableItem.DURATION);

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

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

    //-----------------------------------------------
    // Quote column
    //-----------------------------------------------
    Column<AvailableItem, Number> quote = new Column<AvailableItem, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(AvailableItem availableitem) {
            return availableitem.getQuote();
        }
    };
    specialTable.addNumberColumn(quote, CONSTANTS.specialHeader()[col++], AvailableItem.QUOTE);

    //-----------------------------------------------
    // STO column
    //-----------------------------------------------
    //      Column<AvailableItem, Number> cost = new Column<AvailableItem, Number>(new NumberCell(AbstractField.AF)) {
    //         @Override
    //         public Double getValue( AvailableItem availableitem ) {return availableitem.getCost();}
    //      };
    //      specialTable.alignRightCol(col);
    //      specialTable.addNumberColumn( cost, CONSTANTS.specialHeader()[col++], AvailableItem.COST);

    //-----------------------------------------------
    // Commission column
    //-----------------------------------------------
    Column<AvailableItem, Number> commission = new Column<AvailableItem, Number>(
            new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(AvailableItem availableitem) {
            return availableitem.getCommission();
        }
    };
    specialTable.addNumberColumn(commission, CONSTANTS.specialHeader()[col++], AvailableItem.COMMISSION);

    //-----------------------------------------------
    // Price column
    //-----------------------------------------------
    Column<AvailableItem, Number> price = new Column<AvailableItem, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(AvailableItem availableitem) {
            return availableitem.getPrice();
        }
    };
    specialTable.addNumberColumn(price, CONSTANTS.specialHeader()[col++], AvailableItem.PRICE);

    //-----------------------------------------------
    // Rating column
    //-----------------------------------------------
    Column<AvailableItem, Integer> rating = new Column<AvailableItem, Integer>(
            new ImageCell<Integer>(AbstractField.STARS, CSS.ratingStyle())) {
        @Override
        public Integer getValue(AvailableItem availableitem) {
            return availableitem.getKey();
        }
    };
    specialTable.addColumn(rating, CONSTANTS.specialHeader()[col++], AvailableItem.RATING);
    specialTable.setVisible(false);
    return specialTable;
}

From source file:net.cbtltd.client.panel.BrochurePopup.java

private TableField<Price> createPrice() {
    //-----------------------------------------------
    // Price table
    //-----------------------------------------------
    final TableField<Price> priceTable = new TableField<Price>(this, null, new PriceTableConverted(), 12,
            tab++);// www  . j  a va2  s . co  m

    priceTable.setOrderby(Price.DATE);

    priceTable.setTableError(new TableError() {
        @Override
        public boolean error() {
            return (noAvailableitem());
        }
    });

    priceTable.setTableExecutor(new TableExecutor<PriceTableConverted>() {
        public void execute(PriceTableConverted action) {
            action.setPartyid(getAvailableitem().getSupplierid());
            action.setEntitytype(NameId.Type.Product.name());
            action.setEntityid(getAvailableitem().getProductid());
            action.setCurrency(currencyList.getValue());
        }
    });

    int col = 0;

    //-----------------------------------------------
    // From Date column
    //-----------------------------------------------
    Column<Price, Date> date = new Column<Price, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(Price price) {
            return price.getDate();
        }
    };
    priceTable.addDateColumn(date, CONSTANTS.pricetableHeaders()[col++], Price.DATE);

    //-----------------------------------------------
    // To Date column
    //-----------------------------------------------
    Column<Price, Date> todate = new Column<Price, Date>(new DateCell(AbstractRoot.getDF())) {
        @Override
        public Date getValue(Price price) {
            return price.getTodate();
        }
    };
    priceTable.addDateColumn(todate, CONSTANTS.pricetableHeaders()[col++], Price.TODATE);

    //-----------------------------------------------
    // Price column
    //-----------------------------------------------
    Column<Price, Number> price = new Column<Price, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(Price price) {
            return price.getValue();
        }
    };
    priceTable.addNumberColumn(price, CONSTANTS.pricetableHeaders()[col++], Price.VALUE);

    //-----------------------------------------------
    // Minimum Price column
    //-----------------------------------------------
    Column<Price, Number> minimum = new Column<Price, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(Price price) {
            return price.getMinimum();
        }
    };
    priceTable.addNumberColumn(minimum, CONSTANTS.pricetableHeaders()[col++], Price.VALUE);

    //-----------------------------------------------
    // Currency column
    //-----------------------------------------------
    currencyList = new ListCell<Price>(Currency.EXCHANGE_CURRENCIES, Currency.Code.USD.name(),
            AbstractField.CSS.cbtGradientHead(), new ListCell.Delegate<Price>() {
                public void execute(Price price) {
                    priceTable.execute();
                }
            });

    //-----------------------------------------------
    // Change Currency list
    //-----------------------------------------------
    ActionHeader<Price> changeList = new ActionHeader<Price>(currencyList) {
        public Price getValue(Price price) {
            return price;
        }
    };

    Column<Price, String> currency = new Column<Price, String>(new TextCell()) {
        @Override
        public String getValue(Price price) {
            return price.getCurrency();
        }
    };
    priceTable.addColumn(currency, changeList);

    return priceTable;
}

From source file:net.cbtltd.client.panel.JournalPopup.java

private HorizontalPanel createContent() {
    HorizontalPanel panel = new HorizontalPanel();
    VerticalPanel form = new VerticalPanel();
    panel.add(form);//w w  w.  j  a  v  a 2 s  .  c o m

    reversedLabel = new Label(CONSTANTS.reversedLabel());
    reversedLabel.addStyleName(CSS.reversedField());
    form.add(reversedLabel);
    titleField = new Label(CONSTANTS.journalLabel());
    titleField.addStyleName(AbstractField.CSS.cbtAbstractPopupLabel());
    titleField.addStyleName(AbstractField.CSS.cbtAbstractPointer());
    titleField.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            if (journalTable.noValue()) {
                reversed = !reversed;
                titleField.setText(reversed ? CONSTANTS.reversedNames()[type.ordinal()]
                        : CONSTANTS.processNames()[type.ordinal()]);
            }
        }
    });
    HorizontalPanel titlePanel = new HorizontalPanel();
    titlePanel.add(titleField);
    reportButton = new Image(AbstractField.BUNDLE.printer());
    reportButton.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            reportView.execute();
        }
    });
    reportButton.setTitle(AbstractField.CONSTANTS.helpPrinter());
    titlePanel.add(reportButton);
    reportLoader = new Image(AbstractField.BUNDLE.loader());
    reportLoader.setVisible(false);
    titlePanel.add(reportLoader);
    form.add(titlePanel);

    final Label closeButton = new Label();
    closeButton.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            hide();
        }
    });
    closeButton.addStyleName(AbstractField.CSS.cbtAbstractPopupClose());
    form.add(closeButton);

    //-----------------------------------------------
    // Process field
    //-----------------------------------------------
    processField = new ListField(this, null,
            NameId.getList(AbstractField.CONSTANTS.processList(), Event.PROCESSES), CONSTANTS.processLabel(),
            true, tab++);
    processField.setFieldHalf();
    //form.add(processField);

    //-----------------------------------------------
    // Name field
    //-----------------------------------------------
    eventnameField = new SuggestField(this, null, new NameIdAction(Service.JOURNAL), CONSTANTS.eventnameLabel(),
            20, tab++);
    eventnameField.setFieldHalf();
    eventnameField.setHelpText(CONSTANTS.eventnameHelp());
    form.add(eventnameField);

    //-----------------------------------------------
    // Date field which is the effective date of the transaction
    // It is not a timestamp of when the event was captured
    //-----------------------------------------------
    eventdateField = new DateField(this, null, CONSTANTS.eventdateLabel(), tab++);
    eventdateField.setHelpText(CONSTANTS.eventdateHelp());
    form.add(eventdateField);

    //-----------------------------------------------
    // Tax Category field
    //-----------------------------------------------
    taxField = new ListField(this, null, new NameIdAction(Service.TAX), CONSTANTS.taxLabel(), false, tab++);
    taxField.setType(Tax.Type.SalesTaxIncluded.name());
    taxField.setLabelStyle(CSS.taxLabel());
    taxField.setFieldHalf();
    taxField.setFieldStyle(CSS.taxField());
    taxField.setHelpText(CONSTANTS.taxHelp());
    form.add(taxField);

    //-----------------------------------------------
    // Finance field
    //-----------------------------------------------
    financeField = new ListField(this, null, new NameIdAction(Service.FINANCE), CONSTANTS.financeLabel(), true,
            tab++);
    financeField.setFieldStyle(CSS.financeField());
    financeField.setVisible(false);
    financeField.setHelpText(CONSTANTS.financeHelp());
    form.add(financeField);

    //-----------------------------------------------
    // Account field
    //-----------------------------------------------
    accountField = new SuggestField(this, null, new NameIdAction(Service.ACCOUNT), CONSTANTS.accountLabel(), 20,
            tab++);
    accountField.setType(Account.Type.Expense.name());
    accountField.setVisible(false);
    accountField.setHelpText(CONSTANTS.accountHelp());
    form.add(accountField);

    //-----------------------------------------------
    // Supplier field
    //-----------------------------------------------
    supplierField = new SuggestField(this, null, new NameIdAction(Service.PARTY), CONSTANTS.supplierLabel(), 20,
            tab++);

    Image supplierButton = new Image(AbstractField.BUNDLE.plus());
    supplierButton.addClickHandler(new ClickHandler() {
        public void onClick(ClickEvent event) {
            PartyPopup.getInstance().show(Party.Type.Customer, supplierField, null);
        }
    });
    supplierButton.setTitle(CONSTANTS.partybuttonHelp());
    supplierField.addButton(supplierButton);
    supplierField.setHelpText(CONSTANTS.supplierHelp());
    form.add(supplierField);

    //-----------------------------------------------
    // Party field
    //-----------------------------------------------
    entityField = new SuggestField(this, null, new NameIdAction(Service.PARTY), CONSTANTS.subaccountLabels()[0],
            20, tab++);
    entityField.setHelpText(CONSTANTS.partyHelp());

    entityButton = new Image(AbstractField.BUNDLE.plus());
    entityButton.addClickHandler(new ClickHandler() {
        public void onClick(ClickEvent event) {
            PartyPopup.getInstance().show(partytypes[type.ordinal()], entityField, null);
        }
    });
    entityButton.setTitle(CONSTANTS.partybuttonHelp());
    entityField.addButton(entityButton);
    form.add(entityField);

    //-----------------------------------------------
    // Amount field
    //-----------------------------------------------
    amountField = new DoubleunitField(this, null, new CurrencyNameId(), CONSTANTS.amountLabel(),
            AbstractField.AF, tab++);
    amountField.setHelpText(CONSTANTS.amountHelp());
    form.add(amountField);

    //-----------------------------------------------
    // Debit Amount field
    //-----------------------------------------------
    debitamountField = new DoubleField(this, null, CONSTANTS.debitamountLabel(), AbstractField.AF, tab++);
    debitamountField.setHelpText(CONSTANTS.debitamountHelp());
    debitamountField.setVisible(false);

    //-----------------------------------------------
    // Credit Amount field
    //-----------------------------------------------
    creditamountField = new DoubleField(this, null, CONSTANTS.creditamountLabel(), AbstractField.AF, tab++);
    creditamountField.setVisible(false);
    creditamountField.setHelpText(CONSTANTS.creditamountHelp());

    final HorizontalPanel dc = new HorizontalPanel();
    dc.add(debitamountField);
    dc.add(creditamountField);
    form.add(dc);

    //-----------------------------------------------
    // Description field
    //-----------------------------------------------
    descriptionField = new TextAreaField(this, null, CONSTANTS.descriptionLabel(), tab++);
    descriptionField.setFieldStyle(CSS.descriptionField());
    descriptionField.setMaxLength(1000);
    descriptionField.setHelpText(CONSTANTS.descriptionHelp());
    form.add(descriptionField);

    //-----------------------------------------------
    // Exchange Rate field
    //-----------------------------------------------
    exchangerateField = new DoubleField(this, null, getExchangeLabel(), AbstractField.XF, tab++);
    exchangerateField.setVisible(false);
    exchangerateField.setHelpText(CONSTANTS.exchangerateHelp());
    form.add(exchangerateField);

    //-----------------------------------------------
    // Logo field
    //-----------------------------------------------
    final Image paygate = new Image(AbstractField.BUNDLE.paygate());
    final Image godaddy = new Image(AbstractField.BUNDLE.godaddy());
    final Image thawte = new Image(AbstractField.BUNDLE.thawte());
    final Image mastercard = new Image(AbstractField.BUNDLE.mastercard());
    final Image visa = new Image(AbstractField.BUNDLE.visa());

    logoImages = new HorizontalPanel();
    logoImages.setTitle(CONSTANTS.logoLabel());
    logoImages.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_CENTER);
    logoImages.addStyleName(AbstractField.CSS.cbtAbstractPopupLabel());
    logoImages.add(paygate);
    //logoImages.add(godaddy);
    logoImages.add(thawte);
    logoImages.add(mastercard);
    logoImages.add(visa);
    form.add(logoImages);

    //-----------------------------------------------
    // Card Holder field
    //-----------------------------------------------
    cardholderField = new TextField(this, null, CONSTANTS.cardholderLabel(), tab++);
    cardholderField.setVisible(false);
    cardholderField.setMaxLength(50);
    cardholderField.setHelpText(CONSTANTS.cardholderHelp());
    form.add(cardholderField);

    //-----------------------------------------------
    // Card Number field
    //-----------------------------------------------
    cardnumberField = new TextField(this, null, CONSTANTS.cardnumberLabel(), tab++);
    cardnumberField.setVisible(false);
    cardnumberField.setHelpText(CONSTANTS.cardnumberHelp());
    form.add(cardnumberField);

    //-----------------------------------------------
    // Card Expiry Month field
    //-----------------------------------------------
    cardmonthField = new ListField(this, null, Finance.getMonths(), null, false, tab++);
    cardmonthField.setVisible(false);
    carddetailLabel = new HelpLabel(CONSTANTS.carddetailLabel(), CONSTANTS.carddetailHelp(), cardmonthField);
    carddetailLabel.setVisible(false);
    form.add(carddetailLabel);
    cardmonthField.setFieldStyle(AbstractField.CSS.cbtListFieldCCmonth());

    //-----------------------------------------------
    // Card Expiry Year field
    //-----------------------------------------------
    cardyearField = new ListField(this, null, Finance.getYears(), null, false, tab++);
    cardyearField.setVisible(false);
    cardyearField.setFieldStyle(AbstractField.CSS.cbtListFieldCCyear());

    //-----------------------------------------------
    // Card Security Code field
    //-----------------------------------------------
    cardcodeField = new TextField(this, null, null, tab++);
    cardcodeField.setVisible(false);
    cardcodeField.setFieldStyle(AbstractField.CSS.cbtTextFieldCCcode());

    HorizontalPanel ccc = new HorizontalPanel();
    ccc.add(cardmonthField);
    ccc.add(cardyearField);
    ccc.add(cardcodeField);
    form.add(ccc);

    form.add(createCommands());

    //-----------------------------------------------
    // Available selection change handler
    //-----------------------------------------------
    final NoSelectionModel<Journal> selectionModel = new NoSelectionModel<Journal>();
    SelectionChangeEvent.Handler selectionHandler = new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            selectedjournal = selectionModel.getLastSelectedObject();
            setValue(selectedjournal);
            processField.setValue(Event.Type.Journal.name());
            setView();
        }
    };
    selectionModel.addSelectionChangeHandler(selectionHandler);

    //-----------------------------------------------
    // Journal table
    //-----------------------------------------------
    journalTable = new TableField<Journal>(this, null, new JournalItemTable(), selectionModel,
            CONSTANTS.journaltableLabel(), JOURNAL_ROWS, tab++);

    journalTable.setLabelStyle(CSS.journaltableLabel());
    journalTable.setVisible(false);

    int col = 0;

    //-----------------------------------------------
    // Organization column
    //-----------------------------------------------
    Column<Journal, String> organization = new Column<Journal, String>(new TextCell()) {
        @Override
        public String getValue(Journal journal) {
            return journal.getOrganizationname();
        }
    };
    journalTable.addStringColumn(organization, CONSTANTS.journalHeaders()[col++]);

    //-----------------------------------------------
    // Account column
    //-----------------------------------------------
    Column<Journal, String> process = new Column<Journal, String>(new TextCell()) {
        @Override
        public String getValue(Journal journal) {
            return journal.getAccountname();
        }
    };
    journalTable.addStringColumn(process, CONSTANTS.journalHeaders()[col++]);

    //-----------------------------------------------
    // Subaccount column
    //-----------------------------------------------
    Column<Journal, String> entityname = new Column<Journal, String>(new TextCell()) {
        @Override
        public String getValue(Journal journal) {
            return journal.getEntityname();
        }
    };
    journalTable.addStringColumn(entityname, CONSTANTS.journalHeaders()[col++]);

    //-----------------------------------------------
    // Debit column
    //-----------------------------------------------
    Column<Journal, Number> debitamount = new Column<Journal, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(Journal journal) {
            return journal.getDebitamount();
        }
    };
    journalTable.addNumberColumn(debitamount, CONSTANTS.journalHeaders()[col++]);

    //-----------------------------------------------
    // Credit column
    //-----------------------------------------------
    Column<Journal, Number> creditamount = new Column<Journal, Number>(new NumberCell(AbstractField.AF)) {
        @Override
        public Double getValue(Journal journal) {
            return journal.getCreditamount();
        }
    };
    journalTable.addNumberColumn(creditamount, CONSTANTS.journalHeaders()[col++]);

    //-----------------------------------------------
    // Currency column
    //-----------------------------------------------
    Column<Journal, String> currency = new Column<Journal, String>(new TextCell()) {
        @Override
        public String getValue(Journal journal) {
            return journal.getCurrency();
        }
    };
    journalTable.addStringColumn(currency, CONSTANTS.journalHeaders()[col++]);

    //-----------------------------------------------
    // Description column
    //-----------------------------------------------
    //      Column<Journal, String> description = new Column<Journal, String>( new TextCell() ) {
    //         @Override
    //         public String getValue( Journal journal ) {return journal.getDescription();}
    //      };
    //      journalTable.addStringColumn(description, CONSTANTS.journalHeaders()[col++]);

    panel.add(journalTable);

    onRefresh();
    onReset(Event.CREATED);
    return panel;
}

From source file:net.cristcost.study.gwt.client.list.ListTagsWidget.java

License:Apache License

/**
 * Instantiates a new list tags widget./* ww  w.  j  av a 2s . c  o  m*/
 */
public ListTagsWidget() {

    initWidget(uiBinder.createAndBindUi(this));

    TextColumn<Tag> usernameColumn = new TextColumn<Tag>() {
        @Override
        public String getValue(Tag tag) {
            return tag.getUsername();
        }
    };

    TextColumn<Tag> tagColumn = new TextColumn<Tag>() {
        @Override
        public String getValue(Tag tag) {
            return tag.getTag();
        }
    };

    TextColumn<Tag> publicCheckColumn = new TextColumn<Tag>() {
        @Override
        public String getValue(Tag tag) {
            return tag.isPublic() ? "public" : "private";
        }
    };

    Column<Tag, String> deleteButtonColumn = new Column<Tag, String>(new ButtonCell()) {
        @Override
        public String getValue(Tag object) {
            return "Delete";
        }

        @Override
        public void render(Context context, Tag object, SafeHtmlBuilder sb) {
            if (object.getUsername() == currentUsername) {
                super.render(context, object, sb);
            }
        }
    };
    deleteButtonColumn.setFieldUpdater(new FieldUpdater<Tag, String>() {
        @Override
        public void update(int index, Tag object, String value) {
            presenter.deleteTag(object.getUsername(), object.getTag());
        }
    });

    cellTable.addColumn(usernameColumn, "Name");
    cellTable.addColumn(tagColumn, "Address");
    cellTable.addColumn(publicCheckColumn, "Is Public?");
    cellTable.addColumn(deleteButtonColumn, "Delete");

    cellTable.setRowCount(0, true);
}

From source file:net.exclaimindustries.paste.braket.client.ui.Leaderboard.java

License:Open Source License

/**
 * Add a column with a header./*from w  w  w.  j a va 2  s .c  om*/
 * 
 * @param <C>
 *            the cell type
 * @param cell
 *            the cell used to render the column
 * @param headerText
 *            the header string
 * @param getter
 *            the value getter for the cell
 */
private <C> Column<SelectionInfo, C> addColumn(Cell<C> cell, String headerText, final GetValue<C> getter,
        FieldUpdater<SelectionInfo, C> fieldUpdater) {
    Column<SelectionInfo, C> column = new Column<SelectionInfo, C>(cell) {
        @Override
        public C getValue(SelectionInfo object) {
            return getter.getValue(object);
        }
    };
    column.setFieldUpdater(fieldUpdater);

    dataGrid.addColumn(column, headerText);
    return column;
}

From source file:net.officefloor.demo.stocks.client.StockWatchWidget.java

License:Open Source License

/**
 * Adds {@link Column} to the {@link CellTable}.
 * /* www  . j a v a2  s.  c  o  m*/
 * @param table
 *            {@link CellTable}.
 * @param columnName
 *            Name of the {@link Column}.
 * @param columnValue
 *            {@link ColumnValue} to obtain value for the {@link Column}.
 * @return Added {@link Column}.
 */
private Column<StockEntry, SafeHtml> addColumn(CellTable<StockEntry> table, String columnName,
        final ColumnValue columnValue) {

    // Create the column
    Column<StockEntry, SafeHtml> column = new Column<StockEntry, SafeHtml>(new SafeHtmlCell()) {
        @Override
        public SafeHtml getValue(StockEntry entry) {
            return columnValue.getValue(entry);
        }
    };

    // Add header for the column
    SafeHtml header = this.headerTemplate.header(columnName);

    // Add and return the column
    table.addColumn(column, header);
    return column;
}

From source file:nz.org.winters.appspot.acrareporter.client.ui.MainErrorsList.java

License:Apache License

private void initTableColumns(final SelectionModel<BasicErrorInfo> selectionModel,
        ListHandler<BasicErrorInfo> sortHandler) {

    Column<BasicErrorInfo, String> userCrashDateColumn = new Column<BasicErrorInfo, String>(new TextCell()) {
        @Override//from  w  ww .  ja va 2  s . c o  m
        public String getValue(BasicErrorInfo object) { // 2012-12-02T18:07:33.000-06:00
            return UIUtils.reportDateToLocal(object.USER_CRASH_DATE);
        }
    };
    userCrashDateColumn.setSortable(true);
    sortHandler.setComparator(userCrashDateColumn, new Comparator<BasicErrorInfo>() {
        @Override
        public int compare(BasicErrorInfo o1, BasicErrorInfo o2) {
            Date d1 = UIUtils.reportDateToDate(o1.USER_CRASH_DATE);
            Date d2 = UIUtils.reportDateToDate(o2.USER_CRASH_DATE);

            if (d1 != null && d2 != null) {
                return d1.compareTo(d2);
            } else {
                return o1.USER_CRASH_DATE.compareTo(o2.USER_CRASH_DATE);
            }
        }
    });
    dataGrid.addColumn(userCrashDateColumn, constants.errorListGridCrashDate());
    dataGrid.setColumnWidth(userCrashDateColumn, 150, Unit.PX);

    // AppVersionName
    Column<BasicErrorInfo, String> appVersionNameColumn = new Column<BasicErrorInfo, String>(new TextCell()) {
        @Override
        public String getValue(BasicErrorInfo object) {
            return object.APP_VERSION_NAME;
        }
    };
    appVersionNameColumn.setSortable(true);
    sortHandler.setComparator(appVersionNameColumn, new Comparator<BasicErrorInfo>() {
        @Override
        public int compare(BasicErrorInfo o1, BasicErrorInfo o2) {
            return o1.APP_VERSION_NAME.compareTo(o2.APP_VERSION_NAME);
        }
    });
    dataGrid.addColumn(appVersionNameColumn, constants.errorListGridVersion());
    dataGrid.setColumnWidth(appVersionNameColumn, 100, Unit.PX);

}

From source file:nz.org.winters.appspot.acrareporter.client.ui.MappingList.java

License:Apache License

private void initTableColumns(final SelectionModel<MappingFileInfo> selectionModel,
        ListHandler<MappingFileInfo> sortHandler2) {
    // selection check
    Column<MappingFileInfo, Boolean> checkColumn = new Column<MappingFileInfo, Boolean>(
            new CheckboxCell(true, false)) {
        @Override//  w  ww .  j av a 2s  . com
        public Boolean getValue(MappingFileInfo object) {
            // Get the value from the selection model.
            return selectionModel.isSelected(object);
        }
    };
    dataGrid.addColumn(checkColumn, SafeHtmlUtils.fromSafeConstant("<br/>"));
    dataGrid.setColumnWidth(checkColumn, 40, Unit.PX);

    // Date
    Column<MappingFileInfo, String> uploadDateColumn = new Column<MappingFileInfo, String>(new TextCell()) {
        @Override
        public String getValue(MappingFileInfo object) {
            if (object.uploadDate != null) {
                return object.uploadDate.toString();
            } else {
                return "Unknown Date";
            }
        }
    };
    uploadDateColumn.setSortable(true);
    sortHandler.setComparator(uploadDateColumn, new Comparator<MappingFileInfo>() {
        @Override
        public int compare(MappingFileInfo o1, MappingFileInfo o2) {
            if (o1.uploadDate != null && o2.uploadDate != null)
                return o1.uploadDate.compareTo(o2.uploadDate);
            else
                return 0;
        }
    });
    dataGrid.addColumn(uploadDateColumn, constants.mappingListGridDate());
    dataGrid.setColumnWidth(uploadDateColumn, 200, Unit.PX);

    Column<MappingFileInfo, String> versionColumn = new Column<MappingFileInfo, String>(new TextCell()) {
        @Override
        public String getValue(MappingFileInfo object) { // 2012-12-02T18:07:33.000-06:00
            return object.version;
        }
    };
    versionColumn.setSortable(true);
    sortHandler.setComparator(versionColumn, new Comparator<MappingFileInfo>() {
        @Override
        public int compare(MappingFileInfo o1, MappingFileInfo o2) {
            return o1.version.compareTo(o2.version);
        }
    });
    dataGrid.addColumn(versionColumn, constants.mappingListGridVersion());
    dataGrid.setColumnWidth(versionColumn, 100, Unit.PX);

}

From source file:nz.org.winters.appspot.acrareporter.client.ui.NameValueList.java

License:Apache License

private void initTableColumns(ListHandler<NameValueInfo> sortHandler) {
    Column<NameValueInfo, String> nameColumn = new Column<NameValueInfo, String>(new TextCell()) {
        @Override/*from w  w  w.java 2s  .c  o m*/
        public String getValue(NameValueInfo object) { // 2012-12-02T18:07:33.000-06:00
            return object.name;
        }
    };
    nameColumn.setSortable(true);
    sortHandler.setComparator(nameColumn, new Comparator<NameValueInfo>() {
        @Override
        public int compare(NameValueInfo o1, NameValueInfo o2) {
            return o1.name.compareTo(o2.name);
        }
    });
    cellTable.addColumn(nameColumn, constants.gridName());
    cellTable.setColumnWidth(nameColumn, 300, Unit.PX);

    // Value
    Column<NameValueInfo, String> valueColumn = new Column<NameValueInfo, String>(new TextCell()) {
        @Override
        public String getValue(NameValueInfo object) {
            return object.value;
        }
    };
    valueColumn.setSortable(true);
    sortHandler.setComparator(valueColumn, new Comparator<NameValueInfo>() {
        @Override
        public int compare(NameValueInfo o1, NameValueInfo o2) {
            return o1.value.compareTo(o2.value);
        }
    });
    cellTable.addColumn(valueColumn, constants.gridValue());
    cellTable.setColumnWidth(valueColumn, 600, Unit.PX);

}