org.netbeans.api.visual.model.ObjectScene Java Examples

private List<GraphLocation> createRelativeLocations(ObjectScene scene, List<GraphNode> nodes, Align align) {
    List<GraphLocation> widgetLocations = new ArrayList<GraphLocation>();
    int startY = 0;
    for (GraphNode node : nodes) {
        Widget widget = scene.findWidget(node);
        if (widget == null) {
            continue;
        }
        Rectangle bounds = widget.getBounds();
        if (bounds == null) {
            continue;
        }
        int startX = 0;
        if ( align == Align.RIGHT){
            startX = -bounds.width;
        }
        widgetLocations.add(new GraphLocation(node, startX, startY,bounds));
        startY += bounds.height + verticalGap;
        
    }
    return widgetLocations;
}
 

protected void notifyRemoved() {
    super.notifyRemoved();
    if(getScene() instanceof ObjectScene && userObject!=null) {
        ObjectScene scene =(ObjectScene) getScene();
        List<Widget> widgets = scene.findWidgets(userObject);
        if(widgets!=null && widgets.contains(this)) {
            if(widgets.size()==1) 
                scene.removeObject(userObject);
            else {
                widgets = new ArrayList<Widget>(widgets);
                widgets.remove(this);
                scene.removeObject(userObject);
                scene.addObject(userObject, widgets.toArray(new Widget[widgets.size()]));
            }
        }
    }
}
 

/**
 * Creates a new instance of OperationWidget
 * @param scene
 * @param operation
 */
public OperationWidget(ObjectScene scene, ServiceModel serviceModel, 
        ProjectService service, MethodModel operation) 
{
    super(scene,RADIUS,RADIUS,RADIUS/2,BORDER_COLOR);
    this.service = service;
    this.operation=operation;
    this.serviceModel = serviceModel;
    
    removeAction = new RemoveOperationAction(service);
    removeAction.setWorkingSet(Collections.singleton(operation));
    getActions().addAction(ActionFactory.createPopupMenuAction(
            new DesignViewPopupProvider(new Action [] {
        new GotoSourceAction(operation, serviceModel.getImplementationClass()),
        removeAction
    })));
    createContent();
}
 

public void propertyChange(PropertyChangeEvent evt) {
    Object source = evt.getSource();
    ObjectScene scene = (ObjectScene) widget.getScene();
    String property = evt.getPropertyName();
    Object newValue = evt.getNewValue();
    if(source instanceof WSConfiguration) {
        Widget configWidget = scene.findWidget(source);
        if(WSConfiguration.PROPERTY.equals(property)) {
            if(configWidget instanceof CheckBoxWidget) {
                ((CheckBoxWidget)configWidget).setSelected((Boolean)newValue);
                scene.validate();
                widget.revalidate(true);
            }
        } else if(WSConfiguration.PROPERTY_ENABLE.equals(property)) {
            if(configWidget instanceof CheckBoxWidget) {
                ((CheckBoxWidget)configWidget).setVisible((Boolean)newValue);
                widget.determineVisibility();
                widget.revalidate();
            }
        }

    }
}
 

/**
 * Should be called to set a new resolved preferred location of a node.
 * @param graph the universal graph
 * @param node the node with resolved location
 * @param newPreferredLocation the new resolved location
 */
protected final void setResolvedNodeLocation (UniversalGraph<N,E> graph, N node, Point newPreferredLocation) {
    ObjectScene scene = graph.getScene ();

    Widget widget = scene.findWidget (node);
    if (widget == null)
        return;

    Point previousPreferredLocation = widget.getPreferredLocation ();

    if (animated)
        scene.getSceneAnimator ().animatePreferredLocation (widget, newPreferredLocation);
    else
        widget.setPreferredLocation (newPreferredLocation);

    GraphLayoutListener<N,E>[] listeners = createListenersCopy ();

    for (GraphLayoutListener<N,E> listener : listeners)
        listener.nodeLocationChanged (graph, node, previousPreferredLocation, newPreferredLocation);
}
 

/** 
 * Creates a new instance of OperationWidget 
 * @param scene 
 * @param method 
 */
public ParametersWidget(ObjectScene scene, MethodModel method, boolean nameEditable) {
    super(scene,0,RADIUS,0,BORDER_COLOR);
    this.method = method;
    this.nameEditable = nameEditable;
    createContent();
}
 

/**
 * Returns the index of visible widget represented by given object using depth first search.
 * Integer.MAX_VALUE if none found.
 */ 
