Example usage for com.google.gwt.user.cellview.client CellTable setColumnWidth

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

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

Introduction

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

Prototype

@Override
public void setColumnWidth(Column<T, ?> column, double width, Unit unit)

Source Link

Document

The layout behavior depends on whether or not the table is using fixed layout.

Usage

From source file:org.eclipse.che.ide.processes.runtime.CellTableRuntimeInfoWidgetFactory.java

License:Open Source License

private Widget createCellTable(ListDataProvider<RuntimeInfo> dataProvider) {
    CellTable<RuntimeInfo> table = new CellTable<>(100, resources);
    table.ensureDebugId("runtimeInfoCellTable");

    TextColumn<RuntimeInfo> referenceColumn = new TextColumn<RuntimeInfo>() {
        @Override/*from   w w  w  .  j  ava 2 s.  co m*/
        public String getValue(RuntimeInfo record) {
            return valueOrDefault(record.getReference());
        }

        @Override
        public void render(Context context, RuntimeInfo object, SafeHtmlBuilder sb) {
            sb.appendHtmlConstant("<div id=\"" + UIObject.DEBUG_ID_PREFIX + "runtime-info-reference-"
                    + context.getIndex() + "\">");
            super.render(context, object, sb);
        }
    };

    TextColumn<RuntimeInfo> portColumn = new TextColumn<RuntimeInfo>() {
        @Override
        public String getValue(RuntimeInfo record) {
            return valueOrDefault(record.getPort());
        }

        @Override
        public void render(Context context, RuntimeInfo object, SafeHtmlBuilder sb) {
            sb.appendHtmlConstant("<div id=\"" + UIObject.DEBUG_ID_PREFIX + "runtime-info-port-"
                    + context.getIndex() + "\">");
            super.render(context, object, sb);
        }
    };

    TextColumn<RuntimeInfo> protocolColumn = new TextColumn<RuntimeInfo>() {
        @Override
        public String getValue(RuntimeInfo record) {
            return valueOrDefault(record.getProtocol());
        }

        @Override
        public void render(Context context, RuntimeInfo object, SafeHtmlBuilder sb) {
            sb.appendHtmlConstant("<div id=\"" + UIObject.DEBUG_ID_PREFIX + "runtime-info-protocol-"
                    + context.getIndex() + "\">");
            super.render(context, object, sb);
        }
    };

    Column<RuntimeInfo, SafeHtml> urlColumn = new Column<RuntimeInfo, SafeHtml>(
            new AbstractCell<SafeHtml>("click", "keydown") {

                @Override
                public void render(Context context, SafeHtml value, SafeHtmlBuilder sb) {
                    sb.appendHtmlConstant("<div id=\"" + UIObject.DEBUG_ID_PREFIX + "runtime-info-url-"
                            + context.getIndex() + "\">");

                    if (value != null) {
                        sb.append(value);
                    }
                }

                @Override
                protected void onEnterKeyDown(Context context, Element parent, SafeHtml value,
                        NativeEvent event, ValueUpdater<SafeHtml> valueUpdater) {
                    if (valueUpdater != null) {
                        valueUpdater.update(value);
                    }
                }

                @Override
                public void onBrowserEvent(Context context, Element parent, SafeHtml value, NativeEvent event,
                        ValueUpdater<SafeHtml> valueUpdater) {
                    super.onBrowserEvent(context, parent, value, event, valueUpdater);
                    if ("click".equals(event.getType())) {
                        onEnterKeyDown(context, parent, value, event, valueUpdater);
                    }
                }
            }) {
        @Override
        public SafeHtml getValue(RuntimeInfo record) {
            String value = valueOrDefault(record.getUrl());

            SafeHtmlBuilder sb = new SafeHtmlBuilder();
            sb.appendHtmlConstant("<a target=\"_blank\" href=\"" + value + "\">");
            sb.appendEscaped(value);
            sb.appendHtmlConstant("</a>");
            return sb.toSafeHtml();
        }
    };

    table.addColumn(referenceColumn, locale.cellTableReferenceColumn());
    table.addColumn(portColumn, locale.cellTablePortColumn());
    table.addColumn(protocolColumn, locale.cellTableProtocolColumn());
    table.addColumn(urlColumn, locale.cellTableUrlColumn());

    table.setColumnWidth(referenceColumn, 15., Unit.PCT);
    table.setColumnWidth(portColumn, 7., Unit.PCT);
    table.setColumnWidth(protocolColumn, 7., Unit.PCT);
    table.setColumnWidth(urlColumn, 71., Unit.PCT);

    dataProvider.addDataDisplay(table);

    return table;
}

From source file:org.kie.guvnor.guided.scorecard.client.editor.GuidedScoreCardEditor.java

License:Apache License

private Widget addAttributeCellTable(final DirtyableFlexTable cGrid, final Characteristic characteristic) {
    final CellTable<Attribute> attributeCellTable = new CellTable<Attribute>();
    final List<String> operators = new ArrayList<String>();
    String dataType;/*from   www  . j  av  a  2s .  c o  m*/
    if (characteristic == null) {
        dataType = "String";
    } else {
        dataType = characteristic.getDataType();
    }

    if ("String".equalsIgnoreCase(dataType)) {
        operators.addAll(Arrays.asList(stringOperators));
    } else if ("boolean".equalsIgnoreCase(dataType)) {
        operators.addAll(Arrays.asList(booleanOperators));
    } else {
        operators.addAll(Arrays.asList(numericOperators));
    }

    //Operators column
    final DynamicSelectionCell categoryCell = new DynamicSelectionCell(operators);
    final Column<Attribute, String> operatorColumn = new Column<Attribute, String>(categoryCell) {
        public String getValue(final Attribute object) {
            return object.getOperator();
        }
    };
    operatorColumn.setFieldUpdater(new FieldUpdater<Attribute, String>() {
        public void update(int index, Attribute object, String value) {
            object.setOperator(value);
            attributeCellTable.redraw();
        }
    });

    //Value column
    final Column<Attribute, String> valueColumn = new Column<Attribute, String>(new CustomEditTextCell()) {
        public String getValue(final Attribute attribute) {
            return attribute.getValue();
        }
    };
    valueColumn.setFieldUpdater(new FieldUpdater<Attribute, String>() {
        public void update(int index, Attribute object, String value) {
            object.setValue(value);
            attributeCellTable.redraw();
        }
    });

    //Partial Score column
    final EditTextCell partialScoreCell = new EditTextCell();
    final Column<Attribute, String> partialScoreColumn = new Column<Attribute, String>(partialScoreCell) {
        public String getValue(final Attribute attribute) {
            return "" + attribute.getPartialScore();
        }
    };
    partialScoreColumn.setFieldUpdater(new FieldUpdater<Attribute, String>() {
        public void update(int index, Attribute object, String value) {
            try {
                double d = Double.parseDouble(value);
                object.setPartialScore(d);
            } catch (Exception e1) {
                partialScoreCell.clearViewData(object);
            }
            attributeCellTable.redraw();
        }
    });

    //Reason Code column
    final Column<Attribute, String> reasonCodeColumn = new Column<Attribute, String>(new EditTextCell()) {
        public String getValue(final Attribute attribute) {
            return attribute.getReasonCode();
        }
    };
    reasonCodeColumn.setFieldUpdater(new FieldUpdater<Attribute, String>() {
        public void update(int index, Attribute object, String value) {
            object.setReasonCode(value);
            attributeCellTable.redraw();
        }
    });

    final ActionCell.Delegate<Attribute> delegate = new ActionCell.Delegate<Attribute>() {
        public void execute(final Attribute attribute) {
            if (Window.confirm(Constants.INSTANCE.promptDeleteAttribute())) {
                final List<Attribute> list = characteristicsAttrMap.get(cGrid).getList();
                list.remove(attribute);
                ((ListBox) cGrid.getWidget(2, 0)).setEnabled(list.size() == 0);
                ((ListBox) cGrid.getWidget(2, 1)).setEnabled(list.size() == 0);
                ((Button) cGrid.getWidget(0, 3)).setEnabled(list.size() != 2);
                attributeCellTable.redraw();
            }
        }
    };

    final Cell<Attribute> actionCell = new ActionCell<Attribute>(Constants.INSTANCE.remove(), delegate);
    final Column<Attribute, String> actionColumn = new IdentityColumn(actionCell);

    // Add the columns.
    attributeCellTable.addColumn(operatorColumn, Constants.INSTANCE.operator());
    attributeCellTable.addColumn(valueColumn, Constants.INSTANCE.value());
    attributeCellTable.addColumn(partialScoreColumn, Constants.INSTANCE.partialScore());
    attributeCellTable.addColumn(reasonCodeColumn, Constants.INSTANCE.reasonCode());
    attributeCellTable.addColumn(actionColumn, Constants.INSTANCE.actions());
    attributeCellTable.setWidth("100%", true);

    attributeCellTable.setColumnWidth(operatorColumn, 5.0, Style.Unit.PCT);
    attributeCellTable.setColumnWidth(valueColumn, 10.0, Style.Unit.PCT);
    attributeCellTable.setColumnWidth(partialScoreColumn, 10.0, Style.Unit.PCT);
    attributeCellTable.setColumnWidth(reasonCodeColumn, 10.0, Style.Unit.PCT);
    attributeCellTable.setColumnWidth(actionColumn, 5.0, Style.Unit.PCT);

    ListDataProvider<Attribute> dataProvider = new ListDataProvider<Attribute>();
    dataProvider.addDataDisplay(attributeCellTable);
    characteristicsAttrMap.put(cGrid, dataProvider);
    return (attributeCellTable);
}

