下面列出了怎么用java.awt.peer.LightweightPeer的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* 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);
}
}
}
/**
* 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();
}
}
}
/**
* 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;
}
}
/**
* 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.
**********************************************************************
* <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();
}
}
}
/**
* 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);
}
}
}
/**
* 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();
}
}
}
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) {
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.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);
}
}
/**
* 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;
final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
if(leftC != null && (cPeer = acc.getPeer(leftC)) != null &&
!(cPeer instanceof LightweightPeer)) {
draggingHW = true;
} else if(rightC != null && (cPeer = acc.getPeer(rightC)) != 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();
}
}
}
/**
* 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();
}
}
}
public void run(Component comp, Graphics cg) {
comp.validate();
if (comp.peer instanceof LightweightPeer) {
comp.lightweightPrint(cg);
} else {
comp.peer.print(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) {
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);
}
}
public void run(Component comp, Graphics cg) {
comp.validate();
if (comp.peer instanceof LightweightPeer) {
comp.lightweightPrint(cg);
} else {
comp.peer.print(cg);
}
}