src/plugins/emulator/src/com/motorola/studio/android/emulator/ui/controls/nativewindow/NativeWindowComposite.java

/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.motorola.studio.android.emulator.ui.controls.nativewindow;

import static com.motorola.studio.android.common.log.StudioLogger.error;
import static com.motorola.studio.android.common.log.StudioLogger.info;

import java.util.Timer;
import java.util.TimerTask;

import org.eclipse.core.runtime.Platform;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;

import com.motorola.studio.android.AndroidPlugin;
import com.motorola.studio.android.adt.DDMSFacade;
import com.motorola.studio.android.common.preferences.DialogWithToggleUtils;
import com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance;
import com.motorola.studio.android.emulator.core.model.IInputLogic;
import com.motorola.studio.android.emulator.core.skin.IAndroidSkin;
import com.motorola.studio.android.emulator.core.utils.TelnetAndroidInput;
import com.motorola.studio.android.emulator.i18n.EmulatorNLS;
import com.motorola.studio.android.emulator.logic.AndroidLogicUtils;
import com.motorola.studio.android.emulator.ui.controls.IAndroidComposite;
import com.motorola.studio.android.nativeos.NativeUIUtils;

public class NativeWindowComposite extends ScrolledComposite implements IAndroidComposite
{
    /**
     * Preference key of the Question Dialog about changing zoom
     * 
     */
    private static String LOOSE_ORIGINAL_SCALE_KEY_PREFERENCE = "loose.original.scale";

    //Constants
    private static final double MINIMUM_ZOOM_FACTOR = 0.10;

    private static final double ZOOM_FIT = 0.0;

    private Composite contentComposite;

    private IAndroidEmulatorInstance androidInstance;

    private long windowHandle;

    private long originalParentHandle;

    private long windowProperties;

    private Point windowSize;

    private Point nativeWindowSize;

    private NativeWindowMonitor nativeWindowMonitor;

    protected boolean resizing;

    private boolean isFitToWindow;

    private double zoomFactor = 0.99;

    private double fitZoomFactor = ZOOM_FIT;

    private boolean forceNativeWindowSizeUpdate;

    private boolean isOriginalScale;

    private boolean zoomLocked;

    private class NativeWindowMonitor extends Timer
    {
        private Timer timer;

        private MonitorTask monitorTask;

        public NativeWindowMonitor(long interval)
        {
            timer = new Timer();
            monitorTask = new MonitorTask();
            timer.schedule(monitorTask, interval, interval);
        }

        private class MonitorTask extends TimerTask
        {
            @Override
            public void run()
            {
                Point newWindowSize =
                        NativeUIUtils.getWindowSize(originalParentHandle, windowHandle);
                if ((windowHandle <= 0) || !newWindowSize.equals(windowSize))
                {
                    Display display = Display.getDefault();
                    if (!display.isDisposed())
                    {
                        try
                        {
                            display.syncExec(new Runnable()
                            {
                                public void run()
                                {
                                    updateContentComposite();
                                }
                            });
                        }
                        catch (SWTException e)
                        {
                            //Do nothing in case the widget is disposed, occurs when the tool is closing.
                        }
                    }
                }

                if (NativeUIUtils.isWindowEnabled(windowHandle))
                {
                    Display display = Display.getDefault();
                    if (!display.isDisposed())
                    {
                        try
                        {
                            display.syncExec(new Runnable()
                            {
                                public void run()
                                {
                                    if (!contentComposite.isDisposed())
                                    {
                                        contentComposite.forceFocus();
                                    }
                                }
                            });
                        }
                        catch (SWTException e)
                        {
                            //Do nothing in case the widget is disposed, occurs when the tool is closing.
                        }
                    }
                }
            }
        }

        public void stopMonitoring()
        {
            timer.cancel();
            timer = null;
            monitorTask = null;
        }
    }