From source file:org.pepstock.jem.gwt.client.panels.administration.certificates.CertificateEntriesTable.java

License:Open Source License

/**
 * Adds all columns to table, defining the sort columns too.
 *///from   w  w w.  ja v a2s  .  co m
@Override
public IndexedColumnComparator<CertificateEntry> initCellTable(CellTable<CertificateEntry> table) {

    /*-------------------------+
     | Selector                |
     +-------------------------*/
    @SuppressWarnings("unchecked")
    final SelectionModel<CertificateEntry> selectionModel = (SelectionModel<CertificateEntry>) table
            .getSelectionModel();
    Column<CertificateEntry, Boolean> checkColumn = new Column<CertificateEntry, Boolean>(
            new CheckboxCell(true, false)) {
        @Override
        public Boolean getValue(CertificateEntry entry) {
            return selectionModel.isSelected(entry);
        }
    };

    /*-------------------------+
     | Selector header         |
     +-------------------------*/
    CheckboxCell headerCheckBox = new CheckboxCell(true, false);
    Header<Boolean> checkHeader = new Header<Boolean>(headerCheckBox) {
        // sets header
        @Override
        public Boolean getValue() {
            // if no items, is not selectable
            if (getTable().getVisibleItems().isEmpty()) {
                return false;
            }
            // scans all visible objects
            for (CertificateEntry entry : getTable().getVisibleItems()) {
                // if there is a element already select, header is not selectable
                if (!getTable().getSelectionModel().isSelected(entry)) {
                    return false;
                }
            }
            // all items arre selected
            return true;
        }
    };

    // updater which select and deselect all elements 
    checkHeader.setUpdater(new ValueUpdater<Boolean>() {
        @Override
        public void update(Boolean value) {
            for (CertificateEntry entry : getTable().getVisibleItems()) {
                getTable().getSelectionModel().setSelected(entry, value);
            }
        }
    });

    table.setColumnWidth(checkColumn, 23, Unit.PX);
    table.addColumn(checkColumn, checkHeader);

    /*-------------------------+
     | Alias                   |
     +-------------------------*/
    TextColumn<CertificateEntry> name = new TextColumn<CertificateEntry>() {
        @Override
        public String getValue(CertificateEntry object) {
            return object.getAlias();
        }
    };
    name.setSortable(true);
    table.addColumn(name, "Alias");

    /*-------------------------+
     | issuerDN                |
     +-------------------------*/
    TextColumn<CertificateEntry> principal = new TextColumn<CertificateEntry>() {
        @Override
        public String getValue(CertificateEntry entry) {
            return String.valueOf(entry.getIssuer());
        }
    };
    table.addColumn(principal, "Issuer");

    /*-------------------------+
     | subjectDN               |
     +-------------------------*/
    TextColumn<CertificateEntry> subject = new TextColumn<CertificateEntry>() {
        @Override
        public String getValue(CertificateEntry entry) {
            return String.valueOf(entry.getSubject());
        }
    };
    table.addColumn(subject, "Subject");

    /*-------------------------+
     | NotBefore               |
     +-------------------------*/
    TextColumn<CertificateEntry> begin = new TextColumn<CertificateEntry>() {
        @Override
        public String getValue(CertificateEntry entry) {
            if (entry.getNotBefore() == null) {
                return "";
            }
            return JemConstants.DATE_TIME_FULL.format(entry.getNotBefore());
        }
    };
    begin.setSortable(true);
    table.addColumn(begin, "Valid Not Before");

    /*-------------------------+
     | NotAfter                |
     +-------------------------*/
    TextColumn<CertificateEntry> after = new TextColumn<CertificateEntry>() {
        @Override
        public String getValue(CertificateEntry entry) {
            if (entry.getNotAfter() == null) {
                return "";
            }
            return JemConstants.DATE_TIME_FULL.format(entry.getNotAfter());
        }
    };
    after.setSortable(true);
    table.addColumn(after, "Valid Not After");

    // sets comparator
    return new CertificateEntriesComparator(0);

}

From source file:org.pepstock.jem.gwt.client.panels.jobs.input.InputTable.java

License:Open Source License

/**
 * Adds all columns to table, defining the sort columns too.
 *//* w  w w.j  av  a2  s  .  c  o m*/
