final Graphics getGraphics_NoClientCode() { ComponentPeer peer = this.peer; if (peer instanceof LightweightPeer) { // This is for a lightweight component, need to // translate coordinate spaces and clip relative // to the parent. Container parent = this.parent; if (parent == null) return null; Graphics g = parent.getGraphics_NoClientCode(); if (g == null) return null; if (g instanceof ConstrainableGraphics) { ((ConstrainableGraphics) g).constrain(x, y, width, height); } else { g.translate(x,y); g.setClip(0, 0, width, height); } g.setFont(getFont_NoClientCode()); return g; } else { return (peer != null) ? peer.getGraphics() : null; } }
/** * Updates the cursor. May not be invoked from the native * message pump. */ final void updateCursorImmediately() { if (peer instanceof LightweightPeer) { Container nativeContainer = getNativeContainer(); if (nativeContainer == null) return; ComponentPeer cPeer = nativeContainer.getPeer(); if (cPeer != null) { cPeer.updateCursorImmediately(); } } else if (peer != null) { peer.updateCursorImmediately(); } }
/** * 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; } }
/** * 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(); } } }
/** * 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; } }
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.lightweightPaint(cg); } else { comp.peer.paint(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) { if (comp.peer instanceof LightweightPeer) { comp.paintHeavyweightComponents(cg); } else { comp.paintAll(cg); } }
public void run(Component comp, Graphics cg) { if (comp.peer instanceof LightweightPeer) { comp.printHeavyweightComponents(cg); } else { comp.printAll(cg); } }
/** * Gets the instance of <code>ColorModel</code> used to display * the component on the output device. * @return the color model used by this component * @see java.awt.image.ColorModel * @see java.awt.peer.ComponentPeer#getColorModel() * @see Toolkit#getColorModel() * @since JDK1.0 */ public ColorModel getColorModel() { ComponentPeer peer = this.peer; if ((peer != null) && ! (peer instanceof LightweightPeer)) { return peer.getColorModel(); } else if (GraphicsEnvironment.isHeadless()) { return ColorModel.getRGBdefault(); } // else return getToolkit().getColorModel(); }
private void repaintParentIfNeeded(int oldX, int oldY, int oldWidth, int oldHeight) { if (parent != null && peer instanceof LightweightPeer && isShowing()) { // Have the parent redraw the area this component occupied. parent.repaint(oldX, oldY, oldWidth, oldHeight); // Have the parent redraw the area this component *now* occupies. repaint(); } }
private void reshapeNativePeer(int x, int y, int width, int height, int op) { // native peer might be offset by more than direct // parent since parent might be lightweight. int nativeX = x; int nativeY = y; for (Component c = parent; (c != null) && (c.peer instanceof LightweightPeer); c = c.parent) { nativeX += c.x; nativeY += c.y; } peer.setBounds(nativeX, nativeY, width, height, op); }
/** * Repaints the specified rectangle of this component within * <code>tm</code> milliseconds. * <p> * If this component is a lightweight component, this method causes * a call to this component's <code>paint</code> method. * Otherwise, this method causes a call to this component's * <code>update</code> method. * <p> * <b>Note</b>: For more information on the paint mechanisms utilitized * by AWT and Swing, including information on how to write the most * efficient painting code, see * <a href="http://www.oracle.com/technetwork/java/painting-140037.html">Painting in AWT and Swing</a>. * * @param tm maximum time in milliseconds before update * @param x the <i>x</i> coordinate * @param y the <i>y</i> coordinate * @param width the width * @param height the height * @see #update(Graphics) * @since JDK1.0 */ public void repaint(long tm, int x, int y, int width, int height) { if (this.peer instanceof LightweightPeer) { // Needs to be translated to parent coordinates since // a parent native container provides the actual repaint // services. Additionally, the request is restricted to // the bounds of the component. if (parent != null) { if (x < 0) { width += x; x = 0; } if (y < 0) { height += y; y = 0; } int pwidth = (width > this.width) ? this.width : width; int pheight = (height > this.height) ? this.height : height; if (pwidth <= 0 || pheight <= 0) { return; } int px = this.x + x; int py = this.y + y; parent.repaint(tm, px, py, pwidth, pheight); } } else { if (isVisible() && (this.peer != null) && (width > 0) && (height > 0)) { PaintEvent e = new PaintEvent(this, PaintEvent.UPDATE, new Rectangle(x, y, width, height)); SunToolkit.postEvent(SunToolkit.targetToAppContext(this), e); } } }
/** * Creates an image from the specified image producer. * @param producer the image producer * @return the image produced * @since JDK1.0 */ public Image createImage(ImageProducer producer) { ComponentPeer peer = this.peer; if ((peer != null) && ! (peer instanceof LightweightPeer)) { return peer.createImage(producer); } return getToolkit().createImage(producer); }
/** * Enables the events defined by the specified event mask parameter * to be delivered to this component. * <p> * Event types are automatically enabled when a listener for * that event type is added to the component. * <p> * This method only needs to be invoked by subclasses of * <code>Component</code> which desire to have the specified event * types delivered to <code>processEvent</code> regardless of whether * or not a listener is registered. * @param eventsToEnable the event mask defining the event types * @see #processEvent * @see #disableEvents * @see AWTEvent * @since JDK1.1 */ protected final void enableEvents(long eventsToEnable) { long notifyAncestors = 0; synchronized (this) { if ((eventsToEnable & AWTEvent.HIERARCHY_EVENT_MASK) != 0 && hierarchyListener == null && (eventMask & AWTEvent.HIERARCHY_EVENT_MASK) == 0) { notifyAncestors |= AWTEvent.HIERARCHY_EVENT_MASK; } if ((eventsToEnable & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0 && hierarchyBoundsListener == null && (eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) == 0) { notifyAncestors |= AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK; } eventMask |= eventsToEnable; newEventsOnly = true; } // if this is a lightweight component, enable mouse events // in the native container. if (peer instanceof LightweightPeer) { parent.proxyEnableEvents(eventMask); } if (notifyAncestors != 0) { synchronized (getTreeLock()) { adjustListeningChildrenOnParent(notifyAncestors, 1); } } }
final Container getNativeContainer() { Container p = getContainer(); while (p != null && p.peer instanceof LightweightPeer) { p = p.getContainer(); } return p; }
/** * 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(); } }
/** * 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(); } } }