java.awt.peer.LightweightPeer Java Examples

/**
 * This is called by lightweight components that want the containing
 * windowed parent to enable some kind of events on their behalf.
 * This is needed for events that are normally only dispatched to
 * windows to be accepted so that they can be forwarded downward to
 * the lightweight component that has enabled them.
 */
void proxyEnableEvents(long events) {
    if (peer instanceof LightweightPeer) {
        // this container is lightweight.... continue sending it
        // upward.
        if (parent != null) {
            parent.proxyEnableEvents(events);
        }
    } else {
        // This is a native container, so it needs to host
        // one of it's children.  If this function is called before
        // a peer has been created we don't yet have a dispatcher
        // because it has not yet been determined if this instance
        // is lightweight.
        if (dispatcher != null) {
            dispatcher.enableEvents(events);
        }
    }
}
 

/**
 * Notify the DropTarget that it has been associated with a Component
 *
 **********************************************************************
 * This method is usually called from java.awt.Component.addNotify() of
 * the Component associated with this DropTarget to notify the DropTarget
 * that a ComponentPeer has been associated with that Component.
 *
 * Calling this method, other than to notify this DropTarget of the
 * association of the ComponentPeer with the Component may result in
 * a malfunction of the DnD system.
 **********************************************************************
 */
public void addNotify() {
    final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
    ComponentPeer peer = acc.getPeer(component);
    if (peer == null || peer == componentPeer) {
        return;
    }

    componentPeer = peer;


    for (Component c = component;
         c != null && peer instanceof LightweightPeer; c = c.getParent()) {
        peer = acc.getPeer(c);
    }

    if (peer instanceof DropTargetPeer) {
        nativePeer = (DropTargetPeer) peer;
        ((DropTargetPeer)peer).addDropTarget(this);
    } else {
        nativePeer = null;
    }
}
 

/**
 * Makes this Container displayable by connecting it to
 * a native screen resource.  Making a container displayable will
 * cause all of its children to be made displayable.
 * This method is called internally by the toolkit and should
 * not be called directly by programs.
 * @see Component#isDisplayable
 * @see #removeNotify
 */
public void addNotify() {
    synchronized (getTreeLock()) {
        // addNotify() on the children may cause proxy event enabling
        // on this instance, so we first call super.addNotify() and
        // possibly create an lightweight event dispatcher before calling
        // addNotify() on the children which may be lightweight.
        super.addNotify();
        if (! (peer instanceof LightweightPeer)) {
            dispatcher = new LightweightDispatcher(this);
        }

        // We shouldn't use iterator because of the Swing menu
        // implementation specifics:
        // the menu is being assigned as a child to JLayeredPane
        // instead of particular component so always affect
        // collection of component if menu is becoming shown or hidden.
        for (int i = 0; i < component.size(); i++) {
            component.get(i).addNotify();
        }
    }
}
 

/**
 * Notify the DropTarget that it has been associated with a Component
 *
 **********************************************************************
 * This method is usually called from java.awt.Component.addNotify() of
 * the Component associated with this DropTarget to notify the DropTarget
 * that a ComponentPeer has been associated with that Component.
 *
 * Calling this method, other than to notify this DropTarget of the
 * association of the ComponentPeer with the Component may result in
 * a malfunction of the DnD system.
 **********************************************************************
 * <P>
 * @param peer The Peer of the Component we are associated with!
 *
 */

public void addNotify(ComponentPeer peer) {
    if (peer == componentPeer) return;

    componentPeer = peer;

    for (Component c = component;
         c != null && peer instanceof LightweightPeer; c = c.getParent()) {
        peer = c.getPeer();
    }

    if (peer instanceof DropTargetPeer) {
        nativePeer = peer;
        ((DropTargetPeer)peer).addDropTarget(this);
    } else {
        nativePeer = null;
    }
}
 