@Override
public IndexedColumnComparator<Job> initCellTable(CellTable<Job> table) {
    @SuppressWarnings("unchecked")
    final SelectionModel<Job> selectionModel = (SelectionModel<Job>) table.getSelectionModel();
    Column<Job, Boolean> checkColumn = new Column<Job, Boolean>(new CheckboxCell(true, false)) {
        @Override
        public Boolean getValue(Job job) {
            return selectionModel.isSelected(job);
        }
    };

    CheckboxCell headerCheckBox = new CheckboxCell(true, false);
    Header<Boolean> checkHeader = new Header<Boolean>(headerCheckBox) {
        // imposta lo stato dell'header!
        @Override
        public Boolean getValue() {
            // se e' vuoto, niente e' selezionato/selezionabile
            if (getTable().getVisibleItems().isEmpty()) {
                return false;
            }

            // altrimenti testo
            for (Job j : getTable().getVisibleItems()) {
                // se almeno un elemento non e' selezionato, l'header non deve essere selezionato
                if (!getTable().getSelectionModel().isSelected(j)) {
                    return false;
                }
            }
            // altrimenti se arrivo qui, tutti gli elementi sono selezionati
            return true;
        }
    };

    // updater che seleziona o deseleziona tutti gli elementi visibili in base al "valore" dell'header
    checkHeader.setUpdater(new ValueUpdater<Boolean>() {
        @Override
        public void update(Boolean value) {
            for (Job j : getTable().getVisibleItems()) {
                getTable().getSelectionModel().setSelected(j, value);
            }
        }
    });
    table.setColumnWidth(checkColumn, 23, Unit.PX);
    table.addColumn(checkColumn, checkHeader);

    /*-------------------------+
     | NAME                    |
     +-------------------------*/
    // construct a column that uses anchorRenderer
    AnchorTextColumn<Job> name = new AnchorTextColumn<Job>() {
        @Override
        public String getValue(Job object) {
            return object.getName();
        }

        @Override
        public void onClick(int index, Job object, String value) {
            getInspectListener().inspect(object);
        }

    };
    name.setSortable(true);
    if (hasFilterableHeaders()) {
        table.addColumn(name, new TextFilterableHeader("Name", JobFilterFields.NAME.getName()));
    } else {
        table.addColumn(name, "Name");
    }

    /*-------------------------+
     | TYPE                    |
     +-------------------------*/
    TextColumn<Job> type = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            return job.getJcl().getType();
        }
    };
    type.setSortable(true);
    if (hasFilterableHeaders()) {
        table.addColumn(type, new TextFilterableHeader("Type", JobFilterFields.TYPE.getName()));
    } else {
        table.addColumn(type, "Type");
    }

    /*-------------------------+
     | USER                    |
     +-------------------------*/
    TextColumn<Job> userid = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            // if surrogates, use ONLY user in JCL definition
            return (job.isUserSurrogated()) ? job.getJcl().getUser() : job.getUser();
        }
    };
    userid.setSortable(true);
    if (hasFilterableHeaders()) {
        table.addColumn(userid, new TextFilterableHeader("User", JobFilterFields.USER.getName()));
    } else {
        table.addColumn(userid, "User");
    }

    /*-------------------------+
     | ENVIRONMENT             |
     +-------------------------*/
    if (ClientPermissions.isAuthorized(Permissions.JOBS, Permissions.JOBS_UPDATE)) {
        Column<Job, String> environment = new Column<Job, String>(new EditTextCell()) {
            @Override
            public String getValue(Job object) {
                return object.getJcl().getEnvironment();
            }
        };
        environment.setFieldUpdater(new FieldUpdater<Job, String>() {
            @Override
            public void update(int index, Job job, String value) {
                if (value != null && value.trim().length() > 0) {
                    if (!value.equalsIgnoreCase(job.getJcl().getEnvironment())) {
                        job.getJcl().setEnvironment(value);
                        updateJob(job);
                    }
                    return;
                }
                refresh();
            }
        });
        if (hasFilterableHeaders()) {
            table.addColumn(environment,
                    new TextFilterableHeader("Environment", JobFilterFields.ENVIRONMENT.getName()));
        } else {
            table.addColumn(environment, "Environment");
        }
    } else {
        TextColumn<Job> environment = new TextColumn<Job>() {
            @Override
            public String getValue(Job job) {
                Jcl jcl = job.getJcl();
                return jcl.getEnvironment();
            }
        };
        environment.setSortable(true);
        if (hasFilterableHeaders()) {
            table.addColumn(environment,
                    new TextFilterableHeader("Environment", JobFilterFields.ENVIRONMENT.getName()));
        } else {
            table.addColumn(environment, "Environment");
        }
    }
    /*-------------------------+
     | DOMAIN                  |
     +-------------------------*/
    if (ClientPermissions.isAuthorized(Permissions.JOBS, Permissions.JOBS_UPDATE)) {
        Column<Job, String> domain = new Column<Job, String>(new EditTextCell()) {
            @Override
            public String getValue(Job object) {
                return object.getJcl().getDomain();
            }
        };
        domain.setSortable(true);
        domain.setFieldUpdater(new FieldUpdater<Job, String>() {
            @Override
            public void update(int index, Job job, String valueParm) {
                String value = valueParm;
                if (value != null) {
                    if (value.trim().length() == 0) {
                        value = Jcl.DEFAULT_DOMAIN;
                    }
                    if (!value.equalsIgnoreCase(job.getJcl().getDomain())) {
                        job.getJcl().setDomain(value);
                        updateJob(job);
                    }
                    return;
                }
                refresh();
            }
        });
        if (hasFilterableHeaders()) {
            table.addColumn(domain, new TextFilterableHeader("Domain", JobFilterFields.DOMAIN.getName()));
        } else {
            table.addColumn(domain, "Domain");
        }
    } else {
        TextColumn<Job> domain = new TextColumn<Job>() {
            @Override
            public String getValue(Job job) {
                Jcl jcl = job.getJcl();
                return jcl.getDomain();
            }
        };
        domain.setSortable(true);
        if (hasFilterableHeaders()) {
            table.addColumn(domain, new TextFilterableHeader("Domain", JobFilterFields.DOMAIN.getName()));
        } else {
            table.addColumn(domain, "Domain");
        }
    }

    /*-------------------------+
     | STATIC AFFINITIES       |
     +-------------------------*/
    if (ClientPermissions.isAuthorized(Permissions.JOBS, Permissions.JOBS_UPDATE)) {
        Column<Job, String> affinity = new Column<Job, String>(new EditTextCell()) {
            @Override
            public String getValue(Job object) {
                return object.getJcl().getAffinity();
            }
        };
        affinity.setSortable(true);
        affinity.setFieldUpdater(new FieldUpdater<Job, String>() {
            @Override
            public void update(int index, Job job, String valueParm) {
                String value = valueParm;
                if (value != null) {
                    if (value.trim().length() == 0) {
                        value = Jcl.DEFAULT_AFFINITY;
                    }
                    if (!value.equalsIgnoreCase(job.getJcl().getAffinity())) {
                        job.getJcl().setAffinity(value);
                        updateJob(job);
                    }
                    return;
                }
                refresh();
            }
        });
        if (hasFilterableHeaders()) {
            table.addColumn(affinity, new TextFilterableHeader("Affinity", JobFilterFields.AFFINITY.getName()));
        } else {
            table.addColumn(affinity, "Affinity");
        }
    } else {
        TextColumn<Job> affinity = new TextColumn<Job>() {
            @Override
            public String getValue(Job job) {
                Jcl jcl = job.getJcl();
                return jcl.getAffinity();
            }
        };
        affinity.setSortable(true);
        if (hasFilterableHeaders()) {
            table.addColumn(affinity, new TextFilterableHeader("Affinity", JobFilterFields.AFFINITY.getName()));
        } else {
            table.addColumn(affinity, "Affinity");
        }
    }

    /*-------------------------+
     | SUBMITTED DATE          |
     +-------------------------*/
    TextColumn<Job> submittedDate = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            return JemConstants.DATE_TIME_FULL.format(job.getSubmittedTime());
        }
    };
    submittedDate.setSortable(true);
    if (hasFilterableHeaders()) {
        table.addColumn(submittedDate, new TextFilterableHeader("Submitted time",
                JobFilterFields.SUBMITTED_TIME.getName(), JobFilterFields.SUBMITTED_TIME.getPattern()));
    } else {
        table.addColumn(submittedDate, "Submitted time");
    }

    /*-------------------------+
     | PRIORITY                |
     +-------------------------*/
    if (ClientPermissions.isAuthorized(Permissions.JOBS, Permissions.JOBS_UPDATE)) {
        Column<Job, String> priority = new Column<Job, String>(new EditTextCell()) {
            @Override
            public String getValue(Job job) {
                Jcl jcl = job.getJcl();
                return String.valueOf(jcl.getPriority());
            }
        };
        priority.setSortable(true);
        priority.setFieldUpdater(new FieldUpdater<Job, String>() {
            @Override
            public void update(int index, Job job, String value) {
                if (value != null) {
                    int prio = job.getJcl().getPriority();
                    try {
                        prio = Integer.parseInt(value);
                        if (prio != job.getJcl().getPriority()) {
                            job.getJcl().setPriority(prio);
                            updateJob(job);
                            return;
                        }
                    } catch (Exception e) {
                        LogClient.getInstance().warning(e.getMessage(), e);
                        new Toast(MessageLevel.ERROR, "Value '" + value + "' assigned is NOT valid.",
                                "Priority not changed!").show();
                    }
                }
                refresh();
            }
        });
        if (hasFilterableHeaders()) {
            table.addColumn(priority, new TextFilterableHeader("Priority", JobFilterFields.PRIORITY.getName()));
        } else {
            table.addColumn(priority, "Priority");
        }
    } else {
        TextColumn<Job> priority = new TextColumn<Job>() {
            @Override
            public String getValue(Job job) {
                Jcl jcl = job.getJcl();
                return String.valueOf(jcl.getPriority());
            }
        };
        if (hasFilterableHeaders()) {
            table.addColumn(priority, new TextFilterableHeader("Priority", JobFilterFields.PRIORITY.getName()));
        } else {
            table.addColumn(priority, "Priority");
        }
    }

    /*-------------------------+
     | MEMORY                  |
     +-------------------------*/
    if (ClientPermissions.isAuthorized(Permissions.JOBS, Permissions.JOBS_UPDATE)) {
        Column<Job, String> memory = new Column<Job, String>(new EditTextCell()) {
            @Override
            public String getValue(Job job) {
                Jcl jcl = job.getJcl();
                return String.valueOf(jcl.getMemory());
            }
        };
        memory.setSortable(true);
        memory.setFieldUpdater(new FieldUpdater<Job, String>() {
            @Override
            public void update(int index, Job job, String value) {
                if (value != null) {
                    int mem = job.getJcl().getMemory();
                    try {
                        mem = Integer.parseInt(value);
                        if (mem != job.getJcl().getMemory()) {
                            job.getJcl().setMemory(mem);
                            updateJob(job);
                            return;
                        }
                    } catch (Exception e) {
                        LogClient.getInstance().warning(e.getMessage(), e);
                        new Toast(MessageLevel.ERROR, "Value '" + value + "' assigned is NOT valid.",
                                "Memory not changed!").show();
                    }
                }
                refresh();
            }
        });
        if (hasFilterableHeaders()) {
            table.addColumn(memory, new TextFilterableHeader("Memory (MB)", JobFilterFields.MEMORY.getName()));
        } else {
            table.addColumn(memory, "Memory (MB)");
        }
    } else {
        TextColumn<Job> memory = new TextColumn<Job>() {
            @Override
            public String getValue(Job job) {
                Jcl jcl = job.getJcl();
                return String.valueOf(jcl.getMemory());
            }
        };
        if (hasFilterableHeaders()) {
            table.addColumn(memory, new TextFilterableHeader("Memory (MB)", JobFilterFields.MEMORY.getName()));
        } else {
            table.addColumn(memory, "Memory (MB)");
        }
    }

    /*-------------------------+
     | HOLD                    |
     +-------------------------*/
    TextColumn<Job> hold = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return (jcl.isHold()) ? "hold" : "";
        }
    };
    hold.setSortable(true);
    table.addColumn(hold, "Hold");

    return new InputJobComparator(1);
}

