Example usage for com.google.gwt.user.client.ui DialogBox show

List of usage examples for com.google.gwt.user.client.ui DialogBox show

Introduction

In this page you can find the example usage for com.google.gwt.user.client.ui DialogBox show.

Prototype

@Override
    public void show() 

Source Link

Usage

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

License:Apache License

public static void doAddDialog(final AppUser adminAppUser, final RemoteDataServiceAsync remoteService) {
    final DialogBox dialogBox = new DialogBox();
    dialogBox.setText("Add New User");

    // Create a table to layout the content
    UserEdit pet = new UserEdit(new UserEdit.DialogCallback() {

        @Override//  ww  w . j a  v  a 2 s . co  m
        public void result(boolean ok, AppUser appUser) {
            if (ok) {
                appUser.adminAppUserId = adminAppUser.id;

                remoteService.addAppUser(appUser, new AsyncCallback<Void>() {

                    @Override
                    public void onFailure(Throwable caught) {

                    }

                    @Override
                    public void onSuccess(Void result) {
                        dialogBox.hide();

                    }

                });
            } else {
                dialogBox.hide();
            }

        }
    });

    pet.setWidth("100%");
    dialogBox.setWidget(pet);
    dialogBox.center();
    dialogBox.show();

}

From source file:org.apache.oozie.tools.workflowgenerator.client.OozieWorkflowGenerator.java

License:Apache License

/**
 * Initialize menu panel on top/*w w w .  j ava 2 s .c o m*/
 *
 * @return
 */