    public NativeWindowComposite(Composite parent, IAndroidSkin androidSkin,
            final IAndroidEmulatorInstance instance)
    {
        super(parent, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);

        info("Creating Native Window Composite for " + instance.getName());

        getVerticalBar().setEnabled(true);
        getHorizontalBar().setEnabled(true);
        this.setLayout(new FillLayout());

        androidInstance = instance;

        nativeWindowMonitor = new NativeWindowMonitor(500);

        addControlListener(new ControlAdapter()
        {
            final boolean[] running = new boolean[1];

            /*
             * (non-Javadoc)
             * @see org.eclipse.swt.events.ControlAdapter#controlResized(org.eclipse.swt.events.ControlEvent)
             */
            @Override
            public void controlResized(ControlEvent event)
            {
                if (isFitToWindow)
                {
                    try
                    {
                        Thread.sleep(200);
                    }
                    catch (InterruptedException e)
                    {
                        //do nothing
                    }

                    if (running[0])
                    {
                        return;
                    }
                    running[0] = true;
                    Display.getCurrent().asyncExec(new Runnable()
                    {
                        public void run()
                        {
                            running[0] = false;
                            if (!getShell().isDisposed())
                            {
                                calculateFitZoomFactor(forceNativeWindowSizeUpdate);
                                applyZoomFactor();
                            }

                        }
                    });
                }
            }
        });

        createContentComposite(instance);
        info("Created Native Window Composite for " + instance.getName());
    }

    /**
     * Creates the content composite that will be parent of emulator native window
     * 
     * @param instance A android instance from which the composite could be retrieved if it is already created
     */
    public void createContentComposite(IAndroidEmulatorInstance instance)
    {
        contentComposite = instance.getComposite();
        if (contentComposite != null)
        {
            info("Instance already has a composite");
            contentComposite.setParent(this);
            contentComposite.setVisible(true);
        }
        else
        {
            contentComposite = new Composite(this, SWT.EMBEDDED | SWT.NO_BACKGROUND);
        }

        this.setContent(contentComposite);
        if (instance.getProperties().getProperty("Command_Line").contains("-scale"))
        {
            isOriginalScale = true;
        }

        //Force to update native window size at 100% when first using nativeWindowSize field
        forceNativeWindowSizeUpdate = true;

        //Avoid perform apply zoom factor when creating composite 
        zoomLocked = true;
        draw();
    }

    /**
     * Changes the parent from OS to content composite keeping the original properties and parent window reference
     */
    private void draw()
    {
        if (contentComposite != null)
        {
            windowHandle = androidInstance.getWindowHandle();

            //If the instance does not contain the window handle, it should be retrieved 
            //from native emulator window and assigned to instance
            if (windowHandle <= 0)
            {
                int port =
                        AndroidLogicUtils.getEmulatorPort(DDMSFacade
                                .getSerialNumberByName(androidInstance.getName()));
                windowHandle = NativeUIUtils.getWindowHandle(androidInstance.getName(), port);

                androidInstance.setWindowHandle(windowHandle);
            }

            if ((windowProperties <= 0) && (windowHandle > 0))
            {
                windowProperties = NativeUIUtils.getWindowProperties(windowHandle);
                info("Native Window Properties:" + windowProperties);
            }

            //Set Window Style
            if (windowHandle > 0)
            {
                NativeUIUtils.setWindowStyle(windowHandle);
            }

            if (originalParentHandle <= 0)
            {
                originalParentHandle = windowHandle;
            }

            //Retrieve window size before changing parent
            if (windowHandle > 0)
            {
                windowSize = NativeUIUtils.getWindowSize(originalParentHandle, windowHandle);
            }

            //Set the new Parent and store the original parent            
            if ((originalParentHandle <= 0) || (originalParentHandle == windowHandle))
            {
                if (windowHandle > 0)
                {
                    originalParentHandle =
                            NativeUIUtils.embedWindow(windowHandle, contentComposite);
                    info("Native Window Parent:" + originalParentHandle);
                }
            }
            else
            {
                NativeUIUtils.embedWindow(windowHandle, contentComposite);
            }

            if (windowSize == null)
            {
                windowSize = new Point(700, 500);
            }

            //Update composite size
            contentComposite
                    .setSize(contentComposite.computeSize(windowSize.x, windowSize.y, true));
            contentComposite.redraw();
            this.update();

            this.setMinSize(contentComposite.computeSize(windowSize.x, windowSize.y));
            this.layout();
        }
        else
        {
            createContentComposite(androidInstance);
        }
    }