private static int getIdentityCode(ObjectScene scene, Object object) {
    List<Widget> widgets = scene.findWidgets(object);
    Widget w = null;
    ArrayList<Widget> pathToRoot = new ArrayList<Widget>();
    if(widgets!=null) {
        for(Widget w1:widgets) {
            pathToRoot = new ArrayList<Widget>();
            if(!w1.isVisible()) continue;
            Widget parent = w1.getParentWidget();
            while(parent!=null && parent.isVisible()) {
                pathToRoot.add(0,parent);
                parent = parent.getParentWidget();
            }
            if(!pathToRoot.isEmpty()&&pathToRoot.get(0)==scene) {
                w = w1;
                pathToRoot.add(w);
                break;
            }
        }
    }
    if(w==null) 
        return Integer.MAX_VALUE;
    int code = 0;
    for(int i=0;i<pathToRoot.size();) {
        Widget widgetOnPath=pathToRoot.get(i++);
        code++;
        if(i == pathToRoot.size()) break;
        int nextWidgetOnPathIndex = widgetOnPath.getChildren().indexOf(pathToRoot.get(i));
        for(int j=0;j<nextWidgetOnPathIndex;j++) {
            code+=getTreeSize(widgetOnPath.getChildren().get(j));
        }
    }
    return code;
}
 

/**
 * Creates a new instance of OperationWidget
 * @param scene
 * @param service
 * @param serviceModel
 */
public WsitWidget(ObjectScene scene, final Service service, 
        FileObject implementationClass, 
        Collection<WSConfiguration> wsConfigurations ) 
{
    super(scene,RADIUS,BORDER_COLOR);
    this.implementationClass = implementationClass;
    this.service=service;
    configurations = wsConfigurations;
    setOpaque(true);
    setBackground(TITLE_COLOR_PARAMETER);
    configListener = new WSConfigurationListener(this);
    createContent();
}
 

/** Creates a new instance of Description
 * @param scene
 * @param method
 */
public DescriptionWidget(ObjectScene scene, MethodModel method) {
    super(scene,0,RADIUS,1,BORDER_COLOR);
    this.method = method;
    model = method.getJavadoc();
    listener = new DescriptionListener();
    createContent();
}
 

/** 
 * Creates a new instance of SampleMessageWidget 
 * @param scene 
 * @param operation 
 * @param type 
 */
public SampleMessageWidget(ObjectScene scene, MethodModel operation, Type type) {
    super(scene,0,12,0,TITLE_COLOR);
    this.operation = operation;
    this.type = type;

    headerLabelWidget = new ImageLabelWidget(scene, null, operation.getOperationName()+": ",type.getTitle());
    headerLabelWidget.setLabelFont(scene.getFont().deriveFont(Font.BOLD));
    headerLabelWidget.setPaintAsDisabled(false);
    headerLabelWidget.setLabelForeground(type.getBorderColor());
    getHeaderWidget().addChild(new Widget(getScene()),1);
    getHeaderWidget().addChild(headerLabelWidget);
    getHeaderWidget().addChild(new Widget(getScene()),1);

    buttons = new Widget(getScene());
    buttons.setLayout(LayoutFactory.createHorizontalFlowLayout(
            LayoutFactory.SerialAlignment.JUSTIFY, 8));
    getHeaderWidget().addChild(buttons);
    final ButtonWidget closeButton = new ButtonWidget(getScene(), (String)null);
    closeButton.setImage(new ExpanderImageWidget(scene,type.getBorderColor(),8));
    closeButton.setRoundedBorder(0, 4, 4,type.getBorderColor());
    closeButton.setAction(new AbstractAction() {
        public void actionPerformed(ActionEvent arg0) {
            SampleMessageWidget.this.removeFromParent();
        }
    });
    buttons.addChild(closeButton);

    paneWidget = new EditorPaneWidget(scene, 
            Utils.getFormatedDocument(type.getMessage(operation)),"text/xml");
    paneWidget.setEditable(false);
    getContentWidget().addChild(paneWidget);
    getContentWidget().setBorder(BorderFactory.createEmptyBorder(12, 6));
}
 

