Example usage for com.google.gwt.view.client SingleSelectionModel SingleSelectionModel

List of usage examples for com.google.gwt.view.client SingleSelectionModel SingleSelectionModel

Introduction

In this page you can find the example usage for com.google.gwt.view.client SingleSelectionModel SingleSelectionModel.

Prototype

public SingleSelectionModel() 

Source Link

Document

Constructs a SingleSelectionModel without a key provider.

Usage

From source file:org.eclipse.che.ide.macro.chooser.MacroChooserViewImpl.java

License:Open Source License

private void initMacrosTable(org.eclipse.che.ide.Resources resources) {
    macrosTable = new CellTable<>(500, resources);

    final Column<Macro, String> nameColumn = new Column<Macro, String>(new TextCell()) {
        @Override//from w ww.j a  v a  2 s  . c om
        public String getValue(Macro remote) {
            return remote.getName();
        }
    };

    final Column<Macro, String> descriptionColumn = new Column<Macro, String>(new TextCell()) {
        @Override
        public String getValue(Macro remote) {
            return remote.getDescription();
        }
    };

    macrosTable.addColumn(nameColumn, "Macro");
    macrosTable.setColumnWidth(nameColumn, "40%");
    macrosTable.addColumn(descriptionColumn, "Description");
    macrosTable.setColumnWidth(descriptionColumn, "60%");

    final SingleSelectionModel<Macro> selectionModel = new SingleSelectionModel<>();

    macrosTable.setSelectionModel(selectionModel);

    macrosTable.addDomHandler(event -> {
        if (selectionModel.getSelectedObject() != null) {
            delegate.onMacroChosen(selectionModel.getSelectedObject());
        }
    }, DoubleClickEvent.getType());

    macrosTable.addDomHandler(event -> {
        if (selectionModel.getSelectedObject() != null && (KeyCodes.KEY_ENTER == event.getNativeKeyCode()
                || KeyCodes.KEY_MAC_ENTER == event.getNativeKeyCode())) {

            delegate.onMacroChosen(selectionModel.getSelectedObject());
        }
    }, KeyUpEvent.getType());
}

From source file:org.eclipse.che.ide.preferences.pages.extensions.ExtensionManagerViewImpl.java

License:Open Source License

@Inject
public ExtensionManagerViewImpl(ToolbarPresenter toolbarPresenter, ActionManager actionManager,
        Resources resources) {//from   w w  w  .  j  a v a 2s  .  c  om
    dataGrid = new DataGrid<>(100, resources);
    rootElement = ourUiBinder.createAndBindUi(this);
    DefaultActionGroup actionGroup = new DefaultActionGroup("extensionManager", false, actionManager);
    actionManager.registerAction("extensionManagerGroup", actionGroup);
    toolbarPresenter.bindMainGroup(actionGroup);
    UIObject.ensureDebugId(descriptionArea, "window-preferences-extensions-descriptionArea");

    Column<ExtensionDescription, String> titleColumn = new Column<ExtensionDescription, String>(
            new TextCell()) {
        @Override
        public String getValue(ExtensionDescription object) {
            return object.getTitle();
        }
    };
    titleColumn.setCellStyleNames(style.titleColumn());

    dataGrid.addColumn(titleColumn);
    SingleSelectionModel<ExtensionDescription> selectionModel = new SingleSelectionModel<ExtensionDescription>();
    dataGrid.setSelectionModel(selectionModel);
    selectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        @Override
        public void onSelectionChange(SelectionChangeEvent event) {
        }
    });
}

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

License:Open Source License

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

    final BasicCommandStack commandStack = new BasicCommandStack();
    final AdapterFactoryEditingDomain editingDomain = new AdapterFactoryEditingDomain(composedAdapterFactory,
            commandStack);/* w w  w.ja v  a  2s.  com*/

    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.eclipse.emf.eef.runtime.ui.gwt.editor.widget.EEFTreeViewerContentProvider.java

License:Open Source License

public <T> EEFTreeViewerContentProvider(EEFEditor editor) {
    this.treeSelection = new SingleSelectionModel<Object>();
    this.editor = editor;
}

From source file:org.eobjects.datacleaner.monitor.scheduling.widgets.JobHistoryPanel.java

License:Open Source License

