Example usage for com.google.gwt.user.datepicker.client DateBox setValue

List of usage examples for com.google.gwt.user.datepicker.client DateBox setValue

Introduction

In this page you can find the example usage for com.google.gwt.user.datepicker.client DateBox setValue.

Prototype

public void setValue(Date date) 

Source Link

Document

Set the date.

Usage

From source file:ar.com.kyol.jet.client.wrappers.DateBoxWrapper.java

License:Open Source License

/**
 * Instantiates a new date box wrapper.//from w  ww . j a  va2s. c  om
 *
 * @param date the date
 * @param objSetter the obj setter
 * @param dateBox the date box
 * @param useValueAsString the use value as string
 */
public DateBoxWrapper(Date date, ObjectSetter objSetter, final DateBox dateBox, boolean useValueAsString) {
    super(useValueAsString);
    this.dateBox = dateBox;
    this.date = date;
    this.objSetter = objSetter;
    dateBox.setValue(this.date);
    String format = "dd/MM/yyyy";
    if (objSetter.getFormat() != null && !objSetter.getFormat().equals("")) {
        format = objSetter.getFormat();
    }
    dateBox.setFormat(new DateBox.DefaultFormat(DateTimeFormat.getFormat(format)));

    dateBox.addValueChangeHandler(new ValueChangeHandler<Date>() {

        @Override
        @SuppressWarnings("rawtypes")
        public void onValueChange(ValueChangeEvent<Date> arg0) {
            if (DateBoxWrapper.this.date == null) {
                ClassType cType = TypeOracle.Instance
                        .getClassType(DateBoxWrapper.this.objSetter.getObj().getClass());
                DateBoxWrapper.this.date = new Date();
                cType.invoke(DateBoxWrapper.this.objSetter.getObj(), DateBoxWrapper.this.objSetter.getSetter(),
                        new Object[] { DateBoxWrapper.this.date });
            }

            if (DateBoxWrapper.this.dateBox.getValue() != null) {
                DateBoxWrapper.this.date.setTime(DateBoxWrapper.this.dateBox.getValue().getTime());
            } else {
                DateBoxWrapper.this.date = null;
                ClassType cType = TypeOracle.Instance
                        .getClassType(DateBoxWrapper.this.objSetter.getObj().getClass());
                cType.invoke(DateBoxWrapper.this.objSetter.getObj(), DateBoxWrapper.this.objSetter.getSetter(),
                        new Object[] { DateBoxWrapper.this.date });
            }
        }
    });

    //gwt issue 4084 (Fixed in version 2.5)
    dateBox.getTextBox().addValueChangeHandler(new ValueChangeHandler<String>() {
        @Override
        public void onValueChange(ValueChangeEvent<String> event) {
            if ("".equals(event.getValue()) || null == event.getValue()) {
                ValueChangeEvent.fire(dateBox, null);
            }
        }
    });
    initWidget(dateBox);
}

From source file:ar.com.kyol.jet.client.wrappers.SqlDateBoxWrapper.java

License:Open Source License

/**
 * Instantiates a new sql date box wrapper.
 *
 * @param date the date// w  ww  .j  a  v a2  s.com
 * @param dateBox the date box
 * @param useValueAsString the use value as string
 */
public SqlDateBoxWrapper(java.sql.Date date, DateBox dateBox, boolean useValueAsString,
        ObjectSetter objSetter) {
    super(useValueAsString);
    this.dateBox = dateBox;
    this.objSetter = objSetter;
    if (date != null) {
        this.date = new java.sql.Date(date.getTime());
    }
    dateBox.setValue(this.date);
    String format = "dd/MM/yyyy";
    if (objSetter.getFormat() != null && !objSetter.getFormat().equals("")) {
        format = objSetter.getFormat();
    }
    dateBox.setFormat(new DateBox.DefaultFormat(DateTimeFormat.getFormat(format)));

    dateBox.addValueChangeHandler(new ValueChangeHandler<Date>() {

        @Override
        public void onValueChange(ValueChangeEvent<Date> arg0) {
            java.util.Date date = SqlDateBoxWrapper.this.dateBox.getValue();
            setProperty(new java.sql.Date(date.getTime()));
        }
    });

    initWidget(dateBox);
}

From source file:com.eucalyptus.webui.client.view.ReportViewImpl.java

License:Open Source License

private void initDate(DateBox w, Date date) {
    if (date != null) {
        w.setValue(date);
    }
}

From source file:com.google.gwt.examples.DateBoxExample.java

License:Apache License

public void onModuleLoad() {
    DateBox dateBox = new DateBox();
    dateBox.setValue(new Date());
    RootPanel.get().add(dateBox);//  ww w.  j a  v  a  2 s  . c  om
}

From source file:com.tasktop.c2c.server.tasks.client.presenters.TaskSearchPresenter.java

License:Open Source License

private void updateWidgetsWithCriteria(Criteria crit) {
    if (crit instanceof ColumnCriteria) {
        ColumnCriteria columnCriteria = (ColumnCriteria) crit;
        String field = columnCriteria.getColumnName();

        // Date/*from   w ww . j a va 2  s .  c o m*/
        if (field.equals(TaskFieldConstants.LAST_UPDATE_FIELD)
                || field.equals(TaskFieldConstants.CREATION_TIME_FIELD)) {
            ListBox dateTypeListBox = (ListBox) getWidgetForField("dateType");
            String listBoxValue = field.equals(TaskFieldConstants.LAST_UPDATE_FIELD) ? "Updated" : "Created";
            WidgetUtil.select(dateTypeListBox, listBoxValue);
            switch (columnCriteria.getOperator()) {
            case GREATER_THAN:
                DateBox startDateBox = (DateBox) getWidgetForField("startDate");
                startDateBox.setValue((Date) columnCriteria.getColumnValue());
                break;
            case LESS_THAN:
                DateBox endDateBox = (DateBox) getWidgetForField("endDate");
                endDateBox.setValue((Date) columnCriteria.getColumnValue());
                break;
            default:
                throw new UnsupportedOperationException("Can not parse date crit");

            }
            return;
        }
        // Keywords
        else if (field.endsWith(TaskFieldConstants.KEYWORDS_FIELD)) {
            MultiValueChooser<Keyword> keywordChooser = (MultiValueChooser<Keyword>) getWidgetForField("tags");
            Keyword keyword = null;
            for (Keyword k : repositoryConfiguration.getKeywords()) {
                if (k.getName().equals(columnCriteria.getColumnValue())) {
                    keyword = k;
                    break;
                }
            }
            keywordChooser.addValue(keyword, false);
            return;
        }
        // People
        else if (field.equals(TaskFieldConstants.REPORTER_FIELD)
                || field.equals(TaskFieldConstants.ASSIGNEE_FIELD)
                || field.equals(TaskFieldConstants.COMMENT_AUTHOR_FIELD)
                || field.equals(TaskFieldConstants.WATCHER_FIELD)) {
            TakesValue<Boolean> box = (TakesValue<Boolean>) getWidgetForField(field);
            box.setValue(true);

            MultiValueChooser<Person> personChooser = (MultiValueChooser<Person>) getWidgetForField("person");
            String personLogin = columnCriteria.getColumnValue().toString();
            Person person = new Person(personLogin, personLogin);
            for (TaskUserProfile taskPerson : repositoryConfiguration.getUsers()) {
                if (taskPerson.getLoginName().equals(personLogin)) {
                    person = PersonUtil.toPerson(taskPerson);
                    break;
                }
            }
            personChooser.addValue(person, false);
            return;
        }
        // Text
        else if (field.equals(TaskFieldConstants.SUMMARY_FIELD)
                || field.equals(TaskFieldConstants.DESCRIPTION_FIELD)) {
            TakesValue<Boolean> box = (TakesValue<Boolean>) getWidgetForField(field);
            box.setValue(true);

            TextBox textBox = (TextBox) getWidgetForField("summaryDescriptionComments");
            textBox.setValue(columnCriteria.getColumnValue().toString());
            return;
        } else if (field.equals(TaskFieldConstants.COMMENT_FIELD)) {
            // Ignore this because it is part of the above
            return;
        }

        // Generic
        Widget value = getWidgetForField(field);
        if (value == null) {
            throw new UnsupportedOperationException("Can not parse, unknown field: " + field);
        }
        if (value instanceof TextBox) {
            ((TextBox) value).setText(columnCriteria.getColumnValue().toString());
        } else if (value instanceof ListBox) {
            ListBox listBox = (ListBox) value;
            String colValue = columnCriteria.getColumnValue().toString();
            for (int i = 0; i < listBox.getItemCount(); i++) {
                if (listBox.getItemText(i).equals(colValue)) {
                    listBox.setItemSelected(i, true);
                    return;
                }
            }
        }
    } else if (crit instanceof NaryCriteria) {
        // FIXME/REVIEW this is not necessarly correct, not all crit can be represented in this UI
        NaryCriteria naryCriteria = (NaryCriteria) crit;
        for (Criteria sub : naryCriteria.getSubCriteria()) {
            updateWidgetsWithCriteria(sub);
        }
    }
}

