javauis/eswt_qt/org.eclipse.swt/Eclipse_SWT_PI/qt/org/eclipse/swt/internal/qt/graphics/WindowSurface.java
/*******************************************************************************
* Copyright (c) 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:
* Nokia Corporation - initial implementation
*******************************************************************************/
package org.eclipse.swt.internal.qt.graphics;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Internal_PackageSupport;
public final class WindowSurface {
/**
* Undefined type
*/
final static int UNKNOWN_TYPE = 0;
/**
* QImage
*/
final static int QT_IMAGE = 1;
/**
* CFbsBitmap
*/
final static int SYMBIAN_IMAGE = 2;
/**
* EGL surface
*/
final static int EGL_SURFACE = 4;
/**
* Handle of native peer
*/
int handle;
/**
* Disposal status of native peer
*/
private boolean disposed;
/**
* Indicates if this window surface is being
* currently painted
*/
private boolean paintingActive;
/**
* Constructor for Shell
* @param shell Top level Shell
* @param autoRefresh If true the window surface is automatically kept up to date
* in each call to native objects bind, otherwise refresh needs to be called manually.
* @throws IllegalArgumentException if given shell is not window owning or top level shell
* @throws NullPointerException if shell is null
*/
public WindowSurface(Shell shell, boolean autoRefresh) {
if(shell == null) {
throw new NullPointerException("shell is null");
}
if(shell.getParent() != null) {
throw new IllegalArgumentException("Given shell is not window owning");
}
int widgetHandle = Internal_PackageSupport.handle(shell);
handle = OS.windowsurface_create(widgetHandle, autoRefresh);
}
/**
* Constructor for native window surface
* @param nativeHandle The handle of native widow surface instance
*/
WindowSurface(int nativeHandle) {
handle = nativeHandle;
}
/**
* Opens this window surface for painting. Must be called before painting to window surface
* with any renderer
* @param x The x-coordinated of painting area
* @param y The y-coordinated of painting area
* @param width The width of painting area
* @param height The height of painting area
*/
public void beginPaint(int x, int y, int width, int height) {
if(paintingActive) {
return;
}
checkState();
OS.windowsurface_beginPaint(handle, x, y, width, height);
paintingActive = true;
}
/**
* Ends paint cycle, must be called when painting ends
*/
public void endPaint() {
checkState();
OS.windowsurface_endPaint(handle);
paintingActive = false;
}
/**
* Flushes window surface to display
*/
public void flush() {
checkState();
OS.windowsurface_flush(handle);
}
/**
* Gets the type of window surface
*/
public int getType() {
checkState();
int type = OS.windowsurface_getType(handle);
return type;
}
/**
* Gets the handle of the native peer
*/
public int getHandle() {
checkState();
return handle;
}
/**
* Disposes this instance
*/
public void dispose() {
Utils.validateUiThread();
if (handle != 0) {
OS.windowsurface_dispose(handle);
handle = 0;
}
disposed = true;
}
/**
* Dispose status of this instance.
* @return True if this instance has been disposed, othewise false
*/
public boolean isDisposed() {
return disposed;
}
/**
* Refreshes the contained Qt window surface information, which might change e.g. when
* application is sent to background. If auto refresh is on there's no additional need to call
* this method.
*/
public void refresh()
{
checkState();
OS.windowsurface_refresh(handle);
}
/**
* Switch to software rendering when the window is going invisible
* and back to hardware accelerated rendering when going visible.
* @param goingVisible True if the window is about to become visible (partially or fully).
* False if the window is about to become invisible (fully).
*/
public void handleSymbianWindowVisibilityChange(boolean goingVisible)
{
OS.windowsurface_handleSymbianWindowVisibilityChange(handle, goingVisible);
}
private void checkState() {
Utils.validateUiThread();
if (disposed) {
throw new IllegalStateException("WindowSurface already disposed");
}
}
}