/*******************************************************************************
 * 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");
        }
    }
    
}