From source file:com.tasktop.c2c.server.tasks.client.widgets.CustomFieldEditor.java

License:Open Source License

private Widget createWidget(FieldDescriptor field, String fieldValue) {
    switch (field.getFieldType()) {
    case MULTI_SELECT:
    case SINGLE_SELECT:
        boolean isMultipleSelect = field.getFieldType() == FieldType.MULTI_SELECT;
        ListBox listBox = new ListBox(isMultipleSelect);
        int index = 0;
        Set<String> values = new HashSet<String>();
        if (fieldValue != null) {
            if (isMultipleSelect) {
                values.addAll(Arrays.asList(fieldValue.split("\\s*,\\s*")));
            } else {
                values.add(fieldValue);/*from w  w w.j  a va 2  s  .c om*/
            }
        }
        for (String value : field.getValueStrings()) {
            listBox.addItem(value, value);
            if (values.contains(value)) {
                listBox.setItemSelected(index, true);
            }
            ++index;
        }
        return listBox;

    case TASK_REFERENCE: // FIXME: provide a better way
    case TEXT:
        TextBox textBox = new TextBox();
        textBox.setText(fieldValue);
        return textBox;

    case TIMESTAMP:
        DateBox dateBox = new DateBox();
        if (fieldValue != null && fieldValue.trim().length() > 0) {
            try {
                dateBox.setValue(new Date(Long.parseLong(fieldValue.trim())));
            } catch (NumberFormatException e) {
                // fall-back
                TextBox newTextBox = new TextBox();
                newTextBox.setText(fieldValue);
                return newTextBox;
            }
        }
        return dateBox;

    case CHECKBOX:
        CheckBox checkBox = new CheckBox();
        Boolean cbValue = fieldValue != null && Boolean.parseBoolean(fieldValue);
        checkBox.setValue(cbValue);
        return checkBox;

    }
    return new Label(fieldValue);
}

From source file:eu.riscoss.client.entities.EntityPropertyPage.java

License:Apache License

private void loadContextualInfoData() {
    tb = new FlexTable();
    userForm = new ContextualInfoTable();
    custom = new FlexTable();
    types = new ArrayList<>();

    int row = 0;/*from  w w  w.j a v  a 2  s  .  c o m*/
    int rowC = 0;

    for (int i = 0; i < info.getUserData().size(); i++) {
        JsonRiskDataList.RiskDataItem item = info.getUserData().get(i);

        if (item.getDataType().equals("CUSTOM")) {
            userForm.addField(item.getId(), item.getValue());
        }

        else {

            String val = item.getValue();
            contextualInfo = val.split(";");

            String extrainfo = "";
            for (int k = 1; k < contextualInfo.length; ++k) {
                extrainfo += ";" + contextualInfo[k];
            }
            extraInfoList.add(extrainfo);

            tb.insertRow(row);
            tb.insertCell(row, 0);
            tb.insertCell(row, 1);
            Label id = new Label(item.getId());
            id.setStyleName("bold");
            tb.setWidget(row, 0, id);

            if (item.getDataType().equals("Integer")) {
                TextBox t = new TextBox();
                t.setText(contextualInfo[0]);
                t.addValueChangeHandler(new ValueChangeHandler<String>() {
                    @Override
                    public void onValueChange(ValueChangeEvent<String> event) {
                        changedData = true;
                    }
                });
                tb.setWidget(row, 1, t);
                types.add("Integer");
            } else if (item.getDataType().equals("Boolean")) {
                CheckBox c = new CheckBox();
                if (Integer.parseInt(contextualInfo[0]) == 1)
                    c.setChecked(true);
                c.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
                    @Override
                    public void onValueChange(ValueChangeEvent<Boolean> event) {
                        changedData = true;
                    }
                });
                tb.setWidget(row, 1, c);
                types.add("Boolean");
            } else if (item.getDataType().equals("Date")) {
                DateTimeFormat dateFormat = DateTimeFormat.getLongDateFormat();
                DateBox dateBox = new DateBox();
                dateBox.setFormat(new DateBox.DefaultFormat(dateFormat));
                dateBox.getDatePicker().setYearArrowsVisible(true);
                dateBox.addValueChangeHandler(new ValueChangeHandler<Date>() {
                    @Override
                    public void onValueChange(ValueChangeEvent<Date> event) {
                        changedData = true;
                    }
                });

                Grid g = new Grid(1, 7);

                g.setWidget(0, 0, dateBox);

                String inf[] = contextualInfo[0].split(":");

                TextBox t = new TextBox();
                TextBox t2 = new TextBox();
                TextBox t3 = new TextBox();

                if (inf.length > 1) {
                    String date[] = inf[0].split("-");
                    String time[] = inf[1].split("-");

                    int year = Integer.parseInt(date[0]) - 1900;
                    int month = Integer.parseInt(date[1]) - 1;
                    if (month == 0) {
                        month = 12;
                        --year;
                    }
                    int day = Integer.parseInt(date[2]);
                    Date d = new Date(year, month, day);
                    dateBox.setValue(d);

                    t.setText(String.valueOf(time[0]));
                    t2.setText(String.valueOf(time[1]));
                    t3.setText(String.valueOf(time[2]));
                }

                t.setWidth("30px");

                t.addValueChangeHandler(new ValueChangeHandler<String>() {
                    @Override
                    public void onValueChange(ValueChangeEvent<String> event) {
                        changedData = true;
                    }
                });
                g.setWidget(0, 1, t);
                g.setWidget(0, 2, new Label("hh"));

                t2.setWidth("30px");

                t2.addValueChangeHandler(new ValueChangeHandler<String>() {
                    @Override
                    public void onValueChange(ValueChangeEvent<String> event) {
                        changedData = true;
                    }
                });
                g.setWidget(0, 3, t2);
                g.setWidget(0, 4, new Label("mm"));

                t3.setWidth("30px");

                t3.addValueChangeHandler(new ValueChangeHandler<String>() {
                    @Override
                    public void onValueChange(ValueChangeEvent<String> event) {
                        changedData = true;
                    }
                });
                g.setWidget(0, 5, t3);
                g.setWidget(0, 6, new Label("ss"));

                tb.setWidget(row, 1, g);
                types.add("Date");
            } else if (item.getDataType().equals("List")) {
                ListBox lb = new ListBox();
                for (int k = 1; k < contextualInfo.length; ++k) {
                    lb.addItem(contextualInfo[k]);
                }
                lb.setSelectedIndex(Integer.parseInt(contextualInfo[0]));
                lb.addChangeHandler(new ChangeHandler() {
                    @Override
                    public void onChange(ChangeEvent event) {
                        changedData = true;
                    }
                });

                tb.setWidget(row, 1, lb);
                types.add("List");
            } else if (item.getDataType().equals("Text")) {
                TextBox t = new TextBox();
                t.setText(contextualInfo[0]);
                t.addValueChangeHandler(new ValueChangeHandler<String>() {
                    @Override
                    public void onValueChange(ValueChangeEvent<String> event) {
                        changedData = true;
                    }
                });
                tb.setWidget(row, 1, t);
                types.add("Text");
            }
            ++row;
        }

    }

    HorizontalPanel newCIElement = new HorizontalPanel();
    newCIElement.setStyleName("layerData");
    Label newIDL = new Label("ID");
    newIDL.setStyleName("bold");
    newID = new TextBox();
    Label newValueL = new Label("Value");
    newValueL.setStyleName("bold");
    newValue = new TextBox();
    newCIElement.add(newIDL);
    newCIElement.add(newID);
    newCIElement.add(newValueL);
    newCIElement.add(newValue);

    Button newCustomInfo = new Button("New custom information");
    newCustomInfo.setStyleName("button");
    newCustomInfo.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            boolean b = userForm.newField(newID.getText(), newValue.getText());
            if (b) {
                newID.setText("");
                newValue.setText("");
            }
        }
    });

    VerticalPanel vPanel = new VerticalPanel();
    vPanel.add(newCIElement);
    vPanel.add(newCustomInfo);
    vPanel.add(userForm.getWidget());

    summaryPanel.setWidget(propertiesPanel);
    dataCollectors.setWidget(confDialog.getDock());
    ciPanel.setWidget(vPanel);
}