public JobHistoryPanel(JobIdentifier job, SchedulingServiceAsync service, TenantIdentifier tenant) {
    super();/*from  ww w .j  av a2  s  . c o  m*/
    _job = job;
    _service = service;
    _tenant = tenant;

    _callback = new DCAsyncCallback<ExecutionLog>() {
        @Override
        public void onSuccess(ExecutionLog result) {
            executionLogPanelTarget.setWidget(new ExecutionLogPanel(_service, _tenant, result, true));
        }
    };

    executionLogPanelTarget = new SimplePanel();
    executionLogPanelTarget.setStyleName("ExecutionLogPanelTarget");
    executionList = new CellList<ExecutionIdentifier>(new ExecutionIdentifierCell());
    executionList.setEmptyListWidget(new Label("(none)"));

    final SingleSelectionModel<ExecutionIdentifier> selectionModel = new SingleSelectionModel<ExecutionIdentifier>();
    selectionModel.addSelectionChangeHandler(new Handler() {
        @Override
        public void onSelectionChange(SelectionChangeEvent event) {
            final ExecutionIdentifier executionIdentifier = selectionModel.getSelectedObject();
            if (executionIdentifier != null) {
                _service.getExecution(_tenant, executionIdentifier, _callback);
            }
        }
    });
    executionList.setSelectionModel(selectionModel);

    executionList.setPixelSize(200, 400);
    executionList.addStyleName("ExecutionCellList");

    initWidget(uiBinder.createAndBindUi(this));

    _callback.onSuccess(null);
    _service.getAllExecutions(_tenant, _job, new DCAsyncCallback<List<ExecutionIdentifier>>() {
        @Override
        public void onSuccess(List<ExecutionIdentifier> executions) {
            executionList.setRowData(executions);

            if (!executions.isEmpty()) {
                // build a map of active executions, to be polled for
                // updates
                final Map<Integer, ExecutionIdentifier> activeExecutions = new HashMap<Integer, ExecutionIdentifier>();
                for (int i = 0; i < executions.size(); i++) {
                    final ExecutionIdentifier execution = executions.get(i);
                    if (!execution.isFinished()) {
                        // add as active execution
                        activeExecutions.put(i, execution);
                    }
                }

                // Select the last execution by default
                ExecutionIdentifier selected = executions.get(executions.size() - 1);
                if (!activeExecutions.isEmpty()) {
                    // Select the last one that is running
                    for (ExecutionIdentifier execution : executions) {
                        if (execution.getExecutionStatus() == ExecutionStatus.RUNNING) {
                            selected = execution;
                        }
                    }
                }
                executionList.getSelectionModel().setSelected(selected, true);

                // Start polling for updates
                final Set<Entry<Integer, ExecutionIdentifier>> activeExecutionEntries = activeExecutions
                        .entrySet();
                for (Entry<Integer, ExecutionIdentifier> entry : activeExecutionEntries) {
                    final int index = entry.getKey().intValue();
                    final ExecutionIdentifier execution = entry.getValue();
                    final Callback callback = new Callback() {
                        @Override
                        public void updateExecutionLog(ExecutionLog executionLog) {
                            if (executionLog == null) {
                                return;
                            }
                            final List<ExecutionIdentifier> list = new ArrayList<ExecutionIdentifier>(1);
                            list.add(executionLog);
                            executionList.setRowData(index, list);
                        }
                    };
                    ExecutionLogPoller poller = new ExecutionLogPoller(_service, _tenant, callback);
                    poller.schedulePoll(execution);
                }
            }
        }
    });

}

From source file:org.fourthline.konto.client.currency.view.CurrencyViewImpl.java

License:Open Source License

