Example usage for com.google.gwt.user.client.ui Widget setWidth

Introduction

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

Prototype

public void setWidth(String width) 

Source Link

Document

Sets the object's width.

Usage

From source file:org.drools.guvnor.client.modeldriven.ui.FromCompositeFactPatternWidget.java

License:Apache License

protected Widget addRemoveButton(Widget w, ClickHandler listener) {
    DirtyableHorizontalPane horiz = new DirtyableHorizontalPane();

    final Image remove = new ImageButton(images.deleteItemSmall());
    remove.setTitle(constants.RemoveThisBlockOfData());
    remove.addClickHandler(listener);//from w  w  w. j a va2s  .  c o m

    horiz.setWidth("100%");
    w.setWidth("100%");

    horiz.add(w);
    if (!this.readOnly) {
        horiz.add(remove);
    }
    return horiz;
}

---

From source file:org.drools.guvnor.client.modeldriven.ui.RuleModeller.java

License:Apache License

/**
 * Do all the widgets for the RHS./*from   w w w .j  a v  a2s.  c o m*/
 */
/*
 * TODO STILL NEED TO BE CHECKED
 */
private Widget renderRhs(final RuleModel model) {
    DirtyableVerticalPane vert = new DirtyableVerticalPane();

    for (int i = 0; i < model.rhs.length; i++) {
        IAction action = model.rhs[i];

        Widget w = null;
        if (action instanceof ActionCallMethod) {
            w = new ActionCallMethodWidget(this, (ActionCallMethod) action, completions);
        } else if (action instanceof ActionSetField) {
            w = new ActionSetFieldWidget(this, (ActionSetField) action, completions);
        } else if (action instanceof ActionInsertFact) {
            w = new ActionInsertFactWidget(this, (ActionInsertFact) action, completions);
        } else if (action instanceof ActionRetractFact) {
            w = new ActionRetractFactWidget(this.completions, (ActionRetractFact) action);
        } else if (action instanceof DSLSentence) {
            w = new DSLSentenceWidget((DSLSentence) action, this.completions);
            w.setStyleName("model-builderInner-Background");
        } else if (action instanceof FreeFormLine) {
            final TextBox tb = new TextBox();
            final FreeFormLine ffl = (FreeFormLine) action;
            tb.setText(ffl.text);
            tb.addChangeListener(new ChangeListener() {
                public void onChange(Widget arg0) {
                    ffl.text = tb.getText();
                }
            });
            w = tb;
        }

        //w.setWidth( "100%" );
        vert.add(spacerWidget());
        //vert.setWidth( "100%" );

        DirtyableHorizontalPane horiz = new DirtyableHorizontalPane();

        Image remove = new ImageButton("images/delete_item_small.gif");
        remove.setTitle("Remove this action.");
        final int idx = i;
        remove.addClickListener(new ClickListener() {
            public void onClick(Widget w) {
                if (Window.confirm("Remove this item?")) {
                    model.removeRhsItem(idx);
                    refreshWidget();
                }
            }
        });
        horiz.add(w);
        if (!(w instanceof ActionRetractFactWidget)) {
            w.setWidth("100%");
            horiz.setWidth("100%");
        }

        horiz.add(remove);
        vert.add(horiz);

    }

    return vert;
}

---

From source file:org.drools.guvnor.client.modeldriven.ui.RuleModeller.java

License:Apache License

/**
 * This adds the widget to the UI, also adding the remove icon.
 *///from  ww w  .  j a v a  2s  .c o  m
private Widget wrapLHSWidget(final RuleModel model, int i, Widget w) {
    DirtyableHorizontalPane horiz = new DirtyableHorizontalPane();

    Image remove = new ImageButton("images/delete_item_small.gif");
    remove.setTitle("Remove this ENTIRE condition, and all the field constraints that belong to it.");
    final int idx = i;
    remove.addClickListener(new ClickListener() {
        public void onClick(Widget w) {
            if (Window.confirm("Remove this entire condition?")) {
                if (model.removeLhsItem(idx)) {
                    refreshWidget();
                } else {
                    ErrorPopup.showMessage(
                            "Can't remove that item as it is used in the action part of the rule.");
                }
            }
        }
    });

    horiz.setWidth("100%");
    w.setWidth("100%");

    horiz.add(w);
    horiz.add(remove);

    return horiz;
}

---

From source file:org.drools.workbench.screens.guided.rule.client.widget.FromCompositeFactPatternWidget.java

License:Apache License

