4688 } 4689 4690 void dispatchEventImpl(AWTEvent e) { 4691 int id = e.getID(); 4692 4693 // Check that this component belongs to this app-context 4694 AppContext compContext = appContext; 4695 if (compContext != null && !compContext.equals(AppContext.getAppContext())) { 4696 if (eventLog.isLoggable(PlatformLogger.FINE)) { 4697 eventLog.fine("Event " + e + " is being dispatched on the wrong AppContext"); 4698 } 4699 } 4700 4701 if (eventLog.isLoggable(PlatformLogger.FINEST)) { 4702 eventLog.finest("{0}", e); 4703 } 4704 4705 /* 4706 * 0. Set timestamp and modifiers of current event. 4707 */ 4708 EventQueue.setCurrentEventAndMostRecentTime(e); 4709 4710 /* 4711 * 1. Pre-dispatchers. Do any necessary retargeting/reordering here 4712 * before we notify AWTEventListeners. 4713 */ 4714 4715 if (e instanceof SunDropTargetEvent) { 4716 ((SunDropTargetEvent)e).dispatch(); 4717 return; 4718 } 4719 4720 if (!e.focusManagerIsDispatching) { 4721 // Invoke the private focus retargeting method which provides 4722 // lightweight Component support 4723 if (e.isPosted) { 4724 e = KeyboardFocusManager.retargetFocusEvent(e); 4725 e.isPosted = true; 4726 } 4727 4728 // Now, with the event properly targeted to a lightweight 7590 * @see KeyboardFocusManager#clearGlobalFocusOwner 7591 * @since 1.4 7592 */ 7593 protected boolean requestFocusInWindow(boolean temporary) { 7594 return requestFocusHelper(temporary, false); 7595 } 7596 7597 boolean requestFocusInWindow(boolean temporary, CausedFocusEvent.Cause cause) { 7598 return requestFocusHelper(temporary, false, cause); 7599 } 7600 7601 final boolean requestFocusHelper(boolean temporary, 7602 boolean focusedWindowChangeAllowed) { 7603 return requestFocusHelper(temporary, focusedWindowChangeAllowed, CausedFocusEvent.Cause.UNKNOWN); 7604 } 7605 7606 final boolean requestFocusHelper(boolean temporary, 7607 boolean focusedWindowChangeAllowed, 7608 CausedFocusEvent.Cause cause) 7609 { 7610 if (!isRequestFocusAccepted(temporary, focusedWindowChangeAllowed, cause)) { 7611 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7612 focusLog.finest("requestFocus is not accepted"); 7613 } 7614 return false; 7615 } 7616 7617 // Update most-recent map 7618 KeyboardFocusManager.setMostRecentFocusOwner(this); 7619 7620 Component window = this; 7621 while ( (window != null) && !(window instanceof Window)) { 7622 if (!window.isVisible()) { 7623 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7624 focusLog.finest("component is recurively invisible"); 7625 } 7626 return false; 7627 } 7628 window = window.parent; 7629 } 7630 7631 ComponentPeer peer = this.peer; 7632 Component heavyweight = (peer instanceof LightweightPeer) 7633 ? getNativeContainer() : this; 7634 if (heavyweight == null || !heavyweight.isVisible()) { 7635 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7636 focusLog.finest("Component is not a part of visible hierarchy"); 7637 } 7638 return false; 7639 } 7640 peer = heavyweight.peer; 7641 if (peer == null) { 7642 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7643 focusLog.finest("Peer is null"); 7644 } 7645 return false; 7646 } 7647 7648 // Focus this Component 7649 long time = EventQueue.getMostRecentEventTime(); 7650 boolean success = peer.requestFocus 7651 (this, temporary, focusedWindowChangeAllowed, time, cause); 7652 if (!success) { 7653 KeyboardFocusManager.getCurrentKeyboardFocusManager 7654 (appContext).dequeueKeyEvents(time, this); 7655 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7656 focusLog.finest("Peer request failed"); 7657 } 7658 } else { 7659 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7660 focusLog.finest("Pass for " + this); 7661 } 7662 } 7663 return success; 7664 } 7665 7666 private boolean isRequestFocusAccepted(boolean temporary, 7667 boolean focusedWindowChangeAllowed, 7668 CausedFocusEvent.Cause cause) 7669 { | 4688 } 4689 4690 void dispatchEventImpl(AWTEvent e) { 4691 int id = e.getID(); 4692 4693 // Check that this component belongs to this app-context 4694 AppContext compContext = appContext; 4695 if (compContext != null && !compContext.equals(AppContext.getAppContext())) { 4696 if (eventLog.isLoggable(PlatformLogger.FINE)) { 4697 eventLog.fine("Event " + e + " is being dispatched on the wrong AppContext"); 4698 } 4699 } 4700 4701 if (eventLog.isLoggable(PlatformLogger.FINEST)) { 4702 eventLog.finest("{0}", e); 4703 } 4704 4705 /* 4706 * 0. Set timestamp and modifiers of current event. 4707 */ 4708 if (!(e instanceof KeyEvent)) { 4709 // Timestamp of a key event is set later in DKFM.preDispatchKeyEvent(KeyEvent). 4710 EventQueue.setCurrentEventAndMostRecentTime(e); 4711 } 4712 4713 /* 4714 * 1. Pre-dispatchers. Do any necessary retargeting/reordering here 4715 * before we notify AWTEventListeners. 4716 */ 4717 4718 if (e instanceof SunDropTargetEvent) { 4719 ((SunDropTargetEvent)e).dispatch(); 4720 return; 4721 } 4722 4723 if (!e.focusManagerIsDispatching) { 4724 // Invoke the private focus retargeting method which provides 4725 // lightweight Component support 4726 if (e.isPosted) { 4727 e = KeyboardFocusManager.retargetFocusEvent(e); 4728 e.isPosted = true; 4729 } 4730 4731 // Now, with the event properly targeted to a lightweight 7593 * @see KeyboardFocusManager#clearGlobalFocusOwner 7594 * @since 1.4 7595 */ 7596 protected boolean requestFocusInWindow(boolean temporary) { 7597 return requestFocusHelper(temporary, false); 7598 } 7599 7600 boolean requestFocusInWindow(boolean temporary, CausedFocusEvent.Cause cause) { 7601 return requestFocusHelper(temporary, false, cause); 7602 } 7603 7604 final boolean requestFocusHelper(boolean temporary, 7605 boolean focusedWindowChangeAllowed) { 7606 return requestFocusHelper(temporary, focusedWindowChangeAllowed, CausedFocusEvent.Cause.UNKNOWN); 7607 } 7608 7609 final boolean requestFocusHelper(boolean temporary, 7610 boolean focusedWindowChangeAllowed, 7611 CausedFocusEvent.Cause cause) 7612 { 7613 // 1) Check if the event being dispatched is a system-generated mouse event. 7614 AWTEvent currentEvent = EventQueue.getCurrentEvent(); 7615 if (currentEvent instanceof MouseEvent && 7616 SunToolkit.isSystemGenerated(currentEvent)) 7617 { 7618 // 2) Check if the mouse event originated from the same containing window. 7619 Component source = (Component)currentEvent.getSource(); 7620 if (source != null && source.getContainingWindow() == getContainingWindow()) { 7621 focusLog.finest("requesting focus by mouse event \"in window\""); 7622 7623 // If both the conditions are fulfilled the focus request should be strictly 7624 // bounded by the toplevel window. It's assumed that the mouse event activates 7625 // the window (if it wasn't active) and this makes it possible for a focus 7626 // request with a strong in-window requirement to change focus in the bounds 7627 // of the toplevel. If, by any means, due to asynchronous nature of the event 7628 // dispatching mechanism, the window happens to be natively inactive by the time 7629 // this focus request is eventually handled, it should not re-activate the 7630 // toplevel. Otherwise the result may not meet user expectations. See 6981400. 7631 focusedWindowChangeAllowed = false; 7632 } 7633 } 7634 if (!isRequestFocusAccepted(temporary, focusedWindowChangeAllowed, cause)) { 7635 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7636 focusLog.finest("requestFocus is not accepted"); 7637 } 7638 return false; 7639 } 7640 // Update most-recent map 7641 KeyboardFocusManager.setMostRecentFocusOwner(this); 7642 7643 Component window = this; 7644 while ( (window != null) && !(window instanceof Window)) { 7645 if (!window.isVisible()) { 7646 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7647 focusLog.finest("component is recurively invisible"); 7648 } 7649 return false; 7650 } 7651 window = window.parent; 7652 } 7653 7654 ComponentPeer peer = this.peer; 7655 Component heavyweight = (peer instanceof LightweightPeer) 7656 ? getNativeContainer() : this; 7657 if (heavyweight == null || !heavyweight.isVisible()) { 7658 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7659 focusLog.finest("Component is not a part of visible hierarchy"); 7660 } 7661 return false; 7662 } 7663 peer = heavyweight.peer; 7664 if (peer == null) { 7665 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7666 focusLog.finest("Peer is null"); 7667 } 7668 return false; 7669 } 7670 7671 // Focus this Component 7672 long time = 0; 7673 if (EventQueue.isDispatchThread()) { 7674 time = Toolkit.getEventQueue().getMostRecentKeyEventTime(); 7675 } else { 7676 // A focus request made from outside EDT should not be associated with any event 7677 // and so its time stamp is simply set to the current time. 7678 time = System.currentTimeMillis(); 7679 } 7680 7681 boolean success = peer.requestFocus 7682 (this, temporary, focusedWindowChangeAllowed, time, cause); 7683 if (!success) { 7684 KeyboardFocusManager.getCurrentKeyboardFocusManager 7685 (appContext).dequeueKeyEvents(time, this); 7686 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7687 focusLog.finest("Peer request failed"); 7688 } 7689 } else { 7690 if (focusLog.isLoggable(PlatformLogger.FINEST)) { 7691 focusLog.finest("Pass for " + this); 7692 } 7693 } 7694 return success; 7695 } 7696 7697 private boolean isRequestFocusAccepted(boolean temporary, 7698 boolean focusedWindowChangeAllowed, 7699 CausedFocusEvent.Cause cause) 7700 { |