From source file:gwtquery.plugins.enhance.client.gwt.DateBoxWidgetFactory.java

License:Apache License

@SuppressWarnings("deprecation")
private DateBox create(String v) {
    Date d = new Date();
    DateTimeFormat f = null;//from  w w  w . ja  va2 s.c o m
    if (v != null) {
        try {
            d = new Date(v);
        } catch (Exception e) {
            try {
                f = DateTimeFormat.getFormat(v);
            } catch (Exception e2) {
            }
        }
    }
    DateBox b = new DateBox();
    b.setValue(d);
    if (f != null) {
        b.setFormat(new DefaultFormat(f));
    }
    return b;
}

From source file:org.bonitasoft.forms.client.view.widget.FormFieldWidget.java

License:Open Source License

/**
 * Create a {@link DateBox} widget/*www.  j  a  v a2 s .c om*/
 *
 * @param widgetData
 *        the widget data object
 * @param fieldValue
 *        the widget value
 * @return a {@link DateBox}
 */
@SuppressWarnings("unchecked")
protected DateBox createDateBox(final ReducedFormWidget widgetData, final FormFieldValue fieldValue) {
    final DateBox dateBox = new DateBox();
    dateBox.addValueChangeHandler(this);
    // display format
    if (displayFormatPattern != null && displayFormatPattern.length() > 0) {
        displayFormat = DateTimeFormat.getFormat(displayFormatPattern);
    } else {
        displayFormat = DateTimeFormat.getFormat(PredefinedFormat.DATE_LONG);
    }
    final Format format = new DefaultFormat(displayFormat);
    dateBox.setFormat(format);
    if (fieldValue.getValue() != null) {
        final Date initialDate = (Date) fieldValue.getValue();
        dateBox.setValue(initialDate);
    }
    if (widgetData.isReadOnly()) {
        dateBox.getDatePicker().removeFromParent();
        dateBox.getTextBox().setEnabled(false);
    }
    return dateBox;
}

From source file:org.eclipse.emf.edit.ui.EditorEntryPoint.java

License:Open Source License

