John Mitchell / lpc4088_displaymodule_GC500_2_5inch

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   DMBasicGUI DMSupport

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers GuiGraph.h Source File

GuiGraph.h

00001 /* ************************************************************************ */
00002 /*                                                                          */
00003 /*                     (C)2004-2015 IBIS Solutions ApS                      */
00004 /*                            sales@easyGUI.com                             */
00005 /*                             www.easyGUI.com                              */
00006 /*                                                                          */
00007 /*                         Graphics include library                         */
00008 /*                               v6.0.9.005                                 */
00009 /*                                                                          */
00010 /*     GuiLib.c include file - do NOT reference it in your linker setup     */
00011 /*                                                                          */
00012 /* ************************************************************************ */
00013 
00014 //==============================================================================
00015 #define GuiLib_DEG              10
00016 #define GuiLib_DEG360           360 * GuiLib_DEG
00017 
00018 #define GuiLib_RAD              4096
00019 #define GuiLib_RAD_QUARTER_PI   3217
00020 #define GuiLib_RAD_HALF_PI      6434
00021 #define GuiLib_RAD_PI           12868
00022 #define GuiLib_RAD_2_PI         25736
00023 #define GuiLib_RAD_TO_DEG       573
00024 
00025 //==============================================================================
00026 
00027 //------------------------------------------------------------------------------
00028 GuiConst_INT32S GuiLib_DegToRad(
00029    GuiConst_INT32S Angle)
00030 {
00031   return ((GuiLib_RAD * Angle) / GuiLib_RAD_TO_DEG);
00032 }
00033 
00034 //------------------------------------------------------------------------------
00035 GuiConst_INT32S GuiLib_RadToDeg(
00036    GuiConst_INT32S Angle)
00037 {
00038   return ((GuiLib_RAD_TO_DEG * Angle) / GuiLib_RAD);
00039 }
00040 
00041 //------------------------------------------------------------------------------
00042 GuiConst_INT32S GuiLib_SinRad(
00043    GuiConst_INT32S Angle)
00044 {
00045   GuiConst_INT32S A, B, X2;
00046 
00047   Angle %= GuiLib_RAD_2_PI;
00048 
00049   if (Angle > GuiLib_RAD_PI)
00050     X2 = GuiLib_RAD_2_PI - Angle;
00051   else
00052     X2 = Angle;
00053   if (X2 > GuiLib_RAD_HALF_PI)
00054     X2 = GuiLib_RAD_PI - X2;
00055 
00056   A = ((((X2 * X2) >> 12) * X2) / 6) >> 12;
00057   B = ((((A * X2) >> 12) * X2) / 20) >> 12;
00058   B = X2 - A + B - ((((B * X2) / 42) * X2) >> 24);
00059 
00060   if (Angle > GuiLib_RAD_PI)
00061     return (-B);
00062   else
00063     return (B);
00064 }
00065 
00066 //------------------------------------------------------------------------------
00067 GuiConst_INT32S GuiLib_SinDeg(
00068    GuiConst_INT32S Angle)
00069 {
00070   return (GuiLib_SinRad(GuiLib_DegToRad(Angle)));
00071 }
00072 
00073 //------------------------------------------------------------------------------
00074 GuiConst_INT32S GuiLib_CosRad(
00075    GuiConst_INT32S Angle)
00076 {
00077   GuiConst_INT32S A, B, C, X2;
00078 
00079   Angle %= GuiLib_RAD_2_PI;
00080 
00081   if (Angle > GuiLib_RAD_PI)
00082     Angle = GuiLib_RAD_2_PI - Angle;
00083   if (Angle > GuiLib_RAD_HALF_PI)
00084     X2 = GuiLib_RAD_PI - Angle;
00085   else
00086     X2 = Angle;
00087 
00088   A = (X2 * X2) >> 13;
00089   B = ((((A * X2) >> 12) * X2) / 12) >> 12;
00090   C = (((B * X2) / 30) * X2) >> 24;
00091   C = GuiLib_RAD - A + B - C + (((((C * X2) / 8) * X2) / 7) >> 24);
00092   if (Angle > GuiLib_RAD_HALF_PI)
00093     return (-C);
00094   else
00095     return (C);
00096 }
00097 
00098 //------------------------------------------------------------------------------
00099 GuiConst_INT32S GuiLib_CosDeg(
00100    GuiConst_INT32S Angle)
00101 {
00102   return (GuiLib_CosRad(GuiLib_DegToRad(Angle)));
00103 }
00104 
00105 //------------------------------------------------------------------------------
00106 GuiConst_INT32U GuiLib_Sqrt(
00107    GuiConst_INT32U X)
00108 {
00109   GuiConst_INT32U X1, X2;
00110 
00111   if (X == 0)
00112     return (0);
00113 
00114   X1 = (X / 2) + 1;
00115   X2 = (X1 + (X / X1)) / 2;
00116   while (X2 < X1)
00117   {
00118     X1 = X2;
00119     X2 = (X1 + (X / X1)) / 2;
00120   }
00121   return (X1);
00122 }
00123 
00124 //------------------------------------------------------------------------------
00125 GuiConst_INT8U GuiLib_GetRedRgbColor(
00126    GuiConst_INT32U RgbColor)
00127 {
00128   return (RgbColor & 0x000000FF);
00129 }
00130 
00131 //------------------------------------------------------------------------------
00132 GuiConst_INT32U GuiLib_SetRedRgbColor(
00133    GuiConst_INT32U RgbColor,
00134    GuiConst_INT8U RedColor)
00135 {
00136   return ((RgbColor & 0x00FFFF00) | RedColor);
00137 }
00138 
00139 //------------------------------------------------------------------------------
00140 GuiConst_INT8U GuiLib_GetGreenRgbColor(
00141    GuiConst_INT32U RgbColor)
00142 {
00143   return (GuiConst_INT8U)((RgbColor & 0x0000FF00) >> 8);
00144 }
00145 
00146 //------------------------------------------------------------------------------
00147 GuiConst_INT32U GuiLib_SetGreenRgbColor(
00148    GuiConst_INT32U RgbColor,
00149    GuiConst_INT8U GreenColor)
00150 {
00151   return ((RgbColor & 0x00FF00FF) | ((GuiConst_INT32U)GreenColor << 8));
00152 }
00153 
00154 //------------------------------------------------------------------------------
00155 GuiConst_INT8U GuiLib_GetBlueRgbColor(
00156    GuiConst_INT32U RgbColor)
00157 {
00158   return (GuiConst_INT8U)((RgbColor & 0x00FF0000) >> 16);
00159 }
00160 
00161 //------------------------------------------------------------------------------
00162 GuiConst_INT32U GuiLib_SetBlueRgbColor(
00163    GuiConst_INT32U RgbColor,
00164    GuiConst_INT8U BlueColor)
00165 {
00166   return ((RgbColor & 0xFF00FFFF) | ((GuiConst_INT32U)BlueColor << 16));
00167 }
00168 
00169 //------------------------------------------------------------------------------
00170 GuiConst_INTCOLOR GuiLib_RgbToPixelColor(
00171    GuiConst_INT32U RgbColor)
00172 {
00173 #ifdef GuiConst_COLOR_MODE_GRAY
00174   return ((GuiConst_COLOR_MAX *
00175      (GuiConst_INT16U)GuiLib_RgbColorToGrayScale(RgbColor)) / 255);
00176 #else
00177 #ifdef GuiConst_COLOR_MODE_PALETTE
00178   GuiConst_INT16U ColorR, ColorG, ColorB;
00179   GuiConst_INT16U I, I2, byte, shift;
00180   GuiConst_INT16U Rating, NewRating;
00181   GuiConst_INT32U PColor;
00182 
00183   ColorR = RgbColor & 0x000000FF;
00184   ColorG = (RgbColor & 0x0000FF00) >> 8;
00185   ColorB = (RgbColor & 0x00FF0000) >> 16;
00186 #ifndef GuiConst_COLOR_RGB_STANDARD
00187   ColorR = (GuiConst_COLORCODING_R_MAX * ColorR) / 255;
00188   ColorG = (GuiConst_COLORCODING_G_MAX * ColorG) / 255;
00189   ColorB = (GuiConst_COLORCODING_B_MAX * ColorB) / 255;
00190 #endif
00191   Rating = 0xFFFF;
00192   for (I = 0; I < GuiConst_PALETTE_SIZE; I++)
00193   {
00194     PColor = 0;
00195     for (byte=0,shift=0;byte < GuiConst_COLOR_BYTE_SIZE; byte++, shift +=8)
00196       PColor |= ((GuiConst_INT32U)GuiStruct_Palette[I][byte] << shift);
00197 
00198     NewRating =
00199        abs(ColorR - ((PColor & GuiConst_COLORCODING_R_MASK) >>
00200        GuiConst_COLORCODING_R_START)) +
00201        abs(ColorG - ((PColor & GuiConst_COLORCODING_G_MASK) >>
00202        GuiConst_COLORCODING_G_START)) +
00203        abs(ColorB - ((PColor & GuiConst_COLORCODING_B_MASK) >>
00204        GuiConst_COLORCODING_B_START));
00205     if (NewRating < Rating)
00206     {
00207       Rating = NewRating;
00208       I2 = I;
00209     }
00210   }
00211   return (I2);
00212 #else
00213 #ifdef GuiConst_COLOR_RGB_STANDARD
00214   return (RgbColor);
00215 #else
00216   return ((((GuiConst_COLORCODING_R_MAX *
00217      (RgbColor & 0x000000FF)) / 255) << GuiConst_COLORCODING_R_START) |
00218      (((GuiConst_COLORCODING_G_MAX *
00219      ((RgbColor & 0x0000FF00) >> 8)) / 255) << GuiConst_COLORCODING_G_START) |
00220      (((GuiConst_COLORCODING_B_MAX *
00221      ((RgbColor & 0x00FF0000) >> 16)) / 255) << GuiConst_COLORCODING_B_START));
00222 #endif
00223 #endif
00224 #endif
00225 }
00226 //------------------------------------------------------------------------------
00227 GuiConst_INTCOLOR GuiLib_Rgb888ToPixelColor(
00228    GuiConst_INT8U Red, GuiConst_INT8U Green, GuiConst_INT8U Blue)
00229 {
00230 #ifdef GuiConst_COLOR_MODE_GRAY
00231   return ((GuiConst_COLOR_MAX *
00232      (GuiConst_INT16U)GuiLib_Rgb888ColorToGrayScale(Red, Green, Blue)) / 255);
00233 #else
00234 #ifdef GuiConst_COLOR_MODE_PALETTE
00235   GuiConst_INT16U ColorR, ColorG, ColorB;
00236   GuiConst_INT16U I, I2, byte, shift;
00237   GuiConst_INT16U Rating, NewRating;
00238   GuiConst_INT32U PColor;
00239 
00240   ColorR = Red;
00241   ColorG = Green;
00242   ColorB = Blue;
00243 #ifndef GuiConst_COLOR_RGB_STANDARD
00244   ColorR = (GuiConst_COLORCODING_R_MAX * ColorR) / 255;
00245   ColorG = (GuiConst_COLORCODING_G_MAX * ColorG) / 255;
00246   ColorB = (GuiConst_COLORCODING_B_MAX * ColorB) / 255;
00247 #endif
00248   Rating = 0xFFFF;
00249   for (I = 0; I < GuiConst_PALETTE_SIZE; I++)
00250   {
00251     PColor = 0;
00252     for (byte=0,shift=0;byte < GuiConst_COLOR_BYTE_SIZE; byte++, shift +=8)
00253       PColor |= ((GuiConst_INT32U)GuiStruct_Palette[I][byte] << shift);
00254 
00255     NewRating =
00256        abs(ColorR - ((PColor & GuiConst_COLORCODING_R_MASK) >>
00257        GuiConst_COLORCODING_R_START)) +
00258        abs(ColorG - ((PColor & GuiConst_COLORCODING_G_MASK) >>
00259        GuiConst_COLORCODING_G_START)) +
00260        abs(ColorB - ((PColor & GuiConst_COLORCODING_B_MASK) >>
00261        GuiConst_COLORCODING_B_START));
00262     if (NewRating < Rating)
00263     {
00264       Rating = NewRating;
00265       I2 = I;
00266     }
00267   }
00268   return (I2);
00269 #else
00270 #ifdef GuiConst_COLOR_RGB_STANDARD
00271   return (Red | (Green << 8) | (Blue << 16));
00272 #else
00273   return ((((GuiConst_COLORCODING_R_MAX * Red) / 255)
00274               << GuiConst_COLORCODING_R_START) |
00275           (((GuiConst_COLORCODING_G_MAX * Green) / 255)
00276               << GuiConst_COLORCODING_G_START) |
00277           (((GuiConst_COLORCODING_B_MAX * Blue) / 255)
00278               << GuiConst_COLORCODING_B_START));
00279 #endif
00280 #endif
00281 #endif
00282 }
00283 //------------------------------------------------------------------------------
00284 GuiConst_INT32U GuiLib_PixelToRgbColor(
00285    GuiConst_INTCOLOR PixelColor)
00286 {
00287 #ifdef GuiConst_COLOR_MODE_GRAY
00288   GuiConst_INT16U GrayValue;
00289 
00290   GrayValue = (255 * PixelColor) / GuiConst_COLOR_MAX;
00291   return (GuiLib_GrayScaleToRgbColor((GuiConst_INT8U)GrayValue));
00292 #else
00293   GuiConst_INT32U PColor;
00294 #ifdef GuiConst_COLOR_MODE_PALETTE
00295   GuiConst_INT16U byte, shift;
00296 #endif
00297 #ifndef GuiConst_COLOR_RGB_STANDARD
00298   GuiConst_INT32U ColorR, ColorG, ColorB;
00299 #endif
00300 
00301 #ifdef GuiConst_COLOR_MODE_PALETTE
00302   PColor = 0;
00303   for (byte=0,shift=0;byte < GuiConst_COLOR_BYTE_SIZE; byte++, shift +=8)
00304     PColor |= ((GuiConst_INT32U)GuiStruct_Palette[PixelColor][byte] << shift);
00305 #else
00306   PColor = PixelColor;
00307 #endif
00308 
00309 #ifdef GuiConst_COLOR_RGB_STANDARD
00310   return (PColor);
00311 #else
00312   ColorR =
00313      (PColor & GuiConst_COLORCODING_R_MASK) >> GuiConst_COLORCODING_R_START;
00314   ColorG =
00315      (PColor & GuiConst_COLORCODING_G_MASK) >> GuiConst_COLORCODING_G_START;
00316   ColorB =
00317      (PColor & GuiConst_COLORCODING_B_MASK) >> GuiConst_COLORCODING_B_START;
00318   ColorR = (255 * ColorR) / GuiConst_COLORCODING_R_MAX;
00319   ColorG = (255 * ColorG) / GuiConst_COLORCODING_G_MAX;
00320   ColorB = (255 * ColorB) / GuiConst_COLORCODING_B_MAX;
00321   return (ColorR | (ColorG << 8) | (ColorB << 16));
00322 #endif
00323 #endif
00324 }
00325 
00326 //------------------------------------------------------------------------------
00327 GuiConst_INT8U GuiLib_RgbColorToGrayScale(
00328    GuiConst_INT32U RgbColor)
00329 {
00330   return (((RgbColor & 0x000000FF) +
00331      ((RgbColor & 0x0000FF00) >> 8) +
00332      ((RgbColor & 0x00FF0000) >> 16)) / 3);
00333 }
00334 
00335 //------------------------------------------------------------------------------
00336 GuiConst_INT8U GuiLib_Rgb888ColorToGrayScale(
00337    GuiConst_INT8U Red, GuiConst_INT8U Green, GuiConst_INT8U Blue)
00338 {
00339   return ((Red + Green + Blue) / 3);
00340 }
00341 
00342 //------------------------------------------------------------------------------
00343 GuiConst_INT32U GuiLib_GrayScaleToRgbColor(
00344    GuiConst_INT8U GrayValue)
00345 {
00346   return ((GuiConst_INT32U)GrayValue |
00347          ((GuiConst_INT32U)GrayValue << 8) |
00348          ((GuiConst_INT32U)GrayValue << 16));
00349 }
00350 
00351 //------------------------------------------------------------------------------
00352 GuiConst_INT8U GuiLib_PixelColorToGrayScale(
00353    GuiConst_INTCOLOR PixelColor)
00354 {
00355   return (GuiLib_RgbColorToGrayScale(GuiLib_PixelToRgbColor(PixelColor)));
00356 }
00357 
00358 //------------------------------------------------------------------------------
00359 GuiConst_INTCOLOR GuiLib_GrayScaleToPixelColor(
00360    GuiConst_INT8U GrayValue)
00361 {
00362   return (GuiLib_RgbToPixelColor(GuiLib_GrayScaleToRgbColor(GrayValue)));
00363 }
00364 
00365 //------------------------------------------------------------------------------
00366 GuiConst_INT32U GuiLib_BrightenRgbColor(
00367    GuiConst_INT32U RgbColor,
00368    GuiConst_INT16U Amount)
00369 {
00370   GuiConst_INT32U ColorR, ColorG, ColorB;
00371 
00372   if (Amount == 0)
00373     return (RgbColor);
00374   else
00375   {
00376     ColorR = 255 - ((GuiConst_INT32U)(255 - GuiLib_GetRedRgbColor(RgbColor)) *
00377        (1000 - Amount) / 1000);
00378     ColorG = 255 - ((GuiConst_INT32U)(255 - GuiLib_GetGreenRgbColor(RgbColor)) *
00379        (1000 - Amount) / 1000);
00380     ColorB = 255 - ((GuiConst_INT32U)(255 - GuiLib_GetBlueRgbColor(RgbColor)) *
00381        (1000 - Amount) / 1000);
00382     return (ColorR | (ColorG << 8) | (ColorB << 16));
00383   }
00384 }
00385 
00386 //------------------------------------------------------------------------------
00387 GuiConst_INTCOLOR GuiLib_BrightenPixelColor(
00388    GuiConst_INTCOLOR PixelColor,
00389    GuiConst_INT16U Amount)
00390 {
00391   return (GuiLib_RgbToPixelColor(
00392      GuiLib_BrightenRgbColor(GuiLib_PixelToRgbColor(PixelColor), Amount)));
00393 }
00394 
00395 //------------------------------------------------------------------------------
00396 GuiConst_INT32U GuiLib_DarkenRgbColor(
00397    GuiConst_INT32U RgbColor,
00398    GuiConst_INT16U Amount)
00399 {
00400   GuiConst_INT32U ColorR, ColorG, ColorB;
00401 
00402   if (Amount == 0)
00403     return (RgbColor);
00404   else
00405   {
00406     ColorR = (GuiConst_INT32U)GuiLib_GetRedRgbColor(RgbColor) *
00407        (1000 - Amount) / 1000;
00408     ColorG = (GuiConst_INT32U)GuiLib_GetGreenRgbColor(RgbColor) *
00409        (1000 - Amount) / 1000;
00410     ColorB = (GuiConst_INT32U)GuiLib_GetBlueRgbColor(RgbColor) *
00411        (1000 - Amount) / 1000;
00412     return (ColorR | (ColorG << 8) | (ColorB << 16));
00413   }
00414 }
00415 
00416 //------------------------------------------------------------------------------
00417 GuiConst_INTCOLOR GuiLib_DarkenPixelColor(
00418    GuiConst_INTCOLOR PixelColor,
00419    GuiConst_INT16U Amount)
00420 {
00421   return (GuiLib_RgbToPixelColor(
00422      GuiLib_DarkenRgbColor(GuiLib_PixelToRgbColor(PixelColor), Amount)));
00423 }
00424 
00425 //------------------------------------------------------------------------------
00426 GuiConst_INT32U GuiLib_MiddleRgbColor(
00427    GuiConst_INT32U RgbColor1,
00428    GuiConst_INT32U RgbColor2,
00429    GuiConst_INT16U Amount)
00430 {
00431   GuiConst_INT32S ColorR, ColorG, ColorB;
00432 
00433   if (Amount == 0)
00434     return (RgbColor1);
00435   else if (Amount >= 1000)
00436     return (RgbColor2);
00437   else
00438   {
00439     ColorR = (GuiConst_INT32U)GuiLib_GetRedRgbColor(RgbColor1);
00440     ColorR = ColorR + (((GuiConst_INT32S)Amount *
00441        ((GuiConst_INT32S)GuiLib_GetRedRgbColor(RgbColor2) - ColorR)) / 1000);
00442     ColorG = (GuiConst_INT32U)GuiLib_GetGreenRgbColor(RgbColor1);
00443     ColorG = ColorG + (((GuiConst_INT32S)Amount *
00444        ((GuiConst_INT32S)GuiLib_GetGreenRgbColor(RgbColor2) - ColorG)) / 1000);
00445     ColorB = (GuiConst_INT32U)GuiLib_GetBlueRgbColor(RgbColor1);
00446     ColorB = ColorB + (((GuiConst_INT32S)Amount *
00447        ((GuiConst_INT32S)GuiLib_GetBlueRgbColor(RgbColor2) - ColorB)) / 1000);
00448     return (ColorR | (ColorG << 8) | (ColorB << 16));
00449   }
00450 }
00451 
00452 // -----------------------------------------------------------------------------
00453 GuiConst_INTCOLOR GuiLib_MiddlePixelColor(
00454    GuiConst_INTCOLOR PixelColor1,
00455    GuiConst_INTCOLOR PixelColor2,
00456    GuiConst_INT16U Amount)
00457 {
00458   return (GuiLib_RgbToPixelColor(
00459      GuiLib_MiddleRgbColor(GuiLib_PixelToRgbColor(PixelColor1),
00460                            GuiLib_PixelToRgbColor(PixelColor2),
00461                            Amount)));
00462 }
00463 
00464 // -----------------------------------------------------------------------------
00465 GuiConst_INT32U GuiLib_DesaturateRgbColor(
00466    GuiConst_INT32U RgbColor,
00467    GuiConst_INT16U Amount)
00468 {
00469   GuiConst_INT32U GrayValue;
00470   GuiConst_INT32U ColorDesat;
00471 
00472   GrayValue = (GuiConst_INT32U)GuiLib_RgbColorToGrayScale(RgbColor);
00473   ColorDesat = GrayValue | (GrayValue << 8) | (GrayValue << 16);
00474   return (GuiLib_MiddleRgbColor(RgbColor, ColorDesat, Amount));
00475 }
00476 
00477 // -----------------------------------------------------------------------------
00478 GuiConst_INTCOLOR GuiLib_DesaturatePixelColor(
00479    GuiConst_INTCOLOR PixelColor,
00480    GuiConst_INT16U Amount)
00481 {
00482   return (GuiLib_RgbToPixelColor(
00483      GuiLib_DesaturateRgbColor(GuiLib_PixelToRgbColor(PixelColor), Amount)));
00484 }
00485 
00486 //------------------------------------------------------------------------------
00487 GuiConst_INT32U GuiLib_AccentuateRgbColor(
00488    GuiConst_INT32U RgbColor,
00489    GuiConst_INT16U Amount)
00490 {
00491   if (Amount == 0)
00492     return (RgbColor);
00493   else if (GuiLib_RgbColorToGrayScale(RgbColor) <= 127)
00494     return (GuiLib_BrightenRgbColor(RgbColor, Amount));
00495   else
00496     return (GuiLib_DarkenRgbColor(RgbColor, Amount));
00497 }
00498 
00499 //------------------------------------------------------------------------------
00500 GuiConst_INTCOLOR GuiLib_AccentuatePixelColor(
00501    GuiConst_INTCOLOR PixelColor,
00502    GuiConst_INT16U Amount)
00503 {
00504   return (GuiLib_RgbToPixelColor(
00505      GuiLib_AccentuateRgbColor(GuiLib_PixelToRgbColor(PixelColor), Amount)));
00506 }
00507 
00508 //------------------------------------------------------------------------------
00509 void Ellipse(
00510    GuiConst_INT16S X,
00511    GuiConst_INT16S Y,
00512    GuiConst_INT16U Radius1,
00513    GuiConst_INT16U Radius2,
00514    GuiConst_INT32S BorderColor,
00515    GuiConst_INT32S FillColor,
00516    GuiConst_INT8U Q1,
00517    GuiConst_INT8U Q2,
00518    GuiConst_INT8U Q3,
00519    GuiConst_INT8U Q4)
00520 {
00521   GuiConst_INT16S PX, PY;
00522   GuiConst_INT16S L1, L2, LP1, LP2, LX, LY;
00523   GuiConst_INT16S PX2, PY2;
00524   GuiConst_INTCOLOR BColor;
00525   GuiConst_INT8U Filling, LFilling, First;
00526   GuiConst_INT16S R1, R2;
00527   GuiConst_INT32S R22;
00528   GuiConst_INT8U Q12, Q34, Q14, Q23, Qfull;
00529 
00530   Filling = (FillColor != GuiLib_NO_COLOR);
00531   if (BorderColor == GuiLib_NO_COLOR)
00532   {
00533     if (!Filling)
00534       return;
00535     else
00536       BColor = (GuiConst_INTCOLOR)FillColor;
00537   }
00538   else
00539     BColor = (GuiConst_INTCOLOR)BorderColor;
00540 
00541   Q12 = (Q1 || Q2);
00542   Q34 = (Q3 || Q4);
00543   Q14 = (Q1 || Q4);
00544   Q23 = (Q2 || Q3);
00545   Qfull = Q1 & Q2 & Q3 & Q4;
00546   if (!(Q12 || Q34))
00547     return;
00548 
00549   if (Radius1 == 0)
00550   {
00551     if (Qfull)
00552       GuiLib_VLine(X, Y - Radius2, Y + Radius2, BColor);
00553     else if (Q12)
00554       GuiLib_VLine(X, Y, Y + Radius2, BColor);
00555     else
00556       GuiLib_VLine(X, Y - Radius2, Y, BColor);
00557   }
00558   else if (Radius2 == 0)
00559   {
00560     if (Qfull)
00561       GuiLib_HLine(X - Radius1, X + Radius1, Y, BColor);
00562     else if (Q14)
00563       GuiLib_HLine(X, X + Radius1, Y, BColor);
00564     else
00565       GuiLib_HLine(X - Radius1, X, Y, BColor);
00566   }
00567   else if (Radius1 == 1)
00568   {
00569     PY = Radius2 / 2;
00570     if (Q23)
00571     {
00572       if (Q2 && Q3)
00573         GuiLib_VLine(X - 1, Y - PY, Y + PY, BColor);
00574       else if (Q2)
00575         GuiLib_VLine(X - 1, Y, Y + PY, BColor);
00576       else
00577         GuiLib_VLine(X - 1, Y - PY, Y, BColor);
00578     }
00579     if (Q34)
00580       GuiLib_VLine(X, Y - Radius2, Y - PY - 1, BColor);
00581     if (Filling)
00582     {
00583       if (Q12 && Q34)
00584         GuiLib_VLine(X, Y - PY, Y + PY, (GuiConst_INTCOLOR)FillColor);
00585       else if (Q12)
00586         GuiLib_VLine(X, Y, Y + PY, (GuiConst_INTCOLOR)FillColor);
00587       else
00588         GuiLib_VLine(X, Y - PY, Y, (GuiConst_INTCOLOR)FillColor);
00589     }
00590     if (Q12)
00591       GuiLib_VLine(X, Y + PY + 1, Y + Radius2, BColor);
00592     if (Q14)
00593     {
00594       if (Q1 && Q4)
00595         GuiLib_VLine(X + 1, Y - PY, Y + PY, BColor);
00596       else if (Q1)
00597         GuiLib_VLine(X + 1, Y, Y + PY, BColor);
00598       else
00599         GuiLib_VLine(X + 1, Y - PY, Y, BColor);
00600     }
00601   }
00602   else if (Radius2 == 1)
00603   {
00604     PX = Radius1 / 2;
00605     if (Q34)
00606     {
00607       if (Q3 && Q4)
00608         GuiLib_HLine(X - PX, X + PX, Y - 1, BColor);
00609       else if (Q4)
00610         GuiLib_HLine(X, X + PX, Y - 1, BColor);
00611       else
00612         GuiLib_HLine(X - PX, X, Y - 1, BColor);
00613     }
00614     if (Q23)
00615       GuiLib_HLine(X - Radius1, X - PX - 1, Y, BColor);
00616     if (Filling)
00617     {
00618       if (Q14 && Q23)
00619         GuiLib_HLine(X - PX, X + PX, Y, (GuiConst_INTCOLOR)FillColor);
00620       else if (Q14)
00621         GuiLib_HLine(X, X + PX, Y, (GuiConst_INTCOLOR)FillColor);
00622       else
00623         GuiLib_HLine(X - PX, X, Y, (GuiConst_INTCOLOR)FillColor);
00624     }
00625     if (Q14)
00626       GuiLib_HLine(X + PX + 1, X + Radius1, Y, BColor);
00627     if (Q12)
00628     {
00629       if (Q1 && Q2)
00630         GuiLib_HLine(X - PX, X + PX, Y + 1, BColor);
00631       else if (Q1)
00632         GuiLib_HLine(X, X + PX, Y + 1, BColor);
00633       else
00634         GuiLib_HLine(X - PX, X, Y + 1, BColor);
00635     }
00636   }
00637   else
00638   {
00639     R1 = Radius1 << 3;
00640     R2 = Radius2 << 3;
00641 
00642     if (Radius1 >= Radius2)
00643     {
00644       R22 = (GuiConst_INT32S)R2 * R2;
00645 
00646       PX = 0;
00647       First = 1;
00648       for (PY = R2 - 4; PY >= 4; PY -= 8)
00649       {
00650         PX2 = PX + 8;
00651         PX = (GuiConst_INT16S)((R1 * GuiLib_Sqrt((0x00000400 -
00652            ((((GuiConst_INT32S)PY * (PY + 3)) << 10) / R22)) << 8)) >> 9) + 1;
00653         LY = (PY + 4) >> 3;
00654         if (First)
00655         {
00656           L1 = X - (PX >> 3);
00657           L2 = X + (PX >> 3);
00658           if (Q12)
00659           {
00660             if (Q1 && Q2)
00661               GuiLib_HLine(L1, L2, Y + LY, BColor);
00662             else if (Q1)
00663               GuiLib_HLine(X, L2, Y + LY, BColor);
00664             else
00665               GuiLib_HLine(L1, X, Y + LY, BColor);
00666           }
00667           if (Q34)
00668           {
00669             if (Q3 && Q4)
00670               GuiLib_HLine(L1, L2, Y - LY, BColor);
00671             else if (Q4)
00672               GuiLib_HLine(X, L2, Y - LY, BColor);
00673             else
00674               GuiLib_HLine(L1, X, Y - LY, BColor);
00675           }
00676           First = 0;
00677         }
00678         else
00679         {
00680           LP1 = X - (PX2 >> 3);
00681           LP2 = X + (PX2 >> 3);
00682           L1 = X - (PX >> 3);
00683           L2 = X + (PX >> 3);
00684           if (LP1 < L1)
00685           {
00686             LP1 = L1;
00687             LP2 = L2;
00688           }
00689           LFilling = Filling & (LP2 - LP1 >= 2);
00690 
00691           if (Q12)
00692           {
00693             if (Q2)
00694               GuiLib_HLine(L1, LP1, Y + LY, BColor);
00695             if (LFilling)
00696             {
00697               if (Q1 && Q2)
00698                 GuiLib_HLine(LP1 + 1, LP2 - 1, Y + LY,
00699                    (GuiConst_INTCOLOR)FillColor);
00700               else if (Q1)
00701                 GuiLib_HLine(X, LP2 - 1, Y + LY, (GuiConst_INTCOLOR)FillColor);
00702               else
00703                 GuiLib_HLine(LP1 + 1, X, Y + LY, (GuiConst_INTCOLOR)FillColor);
00704             }
00705             if (Q1)
00706               GuiLib_HLine(LP2, L2, Y + LY, BColor);
00707           }
00708           if (Q34)
00709           {
00710             if (Q3)
00711               GuiLib_HLine(L1, LP1, Y - LY, BColor);
00712             if (LFilling)
00713             {
00714               if (Q3 && Q4)
00715                 GuiLib_HLine(LP1 + 1, LP2 - 1, Y - LY,
00716                    (GuiConst_INTCOLOR)FillColor);
00717               else if (Q4)
00718                 GuiLib_HLine(X, LP2 - 1, Y - LY, (GuiConst_INTCOLOR)FillColor);
00719               else
00720                 GuiLib_HLine(LP1 + 1, X, Y - LY, (GuiConst_INTCOLOR)FillColor);
00721             }
00722             if (Q4)
00723               GuiLib_HLine(LP2, L2, Y - LY, BColor);
00724           }
00725         }
00726       }
00727       L1 = (PX + 8) >> 3;
00728       if (L1 > Radius1)
00729         L1 = Radius1;
00730 
00731       if (Q23)
00732         GuiLib_HLine(X - Radius1, X - L1, Y, BColor);
00733       if (Filling & (L1 >= 1))
00734       {
00735         if (Q14 && Q23)
00736           GuiLib_HLine(X - L1 + 1, X + L1 - 1, Y, (GuiConst_INTCOLOR)FillColor);
00737         else if (Q14)
00738           GuiLib_HLine(X, X + L1 - 1, Y, (GuiConst_INTCOLOR)FillColor);
00739         else
00740           GuiLib_HLine(X - L1 + 1, X, Y, (GuiConst_INTCOLOR)FillColor);
00741       }
00742       if (Q14)
00743         GuiLib_HLine(X + L1, X + Radius1, Y, BColor);
00744     }
00745     else
00746     {
00747       R22 = (GuiConst_INT32S)R1 * R1;
00748 
00749       PY = 0;
00750       First = 1;
00751       for (PX = R1 - 4; PX >= 4; PX -= 8)
00752       {
00753         PY2 = PY + 8;
00754         PY = (GuiConst_INT16S)((R2 * GuiLib_Sqrt((0x00000400 -
00755            ((((GuiConst_INT32S)PX * (PX + 3)) << 10) / R22)) << 8)) >> 9) + 1;
00756         LX = (PX + 4) >> 3;
00757         if (First)
00758         {
00759           L1 = Y - (PY >> 3);
00760           L2 = Y + (PY >> 3);
00761           if (Q14)
00762           {
00763             if (Q1 && Q4)
00764               GuiLib_VLine(X + LX, L1, L2, BColor);
00765             else if (Q1)
00766               GuiLib_VLine(X + LX, Y, L2, BColor);
00767             else
00768               GuiLib_VLine(X + LX, L1, Y, BColor);
00769           }
00770           if (Q23)
00771           {
00772             if (Q2 && Q3)
00773               GuiLib_VLine(X - LX, L1, L2, BColor);
00774             else if (Q2)
00775               GuiLib_VLine(X - LX, Y, L2, BColor);
00776             else
00777               GuiLib_VLine(X - LX, L1, Y, BColor);
00778           }
00779           First = 0;
00780         }
00781         else
00782         {
00783           LP1 = Y - (PY2 >> 3);
00784           LP2 = Y + (PY2 >> 3);
00785           L1 = Y - (PY >> 3);
00786           L2 = Y + (PY >> 3);
00787           if (LP1 < L1)
00788           {
00789             LP1 = L1;
00790             LP2 = L2;
00791           }
00792           LFilling = Filling & (LP2 - LP1 >= 2);
00793 
00794           if (Q14)
00795           {
00796             if (Q4)
00797               GuiLib_VLine(X + LX, L1, LP1, BColor);
00798             if (LFilling)
00799             {
00800               if (Q1 && Q4)
00801                 GuiLib_VLine(X + LX, LP1 + 1, LP2 - 1,
00802                    (GuiConst_INTCOLOR)FillColor);
00803               else if (Q1)
00804                 GuiLib_VLine(X + LX, Y, LP2 - 1, (GuiConst_INTCOLOR)FillColor);
00805               else
00806                 GuiLib_VLine(X + LX, LP1 + 1, Y, (GuiConst_INTCOLOR)FillColor);
00807             }
00808             if (Q1)
00809               GuiLib_VLine(X + LX, LP2, L2, BColor);
00810           }
00811           if (Q23)
00812           {
00813             if (Q3)
00814               GuiLib_VLine(X - LX, L1, LP1, BColor);
00815             if (LFilling)
00816             {
00817               if (Q2 && Q3)
00818                 GuiLib_VLine(X - LX, LP1 + 1, LP2 - 1,
00819                    (GuiConst_INTCOLOR)FillColor);
00820               else if (Q2)
00821                 GuiLib_VLine(X - LX, Y, LP2 - 1, (GuiConst_INTCOLOR)FillColor);
00822               else
00823                 GuiLib_VLine(X - LX, LP1 + 1, Y, (GuiConst_INTCOLOR)FillColor);
00824             }
00825             if (Q2)
00826               GuiLib_VLine(X - LX, LP2, L2, BColor);
00827           }
00828         }
00829       }
00830       L1 = (PY + 8) >> 3;
00831       if (L1 > Radius2)
00832         L1 = Radius2;
00833 
00834       if (Q34)
00835         GuiLib_VLine(X, Y - Radius2, Y - L1, BColor);
00836       if (Filling & (L1 >= 1))
00837       {
00838         if (Q12 && Q34)
00839           GuiLib_VLine(X, Y - L1 + 1, Y + L1 - 1, (GuiConst_INTCOLOR)FillColor);
00840         else if (Q12)
00841           GuiLib_VLine(X, Y, Y + L1 - 1, (GuiConst_INTCOLOR)FillColor);
00842         else
00843           GuiLib_VLine(X, Y - L1 + 1, Y, (GuiConst_INTCOLOR)FillColor);
00844       }
00845       if (Q12)
00846         GuiLib_VLine(X, Y + L1, Y + Radius2, BColor);
00847     }
00848   }
00849 }
00850 
00851 //------------------------------------------------------------------------------
00852 void Circle(
00853    GuiConst_INT16S X,
00854    GuiConst_INT16S Y,
00855    GuiConst_INT16U Radius,
00856    GuiConst_INTCOLOR Color,
00857    GuiConst_INT8U S0,
00858    GuiConst_INT8U S1,
00859    GuiConst_INT8U S2,
00860    GuiConst_INT8U S3,
00861    GuiConst_INT8U S4,
00862    GuiConst_INT8U S5,
00863    GuiConst_INT8U S6,
00864    GuiConst_INT8U S7,
00865    GuiConst_INT8U IF)
00866 {
00867   GuiConst_INT16S PX, PY, PX2;
00868   GuiConst_INT16S L1, L2, LP1, LP2, LX, LY, LX2;
00869   GuiConst_INT8U First;
00870   GuiConst_INT16S R;
00871   GuiConst_INT32S R2;
00872 
00873   if (!(S0 || S1 || S2 || S3 || S4 || S5 || S6 || S7))
00874     return;
00875   if (Radius == 0)
00876     return;
00877 
00878   if (Radius == 1)
00879   {
00880     if (S7 || S0)
00881       GuiLib_Dot(X + 1, Y, Color);
00882     if (S1 || S2)
00883       GuiLib_Dot(X, Y + 1, Color);
00884     if (S3 || S4)
00885       GuiLib_Dot(X - 1, Y, Color);
00886     if (S5 || S6)
00887       GuiLib_Dot(X, Y - 1, Color);
00888   }
00889   else
00890   {
00891     R = Radius << 3;
00892     R2 = (GuiConst_INT32S)R * R;
00893     First = 1;
00894     PX = 0;
00895 
00896     for (PY = R - 4; PY >= R / 2; PY -= 8)
00897     {
00898       PX2 = PX + 8;
00899       PX = (GuiConst_INT16S)((R * GuiLib_Sqrt((0x00000400 -
00900          ((((GuiConst_INT32S)PY * (PY + 3)) << 10) / R2)) << 8)) >> 9) + 1;
00901       LX2 = (PX2 + 4) >> 3;
00902       LX = (PX + 4) >> 3;
00903       LY = (PY + 4) >> 3;
00904       if (First)
00905       {
00906         if (S1 || S2)
00907         {
00908           if (S1)
00909             L2 = X + LX;
00910           else
00911             L2 = X;
00912           if (S2)
00913             L1 = X - LX;
00914           else
00915             L1 = X;
00916           GuiLib_HLine(L1, L2, Y + LY, Color);
00917           if (IF)
00918             GuiLib_HLine(L1, L2, Y + LY - 1, Color);
00919         }
00920         if (S5 || S6)
00921         {
00922           if (S5)
00923             L1 = X - LX;
00924           else
00925             L1 = X;
00926           if (S6)
00927             L2 = X + LX;
00928           else
00929             L2 = X;
00930           GuiLib_HLine(L1, L2, Y - LY, Color);
00931           if (IF)
00932             GuiLib_HLine(L1, L2, Y - LY +1, Color);
00933         }
00934 
00935         if (S3 || S4)
00936         {
00937           if (S3)
00938             L2 = Y + LX;
00939           else
00940             L2 = Y;
00941           if (S4)
00942             L1 = Y - LX;
00943           else
00944             L1 = Y;
00945           GuiLib_VLine(X - LY, L1, L2, Color);
00946           if (IF)
00947             GuiLib_VLine(X - LY + 1, L1, L2, Color);
00948         }
00949         if (S7 || S0)
00950         {
00951           if (S7)
00952             L1 = Y - LX;
00953           else
00954             L1 = Y;
00955           if (S0)
00956             L2 = Y + LX;
00957           else
00958             L2 = Y;
00959           GuiLib_VLine(X + LY, L1, L2, Color);
00960           if (IF)
00961             GuiLib_VLine(X + LY - 1, L1, L2, Color);
00962         }
00963 
00964         First = 0;
00965       }
00966       else if (LX < LY)
00967       {
00968         LP1 = X - LX2;
00969         LP2 = X + LX2;
00970         L1 = X - LX;
00971         L2 = X + LX;
00972 
00973         if (S1)
00974         {
00975           GuiLib_HLine(LP2, L2, Y + LY, Color);
00976           if (IF)
00977             GuiLib_HLine(LP2, L2, Y + LY - 1, Color);
00978         }
00979         if (S2)
00980         {
00981           GuiLib_HLine(L1, LP1, Y + LY, Color);
00982           if (IF)
00983             GuiLib_HLine(L1, LP1, Y + LY - 1, Color);
00984         }
00985 
00986         if (S5)
00987         {
00988           GuiLib_HLine(L1, LP1, Y - LY, Color);
00989           if (IF)
00990             GuiLib_HLine(L1, LP1, Y - LY + 1, Color);
00991         }
00992         if (S6)
00993         {
00994           GuiLib_HLine(LP2, L2, Y - LY, Color);
00995           if (IF)
00996             GuiLib_HLine(LP2, L2, Y - LY + 1, Color);
00997         }
00998 
00999         LP1 = Y - LX2;
01000         LP2 = Y + LX2;
01001         L1 = Y - LX;
01002         L2 = Y + LX;
01003 
01004         if (S7)
01005         {
01006           GuiLib_VLine(X + LY, L1, LP1, Color);
01007           if (IF)
01008             GuiLib_VLine(X + LY - 1, L1, LP1, Color);
01009         }
01010         if (S0)
01011         {
01012           GuiLib_VLine(X + LY, LP2, L2, Color);
01013           if (IF)
01014             GuiLib_VLine(X + LY - 1, LP2, L2, Color);
01015         }
01016 
01017         if (S3)
01018         {
01019           GuiLib_VLine(X - LY, LP2, L2, Color);
01020           if (IF)
01021             GuiLib_VLine(X - LY + 1, LP2, L2, Color);
01022         }
01023         if (S4)
01024         {
01025           GuiLib_VLine(X - LY, L1, LP1, Color);
01026           if (IF)
01027             GuiLib_VLine(X - LY + 1, L1, LP1, Color);
01028         }
01029       }
01030       else
01031       {
01032         if (S0)
01033         {
01034           GuiLib_Dot(X + LY, Y + LX2, Color);
01035           if (IF)
01036             GuiLib_Dot(X + LY - 1, Y + LX2, Color);
01037         }
01038         if (S1)
01039         {
01040           GuiLib_Dot(X + LX2, Y + LY, Color);
01041           if (IF)
01042             GuiLib_Dot(X + LX2, Y + LY - 1, Color);
01043         }
01044         if (S2)
01045         {
01046           GuiLib_Dot(X - LX2, Y + LY, Color);
01047           if (IF)
01048             GuiLib_Dot(X - LX2, Y + LY - 1, Color);
01049         }
01050         if (S3)
01051         {
01052           GuiLib_Dot(X - LY, Y + LX2, Color);
01053           if (IF)
01054             GuiLib_Dot(X - LY + 1, Y + LX2, Color);
01055         }
01056         if (S4)
01057         {
01058           GuiLib_Dot(X - LY, Y - LX2, Color);
01059           if (IF)
01060             GuiLib_Dot(X - LY + 1, Y - LX2, Color);
01061         }
01062         if (S5)
01063         {
01064           GuiLib_Dot(X - LX2, Y - LY, Color);
01065           if (IF)
01066             GuiLib_Dot(X - LX2, Y - LY + 1, Color);
01067         }
01068         if (S6)
01069         {
01070           GuiLib_Dot(X + LX2, Y - LY, Color);
01071           if (IF)
01072             GuiLib_Dot(X + LX2, Y - LY + 1, Color);
01073         }
01074         if (S7)
01075         {
01076           GuiLib_Dot(X + LY, Y - LX2, Color);
01077           if (IF)
01078             GuiLib_Dot(X + LY - 1, Y - LX2, Color);
01079         }
01080 
01081         break;
01082       }
01083     }
01084 
01085     if (S7 || S0)
01086       GuiLib_Dot(X + Radius, Y, Color);
01087     if (S3 || S4)
01088       GuiLib_Dot(X - Radius, Y, Color);
01089   }
01090 }
01091 
01092 //------------------------------------------------------------------------------
01093 void FilledCircle(
01094    GuiConst_INT16S X,
01095    GuiConst_INT16S Y,
01096    GuiConst_INT16U Radius,
01097    GuiConst_INTCOLOR Color)
01098 {
01099   GuiConst_INT16S PX, PY, PX2;
01100   GuiConst_INT16S LX, LY, LXY, LX2;
01101   GuiConst_INT16S R;
01102   GuiConst_INT32S R2;
01103 
01104   if (Radius == 0)
01105     return;
01106 
01107   if (Radius == 1)
01108   {
01109     GuiLib_Dot(X, Y - 1, Color);
01110     GuiLib_HLine(X - 1, X + 1, Y, Color);
01111     GuiLib_Dot(X, Y + 1, Color);
01112   }
01113   else
01114   {
01115     R = Radius << 3;
01116     R2 = (GuiConst_INT32S)R * R;
01117     LXY = (707 * (GuiConst_INT32S)Radius) / 1000;
01118     PX = 0;
01119     LY = 0;
01120 
01121     for (PY = R - 4; PY >= R / 2; PY -= 8)
01122     {
01123       PX2 = PX + 8;
01124       PX = (GuiConst_INT16S)((R * GuiLib_Sqrt((0x00000400 -
01125          ((((GuiConst_INT32S)PY * (PY + 3)) << 10) / R2)) << 8)) >> 9) + 1;
01126       LX2 = (PX2 + 4) >> 3;
01127       LX = (PX + 4) >> 3;
01128       LY = (PY + 4) >> 3;
01129 
01130       if (LX < LY)
01131       {
01132         GuiLib_HLine(X - LX, X + LX, Y + LY, Color);
01133         GuiLib_HLine(X - LX, X + LX, Y - LY, Color);
01134 
01135         if (LX > LXY)
01136           LX = LXY;
01137         GuiLib_VLine(X - LY, Y - LX, Y + LX, Color);
01138         GuiLib_VLine(X + LY, Y - LX, Y + LX, Color);
01139       }
01140       else
01141       {
01142         GuiLib_HLine(X - LX2, X + LX2, Y - LY, Color);
01143         GuiLib_HLine(X - LX2, X + LX2, Y + LY, Color);
01144         GuiLib_VLine(X - LY, Y - LX2, Y + LX2, Color);
01145         GuiLib_VLine(X + LY, Y - LX2, Y + LX2, Color);
01146 
01147         break;
01148       }
01149     }
01150     GuiLib_FillBox(X - LY + 1, Y - LY + 1, X + LY - 1, Y + LY - 1, Color);
01151   }
01152 }
01153 
01154 //------------------------------------------------------------------------------
01155 void GuiLib_Circle(
01156    GuiConst_INT16S X,
01157    GuiConst_INT16S Y,
01158    GuiConst_INT16U Radius,
01159    GuiConst_INT32S BorderColor,
01160    GuiConst_INT32S FillColor)
01161 {
01162   Ellipse(X, Y, Radius, Radius, BorderColor, FillColor, 1, 1, 1, 1);
01163 }
01164 
01165 //------------------------------------------------------------------------------
01166 void GuiLib_Ellipse(
01167    GuiConst_INT16S X,
01168    GuiConst_INT16S Y,
01169    GuiConst_INT16U Radius1,
01170    GuiConst_INT16U Radius2,
01171    GuiConst_INT32S BorderColor,
01172    GuiConst_INT32S FillColor)
01173 {
01174   Ellipse(X, Y, Radius1, Radius2, BorderColor, FillColor, 1, 1, 1, 1);
01175 }
01176 
01177 //==============================================================================
01178 
01179 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01180 //------------------------------------------------------------------------------
01181 void GuiLib_ResetClipping(void)
01182 {
01183   sgl.ClippingTotal = 0;
01184   SetClipping(
01185      0, 0, GuiConst_DISPLAY_WIDTH_HW - 1, GuiConst_DISPLAY_HEIGHT_HW - 1);
01186 }
01187 
01188 //------------------------------------------------------------------------------
01189 void GuiLib_SetClipping(
01190    GuiConst_INT16S X1,
01191    GuiConst_INT16S Y1,
01192    GuiConst_INT16S X2,
01193    GuiConst_INT16S Y2)
01194 {
01195   sgl.ClippingTotal = ((X1 > X2) || (Y1 > Y2));
01196 
01197   GuiLib_COORD_ADJUST(X1, Y1);
01198   GuiLib_COORD_ADJUST(X2, Y2);
01199   OrderCoord(&X1, &X2);
01200   OrderCoord(&Y1, &Y2);
01201 
01202   SetClipping(X1, Y1, X2, Y2);
01203 }
01204 #endif
01205 
01206 //------------------------------------------------------------------------------
01207 void GuiLib_ResetDisplayRepaint(void)
01208 {
01209   GuiConst_INT16S LineNo;
01210 
01211   if (!sgl.BaseLayerDrawing)
01212     return;
01213 
01214   for (LineNo = 0; LineNo < GuiConst_BYTE_LINES; LineNo++)
01215   {
01216     GuiLib_DisplayRepaint[LineNo].ByteEnd = -1;
01217     #ifdef GuiConst_VNC_REMOTE_SUPPORT_ON
01218     GuiLib_VncRepaint[LineNo].ByteEnd = -1;
01219     #endif
01220   }
01221 }
01222 
01223 //------------------------------------------------------------------------------
01224 void GuiLib_MarkDisplayBoxRepaint(
01225    GuiConst_INT16S X1,
01226    GuiConst_INT16S Y1,
01227    GuiConst_INT16S X2,
01228    GuiConst_INT16S Y2)
01229 {
01230   if (!sgl.BaseLayerDrawing)
01231     return;
01232 
01233   GuiLib_COORD_ADJUST(X1, Y1);
01234   GuiLib_COORD_ADJUST(X2, Y2);
01235   OrderCoord(&X1, &X2);
01236   OrderCoord(&Y1, &Y2);
01237 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01238   if (CheckRect (&X1, &Y1, &X2, &Y2))
01239 #endif
01240     MarkDisplayBoxRepaint(X1, Y1, X2, Y2);
01241 }
01242 
01243 //------------------------------------------------------------------------------
01244 void GuiLib_ClearDisplay(void)
01245 {
01246   ClearDisplay();
01247   MarkDisplayBoxRepaint(
01248      0, 0, GuiConst_DISPLAY_WIDTH_HW - 1, GuiConst_DISPLAY_HEIGHT_HW - 1);
01249 }
01250 
01251 //------------------------------------------------------------------------------
01252 void GuiLib_Dot(
01253    GuiConst_INT16S X,
01254    GuiConst_INT16S Y,
01255    GuiConst_INTCOLOR Color)
01256 {
01257   GuiLib_COORD_ADJUST(X, Y);
01258   GuiLib_COLOR_ADJUST(Color);
01259 
01260   MakeDot(X, Y, Color);
01261 }
01262 
01263 //------------------------------------------------------------------------------
01264 GuiConst_INTCOLOR GuiLib_GetDot(
01265    GuiConst_INT16S X,
01266    GuiConst_INT16S Y)
01267 {
01268   GuiLib_COORD_ADJUST(X, Y);
01269 
01270   return (ReadDot(X, Y));
01271 }
01272 
01273 //------------------------------------------------------------------------------
01274 void GuiLib_Line(
01275    GuiConst_INT16S X1,
01276    GuiConst_INT16S Y1,
01277    GuiConst_INT16S X2,
01278    GuiConst_INT16S Y2,
01279    GuiConst_INTCOLOR Color)
01280 {
01281   GuiConst_INT16S X, Y;
01282   GuiConst_INT16S PX1, PY1, PX2, PY2;
01283   GuiConst_INT16S RemCoord;
01284   GuiConst_INT32S Slope;
01285   GuiConst_INT16S Offset, NewOffset;
01286   GuiConst_INT16U OffsetCnt;
01287   GuiConst_INT16S OffsetDir;
01288 
01289   GuiLib_COORD_ADJUST(X1, Y1);
01290   GuiLib_COORD_ADJUST(X2, Y2);
01291   GuiLib_COLOR_ADJUST(Color);
01292 
01293   if (X1 == X2)
01294   {
01295     OrderCoord(&Y1, &Y2);
01296 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01297     if (CheckRect (&X1, &Y1, &X2, &Y2))
01298 #endif
01299     {
01300       VertLine(X1, Y1, Y2, Color);
01301       MarkDisplayBoxRepaint(X1, Y1, X1, Y2);
01302     }
01303   }
01304   else if (Y1 == Y2)
01305   {
01306     OrderCoord(&X1, &X2);
01307 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01308     if (CheckRect (&X1, &Y1, &X2, &Y2))
01309 #endif
01310     {
01311       HorzLine(X1, X2, Y1, Color);
01312       MarkDisplayBoxRepaint(X1, Y1, X2, Y1);
01313     }
01314   }
01315   else
01316   {
01317     Slope = labs ((10000 * (GuiConst_INT32S) (Y2 - Y1))) /
01318        labs ((GuiConst_INT32S) (X2 - X1));
01319 
01320     if (Slope <= 10000)
01321     {
01322       if (OrderCoord(&X1, &X2))
01323         SwapCoord(&Y1, &Y2);
01324 
01325       X = 0;
01326       Offset = 0;
01327       RemCoord = 0;
01328       OffsetCnt = 0;
01329       if (Y1 < Y2)
01330         OffsetDir = 1;
01331       else
01332         OffsetDir = -1;
01333       do
01334       {
01335         NewOffset = (((GuiConst_INT32S) X * Slope) + 5000) / 10000;
01336         if (((X > 0) && (NewOffset != Offset)) || (X > X2 - X1))
01337         {
01338           PX1 = X1 + RemCoord;
01339           PY1 = Y1 + OffsetDir * Offset;
01340           PX2 = PX1 + OffsetCnt - 1;
01341           if (OffsetCnt == 1)
01342             MakeDot(PX1, PY1, Color);
01343           else
01344 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01345                if (CheckRect (&PX1, &PY1, &PX2, &PY1))
01346 #endif
01347           {
01348             HorzLine(PX1, PX2, PY1, Color);
01349             MarkDisplayBoxRepaint(PX1, PY1, PX2, PY1);
01350           }
01351           OffsetCnt = 1;
01352           RemCoord = X;
01353 
01354           if (X > X2 - X1)
01355             return;
01356         }
01357         else
01358           OffsetCnt++;
01359 
01360         Offset = NewOffset;
01361         X++;
01362       }
01363       while (1);
01364     }
01365     else
01366     {
01367       if (OrderCoord(&Y1, &Y2))
01368         SwapCoord(&X1, &X2);
01369 
01370       Y = 0;
01371       Offset = 0;
01372       RemCoord = 0;
01373       OffsetCnt = 0;
01374       if (X1 < X2)
01375         OffsetDir = 1;
01376       else
01377         OffsetDir = -1;
01378       do
01379       {
01380         NewOffset = (((GuiConst_INT32S) Y * 10000) + (Slope / 2)) / Slope;
01381         if (((Y > 0) && (NewOffset != Offset)) || (Y > Y2 - Y1))
01382         {
01383           PX1 = X1 + OffsetDir * Offset;
01384           PY1 = Y1 + RemCoord;
01385           PY2 = PY1 + OffsetCnt - 1;
01386           if (OffsetCnt == 1)
01387             MakeDot(PX1, PY1, Color);
01388           else
01389 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01390                if (CheckRect (&PX1, &PY1, &PX1, &PY2))
01391 #endif
01392           {
01393             VertLine(PX1, PY1, PY2, Color);
01394             MarkDisplayBoxRepaint(PX1, PY1, PX1, PY2);
01395           }
01396           OffsetCnt = 1;
01397           RemCoord = Y;
01398 
01399           if (Y > Y2 - Y1)
01400             return;
01401         }
01402         else
01403           OffsetCnt++;
01404 
01405         Offset = NewOffset;
01406         Y++;
01407       }
01408       while (1);
01409     }
01410   }
01411 }
01412 
01413 //------------------------------------------------------------------------------
01414 void GuiLib_LinePattern(
01415    GuiConst_INT16S X1,
01416    GuiConst_INT16S Y1,
01417    GuiConst_INT16S X2,
01418    GuiConst_INT16S Y2,
01419    GuiConst_INT8U LinePattern,
01420    GuiConst_INTCOLOR Color)
01421 {
01422   GuiConst_INT16S X,Y;
01423   GuiConst_INT32S Slope;
01424   GuiConst_INT16S Offset;
01425   GuiConst_INT8U MaskTemp;
01426   GuiConst_INT8U MaskCtr = 0;
01427   GuiConst_INT8U Vertical;
01428 
01429   GuiLib_COORD_ADJUST(X1, Y1);
01430   GuiLib_COORD_ADJUST(X2, Y2);
01431   GuiLib_COLOR_ADJUST(Color);
01432 
01433   Vertical = (X1 == X2);
01434   if (Vertical)
01435     Offset = 0;
01436   else
01437     Slope = labs ((10000 * (GuiConst_INT32S)(Y2 - Y1))) /
01438             labs ((GuiConst_INT32S)(X2 - X1));
01439 
01440   if (Vertical || (Slope > 10000))
01441   {
01442     if (OrderCoord(&Y1, &Y2))
01443       SwapCoord(&X1, &X2);
01444 
01445     for (Y = 0; Y <= Y2 - Y1; Y++)
01446     {
01447       if (MaskCtr == 0 )
01448       {
01449         MaskCtr = 8;
01450         MaskTemp = LinePattern;
01451       }
01452       if (MaskTemp & 0x01)
01453       {
01454         if (!Vertical)
01455           Offset = (((GuiConst_INT32S) Y * 10000) + (Slope / 2)) / Slope;
01456         if (X1 < X2)
01457           MakeDot(X1 + Offset, Y1 + Y, Color);
01458         else
01459           MakeDot(X1 - Offset, Y1 + Y, Color);
01460       }
01461       MaskTemp >>= 1;
01462       MaskCtr--;
01463     }
01464   }
01465   else
01466   {
01467     if (OrderCoord(&X1, &X2))
01468       SwapCoord(&Y1, &Y2);
01469 
01470     for (X = 0; X <= X2 - X1; X++)
01471     {
01472       if (MaskCtr == 0 )
01473       {
01474         MaskCtr = 8;
01475         MaskTemp = LinePattern;
01476       }
01477 
01478       if (MaskTemp & 0x01)
01479       {
01480         Offset = (((GuiConst_INT32S) X * Slope) + 5000) / 10000;
01481         if (Y1 < Y2)
01482           MakeDot(X1 + X, Y1 + Offset, Color);
01483         else
01484           MakeDot(X1 + X, Y1 - Offset, Color);
01485       }
01486       MaskTemp >>= 1;
01487       MaskCtr--;
01488     }
01489   }
01490 }
01491 
01492 //------------------------------------------------------------------------------
01493 void GuiLib_HLine(
01494    GuiConst_INT16S X1,
01495    GuiConst_INT16S X2,
01496    GuiConst_INT16S Y,
01497    GuiConst_INTCOLOR Color)
01498 {
01499   GuiLib_Line(X1, Y, X2, Y, Color);
01500 }
01501 
01502 //------------------------------------------------------------------------------
01503 void GuiLib_VLine(
01504    GuiConst_INT16S X,
01505    GuiConst_INT16S Y1,
01506    GuiConst_INT16S Y2,
01507    GuiConst_INTCOLOR Color)
01508 {
01509   GuiLib_Line(X, Y1, X, Y2, Color);
01510 }
01511 
01512 //------------------------------------------------------------------------------
01513 void GuiLib_Box(
01514    GuiConst_INT16S X1,
01515    GuiConst_INT16S Y1,
01516    GuiConst_INT16S X2,
01517    GuiConst_INT16S Y2,
01518    GuiConst_INTCOLOR Color)
01519 {
01520   GuiConst_INT16S X1C;
01521   GuiConst_INT16S Y1C;
01522   GuiConst_INT16S X2C;
01523   GuiConst_INT16S Y2C;
01524 
01525   GuiLib_COORD_ADJUST(X1, Y1);
01526   GuiLib_COORD_ADJUST(X2, Y2);
01527   GuiLib_COLOR_ADJUST(Color);
01528 
01529   OrderCoord(&X1, &X2);
01530   OrderCoord(&Y1, &Y2);
01531 
01532   X1C = X1;
01533   Y1C = Y1;
01534   X2C = X2;
01535   Y2C = Y2;
01536 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01537   if (CheckRect(&X1C, &Y1C, &X2C, &Y2C))
01538 #endif
01539   {
01540     MarkDisplayBoxRepaint(X1C, Y1C, X2C, Y2C);
01541     X1C = X1;
01542     Y1C = Y1;
01543     X2C = X1;
01544     Y2C = Y2;
01545 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01546     if (CheckRect(&X1C, &Y1C, &X1C, &Y2C))
01547 #endif
01548       VertLine(X1C, Y1C, Y2C, Color);
01549     X1C = X2;
01550     Y1C = Y1;
01551     X2C = X2;
01552     Y2C = Y2;
01553 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01554     if (CheckRect(&X2C, &Y1C, &X2C, &Y2C))
01555 #endif
01556       VertLine(X2C, Y1C, Y2C, Color);
01557     if (X2 - X1 > 1)
01558     {
01559       X1C = X1 + 1;
01560       Y1C = Y1;
01561       X2C = X2 - 1;
01562 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01563       if (CheckRect(&X1C, &Y1C, &X2C, &Y1C))
01564 #endif
01565         HorzLine(X1C, X2C, Y1C, Color);
01566       X1C = X1 + 1;
01567       Y1C = Y2;
01568       X2C = X2 - 1;
01569       Y2C = Y2;
01570 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01571       if (CheckRect(&X1C, &Y2C, &X2C, &Y2C))
01572 #endif
01573         HorzLine(X1C, X2C, Y2C, Color);
01574     }
01575   }
01576 }
01577 
01578 //------------------------------------------------------------------------------
01579 void GuiLib_FillBox(
01580    GuiConst_INT16S X1,
01581    GuiConst_INT16S Y1,
01582    GuiConst_INT16S X2,
01583    GuiConst_INT16S Y2,
01584    GuiConst_INTCOLOR Color)
01585 {
01586   GuiLib_COORD_ADJUST(X1, Y1);
01587   GuiLib_COORD_ADJUST(X2, Y2);
01588   GuiLib_COLOR_ADJUST(Color);
01589 
01590   OrderCoord(&X1, &X2);
01591   OrderCoord(&Y1, &Y2);
01592 
01593 #ifdef GuiConst_CLIPPING_SUPPORT_ON
01594   if (CheckRect (&X1, &Y1, &X2, &Y2))
01595 #endif
01596   {
01597     MarkDisplayBoxRepaint(X1, Y1, X2, Y2);
01598 #ifdef GuiConst_BYTE_HORIZONTAL
01599     while (Y1 <= Y2)
01600     {
01601       HorzLine(X1, X2, Y1, Color);
01602       Y1++;
01603     }
01604 #else
01605     while (X1 <= X2)
01606     {
01607       VertLine(X1, Y1, Y2, Color);
01608       X1++;
01609     }
01610 #endif
01611   }
01612 }
01613 
01614 //------------------------------------------------------------------------------
01615 void GuiLib_BorderBox(
01616    GuiConst_INT16S X1,
01617    GuiConst_INT16S Y1,
01618    GuiConst_INT16S X2,
01619    GuiConst_INT16S Y2,
01620    GuiConst_INTCOLOR BorderColor,
01621    GuiConst_INTCOLOR FillColor)
01622 {
01623   GuiLib_Box(X1, Y1, X2, Y2, BorderColor);
01624   OrderCoord(&X1, &X2);
01625   OrderCoord(&Y1, &Y2);
01626   if (((X2 - X1) >= 2) && ((Y2 - Y1) >= 2))
01627     GuiLib_FillBox(X1+1, Y1+1, X2-1, Y2-1, FillColor);
01628 }
01629 
01630 #ifdef GuiConst_BITMAP_SUPPORT_ON
01631 //------------------------------------------------------------------------------
01632 static void ReadBitmapSizes(
01633    GuiConst_INT16U BitmapIndex)
01634 {
01635 #ifndef GuiConst_REMOTE_BITMAP_DATA
01636    GuiConst_INT8U PrefixRom * PixelDataPtr;
01637 #endif
01638 
01639 #ifdef GuiConst_REMOTE_BITMAP_DATA
01640   if (BitmapIndex != sgl.CurRemoteBitmap)
01641   {
01642     GuiLib_RemoteDataReadBlock(
01643        (GuiConst_INT32U PrefixRom)GuiStruct_BitmapPtrList[BitmapIndex],
01644        (GuiConst_INT32U PrefixRom)GuiStruct_BitmapPtrList[BitmapIndex + 1] -
01645        (GuiConst_INT32U PrefixRom)GuiStruct_BitmapPtrList[BitmapIndex],
01646        sgl.GuiLib_RemoteBitmapBuffer);
01647     sgl.CurRemoteBitmap = BitmapIndex;
01648   }
01649   sgl.BitmapSizeX = (GuiConst_INT16S)sgl.GuiLib_RemoteBitmapBuffer[0] +
01650                     256*(GuiConst_INT16S)sgl.GuiLib_RemoteBitmapBuffer[1];
01651   sgl.BitmapSizeY = (GuiConst_INT16S)sgl.GuiLib_RemoteBitmapBuffer[2] +
01652                     256*(GuiConst_INT16S)sgl.GuiLib_RemoteBitmapBuffer[3];
01653 #else
01654   PixelDataPtr =
01655      (GuiConst_INT8U PrefixRom *)ReadWord(GuiStruct_BitmapPtrList[BitmapIndex]);
01656 
01657   sgl.BitmapSizeX = (GuiConst_INT16S)*PixelDataPtr;
01658   PixelDataPtr++;
01659   sgl.BitmapSizeX += 256*(GuiConst_INT16S)*PixelDataPtr;
01660   PixelDataPtr++;
01661   sgl.BitmapSizeY = (GuiConst_INT16S)*PixelDataPtr;
01662   PixelDataPtr++;
01663   sgl.BitmapSizeY += 256*(GuiConst_INT16S)*PixelDataPtr;
01664   PixelDataPtr++;
01665 #endif
01666 }
01667 
01668 //------------------------------------------------------------------------------
01669 void GuiLib_ShowBitmap(
01670    GuiConst_INT16U BitmapIndex,
01671    GuiConst_INT16S X,
01672    GuiConst_INT16S Y,
01673    GuiConst_INT32S TranspColor)
01674 {
01675 #ifdef GuiConst_REMOTE_BITMAP_DATA
01676   if (BitmapIndex != sgl.CurRemoteBitmap)
01677   {
01678     GuiLib_RemoteDataReadBlock(
01679        (GuiConst_INT32U PrefixRom)GuiStruct_BitmapPtrList[BitmapIndex],
01680        (GuiConst_INT32U PrefixRom)GuiStruct_BitmapPtrList[BitmapIndex + 1] -
01681        (GuiConst_INT32U PrefixRom)GuiStruct_BitmapPtrList[BitmapIndex],
01682        sgl.GuiLib_RemoteBitmapBuffer);
01683     sgl.CurRemoteBitmap = BitmapIndex;
01684   }
01685   ShowBitmapArea(&sgl.GuiLib_RemoteBitmapBuffer[0],
01686      X, Y, 0, 0, 0, 0, TranspColor, GuiLib_FULL_BITMAP);
01687 #else
01688   ShowBitmapArea(
01689      (GuiConst_INT8U PrefixRom *)ReadWord(GuiStruct_BitmapPtrList[BitmapIndex]),
01690       X, Y, 0, 0, 0, 0, TranspColor, GuiLib_FULL_BITMAP);
01691 #endif
01692 }
01693 
01694 //------------------------------------------------------------------------------
01695 void GuiLib_ShowBitmapAt(
01696    GuiConst_INT8U * BitmapPtr,
01697    GuiConst_INT16S X,
01698    GuiConst_INT16S Y,
01699    GuiConst_INT32S TranspColor)
01700 {
01701   ShowBitmapArea(
01702      BitmapPtr, X, Y, 0, 0, 0, 0, TranspColor, GuiLib_FULL_BITMAP);
01703 }
01704 
01705 //------------------------------------------------------------------------------
01706 void GuiLib_ShowBitmapArea(
01707    GuiConst_INT16U BitmapIndex,
01708    GuiConst_INT16S X,
01709    GuiConst_INT16S Y,
01710    GuiConst_INT16S AX1,
01711    GuiConst_INT16S AY1,
01712    GuiConst_INT16S AX2,
01713    GuiConst_INT16S AY2,
01714    GuiConst_INT32S TranspColor)
01715 {
01716 #ifdef GuiConst_REMOTE_BITMAP_DATA
01717   if (BitmapIndex != sgl.CurRemoteBitmap)
01718   {
01719     GuiLib_RemoteDataReadBlock(
01720      (GuiConst_INT32U PrefixRom)GuiStruct_BitmapPtrList[BitmapIndex],
01721      (GuiConst_INT32U PrefixRom)GuiStruct_BitmapPtrList[BitmapIndex + 1] -
01722      (GuiConst_INT32U PrefixRom)GuiStruct_BitmapPtrList[BitmapIndex],
01723      sgl.GuiLib_RemoteBitmapBuffer);
01724   sgl.CurRemoteBitmap = BitmapIndex;
01725   }
01726   ShowBitmapArea(&sgl.GuiLib_RemoteBitmapBuffer[0],
01727    X, Y, AX1, AY1, AX2, AY2, TranspColor, GuiLib_AREA_BITMAP);
01728 #else
01729   ShowBitmapArea(
01730      (GuiConst_INT8U PrefixRom *)ReadWord(GuiStruct_BitmapPtrList[BitmapIndex]),
01731       X, Y, AX1, AY1, AX2, AY2, TranspColor, GuiLib_AREA_BITMAP);
01732 #endif
01733 }
01734 
01735 //------------------------------------------------------------------------------
01736 void GuiLib_ShowBitmapAreaAt(
01737    GuiConst_INT8U * BitmapPtr,
01738    GuiConst_INT16S X,
01739    GuiConst_INT16S Y,
01740    GuiConst_INT16S AX1,
01741    GuiConst_INT16S AY1,
01742    GuiConst_INT16S AX2,
01743    GuiConst_INT16S AY2,
01744    GuiConst_INT32S TranspColor)
01745 {
01746   ShowBitmapArea(
01747      BitmapPtr, X, Y, AX1, AY1, AX2, AY2, TranspColor, GuiLib_AREA_BITMAP);
01748 }
01749 #endif
01750
Generated on Tue Jul 19 2022 00:31:06 by  doxygen 1.7.2