src/graphics/FGrp_CanvasImplPrivate.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /*
  19  * @file        FGrp_CanvasImplPrivate.h
  20  * @brief       This is the private header file for the _CanvasImpl class
  21  *
  22  */
  23
  24 #ifndef _FGRP_INTERNAL_CANVASIMPL_PRIVATE_H_
  25 #define _FGRP_INTERNAL_CANVASIMPL_PRIVATE_H_
  26
  27
  28 #include <FBaseSysLog.h>
  29
  30 #include "FGrp_CanvasImpl.h"
  31 #include "util/FGrp_UtilType.h"
  32
  33
  34 namespace // unnamed
  35 {
  36
  37 template <typename T>
  38 Tizen::Graphics::_Util::Rectangle<T>
  39 _GetBoundsRelT(const Tizen::Graphics::_CanvasImpl& canvas)
  40 {
  41         Tizen::Graphics::Rectangle bounds = canvas.GetBounds();
  42
  43         Tizen::Graphics::_Util::Rectangle<T> rect =
  44         {
  45                 0,
  46                 0,
  47                 bounds.width,
  48                 bounds.height
  49         };
  50
  51         return rect;
  52 }
  53
  54 template<typename T>
  55 void
  56 _ExpandClippingAreaForLineWidth(Tizen::Graphics::_Util::Rectangle<T>& rtCanvas, T lineWidth)
  57 {
  58         typedef T Type;
  59
  60         Type lineWidthHalf = (lineWidth + Type(1)) / Type(2);
  61
  62         rtCanvas.x -= lineWidthHalf;
  63         rtCanvas.y -= lineWidthHalf;
  64         rtCanvas.w += lineWidthHalf * Type(2);
  65         rtCanvas.h += lineWidthHalf * Type(2);
  66 }
  67
  68 }
  69
  70 namespace Tizen { namespace Graphics
  71 {
  72
  73 class _CanvasImplPrivate
  74 {
  75         friend class _CanvasImpl;
  76
  77         template <typename T>
  78         static result SetPixel(_CanvasImpl* pThis, const _Util::Point<T>& vcPoint)
  79         {
  80                 _Util::Rectangle<T> rtCanvas = _GetBoundsRelT<T>(*pThis);
  81
  82                 if (rtCanvas.w <= 0 || rtCanvas.h <= 0)
  83                 {
  84                         SysTryReturnResult(NID_GRP, 0, E_OPERATION_FAILED, "Cannot get the bounds of the canvas.");
  85                 }
  86
  87                 result r = _Util::ValidateT(vcPoint, rtCanvas);
  88
  89                 if (IsFailed(r))
  90                 {
  91                         SysTryReturn(NID_GRP, 0, r, r, "[%s] Propagating.", GetErrorMessage(r));
  92                 }
  93
  94                 if (_ResUtil::NeedToConvertCoord())
  95                 {
  96                         _Util::Point<T> pcPoint = _ResUtil::ConvertToPhyCoord(vcPoint);
  97
  98                         return pThis->_pNativeCanvas->SetPixel(pcPoint);
  99                 }
 100                 else
 101                 {
 102                         return pThis->_pNativeCanvas->SetPixel(vcPoint);
 103                 }
 104         }
 105
 106         template <typename T>
 107         static result DrawRectangle(_CanvasImpl* pThis, const _Util::Rectangle<T>& vcRect)
 108         {
 109                 typedef T Type;
 110
 111                 if ((vcRect.w == Type(0)) || (vcRect.h == Type(0)))
 112                 {
 113                         return E_SUCCESS;
 114                 }
 115
 116                 _Util::Rectangle<T> rtCanvas = _GetBoundsRelT<T>(*pThis);
 117
 118                 if (rtCanvas.w <= 0 || rtCanvas.h <= 0)
 119                 {
 120                         SysTryReturnResult(NID_GRP, 0, E_OPERATION_FAILED, "Cannot get the bounds of the canvas.");
 121                 }
 122
 123                 _ExpandClippingAreaForLineWidth(rtCanvas, Type(pThis->GetLineWidth()));
 124
 125                 result r = _Util::ValidateT(vcRect, rtCanvas);
 126
 127                 if (IsFailed(r))
 128                 {
 129                         SysTryReturn(NID_GRP, 0, r, r, "[%s] Propagating.", GetErrorMessage(r));
 130                 }
 131
 132                 if (_ResUtil::NeedToConvertCoord())
 133                 {
 134                         _Util::Rectangle<T> pcRect = _ResUtil::ConvertToPhyCoord(vcRect);
 135
 136                         return pThis->_pNativeCanvas->DrawRectangle(pcRect);
 137                 }
 138                 else
 139                 {
 140                         return pThis->_pNativeCanvas->DrawRectangle(vcRect);
 141                 }
 142         }
 143
 144         template <typename T>
 145         static result FillRectangle(_CanvasImpl* pThis, const Color& color, const _Util::Rectangle<T>& vcRect)
 146         {
 147                 typedef T Type;
 148
 149                 if ((vcRect.w == Type(0)) || (vcRect.h == Type(0)))
 150                 {
 151                         return E_SUCCESS;
 152                 }
 153
 154                 _Util::Rectangle<T> rtCanvas = _GetBoundsRelT<T>(*pThis);
 155
 156                 if (rtCanvas.w <= 0 || rtCanvas.h <= 0)
 157                 {
 158                         SysTryReturnResult(NID_GRP, 0, E_OPERATION_FAILED, "Cannot get the bounds of the canvas.");
 159                 }
 160
 161                 result r = _Util::ValidateT(vcRect, rtCanvas);
 162
 163                 if (IsFailed(r))
 164                 {
 165                         SysTryReturn(NID_GRP, 0, r, r, "[%s] Propagating.", GetErrorMessage(r));
 166                 }
 167
 168                 if (_ResUtil::NeedToConvertCoord())
 169                 {
 170                         _Util::Rectangle<T> pcRect = _ResUtil::ConvertToPhyCoord(vcRect);
 171
 172                         return pThis->_pNativeCanvas->FillRectangle(color, pcRect);
 173                 }
 174                 else
 175                 {
 176                         return pThis->_pNativeCanvas->FillRectangle(color, vcRect);
 177                 }
 178         }
 179
 180         template <typename T>
 181         static result DrawRoundRectangle(_CanvasImpl* pThis, const _Util::Rectangle<T>& vcRect, const _Util::Dimension<T>& vcArcDim)
 182         {
 183                 typedef T Type;
 184
 185                 if ((vcRect.w == Type(0)) || (vcRect.h == Type(0)))
 186                 {
 187                         return E_SUCCESS;
 188                 }
 189
 190                 if ((vcArcDim.w == Type(0)) || (vcArcDim.h == Type(0)))
 191                 {
 192                         return _CanvasImplPrivate::DrawRectangle(pThis, vcRect);
 193                 }
 194
 195                 _Util::Rectangle<T> rtCanvas = _GetBoundsRelT<T>(*pThis);
 196
 197                 if (rtCanvas.w <= 0 || rtCanvas.h <= 0)
 198                 {
 199                         SysTryReturnResult(NID_GRP, 0, E_OPERATION_FAILED, "Cannot get the bounds of the canvas.");
 200                 }
 201
 202                 _ExpandClippingAreaForLineWidth(rtCanvas, Type(pThis->GetLineWidth()));
 203
 204                 result r = _Util::ValidateT(vcRect, rtCanvas);
 205
 206                 if (IsFailed(r))
 207                 {
 208                         SysTryReturn(NID_GRP, 0, r, r, "[%s] Propagating.", GetErrorMessage(r));
 209                 }
 210
 211                 if (_ResUtil::NeedToConvertCoord())
 212                 {
 213                         _Util::Rectangle<T> pcRect = _ResUtil::ConvertToPhyCoord(vcRect);
 214                         _Util::Dimension<T> pcArcDim = _ResUtil::ConvertToPhyCoord(vcArcDim);
 215
 216                         return pThis->_pNativeCanvas->DrawRoundRectangle(pcRect, pcArcDim);
 217                 }
 218                 else
 219                 {
 220                         return pThis->_pNativeCanvas->DrawRoundRectangle(vcRect, vcArcDim);
 221                 }
 222         }
 223
 224         template <typename T>
 225         static result FillRoundRectangle(_CanvasImpl* pThis, const Color& color, const _Util::Rectangle<T>& vcRect, const _Util::Dimension<T>& vcArcDim)
 226         {
 227                 typedef T Type;
 228
 229                 if ((vcRect.w == Type(0)) || (vcRect.h == Type(0)))
 230                 {
 231                         return E_SUCCESS;
 232                 }
 233
 234                 _Util::Rectangle<T> rtCanvas = _GetBoundsRelT<T>(*pThis);
 235
 236                 if (rtCanvas.w <= 0 || rtCanvas.h <= 0)
 237                 {
 238                         SysTryReturnResult(NID_GRP, 0, E_OPERATION_FAILED, "Cannot get the bounds of the canvas.");
 239                 }
 240
 241                 result r = _Util::ValidateT(vcRect, rtCanvas);
 242
 243                 if (IsFailed(r))
 244                 {
 245                         SysTryReturn(NID_GRP, 0, r, r, "[%s] Propagating.", GetErrorMessage(r));
 246                 }
 247
 248                 if (_ResUtil::NeedToConvertCoord())
 249                 {
 250                         _Util::Rectangle<T> pcRect = _ResUtil::ConvertToPhyCoord(vcRect);
 251                         _Util::Dimension<T> pcArcDim = _ResUtil::ConvertToPhyCoord(vcArcDim);
 252
 253                         return pThis->_pNativeCanvas->FillRoundRectangle(color, pcRect, pcArcDim);
 254                 }
 255                 else
 256                 {
 257                         return pThis->_pNativeCanvas->FillRoundRectangle(color, vcRect, vcArcDim);
 258                 }
 259         }
 260
 261         template <typename T>
 262         static result DrawEllipse(_CanvasImpl* pThis, const _Util::Rectangle<T>& vcRect)
 263         {
 264                 typedef T Type;
 265
 266                 if ((vcRect.w == Type(0)) || (vcRect.h == Type(0)))
 267                 {
 268                         return E_SUCCESS;
 269                 }
 270
 271                 _Util::Rectangle<T> rtCanvas = _GetBoundsRelT<T>(*pThis);
 272
 273                 if (rtCanvas.w <= 0 || rtCanvas.h <= 0)
 274                 {
 275                         SysTryReturnResult(NID_GRP, 0, E_OPERATION_FAILED, "Cannot get the bounds of the canvas.");
 276                 }
 277
 278                 _ExpandClippingAreaForLineWidth(rtCanvas, Type(pThis->GetLineWidth()));
 279
 280                 result r = _Util::ValidateT(vcRect, rtCanvas);
 281
 282                 if (IsFailed(r))
 283                 {
 284                         SysTryReturn(NID_GRP, 0, r, r, "[%s] Propagating.", GetErrorMessage(r));
 285                 }
 286
 287                 if (_ResUtil::NeedToConvertCoord())
 288                 {
 289                         _Util::Rectangle<T> pcRect = _ResUtil::ConvertToPhyCoord(vcRect);
 290
 291                         return pThis->_pNativeCanvas->DrawEllipse(pcRect);
 292                 }
 293                 else
 294                 {
 295                         return pThis->_pNativeCanvas->DrawEllipse(vcRect);
 296                 }
 297         }
 298
 299         template <typename T>
 300         static result FillEllipse(_CanvasImpl* pThis, const Color& color, const _Util::Rectangle<T>& vcRect)
 301         {
 302                 typedef T Type;
 303
 304                 if ((vcRect.w == Type(0)) || (vcRect.h == Type(0)))
 305                 {
 306                         return E_SUCCESS;
 307                 }
 308
 309                 _Util::Rectangle<T> rtCanvas = _GetBoundsRelT<T>(*pThis);
 310
 311                 if (rtCanvas.w <= 0 || rtCanvas.h <= 0)
 312                 {
 313                         SysTryReturnResult(NID_GRP, 0, E_OPERATION_FAILED, "Cannot get the bounds of the canvas.");
 314                 }
 315
 316                 result r = _Util::ValidateT(vcRect, rtCanvas);
 317
 318                 if (IsFailed(r))
 319                 {
 320                         SysTryReturn(NID_GRP, 0, r, r, "[%s] Propagating.", GetErrorMessage(r));
 321                 }
 322
 323                 if (_ResUtil::NeedToConvertCoord())
 324                 {
 325                         _Util::Rectangle<T> pcRect = _ResUtil::ConvertToPhyCoord(vcRect);
 326
 327                         return pThis->_pNativeCanvas->FillEllipse(color, pcRect);
 328                 }
 329                 else
 330                 {
 331                         return pThis->_pNativeCanvas->FillEllipse(color, vcRect);
 332                 }
 333         }
 334
 335         template <typename T>
 336         static result DrawArc(_CanvasImpl* pThis, const _Util::Rectangle<T>& vcRect, T startAngle, T endAngle, ArcStyle arcStyle)
 337         {
 338                 typedef T Type;
 339
 340                 if ((vcRect.w == Type(0)) || (vcRect.h == Type(0)))
 341                 {
 342                         return E_SUCCESS;
 343                 }
 344
 345                 _Util::Rectangle<T> rtCanvas = _GetBoundsRelT<T>(*pThis);
 346
 347                 if (rtCanvas.w <= 0 || rtCanvas.h <= 0)
 348                 {
 349                         SysTryReturnResult(NID_GRP, 0, E_OPERATION_FAILED, "Cannot get the bounds of the canvas.");
 350                 }
 351
 352                 _ExpandClippingAreaForLineWidth(rtCanvas, Type(pThis->GetLineWidth()));
 353
 354                 result r = _Util::ValidateT(vcRect, rtCanvas);
 355
 356                 if (IsFailed(r))
 357                 {
 358                         SysTryReturn(NID_GRP, 0, r, r, "[%s] Propagating.", GetErrorMessage(r));
 359                 }
 360
 361                 if (_ResUtil::NeedToConvertCoord())
 362                 {
 363                         _Util::Rectangle<T> pcRect = _ResUtil::ConvertToPhyCoord(vcRect);
 364
 365                         return pThis->_pNativeCanvas->DrawArc(pcRect, startAngle, endAngle, arcStyle);
 366                 }
 367                 else
 368                 {
 369                         return pThis->_pNativeCanvas->DrawArc(vcRect, startAngle, endAngle, arcStyle);
 370                 }
 371         }
 372
 373         template <typename T>
 374         static result DrawTriangle(_CanvasImpl* pThis, const _Util::Point<T>& vcPoint1, const _Util::Point<T>& vcPoint2, const _Util::Point<T>& vcPoint3)
 375         {
 376                 typedef T Type;
 377
 378                 if (_ResUtil::NeedToConvertCoord())
 379                 {
 380                         _Util::Point<T> pcPoint1 = _ResUtil::ConvertToPhyCoord(vcPoint1);
 381                         _Util::Point<T> pcPoint2 = _ResUtil::ConvertToPhyCoord(vcPoint2);
 382                         _Util::Point<T> pcPoint3 = _ResUtil::ConvertToPhyCoord(vcPoint3);
 383
 384                         return pThis->_pNativeCanvas->DrawTriangle(pcPoint1, pcPoint2, pcPoint3);
 385                 }
 386                 else
 387                 {
 388                         return pThis->_pNativeCanvas->DrawTriangle(vcPoint1, vcPoint2, vcPoint3);
 389                 }
 390         }
 391
 392         template <typename T>
 393         static result FillTriangle(_CanvasImpl* pThis, const Color& color, const _Util::Point<T>& vcPoint1, const _Util::Point<T>& vcPoint2, const _Util::Point<T>& vcPoint3)
 394         {
 395                 typedef T Type;
 396
 397                 if (_ResUtil::NeedToConvertCoord())
 398                 {
 399                         _Util::Point<T> pcPoint1 = _ResUtil::ConvertToPhyCoord(vcPoint1);
 400                         _Util::Point<T> pcPoint2 = _ResUtil::ConvertToPhyCoord(vcPoint2);
 401                         _Util::Point<T> pcPoint3 = _ResUtil::ConvertToPhyCoord(vcPoint3);
 402
 403                         return pThis->_pNativeCanvas->FillTriangle(color, pcPoint1, pcPoint2, pcPoint3);
 404                 }
 405                 else
 406                 {
 407                         return pThis->_pNativeCanvas->FillTriangle(color, vcPoint1, vcPoint2, vcPoint3);
 408                 }
 409         }
 410
 411         template <typename T>
 412         static result DrawLine(_CanvasImpl* pThis, const _Util::Point<T>& vcPoint1, const _Util::Point<T>& vcPoint2)
 413         {
 414                 typedef T Type;
 415
 416                 if (_ResUtil::NeedToConvertCoord())
 417                 {
 418                         _Util::Point<T> pcPoint1 = _ResUtil::ConvertToPhyCoord(vcPoint1);
 419                         _Util::Point<T> pcPoint2 = _ResUtil::ConvertToPhyCoord(vcPoint2);
 420
 421                         return pThis->_pNativeCanvas->DrawLine(pcPoint1, pcPoint2);
 422                 }
 423                 else
 424                 {
 425                         return pThis->_pNativeCanvas->DrawLine(vcPoint1, vcPoint2);
 426                 }
 427         }
 428 };
 429
 430 }} // Tizen::Graphics
 431
 432 #endif // _FGRP_INTERNAL_CANVASIMPL_PRIVATE_H_