protected Widget addRemoveButton(Widget w, ClickHandler listener) {
    DirtyableHorizontalPane horiz = new DirtyableHorizontalPane();

    final Image remove = GuidedRuleEditorImages508.INSTANCE.DeleteItemSmall();
    remove.setAltText(GuidedRuleEditorResources.CONSTANTS.RemoveThisBlockOfData());
    remove.setTitle(GuidedRuleEditorResources.CONSTANTS.RemoveThisBlockOfData());
    remove.addClickHandler(listener);/*ww w  .  j  a  v a2 s. co  m*/

    horiz.setWidth("100%");
    w.setWidth("100%");

    horiz.add(w);
    if (!this.readOnly) {
        horiz.add(remove);
    }
    return horiz;
}

---

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  av  a2s.co m*/

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

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

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

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

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

    registerPackages(resourceSet.getPackageRegistry());

    final AdapterFactoryItemDelegator itemDelegator = new AdapterFactoryItemDelegator(composedAdapterFactory);

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

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

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

    headerPanel.add(header);

    mainPanel.addNorth(headerPanel, 56.0);

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

    mainPanel.add(bodyPanel);

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

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

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

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

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

    propertiesTitlePanel.add(title);

    propertiesPanel.addNorth(propertiesTitlePanel, 28.0);

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

    propertiesPanel.add(propertiesScrollPanel);

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

    toolBar.add(createButton);

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

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

    toolBar.add(deleteButton);

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

    toolBar.add(validateButton);

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

    toolBar.add(saveButton);

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

    toolBar.add(undoButton);

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

    toolBar.add(redoButton);

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

    toolBar.add(cutButton);

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

    toolBar.add(copyButton);

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

    toolBar.add(pasteButton);

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

    toolBar.add(upButton);

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

    toolBar.add(downButton);

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

    toolBar.add(navigateButton);

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

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

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

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

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

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

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

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

                protected NodeAdapter nodeAdapter = new NodeAdapter();

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

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

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

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

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

    class NavigationListener {
        Object selection;

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

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

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

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

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

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

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

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

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

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

                oldSelection = object;

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

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

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

                            }
                        }
                    }
                }
            }
        }
    });

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

---

From source file:org.eclipse.emf.eef.runtime.ui.gwt.editor.part.EEFPropertiesPanel.java

License:Open Source License