public MenuBar initMenu() {

    // Menu bar
    Command cmd = new Command() {
        public void execute() {
            Window.alert("To be implemented soon");
        }
    };

    Command mr_cmd = new Command() {
        public void execute() {
            initWidget();
            MapReduceActionWidget mr = new MapReduceActionWidget(OozieWorkflowGenerator.this);
            mr.setName("MR_0");
            addWidget(mr, 300, 100);
            ((OozieDiagramController) controller).addConnection(start, mr);
            ((OozieDiagramController) controller).addConnection(mr, end);
            mr.updateOnSelection();
        }
    };

    Command pig_cmd = new Command() {

        public void execute() {
            clear();
            initWidget();
            PigActionWidget pig = new PigActionWidget(OozieWorkflowGenerator.this);
            pig.setName("Pig_0");
            addWidget(pig, 300, 100);
            ((OozieDiagramController) controller).addConnection(start, pig);
            ((OozieDiagramController) controller).addConnection(pig, end);
            pig.updateOnSelection();
        }
    };

    Command java_cmd = new Command() {

        public void execute() {
            clear();
            initWidget();
            JavaActionWidget java = new JavaActionWidget(OozieWorkflowGenerator.this);
            java.setName("Java_0");
            addWidget(java, 300, 100);
            ((OozieDiagramController) controller).addConnection(start, java);
            ((OozieDiagramController) controller).addConnection(java, end);
            java.updateOnSelection();
        }
    };

    Command forkjoin_cmd = new Command() {

        public void execute() {
            clear();
            initWidget();
            ForkNodeWidget fork = new ForkNodeWidget(OozieWorkflowGenerator.this);
            fork.setName("Fork_0");
            addWidget(fork, 150, 100);
            ((OozieDiagramController) controller).addConnection(start, fork);

            MapReduceActionWidget mr = new MapReduceActionWidget(OozieWorkflowGenerator.this);
            mr.setName("MR_0");
            addWidget(mr, 300, 30);
            ((OozieDiagramController) controller).addMultiConnection(fork, mr);

            PigActionWidget pig = new PigActionWidget(OozieWorkflowGenerator.this);
            pig.setName("Pig_0");
            addWidget(pig, 300, 200);
            ((OozieDiagramController) controller).addMultiConnection(fork, pig);

            JoinNodeWidget join = new JoinNodeWidget(OozieWorkflowGenerator.this);
            join.setName("Join_0");
            addWidget(join, 450, 100);
            ((OozieDiagramController) controller).addConnection(mr, join);
            ((OozieDiagramController) controller).addConnection(pig, join);
            ((OozieDiagramController) controller).addConnection(join, end);

            fork.updateOnSelection();
            join.updateOnSelection();
            mr.updateOnSelection();
            pig.updateOnSelection();
        }
    };

    Command clear_cmd = new Command() {

        public void execute() {
            clear();
        }

    };

    MenuBar fileMenu = new MenuBar(true);
    fileMenu.setAutoOpen(true);
    fileMenu.setAnimationEnabled(true);
    fileMenu.addItem("New", cmd);
    fileMenu.addItem("Open", cmd);
    fileMenu.addItem("Load XML", cmd);
    fileMenu.addItem("Save", cmd);
    fileMenu.addItem("Save As..", cmd);
    fileMenu.addItem("Generate XML", cmd);
    fileMenu.addItem("Print", cmd);
    fileMenu.addItem("Quit", cmd);

    MenuBar editMenu = new MenuBar(true);
    editMenu.setAutoOpen(true);
    editMenu.setAnimationEnabled(true);
    editMenu.addItem("Undo", cmd);
    editMenu.addItem("Redo", cmd);
    editMenu.addItem("Copy", cmd);
    editMenu.addItem("Cut", cmd);
    editMenu.addItem("Paste", cmd);
    editMenu.addItem("Duplicate", cmd);
    editMenu.addItem("Delete", cmd);
    editMenu.addItem("Clear Diagram", clear_cmd);

    MenuBar examples = new MenuBar(true);
    examples.setAutoOpen(true);
    examples.setAnimationEnabled(true);
    examples.addItem("wrkflow with MR action", mr_cmd);
    examples.addItem("wrkflow with Pig action", pig_cmd);
    examples.addItem("wrkflow with Java action", java_cmd);
    examples.addItem("wrkflow with Fork/Join ", forkjoin_cmd);

    MenuBar helpMenu = new MenuBar(true);
    helpMenu.setAutoOpen(true);
    helpMenu.setAnimationEnabled(true);

    // TODO this should point to a workflowgenerator's maven site, however there is no maven site available. (Not even in
    // Workspace of the jenkins job at https://builds.apache.org/job/oozie-trunk-precommit-build/ws/workflowgenerator/target/)
    // where client, for example, has target/site/apidocs
    // The ideal place is somewhere under http://oozie.apache.org/docs/ once it is generated.
    Command openOozieTopPageComman = new Command() {
        @Override
        public void execute() {
            Window.open("http://oozie.apache.org/", "_blank", "");
        }
    };
    helpMenu.addItem("Documentation", openOozieTopPageComman);
    helpMenu.addItem("Online Help", openOozieTopPageComman);

    Command aboutCommand = new Command() {
        @Override
        public void execute() {
            // Dialogbox
            final DialogBox d = new DialogBox(false, true);
            d.setGlassEnabled(true);
            d.setText("About Oozie Workflow Generator");
            d.center();

            // Set this to workaround the grid z-index issue https://issues.apache.org/jira/browse/OOZIE-1081
            d.getElement().getStyle().setZIndex(ZINDEX_FRONT_OF_GRID);

            // About text
            VerticalPanel vpanel = new VerticalPanel();
            vpanel.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_CENTER);
            vpanel.setSpacing(10);
            vpanel.setWidth("150");
            vpanel.add(new Label("Oozie Workflow Generator"));
            vpanel.add(new Label("Version 3.4.0-SNAPSHOT")); // TODO how to get a version number from pom?

            // OK button to close
            Button ok = new Button("OK");
            ok.addClickHandler(new ClickHandler() {
                @Override
                public void onClick(ClickEvent event) {
                    d.hide();
                }

            });

            vpanel.add(ok);
            d.setWidget(vpanel);
            d.show();

        }
    };
    helpMenu.addItem("About", aboutCommand);

    MenuBar menu = new MenuBar();
    menu.addItem("File", fileMenu);
    menu.addItem("Edit", editMenu);
    menu.addItem("Example", examples);
    menu.addItem("Help", helpMenu);

    return menu;
}

From source file:org.apache.solr.explorer.client.core.manager.ui.BasicUIManager.java

License:Apache License

protected void showMessgeDialog(String title, Image icon, Widget widget, final AsyncCallback<Void> callback) {
    final DialogBox dialogBox = new DialogBox(false, true);
    dialogBox.setText(title);//from  w  w  w  .  ja  v  a 2s  . c om

    VerticalPanel content = new VerticalPanel();
    content.setStyleName("MessageDialogContent");
    icon.setStyleName("Icon");
    HorizontalPanel messageRow = new HorizontalPanel();
    messageRow.add(icon);
    messageRow.add(widget);
    messageRow.setCellVerticalAlignment(widget, HorizontalPanel.ALIGN_MIDDLE);
    content.add(messageRow);
    Button closeButton = new Button("Close", new ClickHandler() {
        public void onClick(ClickEvent event) {
            dialogBox.hide();
            if (callback != null) {
                callback.onSuccess(null);
            }
        }
    });
    LayoutUtils.addGap(content, "5px");
    content.add(closeButton);
    content.setCellHorizontalAlignment(closeButton, VerticalPanel.ALIGN_RIGHT);

    dialogBox.setWidget(content);
    dialogBox.center();
    dialogBox.show();
}