From source file:org.pepstock.jem.gwt.client.panels.jobs.output.OutputTable.java

License:Open Source License

/**
 * Adds all columns to table, defining the sort columns too.
 *///from   ww  w  . ja va  2 s .  co m
@Override
public IndexedColumnComparator<Job> initCellTable(CellTable<Job> table) {
    @SuppressWarnings("unchecked")
    final SelectionModel<Job> selectionModel = (SelectionModel<Job>) table.getSelectionModel();
    Column<Job, Boolean> checkColumn = new Column<Job, Boolean>(new CheckboxCell(true, false)) {
        @Override
        public Boolean getValue(Job job) {
            return selectionModel.isSelected(job);
        }
    };

    // Checkbox

    CheckboxCell headerCheckBox = new CheckboxCell(true, false);
    Header<Boolean> checkHeader = new Header<Boolean>(headerCheckBox) {
        // imposta lo stato dell'header!
        @Override
        public Boolean getValue() {
            // se e' vuoto, niente e' selezionato/selezionabile
            if (getTable().getVisibleItems().isEmpty()) {
                return false;
            }

            // altrimenti testo
            for (Job j : getTable().getVisibleItems()) {
                // se almeno un elemento non e' selezionato, l'header non deve essere selezionato
                if (!getTable().getSelectionModel().isSelected(j)) {
                    return false;
                }
            }
            // altrimenti se arrivo qui, tutti gli elementi sono selezionati
            return true;
        }
    };

    // updater che seleziona o deseleziona tutti gli elementi visibili in base al "valore" dell'header
    checkHeader.setUpdater(new ValueUpdater<Boolean>() {
        @Override
        public void update(Boolean value) {
            for (Job j : getTable().getVisibleItems()) {
                getTable().getSelectionModel().setSelected(j, value);
            }
        }
    });

    table.setColumnWidth(checkColumn, 23, Unit.PX);

    // Name
    // construct a column that uses anchorRenderer
    AnchorTextColumn<Job> name = new AnchorTextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            return job.getName();
        }

        @Override
        public void onClick(int index, Job job, String value) {
            getInspectListener().inspect(job);
        }

    };
    name.setSortable(true);

    TextColumn<Job> type = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            return job.getJcl().getType();
        }
    };
    type.setSortable(true);

    TextColumn<Job> userid = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            // if surrogates, use ONLY user in JCL definition
            return (job.isUserSurrogated()) ? job.getJcl().getUser() : job.getUser();
        }
    };
    userid.setSortable(true);

    TextColumn<Job> environment = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return jcl.getEnvironment();
        }
    };
    environment.setSortable(true);

    TextColumn<Job> routed = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            Date routedTime = job.getRoutingInfo().getRoutedTime();
            return routedTime != null ? JemConstants.YES : "";
        }
    };
    routed.setSortable(true);

    TextColumn<Job> domain = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return jcl.getDomain();
        }
    };
    domain.setSortable(true);

    TextColumn<Job> affinity = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return jcl.getAffinity();
        }
    };
    affinity.setSortable(true);

    TextColumn<Job> endedDate = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            return JemConstants.DATE_TIME_FULL.format(job.getEndedTime());
        }
    };
    endedDate.setSortable(true);

    TextColumn<Job> result = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            return String.valueOf(job.getResult().getReturnCode());
        }
    };
    result.setSortable(true);

    TextColumn<Job> hold = new TextColumn<Job>() {

        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return (jcl.isHold()) ? "hold" : "";
        }
    };

    TextColumn<Job> member = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            return job.getMemberLabel();
        }
    };
    member.setSortable(true);

    /*
     * Add the headers, type based on filterableHeader value
     */
    table.addColumn(checkColumn, checkHeader);
    if (hasFilterableHeaders()) {
        table.addColumn(name, new TextFilterableHeader("Name", JobFilterFields.NAME.getName()));
        table.addColumn(type, new TextFilterableHeader("Type", JobFilterFields.TYPE.getName()));
        table.addColumn(userid, new TextFilterableHeader("User", JobFilterFields.USER.getName())); // warning
        table.addColumn(environment,
                new TextFilterableHeader("Environment", JobFilterFields.ENVIRONMENT.getName()));
        table.addColumn(routed, new TextFilterableHeader("Routed", JobFilterFields.ROUTED.getName(),
                JobFilterFields.ROUTED.getPattern()));
        table.addColumn(domain, new TextFilterableHeader("Domain", JobFilterFields.DOMAIN.getName()));
        table.addColumn(affinity, new TextFilterableHeader("Affinity", JobFilterFields.AFFINITY.getName()));
        table.addColumn(endedDate, new TextFilterableHeader("Ended time", JobFilterFields.ENDED_TIME.getName(),
                JobFilterFields.ENDED_TIME.getPattern()));
        table.addColumn(result, new TextFilterableHeader("Return code", JobFilterFields.RETURN_CODE.getName()));
        table.addColumn(hold, "Hold");
        table.addColumn(member, new TextFilterableHeader("Member", JobFilterFields.MEMBER.getName()));
    } else {
        table.addColumn(name, "Name");
        table.addColumn(type, "Type");
        table.addColumn(userid, "User");
        table.addColumn(environment, "Environment");
        table.addColumn(routed, "Routed");
        table.addColumn(domain, "Domain");
        table.addColumn(affinity, "Affinity");
        table.addColumn(endedDate, "Ended time");
        table.addColumn(result, "Return code");
        table.addColumn(hold, "Hold");
        table.addColumn(member, "Member");
    }
    return new OutputJobComparator(1);
}

