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

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

Introduction

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

Prototype

@Override
    public void hide() 

Source Link

Usage

From source file:org.berlin.network.client.ParseLogCriticalErrors.java

License:Open Source License

/**
 * This is the entry point method.//w w  w  .j a  v  a 2s  . c  om
 */
public void onModuleLoad() {

    final Button sendButton = new Button("Execute Command");
    final TextBox nameField = new TextBox();
    final TextBox sessionLookupField = new TextBox();
    final TextBox expressionField = new TextBox();

    nameField.setText("help");
    sessionLookupField.setText("");
    expressionField.setText("");

    final Label errorLabel = new Label();
    final Label statusMessageLabel = new Label();
    statusMessageLabel.setText("Status command area - waiting for command...");

    // We can add style names to widgets
    sendButton.addStyleName("sendButton");

    // Add the nameField and sendButton to the RootPanel
    // Use RootPanel.get() to get the entire body element
    RootPanel.get("nameFieldContainer").add(nameField);
    RootPanel.get("sessionFieldContainer").add(sessionLookupField);
    RootPanel.get("expressionFieldContainer").add(expressionField);
    RootPanel.get("sendButtonContainer").add(sendButton);
    RootPanel.get("errorLabelContainer").add(errorLabel);
    RootPanel.get("statusLabelContainer").add(statusMessageLabel);
    // Focus the cursor on the name field when the app loads
    nameField.setFocus(true);
    nameField.selectAll();
    // Create the popup dialog box
    final DialogBox dialogBox = new DialogBox();
    dialogBox.setText("Remote Procedure Call");
    dialogBox.setAnimationEnabled(true);

    final Button closeButton = new Button("Close");
    // We can set the id of a widget by accessing its Element
    closeButton.getElement().setId("closeButton");
    final Label textToServerLabel = new Label();
    final HTML serverResponseLabel = new HTML();

    final VerticalPanel dialogVPanel = new VerticalPanel();
    dialogVPanel.addStyleName("dialogVPanel");
    dialogVPanel.add(new HTML("<b>Sending command to the server:</b>"));
    dialogVPanel.add(textToServerLabel);
    dialogVPanel.add(new HTML("<br><b>Server replies:</b>"));
    dialogVPanel.add(serverResponseLabel);
    dialogVPanel.setHorizontalAlignment(VerticalPanel.ALIGN_RIGHT);
    dialogVPanel.add(closeButton);
    dialogBox.setWidget(dialogVPanel);

    // Add a handler to close the DialogBox
    closeButton.addClickHandler(new ClickHandler() {
        public void onClick(ClickEvent event) {
            dialogBox.hide();
            sendButton.setEnabled(true);
            sendButton.setFocus(true);
        }
    });
    final CellTable<SessionUIInfo> tableSessionInfo = new CellTable<SessionUIInfo>();
    // Create a handler for the sendButton and nameField
    final class MyHandler implements ClickHandler, KeyUpHandler {
        /**
         * Fired when the user clicks on the sendButton.
         */
        public void onClick(ClickEvent event) {
            sendCommandToServer();
        }

        /**
         * Fired when the user types in the nameField.
         */
        public void onKeyUp(KeyUpEvent event) {
            if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
                sendCommandToServer();
            }
        }

        /**
         * Send the name from the nameField to the server and wait for a response.
         */
        private void sendCommandToServer() {

            final String cmdToServer = nameField.getText();
            final String sessionIdData = sessionLookupField.getText();

            // First, we validate the input.
            errorLabel.setText("");
            statusMessageLabel.setText("Running command [" + cmdToServer + "]...");
            tableSessionInfo.setVisible(true);
            if (!FieldVerifier.isValidName(cmdToServer)) {
                errorLabel.setText("Please enter a command (Example = help)");
                return;
            }
            // Then, we send the input to the server.
            sendButton.setEnabled(false);
            textToServerLabel.setText(cmdToServer);
            serverResponseLabel.setText("");

            /**********************************
             * Basic Greet Service Action
             **********************************/
            greetingService.greetServer(cmdToServer, sessionIdData, new AsyncCallback<String>() {
                public void onFailure(final Throwable caught) {
                    // Show the RPC error message to the user
                    dialogBox.setText("Remote Procedure Call - Failure");
                    serverResponseLabel.addStyleName("serverResponseLabelError");
                    serverResponseLabel.setHTML(SERVER_ERROR);
                    statusMessageLabel.setText("Error at command");
                    dialogBox.center();
                    closeButton.setFocus(true);
                }

                public void onSuccess(final String result) {
                    dialogBox.setText("Remote Procedure Call");
                    serverResponseLabel.removeStyleName("serverResponseLabelError");
                    serverResponseLabel.setHTML(result);
                    dialogBox.center();
                    closeButton.setFocus(true);
                    statusMessageLabel.setText("Message command run - [" + cmdToServer + "]");
                    System.out.println("On success of command from server ");
                }
            });

            final String expr = expressionField.getText();
            System.out.println("on command, sending request to server");
            sessionService.sessionServer(cmdToServer, sessionIdData, expr,
                    sessionCallbackFromCommand(tableSessionInfo));
        }
    } // End of class //

    // Add a handler to send the name to the server
    final MyHandler handler = new MyHandler();
    sendButton.addClickHandler(handler);
    nameField.addKeyUpHandler(handler);
    /****************************************************************
     * Add property data table
     ****************************************************************/
    {
        // Create a CellTable.
        final CellTable<PropertyEntry> tableProperty = new CellTable<PropertyEntry>();
        // Create name column.
        final TextColumn<PropertyEntry> nameColumn = new TextColumn<PropertyEntry>() {
            @Override
            public String getValue(final PropertyEntry contact) {
                return contact.name;
            }
        };
        // Make the name column sortable.
        nameColumn.setSortable(true);
        // Create address column.
        final TextColumn<PropertyEntry> addressColumn = new TextColumn<PropertyEntry>() {
            @Override
            public String getValue(final PropertyEntry contact) {
                return contact.value;
            }
        };
        // Add the columns.
        tableProperty.addColumn(nameColumn, "Name");
        tableProperty.addColumn(addressColumn, "Value");

        // Set the total row count. You might send an RPC request to determine the
        // total row count.
        tableProperty.setRowCount(34, false);
        // Set the range to display. In this case, our visible range is smaller than
        // the data set.
        tableProperty.setVisibleRange(0, 34);
        final AsyncDataProvider<PropertyEntry> dataProviderForPropertyList = new AsyncDataProvider<PropertyEntry>() {
            @Override
            protected void onRangeChanged(final HasData<PropertyEntry> display) {
                final Range range = display.getVisibleRange();
                // Get the ColumnSortInfo from the table.
                final ColumnSortList sortList = tableProperty.getColumnSortList();
                new Timer() {
                    @Override
                    public void run() {
                        final AsyncCallback<List<PropertyEntry>> callbackPropertyChange = new AsyncCallback<List<PropertyEntry>>() {
                            @Override
                            public void onFailure(final Throwable caught) {
                                System.out.println("Error - " + caught);
                                dialogBox.setText("Remote Procedure Call - Failure");
                                serverResponseLabel.addStyleName("serverResponseLabelError");
                                serverResponseLabel.setHTML(SERVER_ERROR);
                                dialogBox.center();
                                closeButton.setFocus(true);
                            }

                            @Override
                            public void onSuccess(final List<PropertyEntry> result) {
                                if (result == null) {
                                    System.out.println("Invalid result set");
                                    return;
                                }
                                System.out.println("onSuccess of Timer Callback Table Property Set");
                                final int start = range.getStart();
                                final int end = start + range.getLength();
                                final List<PropertyEntry> statsList = result;
                                Collections.sort(statsList, new Comparator<PropertyEntry>() {
                                    public int compare(final PropertyEntry o1, final PropertyEntry o2) {
                                        if (o1 == o2) {
                                            return 0;
                                        }
                                        int diff = -1;
                                        if (o1 != null) {
                                            diff = (o2 != null) ? o1.name.compareTo(o2.name) : 1;
                                        }
                                        return sortList.get(0).isAscending() ? diff : -diff;
                                    }
                                });
                                final List<PropertyEntry> dataInRange = statsList.subList(start, end);
                                tableProperty.setRowData(start, dataInRange);
                            }
                        }; // End of Callback // 

                        /**********************************
                         * Stats Service Action
                         **********************************/
                        statsService.statsServer("invalid", "invalid", callbackPropertyChange);
                    } // End of Run method //
                }.schedule(100);
            } // onRange Changed //
        };
        // Connect the list to the data provider.
        dataProviderForPropertyList.addDataDisplay(tableProperty);
        final AsyncHandler columnSortHandler = new AsyncHandler(tableProperty);
        tableProperty.addColumnSortHandler(columnSortHandler);
        // We know that the data is sorted alphabetically by default.
        tableProperty.getColumnSortList().push(nameColumn);
        // Add it to the root panel.
        RootPanel.get("listViewContainer").add(tableProperty);
        /**********************************
         * End of adding property table data
         ***********************************/
    } // End - property table //        
    /****************************************************************
     * Add session lookup  data table
     ****************************************************************/
    {
        final TextColumn<SessionUIInfo> sessionColumn = new TextColumn<SessionUIInfo>() {
            @Override
            public String getValue(final SessionUIInfo info) {
                return info.sessionId;
            }
        };
        sessionColumn.setSortable(true);
        final TextColumn<SessionUIInfo> dateColumn = new TextColumn<SessionUIInfo>() {
            @Override
            public String getValue(final SessionUIInfo info) {
                return info.getJavaDate();
            }
        };
        final TextColumn<SessionUIInfo> filenameColumn = new TextColumn<SessionUIInfo>() {
            @Override
            public String getValue(final SessionUIInfo info) {
                return info.filename;
            }
        };
        // Add the columns.
        tableSessionInfo.addColumn(sessionColumn, "Session");
        tableSessionInfo.addColumn(dateColumn, "Date");
        tableSessionInfo.addColumn(filenameColumn, "LogFilename");
        tableSessionInfo.setRowCount(24, false);
        tableSessionInfo.setVisibleRange(0, 24);
        final AsyncDataProvider<SessionUIInfo> dataProviderForSessionList = new AsyncDataProvider<SessionUIInfo>() {
            @Override
            protected void onRangeChanged(final HasData<SessionUIInfo> display) {
                new Timer() {
                    @Override
                    public void run() {
                        /**********************************
                         * Session Service Action
                         **********************************/
                        final String cmd = nameField.getText();
                        final String sessionIdData = sessionLookupField.getText();
                        final String expr = expressionField.getText();
                        System.out.println("on Range changed, sending request to server");
                        sessionService.sessionServer(cmd, sessionIdData, expr,
                                sessionCallback(tableSessionInfo, display));
                    } // End of Run method //
                }.schedule(100);
            } // onRange Changed //
        };
        dataProviderForSessionList.addDataDisplay(tableSessionInfo);
        final AsyncHandler columnSortHandler = new AsyncHandler(tableSessionInfo);
        tableSessionInfo.addColumnSortHandler(columnSortHandler);
        tableSessionInfo.getColumnSortList().push(sessionColumn);
        // Add it to the root panel.
        RootPanel.get("sessionViewContainer").add(tableSessionInfo);
        tableSessionInfo.setVisible(false);

    } // End of add results table    

}

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

