windowingmoduleimpl.java

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

/*
 * %W% %E%
 *
 * Copyright  1990-2006 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 */

package com.sun.jumpimpl.module.windowing;

import java.io.IOException;
import java.util.Map;
import java.util.Vector;
import java.util.NoSuchElementException;

import com.sun.jump.executive.JUMPExecutive;
import com.sun.jump.message.JUMPMessage;
import com.sun.jump.message.JUMPMessageSender;
import com.sun.jump.message.JUMPMessageHandler;
import com.sun.jump.message.JUMPMessageDispatcher;
import com.sun.jump.message.JUMPMessageDispatcherTypeException;
import com.sun.jump.command.JUMPIsolateLifecycleRequest;
import com.sun.jump.command.JUMPExecutiveWindowRequest;
import com.sun.jump.command.JUMPIsolateWindowRequest;
import com.sun.jump.command.JUMPResponse;
import com.sun.jump.module.windowing.JUMPWindowingModule;
import com.sun.jump.module.JUMPModule;
import com.sun.jump.common.JUMPIsolate;
import com.sun.jump.common.JUMPWindow;

import com.sun.jumpimpl.process.RequestSenderHelper;
import com.sun.jumpimpl.process.JUMPProcessProxyImpl;


class WindowingModuleImpl implements JUMPWindowingModule, JUMPMessageHandler {

    private final Object        lock = new Object();
    private Vector              windows;
    private RequestSenderHelper requestSender;
    private JUMPMessageSender   executiveMessageSender;


    private JUMPMessageSender
    getMessageSender(JUMPWindow window) {
        JUMPIsolate isolate = window.getIsolate();    
        if(isolate != null) {
            return (JUMPMessageSender)isolate;
        }
    
        return executiveMessageSender;
    }

    private void
    setForeground(JUMPWindow window, boolean notifyIsolate) {
        if(window == null) {
            throw new IllegalArgumentException();
        }

        WindowImpl oldFgWindow = (WindowImpl)getForeground();
        if(oldFgWindow != window && oldFgWindow != null) {
// FIXME: comment away by now. reason: directfb window manager takes care about
//        windows switching. The bad thing about this comment is that without
//        explicit setting window background GCI continues to eat VM's 
//        resources trying to handle user input and update screen
//            setBackground(oldFgWindow, notifyIsolate);
        }

        if(notifyIsolate) {
            JUMPResponse response =
                requestSender.sendRequest(
                    getMessageSender(window),
                    new JUMPExecutiveWindowRequest(
                        JUMPExecutiveWindowRequest.ID_FOREGROUND, window));
            if(!requestSender.handleBooleanResponse(response)) {
                return;
            }
        }

        synchronized(lock) {
            if(windows.contains(window)) {
                ((WindowImpl)window).setState(JUMPWindow.FOREGROUND_STATE);
                windows.remove(window);
                windows.add(window);
            }
        }
    }

    private void
    setBackground(JUMPWindow window, boolean notifyIsolate) {
        if(window == null) {
            throw new IllegalArgumentException();
        }

        if(notifyIsolate) {
            JUMPResponse response =
                requestSender.sendRequest(
                    getMessageSender(window),
                    new JUMPExecutiveWindowRequest(
                        JUMPExecutiveWindowRequest.ID_BACKGROUND, window));
            if(!requestSender.handleBooleanResponse(response)) {
                return;
            }
        }

        synchronized(lock) {
            if(windows.contains(window) && (windows.size() > 1)) {
                ((WindowImpl)window).setState(JUMPWindow.BACKGROUND_STATE);
            }
        }
    }


    WindowingModuleImpl() {
        // instantiate stuff that will track JUMPWindow-s 
        // created by presentation if any
        new WindowingExecutiveClient();

        JUMPExecutive   executive = JUMPExecutive.getInstance();
        int             isolateId = executive.getProcessId();

        windows                 = new Vector();
        requestSender           = new RequestSenderHelper(executive);
        executiveMessageSender  = 
            JUMPProcessProxyImpl.createProcessProxyImpl(
                executive.getProcessId());

        try {
            JUMPExecutive e = JUMPExecutive.getInstance();
            JUMPMessageDispatcher md = e.getMessageDispatcher();
            md.registerHandler(JUMPIsolateWindowRequest.MESSAGE_TYPE, this);
            md.registerHandler(JUMPIsolateLifecycleRequest.MESSAGE_TYPE, this);
        } catch (JUMPMessageDispatcherTypeException dte) {
            dte.printStackTrace();
            // FIXME: someone else listeneing -- what to do?
        } catch (IOException ex) {
            ex.printStackTrace();
            // FIXME: can't register, what to do?
        }
    }