From source file:org.pepstock.jem.gwt.client.panels.jobs.routing.RoutingTable.java

License:Open Source License

/**
 * Adds all columns to table, defining the sort columns too.
 *///from  www.j a v a  2 s.co  m
@Override
public IndexedColumnComparator<Job> initCellTable(CellTable<Job> table) {
    @SuppressWarnings("unchecked")
    final SelectionModel<Job> selectionModel = (SelectionModel<Job>) table.getSelectionModel();
    Column<Job, Boolean> checkColumn = new Column<Job, Boolean>(new CheckboxCell(true, false)) {
        @Override
        public Boolean getValue(Job job) {
            return selectionModel.isSelected(job);
        }
    };

    CheckboxCell headerCheckBox = new CheckboxCell(true, false);
    Header<Boolean> checkHeader = new Header<Boolean>(headerCheckBox) {
        // imposta lo stato dell'header!
        @Override
        public Boolean getValue() {
            // se e' vuoto, niente e' selezionato/selezionabile
            if (getTable().getVisibleItems().isEmpty()) {
                return false;
            }

            // altrimenti testo
            for (Job j : getTable().getVisibleItems()) {
                // se almeno un elemento non e' selezionato, l'header non deve essere selezionato
                if (!getTable().getSelectionModel().isSelected(j)) {
                    return false;
                }
            }
            // altrimenti se arrivo qui, tutti gli elementi sono selezionati
            return true;
        }
    };

    // updater che seleziona o deseleziona tutti gli elementi visibili in base al "valore" dell'header
    checkHeader.setUpdater(new ValueUpdater<Boolean>() {
        @Override
        public void update(Boolean value) {
            for (Job j : getTable().getVisibleItems()) {
                getTable().getSelectionModel().setSelected(j, value);
            }
        }
    });

    table.setColumnWidth(checkColumn, 23, Unit.PX);

    // construct a column that uses anchorRenderer
    AnchorTextColumn<Job> name = new AnchorTextColumn<Job>() {
        @Override
        public String getValue(Job object) {
            return object.getName();
        }

        @Override
        public void onClick(int index, Job object, String value) {
            getInspectListener().inspect(object);
        }

    };
    name.setSortable(true);

    TextColumn<Job> type = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            return job.getJcl().getType();
        }
    };
    type.setSortable(true);

    TextColumn<Job> userid = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            // if surrogates, use ONLY user in JCL definition
            return (job.isUserSurrogated()) ? job.getJcl().getUser() : job.getUser();
        }
    };
    userid.setSortable(true);

    TextColumn<Job> environment = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return jcl.getEnvironment();
        }
    };
    environment.setSortable(true);

    TextColumn<Job> domain = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return jcl.getDomain();
        }
    };
    domain.setSortable(true);

    TextColumn<Job> affinity = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return jcl.getAffinity();
        }
    };
    affinity.setSortable(true);

    TextColumn<Job> submittedDate = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            return JemConstants.DATE_TIME_FULL.format(job.getSubmittedTime());
        }
    };
    submittedDate.setSortable(true);

    TextColumn<Job> routeStatus = new TextColumn<Job>() {
        @Override
        public String getValue(Job job) {
            String status = null;
            Boolean isRoutingCommited = job.getRoutingInfo().isRoutingCommitted();
            if (isRoutingCommited == null) {
                status = "TO BE ROUTED";
            } else if (!isRoutingCommited) {
                status = "WAITING CONFIRM";
            } else if (isRoutingCommited) {
                status = "ROUTED";
            } else {
                status = JemConstants.UNKNOWN_BRACKETS;
            }
            return status;
        }
    };
    routeStatus.setSortable(true);

    TextColumn<Job> priority = new TextColumn<Job>() {

        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return String.valueOf(jcl.getPriority());
        }
    };

    TextColumn<Job> hold = new TextColumn<Job>() {

        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return (jcl.isHold()) ? "hold" : "";
        }
    };

    /*
     * Add the headers, type based on filterableHeader value
     */
    table.addColumn(checkColumn, checkHeader);
    if (hasFilterableHeaders()) {
        table.addColumn(name, new TextFilterableHeader("Name", JobFilterFields.NAME.getName()));
        table.addColumn(type, new TextFilterableHeader("Type", JobFilterFields.TYPE.getName()));
        table.addColumn(userid, new TextFilterableHeader("User", JobFilterFields.USER.getName()));
        table.addColumn(environment,
                new TextFilterableHeader("Environment", JobFilterFields.ENVIRONMENT.getName()));
        table.addColumn(domain, new TextFilterableHeader("Domain", JobFilterFields.DOMAIN.getName()));
        table.addColumn(affinity, new TextFilterableHeader("Affinity", JobFilterFields.AFFINITY.getName()));
        table.addColumn(submittedDate, new TextFilterableHeader("Submitted time",
                JobFilterFields.SUBMITTED_TIME.getName(), JobFilterFields.SUBMITTED_TIME.getPattern()));
        table.addColumn(routeStatus, "Route status");
        table.addColumn(priority, new TextFilterableHeader("Priority", JobFilterFields.PRIORITY.getName()));
    } else {
        table.addColumn(name, "Name");
        table.addColumn(type, "Type");
        table.addColumn(userid, "User");
        table.addColumn(environment, "Environment");
        table.addColumn(domain, "Domain");
        table.addColumn(affinity, "Affinity");
        table.addColumn(submittedDate, "Submitted time");
        table.addColumn(routeStatus, "Route status");
        table.addColumn(priority, "Priority");
    }
    table.addColumn(hold, "Hold");

    return new RoutingJobComparator(1);
}

