1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Client-side state information for Open VG handle based objects

    15 

    16 #include "vgstate.h"

    17 #include "remotefunctioncall.h"

    18 #include "openvgrfc.h"

    19 

    20 

    21 /////////////////////////////////////////////////////////////////////////////////////////////

    22 // CVgPaintInfo

    23 /////////////////////////////////////////////////////////////////////////////////////////////

    24 

    25 CVgPaintInfo* CVgPaintInfo::New()

    26 	{

    27 	RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();

    28 	CVgPaintInfo* self = new CVgPaintInfo();

    29 	CVghwUtils::SwitchFromVghwHeap(clientHeap);

    30 	return self;

    31 	}

    32 

    33 

    34 CVgPaintInfo::~CVgPaintInfo()

    35 	{}

    36 

    37 

    38 CVgPaintInfo::CVgPaintInfo() :

    39 		CVgHandleBase(EVgHandleForPaint),

    40 		iPaintType(VG_PAINT_TYPE_COLOR), iColorRampSpreadMode(VG_COLOR_RAMP_SPREAD_PAD),

    41 		iColorRampPremultiplied(VG_TRUE), iPatternTilingMode(VG_TILE_FILL)

    42 	{}

    43 

    44 

    45 TBool CVgPaintInfo::DestroyObject(MVgContext& aVgContext)

    46 	{

    47 	VGPANIC_ASSERT_DEBUG(iIsDestroyed, EVgPanicTemp);

    48 	OPENVG_TRACE("  CVgPaintInfo::DestroyObject HostHandle=0x%x", iHostHandle);

    49 

    50 	if (iHostHandle)

    51 		{

    52 		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

    53 		vgApiData.Init(OpenVgRFC::EvgDestroyPaint, RemoteFunctionCallData::EOpRequest);

    54 		vgApiData.AppendParam(iHostHandle);

    55 		aVgContext.ExecuteVgCommand(vgApiData);

    56 		}

    57 

    58 	return ETrue;

    59 	}

    60 

    61 

    62 VGint CVgPaintInfo::GetParameterVectorSize(MVgContext& aVgContext, VGint aParamType)

    63 	{

    64 	switch (aParamType)

    65 		{

    66 		case VG_PAINT_TYPE:

    67 		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

    68 		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

    69 		case VG_PAINT_PATTERN_TILING_MODE:

    70 			return 1;

    71 

    72 		case VG_PAINT_COLOR:

    73 		case VG_PAINT_LINEAR_GRADIENT:

    74 			return 4;

    75 

    76 		case VG_PAINT_COLOR_RAMP_STOPS:

    77 			return 10000; // note: finite limit due to Guest serialisation limits 

    78 

    79 		case VG_PAINT_RADIAL_GRADIENT:

    80 			return 5;

    81 		}

    82 

    83 	// invalid ParamType

    84 	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

    85 	return 0;

    86 	}

    87 

    88 

    89 VGfloat CVgPaintInfo::GetParameterf(MVgContext& aVgContext, VGint aParamType)

    90 	{

    91 	switch (aParamType)

    92 		{

    93 		case VG_PAINT_TYPE:

    94 			return (VGfloat) iPaintType;

    95 		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

    96 			return (VGfloat) iColorRampSpreadMode;

    97 		case VG_PAINT_PATTERN_TILING_MODE:

    98 			return (VGfloat) iPatternTilingMode;

    99 		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

   100 			return (VGfloat) iColorRampPremultiplied;

   101 		case VG_PAINT_COLOR:

   102 		case VG_PAINT_COLOR_RAMP_STOPS:

   103 		case VG_PAINT_LINEAR_GRADIENT:

   104 		case VG_PAINT_RADIAL_GRADIENT:

   105 			return HostVgGetParameterf(aVgContext, aParamType);

   106 		}

   107 

   108 	// invalid ParamType

   109 	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   110 	return 0;

   111 	}

   112 

   113 

   114 VGint CVgPaintInfo::GetParameteri(MVgContext& aVgContext, VGint aParamType)

   115 	{

   116 	switch (aParamType)

   117 		{

   118 		case VG_PAINT_TYPE:

   119 			return iPaintType;

   120 		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

   121 			return iColorRampSpreadMode;

   122 		case VG_PAINT_PATTERN_TILING_MODE:

   123 			return iPatternTilingMode;

   124 		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

   125 			return iColorRampPremultiplied;

   126 		case VG_PAINT_COLOR:

   127 		case VG_PAINT_COLOR_RAMP_STOPS:

   128 		case VG_PAINT_LINEAR_GRADIENT:

   129 		case VG_PAINT_RADIAL_GRADIENT:

   130 			return HostVgGetParameteri(aVgContext, aParamType);

   131 		}

   132 

   133 	// invalid ParamType

   134 	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   135 	return 0;

   136 	}

   137 

   138 

   139 void CVgPaintInfo::GetParameterfv(MVgContext& aVgContext, VGint aParamType, VGint aCount, VGfloat * aValues)

   140 	{

   141 	if (aCount > 0)

   142 		{

   143 		// vSize = 0 means the ParamType is not valid for this object, and VG error is already set 

   144 		VGint vSize = GetParameterVectorSize(aVgContext, aParamType);

   145 		if (vSize == 0)

   146 			{ // VG Error already set

   147 			return;

   148 			}

   149 

   150 		if ( (aCount <= vSize) )

   151 			{

   152 			switch (aParamType)

   153 				{

   154 				case VG_PAINT_TYPE:

   155 					*aValues = (VGfloat) iPaintType;

   156 					return;

   157 				case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

   158 					*aValues = (VGfloat) iColorRampSpreadMode;

   159 					return;

   160 				case VG_PAINT_PATTERN_TILING_MODE:

   161 					*aValues = (VGfloat) iPatternTilingMode;

   162 					return;

   163 				case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

   164 					*aValues = (VGfloat) iColorRampPremultiplied;

   165 					return;

   166 				case VG_PAINT_COLOR:

   167 				case VG_PAINT_COLOR_RAMP_STOPS:

   168 				case VG_PAINT_LINEAR_GRADIENT:

   169 				case VG_PAINT_RADIAL_GRADIENT:

   170 					HostVgGetParameterfv(aVgContext, aParamType, aCount, aValues);

   171 					return;

   172 				}

   173 			}

   174 		}

   175 

   176 	// invalid ParamType

   177 	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   178 	return;

   179 	}

   180 

   181 

   182 void CVgPaintInfo::GetParameteriv(MVgContext& aVgContext, VGint aParamType, VGint aCount, VGint * aValues)

   183 	{

   184 	if (aCount > 0)

   185 		{

   186 		// vSize = 0 means the ParamType is not valid for this object, and VG error is already set 

   187 		VGint vSize = GetParameterVectorSize(aVgContext, aParamType);

   188 		if (vSize == 0)

   189 			{ // VG Error already set

   190 			return;

   191 			}

   192 

   193 		if ( (aCount <= vSize) )

   194 			{

   195 			switch (aParamType)

   196 				{

   197 				case VG_PAINT_TYPE:

   198 					*aValues = iPaintType;

   199 					return;

   200 				case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

   201 					*aValues = iColorRampSpreadMode;

   202 					return;

   203 				case VG_PAINT_PATTERN_TILING_MODE:

   204 					*aValues = iPatternTilingMode;

   205 					return;

   206 				case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

   207 					*aValues = iColorRampPremultiplied;

   208 					return;

   209 				case VG_PAINT_COLOR:

   210 				case VG_PAINT_COLOR_RAMP_STOPS:

   211 				case VG_PAINT_LINEAR_GRADIENT:

   212 				case VG_PAINT_RADIAL_GRADIENT:

   213 					HostVgGetParameteriv(aVgContext, aParamType, aCount, aValues);

   214 					return;

   215 				}

   216 			}

   217 		}

   218 

   219 	// invalid ParamType

   220 	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   221 	return;

   222 	}

   223 

   224 

   225 void CVgPaintInfo::SetParameterf(MVgContext& aVgContext, VGint aParamType, VGfloat aValue)

   226 	{

   227 	switch (aParamType)

   228 		{

   229 		case VG_PAINT_TYPE:

   230 		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

   231 		case VG_PAINT_PATTERN_TILING_MODE:

   232 		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

   233 			SetParameteri(aVgContext, aParamType, (VGint) aValue);

   234 			return;

   235 			// **** desireable: add full checks for valid Values

   236 		case VG_PAINT_COLOR:

   237 		case VG_PAINT_COLOR_RAMP_STOPS:

   238 		case VG_PAINT_LINEAR_GRADIENT:

   239 		case VG_PAINT_RADIAL_GRADIENT:

   240 			HostVgSetParameterf(aVgContext, aParamType, aValue);

   241 			return;

   242 		}

   243 	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR); // invalid or Read-Only parameter

   244 	}

   245 

   246 

   247 void CVgPaintInfo::SetParameteri(MVgContext& aVgContext, VGint aParamType, VGint aValue)

   248 	{

   249 	switch (aParamType)

   250 		{

   251 		case VG_PAINT_TYPE:

   252 			if ( (aValue >= VG_PAINT_TYPE_COLOR) && (aValue <= VG_PAINT_TYPE_PATTERN) )

   253 				{

   254 				iPaintType = (VGPaintType) aValue;

   255 				HostVgSetParameteri(aVgContext, aParamType, aValue);

   256 				return;

   257 				}

   258 			break;

   259 		case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

   260 			if ( (aValue >= VG_COLOR_RAMP_SPREAD_PAD) && (aValue <= VG_COLOR_RAMP_SPREAD_REFLECT) )

   261 				{

   262 				iColorRampSpreadMode = (VGColorRampSpreadMode) aValue;

   263 				HostVgSetParameteri(aVgContext, aParamType, aValue);

   264 				return;

   265 				}

   266 			break;

   267 		case VG_PAINT_PATTERN_TILING_MODE:

   268 			if ( (aValue >= VG_TILE_FILL) && (aValue <= VG_TILE_REFLECT) )

   269 				{

   270 				iPatternTilingMode = (VGTilingMode) aValue;

   271 				HostVgSetParameteri(aVgContext, aParamType, aValue);

   272 				return;

   273 				}

   274 			break;

   275 		case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

   276 			if ( (aValue == VG_FALSE) || (aValue == VG_TRUE) )

   277 				{

   278 				iColorRampPremultiplied = (VGboolean) aValue;

   279 				HostVgSetParameteri(aVgContext, aParamType, aValue);

   280 				return;

   281 				}

   282 			break;

   283 			// **** desireable: add full checks for valid Values

   284 		case VG_PAINT_COLOR:

   285 		case VG_PAINT_COLOR_RAMP_STOPS:

   286 		case VG_PAINT_LINEAR_GRADIENT:

   287 		case VG_PAINT_RADIAL_GRADIENT:

   288 			HostVgSetParameteri(aVgContext, aParamType, aValue);

   289 			return;

   290 		}

   291 	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR); // invalid or Read-Only parameter

   292 	}

   293 

   294 

   295 void CVgPaintInfo::SetParameterfv(MVgContext& aVgContext, VGint aParamType, VGint aCount, const VGfloat * aValues)

   296 	{

   297 	VGint vSize = GetParameterVectorSize(aVgContext, aParamType);

   298 	if (vSize > 0)

   299 		{

   300 		if ( (aCount == 0) && (aValues == NULL) )

   301 			{ // pointless but legal according to Open VG 1.1 spec

   302 			return;

   303 			}

   304 

   305 		if ( (aCount > 0) && (aCount <= vSize) )

   306 			{

   307 			switch (aParamType)

   308 				{

   309 				case VG_PAINT_TYPE:

   310 				case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

   311 				case VG_PAINT_PATTERN_TILING_MODE:

   312 				case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

   313 					SetParameteri(aVgContext, aParamType, (VGint) *aValues);

   314 					return;

   315 				case VG_PAINT_COLOR:

   316 				case VG_PAINT_COLOR_RAMP_STOPS:

   317 				case VG_PAINT_LINEAR_GRADIENT:

   318 				case VG_PAINT_RADIAL_GRADIENT:

   319 					HostVgSetParameterfv(aVgContext, aParamType, aCount, aValues);

   320 					return;

   321 				}

   322 			}

   323 		// VGPaint parameter is Read-Only or should have a smaller vector

   324 		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR); 

   325 		}

   326 	}

   327 

   328 

   329 void CVgPaintInfo::SetParameteriv(MVgContext& aVgContext, VGint aParamType, VGint aCount, const VGint * aValues)

   330 	{

   331 	VGint vSize = GetParameterVectorSize(aVgContext, aParamType);

   332 	if (vSize > 0)

   333 		{

   334 		if ( (aCount == 0) && (aValues == NULL) )

   335 			{ // pointless but legal according to Open VG 1.1 spec

   336 			return;

   337 			}

   338 

   339 		if ( (aCount > 0) && (aCount <= vSize) )

   340 			{

   341 			switch (aParamType)

   342 				{

   343 				case VG_PAINT_TYPE:

   344 				case VG_PAINT_COLOR_RAMP_SPREAD_MODE:

   345 				case VG_PAINT_PATTERN_TILING_MODE:

   346 				case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:

   347 					SetParameteri(aVgContext, aParamType, *aValues);

   348 					return;

   349 				case VG_PAINT_COLOR:

   350 				case VG_PAINT_COLOR_RAMP_STOPS:

   351 				case VG_PAINT_LINEAR_GRADIENT:

   352 				case VG_PAINT_RADIAL_GRADIENT:

   353 					HostVgSetParameteriv(aVgContext, aParamType, aCount, aValues);

   354 					return;

   355 				}

   356 			}

   357 		// VGPaint parameter is Read-Only or should have a smaller vector

   358 		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

   359 		}

   360 	}

   361 

   362 

   363 void CVgPaintInfo::SetPaint(MVgContext& aVgContext, VGbitfield aPaintModes)

   364 	{

   365 	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   366 	vgApiData.Init(OpenVgRFC::EvgSetPaint, RemoteFunctionCallData::EOpRequest);

   367 	vgApiData.AppendParam(iHostHandle);

   368 	vgApiData.AppendParam(aPaintModes);

   369 	aVgContext.ExecuteVgCommand(vgApiData);

   370 	}

   371 

   372 

   373 //static

   374 void CVgPaintInfo::ResetPaint(MVgContext& aVgContext)

   375 	{

   376 	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   377 	vgApiData.Init(OpenVgRFC::EvgSetPaint, RemoteFunctionCallData::EOpRequest);

   378 	vgApiData.AppendParam(VG_INVALID_HANDLE);

   379 	const VGuint KZero = 0; 

   380 	vgApiData.AppendParam(KZero);

   381 	aVgContext.ExecuteVgCommand(vgApiData);

   382 	}

   383 

   384 

   385 void CVgPaintInfo::SetColor(MVgContext& aVgContext, VGuint aRgba)

   386 	{

   387 	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   388 	vgApiData.Init(OpenVgRFC::EvgSetColor, RemoteFunctionCallData::EOpRequest);

   389 	vgApiData.AppendParam(iHostHandle);

   390 	vgApiData.AppendParam(aRgba);

   391 	aVgContext.ExecuteVgCommand(vgApiData);

   392 	}

   393 

   394 

   395 VGuint CVgPaintInfo::GetColor(MVgContext& aVgContext)

   396 	{

   397 	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   398 	vgApiData.Init(OpenVgRFC::EvgGetColor);

   399 	vgApiData.AppendParam(iHostHandle);

   400 	VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);

   401 	aVgContext.ExecuteVgCommand(vgApiData);

   402 	return vgApiData.ReturnValue();

   403 	}

   404 

   405 

   406 void CVgPaintInfo::PaintPattern(MVgContext& aVgContext, CVgImageInfo* aPatternInfo)

   407 	{

   408 	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

   409 	vgApiData.Init(OpenVgRFC::EvgPaintPattern, RemoteFunctionCallData::EOpRequest);

   410 	vgApiData.AppendParam(iHostHandle);

   411 	TUint64 sgId(0L);

   412 	if (aPatternInfo == NULL)

   413 		{

   414 		vgApiData.AppendParam(VG_INVALID_HANDLE);

   415 		}

   416 	else

   417 		{

   418 		vgApiData.AppendParam(aPatternInfo->HostHandle());

   419 		if (aPatternInfo->IsEglSibling())

   420 			{

   421 			sgId = aPatternInfo->SgImageId();

   422 			}

   423 		}

   424 	vgApiData.AppendTUint64(sgId);

   425 	aVgContext.ExecuteVgCommand(vgApiData);

   426 	}

   427 

   428 

   429 // end of file vgpaint.cpp