From source file:org.C2C.client.Task.java

License:Open Source License

public static void INIT() {
    CallManager.INIT();/*  www .  j  a va  2 s . co m*/
    TASK_WAIT = new TaskWait();
    TASK_WAIT.run();
    DialogBox dialogbox = new DialogBox(false);
    dialogbox.setStyleName("demo-DialogBox");
    dialogbox.show();
    ClassRegistry.INIT_CLASSES();
}

From source file:org.C2C.client.TaskManager.java

License:Open Source License

public static void RUN() {
    DialogBox dialogbox = new DialogBox(false);
    dialogbox.setStyleName("demo-DialogBox");
    dialogbox.setText("RUNX " + ACTIVE_COUNT + ", ");
    dialogbox.show();
    if (ACTIVE_COUNT <= 0 /*|| !CallManager.IS_LOGGEDIN*/) {
        return;//www. j  a v  a  2  s . c om
    }
    dialogbox.setText("RUNY");
    dialogbox.show();
    String toServer = "";
    Task prev = null;
    Map<Integer, Task> tasks = GET_TASKS();
    Set<Integer> keySet = tasks.keySet();
    for (Integer key : keySet) {
        final Task tsk = tasks.get(key);
        if (!tsk.isCompleted()) {
            if (tsk instanceof TaskEmpty) {
                if (tsk.isActiveTaskChild()) {
                    if (!toServer.isEmpty()) {
                        prev.addListener(new TaskCompletedListener() {
                            public void completed(Task task) {

                                String s = tsk.run();

                            }
                        });
                    } else {
                        tsk.run();
                    }
                }
            } else {
                String runRes = "";
                runRes = tsk.run();
                toServer = toServer.concat(runRes);

                prev = tsk;

            }
        }
    }
    if (!toServer.isEmpty()) {
        //WindowManager.getInstance().setStatusBarText(toServer.length()+"");
        CallManager.SEND_TO_SERVER(toServer);
    }
}

From source file:org.C2C.client.TaskWait.java

License:Open Source License

/**
 * The default constructor for class TaskWait
 *///from  ww  w .  j  a va 2s.c  o  m
public TaskWait() {
    super();
    setCompleted(true);
    m_listener = new TaskCompletedListener() {
        public void completed(Task task) {
            if (!TaskManager.TRANSFERING) {
                //TaskManager.RUN();
                DialogBox dialogbox = new DialogBox(false);
                dialogbox.setStyleName("demo-DialogBox");
                dialogbox.setText("TaskWait callback");
                dialogbox.show();

            }
            //((TaskWait) task).run();
        }
    };
    //        DialogBox dialogbox = new DialogBox(false);
    //        dialogbox.setStyleName("demo-DialogBox");
    //        dialogbox.setText("TaskWait");
    //        dialogbox.show();
    addListener(m_listener);
    TaskManager.ADD_TASK(this);
}

From source file:org.client.XholonJsApi.java

License:Open Source License

/**
 * Popup a panel containing user-specified HTML.
 * @param title - Popup title./* ww w .jav a  2 s.com*/
 * @param htmlText - HTML content of the panel.
 * @param autoHide - true if the dialog should be automatically hidden when the user clicks outside of it
 * @param modal - true if keyboard and mouse events for widgets not contained by the dialog should be ignored
 * @param left - the popup's left position relative to the browser's client area (in pixels)
 * @param top - the popup's top position relative to the browser's client area (in pixels)
 * @return - the DialogBox's underlying DOM element
 */
public static Element popup(String title, String htmlText, boolean autoHide, boolean modal, int left, int top) {
    final DialogBox db = new DialogBox(autoHide, modal);
    db.setText(title);
    //String safeHtmlText = SafeHtmlUtils.fromString(htmlText).asString();
    //db.setWidget(new HTML(safeHtmlText)); // this doesn't work  "<" becomes &lt;  etc.
    db.setWidget(new HTML(htmlText));
    db.setPopupPosition(left, top);
    db.show();
    return db.getElement();
}

From source file:org.datacleaner.monitor.util.ErrorHandler.java

License:Open Source License

/**
 * Shows an error dialog/*w  w w .j av  a 2s  . c  om*/
 * 
 * @param messageHeader
 * @param details
 * @param additionalDetails
 */