From source file:org.pepstock.jem.gwt.client.panels.jobs.running.RunningTable.java

License:Open Source License

/**
 * Adds all columns to table, defining the sort columns too.
 *///from   ww  w. j a v a 2 s  .com
@Override
public IndexedColumnComparator<Job> initCellTable(CellTable<Job> table) {
    @SuppressWarnings("unchecked")
    final SelectionModel<Job> selectionModel = (SelectionModel<Job>) table.getSelectionModel();
    Column<Job, Boolean> checkColumn = new Column<Job, Boolean>(new CheckboxCell(true, false)) {
        @Override
        public Boolean getValue(Job job) {
            return selectionModel.isSelected(job);
        }
    };

    CheckboxCell headerCheckBox = new CheckboxCell(true, false);
    Header<Boolean> checkHeader = new Header<Boolean>(headerCheckBox) {
        // sets HEADER
        @Override
        public Boolean getValue() {
            // check if is empty
            if (getTable().getVisibleItems().isEmpty()) {
                return false;
            }

            // scans items
            for (Job j : getTable().getVisibleItems()) {
                // if at least one is selected, headr couldn't be chosen
                if (!getTable().getSelectionModel().isSelected(j)) {
                    return false;
                }
            }
            // here all elements are selected
            return true;
        }
    };

    // updater 
    checkHeader.setUpdater(new ValueUpdater<Boolean>() {
        @Override
        public void update(Boolean value) {
            for (Job j : getTable().getVisibleItems()) {
                getTable().getSelectionModel().setSelected(j, value);
            }
        }
    });

    table.setColumnWidth(checkColumn, 23, Unit.PX);

    // construct a column that uses anchorRenderer
    AnchorTextColumn<Job> name = new AnchorTextColumn<Job>() {
        @Override
        public String getValue(Job object) {
            return object.getName();
        }

        @Override
        public void onClick(int index, Job object, String value) {
            getInspectListener().inspect(object);
        }
    };
    name.setSortable(true);

    RunningTextColumn type = new RunningTextColumn() {
        @Override
        public String getValue(Job job) {
            return job.getJcl().getType();
        }
    };
    type.setSortable(true);

    RunningTextColumn userid = new RunningTextColumn() {
        @Override
        public String getValue(Job job) {
            // if surrogates, use ONLY user in JCL definition
            return (job.isUserSurrogated()) ? job.getJcl().getUser() : job.getUser();
        }

    };
    userid.setSortable(true);

    RunningTextColumn step = new RunningTextColumn() {
        @Override
        public String getValue(Job job) {
            if (job.getCurrentStep() != null) {
                return job.getCurrentStep().getName();
            } else {
                return "";
            }
        }
    };

    RunningTextColumn domain = new RunningTextColumn() {
        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return jcl.getDomain();
        }

    };
    domain.setSortable(true);

    RunningTextColumn affinity = new RunningTextColumn() {
        @Override
        public String getValue(Job job) {
            Jcl jcl = job.getJcl();
            return jcl.getAffinity();
        }
    };
    affinity.setSortable(true);

    RunningTextColumn runningTime = new RunningTextColumn() {
        @Override
        public String getValue(Job job) {
            Date startedTime = job.getStartedTime();
            return TimeDisplayUtils.getReadableTimeDiff(startedTime);
        }
    };
    runningTime.setSortable(true);

    RunningTextColumn memory = new RunningTextColumn() {
        @Override
        public String getValue(Job job) {
            return String.valueOf(job.getJcl().getMemory());
        }
    };
    memory.setSortable(true);

    RunningTextColumn member = new RunningTextColumn() {
        @Override
        public String getValue(Job job) {
            return job.getMemberLabel();
        }
    };
    member.setSortable(true);

    /*
     * Add the headers, type based on filterableHeader value
     */
    table.addColumn(checkColumn, checkHeader);
    if (hasFilterableHeaders()) {
        table.addColumn(name, new TextFilterableHeader("Name", JobFilterFields.NAME.getName()));
        table.addColumn(type, new TextFilterableHeader("Type", JobFilterFields.TYPE.getName()));
        table.addColumn(userid, new TextFilterableHeader("User", JobFilterFields.USER.getName()));
        table.addColumn(step, new TextFilterableHeader("Step", JobFilterFields.STEP.getName()));
        table.addColumn(domain, new TextFilterableHeader("Domain", JobFilterFields.DOMAIN.getName()));
        table.addColumn(affinity, new TextFilterableHeader("Affinity", JobFilterFields.AFFINITY.getName()));
        table.addColumn(runningTime, new TextFilterableHeader("Running time",
                JobFilterFields.RUNNING_TIME.getName(), JobFilterFields.RUNNING_TIME.getPattern()));
        table.addColumn(memory, new TextFilterableHeader("Memory (MB)", JobFilterFields.MEMORY.getName()));
        table.addColumn(member, new TextFilterableHeader("Member", JobFilterFields.MEMBER.getName()));
    } else {
        table.addColumn(name, "Name");
        table.addColumn(type, "Type");
        table.addColumn(userid, "User");
        table.addColumn(step, "Step");
        table.addColumn(domain, "Domain");
        table.addColumn(affinity, "Affinity");
        table.addColumn(runningTime, "Running time");
        table.addColumn(memory, "Memory (MB)");
        table.addColumn(member, "Member");
    }

    return new RunningJobComparator(1);

}

From source file:org.pepstock.jem.gwt.client.panels.nodes.NodesTable.java

License:Open Source License

/**
 * Adds all columns to table, defining the sort columns too.
 *///from  ww w.j a  v  a2  s  .c om
