public WPopupMenuPeer(PopupMenu target) { this.target = target; MenuContainer parent = null; boolean isTrayIconPopup = false; isTrayIconPopup = AWTAccessor.getPopupMenuAccessor().isTrayIconPopup(target); if (isTrayIconPopup) { parent = AWTAccessor.getMenuComponentAccessor().getParent(target); } else { parent = target.getParent(); } if (parent instanceof Component) { WComponentPeer parentPeer = (WComponentPeer) WToolkit.targetToPeer(parent); if (parentPeer == null) { // because the menu isn't a component (sigh) we first have to wait // for a failure to map the peer which should only happen for a // lightweight container, then find the actual native parent from // that component. parent = WToolkit.getNativeContainer((Component) parent); parentPeer = (WComponentPeer) WToolkit.targetToPeer(parent); } createMenu(parentPeer); // fix for 5088782: check if menu object is created successfully checkMenuCreation(); } else { throw new IllegalArgumentException("illegal popup menu container class"); } }
public LWWindowPeer( Window target, PlatformComponent platformComponent, PlatformWindow platformWindow, PeerType peerType) { super(target, platformComponent); this.platformWindow = platformWindow; this.peerType = peerType; Window owner = target.getOwner(); LWWindowPeer ownerPeer = owner == null ? null : (LWWindowPeer) AWTAccessor.getComponentAccessor().getPeer(owner); PlatformWindow ownerDelegate = (ownerPeer != null) ? ownerPeer.getPlatformWindow() : null; // The delegate.initialize() needs a non-null GC on X11. GraphicsConfiguration gc = getTarget().getGraphicsConfiguration(); synchronized (getStateLock()) { // graphicsConfig should be updated according to the real window // bounds when the window is shown, see 4868278 this.graphicsConfig = gc; } if (!target.isFontSet()) { target.setFont(DEFAULT_FONT); } if (!target.isBackgroundSet()) { target.setBackground(SystemColor.window); } else { // first we check if user provided alpha for background. This is // similar to what Apple's Java do. // Since JDK7 we should rely on setOpacity() only. // this.opacity = c.getAlpha(); } if (!target.isForegroundSet()) { target.setForeground(SystemColor.windowText); // we should not call setForeground because it will call a repaint // which the peer may not be ready to do yet. } platformWindow.initialize(target, this, ownerDelegate); // Init warning window(for applets) SecurityWarningWindow warn = null; if (target.getWarningString() != null) { // accessSystemTray permission allows to display TrayIcon, TrayIcon tooltip // and TrayIcon balloon windows without a warning window. if (!AWTAccessor.getWindowAccessor().isTrayIconWindow(target)) { LWToolkit toolkit = (LWToolkit) Toolkit.getDefaultToolkit(); warn = toolkit.createSecurityWarning(target, this); } } warningWindow = warn; }
// Fix for 4915454 - override the default implementation to avoid // loading SystemFlavorMap and associated classes. @Override public void setTransferHandler(TransferHandler newHandler) { TransferHandler oldHandler = (TransferHandler) getClientProperty( AWTAccessor.getClientPropertyKeyAccessor().getJComponent_TRANSFER_HANDLER()); putClientProperty( AWTAccessor.getClientPropertyKeyAccessor().getJComponent_TRANSFER_HANDLER(), newHandler); firePropertyChange("transferHandler", oldHandler, newHandler); }
/* * Retrieves the owner of the peer. * Note: this method returns the owner which can be activated, (i.e. the instance * of Frame or Dialog may be returned). */ static LWWindowPeer getOwnerFrameDialog(LWWindowPeer peer) { Window owner = (peer != null ? peer.getTarget().getOwner() : null); while (owner != null && !(owner instanceof Frame || owner instanceof Dialog)) { owner = owner.getOwner(); } return owner == null ? null : (LWWindowPeer) AWTAccessor.getComponentAccessor().getPeer(owner); }
void initTextField() { setVisible(target.isVisible()); setBounds(x, y, width, height, SET_BOUNDS); AWTAccessor.ComponentAccessor compAccessor = AWTAccessor.getComponentAccessor(); foreground = compAccessor.getForeground(target); if (foreground == null) foreground = SystemColor.textText; setForeground(foreground); background = compAccessor.getBackground(target); if (background == null) { if (((TextField) target).isEditable()) background = SystemColor.text; else background = SystemColor.control; } setBackground(background); if (!target.isBackgroundSet()) { // This is a way to set the background color of the TextArea // without calling setBackground - go through accessor compAccessor.setBackground(target, background); } if (!target.isForegroundSet()) { target.setForeground(SystemColor.textText); } setFont(font); }
XTextFieldPeer(TextField target) { super(target); text = target.getText(); xtext = new XAWTTextField(text, this, target.getParent()); xtext.getDocument().addDocumentListener(xtext); xtext.setCursor(target.getCursor()); XToolkit.specialPeerMap.put(xtext, this); initTextField(); setText(target.getText()); if (target.echoCharIsSet()) { setEchoChar(target.getEchoChar()); } else setEchoChar((char) 0); int start = target.getSelectionStart(); int end = target.getSelectionEnd(); // Fix for 5100200 // Restoring Motif behaviour // Since the end position of the selected text can be greater than the length of the text, // so we should set caret to max position of the text setCaretPosition(Math.min(end, text.length())); if (end > start) { // Should be called after setText() and setCaretPosition() select(start, end); } setEditable(target.isEditable()); // After this line we should not change the component's text firstChangeSkipped = true; AWTAccessor.getComponentAccessor().setPeer(xtext, this); }
public void addClient() { client = new Canvas() { public void paint(Graphics g) { super.paint(g); } }; client.setBackground(new Color(30, 220, 40)); clientCont.add(client); clientCont.validate(); final ComponentAccessor acc = AWTAccessor.getComponentAccessor(); WindowIDProvider pid = (WindowIDProvider) acc.getPeer(client); log.fine("Added XEmbed server(Canvas) with X window ID " + pid.getWindow()); Rectangle toFocusBounds = toFocus.getBounds(); toFocusBounds.setLocation(toFocus.getLocationOnScreen()); f.validate(); // KDE doesn't accept clicks on title as activation - click below title Rectangle fbounds = f.getBounds(); fbounds.y += f.getInsets().top; fbounds.height -= f.getInsets().top; Process proc = startClient( new Rectangle[] { fbounds, dummy.getBounds(), toFocusBounds, new Rectangle(b_modal.getLocationOnScreen(), b_modal.getSize()), new Rectangle(10, 130, 20, 20) }, pid.getWindow()); new ClientWatcher(client, proc, clientCont).start(); }
@SuppressWarnings("deprecation") public CPlatformWindow convertJComponentToTarget(final JRootPane p) { Component root = SwingUtilities.getRoot(p); final ComponentAccessor acc = AWTAccessor.getComponentAccessor(); if (root == null || acc.getPeer(root) == null) return null; return (CPlatformWindow) ((LWWindowPeer) acc.getPeer(root)).getPlatformWindow(); }
@Override public boolean updateGraphicsData(GraphicsConfiguration gc) { boolean result = super.updateGraphicsData(gc); Rectangle bounds = AWTAccessor.getFrameAccessor().getMaximizedBounds((Frame) target); if (bounds != null) { setMaximizedBounds(bounds); } return result; }
@Override public void blockWindows(List<Window> windows) { // TODO: LWX will probably need some collectJavaToplevels to speed this up for (Window w : windows) { WindowPeer wp = (WindowPeer) AWTAccessor.getComponentAccessor().getPeer(w); if (wp != null) { wp.setModalBlocked((Dialog) getTarget(), true); } } }
@Override public void print(Graphics g) { // We assume we print the whole frame, // so we expect no clip was set previously Shape shape = AWTAccessor.getWindowAccessor().getShape((Window) target); if (shape != null) { g.setClip(shape); } super.print(g); }
private void postWindowStateChangedEvent(int newWindowState) { if (getTarget() instanceof Frame) { AWTAccessor.getFrameAccessor().setExtendedState((Frame) getTarget(), newWindowState); } WindowEvent stateChangedEvent = new WindowEvent(getTarget(), WindowEvent.WINDOW_STATE_CHANGED, windowState, newWindowState); postEvent(stateChangedEvent); windowState = newWindowState; updateSecurityWarningVisibility(); }
@Override public void repositionSecurityWarning() { if (warningWindow != null) { AWTAccessor.ComponentAccessor compAccessor = AWTAccessor.getComponentAccessor(); Window target = getTarget(); int x = compAccessor.getX(target); int y = compAccessor.getY(target); int width = compAccessor.getWidth(target); int height = compAccessor.getHeight(target); warningWindow.reposition(x, y, width, height); } }
XAWTTextField(String text, XComponentPeer xwin, Container parent) { super(text); this.xwin = xwin; setDoubleBuffered(true); setFocusable(false); AWTAccessor.getComponentAccessor().setParent(this, parent); setBackground(xwin.getPeerBackground()); setForeground(xwin.getPeerForeground()); setFont(xwin.getPeerFont()); setCaretPosition(0); addActionListener(this); addNotify(); }
@Override public void setModalBlocked(Dialog blocker, boolean blocked) { synchronized (getPeerTreeLock()) { ComponentPeer peer = AWTAccessor.getComponentAccessor().getPeer(blocker); if (blocked && (peer instanceof LWWindowPeer)) { this.blocker = (LWWindowPeer) peer; } else { this.blocker = null; } } platformWindow.setModalBlocked(blocked); }
@Override // PlatformWindow public void toFront() { final long nsWindowPtr = getNSWindowPtr(); LWCToolkit lwcToolkit = (LWCToolkit) Toolkit.getDefaultToolkit(); Window w = DefaultKeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); final ComponentAccessor acc = AWTAccessor.getComponentAccessor(); if (w != null && acc.getPeer(w) != null && ((LWWindowPeer) acc.getPeer(w)).getPeerType() == LWWindowPeer.PeerType.EMBEDDED_FRAME && !lwcToolkit.isApplicationActive()) { lwcToolkit.activateApplicationIgnoringOtherApps(); } updateFocusabilityForAutoRequestFocus(false); nativePushNSWindowToFront(nsWindowPtr); updateFocusabilityForAutoRequestFocus(true); }
/** * Sets a specified <code>Component</code> to be the glass pane for this root pane. The glass pane * should normally be a lightweight, transparent component, because it will be made visible when * ever the root pane needs to grab input events. * * <p>The new glass pane's visibility is changed to match that of the current glass pane. An * implication of this is that care must be taken when you want to replace the glass pane and make * it visible. Either of the following will work: * * <pre> * root.setGlassPane(newGlassPane); * newGlassPane.setVisible(true); * </pre> * * or: * * <pre> * root.getGlassPane().setVisible(true); * root.setGlassPane(newGlassPane); * </pre> * * @param glass the <code>Component</code> to use as the glass pane for this <code>JRootPane * </code> * @exception NullPointerException if the <code>glass</code> parameter is <code>null</code> */ public void setGlassPane(Component glass) { if (glass == null) { throw new NullPointerException("glassPane cannot be set to null."); } AWTAccessor.getComponentAccessor().setMixingCutoutShape(glass, new Rectangle()); boolean visible = false; if (glassPane != null && glassPane.getParent() == this) { this.remove(glassPane); visible = glassPane.isVisible(); } glass.setVisible(visible); glassPane = glass; this.add(glassPane, 0); if (visible) { repaint(); } }
public void updateGC() { int scrn = getScreenImOn(); if (screenLog.isLoggable(PlatformLogger.Level.FINER)) { log.finer("Screen number: " + scrn); } // get current GD Win32GraphicsDevice oldDev = (Win32GraphicsDevice) winGraphicsConfig.getDevice(); Win32GraphicsDevice newDev; GraphicsDevice devs[] = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices(); // Occasionally during device addition/removal getScreenImOn can return // a non-existing screen number. Use the default device in this case. if (scrn >= devs.length) { newDev = (Win32GraphicsDevice) GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); } else { newDev = (Win32GraphicsDevice) devs[scrn]; } // Set winGraphicsConfig to the default GC for the monitor this Window // is now mostly on. winGraphicsConfig = (Win32GraphicsConfig) newDev.getDefaultConfiguration(); if (screenLog.isLoggable(PlatformLogger.Level.FINE)) { if (winGraphicsConfig == null) { screenLog.fine("Assertion (winGraphicsConfig != null) failed"); } } // if on a different display, take off old GD and put on new GD if (oldDev != newDev) { oldDev.removeDisplayChangedListener(this); newDev.addDisplayChangedListener(this); } AWTAccessor.getComponentAccessor() .setGraphicsConfiguration((Component) target, winGraphicsConfig); }
/* * Called by the delegate when a key is pressed. */ @Override public void notifyKeyEvent( int id, long when, int modifiers, int keyCode, char keyChar, int keyLocation) { LWKeyboardFocusManagerPeer kfmPeer = LWKeyboardFocusManagerPeer.getInstance(); Component focusOwner = kfmPeer.getCurrentFocusOwner(); if (focusOwner == null) { focusOwner = kfmPeer.getCurrentFocusedWindow(); if (focusOwner == null) { focusOwner = this.getTarget(); } } KeyEvent keyEvent = new KeyEvent(focusOwner, id, when, modifiers, keyCode, keyChar, keyLocation); AWTAccessor.getKeyEventAccessor() .setExtendedKeyCode( keyEvent, (keyChar == KeyEvent.CHAR_UNDEFINED) ? keyCode : ExtendedKeyCodes.getExtendedKeyCodeForChar(keyChar)); postEvent(keyEvent); }
protected void startDrag(Transferable transferable, long[] formats, Map formatMap) { Component component = getTrigger().getComponent(); Component c = null; XWindowPeer wpeer = null; for (c = component; c != null && !(c instanceof Window); c = AWTAccessor.getComponentAccessor().getParent(c)) ; if (c instanceof Window) { wpeer = (XWindowPeer) c.getPeer(); } if (wpeer == null) { throw new InvalidDnDOperationException("Cannot find top-level for the drag source component"); } long xcursor = 0; long rootWindow = 0; long dragWindow = 0; long timeStamp = 0; /* Retrieve the X cursor for the drag operation. */ { Cursor cursor = getCursor(); if (cursor != null) { xcursor = XGlobalCursorManager.getCursor(cursor); } } XToolkit.awtLock(); try { if (proxyModeSourceWindow != 0) { throw new InvalidDnDOperationException("Proxy drag in progress"); } if (dndInProgress) { throw new InvalidDnDOperationException("Drag in progress"); } /* Determine the root window for the drag operation. */ { long screen = XlibWrapper.XScreenNumberOfScreen(wpeer.getScreen()); rootWindow = XlibWrapper.RootWindow(XToolkit.getDisplay(), screen); } dragWindow = XWindow.getXAWTRootWindow().getWindow(); timeStamp = XToolkit.getCurrentServerTime(); int dropActions = getDragSourceContext().getSourceActions(); Iterator dragProtocols = XDragAndDropProtocols.getDragSourceProtocols(); while (dragProtocols.hasNext()) { XDragSourceProtocol dragProtocol = (XDragSourceProtocol) dragProtocols.next(); try { dragProtocol.initializeDrag( dropActions, transferable, formatMap, formats); } catch (XException xe) { throw (InvalidDnDOperationException) new InvalidDnDOperationException().initCause(xe); } } /* Install X grabs. */ { int status; XWindowAttributes wattr = new XWindowAttributes(); try { status = XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(), rootWindow, wattr.pData); if (status == 0) { throw new InvalidDnDOperationException("XGetWindowAttributes failed"); } rootEventMask = wattr.get_your_event_mask(); XlibWrapper.XSelectInput( XToolkit.getDisplay(), rootWindow, rootEventMask | ROOT_EVENT_MASK); } finally { wattr.dispose(); } XBaseWindow.ungrabInput(); status = XlibWrapper.XGrabPointer( XToolkit.getDisplay(), rootWindow, 0, GRAB_EVENT_MASK, XConstants.GrabModeAsync, XConstants.GrabModeAsync, XConstants.None, xcursor, timeStamp); if (status != XConstants.GrabSuccess) { cleanup(timeStamp); throwGrabFailureException("Cannot grab pointer", status); return; } status = XlibWrapper.XGrabKeyboard( XToolkit.getDisplay(), rootWindow, 0, XConstants.GrabModeAsync, XConstants.GrabModeAsync, timeStamp); if (status != XConstants.GrabSuccess) { cleanup(timeStamp); throwGrabFailureException("Cannot grab keyboard", status); return; } } /* Update the global state. */ dndInProgress = true; dragInProgress = true; dragRootWindow = rootWindow; sourceActions = dropActions; sourceFormats = formats; } finally { XToolkit.awtUnlock(); } /* This implementation doesn't use native context */ setNativeContext(0); SunDropTargetContextPeer.setCurrentJVMLocalSourceTransferable(transferable); }
@Override // PlatformWindow public void setVisible(boolean visible) { final long nsWindowPtr = getNSWindowPtr(); // Configure stuff updateIconImages(); updateFocusabilityForAutoRequestFocus(false); boolean wasMaximized = isMaximized(); if (visible && target.isLocationByPlatform()) { nativeSetNSWindowLocationByPlatform(getNSWindowPtr()); } // Actually show or hide the window LWWindowPeer blocker = (peer == null) ? null : peer.getBlocker(); if (blocker == null || !visible) { // If it ain't blocked, or is being hidden, go regular way if (visible) { CWrapper.NSWindow.makeFirstResponder(nsWindowPtr, contentView.getAWTView()); boolean isPopup = (target.getType() == Window.Type.POPUP); if (isPopup) { // Popups in applets don't activate applet's process CWrapper.NSWindow.orderFrontRegardless(nsWindowPtr); } else { CWrapper.NSWindow.orderFront(nsWindowPtr); } boolean isKeyWindow = CWrapper.NSWindow.isKeyWindow(nsWindowPtr); if (!isKeyWindow) { CWrapper.NSWindow.makeKeyWindow(nsWindowPtr); } } else { // immediately hide the window CWrapper.NSWindow.orderOut(nsWindowPtr); // process the close CWrapper.NSWindow.close(nsWindowPtr); } } else { // otherwise, put it in a proper z-order CWrapper.NSWindow.orderWindow( nsWindowPtr, CWrapper.NSWindow.NSWindowBelow, ((CPlatformWindow) blocker.getPlatformWindow()).getNSWindowPtr()); } this.visible = visible; // Manage the extended state when showing if (visible) { // Apply the extended state as expected in shared code if (target instanceof Frame) { if (!wasMaximized && isMaximized()) { // setVisible could have changed the native maximized state deliverZoom(true); } else { int frameState = ((Frame) target).getExtendedState(); if ((frameState & Frame.ICONIFIED) != 0) { // Treat all state bit masks with ICONIFIED bit as ICONIFIED state. frameState = Frame.ICONIFIED; } switch (frameState) { case Frame.ICONIFIED: CWrapper.NSWindow.miniaturize(nsWindowPtr); break; case Frame.MAXIMIZED_BOTH: maximize(); break; default: // NORMAL unmaximize(); // in case it was maximized, otherwise this is a no-op break; } } } } nativeSynthesizeMouseEnteredExitedEvents(); // Configure stuff #2 updateFocusabilityForAutoRequestFocus(true); // Manage parent-child relationship when showing final ComponentAccessor acc = AWTAccessor.getComponentAccessor(); if (visible) { // Order myself above my parent if (owner != null && owner.isVisible()) { CWrapper.NSWindow.orderWindow( nsWindowPtr, CWrapper.NSWindow.NSWindowAbove, owner.getNSWindowPtr()); applyWindowLevel(target); } // Order my own children above myself for (Window w : target.getOwnedWindows()) { final Object p = acc.getPeer(w); if (p instanceof LWWindowPeer) { CPlatformWindow pw = (CPlatformWindow) ((LWWindowPeer) p).getPlatformWindow(); if (pw != null && pw.isVisible()) { CWrapper.NSWindow.orderWindow( pw.getNSWindowPtr(), CWrapper.NSWindow.NSWindowAbove, nsWindowPtr); pw.applyWindowLevel(w); } } } } // Deal with the blocker of the window being shown if (blocker != null && visible) { // Make sure the blocker is above its siblings ((CPlatformWindow) blocker.getPlatformWindow()).orderAboveSiblings(); } }
/** * Execute applet events. Here is the state transition diagram * * <pre>{@literal * Note: (XXX) is the action * APPLET_XXX is the state * (applet code loaded) --> APPLET_LOAD -- (applet init called)--> APPLET_INIT -- * (applet start called) --> APPLET_START -- (applet stop called) --> APPLET_STOP -- * (applet destroyed called) --> APPLET_DESTROY --> (applet gets disposed) --> * APPLET_DISPOSE --> ... * }</pre> * * In the legacy lifecycle model. The applet gets loaded, inited and started. So it stays in the * APPLET_START state unless the applet goes away(refresh page or leave the page). So the applet * stop method called and the applet enters APPLET_STOP state. Then if the applet is revisited, it * will call applet start method and enter the APPLET_START state and stay there. * * <p>In the modern lifecycle model. When the applet first time visited, it is same as legacy * lifecycle model. However, when the applet page goes away. It calls applet stop method and * enters APPLET_STOP state and then applet destroyed method gets called and enters APPLET_DESTROY * state. * * <p>This code is also called by AppletViewer. In AppletViewer "Restart" menu, the applet is jump * from APPLET_STOP to APPLET_DESTROY and to APPLET_INIT . * * <p>Also, the applet can jump from APPLET_INIT state to APPLET_DESTROY (in Netscape/Mozilla * case). Same as APPLET_LOAD to APPLET_DISPOSE since all of this are triggered by browser. */ @Override public void run() { Thread curThread = Thread.currentThread(); if (curThread == loaderThread) { // if we are in the loader thread, cause // loading to occur. We may exit this with // status being APPLET_DISPOSE, APPLET_ERROR, // or APPLET_LOAD runLoader(); return; } boolean disposed = false; while (!disposed && !curThread.isInterrupted()) { AppletEvent evt; try { evt = getNextEvent(); } catch (InterruptedException e) { showAppletStatus("bail"); return; } // showAppletStatus("EVENT = " + evt.getID()); try { switch (evt.getID()) { case APPLET_LOAD: if (!okToLoad()) { break; } // This complexity allows loading of applets to be // interruptable. The actual thread loading runs // in a separate thread, so it can be interrupted // without harming the applet thread. // So that we don't have to worry about // concurrency issues, the main applet thread waits // until the loader thread terminates. // (one way or another). if (loaderThread == null) { setLoaderThread(new Thread(null, this, "AppletLoader", 0, false)); loaderThread.start(); // we get to go to sleep while this runs loaderThread.join(); setLoaderThread(null); } else { // REMIND: issue an error -- this case should never // occur. } break; case APPLET_INIT: // AppletViewer "Restart" will jump from destroy method to // init, that is why we need to check status w/ APPLET_DESTROY if (status != APPLET_LOAD && status != APPLET_DESTROY) { showAppletStatus("notloaded"); break; } applet.resize(defaultAppletSize); if (PerformanceLogger.loggingEnabled()) { PerformanceLogger.setTime("Applet Init"); PerformanceLogger.outputLog(); } applet.init(); // Need the default(fallback) font to be created in this AppContext Font f = getFont(); if (f == null || "dialog".equals(f.getFamily().toLowerCase(Locale.ENGLISH)) && f.getSize() == 12 && f.getStyle() == Font.PLAIN) { setFont(new Font(Font.DIALOG, Font.PLAIN, 12)); } // Validate the applet in event dispatch thread // to avoid deadlock. try { final AppletPanel p = this; Runnable r = new Runnable() { @Override public void run() { p.validate(); } }; AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r); } catch (InterruptedException ie) { } catch (InvocationTargetException ite) { } status = APPLET_INIT; showAppletStatus("inited"); break; case APPLET_START: { if (status != APPLET_INIT && status != APPLET_STOP) { showAppletStatus("notinited"); break; } applet.resize(currentAppletSize); applet.start(); // Validate and show the applet in event dispatch thread // to avoid deadlock. try { final AppletPanel p = this; final Applet a = applet; Runnable r = new Runnable() { @Override public void run() { p.validate(); a.setVisible(true); // Fix for BugTraq ID 4041703. // Set the default focus for an applet. if (hasInitialFocus()) { setDefaultFocus(); } } }; AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r); } catch (InterruptedException ie) { } catch (InvocationTargetException ite) { } status = APPLET_START; showAppletStatus("started"); break; } case APPLET_STOP: if (status != APPLET_START) { showAppletStatus("notstarted"); break; } status = APPLET_STOP; // Hide the applet in event dispatch thread // to avoid deadlock. try { final Applet a = applet; Runnable r = new Runnable() { @Override public void run() { a.setVisible(false); } }; AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r); } catch (InterruptedException ie) { } catch (InvocationTargetException ite) { } // During Applet.stop(), any AccessControlException on an involved Class remains in // the "memory" of the AppletClassLoader. If the same instance of the ClassLoader is // reused, the same exception will occur during class loading. Set the // AppletClassLoader's // exceptionStatusSet flag to allow recognition of what had happened // when reusing AppletClassLoader object. try { applet.stop(); } catch (java.security.AccessControlException e) { setExceptionStatus(e); // rethrow exception to be handled as it normally would be. throw e; } showAppletStatus("stopped"); break; case APPLET_DESTROY: if (status != APPLET_STOP && status != APPLET_INIT) { showAppletStatus("notstopped"); break; } status = APPLET_DESTROY; // During Applet.destroy(), any AccessControlException on an involved Class remains in // the "memory" of the AppletClassLoader. If the same instance of the ClassLoader is // reused, the same exception will occur during class loading. Set the // AppletClassLoader's // exceptionStatusSet flag to allow recognition of what had happened // when reusing AppletClassLoader object. try { applet.destroy(); } catch (java.security.AccessControlException e) { setExceptionStatus(e); // rethrow exception to be handled as it normally would be. throw e; } showAppletStatus("destroyed"); break; case APPLET_DISPOSE: if (status != APPLET_DESTROY && status != APPLET_LOAD) { showAppletStatus("notdestroyed"); break; } status = APPLET_DISPOSE; try { final Applet a = applet; Runnable r = new Runnable() { @Override public void run() { remove(a); } }; AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r); } catch (InterruptedException ie) { } catch (InvocationTargetException ite) { } applet = null; showAppletStatus("disposed"); disposed = true; break; case APPLET_QUIT: return; } } catch (Exception e) { status = APPLET_ERROR; if (e.getMessage() != null) { showAppletStatus("exception2", e.getClass().getName(), e.getMessage()); } else { showAppletStatus("exception", e.getClass().getName()); } showAppletException(e); } catch (ThreadDeath e) { showAppletStatus("death"); return; } catch (Error e) { status = APPLET_ERROR; if (e.getMessage() != null) { showAppletStatus("error2", e.getClass().getName(), e.getMessage()); } else { showAppletStatus("error", e.getClass().getName()); } showAppletException(e); } clearLoadAbortRequest(); } }
// sync target and peer public void setExtendedState(int state) { AWTAccessor.getFrameAccessor().setExtendedState((Frame) target, state); }
public int getExtendedState() { return AWTAccessor.getFrameAccessor().getExtendedState((Frame) target); }
@Override void handleJavaKeyEvent(KeyEvent e) { AWTAccessor.getComponentAccessor().processEvent(xtext, e); }
private void dragFrameFaster(JComponent f, int newX, int newY) { Rectangle previousBounds = new Rectangle(currentBounds.x, currentBounds.y, currentBounds.width, currentBounds.height); // move the frame currentBounds.x = newX; currentBounds.y = newY; if (didDrag) { // Only initiate cleanup if we have actually done a drag. emergencyCleanup(f); } else { didDrag = true; // We reset the danger field as until now we haven't actually // moved the internal frame so we don't need to initiate repaint. ((JInternalFrame) f).danger = false; } boolean floaterCollision = isFloaterCollision(previousBounds, currentBounds); // System.out.println(previousBounds); JComponent parent = (JComponent) f.getParent(); Rectangle visBounds = previousBounds.intersection(desktopBounds); // System.out.println(previousBounds); // System.out.println(visBounds); RepaintManager currentManager = RepaintManager.currentManager(f); currentManager.beginPaint(); try { if (!floaterCollision) { currentManager.copyArea( parent, desktopGraphics, visBounds.x, visBounds.y, visBounds.width, visBounds.height, newX - previousBounds.x, newY - previousBounds.y, true); } f.setBounds(currentBounds); if (floaterCollision) { // since we couldn't blit we just redraw as fast as possible // the isDragging mucking is to avoid activating emergency // cleanup ((JInternalFrame) f).isDragging = false; parent.paintImmediately(currentBounds); ((JInternalFrame) f).isDragging = true; } // fake out the repaint manager. We'll take care of everything currentManager.markCompletelyClean(parent); currentManager.markCompletelyClean(f); // compute the minimal newly exposed area // if the rects intersect then we use computeDifference. Otherwise // we'll repaint the entire previous bounds Rectangle[] dirtyRects = null; if (previousBounds.intersects(currentBounds)) { dirtyRects = SwingUtilities.computeDifference(previousBounds, currentBounds); } else { dirtyRects = new Rectangle[1]; dirtyRects[0] = previousBounds; // System.out.println("no intersection"); } ; // Fix the damage for (int i = 0; i < dirtyRects.length; i++) { parent.paintImmediately(dirtyRects[i]); } // new areas of blit were exposed if (!(visBounds.equals(previousBounds))) { dirtyRects = SwingUtilities.computeDifference(previousBounds, desktopBounds); for (int i = 0; i < dirtyRects.length; i++) { dirtyRects[i].x += newX - previousBounds.x; dirtyRects[i].y += newY - previousBounds.y; ((JInternalFrame) f).isDragging = false; parent.paintImmediately(dirtyRects[i]); ((JInternalFrame) f).isDragging = true; // System.out.println(dirtyRects[i]); } } } finally { currentManager.endPaint(); } // update window if it's non-opaque Window topLevel = SwingUtilities.getWindowAncestor(f); Toolkit tk = Toolkit.getDefaultToolkit(); if (!AWTAccessor.getWindowAccessor().isOpaque(topLevel) && (tk instanceof SunToolkit) && ((SunToolkit) tk).needUpdateWindow()) { AWTAccessor.getWindowAccessor().updateWindow(topLevel); } }
// NOTE: This method may be called by privileged threads. // DO NOT INVOKE CLIENT CODE ON THIS THREAD! public void handleResize(Rectangle bounds) { AWTAccessor.getComponentAccessor().setSize((Component) target, bounds.width, bounds.height); postEvent(new ComponentEvent(target, ComponentEvent.COMPONENT_RESIZED)); }
/* * Requests platform to set native focus on a frame/dialog. * In case of a simple window, triggers appropriate java focus change. */ public boolean requestWindowFocus(CausedFocusEvent.Cause cause) { if (focusLog.isLoggable(PlatformLogger.Level.FINE)) { focusLog.fine("requesting native focus to " + this); } if (!focusAllowedFor()) { focusLog.fine("focus is not allowed"); return false; } // if (platformWindow.rejectFocusRequest(cause)) { // return false; // } AppContext targetAppContext = AWTAccessor.getComponentAccessor().getAppContext(getTarget()); KeyboardFocusManager kfm = AWTAccessor.getKeyboardFocusManagerAccessor() .getCurrentKeyboardFocusManager(targetAppContext); Window currentActive = kfm.getActiveWindow(); Window opposite = LWKeyboardFocusManagerPeer.getInstance().getCurrentFocusedWindow(); // Make the owner active window. if (isSimpleWindow()) { focusLog.fine("This is a Simple Window."); LWWindowPeer owner = getOwnerFrameDialog(this); // If owner is not natively active, request native // activation on it w/o sending events up to java. if (owner != null && !owner.platformWindow.isActive()) { if (focusLog.isLoggable(PlatformLogger.Level.FINE)) { focusLog.fine("requesting native focus to the owner " + owner); } LWWindowPeer currentActivePeer = currentActive == null ? null : (LWWindowPeer) AWTAccessor.getComponentAccessor().getPeer(currentActive); // Ensure the opposite is natively active and suppress sending events. if (currentActivePeer != null && currentActivePeer.platformWindow.isActive()) { if (focusLog.isLoggable(PlatformLogger.Level.FINE)) { focusLog.fine("the opposite is " + currentActivePeer); } currentActivePeer.skipNextFocusChange = true; } owner.skipNextFocusChange = true; owner.platformWindow.requestWindowFocus(); } // DKFM will synthesize all the focus/activation events correctly. changeFocusedWindow(true, opposite); focusLog.fine("DKFM will synthesize all the focus/activation events correctly"); return true; // In case the toplevel is active but not focused, change focus directly, // as requesting native focus on it will not have effect. } else if (getTarget() == currentActive && !getTarget().hasFocus()) { changeFocusedWindow(true, opposite); focusLog.fine("toplevel is active but not focused, change focus directly"); return true; } focusLog.fine("platformWindow.requestWindowFocus()"); return platformWindow.requestWindowFocus(); }