License:Open Source License

/**
 * Shows an error dialog//from  w w  w .  j a va  2 s.  c  o  m
 * 
 * @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);// w  w w . j a v  a2 s .com
    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.dataconservancy.dcs.access.client.upload.Util.java

License:Apache License

public static void popupChooser(final TextBox result, String description, final List<String> list,
        boolean multiple) {
    final DialogBox db = new DialogBox(false, true);

    Panel panel = new FlowPanel();

    db.setAnimationEnabled(true);// w  w w  .j av a2 s .  c  o  m
    db.setText(description);
    db.setWidget(panel);
    db.center();

    final HorizontalPanel buttons = new HorizontalPanel();
    buttons.setSpacing(5);

    Button ok = new Button("Ok");
    Button cancel = new Button("Cancel");

    buttons.add(ok);
    buttons.add(cancel);

    final ListBox lb = new ListBox(multiple);
    lb.setVisibleItemCount(5);

    panel.add(lb);
    panel.add(buttons);

    for (String s : list) {
        lb.addItem(s);
    }

    ok.addClickHandler(new ClickHandler() {

        public void onClick(ClickEvent event) {
            StringBuilder sb = new StringBuilder();

            for (int i = 0; i < list.size(); i++) {
                if (lb.isItemSelected(i)) {
                    if (sb.length() > 0) {
                        sb.append(", ");
                    }

                    sb.append(list.get(i));
                }
            }

            result.setText(sb.toString());
            db.hide();
        }
    });

    cancel.addClickHandler(new ClickHandler() {

        public void onClick(ClickEvent event) {
            db.hide();
        }
    });
}

From source file:org.dataconservancy.dcs.ingest.ui.client.Application.java

License:Apache License

private void displayUploadFileDialog() {
    final DialogBox db = new DialogBox(false, true);

    Panel panel = new FlowPanel();

    db.setAnimationEnabled(true);/*ww  w  .  jav  a  2 s. co m*/
    db.setText("Upload local file");
    db.setWidget(panel);
    db.center();

    final HorizontalPanel buttons = new HorizontalPanel();
    buttons.setSpacing(5);

    Button upload = new Button("Upload");
    Button cancel = new Button("Cancel");

    buttons.add(upload);
    buttons.add(cancel);

    final FormPanel form = new FormPanel();
    FlowPanel formcontents = new FlowPanel();
    form.add(formcontents);

    final FileUpload upfile = new FileUpload();
    upfile.setName("file");

    Hidden depositurl = new Hidden("depositurl");
    depositurl.setValue(depositConfig.fileUploadUrl());

    formcontents.add(upfile);
    formcontents.add(depositurl);

    form.setMethod(FormPanel.METHOD_POST);
    form.setEncoding(FormPanel.ENCODING_MULTIPART);
    form.setAction(FILE_UPLOAD_URL);

    panel.add(new Label("Uploaded files will be included in the SIP."));
    panel.add(form);
    panel.add(buttons);

    upload.addClickHandler(new ClickHandler() {

        public void onClick(ClickEvent event) {
            form.submit();
        }
    });

    cancel.addClickHandler(new ClickHandler() {

        public void onClick(ClickEvent event) {
            db.hide();
        }
    });

    form.addSubmitCompleteHandler(new SubmitCompleteHandler() {

        public void onSubmitComplete(SubmitCompleteEvent event) {
            if (event.getResults() == null) {
                Window.alert("File upload failed");
                db.hide();
                return;
            }

            String[] parts = event.getResults().split("\\^");

            if (parts.length != 4) {
                Window.alert("File upload failed: " + event.getResults());
                db.hide();
                return;
            }

            String filesrc = parts[1].trim();
            // TODO String fileatomurl = parts[2].trim();

            files.setVisible(true);
            String id = nextFileId();
            fileids.add(id);
            files.add(new FileEditor(id, upfile.getFilename(), filesrc), id);
            files.selectTab(files.getWidgetCount() - 1);

            db.hide();
        }
    });
}

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   w ww  .j a  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();
        }
    });
}

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

