/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

	// Turn a color property value string into

	// a color. The value is expected to either

	// be a comma delimited RGB or a system color

function colorFromString(laf, colorStr) {

	if (colorStr == null || colorStr == "")

		return null;

	var result = null;

	var elements = colorStr.split(",");

	if (elements.length == 3) {

		var valid = true;

		for (var i in elements) {

			var num = parseInt(elements[i]);

			if (isNaN(num))

				valid = false;

		}

		if (valid)

			result = Colors.getColor(elements[0], elements[1], elements[2]);

	}

	else {

		result = laf.getColor(colorStr);

	}

	return result;

}

// Get the effective background color, assuming that everything is transparent

// until we get to a component with an attribute describing how its

// background will be drawn

function getBackgroundColor(instance, laf) {

	var color = null;

	while (instance != null) {

		// children of form and settings list have parent-derived colors

		if (instance.parent != null && instance.parent.componentId == "com.nokia.sdt.series60.CAknForm")

			break;

		if (instance.parent != null && instance.parent.componentId == "com.nokia.sdt.series60.CAknSettingItemList") {

			color = laf.getColor("CAknSettingItemList.ContentBackground");

			break;

		}

		var bgProperty = null;

		var bgColor = null;

		if (instance.component != null) {

			bgProperty = instance.component.attributes

				["container-background-color-property-name"];

			bgColor = instance.component.attributes

				["container-background-color"];

		}

		if (bgProperty != null) {

			color = colorFromString(laf, instance.properties[bgProperty]);

			if (color != null) {

				//println("used attribute for " + color);

				break;

			}

		}

		if (bgColor != null) {

			color = laf.getColor(bgColor);

			if (color != null) {

				//println("used property for " + color);

				break;

			}

		}

		instance = instance.parent;

	}

	if (color == null) {

		color = laf.getColor("EEikColorWindowBackground");

		//println("using background color " + color);

		if (color == null) {

			color = Colors.getColor(255, 255, 255);

		}

	}

	return color;

}

/**

 * Return a reference to the IImageRenderingClass for static constant values access

 */

IImageRendering = null;

function getIImageRenderingClass() {

	if (IImageRendering == null)

		IImageRendering = getPluginClass("com.nokia.sdt.uimodel", "com.nokia.sdt.datamodel.images.IImageRendering");

	return IImageRendering;

}

/**

 *	Get the real size of an image from property.

 *	This retrieves the unscaled image, which should 

 *	already be cached.

 *	@param instance the instance

 *	@param imageProperty the property, i.e. instance.properties.image

 *	@param multiImageAbstractImageId for a multi-image property, the abstract image id

 *	@return the Rectangle bounds, or null

 */

function getImageBounds(instance, imageProperty, multiImageAbstractImageId) {

 	var imageRendering = createImagePropertyRendering();

 	imageRendering.setImageProperty(instance, null, null);

 	imageRendering.setImagePropertySource(imageProperty);

 	imageRendering.setViewableSize(null);

 	if (multiImageAbstractImageId)

 		imageRendering.setMultiImagePropertyAbstractImageId(multiImageAbstractImageId);

	var imgData = imageRendering.getImageData();

	if (imgData == null)

		return null;

	return new Rectangle(0, 0, imgData.width, imgData.height);

}

/**

 *	Scale a size to fit in a given size

 *	@param insize incoming size to scale

 *	@param size the size to fit

 *	@param preserveAspect true: keep aspect ratio, false: use instance size exactly

 *	@return a Point

 */

function getSizeScaledToSize(insize, size, preserveAspect) {

	if (!preserveAspect || size.x == 0 || size.y == 0)	{

		return size;

	}

	if (insize.x == 0 || insize.y == 0)

		return insize;

	var iw, ih;

	if (size.x / size.y > insize.x / insize.y) {

		iw = insize.x * size.y / insize.y;

		ih = size.y;

	} else {

		iw = size.x;

		ih = insize.y * size.x / insize.x;

	}

	var scaled = new Point(iw, ih);

	//println("scaled to " + scaled);

	return scaled;

}

/**

 *	Scale a bounds to fit in a given bounding rectangle, and centered therein.

 *	@param inBounds incoming bounds to scale

 *	@param bounds the bounds to fit

 *	@param preserveAspect true: keep aspect ratio, false: use instance size exactly

 *	@return a Rectangle

 */

function getBoundsScaledToBounds(inBounds, bounds, preserveAspect) {

	var size = getSizeScaledToSize(new Point(inBounds.width, inBounds.height),

		new Point(bounds.width, bounds.height),

		preserveAspect);

	var scaled = new Rectangle((bounds.width - size.x) / 2, (bounds.height - size.y) / 2,

			size.x, size.y);

	//println("scaled to " + scaled);

	return scaled;

}