/**
 * Notify the DropTarget that it has been associated with a Component
 *
 **********************************************************************
 * This method is usually called from java.awt.Component.addNotify() of
 * the Component associated with this DropTarget to notify the DropTarget
 * that a ComponentPeer has been associated with that Component.
 *
 * Calling this method, other than to notify this DropTarget of the
 * association of the ComponentPeer with the Component may result in
 * a malfunction of the DnD system.
 **********************************************************************
 * <P>
 * @param peer The Peer of the Component we are associated with!
 *
 */

public void addNotify(ComponentPeer peer) {
    if (peer == componentPeer) return;

    componentPeer = peer;

    for (Component c = component;
         c != null && peer instanceof LightweightPeer; c = c.getParent()) {
        peer = c.getPeer();
    }

    if (peer instanceof DropTargetPeer) {
        nativePeer = peer;
        ((DropTargetPeer)peer).addDropTarget(this);
    } else {
        nativePeer = null;
    }
}
 

/**
 * Makes this Container displayable by connecting it to
 * a native screen resource.  Making a container displayable will
 * cause all of its children to be made displayable.
 * This method is called internally by the toolkit and should
 * not be called directly by programs.
 * @see Component#isDisplayable
 * @see #removeNotify
 */
public void addNotify() {
    synchronized (getTreeLock()) {
        // addNotify() on the children may cause proxy event enabling
        // on this instance, so we first call super.addNotify() and
        // possibly create an lightweight event dispatcher before calling
        // addNotify() on the children which may be lightweight.
        super.addNotify();
        if (! (peer instanceof LightweightPeer)) {
            dispatcher = new LightweightDispatcher(this);
        }

        // We shouldn't use iterator because of the Swing menu
        // implementation specifics:
        // the menu is being assigned as a child to JLayeredPane
        // instead of particular component so always affect
        // collection of component if menu is becoming shown or hidden.
        for (int i = 0; i < component.size(); i++) {
            component.get(i).addNotify();
        }
    }
}
 

/**
 * Makes this Container displayable by connecting it to
 * a native screen resource.  Making a container displayable will
 * cause all of its children to be made displayable.
 * This method is called internally by the toolkit and should
 * not be called directly by programs.
 * @see Component#isDisplayable
 * @see #removeNotify
 */
public void addNotify() {
    synchronized (getTreeLock()) {
        // addNotify() on the children may cause proxy event enabling
        // on this instance, so we first call super.addNotify() and
        // possibly create an lightweight event dispatcher before calling
        // addNotify() on the children which may be lightweight.
        super.addNotify();
        if (! (peer instanceof LightweightPeer)) {
            dispatcher = new LightweightDispatcher(this);
        }

        // We shouldn't use iterator because of the Swing menu
        // implementation specifics:
        // the menu is being assigned as a child to JLayeredPane
        // instead of particular component so always affect
        // collection of component if menu is becoming shown or hidden.
        for (int i = 0; i < component.size(); i++) {
            component.get(i).addNotify();
        }
    }
}
 

/**
 * Makes this Container displayable by connecting it to
 * a native screen resource.  Making a container displayable will
 * cause all of its children to be made displayable.
 * This method is called internally by the toolkit and should
 * not be called directly by programs.
 * @see Component#isDisplayable
 * @see #removeNotify
 */
public void addNotify() {
    synchronized (getTreeLock()) {
        // addNotify() on the children may cause proxy event enabling
        // on this instance, so we first call super.addNotify() and
        // possibly create an lightweight event dispatcher before calling
        // addNotify() on the children which may be lightweight.
        super.addNotify();
        if (! (peer instanceof LightweightPeer)) {
            dispatcher = new LightweightDispatcher(this);
        }

        // We shouldn't use iterator because of the Swing menu
        // implementation specifics:
        // the menu is being assigned as a child to JLayeredPane
        // instead of particular component so always affect
        // collection of component if menu is becoming shown or hidden.
        for (int i = 0; i < component.size(); i++) {
            component.get(i).addNotify();
        }
    }
}
 