License:Open Source License

/**
 * Shows an error dialog/*  w  w  w . jav a2 s . co  m*/
 * 
 * @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 = new Button("Close");
    closeButton.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            dialogBox.hide();
        }
    });

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

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

From source file:org.gatein.management.gadget.client.Application.java

License:Open Source License

/**
 * Create and return the dialog box for the site upload.
 *
 * @return a {@code DialogBox}//from   www  .  ja va  2  s  .co m
 */
private DialogBox createDialogBox() {

    // Create a dialog box
    final DialogBox dialogBox = new DialogBox();
    dialogBox.setText("Import site");
    dialogBox.setAnimationEnabled(true);
    dialogBox.setModal(true);
    dialogBox.setGlassEnabled(true);

    final AbsolutePanel absolutePanel = new AbsolutePanel();
    dialogBox.setWidget(absolutePanel);
    absolutePanel.setStyleName("status-panel");
    absolutePanel.setSize("400px", "220px");

    final Button importButton = new Button("Import");
    final CheckBox overwriteBox = new CheckBox("Overwrite the existing site");
    final HTML statusImg = new HTML("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;", true);
    final Label statusLabel = new Label("status label");
    final Label headerLabel = new Label("Select file to import :");
    final AbsolutePanel statusPanel = new AbsolutePanel();
    headerLabel.setSize("380px", "39px");
    headerLabel.setStyleName("header-style");
    absolutePanel.add(headerLabel, 10, 10);

    final MultiUploader uploader = new GTNMultiUploader();
    uploader.setAvoidRepeatFiles(false);
    absolutePanel.add(uploader, 10, 46);
    uploader.setSize("380px", "32px");
    uploader.addOnChangeUploadHandler(new IUploader.OnChangeUploaderHandler() {

        @Override
        public void onChange(IUploader uploader) {
            // Nothing to do
            if (uploader.getFileName() != null) {
                importButton.setEnabled(true);
            }
        }
    });

    // Add a finish handler which will notify user once the upload finishes
    uploader.addOnFinishUploadHandler(new IUploader.OnFinishUploaderHandler() {

        public void onFinish(IUploader uploader) {

            switch (uploader.getStatus()) {
            case SUCCESS:
                statusLabel.setText("File uploaded with success");
                statusLabel.setStyleName("success-style");
                statusImg.setStyleName("success-style-icon");
                break;
            case ERROR:
                statusLabel.setText("File upload error");
                statusLabel.setStyleName("error-style");
                statusImg.setStyleName("error-style-icon");
                break;
            case CANCELED:
                statusLabel.setText("File upload canceled");
                statusLabel.setStyleName("warn-style");
                statusImg.setStyleName("warn-style-icon");
                break;
            default:
                statusLabel.setText("");
                statusLabel.setStyleName("blank-style");
                statusImg.setStyleName("blank-style");
                break;
            }

            overwriteBox.setEnabled(true);
            importButton.setEnabled(true);
        }
    });
    // Add a start handler which will disable the UI until the upload finishes
    uploader.addOnStartUploadHandler(new IUploader.OnStartUploaderHandler() {

        boolean isShwon = false;

        public void onStart(IUploader uploader) {
            statusLabel.setText("Process in progress...");
            statusLabel.setStyleName("progress-style");
            statusImg.setStyleName("progress-style-icon");
            overwriteBox.setEnabled(false);
            importButton.setEnabled(false);
            if (!isShwon) {
                statusPanel.setStyleName("status-panel");
                statusPanel.setSize("380px", "0px");
                absolutePanel.add(statusPanel, 10, 120);

                Timer t = new Timer() {

                    int dx = 5;
                    int height = 0;

                    public void run() {
                        height += dx;
                        statusPanel.setHeight(height + "px");
                        if (height >= 45) {
                            cancel(); // Stop the timer
                        }
                    }
                };

                // Schedule the timer to run once in 100 milliseconds.
                t.scheduleRepeating(100);
                isShwon = true;
            }
        }
    });
    // accept only zip files
    uploader.setValidExtensions(new String[] { "zip" });
    // You can add customized parameters to servlet call
    uploader.setServletPath(UPLOAD_ACTION_URL + "?pc=" + getPortalContainerName());

    overwriteBox.setTitle("If you want to force overwriting an existing site, check this checkbox");
    overwriteBox.addClickHandler(new ClickHandler() {

        public void onClick(ClickEvent event) {
            String url = UPLOAD_ACTION_URL + "?pc=" + getPortalContainerName() + "&overwrite="
                    + overwriteBox.getValue();
            uploader.setServletPath(url);
        }
    });

    absolutePanel.add(overwriteBox, 10, 84);
    Button closeButton = new Button("Close", new ClickHandler() {

        public void onClick(ClickEvent event) {
            dialogBox.hide();
        }
    });
    absolutePanel.add(closeButton, 343, 188);

    statusImg.setStyleName("progress-style-icon");
    statusPanel.add(statusImg, 10, 10);
    statusImg.setSize("50px", "30px");

    statusPanel.add(statusLabel, 60, 15);
    statusLabel.setSize("300px", "25px");

    importButton.addClickHandler(new ClickHandler() {

        @Override
        public void onClick(ClickEvent event) {

            uploader.submit();
        }
    });
    importButton.setEnabled(false);
    absolutePanel.add(importButton, 10, 188);

    return dialogBox;
}