/**
     * Creates a new instance of RoundedRectangleWidget
     * with default rounded radius and gap and no gradient color
     * @param scene scene this widget belongs to
     * @param radius of the rounded arc
     * @param gap for header widget
     * @param gap for content widget
     * @param color color of the border and gradient title
     */
    public AbstractTitledWidget(ObjectScene scene, int radius, int hgap, int cgap, Color color) {
        super(scene);
        this.radius = radius;
        this.borderColor = color;
        //this.hgap = hgap;
        this.cgap = cgap;
        depth = radius/3;
        setLayout(LayoutFactory.createVerticalFlowLayout(LayoutFactory.SerialAlignment.JUSTIFY, 0));
        setBorder(new RoundedBorder3D(this,radius, depth, 0, 0, borderColor));
        headerWidget = new Widget(getScene());
        headerWidget.setBorder(BorderFactory.createEmptyBorder(hgap, hgap/2));
        headerWidget.setLayout(LayoutFactory.createHorizontalFlowLayout(LayoutFactory.SerialAlignment.CENTER, hgap));
//        headerWidget.setLayout(new BorderLayout(headerWidget));
        addChild(headerWidget);
        seperatorWidget = new SeparatorWidget(getScene(),SeparatorWidget.Orientation.HORIZONTAL);
        seperatorWidget.setForeground(borderColor);
        if(isExpandable()) {
            contentWidget = createContentWidget();
            expanded = ExpanderWidget.isExpanded(this, true);
            if(expanded) {
                expandWidget();
            } else {
                collapseWidget();
            }
            expander = new ExpanderWidget(getScene(), this, expanded);
        }
        getActions().addAction(scene.createSelectAction());
    }
 

RowWidget(Scene scene, int columns, Object userObject) {
    super(scene);
    setLayout(new TableLayout(columns, 0, 0,COLUMN_WIDTH));
    this.userObject = userObject;
    if(getScene() instanceof ObjectScene && userObject!=null) {
        getActions().addAction(((ObjectScene) getScene()).createSelectAction());
        setBorder(new LineBorder(1,0,0,0,BORDER_COLOR));
    }
}
 

protected void notifyAdded() {
    super.notifyAdded();
    if(getScene() instanceof ObjectScene && userObject!=null) {
        ObjectScene scene =(ObjectScene) getScene();
        List<Widget> widgets = scene.findWidgets(userObject);
        if(widgets==null|| widgets.isEmpty())
            scene.addObject(userObject, this);
        else {
            scene.removeObject(userObject);
            widgets = new ArrayList<Widget>(widgets);
            widgets.add(this);
            scene.addObject(userObject, widgets.toArray(new Widget[widgets.size()]));
        }
    }
}
 

@Override
protected void notifyAdded() {
    super.notifyAdded();
    Scene scene = getScene();
    if(scene instanceof ObjectScene) {
        ObjectScene objectScene = (ObjectScene)scene;
        objectScene.addObject(hashKey(), this);
    }
}
 

@Override
protected void notifyRemoved() {
    super.notifyRemoved();
    Scene scene = getScene();
    if(scene instanceof ObjectScene) {
        ((ObjectScene)scene).removeObject(hashKey());
    }
}
 

public FlushableWidget(ObjectScene scene, int radius, int hgap, int cgap, Color color) {
    super(scene,radius,hgap, cgap , color);
}
 

public FlushableWidget(ObjectScene scene, int radius, Color color) {
    super(scene,radius,color);
}
 

private Widget resolve(Widget widget){
    ObjectScene scene = (ObjectScene)widget.getScene();
    return scene.findWidget(scene.findObject(widget));
}
 

/** 
 * Creates a new instance of OperationWidget 
 * @param scene
 * @param method  
 */
public FaultsWidget(ObjectScene scene, MethodModel method) {
    super(scene,0,RADIUS,0,BORDER_COLOR);
    this.method = method;
    createContent();
}
 

public static Object model(Widget widget){
    return ((ObjectScene)widget.getScene()).findObject(widget);
}
 

protected ObjectScene getObjectScene() {
    return (ObjectScene)super.getScene();
}
 

public boolean switchPreviousFocus (Widget widget) {
    Scene scene = widget.getScene ();
    return scene instanceof ObjectScene  &&  switchFocus ((ObjectScene) scene, false);
}
 

/**
 * Creates a new instance of OperationWidget
 * @param scene
 * @param method
 */
public OutputWidget(ObjectScene scene, MethodModel method) {
    super(scene,0,RADIUS,0,BORDER_COLOR);
    this.method = method;
    createContent();
}
 

/**
 * Creates a new instance of GraphView.
 * @param service
 * @param implementationClass
 */