    public void
    handleMessage(JUMPMessage message) {
        if(JUMPIsolateWindowRequest.MESSAGE_TYPE.equals(message.getType())) {
            JUMPIsolateWindowRequest cmd =
                (JUMPIsolateWindowRequest)
                    JUMPIsolateWindowRequest.fromMessage(message);

            WindowImpl window =
                WindowImpl.getWindow(cmd.getIsolateId(), cmd.getWindowId());

            synchronized(lock) {
                if(!windows.contains(window)) {
                    window.setState(JUMPWindow.BACKGROUND_STATE);
                    windows.add(0, window);
                }
            }

            if(JUMPIsolateWindowRequest.ID_NOTIFY_WINDOW_FOREGROUND.equals(
                cmd.getCommandId())) {

                setForeground(window, false);
                return;
            }
            
            if(JUMPIsolateWindowRequest.ID_NOTIFY_WINDOW_BACKGROUND.equals(
                cmd.getCommandId())) {

                setBackground(window, false);
                return;
            }
            return;
            
        }
        
        if(JUMPIsolateLifecycleRequest.MESSAGE_TYPE.equals(
            message.getType())) {

            JUMPIsolateLifecycleRequest cmd =
                (JUMPIsolateLifecycleRequest)
                    JUMPIsolateLifecycleRequest.fromMessage(message);

            if(JUMPIsolateLifecycleRequest.ID_ISOLATE_DESTROYED.equals(
                cmd.getCommandId())) {

                int isolateId = cmd.getIsolateId();

                synchronized(lock) {
                    // remove JUMPWindow-s hosted by the destroyed isolate
                    // from the list
                    int idx = 0;
                    while(idx != windows.size()) {
                        JUMPIsolate isolate = 
                            ((JUMPWindow)windows.elementAt(idx)).getIsolate();
                        if(isolate != null 
                        && isolate.getIsolateId() == isolateId) {
                            windows.remove(idx);
                            continue;
                        }
                        ++idx;
                    }

                    // enshure there is one foreground window
                    if(getForeground() == null) {
                        nextWindow();
                    }
                }
            }
        }
    }

    public void
    load(Map config) {
    }

    public void
    unload() {
    }

    public JUMPWindow[]
    getWindows() {
        synchronized(lock) {
            JUMPWindow[] res = new JUMPWindow[windows.size()];
            for(int i = 0; i != res.length; ++i) {
                res[i] = (JUMPWindow)windows.elementAt(i);
            }
            return res;
        }
    }

    public JUMPWindow
    getForeground() {
        try {
            synchronized(lock) {
                JUMPWindow res = (JUMPWindow)windows.lastElement();
                return
                    WindowImpl.FOREGROUND_STATE.equals(res.getState()) ?
                        res
                        : null;
            }
        } catch(NoSuchElementException e) {
            return null;
        }
    }

    public void
    setForeground(JUMPWindow window) {
        setForeground(window, true);
    }

    public void
    setBackground(JUMPWindow window) {
        setBackground(window, true);
    }

    public JUMPWindow
    nextWindow() {
        synchronized(lock) {
            JUMPWindow fg = null;
            for(int i = windows.size() - 2; i >= 0; --i) {
                fg = (JUMPWindow)windows.elementAt(i);
                setForeground(fg);
                if(fg == getForeground()) {
                    break;
                }
            }
            return fg;
        }
    }

    public JUMPWindow
    idToWindow(long id) {
        JUMPWindow res = null;
        synchronized(lock) {
            for(int i = 0, count = windows.size(); i != count; ++i) {
                if(((JUMPWindow)windows.elementAt(i)).getId() == id) {
                    break;
                }
            }
        }
        return res;
    }
}