@Override
public IndexedColumnComparator<NodeInfoBean> initCellTable(final CellTable<NodeInfoBean> table) {
    /*-------------------------+
     | CHECK BOX FOR SELECTION |
     +-------------------------*/
    @SuppressWarnings("unchecked")
    final SelectionModel<NodeInfoBean> selectionModel = (SelectionModel<NodeInfoBean>) table
            .getSelectionModel();
    Column<NodeInfoBean, Boolean> checkColumn = new Column<NodeInfoBean, Boolean>(
            new CheckboxCell(true, false)) {
        @Override
        public Boolean getValue(NodeInfoBean nodeInfoBean) {
            return selectionModel.isSelected(nodeInfoBean);
        }
    };

    CheckboxCell headerCheckBox = new CheckboxCell(true, false);
    Header<Boolean> checkHeader = new Header<Boolean>(headerCheckBox) {
        // imposta lo stato dell'header!
        @Override
        public Boolean getValue() {
            // se e' vuoto, niente e' selezionato/selezionabile
            if (getTable().getVisibleItems().isEmpty()) {
                return false;
            }

            // altrimenti testo
            for (NodeInfoBean n : getTable().getVisibleItems()) {
                // se almeno un elemento non e' selezionato, l'header non deve essere selezionato
                if (!getTable().getSelectionModel().isSelected(n)) {
                    return false;
                }
            }
            // altrimenti se arrivo qui, tutti gli elementi sono selezionati
            return true;
        }
    };

    // updater che seleziona o deseleziona tutti gli elementi visibili in base al "valore" dell'header
    checkHeader.setUpdater(new ValueUpdater<Boolean>() {
        @Override
        public void update(Boolean value) {
            for (NodeInfoBean n : getTable().getVisibleItems()) {
                getTable().getSelectionModel().setSelected(n, value);
            }
        }
    });

    table.setColumnWidth(checkColumn, 23, Unit.PX);
    table.addColumn(checkColumn, checkHeader);

    /*-------------------------+
     | IPADDRESS AND PORT      |
     +-------------------------*/
    // construct a column that uses anchorRenderer
    AnchorTextColumn<NodeInfoBean> name = new AnchorTextColumn<NodeInfoBean>() {
        @Override
        public String getValue(NodeInfoBean object) {
            return object.getLabel();
        }

        @Override
        public void onClick(int index, NodeInfoBean object, String value) {
            getInspectListener().inspect(object);
        }
    };
    name.setSortable(true);
    table.addColumn(name, new TextFilterableHeader("Name", NodeFilterFields.NAME.getName()));

    /*-------------------------+
     | HOST NAME               |
     +-------------------------*/
    TextColumn<NodeInfoBean> hostname = new TextColumn<NodeInfoBean>() {
        @Override
        public String getValue(NodeInfoBean nodeInfoBean) {
            return nodeInfoBean.getHostname();
        }
    };
    hostname.setSortable(true);
    table.addColumn(hostname, new TextFilterableHeader("Hostname", NodeFilterFields.HOSTNAME.getName()));

    /*-------------------------+
     | DOMAIN                  |
     +-------------------------*/

    if (ClientPermissions.isAuthorized(Permissions.NODES, Permissions.NODES_UPDATE)) {
        Column<NodeInfoBean, String> domain = new Column<NodeInfoBean, String>(new EditTextCell()) {
            @Override
            public String getValue(NodeInfoBean nodeInfoBean) {
                return nodeInfoBean.getExecutionEnvironment().getDomain();
            }
        };
        domain.setSortable(true);
        domain.setFieldUpdater(new DomainFieldUpdater());
        table.addColumn(domain, new TextFilterableHeader("Domain", NodeFilterFields.DOMAIN.getName()));
    } else {
        TextColumn<NodeInfoBean> domain = new TextColumn<NodeInfoBean>() {
            @Override
            public String getValue(NodeInfoBean nodeInfoBean) {
                return nodeInfoBean.getExecutionEnvironment().getDomain();
            }
        };
        domain.setSortable(true);
        table.addColumn(domain, new TextFilterableHeader("Domain", NodeFilterFields.DOMAIN.getName()));
    }

    /*-------------------------+
     | STATIC AFFINITIES       |
     +-------------------------*/
    if (ClientPermissions.isAuthorized(Permissions.NODES, Permissions.NODES_UPDATE)) {
        Column<NodeInfoBean, String> affinity = new Column<NodeInfoBean, String>(new EditTextCell()) {
            @Override
            public String getValue(NodeInfoBean nodeInfoBean) {
                return toAffinityString(nodeInfoBean.getExecutionEnvironment().getStaticAffinities());
            }
        };
        affinity.setSortable(true);
        affinity.setFieldUpdater(new FieldUpdater<NodeInfoBean, String>() {
            @Override
            public void update(int index, NodeInfoBean nodeInfoBean, String valueParm) {
                String value = valueParm;
                if (value != null) {
                    if (value.trim().length() == 0) {
                        value = Jcl.DEFAULT_AFFINITY;
                    }
                    nodeInfoBean.getExecutionEnvironment().getStaticAffinities().clear();
                    String[] affinities = value.split(",");
                    for (int i = 0; i < affinities.length; i++) {
                        nodeInfoBean.getExecutionEnvironment().getStaticAffinities().add(affinities[i]);
                    }
                    updateNode(nodeInfoBean);
                    return;
                }
                refresh();
            }
        });
        table.addColumn(affinity,
                new TextFilterableHeader("Static Affinities", NodeFilterFields.STATIC_AFFINITIES.getName()));
    } else {
        TextColumn<NodeInfoBean> affinity = new TextColumn<NodeInfoBean>() {
            @Override
            public String getValue(NodeInfoBean nodeInfoBean) {
                return toAffinityString(nodeInfoBean.getExecutionEnvironment().getStaticAffinities());
            }
        };
        affinity.setSortable(true);
        table.addColumn(affinity,
                new TextFilterableHeader("Static Affinities", NodeFilterFields.STATIC_AFFINITIES.getName()));
    }

    /*-------------------------+
     | DYNAMIC AFFINITIES      |
     +-------------------------*/
    TextColumn<NodeInfoBean> dynAffinity = new TextColumn<NodeInfoBean>() {
        @Override
        public String getValue(NodeInfoBean nodeInfoBean) {
            return toAffinityString(nodeInfoBean.getExecutionEnvironment().getDynamicAffinities());
        }
    };
    dynAffinity.setSortable(true);
    table.addColumn(dynAffinity,
            new TextFilterableHeader("Dynamic Affinities", NodeFilterFields.DYNAMIC_AFFINITIES.getName()));

    /*-------------------------+
     | STATUS                  |
     +-------------------------*/
    StatusColumn status = new StatusColumn();
    status.setSortable(true);
    table.addColumn(status, new TextFilterableHeader("Status", NodeFilterFields.STATUS.getName()));

    /*-------------------------+
     | OS NAME                 |
     +-------------------------*/
    TextColumn<NodeInfoBean> systemName = new TextColumn<NodeInfoBean>() {
        @Override
        public String getValue(NodeInfoBean nodeInfoBean) {
            return nodeInfoBean.getSystemName();
        }
    };
    systemName.setSortable(true);
    table.addColumn(systemName, new TextFilterableHeader("OS", NodeFilterFields.OS.getName()));

    /*-------------------------+
     | Memory                  |
     +-------------------------*/
    if (ClientPermissions.isAuthorized(Permissions.NODES, Permissions.NODES_UPDATE)) {
        Column<NodeInfoBean, String> memory = new Column<NodeInfoBean, String>(new EditTextCell()) {
            @Override
            public String getValue(NodeInfoBean nodeInfoBean) {
                return String.valueOf(nodeInfoBean.getExecutionEnvironment().getMemory());
            }
        };
        memory.setSortable(true);
        memory.setFieldUpdater(new MemoryFieldUpdater());
        table.addColumn(memory, new TextFilterableHeader("Memory (MB)", NodeFilterFields.MEMORY.getName()));
    } else {
        TextColumn<NodeInfoBean> memory = new TextColumn<NodeInfoBean>() {
            @Override
            public String getValue(NodeInfoBean nodeInfoBean) {
                return String.valueOf(nodeInfoBean.getExecutionEnvironment().getMemory());
            }
        };
        memory.setSortable(true);
        table.addColumn(memory, new TextFilterableHeader("Memory (MB)", NodeFilterFields.MEMORY.getName()));
    }

    /*-------------------------+
     | Parallel jobs           |
     +-------------------------*/
    if (ClientPermissions.isAuthorized(Permissions.NODES, Permissions.NODES_UPDATE)) {
        Column<NodeInfoBean, String> parallelJobs = new Column<NodeInfoBean, String>(new EditTextCell()) {
            @Override
            public String getValue(NodeInfoBean nodeInfoBean) {
                return String.valueOf(nodeInfoBean.getExecutionEnvironment().getParallelJobs());
            }
        };
        parallelJobs.setSortable(true);
        parallelJobs.setFieldUpdater(new ParallelJobsFieldUpdater());
        table.addColumn(parallelJobs,
                new TextFilterableHeader("Parallel Jobs", NodeFilterFields.PARALLEL_JOBS.getName()));
    } else {
        TextColumn<NodeInfoBean> parallelJobs = new TextColumn<NodeInfoBean>() {
            @Override
            public String getValue(NodeInfoBean nodeInfoBean) {
                return String.valueOf(nodeInfoBean.getExecutionEnvironment().getParallelJobs());
            }
        };
        parallelJobs.setSortable(true);
        table.addColumn(parallelJobs,
                new TextFilterableHeader("Parallel Jobs", NodeFilterFields.PARALLEL_JOBS.getName()));
    }

    /*-------------------------+
     | CURRENT JOB             |
     +-------------------------*/
    TextColumn<NodeInfoBean> currentJob = new TextColumn<NodeInfoBean>() {
        @Override
        public String getValue(NodeInfoBean nodeInfoBean) {
            if (nodeInfoBean.getJobNames().isEmpty()) {
                return "";
            } else if (nodeInfoBean.getJobNames().size() > 1) {
                return String.valueOf(nodeInfoBean.getJobNames().size());
            }
            return nodeInfoBean.getJobNames().get(0);
        }

    };

    currentJob.setSortable(true);
    table.addColumn(currentJob,
            new TextFilterableHeader("Running Jobs", NodeFilterFields.CURRENT_JOB.getName()));

    // adds a cell handler to catch the click on column of running jobs
    // to show the list of jobs
    table.addCellPreviewHandler(new JobsListCellPreviewHandler(table));
    return new NodesComparator(1);

}

