Example usage for com.google.gwt.gen2.table.client ListCellEditor ListCellEditor

List of usage examples for com.google.gwt.gen2.table.client ListCellEditor ListCellEditor

Introduction

In this page you can find the example usage for com.google.gwt.gen2.table.client ListCellEditor ListCellEditor.

Prototype

public ListCellEditor() 

Source Link

Document

Construct a new ListCellEditor .

Usage

From source file:com.google.gwt.gen2.demo.scrolltable.client.PagingScrollTableDemo.java

License:Apache License

/**
 * @return the {@link TableDefinition} with all ColumnDefinitions defined.
 *//*from   w  w  w  .  j  a  v  a2  s. com*/
private TableDefinition<Student> createTableDefinition() {
    // Define some cell renderers
    CellRenderer<Student, Integer> intCellRenderer = new CellRenderer<Student, Integer>() {
        public void renderRowValue(Student rowValue, ColumnDefinition<Student, Integer> columnDef,
                AbstractCellView<Student> view) {
            view.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
            view.setHTML(columnDef.getCellValue(rowValue).toString());
        }
    };

    // Create the table definition
    tableDefinition = new DefaultTableDefinition<Student>();

    // Set the row renderer
    String[] rowColors = new String[] { "#FFFFDD", "#EEEEEE" };
    tableDefinition.setRowRenderer(new DefaultRowRenderer<Student>(rowColors));

    // First name
    {
        StudentColumnDefinition<String> columnDef = new StudentColumnDefinition<String>("First Name",
                Group.GENERAL) {
            @Override
            public String getCellValue(Student rowValue) {
                return rowValue.getFirstName();
            }

            @Override
            public void setCellValue(Student rowValue, String cellValue) {
                rowValue.setFirstName(cellValue);
            }
        };
        columnDef.setMinimumColumnWidth(50);
        columnDef.setPreferredColumnWidth(100);
        columnDef.setColumnSortable(true);
        columnDef.setColumnTruncatable(false);
        tableDefinition.addColumnDefinition(columnDef);
    }

    // Last name
    {
        StudentColumnDefinition<String> columnDef = new StudentColumnDefinition<String>("Last Name",
                Group.GENERAL) {
            @Override
            public String getCellValue(Student rowValue) {
                return rowValue.getLastName();
            }

            @Override
            public void setCellValue(Student rowValue, String cellValue) {
                rowValue.setLastName(cellValue);
            }
        };
        columnDef.setMinimumColumnWidth(50);
        columnDef.setPreferredColumnWidth(100);
        columnDef.setColumnSortable(true);
        columnDef.setColumnTruncatable(false);
        tableDefinition.addColumnDefinition(columnDef);
    }

    // Age
    {
        StudentColumnDefinition<Integer> columnDef = new StudentColumnDefinition<Integer>("Age",
                Group.GENERAL) {
            @Override
            public Integer getCellValue(Student rowValue) {
                return rowValue.getAge();
            }

            @Override
            public void setCellValue(Student rowValue, Integer cellValue) {
                rowValue.setAge(cellValue);
            }
        };

        // Dynamic footer provides range of ages
        StudentFooterProperty prop = new StudentFooterProperty() {
            @Override
            public Object getFooter(int row, int column) {
                if (row == 1) {
                    int min = -1;
                    int max = -1;
                    int rowCount = pagingScrollTable.getDataTable().getRowCount();
                    for (int i = 0; i < rowCount; i++) {
                        int age = pagingScrollTable.getRowValue(i).getAge();
                        if (min == -1) {
                            min = age;
                            max = age;
                        } else {
                            min = Math.min(min, age);
                            max = Math.max(max, age);
                        }
                    }
                    return min + "-" + max;
                }
                return super.getFooter(row, column);
            }
        };
        prop.setFooterCount(2);
        prop.setDynamic(true);
        columnDef.setColumnProperty(FooterProperty.TYPE, prop);

        columnDef.setCellRenderer(intCellRenderer);
        columnDef.setMinimumColumnWidth(35);
        columnDef.setPreferredColumnWidth(35);
        columnDef.setMaximumColumnWidth(35);
        columnDef.setColumnSortable(true);
        tableDefinition.addColumnDefinition(columnDef);
    }

    // Gender
    {
        StudentColumnDefinition<Boolean> columnDef = new StudentColumnDefinition<Boolean>("Gender",
                Group.GENERAL) {
            @Override
            public Boolean getCellValue(Student rowValue) {
                return rowValue.isMale();
            }

            @Override
            public void setCellValue(Student rowValue, Boolean cellValue) {
                rowValue.setMale(cellValue);
            }
        };
        columnDef.setCellRenderer(new CellRenderer<Student, Boolean>() {
            public void renderRowValue(Student rowValue, ColumnDefinition<Student, Boolean> columnDef,
                    AbstractCellView<Student> view) {
                if (rowValue.isMale()) {
                    view.setHTML("male");
                } else {
                    view.setHTML("female");
                }
            }
        });
        columnDef.setMinimumColumnWidth(45);
        columnDef.setPreferredColumnWidth(45);
        columnDef.setMaximumColumnWidth(45);
        columnDef.setColumnSortable(true);
        tableDefinition.addColumnDefinition(columnDef);

        // Setup the cellEditor
        RadioCellEditor<Boolean> cellEditor = new RadioCellEditor<Boolean>();
        cellEditor.setLabel("Select a gender:");
        cellEditor.addRadioButton(new RadioButton("editorGender", "male"), true);
        cellEditor.addRadioButton(new RadioButton("editorGender", "female"), false);
        columnDef.setCellEditor(cellEditor);
    }

    // Race
    {
        StudentColumnDefinition<String> columnDef = new StudentColumnDefinition<String>("Race", Group.GENERAL) {
            @Override
            public String getCellValue(Student rowValue) {
                return rowValue.getRace();
            }

            @Override
            public void setCellValue(Student rowValue, String cellValue) {
                rowValue.setRace(cellValue);
            }
        };
        columnDef.setMinimumColumnWidth(45);
        columnDef.setPreferredColumnWidth(55);
        columnDef.setMaximumColumnWidth(70);
        columnDef.setColumnSortable(true);
        tableDefinition.addColumnDefinition(columnDef);

        // Setup the cell editor
        ListCellEditor<String> cellEditor = new ListCellEditor<String>();
        for (int i = 0; i < StudentGenerator.races.length; i++) {
            String race = StudentGenerator.races[i];
            cellEditor.addItem(race, race);
        }
        columnDef.setCellEditor(cellEditor);
    }

    // Favorite color
    {
        StudentColumnDefinition<String> columnDef = new StudentColumnDefinition<String>("Favorite Color",
                null) {
            @Override
            public String getCellValue(Student rowValue) {
                return rowValue.getFavoriteColor();
            }

            @Override
            public void setCellValue(Student rowValue, String cellValue) {
                rowValue.setFavoriteColor(cellValue);
            }
        };
        columnDef.setCellRenderer(new CellRenderer<Student, String>() {
            public void renderRowValue(Student rowValue, ColumnDefinition<Student, String> columnDef,
                    AbstractCellView<Student> view) {
                String color = rowValue.getFavoriteColor();
                view.setStyleAttribute("color", color);
                view.setHTML(color);
            }
        });
        columnDef.setPreferredColumnWidth(80);
        columnDef.setColumnSortable(true);
        columnDef.setHeaderTruncatable(false);
        tableDefinition.addColumnDefinition(columnDef);

        // Setup the cell editor
        RadioCellEditor<String> cellEditor = new RadioCellEditor<String>();
        cellEditor.setLabel("Select a color:");
        for (int i = 0; i < StudentGenerator.colors.length; i++) {
            String color = StudentGenerator.colors[i];
            String text = "<FONT color=\"" + color + "\">" + color + "</FONT>";
            cellEditor.addRadioButton(new RadioButton("editorColor", text, true), color);
        }
        columnDef.setCellEditor(cellEditor);
    }

    // Favorite Sport
    {
        StudentColumnDefinition<String> columnDef = new StudentColumnDefinition<String>("Preferred Sport",
                null) {
            @Override
            public String getCellValue(Student rowValue) {
                return rowValue.getFavoriteSport();
            }

            @Override
            public void setCellValue(Student rowValue, String cellValue) {
                rowValue.setFavoriteSport(cellValue);
            }
        };
        columnDef.setPreferredColumnWidth(110);
        columnDef.setColumnSortable(true);
        tableDefinition.addColumnDefinition(columnDef);

        // Setup the cell editor
        ListCellEditor<String> cellEditor = new ListCellEditor<String>();
        cellEditor.setLabel("Select a sport:");
        for (int i = 0; i < StudentGenerator.sports.length; i++) {
            String sport = StudentGenerator.sports[i];
            cellEditor.addItem(sport, sport);
        }
        columnDef.setCellEditor(cellEditor);
    }

    // College
    {
        StudentColumnDefinition<String> columnDef = new StudentColumnDefinition<String>("College",
                Group.SCHOOL) {
            @Override
            public String getCellValue(Student rowValue) {
                return rowValue.getCollege();
            }

            @Override
            public void setCellValue(Student rowValue, String cellValue) {
                rowValue.setCollege(cellValue);
            }
        };
        columnDef.setMinimumColumnWidth(50);
        columnDef.setPreferredColumnWidth(180);
        columnDef.setMaximumColumnWidth(250);
        columnDef.setColumnSortable(true);
        columnDef.setColumnTruncatable(false);
        tableDefinition.addColumnDefinition(columnDef);

        // Setup the cell editor
        TextCellEditor cellEditor = new TextCellEditor() {
            @Override
            public boolean onAccept() {
                if (getValue().equals("")) {
                    Window.alert("You must enter a school");
                    return false;
                }
                return true;
            }

            @Override
            protected int getOffsetLeft() {
                return -8;
            }

            @Override
            protected int getOffsetTop() {
                return -10;
            }
        };
        columnDef.setCellEditor(cellEditor);
    }

    // Graduation year
    {
        StudentColumnDefinition<Integer> columnDef = new StudentColumnDefinition<Integer>("Year",
                Group.SCHOOL) {
            @Override
            public Integer getCellValue(Student rowValue) {
                return rowValue.getGraduationYear();
            }

            @Override
            public void setCellValue(Student rowValue, Integer cellValue) {
                rowValue.setGraduationYear(cellValue);
            }
        };

        // Dynamic footer provides range of ages
        StudentFooterProperty prop = new StudentFooterProperty() {
            @Override
            public Object getFooter(int row, int column) {
                if (row == 1) {
                    int min = -1;
                    int max = -1;
                    int rowCount = pagingScrollTable.getDataTable().getRowCount();
                    for (int i = 0; i < rowCount; i++) {
                        int year = pagingScrollTable.getRowValue(i).getGraduationYear();
                        if (min == -1) {
                            min = year;
                            max = year;
                        } else {
                            min = Math.min(min, year);
                            max = Math.max(max, year);
                        }
                    }
                    return min + "-" + max;
                }
                return super.getFooter(row, column);
            }
        };
        prop.setFooterCount(2);
        prop.setDynamic(true);
        columnDef.setColumnProperty(FooterProperty.TYPE, prop);

        columnDef.setCellRenderer(intCellRenderer);
        columnDef.setPreferredColumnWidth(35);
        columnDef.setMinimumColumnWidth(35);
        columnDef.setMaximumColumnWidth(35);
        columnDef.setColumnSortable(true);
        columnDef.setColumnTruncatable(false);
        tableDefinition.addColumnDefinition(columnDef);
    }

    // GPA
    {
        StudentColumnDefinition<Double> columnDef = new StudentColumnDefinition<Double>("GPA", Group.SCHOOL) {
            @Override
            public Double getCellValue(Student rowValue) {
                return rowValue.getGpa();
            }

            @Override
            public void setCellValue(Student rowValue, Double cellValue) {
                rowValue.setGpa(cellValue);
            }
        };

        // Dynamic footer provides average GPA
        StudentFooterProperty prop = new StudentFooterProperty() {
            @Override
            public Object getFooter(int row, int column) {
                if (row == 1) {
                    double avg = 0;
                    int rowCount = pagingScrollTable.getDataTable().getRowCount();
                    for (int i = 0; i < rowCount; i++) {
                        avg += pagingScrollTable.getRowValue(i).getGpa();
                    }
                    avg /= rowCount;
                    return gpaToString(avg);
                }
                return super.getFooter(row, column);
            }
        };
        prop.setFooterCount(2);
        prop.setDynamic(true);
        columnDef.setColumnProperty(FooterProperty.TYPE, prop);

        // Custom renderer uses background colors based on GPA
        columnDef.setCellRenderer(new CellRenderer<Student, Double>() {
            public void renderRowValue(Student rowValue, ColumnDefinition<Student, Double> columnDef,
                    AbstractCellView<Student> view) {
                view.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
                double gpa = rowValue.getGpa();
                if (gpa < 2) {
                    view.setStyleName("badGPA");
                } else if (gpa < 3) {
                    view.setStyleName("goodGPA");
                } else {
                    view.setStyleName("greatGPA");
                }
                view.setHTML(gpaToString(gpa));
            }
        });
        columnDef.setPreferredColumnWidth(35);
        columnDef.setMinimumColumnWidth(35);
        columnDef.setMaximumColumnWidth(35);
        columnDef.setColumnSortable(true);
        columnDef.setColumnTruncatable(false);
        tableDefinition.addColumnDefinition(columnDef);
    }

    // ID
    {
        StudentColumnDefinition<Integer> columnDef = new StudentColumnDefinition<Integer>("ID", Group.LOGIN) {
            @Override
            public Integer getCellValue(Student rowValue) {
                return rowValue.getId();
            }

            @Override
            public void setCellValue(Student rowValue, Integer cellValue) {
                rowValue.setId(cellValue);
            }
        };
        columnDef.setCellRenderer(intCellRenderer);
        columnDef.setPreferredColumnWidth(55);
        columnDef.setColumnTruncatable(false);
        tableDefinition.addColumnDefinition(columnDef);
    }

    // Pin
    {
        StudentColumnDefinition<Integer> columnDef = new StudentColumnDefinition<Integer>("Pin", Group.LOGIN) {
            @Override
            public Integer getCellValue(Student rowValue) {
                return rowValue.getPin();
            }

            @Override
            public void setCellValue(Student rowValue, Integer cellValue) {
                rowValue.setPin(cellValue);
            }
        };
        columnDef.setCellRenderer(intCellRenderer);
        columnDef.setPreferredColumnWidth(45);
        columnDef.setColumnTruncatable(false);
        tableDefinition.addColumnDefinition(columnDef);
    }

    return tableDefinition;
}