    public void changeToNextLayout()
    {
        contentComposite.setVisible(false);

        contentComposite.setLocation(0, 0);

        NativeUIUtils.sendNextLayoutCommand(originalParentHandle, windowHandle);

        updateContentComposite();

        forceNativeWindowSizeUpdate = true;
        if (isFitToWindow)
        {
            //Force update to fit zoom factor
            setZoomFactor(ZOOM_FIT);
        }
        applyZoomFactor();

        try
        {
            Thread.sleep(200);
        }
        catch (InterruptedException e)
        {
            //do nothing
        }

        contentComposite.setVisible(true);
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.swt.widgets.Widget#dispose()
     */
    @Override
    public void dispose()
    {
        info("Disposing Native Window Composite");
        if (nativeWindowMonitor != null)
        {
            nativeWindowMonitor.stopMonitoring();
            nativeWindowMonitor = null;
            info("Disposed Native Window Monitor");
        }
        if (windowHandle > 0)
        {
            info("Restoring original properties for window: " + windowHandle);
            NativeUIUtils.setWindowProperties(windowHandle, windowProperties);

            boolean shallUnembed =
                    AndroidPlugin.getDefault().getPreferenceStore()
                            .getBoolean(AndroidPlugin.SHALL_UNEMBED_EMULATORS_PREF_KEY);
            if ((originalParentHandle > 0) && shallUnembed)
            {
                info("Setting original parent: " + originalParentHandle + " for window"
                        + windowHandle);
                NativeUIUtils.unembedWindow(windowHandle, originalParentHandle);
                //Force update when redrawing
                androidInstance.setWindowHandle(0);
                info("Restoring window: " + windowHandle);
                NativeUIUtils.restoreWindow(windowHandle);
            }

        }

        if (!Platform.getOS().equals(Platform.OS_WIN32))
        {
            info("Trying to store the content composite in instance");
            if (contentComposite != null)
            {
                info("Is instance started? :" + androidInstance.isStarted());
                if (androidInstance.isStarted())
                {
                    try
                    {
                        contentComposite.setParent(PlatformUI.getWorkbench()
                                .getActiveWorkbenchWindow().getShell());
                        this.setContent(null);
                        contentComposite.setVisible(true);
                        androidInstance.setComposite(contentComposite);
                    }
                    catch (Exception e)
                    {
                        error("Error trying to store the content composite :" + e.getMessage());
                    }
                }
            }
        }
        super.dispose();
    }

    /**
     * Apply the zoom factor to the instance
     */
    public void applyZoomFactor()
    {
        if (!isOriginalScale && !zoomLocked)
        {
            contentComposite.setLocation(0, 0);
            IInputLogic inputLogic = androidInstance.getInputLogic();
            TelnetAndroidInput telnetAndroidInput = (TelnetAndroidInput) inputLogic;
            NativeUIUtils.hideWindow(windowHandle);

            if (isFitToWindow)
            {
                telnetAndroidInput.sendWindowScale(fitZoomFactor);
            }
            else
            {
                telnetAndroidInput.sendWindowScale(zoomFactor);
            }

            try
            {
                Thread.sleep(200);
            }
            catch (InterruptedException e)
            {
                //do nothing
            }
            telnetAndroidInput.dispose();
            NativeUIUtils.showWindow(windowHandle);
            updateContentComposite();
        }
    }

    void calculateFitZoomFactor(boolean requireNativeSizeUpdate)
    {
        // Compute new zoom factor if the zoom mode is "Fit to Window"
        Rectangle clientArea = getClientArea();
        if ((clientArea.width == 0) || (clientArea.height == 0))
        {
            // zoom factor cannot be zero, otherwise an
            // IllegalArgumentException
            // is raised in some SWT methods
            fitZoomFactor = MINIMUM_ZOOM_FACTOR;
        }
        else
        {
            // if the layout was changed, it is needed to retrieve the native window size at 100%
            // that size is required to the correct ratio calculus
            if (requireNativeSizeUpdate)
            {
                forceNativeWindowSizeUpdate = false;
                updateNativeWindowSize();
            }
            else
            {
                double widthRatio = (double) (clientArea.width) / nativeWindowSize.x;
                double heightRatio = (double) (clientArea.height) / nativeWindowSize.y;
                fitZoomFactor =
                        (Math.min(widthRatio, heightRatio) > MINIMUM_ZOOM_FACTOR ? Math.min(
                                widthRatio, heightRatio) : MINIMUM_ZOOM_FACTOR);
            }
        }
    }

    /**
     * This method brings the emulator window to 100% zoom factor to retrieve their native size
     */
    private void updateNativeWindowSize()
    {
        info("Updating Native Window Size");
        setZoomFactor(1.0d);
        applyZoomFactor();

        nativeWindowSize = NativeUIUtils.getWindowSize(originalParentHandle, windowHandle);

        setZoomFactor(ZOOM_FIT);
        applyZoomFactor();
        info("Updated Native Window Size");
    }

    private void updateContentComposite()
    {
        if (!this.isDisposed())
        {
            windowSize = NativeUIUtils.getWindowSize(originalParentHandle, windowHandle);
            if (windowSize != null)
            {
                if ((contentComposite != null) && !contentComposite.isDisposed())
                {
                    contentComposite.setSize(windowSize.x, windowSize.y);
                    contentComposite.redraw();
                }
                this.setMinSize(windowSize.x, windowSize.y);
                draw();
                this.redraw();
                info("Updated Content Composite");
            }
        }
    }

    /**
     * Gets the current zoom factor.
     * 
     * @return the zoom factor
     */
    public double getZoomFactor()
    {
        if (isFitToWindow)
        {
            return fitZoomFactor;
        }
        return zoomFactor;
    }

    /**
     * Sets the zoom factor.
     * 
     * @param zoom the zoom factor
     *            
     */
    public void setZoomFactor(double zoom)
    {
        boolean execute = true;
        zoomLocked = false;
        if (isOriginalScale)
        {
            execute =
                    DialogWithToggleUtils.showQuestion(LOOSE_ORIGINAL_SCALE_KEY_PREFERENCE,
                            EmulatorNLS.QUESTION_NativeWindow_LooseOriginalScale_Title,
                            EmulatorNLS.QUESTION_NativeWindow_LooseOriginalScale_Text);
        }
        if (execute)
        {
            isOriginalScale = false;

            if (zoom == ZOOM_FIT)
            {
                isFitToWindow = true;
                calculateFitZoomFactor(forceNativeWindowSizeUpdate);
            }
            else
            {
                isOriginalScale = false;
                isFitToWindow = false;
            }
            zoomFactor = zoom;
        }
    }

    @Override
    public boolean setFocus()
    {
        NativeUIUtils.setWindowFocus(windowHandle);
        return super.setFocus();
    }

    public void applyLayout(String layoutName)
    {
        setLayout(new FillLayout());
        draw();
    }

    public KeyListener getKeyListener()
    {
        return null;
    }

    public MouseListener getMouseListener()
    {
        return null;
    }

    public MouseMoveListener getMouseMoveListener()
    {
        return null;
    }

    public boolean isFitToWindowSelected()
    {
        return isFitToWindow;
    }
}