From source file:org.pepstock.jem.gwt.client.panels.resources.inspector.widgets.CustomPropertiesTable.java

License:Open Source License

/**
 * Adds all columns to table, defining the sort columns too.
 *///from  w w  w. j  av  a 2  s.c om
@Override
public IndexedColumnComparator<ResourceProperty> initCellTable(final CellTable<ResourceProperty> table) {
    /*-------------------------+
     | KEY                |
     +-------------------------*/

    Column<ResourceProperty, String> key = new Column<ResourceProperty, String>(new EditTextCell()) {
        @Override
        public String getValue(ResourceProperty property) {
            return property.getName();
        }
    };
    key.setSortable(false);
    key.setFieldUpdater(new KeyFieldUpdater());
    table.addColumn(key, "Key");
    table.setColumnWidth(key, 50, Unit.PCT);

    /*-------------------------+
     | VALUE       |
     +-------------------------*/
    Column<ResourceProperty, String> value = new Column<ResourceProperty, String>(new EditTextCell()) {
        @Override
        public String getValue(ResourceProperty property) {
            return property.getValue();
        }
    };
    value.setSortable(false);
    value.setFieldUpdater(new ValueFieldUpdater());
    table.addColumn(value, "Value");
    table.setColumnWidth(value, 50, Unit.PCT);
    return new CustomPropertiesComparator(1);

}

From source file:org.pepstock.jem.gwt.client.panels.resources.ResourcesTable.java

License:Open Source License

/**
 * Adds all columns to table, defining the sort columns too.
 *///  w  w  w  .j ava 2  s. com
@Override
public IndexedColumnComparator<Resource> initCellTable(CellTable<Resource> table) {
    @SuppressWarnings("unchecked")
    final SelectionModel<Resource> selectionModel = (SelectionModel<Resource>) table.getSelectionModel();
    Column<Resource, Boolean> checkColumn = new Column<Resource, Boolean>(new CheckboxCell(true, false)) {
        @Override
        public Boolean getValue(Resource role) {
            return selectionModel.isSelected(role);
        }
    };

    CheckboxCell headerCheckBox = new CheckboxCell(true, false);
    Header<Boolean> checkHeader = new Header<Boolean>(headerCheckBox) {
        // imposta lo stato dell'header!
        @Override
        public Boolean getValue() {
            // se e' vuoto, niente e' selezionato/selezionabile
            if (getTable().getVisibleItems().isEmpty()) {
                return false;
            }

            // altrimenti testo
            for (Resource r : getTable().getVisibleItems()) {
                // se almeno un elemento non e' selezionato, l'header non deve essere selezionato
                if (!getTable().getSelectionModel().isSelected(r)) {
                    return false;
                }
            }
            // altrimenti se arrivo qui, tutti gli elementi sono selezionati
            return true;
        }
    };

    // updater che seleziona o deseleziona tutti gli elementi visibili in base al "valore" dell'header
    checkHeader.setUpdater(new ValueUpdater<Boolean>() {
        @Override
        public void update(Boolean value) {
            for (Resource r : getTable().getVisibleItems()) {
                getTable().getSelectionModel().setSelected(r, value);
            }
        }
    });

    table.setColumnWidth(checkColumn, 23, Unit.PX);
    table.addColumn(checkColumn, checkHeader);

    AnchorTextColumn<Resource> name = new AnchorTextColumn<Resource>() {
        @Override
        public void onClick(int index, Resource object, String value) {
            getInspectListener().inspect(object);
        }

        @Override
        public String getValue(Resource resource) {
            return resource.getName();
        }
    };
    name.setSortable(true);
    table.addColumn(name, new TextFilterableHeader("Name", ResourceFilterFields.NAME.getName()));

    TextColumn<Resource> type = new TextColumn<Resource>() {
        @Override
        public String getValue(Resource resource) {
            return resource.getType();
        }
    };
    type.setSortable(true);
    table.addColumn(type, new TextFilterableHeader("Type", ResourceFilterFields.TYPE.getName()));

    AttributesColumn attributes = new AttributesColumn();
    table.addColumn(attributes,
            new TextFilterableHeader("Properties", ResourceFilterFields.PROPERTIES.getName()));

    TextColumn<Resource> lastModified = new TextColumn<Resource>() {
        @Override
        public String getValue(Resource resource) {
            if (resource.getLastModified() == null) {
                return "";
            }
            return JemConstants.DATE_TIME_FULL.format(resource.getLastModified());
        }
    };
    lastModified.setSortable(true);
    table.addColumn(lastModified, new TextFilterableHeader("Modified", ResourceFilterFields.MODIFIED.getName(),
            ResourceFilterFields.MODIFIED.getPattern()));

    TextColumn<Resource> user = new TextColumn<Resource>() {
        @Override
        public String getValue(Resource resource) {
            return resource.getUser() != null ? resource.getUser() : "";
        }
    };
    user.setSortable(true);
    table.addColumn(user, new TextFilterableHeader("Modified by", ResourceFilterFields.MODIFIED_BY.getName()));

    return new ResourcesComparator(1);
}