/*
* 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.maindisplay;
import static com.motorola.studio.android.common.log.StudioLogger.info;
import java.util.Properties;
import org.eclipse.core.runtime.Platform;
import org.eclipse.sequoyah.vnc.vncviewer.graphics.IRemoteDisplay;
import org.eclipse.sequoyah.vnc.vncviewer.graphics.swt.SWTRemoteDisplay;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.MouseWheelListener;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import com.motorola.studio.android.adt.DDMSFacade;
import com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance;
import com.motorola.studio.android.emulator.core.model.IInputLogic;
import com.motorola.studio.android.emulator.logic.AndroidLogicUtils;
import com.motorola.studio.android.emulator.skin.android.AndroidSkinTranslator;
import com.motorola.studio.android.emulator.ui.controls.IAndroidComposite;
import com.motorola.studio.android.emulator.ui.controls.UIHelper;
import com.motorola.studio.android.emulator.ui.handlers.IHandlerConstants;
import com.motorola.studio.android.nativeos.NativeUIUtils;
/**
* This class is the composite that holds the main display and it is shown by
* the Emulator Main Display View.
*/
public class MainDisplayComposite extends Composite implements IAndroidComposite
{
/**
* The zoom factor whose default value is 1.0 (100%)
*/
private double zoomFactor = 1.0;
private double fitZoomfactor;
// Minimum value to be used as zoom factor. This is necessary to avoid
// divisions to zero
private static final double MINIMUM_ZOOM_FACTOR = 0.0001;
private static final double ZOOM_FIT = 0.0;
/**
* The flag indicating that Ctrl key is pressed
*/
private boolean ctrlPressed = false;
/**
* SWT key pressed/released events listener.
*/
private KeyListener keyListener;
private MouseListener mouseListener;
private MouseMoveListener mouseMoveListener;
private IInputLogic androidInput;
private boolean isMouseLeftButtonPressed;
private boolean isFitToWindow;
private IAndroidEmulatorInstance androidInstance;
private Properties keyMap;
/**
* Constructor
*
* @param parent
* composite
* @param style
* style
* @param baseWidth
* the default main display width
* @param baseHeight
* the default main display height
*/
public MainDisplayComposite(Composite parent, int style, int baseWidth, int baseHeight,
IAndroidEmulatorInstance instance)
{
super(parent, style);
androidInput = instance.getInputLogic();
androidInstance = instance;
isMouseLeftButtonPressed = false;
keyMap = AndroidSkinTranslator.getQwertyKeyMap();
addListener();
if (!Platform.getOS().equals(Platform.OS_MACOSX))
{
hideEmulatorWindow();
}
}
private void hideEmulatorWindow()
{
int port =
AndroidLogicUtils.getEmulatorPort(DDMSFacade.getSerialNumberByName(androidInstance
.getName()));
long windowHandle = NativeUIUtils.getWindowHandle(androidInstance.getName(), port);
androidInstance.setWindowHandle(windowHandle);
NativeUIUtils.hideWindow(windowHandle);
}
/*
* (non-Javadoc)
* @see org.eclipse.swt.widgets.Widget#dispose()
*/
@Override
public void dispose()
{
if (androidInput != null)
{
androidInput.dispose();
}
keyListener = null;
mouseListener = null;
mouseMoveListener = null;
if (!Platform.getOS().equals(Platform.OS_MACOSX))
{
long hnd = androidInstance.getWindowHandle();
if (hnd > 0)
{
NativeUIUtils.showWindow(hnd);
NativeUIUtils.restoreWindow(hnd);
}
//Force update on redrawing
androidInstance.setWindowHandle(0);
}
super.dispose();
}
/**
* Updates the composite size when zoom is changed.
*
* @param zoom
* the zoom factor
*/
public void setZoomFactor(double zoomFactor)
{
info("Update detached view composite size");
if (zoomFactor == ZOOM_FIT)
{
isFitToWindow = true;
}
else
{
isFitToWindow = false;
}
this.zoomFactor = zoomFactor;
}
/**
* Gets the zoom factor.
*
* @return zoom the zoom factor.
*/
public double getZoomFactor()
{
return zoomFactor;
}
/**
* Applies the zoom factor to the components of the composite, updating the
* composite size to hold totally the main display.
*/
public void applyZoomFactor()
{
SWTRemoteDisplay mainDisplay = UIHelper.getRemoteDisplayAssociatedToControl(this);
IRemoteDisplay.Rotation rotation = mainDisplay.getRotation();
int baseHeight;
int baseWidth;
switch (rotation)
{
case ROTATION_90DEG_COUNTERCLOCKWISE:
baseHeight = mainDisplay.getScreenWidth();
baseWidth = mainDisplay.getScreenHeight();
break;
default:
baseHeight = mainDisplay.getScreenHeight();
baseWidth = mainDisplay.getScreenWidth();
}
int width;
int height;
if (isFitToWindow)
{
Rectangle clientArea = getParent().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
{
double widthRatio = (double) (clientArea.width) / baseWidth;
double heightRatio = (double) (clientArea.height) / baseHeight;
fitZoomfactor = Math.min(widthRatio, heightRatio);
}
width = new Double(baseWidth * fitZoomfactor).intValue();
height = new Double(baseHeight * fitZoomfactor).intValue();
if (mainDisplay != null)
{
mainDisplay.setZoomFactor(fitZoomfactor);
}
}
else
{
width = new Double(baseWidth * zoomFactor).intValue();
height = new Double(baseHeight * zoomFactor).intValue();
if (mainDisplay != null)
{
mainDisplay.setZoomFactor(zoomFactor);
}
}
setSize(width, height);
}
/**
* Adds listener for SWT events.
*/
private void addListener()
{
// add listener to handle keyboard key pressing
keyListener = new KeyListener()
{
public void keyPressed(KeyEvent arg0)
{
int keyCode = arg0.keyCode;
if (keyCode == SWT.CTRL)
{
ctrlPressed = true;
}
else
{
// send message to emulator
androidInput.sendKey(arg0.character, keyCode, keyMap);
}
}
public void keyReleased(KeyEvent arg0)
{
int keyCode = arg0.keyCode;
if (keyCode == SWT.CTRL)
{
ctrlPressed = false;
}
}
};
// listener to change the zoom factor using Ctrl + Mouse Wheel
addMouseWheelListener(new MouseWheelListener()
{
public void mouseScrolled(MouseEvent event)
{
if (ctrlPressed)
{
if ((event.count > 0) && (zoomFactor < IHandlerConstants.MAXIMUM_ZOOM))
{
// increase zoom factor
setZoomFactor(zoomFactor + IHandlerConstants.STEP_ZOOM);
applyZoomFactor();
}
else if ((event.count < 0) && (zoomFactor > IHandlerConstants.MINIMUM_ZOOM))
{
// decrease zoom factor
setZoomFactor(zoomFactor - IHandlerConstants.STEP_ZOOM);
applyZoomFactor();
}
}
}
});
mouseListener = new MouseAdapter()
{
/**
* @see org.eclipse.swt.events.MouseListener#mouseUp(MouseEvent)
*/
@Override
public void mouseUp(MouseEvent e)
{
handleMouseUp(e);
}
/**
* @see org.eclipse.swt.events.MouseListener#mouseDown(MouseEvent)
*/
@Override
public void mouseDown(MouseEvent e)
{
setFocus();
handleMouseDown(e);
}
};
mouseMoveListener = new MouseMoveListener()
{
/**
* @see org.eclipse.swt.events.MouseMoveListener#mouseMove(MouseEvent)
*/
public void mouseMove(MouseEvent e)
{
handleMouseMove(e);
}
};
getParent().addControlListener(new ControlAdapter()
{
/*
* (non-Javadoc)
* @see org.eclipse.swt.events.ControlAdapter#controlResized(org.eclipse.swt.events.ControlEvent)
*/
@Override
public void controlResized(ControlEvent event)
{
if (isFitToWindow)
{
applyZoomFactor();
}
}
});
}
/*
* (non-Javadoc)
* @see com.motorola.studio.android.emulator.ui.controls.IAndroidComposite#applyLayout(java.lang.String)
*/
public void applyLayout(String layoutName)
{
//do nothing
}
/**
* Gets the listener that handles SWT key pressing and releasing events.
*
* @return the KeyListener object
*/
public KeyListener getKeyListener()
{
return keyListener;
}
/**
* Gets the listener that handles SWT mouse clicking events.
*
* @return the MouseListener object
*/
public MouseListener getMouseListener()
{
return mouseListener;
}
/**
* Gets the listener that handles SWT mouse moving events.
*
* @return the MouseMoveListener object
*/
public MouseMoveListener getMouseMoveListener()
{
return mouseMoveListener;
}
/**
* Handles the mouse up event on the skin composite
*
* @param e
* The mouse up event
*/
private void handleMouseUp(MouseEvent e)
{
if (e.button == 1)
{
isMouseLeftButtonPressed = false;
UIHelper.ajustCoordinates(e, this);
androidInput.sendMouseUp(e.x, e.y);
}
}
/**
* Handles the mouse down event on the skin composite
*
* @param e
* The mouse down event
*/
private void handleMouseDown(MouseEvent e)
{
if (e.button == 1)
{
UIHelper.ajustCoordinates(e, this);
androidInput.sendMouseDown(e.x, e.y);
isMouseLeftButtonPressed = true;
}
}
/**
* Handles the mouse move event on the skin composite
*
* @param e
* The mouse move event
*/
private void handleMouseMove(MouseEvent e)
{
if (isMouseLeftButtonPressed)
{
UIHelper.ajustCoordinates(e, this);
androidInput.sendMouseMove(e.x, e.y);
}
}
public boolean isFitToWindowSelected()
{
return isFitToWindow;
}
}