public void updateProperties(final Object newSelection) {
    if (oldSelection == newSelection) {
        for (Runnable runnable : propertyUpdater) {
            runnable.run();/*from w  ww .ja v a2s .  c  o m*/
        }
    } else {
        editor.getNavigationManager().setSelection(null);

        oldSelection = newSelection;

        List<IItemPropertyDescriptor> propertyDescriptors = editor.getItemDelegator()
                .getPropertyDescriptors(newSelection);
        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(newSelection));
                Widget widget = null;
                final IItemLabelProvider itemLabelProvider = propertyDescriptor.getLabelProvider(newSelection);
                final Object feature = propertyDescriptor.getFeature(newSelection);
                if (feature instanceof EReference[]) {
                    final ItemPropertyDescriptorFeatureEditor dialog = new ItemPropertyDescriptorFeatureEditor(
                            newSelection, true, propertyDescriptor) {
                        @Override
                        protected void hook(ListBox listBox, List<?> values) {
                            editor.getNavigationManager().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(newSelection);
                    if (choiceOfValues != null) {
                        final List<?> listOfValues = new ArrayList<Object>(
                                propertyDescriptor.getChoiceOfValues(newSelection));
                        if (propertyDescriptor.isMany(newSelection)) {
                            boolean valid = true;
                            for (Object choice : choiceOfValues) {
                                if (!eType.isInstance(choice)) {
                                    valid = false;
                                    break;
                                }
                            }

                            if (valid) {
                                final ItemPropertyDescriptorFeatureEditor dialog = new ItemPropertyDescriptorFeatureEditor(
                                        newSelection, true, propertyDescriptor) {
                                    @Override
                                    protected void hook(ListBox listBox, List<?> values) {
                                        editor.getNavigationManager().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();
                                    editor.getNavigationManager().listenTo(listBox, listOfValues);
                                    Object propertyValue = editor.getItemDelegator().getEditableValue(
                                            propertyDescriptor.getPropertyValue(newSelection));
                                    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(newSelection, value);
                                }
                            });
                            runnable.run();
                            propertyUpdater.add(runnable);
                        }
                    } else if (eType instanceof EDataType) {
                        final EDataType eDataType = (EDataType) eType;
                        if (eDataType.isSerializable()) {
                            if (propertyDescriptor.isMany(newSelection)) {
                                final ItemPropertyDescriptorFeatureEditor dialog = new ItemPropertyDescriptorFeatureEditor(
                                        newSelection, propertyDescriptor) {
                                    @Override
                                    protected void hook(ListBox listBox, List<?> values) {
                                        editor.getNavigationManager().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 = editor.getItemDelegator().getEditableValue(
                                                    propertyDescriptor.getPropertyValue(newSelection));
                                            dateBox.setValue((Date) propertyValue);
                                        }
                                    };
                                    dateBox.addValueChangeHandler(new ValueChangeHandler<Date>() {
                                        public void onValueChange(ValueChangeEvent<Date> event) {
                                            propertyDescriptor.setPropertyValue(newSelection, 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 = editor.getItemDelegator().getEditableValue(
                                                    propertyDescriptor.getPropertyValue(newSelection));
                                            checkBox.setValue(Boolean.TRUE.equals(propertyValue));
                                        }
                                    };
                                    checkBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
                                        public void onValueChange(ValueChangeEvent<Boolean> event) {
                                            propertyDescriptor.setPropertyValue(newSelection, event.getValue());
                                        }
                                    });
                                    runnable.run();
                                    propertyUpdater.add(runnable);
                                } else if (propertyDescriptor.isMultiLine(newSelection)) {
                                    final TextArea textArea = new TextArea();
                                    widget = textArea;
                                    Runnable runnable = new Runnable() {
                                        public void run() {
                                            Object propertyValue = editor.getItemDelegator().getEditableValue(
                                                    propertyDescriptor.getPropertyValue(newSelection));
                                            textArea.setText(
                                                    EcoreUtil.convertToString(eDataType, propertyValue));
                                        }
                                    };
                                    textArea.addValueChangeHandler(new ValueChangeHandler<String>() {
                                        public void onValueChange(ValueChangeEvent<String> event) {
                                            propertyDescriptor.setPropertyValue(newSelection,
                                                    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(newSelection,
                                                    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 = editor.getItemDelegator().getEditableValue(
                                                    propertyDescriptor.getPropertyValue(newSelection));
                                            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(newSelection, value);
                        }
                    });
                    Runnable runnable = new Runnable() {
                        public void run() {
                            Object propertyValue = editor.getItemDelegator()
                                    .getEditableValue(propertyDescriptor.getPropertyValue(newSelection));
                            String stringValue = propertyValue == null ? null
                                    : propertyDescriptor.getLabelProvider(newSelection).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(newSelection) && widget instanceof FocusWidget) {
                        ((FocusWidget) widget).setEnabled(false);

                    }
                }
            }
        }
    }
}

---

From source file:org.eclipse.swt.widgets.Control.java

License:Open Source License

int setBounds(int x, int y, int width, int height, boolean move, boolean resize) {
    com.google.gwt.user.client.ui.Widget gwtWidget = getGwtWidget();
    gwtWidget.setHeight(height + "px");
    gwtWidget.setWidth(width + "px");
    redrawWidget(0, 0, 0, 0, true, true, true);
    return 0;/* w  w w.j a  v a 2  s . c  o m*/
}

---

From source file:org.gwtbootstrap3.extras.gallery.client.ui.Gallery.java

License:Apache License

@Override
public void add(final Widget child) {
    if (child instanceof GalleryImage) {
        ((GalleryImage) child).addLoadHandler(new LoadHandler() {
            @Override// w w w . ja  v a2 s . co  m
            public void onLoad(LoadEvent event) {
                if (thumbnailWidth != null) {
                    child.setWidth(thumbnailWidth);
                }
                if (thumbnailHeight != null) {
                    child.setHeight(thumbnailHeight);
                }
            }
        });

        super.add(child);
    } else {
        throw new IllegalArgumentException("Gallery can only contain GalleryImage's.");
    }
}

---

From source file:org.iplantc.de.pipelineBuilder.client.Window.java

License:Apache License

public Window(String title, Widget content) {
    this.title = new Label(title);
    this.title.setWordWrap(false);
    bar = new HorizontalPanel();
    bar.setWidth("100%");
    bar.setStyleName("window-bar");
    modalMask.setStyleName("modal-mask");
    VerticalPanel master = new VerticalPanel();
    outside = new FlowPanel() {
        @Override/*  w  w w  .j av  a2 s . co m*/
        protected void onLoad() {
            getElement().getStyle().setLeft(
                    (com.google.gwt.user.client.Window.getClientWidth() / 2) - (getOffsetWidth() / 2), Unit.PX);
            getElement().getStyle().setTop(
                    (com.google.gwt.user.client.Window.getClientHeight() / 2) - (getOffsetHeight() / 2),
                    Unit.PX);
            super.onLoad();
        }
    };
    com.google.gwt.user.client.Window.addResizeHandler(new ResizeHandler() {
        public void onResize(ResizeEvent event) {
            outside.getElement().getStyle().setLeft(
                    (com.google.gwt.user.client.Window.getClientWidth() / 2) - (outside.getOffsetWidth() / 2),
                    Unit.PX);
            outside.getElement().getStyle().setTop(
                    (com.google.gwt.user.client.Window.getClientHeight() / 2) - (outside.getOffsetHeight() / 2),
                    Unit.PX);
        }
    });
    outside.setStyleName("eta-window");
    HorizontalPanel header = new HorizontalPanel();
    this.title.addMouseDownHandler(new MouseDownHandler() {

        @Override
        public void onMouseDown(MouseDownEvent event) {
            isDraging = true;
            x_start = event.getX();
            y_start = event.getY();
        }
    });

    moveHandler = new MouseMoveHandler() {
        @Override
        public void onMouseMove(MouseMoveEvent event) {
            if (!isDraging)
                return;
            int left = event.getClientX() - x_start;
            int top = event.getClientY() - y_start;
            if (left > 0
                    && left + outside.getOffsetWidth() < com.google.gwt.user.client.Window.getClientWidth())
                outside.getElement().getStyle().setLeft(left - 16, Unit.PX);
            if (top > 0
                    && top + outside.getOffsetHeight() < com.google.gwt.user.client.Window.getClientHeight())
                outside.getElement().getStyle().setTop(top - 16, Unit.PX);
        }
    };
    modalMask.addMouseMoveHandler(moveHandler);
    this.title.addMouseMoveHandler(moveHandler);
    outside.addDomHandler(moveHandler, MouseMoveEvent.getType());
    master.addDomHandler(moveHandler, MouseMoveEvent.getType());

    this.title.addMouseUpHandler(new MouseUpHandler() {
        @Override
        public void onMouseUp(MouseUpEvent event) {
            isDraging = false;
        }
    });
    this.title.getElement().getStyle().setCursor(Cursor.MOVE);
    header.setVerticalAlignment(HasVerticalAlignment.ALIGN_MIDDLE);
    header.setHeight("25px");
    master.add(header);
    header.setStyleName("header");
    header.add(this.title);
    Label close = new Label("x");
    close.setStyleName("close");
    FlowPanel tempContent = new FlowPanel() {
        @Override
        protected void onLoad() {
            super.onLoad();
            if (com.google.gwt.user.client.Window.getClientHeight() < getOffsetHeight()) {
                setHeight(com.google.gwt.user.client.Window.getClientHeight() - 100 + "px");
                getElement().getStyle().setOverflow(Overflow.AUTO);
            } else if (com.google.gwt.user.client.Window.getClientWidth() < getOffsetWidth()) {
                setWidth(com.google.gwt.user.client.Window.getClientWidth() - 300 + "px");
                getElement().getStyle().setOverflow(Overflow.AUTO);
            }
        }
    };
    tempContent.getElement().getStyle().setPadding(10, Unit.PX);
    tempContent.add(content);
    content.setWidth("100%");
    master.add(bar);
    master.add(tempContent);
    header.add(close);
    header.setCellHorizontalAlignment(close, HasHorizontalAlignment.ALIGN_RIGHT);
    header.setCellWidth(close, "16px");
    header.setCellHeight(close, "16px");
    header.setWidth("100%");
    master.setWidth("100%");
    master.setCellHeight(header, "25px");
    master.setStyleName("inside");
    outside.add(master);

    close.addClickHandler(new ClickHandler() {
        public void onClick(ClickEvent event) {
            destroy();
        }
    });

}

---

From source file:org.jbpm.form.builder.ng.model.client.form.items.ServerTransformationFormItem.java

License:Apache License

@Override
public Widget cloneDisplay(Map<String, Object> data) {
    Widget display = new MyWidget();
    if (scriptMarker.getText() != null && !"".equals(scriptMarker.getText())) {
        eval0(scriptMarker.getText());//from   w ww. ja v  a  2s.com
    }
    display.setHeight(getHeight());
    display.setWidth(getWidth());
    super.populateActions(display.getElement());
    return display;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• »