public static void showErrorDialog(String messageHeader, String details, String additionalDetails) {
    final DialogBox dialogBox = getDialogBox();

    final FlowPanel panel = new FlowPanel();
    final Label messageLabel = new Label(messageHeader);
    messageLabel.addStyleName("Message");
    panel.add(messageLabel);

    if (details != null && details.trim().length() > 0) {
        final TextArea textArea = new TextArea();
        textArea.setText(details);
        textArea.setReadOnly(true);
        textArea.addStyleName("Details");

        panel.add(textArea);
    }

    if (additionalDetails != null && additionalDetails.trim().length() > 0) {
        final TextArea textArea = new TextArea();
        textArea.setText(additionalDetails);
        textArea.setReadOnly(true);
        textArea.addStyleName("AdditionalMessageDetails");

        panel.add(textArea);
    }

    final Button closeButton = DCButtons.primaryButton(null, "Close");
    closeButton.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            dialogBox.hide();
        }
    });

    final ButtonPanel buttonPanel = new ButtonPanel();
    buttonPanel.addButton(closeButton);
    panel.add(buttonPanel);

    dialogBox.setWidget(panel);
    dialogBox.center();
    dialogBox.show();
}

From source file:org.dataconservancy.dcs.access.client.ui.EmailPopupPanel.java

License:Apache License

public EmailPopupPanel(final String entityId, String emailAddress) {
    super(false);
    grid.getRowFormatter().setStyleName(0, "emailPopupPanelText");
    // grid.setColumnWidth(0, 40, Unit.PX);
    //grid.getColumnFormatter().setStyleName(0, "columnWidth");
    final VerticalPanel panel = new VerticalPanel();

    panel.setStyleName("emailPopupPanel");
    setWidget(panel);/* ww  w.  java  2  s .c o  m*/
    setStyleName("emailPopupPanelContainer");
    emailBox = new TextBox();
    emailBox.setStyleName("textbox");
    if (emailAddress != null)
        emailBox.setText(emailAddress);
    grid.setStyleName("Middle");
    buttonGrid.setStyleName("Middle");
    grid.setWidget(0, 1, emailBox);

    grid.setWidget(0, 0, new Label("Please enter your email address:"));

    Button ok = new Button("Send Email");

    Button cancel = new Button("Cancel");
    buttonGrid.setWidget(0, 0, ok);
    //grid.getCellFormatter().setStyleName(1, 0, "LeftPad");
    buttonGrid.setWidget(0, 1, cancel);

    // panel.setStyleName("Middle");
    panel.add(grid);
    panel.add(buttonGrid);
    ok.addClickHandler(new ClickHandler() {

        @Override
        public void onClick(ClickEvent event) {

            if (emailBox.getText() != null && emailBox.getText().length() > 0) {
                hidePanel();
                final DialogBox db = new DialogBox();
                db.setText("You will receive an email shortly");
                final VerticalPanel panel = new VerticalPanel();
                panel.setStyleName("Middle");
                //         panel.setStyleName("alertContainer");

                final Button buttonClose = new Button("Close", new ClickHandler() {
                    @Override
                    public void onClick(final ClickEvent event) {
                        db.hide();
                    }
                });
                final Label emptyLabel = new Label("");
                emptyLabel.setSize("auto", "25px");
                panel.add(emptyLabel);
                panel.add(emptyLabel);
                buttonClose.setWidth("90px");

                panel.add(buttonClose);

                db.add(panel);
                db.center();
                db.show();
                final UserServiceAsync userService = GWT.create(UserService.class);
                final DepositServiceAsync depositService = GWT.create(DepositService.class);
                AsyncCallback<String> callback = new AsyncCallback<String>() {
                    @Override
                    public void onSuccess(String result) {
                        AsyncCallback<Void> emailCallback = new AsyncCallback<Void>() {

                            @Override
                            public void onSuccess(Void result) {
                                // TODO Auto-generated method stub
                                //Do nothing

                            }

                            @Override
                            public void onFailure(Throwable caught) {
                                // TODO Auto-generated method stub

                            }
                        };
                        //Window.alert("Sent email");
                        if (result != null) {
                            String[] recipients = new String[1];
                            recipients[0] = emailBox.getText();
                            userService.sendEmail(recipients, "Dataset ready for download!",
                                    "Your download is ready and can be obtained from the following url(s):\n"
                                            + result + ".\n\nThanks,\nSEAD Virtual Archive Team",
                                    emailCallback);
                        }
                    }

                    @Override
                    public void onFailure(Throwable caught) {
                        // TODO Auto-generated method stub

                    }
                };
                depositService.getLinks(SeadApp.packageLinkURLnoEncoding(entityId), callback);
            } else {
                Window.alert("Email address cannot be empty");
            }

        }
    });

    cancel.addClickHandler(new ClickHandler() {

        @Override
        public void onClick(ClickEvent event) {
            emailId = "";
            hidePanel();
        }
    });

}

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);//w  w w.jav  a 2 s . co  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();
        }
    });
}