public void onModuleLoad() {
    ComposedAdapterFactory composedAdapterFactory = new ComposedAdapterFactory();
    composedAdapterFactory.addAdapterFactory(new ResourceItemProviderAdapterFactory());
    configureItemProviderAdapterFactories(composedAdapterFactory);
    composedAdapterFactory.addAdapterFactory(new ReflectiveItemProviderAdapterFactory());

    final BasicCommandStack commandStack = new BasicCommandStack();
    final AdapterFactoryEditingDomain editingDomain = new AdapterFactoryEditingDomain(composedAdapterFactory,
            commandStack);/*from  ww w.  ja  v  a  2  s. c  o  m*/

    final ResourceSet resourceSet = editingDomain.getResourceSet();
    resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap()
            .put(Resource.Factory.Registry.DEFAULT_EXTENSION, new ResourceFactoryImpl() {
                @Override
                public Resource createResource(URI uri) {
                    return new BinaryResourceImpl(uri);
                }
            });

    final URIServiceAsync uriService = GWT.create(URIService.class);
    URIServiceCallback uriServiceCallback = new URIServiceCallback(uriService);
    resourceSet.getURIConverter().getURIHandlers().add(uriServiceCallback);

    final List<Resource> originalResources = new ArrayList<Resource>();

    Resource listingResource = resourceSet.getResource(URI.createURI("datastore:/"), new Callback<Resource>() {
        public void onFailure(Throwable caught) {
            System.err.println("Failed");
            caught.printStackTrace();
        }

        public void onSuccess(Resource result) {
            EAnnotation eAnnotation = (EAnnotation) result.getContents().get(0);
            for (Map.Entry<String, String> entry : eAnnotation.getDetails()) {
                resourceSet.createResource(URI.createURI(entry.getKey()));
            }
            originalResources.clear();
            originalResources.addAll(resourceSet.getResources());
        }
    });
    resourceSet.getResources().remove(listingResource);

    registerPackages(resourceSet.getPackageRegistry());

    final AdapterFactoryItemDelegator itemDelegator = new AdapterFactoryItemDelegator(composedAdapterFactory);

    DockLayoutPanel mainPanel = new DockLayoutPanel(Unit.PX);
    mainPanel.setStyleName("Main", true);
    mainPanel.setHeight("100%");

    FlowPanel headerPanel = new FlowPanel();
    headerPanel.setStyleName("Header", true);

    final Label header = new Label(getApplicationTitle());
    header.setStyleName("HeaderLabel", true);

    headerPanel.add(header);

    mainPanel.addNorth(headerPanel, 56.0);

    DockLayoutPanel bodyPanel = new DockLayoutPanel(Unit.PX);
    bodyPanel.setStyleName("Body", true);
    bodyPanel.setHeight("100%");

    mainPanel.add(bodyPanel);

    FlowPanel toolBar = new FlowPanel();
    toolBar.setStyleName("ToolBar", true);

    SplitLayoutPanel contentPanel = new SplitLayoutPanel();
    contentPanel.setStyleName("Content", true);

    DockLayoutPanel propertiesPanel = new DockLayoutPanel(Unit.PX);
    propertiesPanel.setStyleName("Properties", true);
    propertiesPanel.setHeight("100%");

    FlowPanel propertiesTitlePanel = new FlowPanel();
    propertiesTitlePanel.setStyleName("PropertiesTitle", true);

    final Label title = new Label("Properties");
    title.setStyleName("PropertiesTitleLabel", true);

    propertiesTitlePanel.add(title);

    propertiesPanel.addNorth(propertiesTitlePanel, 28.0);

    final Grid properties = new Grid();
    properties.setWidth("100%");
    ScrollPanel propertiesScrollPanel = new ScrollPanel();
    propertiesScrollPanel.add(properties);

    propertiesPanel.add(propertiesScrollPanel);

    final Button createButton = new Button();
    createButton.setText("Create...");
    createButton.setStyleName("ToolBarButtonLeftMargin");

    toolBar.add(createButton);

    final Button deleteButton = new Button();
    deleteButton.setText("Delete");
    final CommandHandler deleteCommandHandler = new CommandHandler(editingDomain, deleteButton) {
        @Override
        public Command createCommand(Object value) {
            if (value instanceof Resource) {
                final Resource resource = (Resource) value;
                final Command deleteContentsCommand = DeleteCommand.create(editingDomain,
                        resource.getContents());
                final RemoveCommand removeResourceCommand = new RemoveCommand(editingDomain,
                        resourceSet.getResources(), resource);
                return new CompoundCommand() {
                    @Override
                    protected boolean prepare() {
                        return true;
                    }

                    @Override
                    public void execute() {
                        appendAndExecute(deleteContentsCommand);
                        appendAndExecute(removeResourceCommand);
                    }
                };
            } else {
                return DeleteCommand.create(editingDomain, value);
            }
        }
    };
    deleteButton.setStyleName("ToolBarButton");

    toolBar.add(deleteButton);

    final Button validateButton = new Button();
    validateButton.setText("Validate");
    validateButton.setStyleName("ToolBarButtonLeftMargin");

    toolBar.add(validateButton);

    final Button saveButton = new Button();
    saveButton.setText("Save");
    saveButton.setStyleName("ToolBarButton");

    toolBar.add(saveButton);

    final Button undoButton = new Button();
    undoButton.setText("Undo");
    undoButton.setStyleName("ToolBarButtonLeftMargin");

    toolBar.add(undoButton);

    final Button redoButton = new Button();
    redoButton.setText("Redo");
    redoButton.setStyleName("ToolBarButton");

    toolBar.add(redoButton);

    final Button cutButton = new Button();
    cutButton.setText("Cut");
    final CommandHandler cutCommandHandler = new CommandHandler(editingDomain, cutButton) {
        @Override
        public Command createCommand(Object value) {
            return CutToClipboardCommand.create(editingDomain, value);
        }
    };
    cutButton.setStyleName("ToolBarButtonLeftMargin");

    toolBar.add(cutButton);

    final Button copyButton = new Button();
    copyButton.setText("Copy");
    final CommandHandler copyCommandHandler = new CommandHandler(editingDomain, copyButton) {
        @Override
        public Command createCommand(Object value) {
            return value instanceof EObject ? CopyToClipboardCommand.create(editingDomain, value)
                    : UnexecutableCommand.INSTANCE;
        }
    };
    copyButton.setStyleName("ToolBarButton");

    toolBar.add(copyButton);

    final Button pasteButton = new Button();
    pasteButton.setText("Paste");
    final CommandHandler pasteCommandHandler = new CommandHandler(editingDomain, pasteButton) {
        @Override
        public Command createCommand(Object value) {
            return PasteFromClipboardCommand.create(editingDomain, value, null);
        }
    };
    pasteButton.setStyleName("ToolBarButton");

    toolBar.add(pasteButton);

    final Button upButton = new Button();
    upButton.setText("Up ^");
    final CommandHandler upCommandHandler = new CommandHandler(editingDomain, upButton) {
        @Override
        public Command createCommand(Object value) {
            Object owner = editingDomain.getParent(value);
            if (owner != null) {
                List<?> children = new ArrayList<Object>(editingDomain.getChildren(owner));
                int index = children.indexOf(value);
                if (index != -1) {
                    return MoveCommand.create(editingDomain, owner, null, value, index - 1);
                }
            }
            return UnexecutableCommand.INSTANCE;
        }
    };
    upButton.setStyleName("ToolBarButtonLeftMargin");

    toolBar.add(upButton);

    final Button downButton = new Button();
    downButton.setText("Down v");
    final CommandHandler downCommandHandler = new CommandHandler(editingDomain, downButton) {
        @Override
        public Command createCommand(Object value) {
            Object owner = editingDomain.getParent(value);
            if (owner != null) {
                List<?> children = new ArrayList<Object>(editingDomain.getChildren(owner));
                int index = children.indexOf(value);
                if (index != -1) {
                    return MoveCommand.create(editingDomain, owner, null, value, index + 1);
                }
            }
            return UnexecutableCommand.INSTANCE;
        }
    };
    downButton.setStyleName("ToolBarButton");

    toolBar.add(downButton);

    final Button navigateButton = new Button();
    navigateButton.setText("Navigate");
    navigateButton.setEnabled(false);
    navigateButton.setStyleName("ToolBarButtonLeftMargin");

    toolBar.add(navigateButton);

    final SingleSelectionModel<Object> treeSelection = new SingleSelectionModel<Object>();
    final Collection<Runnable> propertyUpdater = new HashSet<Runnable>();

    TreeViewModel treeViewModel = new TreeViewModel() {
        public <T> NodeInfo<?> getNodeInfo(final T value) {
            final ListDataProvider<Object> abstractListViewAdapter = new ListDataProvider<Object>() {
                int size;

                class NodeAdapter extends AdapterImpl implements INotifyChangedListener {
                    Set<Object> children = new HashSet<Object>();

                    @Override
                    public void notifyChanged(Notification msg) {
                        if (msg.getEventType() != Notification.REMOVING_ADAPTER) {
                            update();
                            if (!(msg.getNotifier() instanceof EObject)) {
                                for (Runnable runnable : propertyUpdater) {
                                    runnable.run();
                                }
                            }
                        }
                    }

                    public void listenTo(Object target) {
                        if (target instanceof Notifier) {
                            ((Notifier) target).eAdapters().add(this);
                        } else if (target instanceof IChangeNotifier) {
                            ((IChangeNotifier) target).addListener(this);
                        }
                    }

                    public void stopListeningTo(Object target) {
                        if (target instanceof Notifier) {
                            ((Notifier) target).eAdapters().remove(this);
                        } else if (target instanceof IChangeNotifier) {
                            ((IChangeNotifier) target).removeListener(this);
                        }
                    }

                    public void listenTo(List<Object> children) {
                        // TODO
                        // I don't know how to update just one child. :-(

                        boolean isListeningToValue = !this.children.isEmpty();
                        Set<Object> oldChildren = new HashSet<Object>(this.children);
                        for (Object child : children) {
                            if (this.children.contains(child)) {
                                oldChildren.remove(child);
                            } else {
                                this.children.add(child);
                                listenTo(child);
                            }
                        }
                        for (Object child : oldChildren) {
                            stopListeningTo(child);
                            this.children.remove(child);
                        }
                        if (isListeningToValue) {
                            if (children.isEmpty()) {
                                stopListeningTo(value);
                            }
                        } else if (!children.isEmpty()) {
                            listenTo(value);
                        }
                    }
                }

                protected NodeAdapter nodeAdapter = new NodeAdapter();

                @Override
                protected void onRangeChanged(HasData<Object> display) {
                    if (value instanceof Resource) {
                        Resource resource = (Resource) value;
                        if (!resource.isLoaded()) {
                            try {
                                resource.load(resourceSet.getLoadOptions());
                            } catch (IOException e) {
                                // Ignore.
                            }
                        }
                    }
                    update();
                }

                protected void update() {
                    Collection<?> children = itemDelegator.getChildren(value);
                    ArrayList<Object> childrenList = new ArrayList<Object>(children);
                    nodeAdapter.listenTo(childrenList);
                    int size = children.size();
                    if (this.size < size) {
                        updateRowCount(size, true);
                        this.size = size;
                    } else {
                        // Pad with dummy objects.
                        for (int i = size; i < this.size; ++i) {
                            childrenList.add(new Object());
                        }
                    }
                    updateRowData(0, childrenList);
                    if (this.size > size) {
                        updateRowCount(size, true);
                        this.size = size;
                    }
                }
            };

            Cell<Object> cell = new AbstractCell<Object>() {
                @Override
                public void render(Context context, Object value, SafeHtmlBuilder safeHtmlBuilder) {
                    StringBuilder sb = new StringBuilder();
                    Object image = itemDelegator.getImage(value);
                    if (image instanceof ImageResource) {
                        ImageResource imageResource = (ImageResource) image;
                        sb.append("<div style='position:relative;padding-left:");
                        sb.append(imageResource.getWidth() + 6);
                        sb.append("px;'>");
                        sb.append("<div style=\"position:absolute;left:0px;top:0px;height:100%;");
                        sb.append("width:").append(imageResource.getWidth()).append("px;");
                        sb.append("background:url('").append(imageResource.getSafeUri()).append("') ");
                        sb.append("no-repeat scroll center center transparent;");
                        sb.append("\"></div>");
                        sb.append(itemDelegator.getText(value));
                        sb.append("</div>");
                    } else if (image instanceof ComposedImage) {
                        ComposedImage composedImage = (ComposedImage) image;
                        List<ComposedImage.Size> sizes = new ArrayList<ComposedImage.Size>();
                        List<Object> images = new ArrayList<Object>(composedImage.getImages());
                        List<ImageData> nestedImagesData = new ArrayList<ImageData>();
                        for (Object nestedImage : images) {
                            ImageData nestedImageData = getImageData(nestedImage);
                            ComposedImage.Size size = new ComposedImage.Size();
                            size.height = nestedImageData.height;
                            size.width = nestedImageData.width;
                            sizes.add(size);
                            nestedImagesData.add(nestedImageData);
                        }
                        ComposedImage.Size size = composedImage.getSize(sizes);
                        sb.append("<div style='position:relative;padding-left:");
                        sb.append(size.width + 6);
                        sb.append("px;'>");
                        List<ComposedImage.Point> drawPoints = composedImage.getDrawPoints(size);
                        int i = 0;
                        for (ComposedImage.Point drawPoint : drawPoints) {
                            ImageResource nestedImage = (ImageResource) images.get(i++);
                            sb.append("<div style=\"position:absolute;left:").append(drawPoint.x)
                                    .append("px;top:").append(drawPoint.y).append("px;height:100%;");
                            sb.append("width:").append(nestedImage.getWidth()).append("px;");
                            sb.append("background:url('").append(nestedImage.getSafeUri()).append("') ");
                            sb.append("no-repeat scroll center center transparent;");
                            sb.append("\"></div>");
                        }
                        sb.append(itemDelegator.getText(value));
                        sb.append("</div>");
                    } else {
                        sb.append(itemDelegator.getText(value));
                    }
                    safeHtmlBuilder.appendHtmlConstant(sb.toString());
                }
            };
            return new DefaultNodeInfo<Object>(abstractListViewAdapter, cell, treeSelection, null);
        }

        public boolean isLeaf(Object value) {
            return !itemDelegator.hasChildren(value);
        }
    };

    treeSelection.setSelected(resourceSet, true);
    final MyCellTree cellTree = new MyCellTree(treeViewModel,
            new ItemProvider(Collections.singleton(resourceSet)));
    ScrollPanel treeScrollPanel = new ScrollPanel();
    treeScrollPanel.add(cellTree);

    class NavigationListener {
        Object selection;

        {
            navigateButton.addClickHandler(new ClickHandler() {
                public void onClick(ClickEvent event) {
                    final Object oldSelection = treeSelection.getSelectedObject();
                    Object newSelection = selection;
                    cellTree.expand(editingDomain.getTreePath(editingDomain.getParent(newSelection)));
                    treeSelection.setSelected(newSelection, true);
                    Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand() {
                        public void execute() {
                            setSelection(oldSelection);
                        }
                    });
                }
            });
        }

        public void listenTo(final ListBox listBox, final List<?> values) {
            listBox.addFocusHandler(new FocusHandler() {
                protected HandlerRegistration changeHandlerRegistration;

                {
                    listBox.addBlurHandler(new BlurHandler() {
                        public void onBlur(BlurEvent event) {
                            if (changeHandlerRegistration != null) {
                                changeHandlerRegistration.removeHandler();
                                changeHandlerRegistration = null;
                            }
                        }
                    });
                }

                public void onFocus(FocusEvent event) {
                    updateSelection();
                    changeHandlerRegistration = listBox.addChangeHandler(new ChangeHandler() {
                        public void onChange(ChangeEvent event) {
                            updateSelection();
                        }
                    });
                }

                void updateSelection() {
                    int selectedIndex = listBox.getSelectedIndex();
                    setSelection(selectedIndex == -1 || selectedIndex >= values.size() ? null
                            : values.get(selectedIndex));
                }
            });
        }

        protected void setSelection(Object object) {
            if (object != selection) {
                selection = object;
                navigateButton.setEnabled(selection != null);
            }
        }
    }
    final NavigationListener navigationListener = new NavigationListener();

    treeSelection.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        protected Object oldSelection;

        public void onSelectionChange(SelectionChangeEvent event) {
            final Object object = treeSelection.getSelectedObject();

            deleteCommandHandler.setSelection(object);
            cutCommandHandler.setSelection(object);
            pasteCommandHandler.setSelection(object);
            copyCommandHandler.setSelection(object);
            upCommandHandler.setSelection(object);
            downCommandHandler.setSelection(object);
            createButton.setEnabled(object instanceof Resource || object instanceof ResourceSet
                    || !editingDomain.getNewChildDescriptors(object, null).isEmpty());

            if (oldSelection == object) {
                for (Runnable runnable : propertyUpdater) {
                    runnable.run();
                }
            } else {
                navigationListener.setSelection(null);

                oldSelection = object;

                List<IItemPropertyDescriptor> propertyDescriptors = itemDelegator
                        .getPropertyDescriptors(object);
                if (propertyDescriptors != null) {
                    properties.clear();
                    propertyUpdater.clear();
                    int size = propertyDescriptors.size();
                    properties.resize(size, 2);
                    properties.getColumnFormatter().setWidth(0, "10%");
                    properties.getColumnFormatter().setWidth(1, "90%");
                    for (int i = 0; i < size; ++i) {
                        final IItemPropertyDescriptor propertyDescriptor = propertyDescriptors.get(i);
                        properties.setText(i, 0, propertyDescriptor.getDisplayName(object));
                        Widget widget = null;
                        final IItemLabelProvider itemLabelProvider = propertyDescriptor
                                .getLabelProvider(object);
                        final Object feature = propertyDescriptor.getFeature(object);
                        if (feature instanceof EReference[]) {
                            final ItemPropertyDescriptorFeatureEditor dialog = new ItemPropertyDescriptorFeatureEditor(
                                    object, true, propertyDescriptor) {
                                @Override
                                protected void hook(ListBox listBox, List<?> values) {
                                    navigationListener.listenTo(listBox, values);
                                }
                            };
                            dialog.update();
                            widget = dialog;
                            propertyUpdater.add(new Runnable() {
                                public void run() {
                                    dialog.update();
                                }
                            });
                        } else if (feature instanceof EStructuralFeature) {
                            final EStructuralFeature eStructureFeature = (EStructuralFeature) feature;
                            final EClassifier eType = eStructureFeature.getEType();
                            final Collection<?> choiceOfValues = propertyDescriptor.getChoiceOfValues(object);
                            if (choiceOfValues != null) {
                                final List<?> listOfValues = new ArrayList<Object>(
                                        propertyDescriptor.getChoiceOfValues(object));
                                if (propertyDescriptor.isMany(object)) {
                                    boolean valid = true;
                                    for (Object choice : choiceOfValues) {
                                        if (!eType.isInstance(choice)) {
                                            valid = false;
                                            break;
                                        }
                                    }

                                    if (valid) {
                                        final ItemPropertyDescriptorFeatureEditor dialog = new ItemPropertyDescriptorFeatureEditor(
                                                object, true, propertyDescriptor) {
                                            @Override
                                            protected void hook(ListBox listBox, List<?> values) {
                                                navigationListener.listenTo(listBox, values);
                                            }
                                        };
                                        dialog.update();
                                        widget = dialog;
                                        propertyUpdater.add(new Runnable() {
                                            public void run() {
                                                dialog.update();
                                            }
                                        });
                                    }
                                }
                                if (widget == null) {
                                    final ListBox listBox = new ListBox();
                                    widget = listBox;
                                    listBox.setVisibleItemCount(1);
                                    Runnable runnable = new Runnable() {
                                        public void run() {
                                            listBox.clear();
                                            navigationListener.listenTo(listBox, listOfValues);
                                            Object propertyValue = itemDelegator.getEditableValue(
                                                    propertyDescriptor.getPropertyValue(object));
                                            for (Object value : choiceOfValues) {
                                                listBox.addItem(itemLabelProvider.getText(value));
                                                if (value == null ? propertyValue == null
                                                        : value.equals(propertyValue)) {
                                                    listBox.setSelectedIndex(listBox.getItemCount() - 1);
                                                }
                                            }
                                        }
                                    };
                                    listBox.addChangeHandler(new ChangeHandler() {
                                        public void onChange(ChangeEvent event) {
                                            Object value = listOfValues.get(listBox.getSelectedIndex());
                                            propertyDescriptor.setPropertyValue(object, value);
                                        }
                                    });
                                    runnable.run();
                                    propertyUpdater.add(runnable);
                                }
                            } else if (eType instanceof EDataType) {
                                final EDataType eDataType = (EDataType) eType;
                                if (eDataType.isSerializable()) {
                                    if (propertyDescriptor.isMany(object)) {
                                        final ItemPropertyDescriptorFeatureEditor dialog = new ItemPropertyDescriptorFeatureEditor(
                                                object, propertyDescriptor) {
                                            @Override
                                            protected void hook(ListBox listBox, List<?> values) {
                                                navigationListener.listenTo(listBox, values);
                                            }
                                        };
                                        dialog.update();
                                        widget = dialog;
                                        propertyUpdater.add(new Runnable() {
                                            public void run() {
                                                dialog.update();
                                            }
                                        });
                                    } else {
                                        if (eDataType.getInstanceClass() == Date.class) {
                                            final DateBox dateBox = new DateBox();
                                            widget = dateBox;
                                            Runnable runnable = new Runnable() {
                                                public void run() {
                                                    Object propertyValue = itemDelegator.getEditableValue(
                                                            propertyDescriptor.getPropertyValue(object));
                                                    dateBox.setValue((Date) propertyValue);
                                                }
                                            };
                                            dateBox.addValueChangeHandler(new ValueChangeHandler<Date>() {
                                                public void onValueChange(ValueChangeEvent<Date> event) {
                                                    propertyDescriptor.setPropertyValue(object,
                                                            event.getValue());
                                                }
                                            });
                                            runnable.run();
                                            propertyUpdater.add(runnable);

                                        } else if (eDataType.getInstanceClass() == Boolean.class
                                                || eDataType.getInstanceClass() == boolean.class) {
                                            final CheckBox checkBox = new CheckBox();
                                            widget = checkBox;
                                            Runnable runnable = new Runnable() {
                                                public void run() {
                                                    Object propertyValue = itemDelegator.getEditableValue(
                                                            propertyDescriptor.getPropertyValue(object));
                                                    checkBox.setValue(Boolean.TRUE.equals(propertyValue));
                                                }
                                            };
                                            checkBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
                                                public void onValueChange(ValueChangeEvent<Boolean> event) {
                                                    propertyDescriptor.setPropertyValue(object,
                                                            event.getValue());
                                                }
                                            });
                                            runnable.run();
                                            propertyUpdater.add(runnable);
                                        } else if (propertyDescriptor.isMultiLine(object)) {
                                            final TextArea textArea = new TextArea();
                                            widget = textArea;
                                            Runnable runnable = new Runnable() {
                                                public void run() {
                                                    Object propertyValue = itemDelegator.getEditableValue(
                                                            propertyDescriptor.getPropertyValue(object));
                                                    textArea.setText(EcoreUtil.convertToString(eDataType,
                                                            propertyValue));
                                                }
                                            };
                                            textArea.addValueChangeHandler(new ValueChangeHandler<String>() {
                                                public void onValueChange(ValueChangeEvent<String> event) {
                                                    propertyDescriptor.setPropertyValue(object, EcoreUtil
                                                            .createFromString(eDataType, event.getValue()));
                                                }
                                            });
                                            runnable.run();
                                            propertyUpdater.add(runnable);
                                        } else {
                                            final TextBox textBox = new TextBox();
                                            widget = textBox;
                                            textBox.addValueChangeHandler(new ValueChangeHandler<String>() {
                                                public void onValueChange(ValueChangeEvent<String> event) {
                                                    String value = event.getValue();
                                                    propertyDescriptor.setPropertyValue(object,
                                                            EcoreUtil.createFromString(eDataType, value));
                                                    // TOD0
                                                    // commandStack.execute(SetCommand.create(editingDomain, object, feature, EcoreUtil.createFromString(eDataType, value)));
                                                }
                                            });
                                            Runnable runnable = new Runnable() {
                                                public void run() {
                                                    Object propertyValue = itemDelegator.getEditableValue(
                                                            propertyDescriptor.getPropertyValue(object));
                                                    String stringValue = EcoreUtil.convertToString(eDataType,
                                                            propertyValue);
                                                    if (!textBox.getText().equals(stringValue)) {
                                                        textBox.setText(stringValue);
                                                    }
                                                }
                                            };
                                            runnable.run();
                                            propertyUpdater.add(runnable);
                                        }
                                    }
                                }
                            }
                        } else {
                            final TextBox textBox = new TextBox();
                            widget = textBox;
                            textBox.addValueChangeHandler(new ValueChangeHandler<String>() {
                                public void onValueChange(ValueChangeEvent<String> event) {
                                    String value = event.getValue();
                                    propertyDescriptor.setPropertyValue(object, value);
                                }
                            });
                            Runnable runnable = new Runnable() {
                                public void run() {
                                    Object propertyValue = itemDelegator
                                            .getEditableValue(propertyDescriptor.getPropertyValue(object));
                                    String stringValue = propertyValue == null ? null
                                            : propertyDescriptor.getLabelProvider(object)
                                                    .getText(propertyValue);
                                    if (!textBox.getText().equals(stringValue)) {
                                        textBox.setText(stringValue);
                                    }
                                }
                            };
                            runnable.run();
                            propertyUpdater.add(runnable);
                        }
                        if (widget != null) {
                            widget.setWidth("95%");
                            properties.setWidget(i, 1, widget);
                            if (!propertyDescriptor.canSetProperty(object) && widget instanceof FocusWidget) {
                                ((FocusWidget) widget).setEnabled(false);

                            }
                        }
                    }
                }
            }
        }
    });

    contentPanel.addWest(treeScrollPanel, 400);
    contentPanel.add(propertiesPanel);

    bodyPanel.addNorth(toolBar, 28.0);
    bodyPanel.add(contentPanel);

    RootPanel.get("main").add(mainPanel);

    createButton.addClickHandler(new ClickHandler() {
        public void onClick(ClickEvent event) {
            Object selection = treeSelection.getSelectedObject();
            if (selection instanceof ResourceSet) {
                final DialogBox dialogBox = new DialogBox();
                dialogBox.setText("Create Resource");
                final Button okButton = new Button("OK");
                final Button cancelButton = new Button("Cancel");
                VerticalPanel verticalPanel = new VerticalPanel();
                Grid grid = new Grid();
                grid.setWidth("50em");
                grid.resize(3, 2);
                grid.getColumnFormatter().setWidth(0, "15%");
                grid.getColumnFormatter().setWidth(1, "85%");
                Label uriLabel = new Label();
                uriLabel.setText("URI");
                final TextBox uriText = new TextBox();
                uriText.setWidth("90%");
                int count = 1;
                while (resourceSet.getResource(URI.createURI("datastore:/resource" + count), false) != null) {
                    ++count;
                }
                uriText.setValue("datastore:/resource" + count);
                uriText.selectAll();
                final Label message = new Label();
                uriText.addValueChangeHandler(new ValueChangeHandler<String>() {
                    public void onValueChange(ValueChangeEvent<String> event) {
                        String value = event.getValue();
                        try {
                            if (resourceSet.getResource(URI.createURI(value), false) != null) {
                                message.setText("This URI a duplicate");
                                okButton.setEnabled(false);
                            } else {
                                message.setText("");
                                okButton.setEnabled(true);
                            }
                        } catch (RuntimeException exception) {
                            message.setText("This URI is not a well formed");
                            okButton.setEnabled(false);
                        }
                    }
                });
                grid.setWidget(0, 0, uriLabel);
                grid.setWidget(0, 1, uriText);
                verticalPanel.add(grid);
                grid.setWidget(1, 1, message);
                grid.setWidget(2, 0, okButton);
                grid.setWidget(2, 1, cancelButton);
                dialogBox.setWidget(verticalPanel);
                dialogBox.show();
                uriText.setFocus(true);
                // dialogBox.setWidth("50em");
                okButton.addClickHandler(new ClickHandler() {
                    public void onClick(ClickEvent event) {
                        dialogBox.hide();
                        commandStack.execute(new AbstractCommand() {
                            Collection<?> affectedObjects;
                            Resource resource;

                            @Override
                            protected boolean prepare() {
                                return true;
                            }

                            public void redo() {
                                resourceSet.getResources().add(resource);
                                affectedObjects = Collections.singleton(resource);
                            }

                            @Override
                            public void undo() {
                                resourceSet.getResources().remove(resource);
                                affectedObjects = Collections.singleton(resourceSet);
                            }

                            public void execute() {
                                resource = resourceSet.createResource(URI.createURI(uriText.getValue()));
                                resource.getContents().clear();
                                affectedObjects = Collections.singleton(resource);
                            }

                            @Override
                            public Collection<?> getAffectedObjects() {
                                return affectedObjects;
                            }
                        });
                    }
                });
                cancelButton.addClickHandler(new ClickHandler() {
                    public void onClick(ClickEvent event) {
                        dialogBox.hide();
                    }
                });
            } else if (selection instanceof Resource) {
                final Resource resource = (Resource) selection;
                final DialogBox dialogBox = new DialogBox();
                dialogBox.setText("Create Object");
                final ListBox listBox = new ListBox();
                listBox.setVisibleItemCount(1);
                Registry packageRegistry = resourceSet.getPackageRegistry();
                for (String nsURI : packageRegistry.keySet()) {
                    EPackage ePackage = packageRegistry.getEPackage(nsURI);
                    for (EClassifier eClassifier : ePackage.getEClassifiers()) {
                        if (eClassifier instanceof EClass) {
                            EClass eClass = (EClass) eClassifier;
                            if (!eClass.isAbstract()) {
                                EObject eObject = EcoreUtil.create(eClass);
                                listBox.addItem("New " + itemDelegator.getText(eObject),
                                        EcoreUtil.getURI(eClass).toString());
                            }
                        }
                    }
                }
                final Button okButton = new Button("OK");
                final Button cancelButton = new Button("Cancel");
                VerticalPanel verticalPanel = new VerticalPanel();
                Grid grid = new Grid();
                grid.setWidth("50em");
                grid.resize(2, 2);
                grid.getColumnFormatter().setWidth(0, "15%");
                grid.getColumnFormatter().setWidth(1, "85%");
                Label classLabel = new Label();
                classLabel.setText("Class");
                grid.setWidget(0, 0, classLabel);
                grid.setWidget(0, 1, listBox);
                verticalPanel.add(grid);
                // verticalPanel.add(okButton);
                grid.setWidget(1, 0, okButton);
                grid.setWidget(1, 1, cancelButton);
                dialogBox.setWidget(verticalPanel);
                dialogBox.show();
                listBox.setFocus(true);
                // dialogBox.setWidth("50em");
                okButton.addClickHandler(new ClickHandler() {
                    public void onClick(ClickEvent event) {
                        dialogBox.hide();
                        commandStack.execute(new AbstractCommand() {
                            EObject eObject;
                            Collection<?> affectedObjects;

                            @Override
                            protected boolean prepare() {
                                return true;
                            }

                            public void redo() {
                                resource.getContents().add(eObject);
                                affectedObjects = Collections.singleton(eObject);
                            }

                            @Override
                            public void undo() {
                                resource.getContents().remove(eObject);
                                affectedObjects = Collections.singleton(resource);
                            }

                            public void execute() {
                                eObject = EcoreUtil.create((EClass) resourceSet.getEObject(
                                        URI.createURI(listBox.getValue(listBox.getSelectedIndex())), false));
                                resource.getContents().add(eObject);
                                affectedObjects = Collections.singleton(eObject);
                            }

                            @Override
                            public Collection<?> getAffectedObjects() {
                                return affectedObjects;
                            }
                        });
                    }
                });
                cancelButton.addClickHandler(new ClickHandler() {
                    public void onClick(ClickEvent event) {
                        dialogBox.hide();
                    }
                });

            } else {
                Collection<?> newChildDescriptors = editingDomain.getNewChildDescriptors(selection, null);
                final DialogBox dialogBox = new DialogBox();
                dialogBox.setText("Create Object");
                final ListBox listBox = new ListBox();
                final List<Command> commands = new ArrayList<Command>();
                listBox.setVisibleItemCount(1);
                for (Object descriptor : newChildDescriptors) {
                    Command command = CreateChildCommand.create(editingDomain, selection, descriptor,
                            Collections.singleton(selection));
                    commands.add(command);
                    listBox.addItem(command.getLabel());
                }
                final Button okButton = new Button("OK");
                final Button cancelButton = new Button("Cancel");
                VerticalPanel verticalPanel = new VerticalPanel();
                Grid grid = new Grid();
                grid.setWidth("50em");
                grid.resize(2, 2);
                grid.getColumnFormatter().setWidth(0, "15%");
                grid.getColumnFormatter().setWidth(1, "85%");
                Label classLabel = new Label();
                classLabel.setText("Class");
                grid.setWidget(0, 0, classLabel);
                grid.setWidget(0, 1, listBox);
                verticalPanel.add(grid);
                // verticalPanel.add(okButton);
                grid.setWidget(1, 0, okButton);
                grid.setWidget(1, 1, cancelButton);
                dialogBox.setWidget(verticalPanel);
                dialogBox.show();
                listBox.setFocus(true);
                // dialogBox.setWidth("50em");
                okButton.addClickHandler(new ClickHandler() {
                    public void onClick(ClickEvent event) {
                        dialogBox.hide();
                        commandStack.execute(commands.get(listBox.getSelectedIndex()));
                    }
                });
                cancelButton.addClickHandler(new ClickHandler() {
                    public void onClick(ClickEvent event) {
                        dialogBox.hide();
                    }
                });
            }
        }
    });

    saveButton.addClickHandler(new ClickHandler() {
        public void onClick(ClickEvent event) {
            EList<Resource> resources = resourceSet.getResources();
            for (Resource resource : resources) {
                try {
                    if (resource.isLoaded()) {
                        Map<String, Object> options = null;
                        if (originalResources.contains(resource)) {
                            options = new HashMap<String, Object>();
                            options.put(URIConverter.OPTION_UPDATE_ONLY_IF_TIME_STAMP_MATCHES,
                                    resource.getTimeStamp());
                        }
                        resource.save(options, new Callback<Resource>() {
                            public void onFailure(Throwable caught) {
                                final DialogBox dialogBox = new DialogBox();
                                dialogBox.setText("Save conflict");
                                final Button okButton = new Button("OK");
                                final Tree tree = new Tree();
                                tree.addItem(SafeHtmlUtils.fromString(caught.getLocalizedMessage()));
                                Grid grid = new Grid();
                                grid.setWidth("150em");
                                grid.resize(2, 1);
                                grid.setWidget(0, 0, tree);
                                grid.setWidget(1, 0, okButton);
                                dialogBox.setWidget(grid);
                                dialogBox.show();
                                okButton.addClickHandler(new ClickHandler() {
                                    public void onClick(ClickEvent event) {
                                        dialogBox.hide();
                                    }
                                });
                            }

                            public void onSuccess(Resource result) {
                                // TODO Auto-generated method stub
                            }
                        });
                    }
                } catch (IOException exception) {
                    EMFEditUIPlugin.INSTANCE.log(exception);
                }
            }
            for (Resource resource : originalResources) {
                if (!resources.contains(resource)) {
                    Map<String, Object> options = null;
                    if (resource.isLoaded()) {
                        options = new HashMap<String, Object>();
                        options.put(URIConverter.OPTION_UPDATE_ONLY_IF_TIME_STAMP_MATCHES,
                                resource.getTimeStamp());
                    }
                    resourceSet.getURIConverter().delete(resource.getURI(), options, new Callback<Map<?, ?>>() {
                        public void onFailure(Throwable caught) {
                            final DialogBox dialogBox = new DialogBox();
                            dialogBox.setText("Delete conflict");
                            final Button okButton = new Button("OK");
                            final Tree tree = new Tree();
                            tree.addItem(SafeHtmlUtils.fromString(caught.getLocalizedMessage()));
                            Grid grid = new Grid();
                            grid.setWidth("150em");
                            grid.resize(2, 1);
                            grid.setWidget(0, 0, tree);
                            grid.setWidget(1, 0, okButton);
                            dialogBox.setWidget(grid);
                            dialogBox.show();
                            okButton.addClickHandler(new ClickHandler() {
                                public void onClick(ClickEvent event) {
                                    dialogBox.hide();
                                }
                            });
                        }

                        public void onSuccess(Map<?, ?> result) {
                            // TODO Auto-generated method stub
                        }
                    });
                }
            }
            originalResources.clear();
            originalResources.addAll(resources);
            commandStack.saveIsDone();
            saveButton.setEnabled(false);
        }
    });

    validateButton.addClickHandler(new ClickHandler() {
        protected TreeItem createTreeItems(Diagnostic diagnostic) {
            TreeItem treeItem = new TreeItem(SafeHtmlUtils.fromString(diagnostic.getMessage()));
            List<?> data = diagnostic.getData();
            if (!data.isEmpty()) {
                treeItem.setUserObject(data.get(0));
            }
            for (Diagnostic child : diagnostic.getChildren()) {
                treeItem.addItem(createTreeItems(child));
            }
            return treeItem;
        }

        public void onClick(ClickEvent event) {
            Diagnostician diagnostician = new Diagnostician() {
                @Override
                public String getObjectLabel(EObject eObject) {
                    return !eObject.eIsProxy() ? itemDelegator.getText(eObject) : super.getObjectLabel(eObject);
                }
            };
            Map<Object, Object> context = diagnostician.createDefaultContext();
            EList<Resource> resources = resourceSet.getResources();
            BasicDiagnostic diagnostics = new BasicDiagnostic();
            for (Resource resource : resources) {
                if (resource.isLoaded()) {
                    for (EObject eObject : resource.getContents()) {
                        diagnostician.validate(eObject, diagnostics, context);
                    }
                }
            }
            final DialogBox dialogBox = new DialogBox();
            dialogBox.setText("Problems");
            final Button okButton = new Button("OK");
            final Tree tree = new Tree();
            if (diagnostics.getSeverity() == Diagnostic.OK) {
                tree.addItem(SafeHtmlUtils.fromString("No problems detected"));
            } else {
                for (Diagnostic child : diagnostics.getChildren()) {
                    tree.addItem(createTreeItems(child));
                }
            }
            Grid grid = new Grid();
            grid.setWidth("150em");
            grid.resize(2, 1);
            grid.setWidget(0, 0, tree);
            grid.setWidget(1, 0, okButton);
            dialogBox.setWidget(grid);
            dialogBox.show();
            okButton.addClickHandler(new ClickHandler() {
                public void onClick(ClickEvent event) {
                    TreeItem treeItem = tree.getSelectedItem();
                    if (treeItem != null) {
                        Object newSelection = treeItem.getUserObject();
                        if (newSelection != null) {
                            cellTree.expand(editingDomain.getTreePath(editingDomain.getParent(newSelection)));
                            treeSelection.setSelected(newSelection, true);
                        }
                    }
                    dialogBox.hide();
                }
            });
        }
    });
    saveButton.setEnabled(false);
    undoButton.setEnabled(false);
    redoButton.setEnabled(false);

    commandStack.addCommandStackListener(new CommandStackListener() {
        public void commandStackChanged(EventObject event) {
            saveButton.setEnabled(commandStack.isSaveNeeded());
            undoButton.setEnabled(commandStack.canUndo());
            redoButton.setEnabled(commandStack.canRedo());

            Command mostRecentCommand = ((CommandStack) event.getSource()).getMostRecentCommand();
            if (mostRecentCommand != null) {
                Collection<?> affectedObjects = mostRecentCommand.getAffectedObjects();
                if (!affectedObjects.isEmpty()) {
                    Object newSelection = affectedObjects.iterator().next();
                    cellTree.expand(editingDomain.getTreePath(editingDomain.getParent(newSelection)));
                    if (treeSelection.getSelectedObject() == newSelection) {
                        for (Runnable runnable : propertyUpdater) {
                            runnable.run();
                        }
                    } else {
                        treeSelection.setSelected(newSelection, true);
                    }
                }
            }
        }
    });

    undoButton.addClickHandler(new ClickHandler() {
        public void onClick(ClickEvent event) {
            commandStack.undo();
        }
    });

    redoButton.addClickHandler(new ClickHandler() {
        public void onClick(ClickEvent event) {
            commandStack.redo();
        }
    });
}