public DesignView(ProjectService service, FileObject implementationClass) {
    super(new BorderLayout());
    
    this.service = service;
    this.implementationClass = implementationClass;
    
    scene = new ObjectScene() {
        @Override
        /**
         * Use our own traversal policy
         */
        public Comparable<DesignerWidgetIdentityCode> getIdentityCode(Object object) {
            return new DesignerWidgetIdentityCode(scene,object);
        }
    };
    zoomer = new ZoomManager(scene);

    scene.getActions().addAction(ActionFactory.createCycleObjectSceneFocusAction());
    scene.setKeyEventProcessingType (EventProcessingType.FOCUSED_WIDGET_AND_ITS_PARENTS);

    mainLayer = new LayerWidget(scene);
    mainLayer.setPreferredLocation(new Point(0, 0));
    mainLayer.setLayout(LayoutFactory.createVerticalFlowLayout(
            LayoutFactory.SerialAlignment.JUSTIFY, 12));
    scene.addChild(mainLayer);
    
    mainWidget = new Widget(scene);
    mainWidget.setLayout(LayoutFactory.createVerticalFlowLayout(
            LayoutFactory.SerialAlignment.JUSTIFY, 12));
    
    headerWidget = new LabelWidget(scene);
    headerWidget.setFont(scene.getFont().deriveFont(Font.BOLD));
    headerWidget.setForeground(Color.GRAY);
    headerWidget.setBorder(BorderFactory.createEmptyBorder(6,28,0,0));
    mainWidget.addChild(headerWidget);
    
    separatorWidget = new SeparatorWidget(scene,
            SeparatorWidget.Orientation.HORIZONTAL);
    separatorWidget.setForeground(Color.ORANGE);
    mainWidget.addChild(separatorWidget);
    
    contentWidget = new Widget(scene);
    contentWidget.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 20));
    contentWidget.setLayout(LayoutFactory.createVerticalFlowLayout(
            LayoutFactory.SerialAlignment.JUSTIFY, 16));
    mainWidget.addChild(contentWidget);
    
    JPanel panel = new JPanel(new FlowLayout(FlowLayout.CENTER){
        /* (non-Javadoc)
         * @see java.awt.FlowLayout#layoutContainer(java.awt.Container)
         */
        @Override
        public void layoutContainer( Container target ) {
            super.layoutContainer(target);
            Component[] components = target.getComponents();
            double height = target.getSize().getHeight()/2;
            for (Component component : components) {
                Point location = component.getLocation();
                component.setLocation( (int)location.getX(), (int)height );
            }
        }
    });
    panel.add(new JLabel(NbBundle.getMessage( DesignView.class, "LBL_Wait")));
    add( panel,BorderLayout.CENTER);
    
    mainLayer.addChild(mainWidget);

    messageWidget = new Widget(scene);
    messageWidget.setLayout(LayoutFactory.createVerticalFlowLayout(
            LayoutFactory.SerialAlignment.JUSTIFY, 4));
    mainLayer.addChild(messageWidget);
    scene.addObject(messageLayerKey, messageWidget);
    
    initServiceModel();
}
 

public DesignerWidgetIdentityCode(ObjectScene scene, Object object) {
    this.scene = scene;
    this.object = object;
}
 

public ObjectSceneRectangularSelectProvider (ObjectScene scene) {
    this.scene = scene;
}
 

public boolean switchNextFocus (Widget widget) {
    Scene scene = widget.getScene ();
    return scene instanceof ObjectScene  &&  switchFocus ((ObjectScene) scene, true);
}
 

/**
 * Creates a new instance of RoundedRectangleWidget
 * with default rounded radius and gap and no gradient color
 * @param scene scene this widget belongs to
 * @param radius of the rounded arc
 * @param color color of the border and gradient title
 */
public AbstractTitledWidget(ObjectScene scene, int radius, Color color) {
    this(scene,radius,radius,radius,color);
}
 

/**
 * Returns a related scene as a ObjectScene.
 * @return the related scene which is represented by the universal graph.
 */
public abstract ObjectScene getScene ();
 

/**
 * Creates a rectangular select provider which controls a selection of an object scene.
 * @param scene the object scene where an action is used
 * @return the rectangular select provider
 */
public static RectangularSelectProvider createObjectSceneRectangularSelectProvider (ObjectScene scene) {
    assert scene != null;
    return new ObjectSceneRectangularSelectProvider (scene);
}