/**
 * Notify the DropTarget that it has been associated with a Component
 *
 **********************************************************************
 * This method is usually called from java.awt.Component.addNotify() of
 * the Component associated with this DropTarget to notify the DropTarget
 * that a ComponentPeer has been associated with that Component.
 *
 * Calling this method, other than to notify this DropTarget of the
 * association of the ComponentPeer with the Component may result in
 * a malfunction of the DnD system.
 **********************************************************************
 * <P>
 * @param peer The Peer of the Component we are associated with!
 *
 */

public void addNotify(ComponentPeer peer) {
    if (peer == componentPeer) return;

    componentPeer = peer;

    for (Component c = component;
         c != null && peer instanceof LightweightPeer; c = c.getParent()) {
        peer = c.getPeer();
    }

    if (peer instanceof DropTargetPeer) {
        nativePeer = peer;
        ((DropTargetPeer)peer).addDropTarget(this);
    } else {
        nativePeer = null;
    }
}
 

/**
 * Makes this Container displayable by connecting it to
 * a native screen resource.  Making a container displayable will
 * cause all of its children to be made displayable.
 * This method is called internally by the toolkit and should
 * not be called directly by programs.
 * @see Component#isDisplayable
 * @see #removeNotify
 */
public void addNotify() {
    synchronized (getTreeLock()) {
        // addNotify() on the children may cause proxy event enabling
        // on this instance, so we first call super.addNotify() and
        // possibly create an lightweight event dispatcher before calling
        // addNotify() on the children which may be lightweight.
        super.addNotify();
        if (! (peer instanceof LightweightPeer)) {
            dispatcher = new LightweightDispatcher(this);
        }

        // We shouldn't use iterator because of the Swing menu
        // implementation specifics:
        // the menu is being assigned as a child to JLayeredPane
        // instead of particular component so always affect
        // collection of component if menu is becoming shown or hidden.
        for (int i = 0; i < component.size(); i++) {
            component.get(i).addNotify();
        }
    }
}
 

/**
 * This is called by lightweight components that want the containing
 * windowed parent to enable some kind of events on their behalf.
 * This is needed for events that are normally only dispatched to
 * windows to be accepted so that they can be forwarded downward to
 * the lightweight component that has enabled them.
 */
void proxyEnableEvents(long events) {
    if (peer instanceof LightweightPeer) {
        // this container is lightweight.... continue sending it
        // upward.
        if (parent != null) {
            parent.proxyEnableEvents(events);
        }
    } else {
        // This is a native container, so it needs to host
        // one of it's children.  If this function is called before
        // a peer has been created we don't yet have a dispatcher
        // because it has not yet been determined if this instance
        // is lightweight.
        if (dispatcher != null) {
            dispatcher.enableEvents(events);
        }
    }
}
 

/**
 * This is called by lightweight components that want the containing
 * windowed parent to enable some kind of events on their behalf.
 * This is needed for events that are normally only dispatched to
 * windows to be accepted so that they can be forwarded downward to
 * the lightweight component that has enabled them.
 */
void proxyEnableEvents(long events) {
    if (peer instanceof LightweightPeer) {
        // this container is lightweight.... continue sending it
        // upward.
        if (parent != null) {
            parent.proxyEnableEvents(events);
        }
    } else {
        // This is a native container, so it needs to host
        // one of it's children.  If this function is called before
        // a peer has been created we don't yet have a dispatcher
        // because it has not yet been determined if this instance
        // is lightweight.
        if (dispatcher != null) {
            dispatcher.enableEvents(events);
        }
    }
}
 

/**
 * Makes this Container displayable by connecting it to
 * a native screen resource.  Making a container displayable will
 * cause all of its children to be made displayable.
 * This method is called internally by the toolkit and should
 * not be called directly by programs.
 * @see Component#isDisplayable
 * @see #removeNotify
 */