From source file:org.gatein.management.gadget.mop.exportimport.client.Application.java

License:Open Source License

/**
 * Create and return the dialog box for the site upload.
 *
 * @return a {@code DialogBox}//www .  j a  va 2s . c o m
 */
private DialogBox createDialogBox() {

    // Create a dialog box
    final DialogBox dialogBox = new DialogBox();
    dialogBox.setText("Import site");
    dialogBox.setAnimationEnabled(true);
    dialogBox.setModal(true);
    dialogBox.setGlassEnabled(true);

    final AbsolutePanel absolutePanel = new AbsolutePanel();
    dialogBox.setWidget(absolutePanel);
    absolutePanel.setStyleName("status-panel");
    absolutePanel.setSize("400px", "220px");

    final Button importButton = new Button("Import");
    final Label importModeLabel = new Label("Import Mode:");
    final ListBox importModeListBox = new ListBox(false);
    importModeListBox.addItem("Conserve", "conserve");
    importModeListBox.addItem("Insert", "insert");
    importModeListBox.addItem("Merge", "merge");
    importModeListBox.addItem("Overwrite", "overwrite");
    importModeListBox.setSelectedIndex(2); // set default to 'merge'

    final HTML statusImg = new HTML("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;", true);
    final Label statusLabel = new Label("status label");
    final Label headerLabel = new Label("Select file to import :");
    final AbsolutePanel statusPanel = new AbsolutePanel();
    headerLabel.setSize("380px", "39px");
    headerLabel.setStyleName("header-style");
    absolutePanel.add(headerLabel, 10, 10);

    final MultiUploader uploader = new GTNMultiUploader();
    uploader.setAvoidRepeatFiles(false);
    absolutePanel.add(uploader, 10, 46);
    uploader.setSize("380px", "32px");
    uploader.addOnChangeUploadHandler(new IUploader.OnChangeUploaderHandler() {

        @Override
        public void onChange(IUploader uploader) {
            // Nothing to do
            if (uploader.getFileName() != null) {
                importButton.setEnabled(true);
            }
        }
    });

    // Add a finish handler which will notify user once the upload finishes
    uploader.addOnFinishUploadHandler(new IUploader.OnFinishUploaderHandler() {

        public void onFinish(IUploader uploader) {

            switch (uploader.getStatus()) {
            case SUCCESS:
                statusLabel.setText("File uploaded with success");
                statusLabel.setStyleName("success-style");
                statusImg.setStyleName("success-style-icon");
                break;
            case ERROR:
                statusLabel.setText("File upload error");
                statusLabel.setStyleName("error-style");
                statusImg.setStyleName("error-style-icon");
                break;
            case CANCELED:
                statusLabel.setText("File upload canceled");
                statusLabel.setStyleName("warn-style");
                statusImg.setStyleName("warn-style-icon");
                break;
            default:
                statusLabel.setText("");
                statusLabel.setStyleName("blank-style");
                statusImg.setStyleName("blank-style");
                break;
            }

            importModeListBox.setEnabled(true);
            importButton.setEnabled(true);
        }
    });
    // Add a start handler which will disable the UI until the upload finishes
    uploader.addOnStartUploadHandler(new IUploader.OnStartUploaderHandler() {

        boolean isShwon = false;

        public void onStart(IUploader uploader) {
            if (uploader.getStatus() == IUploadStatus.Status.INPROGRESS) {
                statusLabel.setText("Process in progress...");
                statusLabel.setStyleName("progress-style");
                statusImg.setStyleName("progress-style-icon");
                importModeListBox.setEnabled(false);
                importButton.setEnabled(false);
                if (!isShwon) {
                    statusPanel.setStyleName("status-panel");
                    statusPanel.setSize("380px", "0px");
                    absolutePanel.add(statusPanel, 10, 120);

                    Timer t = new Timer() {

                        int dx = 5;
                        int height = 0;

                        public void run() {
                            height += dx;
                            statusPanel.setHeight(height + "px");
                            if (height >= 45) {
                                cancel(); // Stop the timer
                            }
                        }
                    };

                    // Schedule the timer to run once in 100 milliseconds.
                    t.scheduleRepeating(100);
                    isShwon = true;
                }
            }
        }
    });
    // accept only zip files
    uploader.setValidExtensions("zip");
    // You can add customized parameters to servlet call
    uploader.setServletPath(UPLOAD_ACTION_URL + "?pc=" + getPortalContainerName());

    importModeListBox.setTitle("The import mode to use during import.");
    importModeListBox.addChangeHandler(new ChangeHandler() {
        @Override
        public void onChange(ChangeEvent changeEvent) {
            String url = UPLOAD_ACTION_URL + "?pc=" + getPortalContainerName() + "&importMode="
                    + importModeListBox.getValue(importModeListBox.getSelectedIndex());
            uploader.setServletPath(url);
        }
    });

    absolutePanel.add(importModeLabel, 10, 88);
    absolutePanel.add(importModeListBox, 95, 84);
    Button closeButton = new Button("Close", new ClickHandler() {

        public void onClick(ClickEvent event) {
            dialogBox.hide();
        }
    });
    absolutePanel.add(closeButton, 343, 188);

    statusImg.setStyleName("progress-style-icon");
    statusPanel.add(statusImg, 10, 10);
    statusImg.setSize("50px", "30px");

    statusPanel.add(statusLabel, 60, 15);
    statusLabel.setSize("300px", "25px");

    importButton.addClickHandler(new ClickHandler() {

        @Override
        public void onClick(ClickEvent event) {

            uploader.submit();
        }
    });
    importButton.setEnabled(false);
    absolutePanel.add(importButton, 10, 188);

    return dialogBox;
}