@Inject
public CurrencyViewImpl(Bundle bundle, MonetaryUnitView unitView, CurrencyPairView currencyPairView) {
    this.bundle = bundle;

    CellTable.Resources cellTableResource = bundle.themeBundle().create().cellTableResources().create();
    this.monetaryUnitCellTable = new MonetaryUnitCellTable(cellTableResource);
    this.currencyPairCellTable = new CurrencyPairCellTable(cellTableResource);

    initWidget(ui.createAndBindUi(this));

    monetaryUnitCellTable.applyStyle(monetaryUnitStyle);
    currencyPairCellTable.applyStyle(currencyPairStyle);

    unitSelectionModel = new SingleSelectionModel();
    unitSelectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        @Override/* ww  w  .  j  a v  a  2  s  .  c om*/
        public void onSelectionChange(SelectionChangeEvent event) {
            MonetaryUnit selected;
            if ((selected = unitSelectionModel.getSelectedObject()) != null && presenter != null) {
                presenter.monetaryUnitSelected(selected);
            }
        }
    });
    monetaryUnitCellTable.setSelectionModel(unitSelectionModel);

    pairSelectionModel = new SingleSelectionModel();
    pairSelectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        @Override
        public void onSelectionChange(SelectionChangeEvent event) {
            CurrencyPair selected;
            if ((selected = pairSelectionModel.getSelectedObject()) != null && presenter != null) {
                presenter.currencyPairSelected(selected);
            }
        }
    });
    currencyPairCellTable.setSelectionModel(pairSelectionModel);

    this.unitView.setWidget(unitView);
    this.currencyPairView.setWidget(currencyPairView);

    exchangeUnitListBox.addChangeHandler(new ChangeHandler() {
        @Override
        public void onChange(ChangeEvent event) {
            presenter.exchangeMonetaryUnitSelected(exchangeUnitListBox.getSelectedIndex());
        }
    });

}

From source file:org.fourthline.konto.client.ledger.view.LedgerLineTable.java

License:Open Source License

public LedgerLineTable(CellTable.Resources cellTableResources, final Style style) {
    super(Integer.MAX_VALUE, cellTableResources);

    // This steals the focus from the entry form if enabled
    setKeyboardSelectionPolicy(HasKeyboardSelectionPolicy.KeyboardSelectionPolicy.DISABLED);

    selectionModel = new SingleSelectionModel<LedgerLine>();
    selectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        public void onSelectionChange(SelectionChangeEvent event) {
            LedgerLine selected = selectionModel.getSelectedObject();
            if (selected != null) {
                onSelection(selected);//  w w  w.ja va2s . c om
            }
        }
    });

    // TODO Hack until this is available http://code.google.com/p/google-web-toolkit/source/detail?r=9788#
    setSelectionModel(selectionModel, new DefaultSelectionEventManager(new BlacklistEventTranslator(2)) {
    });

    dateColumn.setVerticalAlignment(HasVerticalAlignment.ALIGN_TOP);

    TextColumn<LedgerLine> descriptionColumn = new TextColumn<LedgerLine>() {
        @Override
        public String getValue(LedgerLine object) {
            return object.getDescription();
        }
    };
    descriptionColumn.setVerticalAlignment(HasVerticalAlignment.ALIGN_TOP);

    Column<LedgerLine, String> accountColumn = new ClickableTextColumn<LedgerLine>(style.accountCell()) {

        @Override
        protected boolean isStyled(LedgerLine object) {
            return object.getFromToAccount() != null;
        }

        @Override
        public String getValue(LedgerLine object) {
            if (!object.getDescription().toLowerCase().contains(getCurrentDescriptionFilter().toLowerCase())) {
                return "Split(s) match '" + getCurrentDescriptionFilter() + "'";
            } else {
                if (object.getFromToAccount() == null) {
                    return ((Entry) object.getLedgerEntry()).getSplits().size() + " Splits";
                } else {
                    return object.getFromToAccount().getLabel(true, true, true, false);
                }
            }
        }

        @Override
        protected void onClick(int index, LedgerLine object, String value) {
            if (object.getFromToAccount() != null) {
                onSelection(object.getFromToAccount());
            }
        }
    };
    accountColumn.setVerticalAlignment(HasVerticalAlignment.ALIGN_TOP);

    TextColumn<LedgerLine> debitColumn = new TextColumn<LedgerLine>() {
        @Override
        public String getValue(LedgerLine object) {
            return object.getDebit().getReportString(false, false, true);
        }
    };
    debitColumn.setVerticalAlignment(HasVerticalAlignment.ALIGN_TOP);
    debitColumn.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);

    TextColumn<LedgerLine> creditColumn = new TextColumn<LedgerLine>() {
        @Override
        public String getValue(LedgerLine object) {
            return object.getCredit().getReportString(false, false, true);
        }
    };
    creditColumn.setVerticalAlignment(HasVerticalAlignment.ALIGN_TOP);
    creditColumn.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);

    TextColumn<LedgerLine> balanceColumn = new TextColumn<LedgerLine>() {

        @Override
        public void render(Cell.Context context, LedgerLine object, SafeHtmlBuilder sb) {
            if (getCurrentDescriptionFilter().length() > 0) {
                sb.appendHtmlConstant("<span class=\"" + style.filteredBalance() + "\">");
                super.render(context, object, sb);
                sb.appendHtmlConstant("</span>");
            } else {
                super.render(context, object, sb);
            }
        }

        @Override
        public String getValue(LedgerLine object) {
            return object.getBalanceString();
        }
    };
    balanceColumn.setVerticalAlignment(HasVerticalAlignment.ALIGN_TOP);
    balanceColumn.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);

    addColumn(dateColumn, new TextHeader("Date"));
    addColumnStyleName(0, style.dateColumn());
    addColumn(descriptionColumn, new TextHeader("Description"));
    addColumnStyleName(1, style.descriptionColumn());
    addColumn(accountColumn, new TextHeader("From/To"));
    addColumnStyleName(2, style.accountColumn());

    // TODO: This celltable API and behavior is evil
    addColumn(debitColumn, new Header<String>(new TextCell() {
        @Override
        public void render(Context context, SafeHtml value, SafeHtmlBuilder sb) {
            sb.appendHtmlConstant("<div align=\"right\">");
            super.render(context, value, sb);
            sb.appendHtmlConstant("</div>");
        }
    }) {

        @Override
        public String getValue() {
            return getDebitLabel();
        }

        @Override
        public void render(Cell.Context context, SafeHtmlBuilder sb) {
            super.render(context, sb);
        }
    });
    addColumnStyleName(3, style.amountColumn());
    addColumnStyleName(3, style.amountColumn());
    addColumn(creditColumn, new Header<String>(new TextCell() {
        @Override
        public void render(Context context, SafeHtml value, SafeHtmlBuilder sb) {
            sb.appendHtmlConstant("<div align=\"right\">");
            super.render(context, value, sb);
            sb.appendHtmlConstant("</div>");
        }
    }) {

        @Override
        public String getValue() {
            return getCreditLabel();
        }
    });
    addColumnStyleName(4, style.amountColumn());
    addColumn(balanceColumn, new Header<String>(new TextCell() {
        @Override
        public void render(Context context, SafeHtml value, SafeHtmlBuilder sb) {
            sb.appendHtmlConstant("<div align=\"right\">");
            super.render(context, value, sb);
            sb.appendHtmlConstant("</div>");
        }
    }) {
        @Override
        public String getValue() {
            return "Balance";
        }
    });
    addColumnStyleName(5, style.amountColumn());

    setRowStyles(new RowStyles<LedgerLine>() {
        @Override
        public String getStyleNames(LedgerLine row, int rowIndex) {
            return !getSelectionModel().isSelected(row) && row.isDateInFuture() ? style.rowInFuture() : null;
        }
    });
}