public void addNotify() {
    synchronized (getTreeLock()) {
        // addNotify() on the children may cause proxy event enabling
        // on this instance, so we first call super.addNotify() and
        // possibly create an lightweight event dispatcher before calling
        // addNotify() on the children which may be lightweight.
        super.addNotify();
        if (! (peer instanceof LightweightPeer)) {
            dispatcher = new LightweightDispatcher(this);
        }

        // We shouldn't use iterator because of the Swing menu
        // implementation specifics:
        // the menu is being assigned as a child to JLayeredPane
        // instead of particular component so always affect
        // collection of component if menu is becoming shown or hidden.
        for (int i = 0; i < component.size(); i++) {
            component.get(i).addNotify();
        }
    }
}
 

/**
 * Makes this Container displayable by connecting it to
 * a native screen resource.  Making a container displayable will
 * cause all of its children to be made displayable.
 * This method is called internally by the toolkit and should
 * not be called directly by programs.
 * @see Component#isDisplayable
 * @see #removeNotify
 */
public void addNotify() {
    synchronized (getTreeLock()) {
        // addNotify() on the children may cause proxy event enabling
        // on this instance, so we first call super.addNotify() and
        // possibly create an lightweight event dispatcher before calling
        // addNotify() on the children which may be lightweight.
        super.addNotify();
        if (! (peer instanceof LightweightPeer)) {
            dispatcher = new LightweightDispatcher(this);
        }

        // We shouldn't use iterator because of the Swing menu
        // implementation specifics:
        // the menu is being assigned as a child to JLayeredPane
        // instead of particular component so always affect
        // collection of component if menu is becoming shown or hidden.
        for (int i = 0; i < component.size(); i++) {
            component.get(i).addNotify();
        }
    }
}
 

/**
 * Notify the DropTarget that it has been associated with a Component
 *
 **********************************************************************
 * This method is usually called from java.awt.Component.addNotify() of
 * the Component associated with this DropTarget to notify the DropTarget
 * that a ComponentPeer has been associated with that Component.
 *
 * Calling this method, other than to notify this DropTarget of the
 * association of the ComponentPeer with the Component may result in
 * a malfunction of the DnD system.
 **********************************************************************
 * <P>
 * @param peer The Peer of the Component we are associated with!
 *
 */

public void addNotify(ComponentPeer peer) {
    if (peer == componentPeer) return;

    componentPeer = peer;

    for (Component c = component;
         c != null && peer instanceof LightweightPeer; c = c.getParent()) {
        peer = c.getPeer();
    }

    if (peer instanceof DropTargetPeer) {
        nativePeer = peer;
        ((DropTargetPeer)peer).addDropTarget(this);
    } else {
        nativePeer = null;
    }
}
 

/**
 * Makes this Container displayable by connecting it to
 * a native screen resource.  Making a container displayable will
 * cause all of its children to be made displayable.
 * This method is called internally by the toolkit and should
 * not be called directly by programs.
 * @see Component#isDisplayable
 * @see #removeNotify
 */
public void addNotify() {
    synchronized (getTreeLock()) {
        // addNotify() on the children may cause proxy event enabling
        // on this instance, so we first call super.addNotify() and
        // possibly create an lightweight event dispatcher before calling
        // addNotify() on the children which may be lightweight.
        super.addNotify();
        if (! (peer instanceof LightweightPeer)) {
            dispatcher = new LightweightDispatcher(this);
        }

        // We shouldn't use iterator because of the Swing menu
        // implementation specifics:
        // the menu is being assigned as a child to JLayeredPane
        // instead of particular component so always affect
        // collection of component if menu is becoming shown or hidden.
        for (int i = 0; i < component.size(); i++) {
            component.get(i).addNotify();
        }
    }
}
 

static Component getHeavyweight(Component comp) {
    if (comp == null || comp.getPeer() == null) {
        return null;
    } else if (comp.getPeer() instanceof LightweightPeer) {
        return comp.getNativeContainer();
    } else {
        return comp;
    }
}
 

public void run(Component comp, Graphics cg) {
    comp.validate();
    if (comp.peer instanceof LightweightPeer) {
        comp.lightweightPrint(cg);
    } else {
        comp.peer.print(cg);
    }
}
 