From source file:org.geosdi.maplite.client.model.LegendBuilder.java

private static DialogBox getRefreshDialogBox(final ClientRasterInfo raster, final Map map) {
    // Create a dialog box and set the caption text
    final DialogBox refreshDialogBox = new DialogBox();
    refreshDialogBox.ensureDebugId("cwDialogBox");
    refreshDialogBox.setText("REFRESH TIME");

    // Create a table to layout the content
    VerticalPanel dialogContents = new VerticalPanel();
    dialogContents.setSpacing(4);//from w w w.j  av a2 s  . c o m
    refreshDialogBox.setWidget(dialogContents);

    // Add some text to the top of the dialog
    HTML details = new HTML("seconds");
    dialogContents.add(details);
    dialogContents.setCellHorizontalAlignment(details, HasHorizontalAlignment.ALIGN_CENTER);

    final TextBox normalText = new TextBox();
    normalText.ensureDebugId("cwBasicText-textbox");
    // Set the normal text box to automatically adjust its direction according
    // to the input text. Use the Any-RTL heuristic, which sets an RTL direction
    // iff the text contains at least one RTL character.
    normalText.setDirectionEstimator(AnyRtlDirectionEstimator.get());

    dialogContents.add(normalText);
    dialogContents.setCellHorizontalAlignment(normalText, HasHorizontalAlignment.ALIGN_CENTER);

    // Add a close button at the bottom of the dialog
    Button closeButton = new Button("Apply", new ClickHandler() {

        private java.util.Map<ClientRasterInfo, Timer> timerMap = Maps.<ClientRasterInfo, Timer>newHashMap();

        @Override
        public void onClick(ClickEvent event) {
            String value = normalText.getValue();
            try {
                int seconds = Integer.parseInt(value);
                if (seconds != 0 && seconds < 30) {
                    Window.alert("The time must be greater or equal to 30 seconds");
                } else {
                    Layer layer = map.getLayer(raster.getWmsLayerId());

                    final WMS wms = WMS.narrowToLayer(layer.getJSObject());
                    Timer timer = timerMap.get(raster);
                    if (timer == null) {
                        timer = new Timer() {

                            @Override
                            public void run() {
                                logger.info("Repeat scheduling");
                                wms.redraw(true);
                            }
                        };
                        timerMap.put(raster, timer);
                    }
                    if (seconds == 0) {
                        timer.cancel();
                    } else {
                        timer.scheduleRepeating(seconds * 1000);
                    }
                    refreshDialogBox.hide();
                }
            } catch (NumberFormatException nfe) {
                Window.alert("The passed value is not a valid integer number");
            }
        }
    });
    dialogContents.add(closeButton);
    if (LocaleInfo.getCurrentLocale().isRTL()) {
        dialogContents.setCellHorizontalAlignment(closeButton, HasHorizontalAlignment.ALIGN_LEFT);

    } else {
        dialogContents.setCellHorizontalAlignment(closeButton, HasHorizontalAlignment.ALIGN_RIGHT);
    }

    // Return the dialog box
    refreshDialogBox.setGlassEnabled(true);
    refreshDialogBox.setAnimationEnabled(true);
    refreshDialogBox.center();
    return refreshDialogBox;
}