reactos/lib/gdiplus/gdiplus/pathgradient.c

   1 #include <windows.h>
   2 #include <GdiPlusPrivate.h>
   3 #include <debug.h>
   4
   5 /*
   6  * @unimplemented
   7  */
   8 GpStatus WINGDIPAPI
   9 GdipCreatePathGradient(GDIPCONST GpPointF* points,
  10   INT count,
  11   GpWrapMode wrapMode,
  12   GpPathGradient **polyGradient)
  13 {
  14   return NotImplemented;
  15 }
  16
  17 /*
  18  * @unimplemented
  19  */
  20 GpStatus WINGDIPAPI
  21 GdipCreatePathGradientI(GDIPCONST GpPoint* points,
  22   INT count,
  23   GpWrapMode wrapMode,
  24   GpPathGradient **polyGradient)
  25 {
  26   return NotImplemented;
  27 }
  28
  29 /*
  30  * @unimplemented
  31  */
  32 GpStatus WINGDIPAPI
  33 GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
  34   GpPathGradient **polyGradient)
  35 {
  36   return NotImplemented;
  37 }
  38
  39 /*
  40  * @unimplemented
  41  */
  42 GpStatus WINGDIPAPI
  43 GdipGetPathGradientCenterColor(GpPathGradient *brush,
  44   ARGB* colors)
  45 {
  46   return NotImplemented;
  47 }
  48
  49 /*
  50  * @unimplemented
  51  */
  52 GpStatus WINGDIPAPI
  53 GdipSetPathGradientCenterColor(GpPathGradient *brush,
  54   ARGB colors)
  55 {
  56   return NotImplemented;
  57 }
  58
  59 /*
  60  * @unimplemented
  61  */
  62 GpStatus WINGDIPAPI
  63 GdipGetPathGradientSurroundColorsWithCount(GpPathGradient *brush,
  64   ARGB* color,
  65   INT* count)
  66 {
  67   return NotImplemented;
  68 }
  69
  70 /*
  71  * @unimplemented
  72  */
  73 GpStatus WINGDIPAPI
  74 GdipSetPathGradientSurroundColorsWithCount(GpPathGradient *brush,
  75   GDIPCONST ARGB* color,
  76   INT* count)
  77 {
  78   return NotImplemented;
  79 }
  80
  81 /*
  82  * @unimplemented
  83  */
  84 GpStatus WINGDIPAPI
  85 GdipGetPathGradientPath(GpPathGradient *brush,
  86   GpPath *path)
  87 {
  88   return NotImplemented;
  89 }
  90
  91 /*
  92  * @unimplemented
  93  */
  94 GpStatus WINGDIPAPI
  95 GdipSetPathGradientPath(GpPathGradient *brush,
  96   GDIPCONST GpPath *path)
  97 {
  98   return NotImplemented;
  99 }
 100
 101 /*
 102  * @unimplemented
 103  */
 104 GpStatus WINGDIPAPI
 105 GdipGetPathGradientCenterPoint(GpPathGradient *brush,
 106   GpPointF* points)
 107 {
 108   return NotImplemented;
 109 }
 110
 111 /*
 112  * @unimplemented
 113  */
 114 GpStatus WINGDIPAPI
 115 GdipGetPathGradientCenterPointI(GpPathGradient *brush,
 116   GpPoint* points)
 117 {
 118   return NotImplemented;
 119 }
 120
 121 /*
 122  * @unimplemented
 123  */
 124 GpStatus WINGDIPAPI
 125 GdipSetPathGradientCenterPoint(GpPathGradient *brush,
 126   GDIPCONST GpPointF* points)
 127 {
 128   return NotImplemented;
 129 }
 130
 131 /*
 132  * @unimplemented
 133  */
 134 GpStatus WINGDIPAPI
 135 GdipSetPathGradientCenterPointI(GpPathGradient *brush,
 136   GDIPCONST GpPoint* points)
 137 {
 138   return NotImplemented;
 139 }
 140
 141 /*
 142  * @unimplemented
 143  */
 144 GpStatus WINGDIPAPI
 145 GdipGetPathGradientRect(GpPathGradient *brush,
 146   GpRectF *rect)
 147 {
 148   return NotImplemented;
 149 }
 150
 151 /*
 152  * @unimplemented
 153  */
 154 GpStatus WINGDIPAPI
 155 GdipGetPathGradientRectI(GpPathGradient *brush,
 156   GpRect *rect)
 157 {
 158   return NotImplemented;
 159 }
 160
 161 /*
 162  * @unimplemented
 163  */
 164 GpStatus WINGDIPAPI
 165 GdipGetPathGradientPointCount(GpPathGradient *brush,
 166   INT* count)
 167 {
 168   return NotImplemented;
 169 }
 170
 171 /*
 172  * @unimplemented
 173  */
 174 GpStatus WINGDIPAPI
 175 GdipGetPathGradientSurroundColorCount(GpPathGradient *brush,
 176   INT* count)
 177 {
 178   return NotImplemented;
 179 }
 180
 181 /*
 182  * @unimplemented
 183  */
 184 GpStatus WINGDIPAPI
 185 GdipSetPathGradientGammaCorrection(GpPathGradient *brush,
 186   BOOL useGammaCorrection)
 187 {
 188   return NotImplemented;
 189 }
 190
 191 /*
 192  * @unimplemented
 193  */
 194 GpStatus WINGDIPAPI
 195 GdipGetPathGradientGammaCorrection(GpPathGradient *brush,
 196   BOOL *useGammaCorrection)
 197 {
 198   return NotImplemented;
 199 }
 200
 201 /*
 202  * @unimplemented
 203  */
 204 GpStatus WINGDIPAPI
 205 GdipGetPathGradientBlendCount(GpPathGradient *brush,
 206   INT *count)
 207 {
 208   return NotImplemented;
 209 }
 210
 211 /*
 212  * @unimplemented
 213  */
 214 GpStatus WINGDIPAPI
 215 GdipGetPathGradientBlend(GpPathGradient *brush,
 216   REAL *blend,
 217   REAL *positions,
 218   INT count)
 219 {
 220   return NotImplemented;
 221 }
 222
 223 /*
 224  * @unimplemented
 225  */
 226 GpStatus WINGDIPAPI
 227 GdipSetPathGradientBlend(GpPathGradient *brush,
 228   GDIPCONST REAL *blend,
 229   GDIPCONST REAL *positions,
 230   INT count)
 231 {
 232   return NotImplemented;
 233 }
 234
 235 /*
 236  * @unimplemented
 237  */
 238 GpStatus WINGDIPAPI
 239 GdipGetPathGradientPresetBlendCount(GpPathGradient *brush,
 240   INT *count)
 241 {
 242   return NotImplemented;
 243 }
 244
 245 /*
 246  * @unimplemented
 247  */
 248 GpStatus WINGDIPAPI
 249 GdipGetPathGradientPresetBlend(GpPathGradient *brush,
 250   ARGB *blend,
 251   REAL* positions,
 252   INT count)
 253 {
 254   return NotImplemented;
 255 }
 256
 257 /*
 258  * @unimplemented
 259  */
 260 GpStatus WINGDIPAPI
 261 GdipSetPathGradientPresetBlend(GpPathGradient *brush,
 262   GDIPCONST ARGB *blend,
 263   GDIPCONST REAL* positions,
 264   INT count)
 265 {
 266   return NotImplemented;
 267 }
 268
 269 /*
 270  * @unimplemented
 271  */
 272 GpStatus WINGDIPAPI
 273 GdipSetPathGradientSigmaBlend(GpPathGradient *brush,
 274   REAL focus,
 275   REAL scale)
 276 {
 277   return NotImplemented;
 278 }
 279
 280 /*
 281  * @unimplemented
 282  */
 283 GpStatus WINGDIPAPI
 284 GdipGetPathGradientWrapMode(GpPathGradient *brush,
 285   GpWrapMode *wrapmode)
 286 {
 287   return NotImplemented;
 288 }
 289
 290 /*
 291  * @unimplemented
 292  */
 293 GpStatus WINGDIPAPI
 294 GdipSetPathGradientWrapMode(GpPathGradient *brush,
 295   GpWrapMode wrapmode)
 296 {
 297   return NotImplemented;
 298 }
 299
 300 /*
 301  * @unimplemented
 302  */
 303 GpStatus WINGDIPAPI
 304 GdipGetPathGradientTransform(GpPathGradient *brush,
 305   GpMatrix *matrix)
 306 {
 307   return NotImplemented;
 308 }
 309
 310 /*
 311  * @unimplemented
 312  */
 313 GpStatus WINGDIPAPI
 314 GdipSetPathGradientTransform(GpPathGradient *brush,
 315   GpMatrix *matrix)
 316 {
 317   return NotImplemented;
 318 }
 319
 320 /*
 321  * @unimplemented
 322  */
 323 GpStatus WINGDIPAPI
 324 GdipResetPathGradientTransform(GpPathGradient* brush)
 325 {
 326   return NotImplemented;
 327 }
 328
 329 /*
 330  * @unimplemented
 331  */
 332 GpStatus WINGDIPAPI
 333 GdipMultiplyPathGradientTransform(GpPathGradient* brush,
 334   GDIPCONST GpMatrix *matrix,
 335   GpMatrixOrder order)
 336 {
 337   return NotImplemented;
 338 }
 339
 340 /*
 341  * @unimplemented
 342  */
 343 GpStatus WINGDIPAPI
 344 GdipTranslatePathGradientTransform(GpPathGradient* brush,
 345   REAL dx,
 346   REAL dy,
 347   GpMatrixOrder order)
 348 {
 349   return NotImplemented;
 350 }
 351
 352 /*
 353  * @unimplemented
 354  */
 355 GpStatus WINGDIPAPI
 356 GdipScalePathGradientTransform(GpPathGradient* brush,
 357   REAL sx,
 358   REAL sy,
 359   GpMatrixOrder order)
 360 {
 361   return NotImplemented;
 362 }
 363
 364 /*
 365  * @unimplemented
 366  */
 367 GpStatus WINGDIPAPI
 368 GdipRotatePathGradientTransform(GpPathGradient* brush,
 369   REAL angle,
 370   GpMatrixOrder order)
 371 {
 372   return NotImplemented;
 373 }
 374
 375 /*
 376  * @unimplemented
 377  */
 378 GpStatus WINGDIPAPI
 379 GdipGetPathGradientFocusScales(GpPathGradient *brush,
 380   REAL* xScale,
 381   REAL* yScale)
 382 {
 383   return NotImplemented;
 384 }
 385
 386 /*
 387  * @unimplemented
 388  */
 389 GpStatus WINGDIPAPI
 390 GdipSetPathGradientFocusScales(GpPathGradient *brush,
 391   REAL xScale,
 392   REAL yScale)
 393 {
 394   return NotImplemented;
 395 }