javauis/eswt_qt/org.eclipse.swt/Eclipse SWT/qt/org/eclipse/ercp/swt/mobile/Screen.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/eswt_qt/org.eclipse.swt/Eclipse SWT/qt/org/eclipse/ercp/swt/mobile/Screen.java Mon May 03 12:27:20 2010 +0300
@@ -0,0 +1,592 @@
+/*******************************************************************************
+ * Copyright (c) 2004 IBM Corp.
+ * Portion Copyright (c) 2004, 2008 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Mark Rogalski (IBM Corp.) - initial API specification
+ * Nokia Corporation - S60 implementation
+ * Nokia Corporation - Qt implementation
+ *******************************************************************************/
+
+package org.eclipse.ercp.swt.mobile;
+
+import java.util.Vector;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.internal.qt.OS;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Internal_PackageSupport;
+
+
+/**
+ * Instances of this class represent display screens available for application
+ * use.
+ *
+ * <dl>
+ * <dt><b>Screen usage types: </b></dt>
+ * <dd>PRIMARY</dd>
+ * <dd>SECONDARY</dd>
+ * <dd>STATUS</dd>
+ * </dl>
+ *
+ * <dl>
+ * <dt><b>Screen orientation styles: </b></dt>
+ * <dd>PORTRAIT</dd>
+ * <dd>LANDSCAPE</dd>
+ * </dl>
+ *
+ * @see MobileDevice
+ * @see MobileDeviceListener
+ */
+public class Screen {
+ /**
+ * Handle of this Object Screen.
+ */
+ int screenHandle;
+
+ /**
+ * Indicate if the screen is disposed.
+ */
+ private boolean isDisposed;
+
+ /**
+ * All ScreenListener on this Screeen.
+ */
+ private Vector screenListeners;
+
+ /**
+ * one primary screen may be active at a time
+ */
+ public static final int PRIMARY = 1;
+
+ /**
+ * multiple secondary screens may be simultaneously active
+ */
+ public static final int SECONDARY = 2;
+
+ /**
+ * sub type of secondary screen that shows minimal content for notification
+ * purposes
+ */
+ public static final int STATUS = 3;
+
+ /**
+ * indicates text is normally written across the shortest width
+ */
+ public static final int PORTRAIT = 0;
+
+ /**
+ * indicates text is normally written across the longest width
+ */
+ public static final int LANDSCAPE = 1;
+
+ /**
+ * The Screen used by the Runnable.
+ */
+
+ /**
+ * The bounds used by the Runnable.
+ */
+ private Rectangle boundsForRunnable;
+
+ /**
+ * The Color depth used by the Runnable.
+ */
+ private int colorDepthForRunnable;
+
+ /**
+ * The location used by the Runnable.
+ */
+ private int locationForRunnable;
+
+ /**
+ * The orientation used by the Runnable.
+ */
+ private int orientationGetForRunnable;
+
+ /**
+ * The usage used by the Runnable.
+ */
+ private int usageForRunnable;
+
+ /**
+ * The activation state used by the Runnable.
+ */
+ boolean isActiveForRunnable;
+
+ boolean isActive;
+
+ /**
+ * The Touchscreen state used by the Runnable.
+ */
+ private boolean isTouchScreenForRunnable;
+
+ /**
+ * The Orientation state used by the Runnable.
+ */
+ private int orientationSetForRunnable;
+
+ /**
+ * Screen id.
+ */
+ int id;
+
+ private int desktopWidgetHandle;
+
+ /**
+ * Constructs a new instance of this class. Non-public to prevent
+ * instantiation outside of this package.
+ *
+ * @see MobileDevice#getLocalScreens
+ */
+ Screen( int aScreenId, int aDesktopWidgetHandle){
+ id = aScreenId;
+ desktopWidgetHandle = aDesktopWidgetHandle;
+ (getDisplay()).syncExec(new Runnable() {
+ public void run() {
+ screenHandle = OS.QDesktopWidget_screen(desktopWidgetHandle, id);
+ }
+ });
+ screenListeners = new Vector();
+ isDisposed = false;
+ }
+
+ /**
+ * Adds the listener to the collection of listeners that will be notified
+ * when screen events occur by sending it one of the messages defined in the
+ * ScreenListener interface.
+ * <p>
+ * <code>screenActivated</code> is called when a screen becomes active. That
+ * is, the screen is powered and contents are visible to the user.
+ * <br>
+ * <code>screenDeactivated</code> is called when a screen is no longer
+ * active. <br>
+ *
+ * @param listener
+ * instance called when screen events occur
+ *
+ * @exception IllegalArgumentException
+ * <ul>
+ * <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
+ * </ul>
+ * @exception SWTException
+ * <ul>
+ * <li>ERROR_WIDGET_DISPOSED - if the receiver has been
+ * disposed</li>
+ * </ul>
+ * @exception SWTError
+ * <ul>
+ * <li>ERROR_ITEM_NOT_ADDED - if the operation fails
+ * because of an operating system failure</li>
+ * </ul>
+ *
+ * @see ScreenListener
+ * @see Screen#removeEventListener
+ */
+ public void addEventListener(ScreenListener listener) {
+ check();
+
+ if (listener == null) {
+ SWT.error (SWT.ERROR_NULL_ARGUMENT);
+ }
+
+ screenListeners.addElement(listener);
+ }
+
+ /**
+ * Returns the bounds of the screen. Application contents must be within
+ * these bounds to be visible on the given device screen. Note, the bounds
+ * may not have a 0,0 origin.
+ *
+ * @return Rectangle The bounds of the sceen.
+ * @exception SWTException
+ * <ul>
+ * <li>ERROR_WIDGET_DISPOSED - if the receiver has been
+ * disposed</li>
+ * </ul>
+ * @exception SWTError
+ * <ul>
+ * <li>ERROR_CANNOT_GET_SELECTION - if the operation fails
+ * because of an operating system failure</li>
+ * </ul>
+ *
+ */
+
+ public Rectangle getBounds() {
+ check();
+ (getDisplay()).syncExec(new Runnable() {
+ public void run() {
+ boundsForRunnable = OS.QDesktopWidget_screenGeometry(screenHandle, id);
+ }
+ });
+
+ return boundsForRunnable;
+ }
+
+ /**
+ * Returns the color depth of the screen in bits per pixel.
+ *
+ * @return int the color depth.
+ * @exception SWTException
+ * <ul>
+ * <li>ERROR_WIDGET_DISPOSED - if the receiver has been
+ * disposed</li>
+ * </ul>
+ * @exception SWTError
+ * <ul>
+ * <li>ERROR_CANNOT_GET_SELECTION - if the operation fails
+ * because of an operating system failure</li>
+ * </ul>
+ *
+ */
+ public int getColorDepth() {
+ check();
+
+ (getDisplay()).syncExec(new Runnable() {
+ public void run() {
+ if(isActive()){
+ colorDepthForRunnable = OS.getColorDepth();
+ } else{
+ colorDepthForRunnable = -1;
+ }
+ }
+ });
+
+ return colorDepthForRunnable;
+ }
+
+ /**
+ * Returns the location of the screen device.
+ *
+ * @return int The screen location. The value is one of
+ * {@link MobileDevice#LOCAL LOCAL},
+ * {@link MobileDevice#INTERNAL INTERNAL},
+ * {@link MobileDevice#EXTERNAL EXTERNAL}, or
+ * {@link MobileDevice#REMOTE REMOTE}
+ *
+ * @exception SWTException
+ * <ul>
+ * <li>ERROR_WIDGET_DISPOSED - if the receiver has been
+ * disposed</li>
+ * </ul>
+ * @exception SWTError
+ * <ul>
+ * <li>ERROR_CANNOT_GET_SELECTION - if the operation fails
+ * because of an operating system failure</li>
+ * </ul>
+ *
+ * @see MobileDevice#LOCAL
+ * @see MobileDevice#INTERNAL
+ * @see MobileDevice#EXTERNAL
+ * @see MobileDevice#REMOTE
+ */
+ public int getLocation() {
+ check();
+
+ (getDisplay()).syncExec(new Runnable() {
+ public void run() {
+ if(OS.QDesktopWidget_screenCount(desktopWidgetHandle)>1){
+ if(OS.QDesktopWidget_primaryScreen(desktopWidgetHandle) == id){
+ locationForRunnable = MobileDevice.INTERNAL;
+ }else{
+ locationForRunnable = MobileDevice.EXTERNAL;
+ }
+ } else{
+ locationForRunnable = MobileDevice.LOCAL;
+ }
+ }
+ });
+
+ return locationForRunnable;
+ }
+
+ /**
+ * Returns the screen orientation.
+ *
+ * @return int The screen orientation. The value must be either PORTRAIT or
+ * LANDSCAPE.
+ * @exception SWTException
+ * <ul>
+ * <li>ERROR_WIDGET_DISPOSED - if the receiver has been
+ * disposed</li>
+ * </ul>
+ * @exception SWTError
+ * <ul>
+ * <li>ERROR_CANNOT_GET_SELECTION - if the operation fails
+ * because of an operating system failure</li>
+ * </ul>
+ *
+ * @see Screen#PORTRAIT
+ * @see Screen#LANDSCAPE
+ * @see #setOrientation(int)
+ */
+ public int getOrientation() {
+ check();
+ (getDisplay()).syncExec(new Runnable() {
+ public void run() {
+ Rectangle bounds= getBounds();
+ if(bounds.width>bounds.height){
+ orientationGetForRunnable = Screen.LANDSCAPE;
+ }else {
+ orientationGetForRunnable = Screen.PORTRAIT;
+ }
+ }
+ });
+ return orientationGetForRunnable;
+ }
+
+ /**
+ * Returns the usage type of the screen.
+ *
+ * @return int The type of the screen. The value must be one of PRIMARY,
+ * SECONDARY and STATUS</dd>
+ * @exception SWTException
+ * <ul>
+ * <li>ERROR_WIDGET_DISPOSED - if the receiver has been
+ * disposed</li>
+ * </ul>
+ * @exception SWTError
+ * <ul>
+ * <li>ERROR_CANNOT_GET_SELECTION - if the operation fails
+ * because of an operating system failure</li>
+ * </ul>
+ *
+ * @see Screen#PRIMARY
+ * @see Screen#SECONDARY
+ * @see Screen#STATUS
+ */
+ public int getUsage() {
+ check();
+
+ (getDisplay()).syncExec(new Runnable() {
+ public void run() {
+ if(OS.QDesktopWidget_primaryScreen(desktopWidgetHandle) ==
+ OS.QDesktopWidget_screenNumber(desktopWidgetHandle, screenHandle)){
+ usageForRunnable = PRIMARY;
+ } else {
+ usageForRunnable = SECONDARY;
+ }
+ }
+ });
+
+ return usageForRunnable;
+ }
+
+ /**
+ * Returns whether the screen is currently active. That is, whether it is
+ * powered up and contents are visible to the user.
+ *
+ * @return boolean The screen status.
+ * @exception SWTException
+ * <ul>
+ * <li>ERROR_WIDGET_DISPOSED - if the receiver has been
+ * disposed</li>
+ * </ul>
+ * @exception SWTError
+ * <ul>
+ * <li>ERROR_CANNOT_GET_SELECTION - if the operation fails
+ * because of an operating system failure</li>
+ * </ul>
+ *
+ */
+ public boolean isActive() {
+ check();
+
+ (getDisplay()).syncExec(new Runnable() {
+ public void run() {
+ if(!(OS.QDesktopWidget_screenCount(desktopWidgetHandle)==1)){
+ if(OS.getScreenDeviceNumber() == id){
+ isActive = isActiveForRunnable;
+ } else {
+ isActive = false;
+ }
+ }else{
+ isActive = true;
+ }
+ }
+ });
+
+ return isActive;
+ }
+
+ /**
+ * Returns whether the screen has touch screen capability.
+ *
+ * @return boolean The touch screen capability.
+ * @exception SWTException
+ * <ul>
+ * <li>ERROR_WIDGET_DISPOSED - if the receiver has been
+ * disposed</li>
+ * </ul>
+ * @exception SWTError
+ * <ul>
+ * <li>ERROR_CANNOT_GET_SELECTION - if the operation fails
+ * because of an operating system failure</li>
+ * </ul>
+ *
+ */
+ public boolean isTouchScreen() {
+ check();
+
+ (getDisplay()).syncExec(new Runnable() {
+ public void run() {
+ if(isActive()){
+ isTouchScreenForRunnable = true;
+ }else {
+ isTouchScreenForRunnable = false;
+ }
+ }
+ });
+
+ return isTouchScreenForRunnable;
+ }
+
+ /**
+ * Removes the listener from the collection of listeners that will be
+ * notified when screen events occur.
+ *
+ * @param listener
+ * instance called when screen events occur
+ *
+ * @exception IllegalArgumentException
+ * <ul>
+ * <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
+ * </ul>
+ * @exception SWTException
+ * <ul>
+ * <li>ERROR_WIDGET_DISPOSED - if the receiver has been
+ * disposed</li>
+ * </ul>
+ * @exception SWTError
+ * <ul>
+ * <li>ERROR_ITEM_NOT_REMOVED - if the operation fails
+ * because of an operating system failure</li>
+ * </ul
+ *
+ * @see ScreenListener
+ * @see Screen#addEventListener
+ */
+ public void removeEventListener(ScreenListener listener) {
+ check();
+
+ if (listener == null) {
+ SWT.error (SWT.ERROR_NULL_ARGUMENT);
+ }
+
+ screenListeners.removeElement(listener);
+ }
+
+ /**
+ * Sets the screen orientation if supported on this device. Note that this
+ * feature is implementation-dependent.
+ *
+ * @param orientation
+ * the caller's preferred orientation. Must be one of PORTRAIT and
+ * LANDSCAPE.
+ *
+ * @exception IllegalArgumentException
+ * <ul>
+ * <li>ERROR_INVALID_ARGUMENT - if the argument is not
+ * either PORTRAIT or LANDSCAPE</li>
+ * </ul>
+ * @exception SWTException
+ * <ul>
+ * <li>ERROR_WIDGET_DISPOSED - if the receiver has been
+ * disposed</li>
+ * <li>ERROR_CANNOT_SET_SELECTION - if the device could not set
+ * the orientation</li>
+ * </ul>
+ *
+ * @see Screen#PORTRAIT
+ * @see Screen#LANDSCAPE
+ * @see #getOrientation()
+ */
+ public void setOrientation(int orientation) {
+ check();
+ if ( (orientation != PORTRAIT) && (orientation != LANDSCAPE) ) {
+ SWT.error (SWT.ERROR_INVALID_ARGUMENT);
+ }
+
+ orientationSetForRunnable = orientation;
+ getDisplay();
+ }
+
+ /**
+ * Call to dispose the Screen object.
+ *
+ */
+ void internal_dispose() {
+ isDisposed = true;
+ screenListeners = null;
+ screenHandle = 0;
+ }
+
+ /**
+ * Verify if the object is disposed.
+ *
+ */
+ private void check() {
+ if (isDisposed == true) {
+ SWT.error (SWT.ERROR_WIDGET_DISPOSED);
+ }
+ }
+
+ private ScreenEvent getAScreenEvent() {
+ ScreenEvent screenEvent = new ScreenEvent(this);
+ screenEvent.isActive = isActive();
+ screenEvent.orientation = getOrientation();
+ return screenEvent;
+ }
+
+ void internal_sendScreenEventActivated() {
+ isActiveForRunnable = true;
+ ScreenEvent screenEvent = getAScreenEvent();
+
+ int count = screenListeners.size();
+ for (int i = 0; i < count; ++i) {
+ ScreenListener listener = (ScreenListener)screenListeners.elementAt(i);
+ listener.screenActivated(screenEvent);
+ }
+ }
+
+ void internal_sendScreenEventDeactivated() {
+ isActiveForRunnable = false;
+ ScreenEvent screenEvent = getAScreenEvent();
+
+ int count = screenListeners.size();
+ for (int i = 0; i < count; ++i) {
+ ScreenListener listener =(ScreenListener)screenListeners.elementAt(i);
+ listener.screenDeactivated(screenEvent);
+ }
+ }
+
+ void internal_sendOrientationScreenChanged() {
+ ScreenEvent screenEvent = getAScreenEvent();
+
+ int count = screenListeners.size();
+ for (int i = 0; i < count; ++i) {
+ ScreenListener listener =(ScreenListener)screenListeners.elementAt(i);
+ listener.screenOrientationChanged(screenEvent);
+ }
+ }
+
+ private static Display getDisplay(){
+ Display display = Internal_PackageSupport.getDisplayInstance();
+
+ // following if loop (getting default display) should be removed
+ // if agreed that MobileDevice shouldn't create the display.
+ if(display==null){
+ display = Display.getDefault();
+ }
+
+ if(display == null || display.isDisposed()){
+ SWT.error(SWT.ERROR_DEVICE_DISPOSED);
+ }
+ return display;
+ }
+};