//	Draw an image into the given rectangle in the gc

//	@param instance the instance

//	@param graphics the GC

//	@param rect the rectangle to draw to.  If the rectangle is null

//		or the width/height are 0, no scaling is performed.

//		The x/y offset are used, if non-null, to offset the image.

//	@param doBlend true: blend smoothly with background (only works with solid background)

//	@return the Image, or null

function drawImage(instance, graphics, image, rect, doBlend) {

	if (image) {

		// show image in dialog

		//var dump = new ImageDump(null, image);

		//dump.open();

		var imgRect = image.getBounds()

		//println("image is " + imgRect);

		var blended = ImageUtils.flattenAlphaMaskedImage(graphics.getDevice(), image, 

			graphics.getBackground(), doBlend, true /* transparent */);

		// show blended image in dialog

		//var dump = new ImageDump(null, blended);

		//dump.open();

		if (rect) {

			var imgRect = blended.getBounds()

			if (rect.width != 0 && rect.height != 0)

				graphics.drawImage(blended, 0, 0, imgRect.width, imgRect.height, rect.x, rect.y, rect.width, rect.height);

			else

				graphics.drawImage(blended, 0, 0, imgRect.width, imgRect.height, rect.x, rect.y, imgRect.width, imgRect.height);

		} else {

			graphics.drawImage(blended, 0, 0);

		}

		blended.dispose();

	}

}

/**

 * Get the height of a font which properly encompasses its leading,

 * descent, and ascent.  font.getHeight() is not quite accurate, for some reason...

 */

function getFontHeight(font) {

	return font.formattedStringExtent("x", new Point(0, 0), 0, 0).y;

}

/**

 *	Render an image to the gc

 *	@param prototype a prototype implementing IImagePropertyRenderingInfo

 *	@param instance the component instance holding the image property

 *	@param laf the look and feel information

 *	@param graphics the GC

 *	@param x x offset of image (left)

 *	@param y y offset of image (top)

 *	@param propertyId the property path of the image compound property

 *	@param doBlend true: blend image with background when flattening alpha

 *  @param multiImageAbstractImageId if non-null, then the image property houses multiple images, and draw this one

 *	(@see IMultiImagePropertyInfo)

 */

function renderImage(prototype, instance, laf, graphics, x, y, propertyId, doBlend, multiImageAbstractImageId) {

	var imagePropertyRendering = createImagePropertyRendering();

	imagePropertyRendering.setImageProperty(instance, propertyId, laf);

	imagePropertyRendering.setViewableSize(prototype.getViewableSize(instance, propertyId, laf));

	imagePropertyRendering.setAlignmentWeights(prototype.getAlignmentWeights(instance, propertyId, laf));

	imagePropertyRendering.setScaling(prototype.isScaling(instance, propertyId, laf));

	imagePropertyRendering.setPreservingAspectRatio(prototype.isPreservingAspectRatio(instance, propertyId, laf));

	if (doBlend)

		imagePropertyRendering.setTransparencyHandling(getIImageRenderingClass().TRANSPARENCY_FLATTEN_AND_BLEND);

	else

		imagePropertyRendering.setTransparencyHandling(getIImageRenderingClass().TRANSPARENCY_FLATTEN);

	if (multiImageAbstractImageId)

		imagePropertyRendering.setMultiImagePropertyAbstractImageId(multiImageAbstractImageId);

	imagePropertyRendering.render(graphics.getWrappedGC(), x, y);

}

/**

 *	Get the bounds consumed by wrappable text, given a limiting width and 

 *	maximum number of lines.  This detects newlines embedded in text.

 *	@param string the text to measure

 *	@param width width in pixels

 *	@param font the font

 *	@param flags mask of IFont.XXX flags (wrapping flags ignored!)

 *	@param lineGap pixel gap b/t lines

 *	@param maxLines maximum # lines to emit

 *	@return Point (maxWidthUsed, requiredHeight)

 */

function calculateWrappedTextSize(string, width, font, flags, lineGap, maxLines) {

	var lines = TextRendering.formatIntoLines(font, string, width, flags, maxLines);

	var fontHeight = font.getHeight();

	var gappedLineHeight = fontHeight + lineGap;

	var maxWidth = 0;

	for (var i in lines) {

		var line = lines[i];

		maxWidth = Math.max(maxWidth, font.stringExtent(line).x);

	}

	return new Point(maxWidth, lines.length * gappedLineHeight);

}