From source file:org.gwt.dynamic.host.client.main.MainLayout.java

License:MIT License

public MainLayout() {
    initWidget(uiBinder.createAndBindUi(this));
    dataProvider = new ListDataProvider<ModuleInfo>();
    dataProvider.addDataDisplay(cellList);
    final SingleSelectionModel<ModuleInfo> selectionModel = new SingleSelectionModel<ModuleInfo>();
    cellList.setSelectionModel(selectionModel);
    selectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        @Override/*  w  ww  .ja va2  s  .  co m*/
        public void onSelectionChange(SelectionChangeEvent event) {
            final ModuleInfo moduleInfo = selectionModel.getSelectedObject();
            LOG.info("MainLayout.cellList.selectionModel#onSelectionChange: moduleInfo="
                    + toStringJSO(moduleInfo));
            if (moduleInfo != null) {
                centerPanel.setCaptionText(moduleInfo.getCaption());

                HTML panel = null;
                String id = "content" + moduleInfo.getName();
                for (int i = 0, l = slidePanel.getWidgetCount(); i < l; ++i) {
                    Widget w = slidePanel.getWidget(i);
                    if (id.equals(w.getElement().getId())) {
                        panel = (HTML) w;
                        break;
                    }
                }
                if (panel == null) {
                    LOG.warning(
                            "MainLayout.cellList.selectionModel#onSelectionChange: cannot find element with ID "
                                    + id);
                    return;
                }
                final Widget showWidget = panel;
                moduleContentFeatureConsumer.call(moduleInfo.getName(), panel.getElement(),
                        new AsyncCallback<Void>() {

                            @Override
                            public void onSuccess(Void result) {
                                LOG.info("MainLayout.moduleContentFeatureConsumer#onSuccess: moduleBean.name="
                                        + moduleInfo.getName());
                                slidePanel.showWidget(showWidget);
                            }

                            @Override
                            public void onFailure(Throwable caught) {
                                LOG.severe("MainLayout.moduleContentFeatureConsumer#onFailure: "
                                        + caught.getMessage());
                                slidePanel.showWidget(showWidget);
                            }
                        });
            }
        }
    });
    LOG.info("MainLayout: instantiated");
}