/**
 * Returns closest heavyweight component to this container. If this container is heavyweight
 * returns this.
 * @since 1.5
 */
Container getHeavyweightContainer() {
    checkTreeLock();
    if (peer != null && !(peer instanceof LightweightPeer)) {
        return this;
    } else {
        return getNativeContainer();
    }
}
 

public void run(Component comp, Graphics cg) {
    comp.validate();
    if (comp.peer instanceof LightweightPeer) {
        comp.lightweightPaint(cg);
    } else {
        comp.peer.paint(cg);
    }
}
 

public void run(Component comp, Graphics cg) {
    if (comp.peer instanceof LightweightPeer) {
        comp.paintHeavyweightComponents(cg);
    } else {
        comp.paintAll(cg);
    }
}
 

static Component getHeavyweight(Component comp) {
    if (comp == null || comp.getPeer() == null) {
        return null;
    } else if (comp.getPeer() instanceof LightweightPeer) {
        return comp.getNativeContainer();
    } else {
        return comp;
    }
}
 

public void run(Component comp, Graphics cg) {
    if (comp.peer instanceof LightweightPeer) {
        comp.paintHeavyweightComponents(cg);
    } else {
        comp.paintAll(cg);
    }
}
 

public void run(Component comp, Graphics cg) {
    comp.validate();
    if (comp.peer instanceof LightweightPeer) {
        comp.lightweightPrint(cg);
    } else {
        comp.peer.print(cg);
    }
}
 

public void run(Component comp, Graphics cg) {
    comp.validate();
    if (comp.peer instanceof LightweightPeer) {
        comp.lightweightPaint(cg);
    } else {
        comp.peer.paint(cg);
    }
}
 

/**
 * Should be messaged before the dragging session starts, resets
 * lastDragLocation and dividerSize.
 */
protected void startDragging() {
    Component       leftC = splitPane.getLeftComponent();
    Component       rightC = splitPane.getRightComponent();
    ComponentPeer   cPeer;

    beginDragDividerLocation = getDividerLocation(splitPane);
    draggingHW = false;
    if(leftC != null && (cPeer = leftC.getPeer()) != null &&
       !(cPeer instanceof LightweightPeer)) {
        draggingHW = true;
    } else if(rightC != null && (cPeer = rightC.getPeer()) != null
              && !(cPeer instanceof LightweightPeer)) {
        draggingHW = true;
    }
    if(orientation == JSplitPane.HORIZONTAL_SPLIT) {
        setLastDragLocation(divider.getBounds().x);
        dividerSize = divider.getSize().width;
        if(!isContinuousLayout() && draggingHW) {
            nonContinuousLayoutDivider.setBounds
                    (getLastDragLocation(), 0, dividerSize,
                     splitPane.getHeight());
                  addHeavyweightDivider();
        }
    } else {
        setLastDragLocation(divider.getBounds().y);
        dividerSize = divider.getSize().height;
        if(!isContinuousLayout() && draggingHW) {
            nonContinuousLayoutDivider.setBounds
                    (0, getLastDragLocation(), splitPane.getWidth(),
                     dividerSize);
                  addHeavyweightDivider();
        }
    }
}
 

static Component getHeavyweight(Component comp) {
    if (comp == null || comp.peer == null) {
        return null;
    } else if (comp.peer instanceof LightweightPeer) {
        return comp.getNativeContainer();
    } else {
        return comp;
    }
}
 

public void run(Component comp, Graphics cg) {
    if (comp.peer instanceof LightweightPeer) {
        comp.printHeavyweightComponents(cg);
    } else {
        comp.printAll(cg);
    }
}
 

public void run(Component comp, Graphics cg) {
    if (comp.peer instanceof LightweightPeer) {
        comp.paintHeavyweightComponents(cg);
    } else {
        comp.paintAll(cg);
    }
}
 

public void run(Component comp, Graphics cg) {
    comp.validate();
    if (comp.peer instanceof LightweightPeer) {
        comp.lightweightPrint(cg);
    } else {
        comp.peer.print(cg);
    }
}