From source file:org.hudsonci.maven.plugin.ui.gwt.configure.documents.internal.DocumentMasterPresenterImpl.java

License:Open Source License

@Inject
public DocumentMasterPresenterImpl(final DocumentMasterView view, final EventBus eventBus,
        final Scheduler scheduler, final DocumentManagerLiaison documentManagerLiaison,
        final DocumentDetailPresenter documentDetailPresenter,
        final ConfirmDialogPresenter confirmDialogPresenter, final MessagesResource messages) {
    this.view = checkNotNull(view);
    this.eventBus = checkNotNull(eventBus);
    this.documentManagerLiaison = checkNotNull(documentManagerLiaison);
    this.documentDetailPresenter = checkNotNull(documentDetailPresenter);
    this.confirmDialogPresenter = checkNotNull(confirmDialogPresenter);
    this.messages = checkNotNull(messages);

    view.setPresenter(this);

    // Hook up data provider
    HasData<Document> documentDataContainer = view.getDocumentDataContainer();
    selectionModel = new SingleSelectionModel<Document>();
    selectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        public void onSelectionChange(final SelectionChangeEvent event) {
            Document document = selectionModel.getSelectedObject();
            fireDocumentSelected(document);
            view.setDocumentSelected(true);
        }//from   ww  w.j  av a2 s  . c om
    });
    documentDataContainer.setSelectionModel(selectionModel);
    documentManagerLiaison.getDataProvider().addDataDisplay(documentDataContainer);

    // Attach the detail view, handle events
    view.setDocumentDetailView(documentDetailPresenter.getView());
    eventBus.addHandler(DocumentSelectedEvent.TYPE, documentDetailPresenter);
    eventBus.addHandler(DocumentAddedEvent.TYPE, documentDetailPresenter);
    eventBus.addHandler(DocumentUpdatedEvent.TYPE, documentDetailPresenter);

    // Fetch the initial data
    scheduler.scheduleDeferred(new ScheduledCommand() {
        public void execute() {
            documentManagerLiaison.fetchAll();
        }
    });
}

From source file:org.idwebmail.client.grids.DataGrid.java

public DataGrid() {

    this.setWidth("100%", true);
    this.setKeyboardSelectionPolicy(KeyboardSelectionPolicy.ENABLED);
    this.setPageSize(4);

    // Add a text column to show the name.
    TextColumn<EmailStruct> nameColumn = new TextColumn<EmailStruct>() {
        @Override/*from   w w w. jav a2 s .  c o  m*/
        public String getValue(EmailStruct object) {
            return object.asunto;
        }
    };
    this.addColumn(nameColumn, "Asunto");

    // Add a date column to show the birthday.
    DateCell dateCell = new DateCell();
    Column<EmailStruct, Date> dateColumn = new Column<EmailStruct, Date>(dateCell) {
        @Override
        public Date getValue(EmailStruct object) {
            return object.fecha;
        }
    };
    this.addColumn(dateColumn, "Fecha");

    // Add a text column to show the address.
    TextColumn<EmailStruct> addressColumn = new TextColumn<EmailStruct>() {
        @Override
        public String getValue(EmailStruct object) {
            return object.remitente;
        }
    };
    this.addColumn(addressColumn, "Remitente");

    // Add a selection model to handle user selection.
    final SingleSelectionModel<EmailStruct> selectionModel = new SingleSelectionModel<EmailStruct>();
    this.setSelectionModel(selectionModel);

    selectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
        @Override
        public void onSelectionChange(SelectionChangeEvent event) {
            EmailStruct selected = selectionModel.getSelectedObject();
            selectedBody = selected.body;

            subject = selected.headAsunto;
            from = selected.headRemitente;
            to = selected.headDestinatario;
            date = selected.headfecha;
            tamanio = selected.headSise;
            onRowSelected();
        }
    });
    this.setStyleName("innodite-grid");
}