John Mitchell
Single Photo displayed on LPC4088
Dependencies: DMBasicGUI DMSupport
Diff: easyGUIFixed/GuiLib.c
- Revision:
- 0:9140ec6aa604
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/easyGUIFixed/GuiLib.c Fri Jul 28 14:19:12 2017 +0000
@@ -0,0 +1,4965 @@
+/* ************************************************************************ */
+/* */
+/* (C)2004-2015 IBIS Solutions ApS */
+/* sales@easyGUI.com */
+/* www.easyGUI.com */
+/* */
+/* v6.0.9.005 */
+/* */
+/* ************************************************************************ */
+
+
+
+//------------------------------------------------------------------------------
+
+#include "GuiConst.h"
+#include "GuiLib.h"
+#include "GuiLibStruct.h"
+#ifdef GuiConst_VNC_REMOTE_SUPPORT_ON
+#include "GuiVnc.h"
+#endif
+#include <string.h>
+#include <stdlib.h>
+
+#ifndef GuiConst_PC_V6_0_9
+If your compiler sees this text you are using a wrong version of the easyGUI
+library. Version numbers of the easyGUI PC application and c library must match.
+Only exception is GuiDisplay.c/h (your display driver), which can be kept from
+version to version.
+#endif
+
+#define WANT_DOUBLE_BUFFERING // Also in GuiGraph16.h, GuiDisplay.c - *** all three must match ***
+
+
+#define GuiLib_CHR_PSLEFT_OFS 0
+#define GuiLib_CHR_PSRIGHT_OFS 5
+#define GuiLib_CHR_XLEFT_OFS 10
+#define GuiLib_CHR_XWIDTH_OFS 11
+#define GuiLib_CHR_YTOP_OFS 12
+#define GuiLib_CHR_YHEIGHT_OFS 13
+#define GuiLib_CHR_LINECTRL_OFS 14
+#define GuiLib_CHR_PS_TOP_OFS 0
+#define GuiLib_CHR_PS_MID_OFS 1
+#define GuiLib_CHR_PS_MIDBASE_OFS 2
+#define GuiLib_CHR_PS_BASE_OFS 3
+#define GuiLib_CHR_PS_BOTTOM_OFS 4
+
+
+
+#ifdef GuiConst_ARAB_CHARS_INUSE
+#define GuiLib_ARAB_LIGATURES_CNT 4
+const GuiConst_INT16U GuiLib_ARAB_LIGATURES[GuiLib_ARAB_LIGATURES_CNT][3] =
+ {{0x0644, 0x0622, 0xFEF5},
+ {0x0644, 0x0623, 0xFEF7},
+ {0x0644, 0x0625, 0xFEF9},
+ {0x0644, 0x0627, 0xFEFB}};
+
+#define GuiLib_ARAB_CHAR_PRI_MIN 0x0622
+#define GuiLib_ARAB_CHAR_PRI_MAX 0x06D6
+#define GuiLib_ARAB_CHAR_SEC_MIN 0xFB50
+#define GuiLib_ARAB_CHAR_SEC_MAX 0xFEF4
+#define GuiLib_ARAB_CHAR_TYPE_ISO 0
+#define GuiLib_ARAB_CHAR_TYPE_FIN 1
+#define GuiLib_ARAB_CHAR_TYPE_INI 2
+#define GuiLib_ARAB_CHAR_TYPE_MED 3
+#define GuiLib_ARAB_CHAR_ISOFIN 0x02
+#define GuiLib_ARAB_CHAR_ISOFININIMED 0x04
+#define GuiLib_ARAB_CHAR_DIACRITIC 0x0A
+#define GuiLib_ARAB_CHAR_CONVERT_CNT 83
+
+const GuiConst_INT16U GuiLib_ARAB_CHAR_CONVERT[GuiLib_ARAB_CHAR_CONVERT_CNT][3] =
+ {{0x0622, 0xFE81, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0623, 0xFE83, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0624, 0xFE85, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0625, 0xFE87, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0626, 0xFE89, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0627, 0xFE8D, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0628, 0xFE8F, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0629, 0xFE93, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x062A, 0xFE95, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x062B, 0xFE99, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x062C, 0xFE9D, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x062D, 0xFEA1, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x062E, 0xFEA5, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x062F, 0xFEA9, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0630, 0xFEAB, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0631, 0xFEAD, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0632, 0xFEAF, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0633, 0xFEB1, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0634, 0xFEB5, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0635, 0xFEB9, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0636, 0xFEBD, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0637, 0xFEC1, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0638, 0xFEC5, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0639, 0xFEC9, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x063A, 0xFECD, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0641, 0xFED1, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0642, 0xFED5, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0643, 0xFED9, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0644, 0xFEDD, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0645, 0xFEE1, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0646, 0xFEE5, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0647, 0xFEE9, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0648, 0xFEED, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0649, 0xFEEF, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x064A, 0xFEF1, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x064E, 0xFE76, GuiLib_ARAB_CHAR_DIACRITIC},
+ {0x064F, 0xFE78, GuiLib_ARAB_CHAR_DIACRITIC},
+ {0x0650, 0xFE7A, GuiLib_ARAB_CHAR_DIACRITIC},
+ {0x0651, 0xFE7C, GuiLib_ARAB_CHAR_DIACRITIC},
+ {0x0652, 0xFE7E, GuiLib_ARAB_CHAR_DIACRITIC},
+ {0x0671, 0xFB50, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0679, 0xFB66, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x067A, 0xFB5E, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x067B, 0xFB52, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x067E, 0xFB56, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x067F, 0xFB62, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0680, 0xFB5A, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0683, 0xFB76, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0684, 0xFB72, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0686, 0xFB7A, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0687, 0xFB7E, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x0688, 0xFB88, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x068C, 0xFB84, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x068D, 0xFB82, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x068E, 0xFB86, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0691, 0xFB8C, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x0698, 0xFB8A, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x06A4, 0xFB6A, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06A6, 0xFB6E, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06A9, 0xFB8E, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06AD, 0xFBD3, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06AF, 0xFB92, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06B1, 0xFB9A, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06B3, 0xFB96, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06BA, 0xFB9E, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x06BB, 0xFBA0, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06BE, 0xFBAA, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06C0, 0xFBA4, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x06C1, 0xFBA6, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06C5, 0xFBE0, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x06C6, 0xFBD9, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x06C7, 0xFBD7, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x06C8, 0xFBDB, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x06C9, 0xFBE2, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x06CB, 0xFBDE, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x06CC, 0xFBFC, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06D0, 0xFBE4, GuiLib_ARAB_CHAR_ISOFININIMED},
+ {0x06D2, 0xFBAE, GuiLib_ARAB_CHAR_ISOFIN},
+ {0x06D3, 0xFBB0, GuiLib_ARAB_CHAR_ISOFIN},
+ { 0, 0xFEF5, GuiLib_ARAB_CHAR_ISOFIN},
+ { 0, 0xFEF7, GuiLib_ARAB_CHAR_ISOFIN},
+ { 0, 0xFEF9, GuiLib_ARAB_CHAR_ISOFIN},
+ { 0, 0xFEFB, GuiLib_ARAB_CHAR_ISOFIN}};
+#endif
+
+//------------------------------------------------------------------------------
+//----------------------X-----------------------
+
+GuiLib_DisplayLineRec GuiLib_DisplayRepaint[GuiConst_BYTE_LINES];
+#ifdef GuiConst_VNC_REMOTE_SUPPORT_ON
+GuiLib_DisplayLineRec GuiLib_VncRepaint[GuiConst_BYTE_LINES];
+#endif // GuiConst_VNC_REMOTE_SUPPORT_ON
+
+#ifdef GuiConst_REMOTE_DATA
+void (*GuiLib_RemoteDataReadBlock) (
+ GuiConst_INT32U SourceOffset,
+ GuiConst_INT32U SourceSize,
+ GuiConst_INT8U * TargetAddr);
+#endif // GuiConst_REMOTE_DATA
+#ifdef GuiConst_REMOTE_TEXT_DATA
+void (*GuiLib_RemoteTextReadBlock) (
+ GuiConst_INT32U SourceOffset,
+ GuiConst_INT32U SourceSize,
+ void * TargetAddr);
+#endif // GuiConst_REMOTE_TEXT_DATA
+
+#ifdef GuiConst_CURSOR_SUPPORT_ON
+GuiConst_INT16S GuiLib_ActiveCursorFieldNo;
+#endif
+#ifdef GuiConst_ALLOW_UPSIDEDOWN_AT_RUNTIME
+GuiConst_INT8U GuiLib_DisplayUpsideDown;
+#endif
+
+GuiConst_INT16S GuiLib_CurStructureNdx;
+GuiConst_INT16S GuiLib_LanguageIndex;
+
+PrefixLocate GuiLib_GLOBAL gl;
+static PrefixLocate GuiLib_STATIC sgl;
+
+
+//==============================================================================
+#ifdef GuiConst_ALLOW_UPSIDEDOWN_AT_RUNTIME
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ if (GuiLib_DisplayUpsideDown) \
+ { \
+ X = GuiConst_DISPLAY_WIDTH_HW - 1 - sgl.CoordOrigoX - X; \
+ Y = GuiConst_DISPLAY_HEIGHT_HW - 1 - sgl.CoordOrigoY - Y; \
+ } \
+ else \
+ { \
+ X = sgl.CoordOrigoX + X; \
+ Y = sgl.CoordOrigoY + Y; \
+ } \
+ }
+
+ #define GuiLib_MIRROR_BITS(B) \
+ { \
+ B = (((B & 0x80) >> 7) | ((B & 0x40) >> 5) | \
+ ((B & 0x20) >> 3) | ((B & 0x10) >> 1) | \
+ ((B & 0x08) << 1) | ((B & 0x04) << 3) | \
+ ((B & 0x02) << 5) | ((B & 0x01) << 7)); \
+ }
+#else
+ #ifdef GuiConst_ROTATED_OFF
+ #ifdef GuiConst_MIRRORED_HORIZONTALLY
+ #ifdef GuiConst_MIRRORED_VERTICALLY
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = GuiConst_DISPLAY_WIDTH_HW - 1 - sgl.CoordOrigoX - X; \
+ Y = GuiConst_DISPLAY_HEIGHT_HW - 1 - sgl.CoordOrigoY - Y; \
+ }
+ #else
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = GuiConst_DISPLAY_WIDTH_HW - 1 - sgl.CoordOrigoX - X; \
+ Y = sgl.CoordOrigoY + Y; \
+ }
+ #endif
+ #else
+ #ifdef GuiConst_MIRRORED_VERTICALLY
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = sgl.CoordOrigoX + X; \
+ Y = GuiConst_DISPLAY_HEIGHT_HW - 1 - sgl.CoordOrigoY - Y; \
+ }
+ #else
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = sgl.CoordOrigoX + X; \
+ Y = sgl.CoordOrigoY + Y; \
+ }
+ #endif
+ #endif
+ #endif
+ #ifdef GuiConst_ROTATED_90DEGREE_RIGHT
+ #ifdef GuiConst_MIRRORED_HORIZONTALLY
+ #ifdef GuiConst_MIRRORED_VERTICALLY
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = sgl.CoordOrigoX + X; \
+ Y = GuiConst_DISPLAY_WIDTH_HW - 1 - sgl.CoordOrigoY - Y; \
+ SwapCoord(&X, &Y); \
+ }
+ #else
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = sgl.CoordOrigoX + X; \
+ Y = sgl.CoordOrigoY + Y; \
+ SwapCoord(&X, &Y); \
+ }
+ #endif
+ #else
+ #ifdef GuiConst_MIRRORED_VERTICALLY
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = GuiConst_DISPLAY_HEIGHT_HW - 1 - sgl.CoordOrigoX - X; \
+ Y = GuiConst_DISPLAY_WIDTH_HW - 1 - sgl.CoordOrigoY - Y; \
+ SwapCoord(&X, &Y); \
+ }
+ #else
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = GuiConst_DISPLAY_HEIGHT_HW - 1 - sgl.CoordOrigoX - X; \
+ Y = sgl.CoordOrigoY + Y; \
+ SwapCoord(&X, &Y); \
+ }
+ #endif
+ #endif
+ #endif
+ #ifdef GuiConst_ROTATED_UPSIDEDOWN
+ #ifdef GuiConst_MIRRORED_HORIZONTALLY
+ #ifdef GuiConst_MIRRORED_VERTICALLY
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = sgl.CoordOrigoX + X; \
+ Y = sgl.CoordOrigoY + Y; \
+ }
+ #else
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = sgl.CoordOrigoX + X; \
+ Y = GuiConst_DISPLAY_HEIGHT_HW - 1 - sgl.CoordOrigoY - Y; \
+ }
+ #endif
+ #else
+ #ifdef GuiConst_MIRRORED_VERTICALLY
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = GuiConst_DISPLAY_WIDTH_HW - 1 - sgl.CoordOrigoX - X; \
+ Y = sgl.CoordOrigoY + Y; \
+ }
+ #else
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = GuiConst_DISPLAY_WIDTH_HW - 1 - sgl.CoordOrigoX - X; \
+ Y = GuiConst_DISPLAY_HEIGHT_HW - 1 - sgl.CoordOrigoY - Y; \
+ }
+ #endif
+ #endif
+ #endif
+ #ifdef GuiConst_ROTATED_90DEGREE_LEFT
+ #ifdef GuiConst_MIRRORED_HORIZONTALLY
+ #ifdef GuiConst_MIRRORED_VERTICALLY
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = GuiConst_DISPLAY_HEIGHT_HW - 1 - sgl.CoordOrigoX - X; \
+ Y = sgl.CoordOrigoY + Y; \
+ SwapCoord(&X, &Y); \
+ }
+ #else
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = GuiConst_DISPLAY_HEIGHT_HW - 1 - sgl.CoordOrigoX - X; \
+ Y = GuiConst_DISPLAY_WIDTH_HW - 1 - sgl.CoordOrigoY - Y; \
+ SwapCoord(&X, &Y); \
+ }
+ #endif
+ #else
+ #ifdef GuiConst_MIRRORED_VERTICALLY
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = sgl.CoordOrigoX + X; \
+ Y = sgl.CoordOrigoY + Y; \
+ SwapCoord(&X, &Y); \
+ }
+ #else
+ #define GuiLib_COORD_ADJUST(X, Y) \
+ { \
+ X = sgl.CoordOrigoX + X; \
+ Y = GuiConst_DISPLAY_WIDTH_HW - 1 - sgl.CoordOrigoY - Y; \
+ SwapCoord(&X, &Y); \
+ }
+ #endif
+ #endif
+ #endif
+#endif
+
+#define GuiLib_FONT_MID_Y(BaseLine, TopLine) ((BaseLine - TopLine + 1) / 2)
+
+#ifdef GuiConst_COLOR_DEPTH_1
+#define GuiLib_COLOR_ADJUST(C) C &= 0x01;
+#endif
+#ifdef GuiConst_COLOR_DEPTH_2
+#define GuiLib_COLOR_ADJUST(C) C &= 0x03;
+#endif
+#ifdef GuiConst_COLOR_DEPTH_4
+#define GuiLib_COLOR_ADJUST(C) C &= 0x0F;
+#endif
+#ifdef GuiConst_COLOR_DEPTH_5
+#define GuiLib_COLOR_ADJUST(C) C = (C & 0x1F) << 3;
+#endif
+#ifndef GuiLib_COLOR_ADJUST
+#define GuiLib_COLOR_ADJUST_TRANSP(C)
+#define GuiLib_COLOR_ADJUST(C)
+#else
+#define GuiLib_COLOR_ADJUST_TRANSP(C) if (C != -1) GuiLib_COLOR_ADJUST(C)
+#endif
+//----------------------X-----------------------
+#define GuiLib_GET_MIN(A, B) ((A) > (B) ? (B) : (A))
+#define GuiLib_GET_MAX(A, B) ((A) > (B) ? (A) : (B))
+#define GuiLib_GET_MINMAX(X, A, B) ((X) > (A) ? (GuiLib_GET_MIN(X,B)) : (A))
+#define GuiLib_LIMIT_MIN(X, A) if (X < A) X = A
+#define GuiLib_LIMIT_MAX(X, B) if (X > B) X = B
+#define GuiLib_LIMIT_MINMAX(X, A, B) \
+{ \
+ if (X < A) \
+ X = A; \
+ else if ((B < A) && (X > A)) \
+ X = A; \
+ else if ((B >= A) && (X > B)) \
+ X = B; \
+}
+
+//==============================================================================
+
+//------------------------------------------------------------------------------
+static GuiConst_INT16S CopyBytes(GuiConst_INT8U *dst, GuiConst_INT8U *src, GuiConst_INT32S size)
+{
+ GuiConst_INT32S i;
+ GuiConst_INT8U *d, *s;
+
+ if (size < 0)
+ return -1;
+
+ if (size > GuiConst_DISPLAY_BYTES)
+ return -1;
+
+ d = (GuiConst_INT8U *)dst;
+ s = (GuiConst_INT8U *)src;
+
+ for (i=0;i<size;i++)
+ *d++ = *s++;
+
+ return 0;
+}
+//------------------------------------------------------------------------------
+static void SwapCoord(
+ GuiConst_INT16S * X1,
+ GuiConst_INT16S * X2)
+{
+ GuiConst_INT16S Tmp;
+
+ Tmp = *X1;
+ *X1 = *X2;
+ *X2 = Tmp;
+}
+
+//------------------------------------------------------------------------------
+static GuiConst_INT8U OrderCoord(
+ GuiConst_INT16S * X1,
+ GuiConst_INT16S * X2)
+{
+ if (*X1 > *X2)
+ {
+ SwapCoord (X1, X2);
+ return (1);
+ }
+ else
+ return (0);
+}
+
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+//------------------------------------------------------------------------------
+static GuiConst_INT8U CheckRect(
+ GuiConst_INT16S * X1,
+ GuiConst_INT16S * Y1,
+ GuiConst_INT16S * X2,
+ GuiConst_INT16S * Y2)
+{
+ if (sgl.ClippingTotal ||
+ (*X1 > sgl.ClippingX2) || (*X2 < sgl.ClippingX1) ||
+ (*Y1 > sgl.ClippingY2) || (*Y2 < sgl.ClippingY1))
+ return (0);
+ else
+ {
+ if (*X1 < sgl.ClippingX1)
+ *X1 = sgl.ClippingX1;
+ if (*X2 > sgl.ClippingX2)
+ *X2 = sgl.ClippingX2;
+ if (*Y1 < sgl.ClippingY1)
+ *Y1 = sgl.ClippingY1;
+ if (*Y2 > sgl.ClippingY2)
+ *Y2 = sgl.ClippingY2;
+ return (1);
+ }
+}
+#endif
+
+//==============================================================================
+
+#ifdef GuiConst_COLOR_DEPTH_1
+ #ifdef GuiConst_BYTE_HORIZONTAL
+ #include "GuiGraph1H.c"
+ #else
+ #include "GuiGraph1V.c"
+ #endif
+#endif
+#ifdef GuiConst_COLOR_DEPTH_2
+ #ifdef GuiConst_BYTE_HORIZONTAL
+ #ifdef GuiConst_COLOR_PLANES_2
+ #include "GuiGraph2H2P.c"
+ #else
+ #include "GuiGraph2H.c"
+ #endif
+ #else
+ #ifdef GuiConst_COLOR_PLANES_2
+ #include "GuiGraph2V2P.c"
+ #else
+ #include "GuiGraph2V.c"
+ #endif
+ #endif
+#endif
+#ifdef GuiConst_COLOR_DEPTH_4
+ #ifdef GuiConst_BYTE_HORIZONTAL
+ #include "GuiGraph4H.c"
+ #else
+ #include "GuiGraph4V.c"
+ #endif
+#endif
+#ifdef GuiConst_COLOR_DEPTH_5
+ #include "GuiGraph5.c"
+#endif
+#ifdef GuiConst_COLOR_DEPTH_8
+ #include "GuiGraph8.c"
+#endif
+#ifdef GuiConst_COLOR_DEPTH_12
+ #include "GuiGraph16.c"
+#endif
+#ifdef GuiConst_COLOR_DEPTH_15
+ #include "GuiGraph16.c"
+#endif
+#ifdef GuiConst_COLOR_DEPTH_16
+ #include "GuiGraph16.h"
+#endif
+#ifdef GuiConst_COLOR_DEPTH_18
+ #include "GuiGraph24.c"
+#endif
+#ifdef GuiConst_COLOR_DEPTH_24
+ #include "GuiGraph24.h"
+#endif
+#ifdef GuiConst_COLOR_DEPTH_32
+ #include "GuiGraph32.c"
+#endif
+
+#include "GuiGraph.h"
+#ifdef GuiConst_ADV_GRAPHICS_ON
+//#include "GuiGraphAdv.c"
+#endif
+
+//==============================================================================
+static void DrawStructure(GuiLib_StructPtr Structure, GuiConst_INT8U ColorInvert) PrefixReentrant;
+
+#ifdef GuiConst_CURSOR_SUPPORT_ON
+static void DrawCursorItem(GuiConst_INT8U CursorVisible);
+#endif
+
+#ifdef GuiConst_ITEM_SCROLLBOX_INUSE
+static void ScrollBox_DrawScrollLine(GuiConst_INT8U ScrollBoxIndex, GuiConst_INT16S LineNdx);
+#endif
+
+#ifdef GuiConst_ITEM_GRAPHICS_LAYER_FILTER_INUSE
+static GuiConst_INT16S IndexOfGraphicsLayer(GuiConst_INT16S GraphicsLayerIndex);
+static GuiConst_INT8U GraphicsLayer_Push(GuiConst_INT8U GraphicsLayerIndex);
+static GuiConst_INT8U GraphicsLayer_Pop(GuiConst_INT16S GraphicsLayerIndex);
+static void GraphicsLayer_Copy(
+ GuiConst_INT8U *DestAddress,
+ GuiConst_INT16U DestLineSize,
+ GuiConst_INT16S DestX,
+ GuiConst_INT16S DestY,
+ GuiConst_INT8U *SourceAddress,
+ GuiConst_INT16U SourceLineSize,
+ GuiConst_INT16S SourceX,
+ GuiConst_INT16S SourceY,
+ GuiConst_INT16U Width,
+ GuiConst_INT16U Height);
+#endif
+
+//==============================================================================
+
+//------------------------------------------------------------------------------
+static void ResetLayerBufPtr(void)
+{
+#ifdef GuiConst_DISPLAY_BUFFER_EASYGUI
+#ifdef GuiLib_COLOR_UNIT_16
+ sgl.CurLayerBufPtr = &(GuiLib_DisplayBuf.Bytes[0][0]);
+#else
+ #ifdef GuiConst_COLOR_DEPTH_2
+ #ifdef GuiConst_BYTE_HORIZONTAL
+ #ifdef GuiConst_COLOR_PLANES_2
+ sgl.CurLayerBufPtr = &(GuiLib_DisplayBuf[0][0][0]);
+ #else
+ sgl.CurLayerBufPtr = &(GuiLib_DisplayBuf[0][0]);
+ #endif
+ #else // GuiConst_BYTE_HORIZONTAL
+ #ifdef GuiConst_COLOR_PLANES_2
+ sgl.CurLayerBufPtr = &(GuiLib_DisplayBuf[0][0][0]);
+ #else
+ sgl.CurLayerBufPtr = &(GuiLib_DisplayBuf[0][0]);
+ #endif
+ #endif // GuiConst_BYTE_HORIZONTAL
+ #else // GuiConst_COLOR_DEPTH_2
+ sgl.CurLayerBufPtr = &(GuiLib_DisplayBuf[0][0]);
+ #endif // GuiConst_COLOR_DEPTH_2
+#endif // GuiLib_COLOR_UNIT_16
+#else // GuiConst_DISPLAY_BUFFER_EASYGUI
+ sgl.CurLayerBufPtr = 0;
+#endif // GuiConst_DISPLAY_BUFFER_EASYGUI
+
+ sgl.CurLayerLineSize = GuiConst_BYTES_PR_LINE;
+ sgl.CurLayerWidth = GuiConst_DISPLAY_WIDTH_HW;
+ sgl.CurLayerHeight = GuiConst_DISPLAY_HEIGHT_HW;
+ sgl.CurLayerBytes = GuiConst_DISPLAY_BYTES;
+ sgl.BaseLayerDrawing = 1;
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_Init(void)
+{
+ sgl.RefreshClock = 0;
+
+ ResetLayerBufPtr();
+
+ AutoRedraw_Init();
+
+#ifdef GuiConst_DISPLAY_ACTIVE_AREA
+#ifdef GuiConst_DISPLAY_ACTIVE_AREA_COO_REL
+ sgl.DisplayOrigoX = GuiConst_DISPLAY_ACTIVE_AREA_X1;
+ sgl.DisplayOrigoY = GuiConst_DISPLAY_ACTIVE_AREA_Y1;
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+ sgl.DisplayActiveAreaX1 = 0;
+ sgl.DisplayActiveAreaY1 = 0;
+#endif // GuiConst_CLIPPING_SUPPORT_ON
+#ifdef GuiConst_DISPLAY_ACTIVE_AREA_CLIPPING
+ sgl.DisplayActiveAreaX2 =
+ GuiConst_DISPLAY_ACTIVE_AREA_X2 - GuiConst_DISPLAY_ACTIVE_AREA_X1;
+ sgl.DisplayActiveAreaY2 =
+ GuiConst_DISPLAY_ACTIVE_AREA_Y2 - GuiConst_DISPLAY_ACTIVE_AREA_Y1;
+#else // GuiConst_DISPLAY_ACTIVE_AREA_CLIPPING
+ sgl.DisplayActiveAreaX2 =
+ GuiConst_DISPLAY_WIDTH - GuiConst_DISPLAY_ACTIVE_AREA_X1 - 1;
+ sgl.DisplayActiveAreaY2 =
+ GuiConst_DISPLAY_HEIGHT - GuiConst_DISPLAY_ACTIVE_AREA_Y1 - 1;
+#endif // GuiConst_DISPLAY_ACTIVE_AREA_CLIPPING
+#else // GuiConst_DISPLAY_ACTIVE_AREA_COO_REL
+ sgl.DisplayOrigoX = 0;
+ sgl.DisplayOrigoY = 0;
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+#ifdef GuiConst_DISPLAY_ACTIVE_AREA_CLIPPING
+ sgl.DisplayActiveAreaX1 = GuiConst_DISPLAY_ACTIVE_AREA_X1;
+ sgl.DisplayActiveAreaY1 = GuiConst_DISPLAY_ACTIVE_AREA_Y1;
+ sgl.DisplayActiveAreaX2 = GuiConst_DISPLAY_ACTIVE_AREA_X2;
+ sgl.DisplayActiveAreaY2 = GuiConst_DISPLAY_ACTIVE_AREA_Y2;
+#else // GuiConst_DISPLAY_ACTIVE_AREA_CLIPPING
+ sgl.DisplayActiveAreaX1 = 0;
+ sgl.DisplayActiveAreaY1 = 0;
+ sgl.DisplayActiveAreaX2 = GuiConst_DISPLAY_WIDTH - 1;
+ sgl.DisplayActiveAreaY2 = GuiConst_DISPLAY_HEIGHT - 1;
+#endif // GuiConst_DISPLAY_ACTIVE_AREA_CLIPPING
+#endif // GuiConst_CLIPPING_SUPPORT_ON
+#endif // GuiConst_DISPLAY_ACTIVE_AREA_COO_REL
+#else // GuiConst_DISPLAY_ACTIVE_AREA
+ sgl.DisplayOrigoX = 0;
+ sgl.DisplayOrigoY = 0;
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+ sgl.DisplayActiveAreaX1 = 0;
+ sgl.DisplayActiveAreaY1 = 0;
+ sgl.DisplayActiveAreaX2 = GuiConst_DISPLAY_WIDTH - 1;
+ sgl.DisplayActiveAreaY2 = GuiConst_DISPLAY_HEIGHT - 1;
+#endif // GuiConst_CLIPPING_SUPPORT_ON
+#endif // GuiConst_DISPLAY_ACTIVE_AREA
+
+#ifdef GuiConst_ADV_GRAPHICS_ON
+// GuiLib_AG_Init();
+#endif
+
+ GuiDisplay_Init();
+
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+ GuiLib_ResetClipping();
+#endif
+ GuiLib_ResetDisplayRepaint();
+ GuiLib_Clear();
+
+ sgl.DisplayWriting = 1;
+ sgl.InitialDrawing = 0;
+ sgl.TopLevelStructure = 0;
+ sgl.SwapColors = 0;
+ GuiLib_SetLanguage(0);
+#ifdef GuiConst_BLINK_SUPPORT_ON
+ sgl.BlinkBoxRate = 0;
+#endif
+ sgl.InvertBoxOn = 0;
+ sgl.DrawingLevel = 0;
+ GuiLib_CurStructureNdx = -1;
+#ifdef GuiConst_ITEM_TOUCHAREA_INUSE
+ GuiLib_TouchAdjustReset();
+#endif
+#ifdef GuiConst_ITEM_BUTTON_INUSE
+ sgl.ButtonColorOverride = GuiLib_FALSE;
+ sgl.DisabledButtonColor = 0;
+#endif
+#ifdef GuiConst_REMOTE_DATA
+ GuiLib_RemoteDataReadBlock = 0;
+ #ifdef GuiConst_REMOTE_TEXT_DATA
+ GuiLib_RemoteTextReadBlock = 0;
+ sgl.CurRemoteText = -1;
+ sgl.RemoteTextTableOfs = -1;
+ #endif
+ #ifdef GuiConst_REMOTE_FONT_DATA
+ sgl.CurRemoteFont = -1;
+ #endif
+ #ifdef GuiConst_REMOTE_BITMAP_DATA
+ sgl.CurRemoteBitmap = -1;
+ #endif
+#endif
+
+#ifdef GuiConst_VNC_REMOTE_SUPPORT_ON
+ GuiVnc_Init();
+#endif
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_Clear(void)
+{
+ GuiConst_INT16S I;
+#ifdef GuiConst_ITEM_GRAPHICS_LAYER_FILTER_INUSE
+ GuiConst_INT16S N;
+#endif
+
+ GuiLib_ClearDisplay();
+
+ GuiLib_CurStructureNdx = -1;
+
+ AutoRedraw_Destroy();
+
+#ifdef GuiConst_CURSOR_SUPPORT_ON
+ sgl.CursorInUse = 0;
+ GuiLib_ActiveCursorFieldNo = -1;
+#endif
+#ifdef GuiConst_BLINK_SUPPORT_ON
+#ifndef GuiConst_BLINK_FIELDS_OFF
+ for (I = 0; I < GuiConst_BLINK_FIELDS_MAX; I++)
+ {
+ sgl.BlinkTextItems[I].InUse = 0;
+ sgl.BlinkTextItems[I].Active = 0;
+ }
+#endif
+#endif
+#ifdef GuiConst_ITEM_TOUCHAREA_INUSE
+ sgl.TouchAreaCnt = 0;
+#endif
+
+#ifdef GuiConst_TEXTBOX_FIELDS_ON
+ for (I = 0; I < GuiConst_TEXTBOX_FIELDS_MAX; I++)
+ sgl.TextBoxScrollPositions[I].index = -1;
+#endif
+
+ sgl.LayerOrigoX = 0;
+ sgl.LayerOrigoY = 0;
+
+ sgl.CoordOrigoX = sgl.DisplayOrigoX + sgl.LayerOrigoX;
+ sgl.CoordOrigoY = sgl.DisplayOrigoY + sgl.LayerOrigoY;
+
+#ifdef GuiConst_ITEM_SCROLLBOX_INUSE
+ sgl.NextScrollLineReading = 0;
+ sgl.GlobalScrollBoxIndex = 0;
+ for (I = 0; I < GuiConst_SCROLLITEM_BOXES_MAX; I++)
+ {
+ sgl.ScrollBoxesAry[I].X1 = 0;
+ sgl.ScrollBoxesAry[I].Y1 = 0;
+ sgl.ScrollBoxesAry[I].InUse = GuiLib_SCROLL_STRUCTURE_UNDEF;
+ sgl.ScrollBoxesAry[I].ScrollTopLine = 0;
+ sgl.ScrollBoxesAry[I].LastScrollTopLine = 0;
+ sgl.ScrollBoxesAry[I].LastMarkerLine = 0;
+ sgl.ScrollBoxesAry[I].ScrollActiveLine = 0;
+ sgl.ScrollBoxesAry[I].NumberOfLines = 0;
+ }
+#endif
+
+#ifdef GuiConst_ITEM_GRAPH_INUSE
+ sgl.GlobalGraphIndex = 0;
+ for (I = 0; I < GuiConst_GRAPH_MAX; I++)
+ {
+ sgl.GraphAry[I].InUse = GuiLib_GRAPH_STRUCTURE_UNDEF;
+ sgl.GraphAry[I].GraphAxesCnt[GuiLib_GRAPHAXIS_X] = 0;
+ sgl.GraphAry[I].GraphAxesCnt[GuiLib_GRAPHAXIS_Y] = 0;
+ sgl.GraphAry[I].GraphDataSetCnt = 0;
+ }
+#endif
+
+#ifdef GuiConst_ITEM_GRAPHICS_LAYER_FILTER_INUSE
+ GraphicsLayer_Pop(GuiLib_GRAPHICS_LAYER_BASE);
+ for (I = 0; I < GuiConst_GRAPHICS_LAYER_MAX; I++)
+ sgl.GraphicsLayerLifo[I] = -1;
+ sgl.GraphicsLayerLifoCnt = 0;
+ sgl.GlobalGraphicsLayerIndex = 0;
+ for (I = 0; I < GuiConst_GRAPHICS_LAYER_MAX; I++)
+ {
+ sgl.GraphicsLayerList[I].InUse = GuiLib_GRAPHICS_LAYER_UNDEF;
+ sgl.GraphicsLayerList[I].SizeMode = 0;
+ sgl.GraphicsLayerList[I].InitMode = 0;
+ }
+ sgl.GlobalGraphicsFilterIndex = 0;
+ for (I = 0; I < GuiConst_GRAPHICS_FILTER_MAX; I++)
+ {
+ sgl.GraphicsFilterList[I].InUse = GuiLib_GRAPHICS_FILTER_UNDEF;
+ sgl.GraphicsFilterList[I].GraphicsFilterFunc = 0;
+ sgl.GraphicsFilterList[I].SourceLayerIndexNo = GuiLib_GRAPHICS_LAYER_BASE;
+ sgl.GraphicsFilterList[I].DestLayerIndexNo = GuiLib_GRAPHICS_LAYER_BASE;
+ sgl.GraphicsFilterList[I].ContAtLayerIndexNo = GuiLib_GRAPHICS_LAYER_BASE;
+ for (N = 0; N <= 9; N++)
+ {
+ sgl.GraphicsFilterList[I].ParVarType[N] = 0;
+ sgl.GraphicsFilterList[I].ParVarPtr[N] = 0;
+ sgl.GraphicsFilterList[I].ParValueNum[N] = 0;
+ }
+ }
+#endif
+
+#ifdef GuiConst_BITMAP_SUPPORT_ON
+ sgl.GlobalBackgrBitmapIndex = 0;
+ for (I = 0; I < GuiConst_MAX_BACKGROUND_BITMAPS; I++)
+ {
+ sgl.BackgrBitmapAry[I].InUse = 0;
+ sgl.BackgrBitmapAry[I].Index = 0;
+ sgl.BackgrBitmapAry[I].X = 0;
+ sgl.BackgrBitmapAry[I].Y = 0;
+ }
+#endif
+
+ GuiLib_ClearPositionCallbacks();
+}
+
+// Groupstart CHARS
+
+#ifdef GuiConst_CHARMODE_UNICODE
+//------------------------------------------------------------------------------
+GuiConst_INT16U GuiLib_UnicodeStrLen(
+ GuiConst_TEXT PrefixLocate *S)
+{
+ GuiConst_INT16U StrLen;
+
+ StrLen = 0;
+ while (*S != 0)
+ {
+ StrLen++;
+ S++;
+ }
+ return (StrLen);
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_StrAnsiToUnicode(
+ GuiConst_TEXT PrefixLocate *S2,
+ GuiConst_CHAR PrefixLocate *S1)
+{
+ do
+ {
+ *S2 = (GuiConst_TEXT)(*S1);
+ *S2 &= 0x00ff;
+ if (*S1 == 0)
+ return;
+ S1++;
+ S2++;
+ }
+ while (1);
+}
+
+//------------------------------------------------------------------------------
+GuiConst_INT16S GuiLib_UnicodeStrCmp(
+ GuiConst_TEXT PrefixLocate *S1,
+ GuiConst_TEXT PrefixLocate *S2)
+{
+ do
+ {
+ if ((*S1 == 0) && (*S2 == 0))
+ return (0);
+
+ else if (*S1 == 0)
+ return (-1);
+ else if (*S2 == 0)
+ return (1);
+ else if (*S1 < *S2)
+ return (-1);
+ else if (*S1 > *S2)
+ return (1);
+ S1++;
+ S2++;
+ }
+ while (1);
+}
+
+//------------------------------------------------------------------------------
+GuiConst_INT16S GuiLib_UnicodeStrNCmp(
+ GuiConst_TEXT PrefixLocate *S1,
+ GuiConst_TEXT PrefixLocate *S2,
+ GuiConst_INT16U StrLen)
+{
+ while (StrLen > 0)
+ {
+ if ((*S1 == 0) && (*S2 == 0))
+ return (0);
+ else if (*S1 == 0)
+ return (-1);
+ else if (*S2 == 0)
+ return (1);
+ else if (*S1 < *S2)
+ return (-1);
+ else if (*S1 > *S2)
+ return (1);
+ S1++;
+ S2++;
+ StrLen--;
+ }
+ return (0);
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_UnicodeStrCpy(
+ GuiConst_TEXT PrefixLocate *S2,
+ GuiConst_TEXT PrefixLocate *S1)
+{
+ do
+ {
+ *S2 = *S1;
+ if (*S1 == 0)
+ return;
+ S1++;
+ S2++;
+ }
+ while (1);
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_UnicodeStrNCpy(
+ GuiConst_TEXT PrefixLocate *S2,
+ GuiConst_TEXT PrefixLocate *S1,
+ GuiConst_INT16U StrLen)
+{
+ while (StrLen > 0)
+ {
+ *S2 = *S1;
+ if (*S1 != 0)
+ S1++;
+ S2++;
+ StrLen--;
+ }
+}
+#endif // GuiConst_CHARMODE_UNICODE
+
+//------------------------------------------------------------------------------
+static void ConvertIntToStr(
+ GuiConst_INT32U num,
+ GuiConst_CHAR PrefixLocate *string,
+ GuiConst_INT32U base)
+{
+ #define BUFFER_SIZE 11
+
+ GuiConst_INT8U digits[16] =
+ { 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70 };
+ GuiConst_CHAR buffer[BUFFER_SIZE];
+ GuiConst_INT8U bufferLen;
+ GuiConst_INT8U i;
+
+ bufferLen = 0;
+ do
+ {
+ i = num % base;
+ buffer[bufferLen++] = digits[i];
+ num /= base;
+ }
+ while ((num != 0) && (bufferLen < BUFFER_SIZE));
+
+ if (bufferLen <= GuiConst_MAX_VARNUM_TEXT_LEN)
+ while (bufferLen-- > 0)
+ *string++ = buffer[bufferLen];
+
+ *string = '\0';
+}
+
+//------------------------------------------------------------------------------
+static GuiConst_INT16S CharDist(
+ GuiConst_INT16U ChPos1,
+ GuiConst_INT16U ChPos2,
+ GuiConst_INT8U Ps)
+{
+ GuiConst_INT16S Result, D;
+#ifndef GuiConst_REMOTE_FONT_DATA
+ GuiConst_INT8U PrefixRom *Ps1;
+ GuiConst_INT8U PrefixRom *Ps2;
+#endif
+#ifdef GuiConst_REMOTE_FONT_DATA
+ GuiConst_INT8U CharHeader1[GuiLib_CHR_LINECTRL_OFS];
+ GuiConst_INT8U CharHeader2[GuiLib_CHR_LINECTRL_OFS];
+#endif
+
+#ifdef GuiConst_REMOTE_FONT_DATA
+ if (Ps == GuiLib_PS_OFF)
+ return (sgl.CurFont->XSize);
+ else if ((Ps == GuiLib_PS_ON) || (Ps == GuiLib_PS_NUM))
+ {
+ GuiLib_RemoteDataReadBlock(
+ (GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[sgl.TextCharNdx[ChPos1]],
+ GuiLib_CHR_LINECTRL_OFS, CharHeader1);
+ GuiLib_RemoteDataReadBlock(
+ (GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[sgl.TextCharNdx[ChPos2]],
+ GuiLib_CHR_LINECTRL_OFS, CharHeader2);
+ if ((Ps == GuiLib_PS_ON) || (sgl.TextPsMode[ChPos1] && sgl.TextPsMode[ChPos2]))
+ {
+ Result = CharHeader1[GuiLib_CHR_PSRIGHT_OFS + GuiLib_CHR_PS_TOP_OFS] -
+ CharHeader2[GuiLib_CHR_PSLEFT_OFS + GuiLib_CHR_PS_TOP_OFS];
+ D = CharHeader1[GuiLib_CHR_PSRIGHT_OFS + GuiLib_CHR_PS_MID_OFS] -
+ CharHeader2[GuiLib_CHR_PSLEFT_OFS + GuiLib_CHR_PS_MID_OFS];
+ if (D > Result)
+ Result = D;
+ D = CharHeader1[GuiLib_CHR_PSRIGHT_OFS + GuiLib_CHR_PS_MIDBASE_OFS] -
+ CharHeader2[GuiLib_CHR_PSLEFT_OFS + GuiLib_CHR_PS_MIDBASE_OFS];
+ if (D > Result)
+ Result = D;
+ D = CharHeader1[GuiLib_CHR_PSRIGHT_OFS + GuiLib_CHR_PS_BASE_OFS] -
+ CharHeader2[GuiLib_CHR_PSLEFT_OFS + GuiLib_CHR_PS_BASE_OFS];
+ if (D > Result)
+ Result = D;
+ D = CharHeader1[GuiLib_CHR_PSRIGHT_OFS + GuiLib_CHR_PS_BOTTOM_OFS] -
+ CharHeader2[GuiLib_CHR_PSLEFT_OFS + GuiLib_CHR_PS_BOTTOM_OFS];
+ if (D > Result)
+ Result = D;
+ return (Result + sgl.CurFont->PsSpace + 1);
+ }
+ else if (sgl.TextPsMode[ChPos1])
+ {
+ Result = CharHeader1[GuiLib_CHR_PSRIGHT_OFS + GuiLib_CHR_PS_TOP_OFS];
+ D = CharHeader1[GuiLib_CHR_PSRIGHT_OFS + GuiLib_CHR_PS_MID_OFS];
+ if (D > Result)
+ Result = D;
+ D = CharHeader1[GuiLib_CHR_PSRIGHT_OFS + GuiLib_CHR_PS_MIDBASE_OFS];
+ if (D > Result)
+ Result = D;
+ D = CharHeader1[GuiLib_CHR_PSRIGHT_OFS + GuiLib_CHR_PS_BASE_OFS];
+ if (D > Result)
+ Result = D;
+ D = CharHeader1[GuiLib_CHR_PSRIGHT_OFS + GuiLib_CHR_PS_BOTTOM_OFS];
+ if (D > Result)
+ Result = D;
+ return (Result + sgl.CurFont->PsSpace + 1);
+ }
+ else if (sgl.TextPsMode[ChPos2])
+ {
+ Result = CharHeader2[GuiLib_CHR_PSLEFT_OFS + GuiLib_CHR_PS_TOP_OFS];
+ D = CharHeader2[GuiLib_CHR_PSLEFT_OFS + GuiLib_CHR_PS_MID_OFS];
+ if (D < Result)
+ Result = D;
+ D = CharHeader2[GuiLib_CHR_PSLEFT_OFS + GuiLib_CHR_PS_MIDBASE_OFS];
+ if (D < Result)
+ Result = D;
+ D = CharHeader2[GuiLib_CHR_PSLEFT_OFS + GuiLib_CHR_PS_BASE_OFS];
+ if (D < Result)
+ Result = D;
+ D = CharHeader2[GuiLib_CHR_PSLEFT_OFS + GuiLib_CHR_PS_BOTTOM_OFS];
+ if (D < Result)
+ Result = D;
+ return (sgl.CurFont->PsNumWidth - Result + sgl.CurFont->PsSpace);
+ }
+ else
+ return (sgl.CurFont->PsNumWidth + sgl.CurFont->PsSpace);
+ }
+ else
+ return (0);
+#else
+ if (Ps == GuiLib_PS_OFF)
+ return (ReadByte(sgl.CurFont->XSize));
+ else if ((Ps == GuiLib_PS_ON) || (Ps == GuiLib_PS_NUM))
+ {
+ if ((Ps == GuiLib_PS_ON) || (sgl.TextPsMode[ChPos1] && sgl.TextPsMode[ChPos2]))
+ {
+ Ps1 = sgl.TextCharPtrAry[ChPos1] + GuiLib_CHR_PSRIGHT_OFS;
+ Ps2 = sgl.TextCharPtrAry[ChPos2] + GuiLib_CHR_PSLEFT_OFS;
+ Result = (GuiConst_INT16S)(ReadBytePtr(Ps1 + GuiLib_CHR_PS_TOP_OFS)) -
+ (GuiConst_INT16S)(ReadBytePtr(Ps2 + GuiLib_CHR_PS_TOP_OFS));
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps1 + GuiLib_CHR_PS_MID_OFS)) -
+ (GuiConst_INT16S)(ReadBytePtr(Ps2 + GuiLib_CHR_PS_MID_OFS));
+ if (D > Result)
+ Result = D;
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps1 + GuiLib_CHR_PS_MIDBASE_OFS)) -
+ (GuiConst_INT16S)(ReadBytePtr(Ps2 + GuiLib_CHR_PS_MIDBASE_OFS));
+ if (D > Result)
+ Result = D;
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps1 + GuiLib_CHR_PS_BASE_OFS)) -
+ (GuiConst_INT16S)(ReadBytePtr(Ps2 + GuiLib_CHR_PS_BASE_OFS));
+ if (D > Result)
+ Result = D;
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps1 + GuiLib_CHR_PS_BOTTOM_OFS)) -
+ (GuiConst_INT16S)(ReadBytePtr(Ps2 + GuiLib_CHR_PS_BOTTOM_OFS));
+ if (D > Result)
+ Result = D;
+ return (Result + ReadByte(sgl.CurFont->PsSpace) + 1);
+ }
+ else if (sgl.TextPsMode[ChPos1])
+ {
+ Ps1 = sgl.TextCharPtrAry[ChPos1] + GuiLib_CHR_PSRIGHT_OFS;
+ Result = (GuiConst_INT16S)(ReadBytePtr(Ps1 + GuiLib_CHR_PS_TOP_OFS));
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps1 + GuiLib_CHR_PS_MID_OFS));
+ if (D > Result)
+ Result = D;
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps1 + GuiLib_CHR_PS_MIDBASE_OFS));
+ if (D > Result)
+ Result = D;
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps1 + GuiLib_CHR_PS_BASE_OFS));
+ if (D > Result)
+ Result = D;
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps1 + GuiLib_CHR_PS_BOTTOM_OFS));
+ if (D > Result)
+ Result = D;
+ return (Result + ReadByte(sgl.CurFont->PsSpace) + 1);
+ }
+ else if (sgl.TextPsMode[ChPos2])
+ {
+ Ps2 = sgl.TextCharPtrAry[ChPos2] + GuiLib_CHR_PSLEFT_OFS;
+ Result = (GuiConst_INT16S)(ReadBytePtr(Ps2 + GuiLib_CHR_PS_TOP_OFS));
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps2 + GuiLib_CHR_PS_MID_OFS));
+ if (D < Result)
+ Result = D;
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps2 + GuiLib_CHR_PS_MIDBASE_OFS));
+ if (D < Result)
+ Result = D;
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps2 + GuiLib_CHR_PS_BASE_OFS));
+ if (D < Result)
+ Result = D;
+ D = (GuiConst_INT16S)(ReadBytePtr(Ps2 + GuiLib_CHR_PS_BOTTOM_OFS));
+ if (D < Result)
+ Result = D;
+ return (ReadByte(sgl.CurFont->PsNumWidth) - Result +
+ ReadByte(sgl.CurFont->PsSpace));
+ }
+ else
+ return (ReadByte(sgl.CurFont->PsNumWidth) +
+ ReadByte(sgl.CurFont->PsSpace));
+ }
+ else
+ return (0);
+#endif
+}
+
+//------------------------------------------------------------------------------
+static GuiConst_INT16S TextPixelLength(
+ GuiConst_INT8U Ps,
+ GuiConst_INT16U CharCnt,
+ GuiConst_INT16S *TextXOfs)
+{
+ GuiConst_INT16U P;
+ GuiConst_INT16S L;
+#ifdef GuiConst_REMOTE_FONT_DATA
+ GuiConst_INT8U CharHeader1[GuiLib_CHR_LINECTRL_OFS + 1];
+ GuiConst_INT8U CharHeader2[GuiLib_CHR_LINECTRL_OFS + 1];
+#endif
+
+ if (CharCnt == 0)
+ return (0);
+ else
+ {
+#ifdef GuiConst_REMOTE_FONT_DATA
+ GuiLib_RemoteDataReadBlock(
+ (GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[sgl.TextCharNdx[0]],
+ GuiLib_CHR_LINECTRL_OFS + 1, CharHeader1);
+ GuiLib_RemoteDataReadBlock(
+ (GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[sgl.TextCharNdx[CharCnt - 1]],
+ GuiLib_CHR_LINECTRL_OFS + 1, CharHeader2);
+#endif
+
+ if (sgl.TextPsMode[0])
+ {
+#ifdef GuiConst_REMOTE_FONT_DATA
+ if (CharHeader1[GuiLib_CHR_LINECTRL_OFS] & 0x01)
+ L = -(GuiConst_INT16S)CharHeader1[GuiLib_CHR_PSLEFT_OFS];
+ else
+ L = -(GuiConst_INT16S)CharHeader1[GuiLib_CHR_XLEFT_OFS];
+#else
+ if (ReadBytePtr(sgl.TextCharPtrAry[0] + GuiLib_CHR_LINECTRL_OFS) & 0x01)
+ L = -(GuiConst_INT16S)(ReadBytePtr(sgl.TextCharPtrAry[0] +
+ GuiLib_CHR_PSLEFT_OFS));
+ else
+ L = -(GuiConst_INT16S)(ReadBytePtr(sgl.TextCharPtrAry[0] +
+ GuiLib_CHR_XLEFT_OFS));
+#endif
+ }
+ else
+ L = 0;
+
+ if (TextXOfs != NULL)
+ TextXOfs[0] = L;
+
+ for (P = 0; P < CharCnt - 1; P++)
+ {
+ L += CharDist (P, P + 1, Ps);
+ if (TextXOfs != NULL)
+ TextXOfs[P + 1] = L;
+ }
+
+#ifdef GuiConst_REMOTE_FONT_DATA
+ if (sgl.TextPsMode[CharCnt - 1])
+ {
+ if (CharHeader2[GuiLib_CHR_LINECTRL_OFS] & 0x01)
+ L += (GuiConst_INT16S)CharHeader2[GuiLib_CHR_PSRIGHT_OFS] + 1;
+ else
+ L += (GuiConst_INT16S)CharHeader2[GuiLib_CHR_XLEFT_OFS] +
+ (GuiConst_INT16S)CharHeader2[GuiLib_CHR_XWIDTH_OFS];
+ }
+ else if (Ps == GuiLib_PS_NUM)
+ {
+ if (CharHeader2[GuiLib_CHR_LINECTRL_OFS] & 0x01)
+ L += (GuiConst_INT16S)CharHeader2[GuiLib_CHR_PSRIGHT_OFS] + 1;
+ else
+ L += sgl.CurFont->PsNumWidth + sgl.CurFont->PsSpace;
+ }
+ else
+ L += sgl.CurFont->XSize;
+#else
+ if (sgl.TextPsMode[CharCnt - 1])
+ {
+ if (ReadBytePtr(sgl.TextCharPtrAry[CharCnt - 1] + GuiLib_CHR_LINECTRL_OFS) & 0x01)
+ L += (GuiConst_INT16S)(ReadBytePtr(sgl.TextCharPtrAry[CharCnt - 1] +
+ GuiLib_CHR_PSRIGHT_OFS)) + 1;
+ else
+ L += ReadBytePtr(sgl.TextCharPtrAry[CharCnt - 1] + GuiLib_CHR_XLEFT_OFS) +
+ ReadBytePtr(sgl.TextCharPtrAry[CharCnt - 1] + GuiLib_CHR_XWIDTH_OFS);
+ }
+ else if (Ps == GuiLib_PS_NUM)
+ {
+ if (ReadBytePtr(sgl.TextCharPtrAry[CharCnt - 1] +
+ GuiLib_CHR_LINECTRL_OFS) & 0x01)
+ L += (GuiConst_INT16S)(ReadBytePtr(sgl.TextCharPtrAry[CharCnt - 1] +
+ GuiLib_CHR_PSRIGHT_OFS)) + 1;
+ else
+ L += ReadByte(sgl.CurFont->PsNumWidth) +
+ ReadByte(sgl.CurFont->PsSpace);
+ }
+ else
+ L += ReadByte(sgl.CurFont->XSize);
+#endif
+ if (TextXOfs != NULL)
+ TextXOfs[CharCnt] = L;
+ return (L);
+ }
+}
+
+//------------------------------------------------------------------------------
+static GuiConst_INT16U CalcCharsWidth(
+ GuiConst_INT16U CharPos1,
+ GuiConst_INT16U CharPos2,
+ GuiConst_INT16S *TextXOfs,
+ GuiConst_INT16S *pXStart,
+ GuiConst_INT16S *pXEnd)
+{
+ GuiConst_INT16S X1;
+ GuiConst_INT16S X2;
+
+#ifdef GuiConst_REMOTE_FONT_DATA
+ GuiConst_INT8U CharHeader1[GuiLib_CHR_LINECTRL_OFS+1];
+ GuiConst_INT8U CharHeader2[GuiLib_CHR_LINECTRL_OFS+1];
+
+ GuiLib_RemoteDataReadBlock(
+ (GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[sgl.TextCharNdx[CharPos1]],
+ GuiLib_CHR_LINECTRL_OFS+1, CharHeader1);
+ GuiLib_RemoteDataReadBlock(
+ (GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[sgl.TextCharNdx[CharPos2]],
+ GuiLib_CHR_LINECTRL_OFS+1, CharHeader2);
+
+ if (sgl.TextPsMode[CharPos1])
+ {
+ if (CharHeader1[GuiLib_CHR_LINECTRL_OFS] & 0x01)
+ X1 = TextXOfs[CharPos1] +
+ (GuiConst_INT16S)CharHeader1[GuiLib_CHR_PSLEFT_OFS];
+ else
+ X1 = TextXOfs[CharPos1] +
+ (GuiConst_INT16S)CharHeader1[GuiLib_CHR_XLEFT_OFS];
+ }
+ else
+ X1 = TextXOfs[CharPos1];
+ if (sgl.TextPsMode[CharPos2])
+ {
+ if (CharHeader2[GuiLib_CHR_LINECTRL_OFS] & 0x01)
+ X2 = TextXOfs[CharPos2] +
+ (GuiConst_INT16S)CharHeader2[GuiLib_CHR_PSRIGHT_OFS];
+ else
+ X2 = TextXOfs[CharPos2] +
+ (GuiConst_INT16S)CharHeader1[GuiLib_CHR_XLEFT_OFS] +
+ (GuiConst_INT16S)CharHeader2[GuiLib_CHR_XWIDTH_OFS] - 1;
+ }
+ else
+ X2 = TextXOfs[CharPos2] + sgl.CurFont->XSize - 1;
+#else
+ if (sgl.TextPsMode[CharPos1])
+ {
+ if (ReadBytePtr(sgl.TextCharPtrAry[CharPos1] +
+ GuiLib_CHR_LINECTRL_OFS) & 0x01)
+ X1 = TextXOfs[CharPos1] +
+ (GuiConst_INT16S)(ReadBytePtr(sgl.TextCharPtrAry[CharPos1] +
+ GuiLib_CHR_PSLEFT_OFS));
+ else
+ X1 = TextXOfs[CharPos1] +
+ (GuiConst_INT16S)(ReadBytePtr(sgl.TextCharPtrAry[CharPos1] +
+ GuiLib_CHR_XLEFT_OFS));
+ }
+ else
+ X1 = TextXOfs[CharPos1];
+ if (sgl.TextPsMode[CharPos2])
+ {
+ if (ReadBytePtr(sgl.TextCharPtrAry[CharPos2] +
+ GuiLib_CHR_LINECTRL_OFS) & 0x01)
+ X2 = TextXOfs[CharPos2] +
+ (GuiConst_INT16S)(ReadBytePtr(sgl.TextCharPtrAry[CharPos2] +
+ GuiLib_CHR_PSRIGHT_OFS));
+ else
+ X2 = TextXOfs[CharPos2] +
+ (GuiConst_INT16S)(ReadBytePtr(sgl.TextCharPtrAry[CharPos2] +
+ GuiLib_CHR_XLEFT_OFS)) +
+ (GuiConst_INT16S)(ReadBytePtr(sgl.TextCharPtrAry[CharPos2] +
+ GuiLib_CHR_XWIDTH_OFS)) - 1;
+ }
+ else
+ X2 = TextXOfs[CharPos2] + sgl.CurFont->XSize - 1;
+#endif
+
+ *pXStart = X1;
+ *pXEnd = X2;
+ return(X2 - X1 + 1);
+}
+
+#ifdef GuiConst_CHARMODE_UNICODE
+//------------------------------------------------------------------------------
+static GuiConst_INT32U GetCharNdx(
+ GuiLib_FontRecPtr Font,
+ GuiConst_INT16U CharCode)
+{
+ GuiConst_INT32U CharNdx,CharNdx1,CharNdx2;
+ GuiConst_INT32U ReturnValue;
+
+ CharNdx1 = ReadWord(Font->FirstCharNdx) + 1;
+ CharNdx2 = CharNdx1 + ReadWord(Font->CharCount) - 1;
+
+ ReturnValue = 0;
+
+ do
+ {
+ CharNdx = CharNdx1 + ((CharNdx2 - CharNdx1) >> 1);
+
+ if (ReadWord(GuiFont_ChUnicodeList[CharNdx]) == CharCode)
+ {
+ ReturnValue = CharNdx;
+ break;
+ }
+
+ if (CharNdx1 == CharNdx2)
+ {
+ ReturnValue = ReadWord(Font->FirstCharNdx);
+ break;
+ }
+
+ if (ReadWord(GuiFont_ChUnicodeList[CharNdx]) > CharCode)
+ CharNdx2 = CharNdx - 1;
+ else
+ CharNdx1 = CharNdx + 1;
+
+ if (CharNdx1 > CharNdx2)
+ {
+ ReturnValue = ReadWord(Font->FirstCharNdx);
+ break;
+ }
+ }
+ while (1);
+
+ return ReturnValue;
+}
+#endif
+
+//------------------------------------------------------------------------------
+static void PrepareText(
+ GuiConst_TEXT PrefixGeneric *CharPtr,
+ GuiConst_INT16U CharCnt,
+ GuiConst_INT8U TextNdx)
+{
+ GuiConst_INT16S P;
+#ifdef GuiConst_CHARMODE_ANSI
+ GuiConst_INT8U CharCode;
+#else
+ GuiConst_INT16U CharCode;
+ GuiConst_INT16U CharNdx;
+#endif
+
+ if (CharCnt > GuiConst_MAX_TEXT_LEN)
+ CharCnt = GuiConst_MAX_TEXT_LEN;
+
+ for (P = 0; P < CharCnt; P++)
+ {
+#ifdef GuiConst_CHARMODE_ANSI
+
+#ifdef GuiConst_AVRGCC_COMPILER
+ if (displayVarNow)
+ CharCode = (unsigned GuiConst_CHAR) *CharPtr;
+ else
+ CharCode = (unsigned GuiConst_CHAR) ReadBytePtr(CharPtr);
+#else
+#ifdef GuiConst_ICC_COMPILER
+ if (displayVarNow)
+ CharCode = (unsigned GuiConst_CHAR) *CharPtr;
+ else
+ CharCode = *((GuiConst_INT8U PrefixRom *)CharPtr);
+#else
+#ifdef GuiConst_CODEVISION_COMPILER
+ if (displayVarNow)
+ CharCode = (unsigned GuiConst_CHAR) *CharPtr;
+ else
+ CharCode = *((GuiConst_INT8U PrefixRom *)CharPtr);
+#else
+#ifdef GuiConst_RENESAS_COMPILER_FAR
+ if (displayVarNow)
+ CharCode = (unsigned GuiConst_CHAR) *CharPtr;
+ else
+ CharCode = *((GuiConst_INT8U PrefixRom *)CharPtr);
+#else
+ CharCode = (unsigned GuiConst_TEXT) *CharPtr;
+#endif // GuiConst_RENESAS_COMPILER_FAR
+#endif // GuiConst_CODEVISION_COMPILER
+#endif // GuiConst_ICC_COMPILER
+#endif // GuiConst_AVRGCC_COMPILER
+
+#ifdef GuiConst_REMOTE_FONT_DATA
+ if ((CharCode < sgl.CurFont->FirstChar) ||
+ (CharCode > sgl.CurFont->LastChar))
+ sgl.TextCharNdx[P] = sgl.CurFont->IllegalCharNdx;
+ else
+ {
+ sgl.TextCharNdx[P] =
+ sgl.CurFont->FirstCharNdx + (GuiConst_INT16U)CharCode -
+ (GuiConst_INT16U)sgl.CurFont->FirstChar;
+
+ if ((GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[sgl.TextCharNdx[P] + 1] -
+ (GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[sgl.TextCharNdx[P]] == 0)
+ sgl.TextCharNdx[P] = sgl.CurFont->IllegalCharNdx;
+ }
+#else // GuiConst_REMOTE_FONT_DATA
+ if ((CharCode < ReadByte(sgl.CurFont->FirstChar)) ||
+ (CharCode > ReadByte(sgl.CurFont->LastChar)))
+ sgl.TextCharPtrAry[P] = (GuiConst_INT8U*)ReadWord(
+ GuiFont_ChPtrList[ReadWord(sgl.CurFont->IllegalCharNdx)]);
+ else
+ sgl.TextCharPtrAry[P] = (GuiConst_INT8U*)ReadWord(
+ GuiFont_ChPtrList[ReadWord(sgl.CurFont->FirstCharNdx) +
+ (GuiConst_INT16U)CharCode -
+ (GuiConst_INT16U)ReadByte(sgl.CurFont->FirstChar)]);
+#endif // GuiConst_REMOTE_FONT_DATA
+
+ if (sgl.CurItem.TextPar[TextNdx].Ps == GuiLib_PS_ON)
+ sgl.TextPsMode[P] = 1;
+ else if (sgl.CurItem.TextPar[TextNdx].Ps == GuiLib_PS_NUM)
+ {
+ if (((CharCode >= '0') && (CharCode <= '9')) ||
+ (CharCode == ' ') || (CharCode == '+') || (CharCode == '-') ||
+ (CharCode == '*') || (CharCode == '/') || (CharCode == '='))
+ sgl.TextPsMode[P] = 0;
+ else
+ sgl.TextPsMode[P] = 1;
+ }
+ else
+ sgl.TextPsMode[P] = 0;
+
+#else // GuiConst_CHARMODE_ANSI
+ CharCode = *((PrefixLocate GuiConst_INT16U*)CharPtr);
+ CharNdx = GetCharNdx(sgl.CurFont, CharCode);
+
+#ifdef GuiConst_REMOTE_FONT_DATA
+ sgl.TextCharNdx[P] = CharNdx;
+#else
+ sgl.TextCharPtrAry[P] =
+ (GuiConst_INT8U PrefixRom *)ReadWord(GuiFont_ChPtrList[CharNdx]);
+#endif
+
+ if (sgl.CurItem.TextPar[TextNdx].Ps == GuiLib_PS_ON)
+ sgl.TextPsMode[P] = 1;
+ else if ((sgl.CurItem.TextPar[TextNdx].Ps == GuiLib_PS_NUM) && (CharNdx > 0))
+ {
+ if (((CharCode >= '0') && (CharCode <= '9')) ||
+ (CharCode == ' ') || (CharCode == '+') || (CharCode == '-') ||
+ (CharCode == '*') || (CharCode == '/') || (CharCode == '='))
+ sgl.TextPsMode[P] = 0;
+ else
+ sgl.TextPsMode[P] = 1;
+ }
+ else
+ sgl.TextPsMode[P] = 0;
+#endif // GuiConst_CHARMODE_ANSI
+ CharPtr++;
+ }
+}
+
+#ifdef GuiConst_ARAB_CHARS_INUSE
+//------------------------------------------------------------------------------
+static GuiConst_INT16U ArabicCorrection(
+ GuiConst_TEXT PrefixGeneric *CharPtr,
+ GuiConst_INT16U CharCnt,
+ GuiConst_INT8U RightToLeftWriting)
+{
+ GuiConst_INT16S I, J, P;
+ GuiConst_INT16U CharCode;
+ GuiConst_INT16U CharCode2;
+ GuiConst_TEXT PrefixLocate *CharPtr2;
+ GuiConst_TEXT PrefixLocate *CharPtrA;
+ GuiConst_TEXT PrefixLocate *CharPtrB;
+
+ if (!RightToLeftWriting)
+ return CharCnt;
+
+ CharPtr2 = CharPtr;
+
+ for (P = 0; P < CharCnt; P++)
+ {
+ CharCode = *((GuiConst_INT16U*)CharPtr);
+ switch (CharCode)
+ {
+ case 40:
+ *((GuiConst_INT16U*)CharPtr) = 41;
+ break;
+ case 41:
+ *((GuiConst_INT16U*)CharPtr) = 40;
+ break;
+
+ case 91:
+ *((GuiConst_INT16U*)CharPtr) = 93;
+ break;
+ case 93:
+ *((GuiConst_INT16U*)CharPtr) = 91;
+ break;
+
+ case 123:
+ *((GuiConst_INT16U*)CharPtr) = 125;
+ break;
+ case 125:
+ *((GuiConst_INT16U*)CharPtr) = 123;
+ break;
+ }
+
+ CharPtr++;
+ }
+
+ P = 0;
+ CharPtr = CharPtr2;
+ do
+ {
+ CharCode = *((GuiConst_INT16U*)CharPtr);
+ CharPtrA = CharPtr;
+ CharPtr++;
+ CharCode2 = *((GuiConst_INT16U*)CharPtr);
+
+ for (I = 0; I < GuiLib_ARAB_LIGATURES_CNT; I++)
+ if ((CharCode == GuiLib_ARAB_LIGATURES[I][0]) &&
+ (CharCode2 == GuiLib_ARAB_LIGATURES[I][1]))
+ {
+ *((GuiConst_INT16U*)CharPtrA) = GuiLib_ARAB_LIGATURES[I][2];
+ CharPtrA = CharPtr;
+ CharPtrB = CharPtrA;
+ CharPtrB++;
+ CharCnt--;
+ for (J = P + 1; J < CharCnt; J++)
+ {
+ *((GuiConst_INT16U*)CharPtrA) = *((GuiConst_INT16U*)CharPtrB);
+ CharPtrA++;
+ CharPtrB++;
+ }
+ *((GuiConst_INT16U*)CharPtrA) = 0;
+ break;
+ }
+
+ P++;
+ }
+ while (P < CharCnt - 1);
+
+ CharPtr = CharPtr2;
+ for (P = 0; P < CharCnt; P++)
+ {
+ CharCode = *((GuiConst_INT16U*)CharPtr);
+
+ for (I = 0; I < GuiLib_ARAB_CHAR_CONVERT_CNT; I++)
+ if ((CharCode == GuiLib_ARAB_CHAR_CONVERT[I][0]) && (CharCode > 0))
+ {
+ *((GuiConst_INT16U*)CharPtr) = GuiLib_ARAB_CHAR_CONVERT[I][1];
+ break;
+ }
+
+ CharPtr++;
+ }
+
+ gl.ArabicCharJoiningModeIndex[0] = -1;
+ CharPtr = CharPtr2;
+ for (P = 0; P < CharCnt; P++)
+ {
+ CharCode = *((GuiConst_INT16U*)CharPtr);
+
+ gl.ArabicCharJoiningModeIndex[P + 1] = -1;
+ for (I = 0; I < GuiLib_ARAB_CHAR_CONVERT_CNT; I++)
+ if ((CharCode >= GuiLib_ARAB_CHAR_CONVERT[I][1]) &&
+ (CharCode <= GuiLib_ARAB_CHAR_CONVERT[I][1] +
+ (GuiLib_ARAB_CHAR_CONVERT[I][2] & 7) - 1))
+ {
+ gl.ArabicCharJoiningModeIndex[P + 1] = I;
+ break;
+ }
+
+ CharPtr++;
+ }
+ gl.ArabicCharJoiningModeIndex[CharCnt + 1] = -1;
+
+ for (P = 0; P < CharCnt + 2; P++)
+ {
+ if (gl.ArabicCharJoiningModeIndex[P] == -1)
+ gl.ArabicCharJoiningMode[P] = GuiLib_ARAB_CHAR_TYPE_ISO;
+ else
+ gl.ArabicCharJoiningMode[P] =
+ GuiLib_ARAB_CHAR_CONVERT[gl.ArabicCharJoiningModeIndex[P]][2];
+ }
+
+ CharPtr = CharPtr2;
+ for (P = 0; P < CharCnt; P++)
+ {
+ CharCode = *((GuiConst_INT16U*)CharPtr);
+
+ I = P;
+ while (gl.ArabicCharJoiningMode[I] == GuiLib_ARAB_CHAR_DIACRITIC)
+ I--;
+ gl.ArabicCharJoiningModeBefore = gl.ArabicCharJoiningMode[I];
+ I = P + 2;
+ while (gl.ArabicCharJoiningMode[I] == GuiLib_ARAB_CHAR_DIACRITIC)
+ I++;
+ gl.ArabicCharJoiningModeAfter = gl.ArabicCharJoiningMode[I];
+
+ switch (gl.ArabicCharJoiningMode[P + 1])
+ {
+ case GuiLib_ARAB_CHAR_ISOFIN:
+ if (gl.ArabicCharJoiningModeBefore == GuiLib_ARAB_CHAR_ISOFININIMED)
+ *((GuiConst_INT16U*)CharPtr) =
+ GuiLib_ARAB_CHAR_CONVERT[gl.ArabicCharJoiningModeIndex[P + 1]][1] +
+ GuiLib_ARAB_CHAR_TYPE_FIN;
+ break;
+
+ case GuiLib_ARAB_CHAR_ISOFININIMED:
+ if ((gl.ArabicCharJoiningModeAfter == GuiLib_ARAB_CHAR_ISOFIN) ||
+ (gl.ArabicCharJoiningModeAfter == GuiLib_ARAB_CHAR_ISOFININIMED))
+ {
+ if (gl.ArabicCharJoiningModeBefore == GuiLib_ARAB_CHAR_ISOFININIMED)
+ *((GuiConst_INT16U*)CharPtr) =
+ GuiLib_ARAB_CHAR_CONVERT[gl.ArabicCharJoiningModeIndex[P + 1]][1] +
+ GuiLib_ARAB_CHAR_TYPE_MED;
+ else
+ *((GuiConst_INT16U*)CharPtr) =
+ GuiLib_ARAB_CHAR_CONVERT[gl.ArabicCharJoiningModeIndex[P + 1]][1] +
+ GuiLib_ARAB_CHAR_TYPE_INI;
+ }
+ else if (gl.ArabicCharJoiningModeBefore == GuiLib_ARAB_CHAR_ISOFININIMED)
+ *((GuiConst_INT16U*)CharPtr) =
+ GuiLib_ARAB_CHAR_CONVERT[gl.ArabicCharJoiningModeIndex[P + 1]][1] +
+ GuiLib_ARAB_CHAR_TYPE_FIN;
+ break;
+
+ case GuiLib_ARAB_CHAR_DIACRITIC:
+ if (((gl.ArabicCharJoiningMode[P + 2] == GuiLib_ARAB_CHAR_ISOFIN) ||
+ (gl.ArabicCharJoiningMode[P + 2] == GuiLib_ARAB_CHAR_ISOFININIMED)) &&
+ (gl.ArabicCharJoiningMode[P] == GuiLib_ARAB_CHAR_ISOFININIMED))
+ *((GuiConst_INT16U*)CharPtr) =
+ GuiLib_ARAB_CHAR_CONVERT[gl.ArabicCharJoiningModeIndex[P + 1]][1] + 1;
+ break;
+ }
+
+ CharPtr++;
+ }
+
+ return (CharCnt);
+}
+#endif
+
+// Groupend CHARS
+// Groupstart DRAW
+
+//------------------------------------------------------------------------------
+static void ResetDrawLimits(void)
+{
+ gl.Drawn = 0;
+ gl.DrawnX1 = 0x7FFF;
+ gl.DrawnY1 = 0x7FFF;
+ gl.DrawnX2 = 0x8000;
+ gl.DrawnY2 = 0x8000;
+}
+
+//------------------------------------------------------------------------------
+static void UpdateDrawLimits(
+ GuiConst_INT16S X1,
+ GuiConst_INT16S Y1,
+ GuiConst_INT16S X2,
+ GuiConst_INT16S Y2)
+{
+ sgl.CurItem.Drawn = 1;
+ sgl.CurItem.DrawnX1 = X1;
+ sgl.CurItem.DrawnY1 = Y1;
+ sgl.CurItem.DrawnX2 = X2;
+ sgl.CurItem.DrawnY2 = Y2;
+
+ gl.Drawn = 1;
+ gl.DrawnX1 = GuiLib_GET_MIN(gl.DrawnX1, X1);
+ gl.DrawnY1 = GuiLib_GET_MIN(gl.DrawnY1, Y1);
+ gl.DrawnX2 = GuiLib_GET_MAX(gl.DrawnX2, X2);
+ gl.DrawnY2 = GuiLib_GET_MAX(gl.DrawnY2, Y2);
+}
+
+//------------------------------------------------------------------------------
+static void DrawBorderBox(
+ GuiConst_INT16S X1,
+ GuiConst_INT16S Y1,
+ GuiConst_INT16S X2,
+ GuiConst_INT16S Y2,
+ GuiConst_INTCOLOR BorderColor,
+ GuiConst_INTCOLOR FillColor,
+ GuiConst_INT8U FillTransparent,
+ GuiConst_INT16U BorderThickness)
+{
+ if (BorderThickness == 1)
+ GuiLib_Box(X1, Y1, X2, Y2, BorderColor);
+ else
+ {
+ GuiLib_FillBox(X1, Y1, X1 + BorderThickness - 1, Y2, BorderColor);
+ GuiLib_FillBox(X2 - BorderThickness + 1, Y1, X2, Y2, BorderColor);
+ GuiLib_FillBox(X1, Y1, X2, Y1 + BorderThickness - 1, BorderColor);
+ GuiLib_FillBox(X1, Y2 - BorderThickness + 1, X2, Y2, BorderColor);
+ }
+ if ((!FillTransparent) &&
+ (X2 - X1 >= 2 * BorderThickness) &&
+ (Y2 - Y1 >= 2 * BorderThickness))
+ GuiLib_FillBox(X1 + BorderThickness,
+ Y1 + BorderThickness,
+ X2 - BorderThickness,
+ Y2 - BorderThickness,
+ FillColor);
+}
+
+//------------------------------------------------------------------------------
+static void SetBackColorBox(
+ GuiConst_INT16S X1,
+ GuiConst_INT16S Y1,
+ GuiConst_INT16S X2,
+ GuiConst_INT16S Y2,
+ GuiConst_INT8U TextNdx)
+{
+ sgl.BbX1 = X1;
+ sgl.BbY1 = Y1;
+ sgl.BbX2 = X2;
+ sgl.BbY2 = Y2;
+
+ if ((sgl.CurItem.TextPar[TextNdx].BackBorderPixels & GuiLib_BBP_LEFT) != 0)
+ sgl.BbX1--;
+ if ((sgl.CurItem.TextPar[TextNdx].BackBorderPixels & GuiLib_BBP_RIGHT) != 0)
+ sgl.BbX2++;
+ if ((sgl.CurItem.TextPar[TextNdx].BackBorderPixels & GuiLib_BBP_TOP) != 0)
+ sgl.BbY1--;
+ if ((sgl.CurItem.TextPar[TextNdx].BackBorderPixels & GuiLib_BBP_BOTTOM) != 0)
+ sgl.BbY2++;
+}
+
+//------------------------------------------------------------------------------
+static void SetBackBox(
+ GuiConst_INT8U TextNdx)
+{
+ GuiConst_INT16S L;
+
+ L = sgl.CurItem.TextPar[TextNdx].BackBoxSizeX;
+ sgl.BbX1 = sgl.CurItem.X1;
+ sgl.BbX2 = sgl.CurItem.X1 + L - 1;
+
+ if (sgl.CurItem.TextPar[TextNdx].Alignment == GuiLib_ALIGN_CENTER)
+ {
+ sgl.BbX1 -= L / 2;
+ sgl.BbX2 -= L / 2;
+ }
+ else if (sgl.CurItem.TextPar[TextNdx].Alignment == GuiLib_ALIGN_RIGHT)
+ {
+ sgl.BbX1 -= L - 1;
+ sgl.BbX2 -= L - 1;
+ }
+
+ if (sgl.CurItem.TextPar[TextNdx].BackBoxSizeY1 > 0)
+ sgl.BbY1 = sgl.CurItem.Y1 - sgl.CurItem.TextPar[TextNdx].BackBoxSizeY1;
+ else
+ sgl.BbY1 = sgl.CurItem.Y1 - ReadByte(sgl.CurFont->BaseLine);
+ if (sgl.CurItem.TextPar[TextNdx].BackBoxSizeY2 > 0)
+ sgl.BbY2 = sgl.CurItem.Y1 + sgl.CurItem.TextPar[TextNdx].BackBoxSizeY2;
+ else
+ sgl.BbY2 = sgl.CurItem.Y1 - ReadByte(sgl.CurFont->BaseLine) +
+ ReadByte(sgl.CurFont->YSize) - 1;
+
+ if ((sgl.CurItem.TextPar[TextNdx].BackBorderPixels & GuiLib_BBP_LEFT) != 0)
+ sgl.BbX1--;
+ if ((sgl.CurItem.TextPar[TextNdx].BackBorderPixels & GuiLib_BBP_RIGHT) != 0)
+ sgl.BbX2++;
+ if ((sgl.CurItem.TextPar[TextNdx].BackBorderPixels & GuiLib_BBP_TOP) != 0)
+ sgl.BbY1--;
+ if ((sgl.CurItem.TextPar[TextNdx].BackBorderPixels & GuiLib_BBP_BOTTOM) != 0)
+ sgl.BbY2++;
+}
+
+//------------------------------------------------------------------------------
+static void DrawBackBox(
+ GuiConst_INTCOLOR BoxColor,
+ GuiConst_INT8U Transparent,
+ GuiConst_INT8U TextNdx)
+{
+ SetBackBox(TextNdx);
+
+ if (!Transparent)
+ GuiLib_FillBox(sgl.BbX1, sgl.BbY1, sgl.BbX2, sgl.BbY2, BoxColor);
+}
+
+//------------------------------------------------------------------------------
+#ifdef GuiConst_CHARMODE_ANSI
+ #ifdef GuiConst_ICC_COMPILER
+#define DRAW_ROM_TEXT(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ DrawText((GuiConst_TEXT *)ChPtr, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+ #ifdef GuiConst_CODEVISION_COMPILER
+#define DRAW_ROM_TEXT(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ DrawText((GuiConst_TEXT *)ChPtr, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+ #ifdef GuiConst_RENESAS_COMPILER_FAR
+#define DRAW_ROM_TEXT(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ DrawText((GuiConst_TEXT PrefixLocate *)ChPtr, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+#define DRAW_ROM_TEXT(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ DrawText((GuiConst_TEXT PrefixRom *)ChPtr, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #endif
+ #endif
+ #endif
+#else
+ #ifdef GuiConst_ICC_COMPILER
+#define DRAW_ROM_TEXT(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ ExtractUnicodeString((GuiConst_INT8U *)ChPtr, ChCnt); \
+ DrawText((GuiConst_TEXT *)&sgl.UnicodeTextBuf, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+ #ifdef GuiConst_CODEVISION_COMPILER
+#define DRAW_ROM_TEXT(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ ExtractUnicodeString((GuiConst_INT8U *)ChPtr, ChCnt); \
+ DrawText((GuiConst_TEXT *)sgl.UnicodeTextBuf, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+ #ifdef GuiConst_RENESAS_COMPILER_FAR
+#define DRAW_ROM_TEXT(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ ExtractUnicodeString((GuiConst_INT8U PrefixLocate *)ChPtr, ChCnt); \
+ DrawText((GuiConst_TEXT PrefixLocate *)sgl.UnicodeTextBuf, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+#define DRAW_ROM_TEXT(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ ExtractUnicodeString((GuiConst_INT8U PrefixRom *)ChPtr, ChCnt); \
+ DrawText((GuiConst_TEXT *)&sgl.UnicodeTextBuf, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #endif
+ #endif
+#endif
+#endif
+
+//------------------------------------------------------------------------------
+static void DrawText(
+ GuiConst_TEXT PrefixGeneric *CharPtr,
+ GuiConst_INT16U CharCount,
+ GuiConst_INT8U TextNdx,
+ GuiConst_INTCOLOR ForeColor,
+ GuiConst_INTCOLOR BackColor,
+ GuiConst_INT8U Transparent)
+{
+ GuiConst_INT16S P, N;
+ GuiConst_INT16U CharCnt;
+#ifdef GuiConst_REMOTE_FONT_DATA
+ GuiConst_INT32U PrefixRom TempOfs;
+#else
+ GuiConst_INT8U PrefixRom * TempPtr;
+#endif
+ GuiConst_INT8U TempPsMode;
+ GuiConst_INT16S TextPixelLen;
+ GuiConst_INT16S X1, Y1, X2, Y2;
+ GuiConst_INT16S TextXOfs[GuiConst_MAX_TEXT_LEN + 2];
+
+#ifdef GuiConst_ARAB_CHARS_INUSE
+ CharCnt = ArabicCorrection(CharPtr,
+ CharCount,
+ (sgl.CurItem.TextPar[TextNdx].BitFlags &
+ GuiLib_BITFLAG_REVERSEWRITING) > 0);
+#else
+ CharCnt = CharCount;
+#endif
+ PrepareText(CharPtr, CharCnt, TextNdx);
+
+ if (sgl.CurItem.TextPar[TextNdx].BitFlags & GuiLib_BITFLAG_REVERSEWRITING)
+ {
+ for (N = 0; N < CharCnt / 2; N++)
+ {
+#ifdef GuiConst_REMOTE_FONT_DATA
+ TempOfs = sgl.TextCharNdx[N];
+ sgl.TextCharNdx[N] = sgl.TextCharNdx[CharCnt - 1 - N];
+ sgl.TextCharNdx[CharCnt - 1 - N] = TempOfs;
+#else
+ TempPtr = sgl.TextCharPtrAry[N];
+ sgl.TextCharPtrAry[N] =
+ (GuiConst_INT8U PrefixRom *)sgl.TextCharPtrAry[CharCnt - 1 - N];
+ sgl.TextCharPtrAry[CharCnt - 1 - N] = (GuiConst_INT8U PrefixRom *)TempPtr;
+#endif
+ TempPsMode = sgl.TextPsMode[N];
+ sgl.TextPsMode[N] = sgl.TextPsMode[CharCnt - 1 - N];
+ sgl.TextPsMode[CharCnt - 1 - N] = TempPsMode;
+ }
+ }
+
+ TextPixelLen = TextPixelLength(sgl.CurItem.TextPar[TextNdx].Ps,
+ CharCnt,
+ TextXOfs);
+
+ X1 = sgl.CurItem.X1;
+ switch (sgl.CurItem.TextPar[TextNdx].Alignment)
+ {
+ case GuiLib_ALIGN_CENTER:
+ if (CharCnt > 0)
+ X1 -= TextPixelLen / 2;
+ break;
+
+ case GuiLib_ALIGN_RIGHT:
+ X1 -= TextPixelLen - 1;
+ break;
+ }
+ Y1 = sgl.CurItem.Y1 - ReadByte(sgl.CurFont->BaseLine);
+ X2 = X1 + TextPixelLen - 1;
+ Y2 = Y1 + ReadByte(sgl.CurFont->YSize) - 1;
+
+ sgl.FontWriteX1 = X1;
+ sgl.FontWriteY1 = Y1;
+ sgl.FontWriteX2 = X2;
+ sgl.FontWriteY2 = Y2;
+
+ if (sgl.DisplayWriting)
+ {
+ if (CharCnt > 0)
+ {
+ if ((Transparent == 0) && (sgl.CurItem.TextPar[TextNdx].BackBoxSizeX == 0))
+ {
+ SetBackColorBox(X1, Y1, X2, Y2, TextNdx);
+ GuiLib_FillBox(sgl.BbX1, sgl.BbY1, sgl.BbX2, sgl.BbY2, BackColor);
+ }
+
+ for (P = 0; P < CharCnt; P++)
+#ifdef GuiConst_REMOTE_FONT_DATA
+ DrawChar(X1 + TextXOfs[P], Y1, sgl.CurFont, sgl.TextCharNdx[P], ForeColor, (Transparent == 2));
+#else
+ DrawChar(X1 + TextXOfs[P], Y1, sgl.CurFont, sgl.TextCharPtrAry[P], ForeColor, (Transparent == 2));
+#endif
+ }
+
+ if ((sgl.CurItem.TextPar[TextNdx].BitFlags & GuiLib_BITFLAG_UNDERLINE) &&
+ (CharCnt > 0))
+ GuiLib_FillBox(X1, Y1 + ReadByte(sgl.CurFont->Underline1), X2,
+ Y1 + ReadByte(sgl.CurFont->Underline2), ForeColor);
+
+ GuiLib_MarkDisplayBoxRepaint(X1, Y1, X2, Y2);
+
+#ifdef GuiConst_BLINK_SUPPORT_ON
+#ifndef GuiConst_BLINK_FIELDS_OFF
+ if ((sgl.CurItem.TextPar[TextNdx].BitFlags & GuiLib_BITFLAG_BLINKTEXTFIELD) &&
+ (sgl.CurItem.BlinkFieldNo < GuiConst_BLINK_FIELDS_MAX))
+ {
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].InUse = 1;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].BlinkBoxInverted = 0;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].ItemType = sgl.CurItem.ItemType;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].CharCnt = CharCnt;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].TextPar = sgl.CurItem.TextPar[TextNdx];
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].FormatFieldWidth =
+ sgl.CurItem.FormatFieldWidth;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].FormatDecimals =
+ sgl.CurItem.FormatDecimals;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].FormatAlignment =
+ sgl.CurItem.FormatAlignment;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].FormatFormat = sgl.CurItem.FormatFormat;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].VarType = sgl.CurItem.VarType;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].XSize =
+ ReadByte(sgl.CurFont->XSize);
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].PsNumWidth =
+ ReadByte(sgl.CurFont->PsNumWidth);
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].PsSpace =
+ ReadByte(sgl.CurFont->PsSpace);
+ if (sgl.CurItem.ItemType == GuiLib_ITEM_TEXT)
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].TextPtr =
+ sgl.CurItem.TextPtr[TextNdx];
+ else
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].TextPtr =
+ (GuiConst_TEXT*)sgl.CurItem.VarPtr;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].X1 = sgl.CurItem.X1;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].X2 = sgl.CurItem.X2;
+ if (sgl.CurItem.TextPar[TextNdx].BackBoxSizeX > 0)
+ {
+ if (sgl.CurItem.TextPar[TextNdx].BackBoxSizeY1 > 0)
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].Y1 =
+ sgl.CurItem.Y1 - sgl.CurItem.TextPar[TextNdx].BackBoxSizeY1;
+ else
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].Y1 =
+ sgl.CurItem.Y1 - ReadByte(sgl.CurFont->BaseLine);
+ if (sgl.CurItem.TextPar[TextNdx].BackBoxSizeY1 > 0)
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].Y2 =
+ sgl.CurItem.Y1 + sgl.CurItem.TextPar[TextNdx].BackBoxSizeY2;
+ else
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].Y2 =
+ sgl.CurItem.Y1 - ReadByte(sgl.CurFont->BaseLine) +
+ ReadByte(sgl.CurFont->YSize) - 1;
+ }
+ else
+ {
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].Y1 = Y1;
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].Y2 = Y2;
+ }
+ }
+#endif
+#endif
+ }
+}
+
+#ifdef GuiConst_ITEM_TEXTBLOCK_INUSE
+
+//------------------------------------------------------------------------------
+#ifdef GuiConst_CHARMODE_ANSI
+ #ifdef GuiConst_ICC_COMPILER
+#define DRAW_ROM_TEXTBLOCK(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ DrawTextBlock((GuiConst_TEXT *)ChPtr, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+ #ifdef GuiConst_CODEVISION_COMPILER
+#define DRAW_ROM_TEXTBLOCK(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ DrawTextBlock((GuiConst_TEXT *)ChPtr, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+ #ifdef GuiConst_RENESAS_COMPILER_FAR
+#define DRAW_ROM_TEXTBLOCK(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ DrawTextBlock((GuiConst_TEXT PrefixLocate *)ChPtr, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+#define DRAW_ROM_TEXTBLOCK(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ DrawTextBlock((GuiConst_TEXT PrefixRom *)ChPtr, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #endif
+ #endif
+ #endif
+#else
+ #ifdef GuiConst_ICC_COMPILER
+#define DRAW_ROM_TEXTBLOCK(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ ExtractUnicodeString((GuiConst_INT8U *)ChPtr, ChCnt); \
+ DrawTextBlock((GuiConst_TEXT *)&sgl.UnicodeTextBuf, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+ #ifdef GuiConst_CODEVISION_COMPILER
+#define DRAW_ROM_TEXTBLOCK(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ ExtractUnicodeString((GuiConst_INT8U *)ChPtr, ChCnt); \
+ DrawTextBlock((GuiConst_TEXT *)sgl.UnicodeTextBuf, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+ #ifdef GuiConst_RENESAS_COMPILER_FAR
+#define DRAW_ROM_TEXTBLOCK(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ ExtractUnicodeString((GuiConst_INT8U PrefixLocate *)ChPtr, ChCnt); \
+ DrawTextBlock((GuiConst_TEXT PrefixLocate *)sgl.UnicodeTextBuf, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #else
+#define DRAW_ROM_TEXTBLOCK(ChPtr, ChCnt, TxtNdx, FColor, BColor, Transparent) \
+ ExtractUnicodeString((GuiConst_INT8U PrefixRom *)ChPtr, ChCnt); \
+ DrawTextBlock((GuiConst_TEXT *)&sgl.UnicodeTextBuf, \
+ ChCnt, \
+ TxtNdx, \
+ FColor, \
+ BColor, \
+ Transparent);
+ #endif
+ #endif
+#endif
+#endif
+
+//------------------------------------------------------------------------------
+static void DrawTextBlock(
+ GuiConst_TEXT PrefixGeneric *CharPtr,
+ GuiConst_INT16U CharCnt,
+ GuiConst_INT8U TextNdx,
+ GuiConst_INTCOLOR ForeColor,
+ GuiConst_INTCOLOR BackColor,
+ GuiConst_INT8U Transparent)
+{
+ GuiConst_INT16S X1, Y1, X2, Y2;
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+ GuiConst_INT16S CX1, CX2;
+#endif
+ GuiConst_INT16S CY1, CY2;
+ GuiConst_INT16S TextXOfs[GuiConst_MAX_TEXT_LEN + 2];
+ GuiConst_INT16S TextCharLineStart[GuiConst_MAX_PARAGRAPH_LINE_CNT + 1];
+ GuiConst_INT16S TextCharLineEnd[GuiConst_MAX_PARAGRAPH_LINE_CNT + 1];
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+ GuiConst_INT16S RemClipX1, RemClipY1, RemClipX2, RemClipY2;
+#endif
+#ifdef GuiConst_BLINK_SUPPORT_ON
+#ifndef GuiConst_BLINK_FIELDS_OFF
+ GuiConst_INT16S BlinkNo;
+#endif
+#endif
+ GuiConst_INT16S PixWidth;
+ GuiConst_INT16S N, P, M, F;
+ GuiConst_INT16S LineLen;
+ GuiConst_INT16S LineCnt;
+ GuiConst_INT16S LineCnt2;
+ GuiConst_INT16S BlindLinesAtTop;
+ GuiConst_INT16S XPos, YPos;
+ GuiConst_INT16S XStart, XEnd;
+ GuiConst_INT8U TempPsMode;
+#ifdef GuiConst_REMOTE_FONT_DATA
+ GuiConst_INT32U PrefixRom TempOfs;
+ GuiConst_INT8U CharHeader1[GuiLib_CHR_LINECTRL_OFS];
+ GuiConst_INT8U CharHeader2[GuiLib_CHR_LINECTRL_OFS];
+#else
+ GuiConst_INT8U PrefixRom * TempPtr;
+#endif
+
+ X1 = sgl.CurItem.X1;
+ Y1 = sgl.CurItem.Y1;
+ X2 = sgl.CurItem.X2;
+ Y2 = sgl.CurItem.Y2;
+ sgl.FontWriteX1 = X1;
+ sgl.FontWriteY1 = Y1;
+ sgl.FontWriteX2 = X2;
+ sgl.FontWriteY2 = Y2;
+
+ PixWidth = 0;
+
+ if (sgl.DisplayWriting)
+ {
+ if (!Transparent && (sgl.CurItem.TextPar[TextNdx].BackBoxSizeX == 0))
+ {
+ SetBackColorBox(X1, Y1, X2, Y2, TextNdx);
+ GuiLib_FillBox(sgl.BbX1, sgl.BbY1, sgl.BbX2, sgl.BbY2, BackColor);
+ }
+
+ if (sgl.CurItem.CompPars.CompTextBox.LineDistRelToFont)
+ {
+ sgl.CurItem.CompPars.CompTextBox.LineDist +=sgl.CurFont->YSize;
+ sgl.CurItem.CompPars.CompTextBox.LineDistRelToFont = 0;
+ }
+
+ LineCnt = 0;
+#ifdef GuiConst_TEXTBOX_FIELDS_ON
+ sgl.CurItem.CompPars.CompTextBox.Lines = 1;
+#endif
+ if (CharCnt > 0)
+ {
+ PixWidth = X2 - X1 + 1;
+
+#ifdef GuiConst_ARAB_CHARS_INUSE
+ CharCnt =
+ ArabicCorrection(CharPtr,
+ CharCnt,
+ (sgl.CurItem.TextPar[TextNdx].BitFlags &
+ GuiLib_BITFLAG_REVERSEWRITING) > 0);
+#endif
+ PrepareText(CharPtr, CharCnt, TextNdx);
+ TextPixelLength(sgl.CurItem.TextPar[TextNdx].Ps,
+ CharCnt,
+ TextXOfs);
+
+ TextCharLineStart[0] = 0;
+ TextCharLineEnd[0] = -1;
+#ifdef GuiConst_TEXTBOX_FIELDS_ON
+ if (sgl.CurItem.CompPars.CompTextBox.ScrollIndex == 0xFF)
+ BlindLinesAtTop = 0;
+ else
+ BlindLinesAtTop = sgl.CurItem.CompPars.CompTextBox.ScrollPos /
+ sgl.CurItem.CompPars.CompTextBox.LineDist;
+#else
+ BlindLinesAtTop = 0;
+#endif
+ LineCnt = 1 - BlindLinesAtTop;
+ if (LineCnt >= 1)
+ LineCnt = 1;
+ LineCnt2 = 1;
+ P = 0;
+#ifdef GuiConst_REMOTE_FONT_DATA
+ GuiLib_RemoteDataReadBlock(
+ (GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[
+ sgl.TextCharNdx[TextCharLineStart[LineCnt2 - 1]]],
+ GuiLib_CHR_LINECTRL_OFS,
+ CharHeader2);
+#endif
+ while (P < CharCnt)
+ {
+ while ((P < CharCnt - 1) &&
+ !((ReadBytePtr(CharPtr + P) == GuiLib_LINEFEED) ||
+ ((ReadBytePtr(CharPtr + P) != ' ') &&
+ (ReadBytePtr(CharPtr + P + 1) == ' ')) ||
+ ((ReadBytePtr(CharPtr + P) == '-') &&
+ (ReadBytePtr(CharPtr + P + 1) != ' '))))
+ P++;
+
+ F = 0;
+
+ if (CalcCharsWidth(TextCharLineStart[LineCnt2 - 1], P,
+ TextXOfs, &XStart, &XEnd) > PixWidth)
+ {
+ if (TextCharLineEnd[LineCnt2 - 1] == -1)
+ {
+ if (ReadBytePtr(CharPtr + P) == GuiLib_LINEFEED)
+ {
+ TextCharLineEnd[LineCnt2 - 1] = P - 1;
+ F = 1;
+ }
+ else
+ TextCharLineEnd[LineCnt2 - 1] = P;
+
+ TextCharLineStart[LineCnt2] = P + 1;
+ TextCharLineEnd[LineCnt2] = -1;
+ }
+ else
+ {
+ TextCharLineStart[LineCnt2] = TextCharLineEnd[LineCnt2 - 1] + 1;
+ while ((TextCharLineStart[LineCnt2] < P) &&
+ (ReadBytePtr(CharPtr + TextCharLineStart[LineCnt2]) == ' '))
+ TextCharLineStart[LineCnt2]++;
+ TextCharLineEnd[LineCnt2] = P;
+ }
+ if (LineCnt >= GuiConst_MAX_PARAGRAPH_LINE_CNT)
+ {
+ P = CharCnt;
+ break;
+ }
+ LineCnt++;
+ if (LineCnt > 1)
+ LineCnt2 = LineCnt;
+ else
+ {
+ TextCharLineStart[LineCnt2 - 1] = TextCharLineStart[LineCnt2];
+ TextCharLineEnd[LineCnt2 - 1] = TextCharLineEnd[LineCnt2];
+ }
+#ifdef GuiConst_TEXTBOX_FIELDS_ON
+ sgl.CurItem.CompPars.CompTextBox.Lines++;
+#endif
+ }
+ else
+ TextCharLineEnd[LineCnt2 - 1] = P;
+
+ if ((ReadBytePtr(CharPtr + P) == GuiLib_LINEFEED) &&
+ (F == 0))
+ {
+ TextCharLineEnd[LineCnt2 - 1] = P - 1;
+ TextCharLineStart[LineCnt2] = P + 1;
+ TextCharLineEnd[LineCnt2] = -1;
+
+ if (LineCnt >= GuiConst_MAX_PARAGRAPH_LINE_CNT)
+ {
+ P = CharCnt;
+ break;
+ }
+ LineCnt++;
+ if (LineCnt > 1)
+ LineCnt2 = LineCnt;
+ else
+ {
+ TextCharLineStart[LineCnt2 - 1] = TextCharLineStart[LineCnt2];
+ TextCharLineEnd[LineCnt2 - 1] = TextCharLineEnd[LineCnt2];
+ }
+#ifdef GuiConst_TEXTBOX_FIELDS_ON
+ sgl.CurItem.CompPars.CompTextBox.Lines++;
+#endif
+ }
+
+ P++;
+ }
+ }
+
+ if (LineCnt >= 1)
+ {
+ if (sgl.CurItem.TextPar[TextNdx].BitFlags & GuiLib_BITFLAG_REVERSEWRITING)
+ {
+ for (M = 0; M < LineCnt ; M++)
+ {
+ for (P = TextCharLineStart[M]; P <= (TextCharLineStart[M] +
+ ((TextCharLineEnd[M] - TextCharLineStart[M] + 1) / 2) - 1); P++)
+ {
+#ifdef GuiConst_REMOTE_FONT_DATA
+ TempOfs = sgl.TextCharNdx[P];
+ sgl.TextCharNdx[P] =
+ sgl.TextCharNdx[TextCharLineEnd[M] - (P - TextCharLineStart[M])];
+ sgl.TextCharNdx[TextCharLineEnd[M] - (P - TextCharLineStart[M])] =
+ TempOfs;
+#else
+#ifdef GuiConst_CODEVISION_COMPILER
+ TempPtr = &sgl.TextCharPtrAry[P];
+#else
+ TempPtr = sgl.TextCharPtrAry[P];
+#endif
+ sgl.TextCharPtrAry[P] = (GuiConst_INT8U PrefixRom *)
+ sgl.TextCharPtrAry[TextCharLineEnd[M] - (P - TextCharLineStart[M])];
+ sgl.TextCharPtrAry[TextCharLineEnd[M] - (P - TextCharLineStart[M])] =
+ (GuiConst_INT8U PrefixRom *)TempPtr;
+#endif
+ TempPsMode = sgl.TextPsMode[P];
+ sgl.TextPsMode[P] =
+ sgl.TextPsMode[TextCharLineEnd[M] - (P - TextCharLineStart[M])];
+ sgl.TextPsMode[TextCharLineEnd[M] - (P - TextCharLineStart[M])] =
+ TempPsMode;
+ }
+ }
+ TextPixelLength(sgl.CurItem.TextPar[TextNdx].Ps,
+ CharCnt,
+ TextXOfs);
+ }
+
+ CY1 = Y1;
+ CY2 = Y2;
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+ CX1 = X1;
+ CX2 = X2;
+ RemClipX1 = sgl.CurItem.ClipRectX1;
+ RemClipY1 = sgl.CurItem.ClipRectY1;
+ RemClipX2 = sgl.CurItem.ClipRectX2;
+ RemClipY2 = sgl.CurItem.ClipRectY2;
+ if (RemClipX1 > CX1)
+ CX1 = RemClipX1;
+ if (RemClipY1 > CY1)
+ CY1 = RemClipY1;
+ if (RemClipX2 < CX2)
+ CX2 = RemClipX2;
+ if (RemClipY2 < CY2)
+ CY2 = RemClipY2;
+ GuiLib_SetClipping(CX1, CY1, CX2, CY2);
+#endif
+
+#ifdef GuiConst_BLINK_SUPPORT_ON
+#ifndef GuiConst_BLINK_FIELDS_OFF
+ if ((sgl.CurItem.TextPar[TextNdx].BitFlags & GuiLib_BITFLAG_BLINKTEXTFIELD) &&
+ (sgl.CurItem.BlinkFieldNo < GuiConst_BLINK_FIELDS_MAX))
+ {
+ BlinkNo = sgl.CurItem.BlinkFieldNo;
+ sgl.BlinkTextItems[BlinkNo].InUse = 1;
+ sgl.BlinkTextItems[BlinkNo].ItemType = sgl.CurItem.ItemType;
+ sgl.BlinkTextItems[BlinkNo].VarType = sgl.CurItem.VarType;
+ sgl.BlinkTextItems[BlinkNo].CharCnt = CharCnt;
+ sgl.BlinkTextItems[BlinkNo].TextPar = sgl.CurItem.TextPar[TextNdx];
+ sgl.BlinkTextItems[BlinkNo].XSize = sgl.CurFont->XSize;
+ sgl.BlinkTextItems[BlinkNo].YSize = sgl.CurFont->YSize;
+ sgl.BlinkTextItems[BlinkNo].PsNumWidth = sgl.CurFont->PsNumWidth;
+ sgl.BlinkTextItems[BlinkNo].PsSpace = sgl.CurFont->PsSpace;
+ if (sgl.CurItem.ItemType == GuiLib_ITEM_TEXTBLOCK)
+ sgl.BlinkTextItems[BlinkNo].TextPtr = sgl.CurItem.TextPtr[TextNdx];
+ else
+ sgl.BlinkTextItems[BlinkNo].TextPtr = (GuiConst_TEXT*)sgl.CurItem.VarPtr;
+ sgl.BlinkTextItems[BlinkNo].X1 = X1;
+ sgl.BlinkTextItems[BlinkNo].X2 = X2;
+ sgl.BlinkTextItems[BlinkNo].Y1 = Y1;
+ sgl.BlinkTextItems[BlinkNo].Y2 = Y2;
+ sgl.BlinkTextItems[BlinkNo].LineCnt = LineCnt;
+ sgl.BlinkTextItems[BlinkNo].TextBoxLineDist =
+ sgl.CurItem.CompPars.CompTextBox.LineDist;
+ sgl.BlinkTextItems[BlinkNo].BlindLinesAtTop = BlindLinesAtTop;
+ sgl.BlinkTextItems[BlinkNo].FormatFieldWidth = sgl.CurItem.FormatFieldWidth;
+ sgl.BlinkTextItems[BlinkNo].FormatDecimals = sgl.CurItem.FormatDecimals;
+ sgl.BlinkTextItems[BlinkNo].FormatAlignment = sgl.CurItem.FormatAlignment;
+ sgl.BlinkTextItems[BlinkNo].FormatFormat = sgl.CurItem.FormatFormat;
+ sgl.BlinkTextItems[BlinkNo].TextBoxHorzAlignment =
+ sgl.CurItem.CompPars.CompTextBox.HorzAlignment;
+ sgl.BlinkTextItems[BlinkNo].TextBoxVertAlignment =
+ sgl.CurItem.CompPars.CompTextBox.VertAlignment;
+#ifdef GuiConst_TEXTBOX_FIELDS_ON
+ sgl.BlinkTextItems[BlinkNo].TextBoxScrollPos =
+ sgl.CurItem.CompPars.CompTextBox.ScrollPos;
+#endif
+ }
+ else
+ BlinkNo = -1;
+#endif
+#endif
+
+ YPos = Y1;
+#ifdef GuiConst_TEXTBOX_FIELDS_ON
+ if (BlindLinesAtTop < 0)
+ BlindLinesAtTop = 0;
+ YPos -= sgl.CurItem.CompPars.CompTextBox.ScrollPos -
+ (sgl.CurItem.CompPars.CompTextBox.LineDist * BlindLinesAtTop);
+#endif
+
+ N = ReadByte(sgl.CurFont->YSize) +
+ (LineCnt - 1) * sgl.CurItem.CompPars.CompTextBox.LineDist;
+ switch (sgl.CurItem.CompPars.CompTextBox.VertAlignment)
+ {
+ case GuiLib_ALIGN_CENTER:
+ YPos += (Y2 - Y1 + 1 - N) / 2;
+ break;
+
+ case GuiLib_ALIGN_RIGHT:
+ YPos += Y2 - Y1 + 1 - N;
+ break;
+ }
+
+ for (N = 0; N < LineCnt; N++)
+ {
+ if (TextCharLineEnd[N] >= TextCharLineStart[N])
+ {
+ XPos = X1;
+
+ LineLen = CalcCharsWidth(TextCharLineStart[N],
+ TextCharLineEnd[N],
+ TextXOfs,
+ &XStart,
+ &XEnd);
+ switch (sgl.CurItem.CompPars.CompTextBox.HorzAlignment)
+ {
+ case GuiLib_ALIGN_CENTER:
+ XPos += (PixWidth - LineLen) / 2;
+ break;
+
+ case GuiLib_ALIGN_RIGHT:
+ XPos += PixWidth - LineLen;
+ break;
+ }
+
+ if (sgl.CurItem.TextPar[TextNdx].BitFlags & GuiLib_BITFLAG_UNDERLINE)
+ GuiLib_FillBox(XPos, YPos + ReadByte(sgl.CurFont->Underline1),
+ XPos + LineLen - 1, YPos + ReadByte(sgl.CurFont->Underline2),
+ ForeColor);
+
+ XPos -= XStart;
+ if ((YPos + sgl.CurFont->YSize >= CY1) && (YPos <= CY2))
+ for (P = TextCharLineStart[N]; P <= TextCharLineEnd[N]; P++)
+#ifdef GuiConst_REMOTE_FONT_DATA
+ DrawChar(
+ XPos + TextXOfs[P], YPos, sgl.CurFont, sgl.TextCharNdx[P], ForeColor, 0);
+#else
+ DrawChar(XPos + TextXOfs[P], YPos, sgl.CurFont, sgl.TextCharPtrAry[P],
+ ForeColor, 0);
+#endif
+ }
+ YPos += sgl.CurItem.CompPars.CompTextBox.LineDist;
+ }
+
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+ GuiLib_SetClipping(RemClipX1, RemClipY1, RemClipX2, RemClipY2);
+#endif
+ }
+ GuiLib_MarkDisplayBoxRepaint(X1, Y1, X2, Y2);
+ }
+}
+#endif
+// Groupend DRAW
+
+#ifdef GuiConst_FLOAT_SUPPORT_ON
+static float Floor(float X)
+{
+ GuiConst_INT32S I;
+
+ I = X - 2;
+ while(++I <= X - 1);
+ return I;
+}
+#endif
+
+//------------------------------------------------------------------------------
+static GuiConst_INT32S ReadVar(
+ void PrefixLocate *VarPtr,
+ GuiConst_INT8U VarType)
+{
+#ifdef GuiConst_FLOAT_SUPPORT_ON
+ GuiConst_INT32S tmp;
+ GuiConst_INT8U i;
+ double dfactor;
+ double dx;
+ float ffactor;
+ float fx;
+#endif
+
+ if (VarPtr == 0)
+ return (0);
+ else
+ {
+ if (sgl.CurItem.FormatFormat == GuiLib_FORMAT_EXP)
+ {
+#ifdef GuiConst_FLOAT_SUPPORT_ON
+ if ((VarType == GuiLib_VAR_FLOAT) || (VarType == GuiLib_VAR_DOUBLE))
+ sgl.VarExponent = 0;
+ else
+#endif
+ sgl.CurItem.FormatFormat = GuiLib_FORMAT_DEC;
+ }
+ switch (VarType)
+ {
+ case GuiLib_VAR_BOOL:
+ if (*(GuiConst_INT8U PrefixLocate *) VarPtr == 0)
+ return (0);
+ else
+ return (1);
+
+ case GuiLib_VAR_UNSIGNED_CHAR:
+ return (*(GuiConst_INT8U PrefixLocate *) VarPtr);
+
+ case GuiLib_VAR_SIGNED_CHAR:
+ return (*(GuiConst_INT8S PrefixLocate *) VarPtr);
+
+ case GuiLib_VAR_UNSIGNED_INT:
+ return (*(GuiConst_INT16U PrefixLocate *) VarPtr);
+
+ case GuiLib_VAR_SIGNED_INT:
+ return (*(GuiConst_INT16S PrefixLocate *) VarPtr);
+
+ case GuiLib_VAR_UNSIGNED_LONG:
+ return (*(GuiConst_INT32U PrefixLocate *) VarPtr);
+
+ case GuiLib_VAR_SIGNED_LONG:
+ return (*(GuiConst_INT32S PrefixLocate *) VarPtr);
+
+ case GuiLib_VAR_COLOR:
+ return (*(GuiConst_INTCOLOR PrefixLocate *) VarPtr);
+
+ case GuiLib_VAR_FLOAT:
+#ifdef GuiConst_FLOAT_SUPPORT_ON
+ fx = *(float PrefixLocate *) VarPtr;
+ if (fx < 0)
+ fx = -fx;
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_EXP) && (fx != 0))
+ {
+ while (Floor(fx + 0.5) > 10)
+ {
+ fx /= 10;
+ sgl.VarExponent++;
+ }
+ while (Floor(fx) < 1)
+ {
+ fx *= 10;
+ sgl.VarExponent--;
+ }
+ }
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_DEC) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_EXP))
+ {
+ ffactor=1.0;
+ for (i = 0; i < sgl.CurItem.FormatDecimals ; i++)
+ ffactor *= 10.0;
+ tmp = (GuiConst_INT32S) (fx * ffactor);
+ ffactor *= 100.0;
+ if (((GuiConst_INT32S) (fx * ffactor) - (tmp * 100)) >= 45)
+ tmp++;
+ if (*(float PrefixLocate *) VarPtr < 0)
+ tmp = -tmp;
+ }
+ else
+ tmp = (GuiConst_INT32S) *(float PrefixLocate *) VarPtr;
+ return (tmp);
+#else
+ return (0);
+#endif
+
+ case GuiLib_VAR_DOUBLE:
+#ifdef GuiConst_FLOAT_SUPPORT_ON
+ dx = *(double PrefixLocate *) VarPtr;
+ if (dx < 0)
+ dx = -dx;
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_EXP) && (dx != 0))
+ {
+ while (dx > 10)
+ {
+ dx /= 10;
+ sgl.VarExponent++;
+ }
+ while (dx < 1)
+ {
+ dx *= 10;
+ sgl.VarExponent--;
+ }
+ }
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_DEC) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_EXP))
+ {
+ dfactor=1.0;
+ for (i = 0; i < sgl.CurItem.FormatDecimals ; i++)
+ dfactor *= 10.0;
+ tmp = (GuiConst_INT32S) (dx * dfactor);
+ dfactor *= 100.0;
+ if (((GuiConst_INT32S) (dx * dfactor) - (tmp * 100)) >= 45)
+ tmp++;
+ if (*(double PrefixLocate *) VarPtr < 0)
+ tmp = -tmp;
+ }
+ else
+ tmp = (GuiConst_INT32S) dx;
+ return (tmp);
+#else
+ return (0);
+#endif
+
+ default:
+ return (0);
+ }
+ }
+}
+
+//------------------------------------------------------------------------------
+static GuiConst_INT8U DataNumStr(
+ GuiConst_INT32S DataValue,
+ GuiConst_INT8U VarType,
+ GuiConst_INT8U TextNdx)
+{
+ GuiConst_CHAR *S1;
+ GuiConst_INT8U StrLen, L;
+ GuiConst_INT16S I, N, P;
+ GuiConst_INT8U Offset;
+ GuiConst_INT8U Sign;
+ GuiConst_INT8U ShowSign;
+ GuiConst_INT8U ZeroPadding;
+ GuiConst_INT8U TrailingZeros;
+ GuiConst_INT8U ThousandsSeparator;
+ GuiConst_INT8U Time;
+ GuiConst_INT16S TT1, TT2, TT3;
+ GuiConst_INT8U am;
+ GuiConst_INT8U DecimalsPos;
+#ifdef GuiConst_FLOAT_SUPPORT_ON
+ GuiConst_CHAR ExponentStr[5];
+#endif
+
+ sgl.VarNumTextStr[0] = 0;
+ am = 0;
+
+ Sign = 0;
+ switch (VarType)
+ {
+ case GuiLib_VAR_BOOL:
+ case GuiLib_VAR_UNSIGNED_CHAR:
+ if (DataValue > 255)
+ DataValue = 255;
+ else if (DataValue < 0)
+ DataValue = 0;
+ break;
+
+ case GuiLib_VAR_SIGNED_CHAR:
+ if (DataValue > 127)
+ DataValue = 127;
+ else if (DataValue < -128)
+ DataValue = -128;
+ if (DataValue < 0)
+ Sign = 1;
+ break;
+
+ case GuiLib_VAR_UNSIGNED_INT:
+ if (DataValue > 65535)
+ DataValue = 65535;
+ else if (DataValue < 0)
+ DataValue = 0;
+ break;
+
+ case GuiLib_VAR_SIGNED_INT:
+ if (DataValue > 32767)
+ DataValue = 32767;
+ else if (DataValue < -32768)
+ DataValue = -32768;
+ if (DataValue < 0)
+ Sign = 1;
+ break;
+
+ case GuiLib_VAR_SIGNED_LONG:
+ case GuiLib_VAR_FLOAT:
+ case GuiLib_VAR_DOUBLE:
+ if (DataValue < 0)
+ Sign = 1;
+ break;
+
+ case GuiLib_VAR_COLOR:
+ if (DataValue < 0)
+ DataValue = 0;
+#if GuiConst_PIXEL_BYTE_SIZE == 1
+ if (DataValue > 255)
+ DataValue = 255;
+#elif GuiConst_PIXEL_BYTE_SIZE == 2
+ if (DataValue > 65535)
+ DataValue = 65535;
+#elif GuiConst_PIXEL_BYTE_SIZE == 3
+ if (DataValue > 16777215)
+ DataValue = 16777215;
+#endif
+ break;
+ }
+
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_DEC) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_EXP))
+ DecimalsPos = sgl.CurItem.FormatDecimals;
+ else
+ DecimalsPos = 0;
+ Time = ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_MMSS) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMM_24) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMMSS_24) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMM_12_ampm) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMMSS_12_ampm) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMM_12_AMPM) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMMSS_12_AMPM));
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_DEC) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_EXP))
+ ShowSign = ((sgl.CurItem.TextPar[TextNdx].BitFlags &
+ GuiLib_BITFLAG_FORMATSHOWSIGN) > 0);
+ else
+ {
+ Sign = 0;
+ ShowSign = 0;
+ }
+ if (sgl.CurItem.FormatAlignment == GuiLib_FORMAT_ALIGNMENT_RIGHT)
+ ZeroPadding = ((sgl.CurItem.TextPar[TextNdx].BitFlags &
+ GuiLib_BITFLAG_FORMATZEROPADDING) > 0);
+ else
+ ZeroPadding = 0;
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_DEC) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_EXP))
+ TrailingZeros = ((sgl.CurItem.TextPar[TextNdx].BitFlags &
+ GuiLib_BITFLAG_FORMATTRAILINGZEROS) > 0);
+ else
+ TrailingZeros = 0;
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_DEC) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_HEX_POSTFIX_H) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_HEX_PREFIX_0X) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_HEX_CLEAN))
+ ThousandsSeparator = ((sgl.CurItem.TextPar[TextNdx].BitFlags &
+ GuiLib_BITFLAG_FORMATTHOUSANDSSEP) > 0);
+ else
+ ThousandsSeparator = 0;
+
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_DEC) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_EXP))
+ {
+ if (Sign)
+ ConvertIntToStr(-DataValue, sgl.VarNumTextStr, 10);
+ else
+ ConvertIntToStr(DataValue, sgl.VarNumTextStr, 10);
+ }
+
+ else if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_HEX_POSTFIX_H) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_HEX_PREFIX_0X) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_HEX_CLEAN))
+ {
+ ConvertIntToStr(DataValue, sgl.VarNumTextStr, 16);
+ S1 = sgl.VarNumTextStr;
+ StrLen = 0;
+ while (*S1 != 0)
+ {
+ if ((*S1 >= 'a') && (*S1 <= 'f'))
+ *S1 -= 32;
+ S1++;
+ StrLen++;
+ }
+ if (DataValue < 0)
+ {
+ while ((StrLen > 1) && (StrLen >= sgl.CurItem.FormatFieldWidth))
+ {
+ if (sgl.VarNumTextStr[0] == 'F')
+ {
+ for (N = 0; N < StrLen; N++)
+ sgl.VarNumTextStr[N] = sgl.VarNumTextStr[N + 1];
+ sgl.VarNumTextStr[StrLen] = 0;
+ StrLen--;
+ }
+ else
+ break;
+ }
+
+ }
+ if (StrLen >= GuiConst_MAX_VARNUM_TEXT_LEN)
+ return (0);
+
+ switch (sgl.CurItem.FormatFormat)
+ {
+ case GuiLib_FORMAT_HEX_POSTFIX_H:
+ if (StrLen < GuiConst_MAX_VARNUM_TEXT_LEN - 1)
+ {
+ #ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "h");
+ #else
+ strcat(sgl.VarNumTextStr, "h");
+ #endif
+ }
+ break;
+ case GuiLib_FORMAT_HEX_PREFIX_0X:
+ if (StrLen < GuiConst_MAX_VARNUM_TEXT_LEN - 2)
+ {
+ for (N = StrLen - 1; N >= 0; N--)
+ sgl.VarNumTextStr[N + 2] = sgl.VarNumTextStr[N];
+ sgl.VarNumTextStr[0] = '0';
+ sgl.VarNumTextStr[1] = 'x';
+ }
+ break;
+ }
+ }
+
+ else if (Time)
+ {
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMMSS_24) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMMSS_12_ampm) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMMSS_12_AMPM))
+ {
+ DataValue %= 360000;
+ TT1 = DataValue / 3600;
+ TT2 = (DataValue % 3600) / 60;
+ TT3 = DataValue % 60;
+ }
+ else
+ {
+ DataValue %= 6000;
+ TT1 = DataValue / 60;
+ TT2 = DataValue % 60;
+ TT3 = -1;
+ }
+
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMM_12_ampm) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMMSS_12_ampm) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMM_12_AMPM) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMMSS_12_AMPM))
+ {
+ am = ((TT1%24) < 12);
+ TT1 %= 12;
+ if (TT1 == 0)
+ TT1 = 12;
+ }
+ else
+ am = 0; // To avoid compiler warning
+
+ if (ZeroPadding && (TT1 < 10))
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "0");
+#else
+ strcat(sgl.VarNumTextStr, "0");
+#endif
+ ConvertIntToStr(TT1, sgl.VarNumTextStr + strlen(sgl.VarNumTextStr), 10);
+
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, ":");
+#else
+ strcat(sgl.VarNumTextStr, ":");
+#endif
+
+ if (TT2 < 10)
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "0");
+#else
+ strcat(sgl.VarNumTextStr, "0");
+#endif
+ ConvertIntToStr(TT2, sgl.VarNumTextStr + strlen(sgl.VarNumTextStr), 10);
+
+ if (TT3 >= 0)
+ {
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, ":");
+#else
+ strcat(sgl.VarNumTextStr, ":");
+#endif
+
+ if (TT3 < 10)
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "0");
+#else
+ strcat(sgl.VarNumTextStr, "0");
+#endif
+ ConvertIntToStr(TT3, sgl.VarNumTextStr + strlen(sgl.VarNumTextStr), 10);
+ }
+
+ if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMM_12_ampm) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMMSS_12_ampm))
+ {
+ if (am)
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "am");
+#else
+ strcat(sgl.VarNumTextStr, "am");
+#endif
+ else
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "pm");
+#else
+ strcat(sgl.VarNumTextStr, "pm");
+#endif
+ }
+ else if ((sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMM_12_AMPM) ||
+ (sgl.CurItem.FormatFormat == GuiLib_FORMAT_TIME_HHMMSS_12_AMPM))
+ {
+ if (am)
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "AM");
+#else
+ strcat(sgl.VarNumTextStr, "AM");
+#endif
+ else
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "PM");
+#else
+ strcat(sgl.VarNumTextStr, "PM");
+#endif
+ }
+ }
+ else
+ return (0);
+
+ StrLen = 0;
+ S1 = sgl.VarNumTextStr;
+ while (*S1 != 0)
+ {
+ StrLen++;
+ S1++;
+ }
+
+ if (DecimalsPos > 0)
+ {
+ L = DecimalsPos + 1;
+ if (StrLen < L)
+ {
+ if (L > GuiConst_MAX_VARNUM_TEXT_LEN)
+ return (0);
+ for (N = 1; N <= StrLen; N++)
+ sgl.VarNumTextStr[L - N] = sgl.VarNumTextStr[StrLen - N];
+ for (N = 0; N < L - StrLen; N++)
+ sgl.VarNumTextStr[N] = '0';
+
+ StrLen = L;
+ }
+
+ if ((!TrailingZeros) && (!Time) && (VarType != GuiLib_VAR_BOOL))
+ {
+ L = StrLen;
+ for (N = L - 1; N > L - sgl.CurItem.FormatDecimals; N--)
+ if (sgl.VarNumTextStr[N] == '0')
+ {
+ DecimalsPos--;
+ StrLen--;
+ }
+ else
+ break;
+ }
+
+ if (StrLen >= GuiConst_MAX_VARNUM_TEXT_LEN)
+ return (0);
+ P = StrLen - DecimalsPos;
+ for (N = StrLen; N > P; N--)
+ sgl.VarNumTextStr[N] = sgl.VarNumTextStr[N - 1];
+ if (ReadByte(GuiFont_DecimalChar[GuiLib_LanguageIndex]) == GuiLib_DECIMAL_PERIOD)
+ sgl.VarNumTextStr[P] = '.';
+ else
+ sgl.VarNumTextStr[P] = ',';
+ StrLen++;
+ sgl.VarNumTextStr[StrLen] = 0;
+ }
+ else
+ P = StrLen;
+
+ if (ThousandsSeparator)
+ {
+ I = 0;
+ while (P > 0)
+ {
+ if ((I > 0) && (I % 3 ==0 ))
+ {
+ for (N = StrLen; N > P; N--)
+ sgl.VarNumTextStr[N] = sgl.VarNumTextStr[N - 1];
+ if (ReadByte(GuiFont_DecimalChar[GuiLib_LanguageIndex]) == GuiLib_DECIMAL_PERIOD)
+ sgl.VarNumTextStr[P] = ',';
+ else
+ sgl.VarNumTextStr[P] = '.';
+ StrLen++;
+ if (StrLen >= GuiConst_MAX_VARNUM_TEXT_LEN)
+ return (0);
+ sgl.VarNumTextStr[StrLen] = 0;
+ }
+ I++;
+ P--;
+ }
+ }
+
+ if (Sign || ShowSign)
+ {
+ if (StrLen > GuiConst_MAX_VARNUM_TEXT_LEN)
+ return (0);
+ for (N = StrLen; N >= 1; N--)
+ sgl.VarNumTextStr[N] = sgl.VarNumTextStr[N - 1];
+ if (Sign)
+ sgl.VarNumTextStr[0] = '-';
+ else
+ sgl.VarNumTextStr[0] = '+';
+ StrLen++;
+ sgl.VarNumTextStr[StrLen] = 0;
+ }
+
+#ifdef GuiConst_FLOAT_SUPPORT_ON
+ if (sgl.CurItem.FormatFormat == GuiLib_FORMAT_EXP)
+ {
+ N = sgl.VarExponent;
+ if (N < 0)
+ N = -N;
+ ConvertIntToStr(N, ExponentStr, 10);
+ S1 = ExponentStr;
+ N = 0;
+ while (*S1 != 0)
+ {
+ S1++;
+ N++;
+ }
+ if (N == 1)
+ I = 2;
+ else
+ I = N;
+ if (StrLen + 2 + I >= GuiConst_MAX_VARNUM_TEXT_LEN)
+ return (0);
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "E");
+#else
+ strcat(sgl.VarNumTextStr, "E");
+#endif
+ StrLen++;
+ if (sgl.VarExponent >= 0)
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "+");
+#else
+ strcat(sgl.VarNumTextStr, "+");
+#endif
+ else
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "-");
+#else
+ strcat(sgl.VarNumTextStr, "-");
+#endif
+ StrLen++;
+ if (N == 1)
+ {
+#ifdef GuiConst_CODEVISION_COMPILER
+ strcatf(sgl.VarNumTextStr, "0");
+#else
+ strcat(sgl.VarNumTextStr, "0");
+#endif
+ StrLen++;
+ }
+ strcat(sgl.VarNumTextStr, ExponentStr);
+ StrLen += N;
+ }
+#endif
+
+ if (sgl.CurItem.FormatFieldWidth > 0)
+ {
+ if (StrLen > sgl.CurItem.FormatFieldWidth)
+ {
+ for (N = 0; N < sgl.CurItem.FormatFieldWidth; N++)
+ sgl.VarNumTextStr[N] = '-';
+ }
+ else
+ {
+ if (sgl.CurItem.FormatFieldWidth > GuiConst_MAX_VARNUM_TEXT_LEN)
+ return (0);
+ if (ZeroPadding && (!Time))
+ {
+ if ((sgl.VarNumTextStr[0] == '-') || (sgl.VarNumTextStr[0] == '+'))
+ Offset = 1;
+ else
+ Offset = 0;
+ for (N = 1; N <= StrLen - Offset; N++)
+ sgl.VarNumTextStr[sgl.CurItem.FormatFieldWidth - N] =
+ sgl.VarNumTextStr[StrLen - N];
+ for (N = 0; N < sgl.CurItem.FormatFieldWidth - StrLen; N++)
+ sgl.VarNumTextStr[N + Offset] = '0';
+ }
+ else if (sgl.CurItem.FormatAlignment == GuiLib_FORMAT_ALIGNMENT_LEFT)
+ {
+ for (N = StrLen; N < sgl.CurItem.FormatFieldWidth; N++)
+ sgl.VarNumTextStr[N] = ' ';
+ }
+ else if (sgl.CurItem.FormatAlignment == GuiLib_FORMAT_ALIGNMENT_CENTER)
+ {
+ Offset = (sgl.CurItem.FormatFieldWidth - StrLen) / 2;
+ if (Offset > 0)
+ {
+ for (N = StrLen - 1; N >= 0; N--)
+ sgl.VarNumTextStr[N + Offset] = sgl.VarNumTextStr[N];
+ for (N = 0; N < Offset; N++)
+ sgl.VarNumTextStr[N] = ' ';
+ }
+ Offset = sgl.CurItem.FormatFieldWidth - StrLen - Offset;
+ if (Offset > 0)
+ for (N = sgl.CurItem.FormatFieldWidth - Offset;
+ N < sgl.CurItem.FormatFieldWidth; N++)
+ sgl.VarNumTextStr[N] = ' ';
+ }
+ else if (sgl.CurItem.FormatAlignment == GuiLib_FORMAT_ALIGNMENT_RIGHT)
+ {
+ for (N = 1; N <= StrLen; N++)
+ sgl.VarNumTextStr[sgl.CurItem.FormatFieldWidth - N] =
+ sgl.VarNumTextStr[StrLen - N];
+ for (N = 0; N < sgl.CurItem.FormatFieldWidth - StrLen; N++)
+ sgl.VarNumTextStr[N] = ' ';
+ }
+ }
+ sgl.VarNumTextStr[sgl.CurItem.FormatFieldWidth] = 0;
+ return (sgl.CurItem.FormatFieldWidth);
+ }
+ else
+ {
+ sgl.VarNumTextStr[StrLen] = 0;
+ return (StrLen);
+ }
+}
+
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+//------------------------------------------------------------------------------
+static GuiLib_StructPtr GetRemoteStructData(
+ GuiConst_INT32S StructIndex)
+{
+ sgl.RemoteStructOffset =
+ (GuiConst_INT32U PrefixRom)GuiStruct_StructPtrList[StructIndex];
+ GuiLib_RemoteDataReadBlock(
+ sgl.RemoteStructOffset,
+ 1,
+ sgl.GuiLib_RemoteStructBuffer);
+ sgl.RemoteStructOffset++;
+ return((GuiLib_StructPtr)&sgl.GuiLib_RemoteStructBuffer[0]);
+}
+
+#ifdef GuiConst_REMOTE_TEXT_DATA
+//------------------------------------------------------------------------------
+static GuiConst_INT16U GetRemoteText(
+ GuiConst_INT16U TextIndex)
+{
+ GuiConst_INT32S TextOfs;
+
+ if (TextIndex != sgl.CurRemoteText)
+ {
+ if (sgl.RemoteTextTableOfs == -1)
+ GuiLib_RemoteTextReadBlock(4, 4, &sgl.RemoteTextTableOfs);
+
+ GuiLib_RemoteTextReadBlock(sgl.RemoteTextTableOfs + 6 * TextIndex, 4, &TextOfs);
+ GuiLib_RemoteTextReadBlock(
+ sgl.RemoteTextTableOfs + 6 * TextIndex + 4, 2, &sgl.RemoteTextLen);
+
+#ifdef GuiConst_CHARMODE_ANSI
+ GuiLib_RemoteTextReadBlock(TextOfs, sgl.RemoteTextLen, sgl.GuiLib_RemoteTextBuffer);
+#else
+ GuiLib_RemoteTextReadBlock(TextOfs, 2 * sgl.RemoteTextLen, sgl.GuiLib_RemoteTextBuffer);
+#endif
+ sgl.CurRemoteText = TextIndex;
+ }
+ return(sgl.RemoteTextLen);
+}
+#endif
+
+#endif
+
+#ifdef GuiConst_CHARMODE_UNICODE
+//------------------------------------------------------------------------------
+static void ExtractUnicodeString(
+ GuiConst_INT8U PrefixLocate *ItemTextPtr,
+ GuiConst_INT16U TextLength)
+{
+ GuiConst_INT16U P;
+
+ for (P = 0; P < TextLength; P++)
+ sgl.UnicodeTextBuf[P] = GetItemWord(&ItemTextPtr);
+ sgl.UnicodeTextBuf[TextLength] = 0;
+}
+#endif
+
+//------------------------------------------------------------------------------
+static void SetCurFont(
+ GuiConst_INT8U FontIndex)
+{
+ if (FontIndex >= GuiFont_FontCnt)
+ sgl.CurFont = (GuiLib_FontRecPtr)ReadWord(GuiFont_FontList[0]);
+ else
+ sgl.CurFont = (GuiLib_FontRecPtr)ReadWord(GuiFont_FontList[FontIndex]);
+}
+
+#ifdef GuiConst_BITMAP_SUPPORT_ON
+//------------------------------------------------------------------------------
+static void UpdateBackgroundBitmap(void)
+{
+ GuiConst_INT8U BackgroundOn;
+ GuiConst_INT16U BackgroundX1, BackgroundY1, BackgroundX2, BackgroundY2;
+ GuiConst_INT16S N;
+
+ for (N = 0; N < GuiConst_MAX_BACKGROUND_BITMAPS; N++)
+ if (sgl.BackgrBitmapAry[N].InUse)
+ {
+ BackgroundOn = 0;
+ switch (sgl.CurItem.ItemType)
+ {
+ case GuiLib_ITEM_TEXT:
+ case GuiLib_ITEM_VAR:
+ BackgroundOn = 1;
+ if (sgl.CurItem.TextPar[0].BackBoxSizeX == 0)
+ {
+ BackgroundX1 = sgl.CurItem.DrawnX1;
+ BackgroundY1 = sgl.CurItem.DrawnY1;
+ BackgroundX2 = sgl.CurItem.DrawnX2;
+ BackgroundY2 = sgl.CurItem.DrawnY2;
+ }
+ else
+ {
+ SetCurFont(sgl.CurItem.TextPar[0].FontIndex);
+ SetBackBox(0);
+ BackgroundX1 = sgl.BbX1;
+ BackgroundY1 = sgl.BbY1;
+ BackgroundX2 = sgl.BbX2;
+ BackgroundY2 = sgl.BbY2;
+ }
+ break;
+
+ case GuiLib_ITEM_STRUCTURE:
+ case GuiLib_ITEM_STRUCTARRAY:
+ case GuiLib_ITEM_STRUCTCOND:
+ if (sgl.CurItem.Drawn)
+ {
+ BackgroundOn = 1;
+ BackgroundX1 = sgl.CurItem.DrawnX1;
+ BackgroundY1 = sgl.CurItem.DrawnY1;
+ BackgroundX2 = sgl.CurItem.DrawnX2;
+ BackgroundY2 = sgl.CurItem.DrawnY2;
+ }
+ break;
+
+ case GuiLib_ITEM_TEXTBLOCK:
+ case GuiLib_ITEM_VARBLOCK:
+ case GuiLib_ITEM_CHECKBOX:
+ case GuiLib_ITEM_BUTTON:
+ case GuiLib_ITEM_EDITBOX:
+ case GuiLib_ITEM_PANEL:
+ case GuiLib_ITEM_MEMO:
+ case GuiLib_ITEM_LISTBOX:
+ case GuiLib_ITEM_COMBOBOX:
+ case GuiLib_ITEM_SCROLLBOX:
+ case GuiLib_ITEM_SCROLLAREA:
+ case GuiLib_ITEM_PROGRESSBAR:
+ if (sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_TRANSPARENT)
+ {
+ BackgroundOn = 1;
+ SetBackColorBox(sgl.CurItem.X1, sgl.CurItem.Y1,
+ sgl.CurItem.X2, sgl.CurItem.Y2,
+ 0);
+ BackgroundX1 = sgl.BbX1;
+ BackgroundY1 = sgl.BbY1;
+ BackgroundX2 = sgl.BbX2;
+ BackgroundY2 = sgl.BbY2;
+ }
+ break;
+#ifdef GuiConst_ITEM_RADIOBUTTON_INUSE
+ case GuiLib_ITEM_RADIOBUTTON:
+ if (sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_TRANSPARENT)
+ {
+ BackgroundOn = 1;
+ SetBackColorBox(sgl.CurItem.X1,
+ sgl.CurItem.Y1,
+ sgl.CurItem.X2,
+ sgl.CurItem.Y2 +
+ (sgl.CurItem.CompPars.CompRadioButton.Count - 1) *
+ sgl.CurItem.CompPars.CompRadioButton.InterDistance,
+ 0);
+ BackgroundX1 = sgl.BbX1;
+ BackgroundY1 = sgl.BbY1;
+ BackgroundX2 = sgl.BbX2;
+ BackgroundY2 = sgl.BbY2;
+ }
+ break;
+#endif
+ }
+ if (BackgroundOn)
+ GuiLib_ShowBitmapArea(sgl.BackgrBitmapAry[N].Index,
+ sgl.BackgrBitmapAry[N].X, sgl.BackgrBitmapAry[N].Y,
+ BackgroundX1, BackgroundY1, BackgroundX2, BackgroundY2, -1);
+ }
+}
+#endif
+
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+//------------------------------------------------------------------------------
+static void StartClipping(
+ GuiConst_INT8U Clipping)
+{
+#ifdef GuiConst_REL_COORD_ORIGO_INUSE
+ sgl.CurItem.ClipRectX1 += sgl.CoordOrigoX;
+ sgl.CurItem.ClipRectY1 += sgl.CoordOrigoY;
+ sgl.CurItem.ClipRectX2 += sgl.CoordOrigoX;
+ sgl.CurItem.ClipRectY2 += sgl.CoordOrigoY;
+#endif
+ if (Clipping)
+ {
+ OrderCoord(&sgl.CurItem.ClipRectX1, &sgl.CurItem.ClipRectX2);
+ OrderCoord(&sgl.CurItem.ClipRectY1, &sgl.CurItem.ClipRectY2);
+ if (sgl.CurItem.ClipRectX1 < sgl.ActiveAreaX1)
+ sgl.CurItem.ClipRectX1 = sgl.ActiveAreaX1;
+ if (sgl.CurItem.ClipRectY1 < sgl.ActiveAreaY1)
+ sgl.CurItem.ClipRectY1 = sgl.ActiveAreaY1;
+ if (sgl.CurItem.ClipRectX2 > sgl.ActiveAreaX2)
+ sgl.CurItem.ClipRectX2 = sgl.ActiveAreaX2;
+ if (sgl.CurItem.ClipRectY2 > sgl.ActiveAreaY2)
+ sgl.CurItem.ClipRectY2 = sgl.ActiveAreaY2;
+ }
+ else
+ {
+ sgl.CurItem.ClipRectX1 = sgl.ActiveAreaX1;
+ sgl.CurItem.ClipRectY1 = sgl.ActiveAreaY1;
+ sgl.CurItem.ClipRectX2 = sgl.ActiveAreaX2;
+ sgl.CurItem.ClipRectY2 = sgl.ActiveAreaY2;
+ }
+#ifdef GuiConst_REL_COORD_ORIGO_INUSE
+ sgl.CurItem.ClipRectX1 -= sgl.CoordOrigoX;
+ sgl.CurItem.ClipRectY1 -= sgl.CoordOrigoY;
+ sgl.CurItem.ClipRectX2 -= sgl.CoordOrigoX;
+ sgl.CurItem.ClipRectY2 -= sgl.CoordOrigoY;
+#endif
+ GuiLib_SetClipping(sgl.CurItem.ClipRectX1, sgl.CurItem.ClipRectY1,
+ sgl.CurItem.ClipRectX2, sgl.CurItem.ClipRectY2);
+}
+#endif
+
+//------------------------------------------------------------------------------
+static void PrepareInternalStruct(void)
+{
+ sgl.Memory.X[GuiLib_MEMORY_CNT] = sgl.CurItem.X1;
+ sgl.Memory.Y[GuiLib_MEMORY_CNT] = sgl.CurItem.Y1;
+}
+
+//------------------------------------------------------------------------------
+static void DrawSubStruct(
+ GuiConst_INT16U SubStructIndex,
+ GuiConst_INT8U ColorInvert,
+ GuiConst_INT8U SubInt)
+{
+ GuiLib_ItemRec RemCurItem;
+ GuiLib_StructPtr StructToCall;
+ GuiConst_INT8U RemBackBox;
+ GuiConst_INT16S RemBbX1, RemBbX2;
+ GuiConst_INT16S RemBbY1, RemBbY2;
+ GuiConst_INT8U RemDrawn;
+ GuiConst_INT16S RemDrawnX1, RemDrawnY1, RemDrawnX2, RemDrawnY2;
+ GuiConst_INT16S RemAutoRedrawSaveIndex;
+ GuiConst_INT16S RemAutoRedrawParent;
+ GuiConst_INT16S RemAutoRedrawLatest;
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ GuiConst_INT32U RemRemoteStructOffset;
+#endif
+
+ if (SubStructIndex != 0xFFFF)
+ {
+ RemAutoRedrawParent = sgl.AutoRedrawParent;
+ RemAutoRedrawLatest = sgl.AutoRedrawLatest;
+
+ sgl.AutoRedrawParent = sgl.AutoRedrawLatest;
+
+ if (SubInt)
+ memcpy(&RemCurItem, &sgl.CurItem, sizeof(GuiLib_ItemRec));
+
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ RemRemoteStructOffset = sgl.RemoteStructOffset;
+#endif
+ RemBackBox = (sgl.CurItem.TextPar[0].BackBoxSizeX);
+ RemBbX1 = sgl.BbX1;
+ RemBbX2 = sgl.BbX2;
+ RemBbY1 = sgl.BbY1;
+ RemBbY2 = sgl.BbY2;
+ RemDrawn = gl.Drawn;
+ RemDrawnX1 = gl.DrawnX1;
+ RemDrawnY1 = gl.DrawnY1;
+ RemDrawnX2 = gl.DrawnX2;
+ RemDrawnY2 = gl.DrawnY2;
+ ResetDrawLimits();
+ RemAutoRedrawSaveIndex = sgl.AutoRedrawSaveIndex;
+
+ sgl.DisplayLevel++;
+ StructToCall =
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ GetRemoteStructData(SubStructIndex);
+#else
+ (GuiLib_StructPtr)ReadWord(GuiStruct_StructPtrList[SubStructIndex]);
+#endif
+ DrawStructure(StructToCall, ColorInvert);
+ sgl.DisplayLevel--;
+
+ if (RemBackBox)
+ {
+ sgl.CurItem.Drawn = 1;
+ sgl.CurItem.DrawnX1 = RemBbX1;
+ sgl.CurItem.DrawnY1 = RemBbY1;
+ sgl.CurItem.DrawnX2 = RemBbX2;
+ sgl.CurItem.DrawnY2 = RemBbY2;
+
+ gl.DrawnX1 = GuiLib_GET_MIN(sgl.BbX1, RemDrawnX1);
+ gl.DrawnY1 = GuiLib_GET_MIN(sgl.BbY1, RemDrawnY1);
+ gl.DrawnX2 = GuiLib_GET_MAX(sgl.BbX2, RemDrawnX2);
+ gl.DrawnY2 = GuiLib_GET_MAX(sgl.BbY2, RemDrawnY2);
+ }
+ else if (gl.Drawn)
+ {
+ sgl.CurItem.Drawn = 1;
+ sgl.CurItem.DrawnX1 = gl.DrawnX1;
+ sgl.CurItem.DrawnY1 = gl.DrawnY1;
+ sgl.CurItem.DrawnX2 = gl.DrawnX2;
+ sgl.CurItem.DrawnY2 = gl.DrawnY2;
+
+ gl.DrawnX1 = GuiLib_GET_MIN(gl.DrawnX1, RemDrawnX1);
+ gl.DrawnY1 = GuiLib_GET_MIN(gl.DrawnY1, RemDrawnY1);
+ gl.DrawnX2 = GuiLib_GET_MAX(gl.DrawnX2, RemDrawnX2);
+ gl.DrawnY2 = GuiLib_GET_MAX(gl.DrawnY2, RemDrawnY2);
+ }
+ else
+ {
+ gl.Drawn = RemDrawn;
+ gl.DrawnX1 = RemDrawnX1;
+ gl.DrawnY1 = RemDrawnY1;
+ gl.DrawnX2 = RemDrawnX2;
+ gl.DrawnY2 = RemDrawnY2;
+ }
+ sgl.AutoRedrawSaveIndex = RemAutoRedrawSaveIndex;
+
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ sgl.RemoteStructOffset = RemRemoteStructOffset;
+#endif
+
+ if (SubInt)
+ memcpy(&sgl.CurItem, &RemCurItem, sizeof(GuiLib_ItemRec));
+
+ sgl.AutoRedrawLatest = RemAutoRedrawLatest;
+ sgl.AutoRedrawParent = RemAutoRedrawParent;
+ }
+}
+
+#include "GuiItems.h"
+
+//------------------------------------------------------------------------------
+static void DrawStructure(
+ GuiLib_StructPtr Structure,
+ GuiConst_INT8U ColorInvert) PrefixReentrant
+{
+ GuiConst_INT16S ItemNdx;
+ GuiConst_INT16S X, RemAutoRedrawLatest;
+ void PrefixLocate *XVarPtr;
+ void PrefixLocate *YVarPtr;
+ GuiConst_INT8U ItemCnt;
+ GuiConst_INT8U PrefixLocate *LocalItemDataPtr;
+#ifdef GuiConst_ITEM_GRAPHICS_LAYER_FILTER_INUSE
+ GuiConst_INT16S I;
+#endif
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ GuiConst_INT8U ItemSizeBuf[2];
+ GuiConst_INT16U ItemSize;
+#endif
+
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ LocalItemDataPtr = sgl.GuiLib_RemoteStructBuffer;
+#else
+ LocalItemDataPtr = (GuiConst_INT8U PrefixLocate *)Structure;
+#endif
+ ItemCnt = GetItemByte(&LocalItemDataPtr);
+
+ for (ItemNdx = 0; ItemNdx < ItemCnt; ItemNdx++)
+ {
+ RemAutoRedrawLatest = sgl.AutoRedrawLatest;
+
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ GuiLib_RemoteDataReadBlock(
+ sgl.RemoteStructOffset,
+ 2,
+ (GuiConst_INT8U*)&ItemSizeBuf);
+ ItemSize = (256 * (GuiConst_INT16U)ItemSizeBuf[1]) + ItemSizeBuf[0];
+ sgl.RemoteStructOffset += 2;
+ GuiLib_RemoteDataReadBlock(
+ sgl.RemoteStructOffset,
+ ItemSize,
+ sgl.GuiLib_RemoteItemBuffer);
+ sgl.RemoteStructOffset += ItemSize;
+ LocalItemDataPtr = &sgl.GuiLib_RemoteItemBuffer[0];
+#endif
+
+ sgl.ItemDataPtr = LocalItemDataPtr;
+ ReadItem(GuiLib_LanguageIndex);
+ LocalItemDataPtr = sgl.ItemDataPtr;
+
+ if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_CLEARAREA +
+ GuiLib_ITEMBIT_TEXT +
+ GuiLib_ITEMBIT_TEXTBLOCK +
+ GuiLib_ITEMBIT_DOT +
+ GuiLib_ITEMBIT_LINE +
+ GuiLib_ITEMBIT_FRAME +
+ GuiLib_ITEMBIT_BLOCK +
+ GuiLib_ITEMBIT_CIRCLE +
+ GuiLib_ITEMBIT_ELLIPSE +
+ GuiLib_ITEMBIT_BITMAP +
+ GuiLib_ITEMBIT_BACKGROUND +
+ GuiLib_ITEMBIT_STRUCTURE +
+ GuiLib_ITEMBIT_STRUCTARRAY +
+ GuiLib_ITEMBIT_ACTIVEAREA +
+ GuiLib_ITEMBIT_CLIPRECT +
+ GuiLib_ITEMBIT_VAR +
+ GuiLib_ITEMBIT_VARBLOCK +
+ GuiLib_ITEMBIT_TOUCHAREA +
+ GuiLib_ITEMBIT_SCROLLBOX +
+ GuiLib_ITEMBIT_GRAPH +
+ GuiLib_ITEMBIT_GRAPHICSLAYER)) ||
+ (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_ROUNDEDFRAME +
+ GuiLib_ITEMBIT_ROUNDEDBLOCK +
+ GuiLib_ITEMBIT_QUARTERCIRCLE +
+ GuiLib_ITEMBIT_QUARTERELLIPSE +
+ GuiLib_ITEMBIT_CHECKBOX +
+ GuiLib_ITEMBIT_RADIOBUTTON +
+ GuiLib_ITEMBIT_BUTTON +
+ GuiLib_ITEMBIT_EDITBOX +
+ GuiLib_ITEMBIT_PANEL +
+ GuiLib_ITEMBIT_MEMO +
+ GuiLib_ITEMBIT_LISTBOX +
+ GuiLib_ITEMBIT_COMBOBOX +
+ GuiLib_ITEMBIT_SCROLLAREA +
+ GuiLib_ITEMBIT_PROGRESSBAR +
+ GuiLib_ITEMBIT_STRUCTCOND +
+ GuiLib_ITEMBIT_POSCALLBACK)))
+ {
+ if (sgl.CommonByte2 & 0x10)
+ {
+ XVarPtr = (void PrefixLocate *)ReadWord(GuiStruct_VarPtrList[sgl.X1VarIdx]);
+ sgl.X1VarType = ReadByte(GuiStruct_VarTypeList[sgl.X1VarIdx]);
+ }
+ else
+ XVarPtr = 0;
+ if (XVarPtr != 0)
+ sgl.ItemX1 += ReadVar(XVarPtr, sgl.X1VarType);
+ if (sgl.X1MemoryRead > 0)
+ sgl.ItemX1 += sgl.Memory.X[sgl.X1MemoryRead - 1];
+ if (sgl.X1Mode == GuiLib_COOR_REL)
+ sgl.ItemX1 += sgl.CurItem.RX;
+ else if (sgl.X1Mode == GuiLib_COOR_REL_1)
+ sgl.ItemX1 += sgl.CurItem.RX1;
+ else if (sgl.X1Mode == GuiLib_COOR_REL_2)
+ sgl.ItemX1 += sgl.CurItem.RX2;
+ if (sgl.X1MemoryWrite > 0)
+ sgl.Memory.X[sgl.X1MemoryWrite - 1] = sgl.ItemX1;
+ sgl.CurItem.X1 = sgl.ItemX1;
+
+ if (sgl.CommonByte2 & 0x20)
+ {
+ YVarPtr = (void PrefixLocate *)ReadWord(GuiStruct_VarPtrList[sgl.Y1VarIdx]);
+ sgl.Y1VarType = ReadByte(GuiStruct_VarTypeList[sgl.Y1VarIdx]);
+ }
+ else
+ YVarPtr = 0;
+ if (YVarPtr != 0)
+ sgl.ItemY1 += ReadVar(YVarPtr, sgl.Y1VarType);
+ if (sgl.Y1MemoryRead > 0)
+ sgl.ItemY1 += sgl.Memory.Y[sgl.Y1MemoryRead - 1];
+ if (sgl.Y1Mode == GuiLib_COOR_REL)
+ sgl.ItemY1 += sgl.CurItem.RY;
+ else if (sgl.Y1Mode == GuiLib_COOR_REL_1)
+ sgl.ItemY1 += sgl.CurItem.RY1;
+ else if (sgl.Y1Mode == GuiLib_COOR_REL_2)
+ sgl.ItemY1 += sgl.CurItem.RY2;
+ if (sgl.Y1MemoryWrite > 0)
+ sgl.Memory.Y[sgl.Y1MemoryWrite - 1] = sgl.ItemY1;
+ sgl.CurItem.Y1 = sgl.ItemY1;
+
+ sgl.CurItem.RX = sgl.CurItem.X1;
+ sgl.CurItem.RY = sgl.CurItem.Y1;
+ }
+
+#ifdef GuiConst_ITEM_SCROLLBOX_INUSE
+ if (sgl.ItemTypeBit1 & GuiLib_ITEMBIT_SCROLLBOX)
+ {
+ sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].X1 = sgl.CurItem.X1;
+ sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].Y1 = sgl.CurItem.Y1;
+ sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].BackColor = sgl.CurItem.BackColor;
+
+#ifndef GuiConst_SCROLLITEM_BAR_NONE
+ if ((sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].BarMode & 0x03) ==
+ GuiLib_COOR_REL)
+ sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].BarPositionX += sgl.CurItem.X1;
+ if (((sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].BarMode >> 2) & 0x03) ==
+ GuiLib_COOR_REL)
+ sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].BarPositionY += sgl.CurItem.Y1;
+#endif
+#ifndef GuiConst_SCROLLITEM_INDICATOR_NONE
+ if ((sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].IndicatorMode & 0x03) ==
+ GuiLib_COOR_REL)
+ sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].IndicatorPositionX += sgl.CurItem.X1;
+ if (((sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].IndicatorMode >> 2) & 0x03) ==
+ GuiLib_COOR_REL)
+ sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].IndicatorPositionY += sgl.CurItem.Y1;
+#endif
+ }
+#endif
+
+ if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_CLEARAREA +
+ GuiLib_ITEMBIT_TEXTBLOCK +
+ GuiLib_ITEMBIT_VARBLOCK +
+ GuiLib_ITEMBIT_LINE +
+ GuiLib_ITEMBIT_FRAME +
+ GuiLib_ITEMBIT_BLOCK +
+ GuiLib_ITEMBIT_BITMAP +
+ GuiLib_ITEMBIT_BACKGROUND +
+ GuiLib_ITEMBIT_ACTIVEAREA +
+ GuiLib_ITEMBIT_CLIPRECT +
+ GuiLib_ITEMBIT_TOUCHAREA +
+ GuiLib_ITEMBIT_GRAPH +
+ GuiLib_ITEMBIT_GRAPHICSLAYER)) ||
+ (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_ROUNDEDFRAME +
+ GuiLib_ITEMBIT_ROUNDEDBLOCK +
+ GuiLib_ITEMBIT_BUTTON +
+ GuiLib_ITEMBIT_EDITBOX +
+ GuiLib_ITEMBIT_PANEL +
+ GuiLib_ITEMBIT_MEMO +
+ GuiLib_ITEMBIT_LISTBOX +
+ GuiLib_ITEMBIT_COMBOBOX +
+ GuiLib_ITEMBIT_SCROLLAREA +
+ GuiLib_ITEMBIT_PROGRESSBAR)))
+ {
+ if (sgl.CommonByte2 & 0x40)
+ {
+ XVarPtr = (void PrefixLocate *)ReadWord(GuiStruct_VarPtrList[sgl.X2VarIdx]);
+ sgl.X2VarType = ReadByte(GuiStruct_VarTypeList[sgl.X2VarIdx]);
+ }
+ else
+ XVarPtr = 0;
+ if (XVarPtr != 0)
+ sgl.ItemX2 += ReadVar(XVarPtr, sgl.X2VarType);
+ if (sgl.X2MemoryRead > 0)
+ sgl.ItemX2 += sgl.Memory.X[sgl.X2MemoryRead - 1];
+ if (sgl.X2Mode == GuiLib_COOR_REL)
+ sgl.ItemX2 += sgl.CurItem.X1;
+ else if (sgl.X2Mode == GuiLib_COOR_REL_1)
+ sgl.ItemX2 += sgl.CurItem.RX1;
+ else if (sgl.X2Mode == GuiLib_COOR_REL_2)
+ sgl.ItemX2 += sgl.CurItem.RX2;
+ if (sgl.X2MemoryWrite > 0)
+ sgl.Memory.X[sgl.X2MemoryWrite - 1] = sgl.ItemX2;
+ sgl.CurItem.X2 = sgl.ItemX2;
+
+ if (sgl.CommonByte2 & 0x80)
+ {
+ YVarPtr = (void PrefixLocate *)ReadWord(GuiStruct_VarPtrList[sgl.Y2VarIdx]);
+ sgl.Y2VarType = ReadByte(GuiStruct_VarTypeList[sgl.Y2VarIdx]);
+ }
+ else
+ YVarPtr = 0;
+ if (YVarPtr != 0)
+ sgl.ItemY2 += ReadVar(YVarPtr, sgl.Y2VarType);
+ if (sgl.Y2MemoryRead > 0)
+ sgl.ItemY2 += sgl.Memory.Y[sgl.Y2MemoryRead - 1];
+ if (sgl.Y2Mode == GuiLib_COOR_REL)
+ sgl.ItemY2 += sgl.CurItem.Y1;
+ else if (sgl.Y2Mode == GuiLib_COOR_REL_1)
+ sgl.ItemY2 += sgl.CurItem.RY1;
+ else if (sgl.Y2Mode == GuiLib_COOR_REL_2)
+ sgl.ItemY2 += sgl.CurItem.RY2;
+ if (sgl.Y2MemoryWrite > 0)
+ sgl.Memory.Y[sgl.Y2MemoryWrite - 1] = sgl.ItemY2;
+ sgl.CurItem.Y2 = sgl.ItemY2;
+ }
+#ifdef GuiConst_ITEM_CHECKBOX_INUSE
+ else if (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_CHECKBOX)
+ {
+ switch (sgl.CurItem.CompPars.CompCheckBox.Style)
+ {
+ case GuiLib_CHECKBOX_FLAT:
+ case GuiLib_CHECKBOX_3D:
+ case GuiLib_CHECKBOX_NONE:
+ sgl.CurItem.X2 = sgl.CurItem.X1 +
+ sgl.CurItem.CompPars.CompCheckBox.Size - 1;
+ sgl.CurItem.Y2 = sgl.CurItem.Y1 +
+ sgl.CurItem.CompPars.CompCheckBox.Size - 1;
+ break;
+ case GuiLib_CHECKBOX_ICON:
+ sgl.CurItem.X2 = sgl.CurItem.X1;
+ sgl.CurItem.Y2 = sgl.CurItem.Y1;
+ break;
+ case GuiLib_CHECKBOX_BITMAP:
+ sgl.CurItem.X2 = sgl.CurItem.X1;
+ sgl.CurItem.Y2 = sgl.CurItem.Y1;
+ break;
+ }
+ }
+#endif
+#ifdef GuiConst_ITEM_RADIOBUTTON_INUSE
+ else if (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_RADIOBUTTON)
+ {
+ switch (sgl.CurItem.CompPars.CompRadioButton.Style)
+ {
+ case GuiLib_RADIOBUTTON_FLAT:
+ case GuiLib_RADIOBUTTON_3D:
+ sgl.CurItem.X2 = sgl.CurItem.X1 +
+ 2 * sgl.CurItem.CompPars.CompRadioButton.Size;
+ sgl.CurItem.Y2 = sgl.CurItem.Y1 +
+ 2 * sgl.CurItem.CompPars.CompRadioButton.Size;
+ break;
+ case GuiLib_RADIOBUTTON_ICON:
+ sgl.CurItem.X2 = sgl.CurItem.X1;
+ sgl.CurItem.Y2 = sgl.CurItem.Y1;
+ break;
+ case GuiLib_RADIOBUTTON_BITMAP:
+ sgl.CurItem.X2 = sgl.CurItem.X1;
+ sgl.CurItem.Y2 = sgl.CurItem.Y1;
+ break;
+ }
+ }
+#endif
+#ifdef GuiConst_ITEM_BUTTON_INUSE
+ else if (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_BUTTON)
+ {
+ sgl.CurItem.X2 = sgl.CurItem.X1;
+ sgl.CurItem.Y2 = sgl.CurItem.Y1;
+ }
+#endif
+
+ if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_CIRCLE +
+ GuiLib_ITEMBIT_ELLIPSE)) ||
+ (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_ROUNDEDFRAME +
+ GuiLib_ITEMBIT_ROUNDEDBLOCK +
+ GuiLib_ITEMBIT_QUARTERCIRCLE +
+ GuiLib_ITEMBIT_QUARTERELLIPSE +
+ GuiLib_ITEMBIT_BUTTON +
+ GuiLib_ITEMBIT_PANEL)))
+ {
+ if (sgl.CommonByte6 & 0x40)
+ {
+ XVarPtr = (void PrefixLocate *)ReadWord(GuiStruct_VarPtrList[sgl.R1VarIdx]);
+ sgl.R1VarType = ReadByte(GuiStruct_VarTypeList[sgl.R1VarIdx]);
+ }
+ else
+ XVarPtr = 0;
+ if (XVarPtr != 0)
+ sgl.ItemR1 += ReadVar(XVarPtr, sgl.R1VarType);
+ if (sgl.R1MemoryRead > 0)
+ sgl.ItemR1 += sgl.Memory.X[sgl.R1MemoryRead - 1];
+ if (sgl.R1Mode == GuiLib_COOR_REL)
+ sgl.ItemR1 += sgl.CurItem.X1;
+ else if (sgl.R1Mode == GuiLib_COOR_REL_1)
+ sgl.ItemR1 += sgl.CurItem.RX1;
+ else if (sgl.R1Mode == GuiLib_COOR_REL_2)
+ sgl.ItemR1 += sgl.CurItem.RX2;
+ if (sgl.R1MemoryWrite > 0)
+ sgl.Memory.X[sgl.R1MemoryWrite - 1] = sgl.ItemR1;
+ sgl.CurItem.R1 = sgl.ItemR1;
+ }
+
+ if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_ELLIPSE)) ||
+ (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_QUARTERELLIPSE)))
+ {
+ if (sgl.CommonByte6 & 0x80)
+ {
+ YVarPtr = (void PrefixLocate *)ReadWord(GuiStruct_VarPtrList[sgl.R2VarIdx]);
+ sgl.R2VarType = ReadByte(GuiStruct_VarTypeList[sgl.R2VarIdx]);
+ }
+ else
+ YVarPtr = 0;
+ if (YVarPtr != 0)
+ sgl.ItemR2 += ReadVar(YVarPtr, sgl.R2VarType);
+ if (sgl.R2MemoryRead > 0)
+ sgl.ItemR2 += sgl.Memory.Y[sgl.R2MemoryRead - 1];
+ if (sgl.R2Mode == GuiLib_COOR_REL)
+ sgl.ItemR2 += sgl.CurItem.Y1;
+ else if (sgl.R2Mode == GuiLib_COOR_REL_1)
+ sgl.ItemR2 += sgl.CurItem.RY1;
+ else if (sgl.R2Mode == GuiLib_COOR_REL_2)
+ sgl.ItemR2 += sgl.CurItem.RY2;
+ if (sgl.R2MemoryWrite > 0)
+ sgl.Memory.Y[sgl.R2MemoryWrite - 1] = sgl.ItemR2;
+ sgl.CurItem.R2 = sgl.ItemR2;
+ }
+
+ if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_CLEARAREA +
+ GuiLib_ITEMBIT_TEXTBLOCK +
+ GuiLib_ITEMBIT_VARBLOCK +
+ GuiLib_ITEMBIT_LINE +
+ GuiLib_ITEMBIT_FRAME +
+ GuiLib_ITEMBIT_BLOCK +
+ GuiLib_ITEMBIT_BITMAP +
+ GuiLib_ITEMBIT_BACKGROUND +
+ GuiLib_ITEMBIT_ACTIVEAREA +
+ GuiLib_ITEMBIT_CLIPRECT +
+ GuiLib_ITEMBIT_TOUCHAREA +
+ GuiLib_ITEMBIT_GRAPH +
+ GuiLib_ITEMBIT_GRAPHICSLAYER)) ||
+ (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_ROUNDEDFRAME +
+ GuiLib_ITEMBIT_ROUNDEDBLOCK +
+ GuiLib_ITEMBIT_CHECKBOX +
+ GuiLib_ITEMBIT_RADIOBUTTON +
+ GuiLib_ITEMBIT_BUTTON +
+ GuiLib_ITEMBIT_EDITBOX +
+ GuiLib_ITEMBIT_PANEL +
+ GuiLib_ITEMBIT_MEMO +
+ GuiLib_ITEMBIT_LISTBOX +
+ GuiLib_ITEMBIT_COMBOBOX +
+ GuiLib_ITEMBIT_SCROLLAREA +
+ GuiLib_ITEMBIT_PROGRESSBAR)))
+ {
+ X = sgl.CurItem.X2 - sgl.CurItem.X1;
+ if (sgl.CurItem.TextPar[0].Alignment == GuiLib_ALIGN_CENTER)
+ {
+ sgl.CurItem.X1 -= X / 2;
+ sgl.CurItem.X2 -= X / 2;
+ }
+ else if (sgl.CurItem.TextPar[0].Alignment == GuiLib_ALIGN_RIGHT)
+ {
+ sgl.CurItem.X1 -= X;
+ sgl.CurItem.X2 -= X;
+ }
+ }
+ else if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_CIRCLE +
+ GuiLib_ITEMBIT_ELLIPSE)) ||
+ (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_QUARTERCIRCLE +
+ GuiLib_ITEMBIT_QUARTERELLIPSE)))
+ {
+ if (sgl.CurItem.TextPar[0].Alignment == GuiLib_ALIGN_CENTER)
+ sgl.CurItem.X1 -= sgl.CurItem.R1;
+ else if (sgl.CurItem.TextPar[0].Alignment == GuiLib_ALIGN_RIGHT)
+ sgl.CurItem.X1 -= 2 * sgl.CurItem.R1;
+ }
+
+#ifdef GuiConst_ITEM_SCROLLBOX_INUSE
+ if (sgl.ItemTypeBit1 & GuiLib_ITEMBIT_SCROLLBOX)
+ memcpy(&sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].ScrollBoxItem, &sgl.CurItem,
+ sizeof(GuiLib_ItemRec));
+#endif
+
+#ifdef GuiConst_ITEM_GRAPH_INUSE
+ if (sgl.ItemTypeBit1 & GuiLib_ITEMBIT_GRAPH)
+ {
+ memcpy(&sgl.GraphAry[sgl.GlobalGraphIndex].GraphItem, &sgl.CurItem,
+ sizeof(GuiLib_ItemRec));
+ OrderCoord(&sgl.GraphAry[sgl.GlobalGraphIndex].GraphItem.X1,
+ &sgl.GraphAry[sgl.GlobalGraphIndex].GraphItem.X2);
+ OrderCoord(&sgl.GraphAry[sgl.GlobalGraphIndex].GraphItem.Y1,
+ &sgl.GraphAry[sgl.GlobalGraphIndex].GraphItem.Y2);
+ sgl.GraphAry[sgl.GlobalGraphIndex].OrigoX =
+ sgl.GraphAry[sgl.GlobalGraphIndex].GraphItem.X1 +
+ sgl.GraphAry[sgl.GlobalGraphIndex].OriginOffsetX;
+ sgl.GraphAry[sgl.GlobalGraphIndex].OrigoY =
+ sgl.GraphAry[sgl.GlobalGraphIndex].GraphItem.Y2 -
+ sgl.GraphAry[sgl.GlobalGraphIndex].OriginOffsetY;
+ }
+#endif
+
+#ifdef GuiConst_ITEM_SCROLLBOX_INUSE
+ if (sgl.NextScrollLineReading)
+ sgl.DisplayWriting = 0;
+ else
+#endif
+ sgl.DisplayWriting = 1;
+ DrawItem(ColorInvert);
+
+ sgl.DisplayWriting = 1;
+
+ switch (sgl.CurItem.ItemType)
+ {
+ case GuiLib_ITEM_TEXT:
+ case GuiLib_ITEM_VAR:
+ sgl.CurItem.RX1 = sgl.FontWriteX1;
+ sgl.CurItem.RY1 = sgl.FontWriteY1;
+ sgl.CurItem.RX2 = sgl.FontWriteX2 + 1;
+ sgl.CurItem.RY2 = sgl.FontWriteY2;
+ break;
+ case GuiLib_ITEM_DOT:
+ sgl.CurItem.RX1 = sgl.CurItem.X1;
+ sgl.CurItem.RY1 = sgl.CurItem.Y1;
+ sgl.CurItem.RX2 = sgl.CurItem.X1 + 1;
+ sgl.CurItem.RY2 = sgl.CurItem.Y1;
+ break;
+ case GuiLib_ITEM_CIRCLE:
+ case GuiLib_ITEM_QUARTERCIRCLE:
+ sgl.CurItem.RX1 = sgl.CurItem.X1;
+ sgl.CurItem.RY1 = sgl.CurItem.Y1 - sgl.CurItem.R1;
+ sgl.CurItem.RX2 = sgl.CurItem.X1 + (2 * sgl.CurItem.R1) + 1;
+ sgl.CurItem.RY2 = sgl.CurItem.Y1 + sgl.CurItem.R1;
+ break;
+ case GuiLib_ITEM_ELLIPSE:
+ case GuiLib_ITEM_QUARTERELLIPSE:
+ sgl.CurItem.RX1 = sgl.CurItem.X1;
+ sgl.CurItem.RY1 = sgl.CurItem.Y1 - sgl.CurItem.R2;
+ sgl.CurItem.RX2 = sgl.CurItem.X1 + (2 * sgl.CurItem.R1) + 1;
+ sgl.CurItem.RY2 = sgl.CurItem.Y1 + sgl.CurItem.R2;
+ break;
+ case GuiLib_ITEM_CLEARAREA:
+ case GuiLib_ITEM_LINE:
+ case GuiLib_ITEM_FRAME:
+ case GuiLib_ITEM_ROUNDEDFRAME:
+ case GuiLib_ITEM_BLOCK:
+ case GuiLib_ITEM_ROUNDEDBLOCK:
+ case GuiLib_ITEM_BITMAP:
+ case GuiLib_ITEM_BACKGROUND:
+ case GuiLib_ITEM_ACTIVEAREA:
+ case GuiLib_ITEM_CLIPRECT:
+ case GuiLib_ITEM_TEXTBLOCK:
+ case GuiLib_ITEM_VARBLOCK:
+ case GuiLib_ITEM_CHECKBOX:
+ case GuiLib_ITEM_BUTTON:
+ case GuiLib_ITEM_EDITBOX:
+ case GuiLib_ITEM_PANEL:
+ case GuiLib_ITEM_MEMO:
+ case GuiLib_ITEM_LISTBOX:
+ case GuiLib_ITEM_COMBOBOX:
+ case GuiLib_ITEM_SCROLLAREA:
+ case GuiLib_ITEM_PROGRESSBAR:
+ case GuiLib_ITEM_TOUCHAREA:
+ case GuiLib_ITEM_SCROLLBOX:
+ case GuiLib_ITEM_GRAPH:
+ case GuiLib_ITEM_GRAPHICSLAYER:
+ sgl.CurItem.RX1 = sgl.CurItem.X1;
+ sgl.CurItem.RY1 = sgl.CurItem.Y1;
+ sgl.CurItem.RX2 = sgl.CurItem.X2 + 1;
+ sgl.CurItem.RY2 = sgl.CurItem.Y2;
+ break;
+ case GuiLib_ITEM_POSCALLBACK:
+ sgl.CurItem.RX1 = sgl.CurItem.X1;
+ sgl.CurItem.RY1 = sgl.CurItem.Y1;
+ sgl.CurItem.RX2 = sgl.CurItem.X1;
+ sgl.CurItem.RY2 = sgl.CurItem.Y1;
+ break;
+#ifdef GuiConst_ITEM_RADIOBUTTON_INUSE
+ case GuiLib_ITEM_RADIOBUTTON:
+ sgl.CurItem.RX1 = sgl.CurItem.X1;
+ sgl.CurItem.RY1 = sgl.CurItem.Y1;
+ sgl.CurItem.RX2 = sgl.CurItem.X2 + 1;
+ sgl.CurItem.RY2 = sgl.CurItem.Y2 +
+ (sgl.CurItem.CompPars.CompRadioButton.Count - 1) *
+ sgl.CurItem.CompPars.CompRadioButton.InterDistance;
+ break;
+#endif
+ }
+
+ sgl.AutoRedrawLatest = RemAutoRedrawLatest;
+ }
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_ShowScreen(
+ const GuiConst_INT16U StructureNdx,
+ GuiConst_INT16S CursorFieldToShow,
+ GuiConst_INT8U ResetAutoRedraw)
+{
+#ifdef GuiConst_ITEM_SCROLLBOX_INUSE
+ GuiConst_INT16S M;
+#endif
+ GuiConst_INT16S N;
+ GuiLib_StructPtr StructureToCall;
+
+ GuiDisplay_Lock();
+
+ GuiLib_CurStructureNdx = StructureNdx;
+ StructureToCall =
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ GetRemoteStructData(StructureNdx);
+#else
+ (GuiLib_StructPtr)ReadWord(GuiStruct_StructPtrList[StructureNdx]);
+#endif
+
+#ifdef GuiConst_CURSOR_SUPPORT_ON
+ sgl.CursorFieldFound = -1;
+ sgl.CursorActiveFieldFound = 0;
+ GuiLib_ActiveCursorFieldNo = CursorFieldToShow;
+ sgl.CursorInUse = (GuiLib_ActiveCursorFieldNo >= 0);
+#else
+ gl.Dummy1_16S = CursorFieldToShow; // To avoid compiler warning
+#endif
+
+ if ((GuiLib_StructPtr)StructureToCall != 0)
+ {
+ sgl.CurItem.X1 = 0;
+ sgl.CurItem.Y1 = 0;
+ sgl.CurItem.X2 = 0;
+ sgl.CurItem.Y2 = 0;
+ sgl.CurItem.R1 = 0;
+ sgl.CurItem.R2 = 0;
+
+ sgl.CurItem.RX = 0;
+ sgl.CurItem.RY = 0;
+ sgl.CurItem.RX1 = 0;
+ sgl.CurItem.RY1 = 0;
+ sgl.CurItem.RX2 = 0;
+ sgl.CurItem.RY2 = 0;
+
+ for (N = 0; N < 2 * GuiLib_MEMORY_CNT; N++)
+ {
+ sgl.Memory.X[N] = 0;
+ sgl.Memory.Y[N] = 0;
+ }
+ for (N = 0; N < GuiLib_MEMORY_CNT; N++)
+ sgl.Memory.C[N] = 0;
+ sgl.ThicknessMemory = 1;
+
+ sgl.CurItem.ForeColor = GuiConst_PIXEL_ON;
+ sgl.CurItem.BackColor = GuiConst_PIXEL_OFF;
+ sgl.CurItem.BarForeColor = GuiConst_PIXEL_OFF;
+ sgl.CurItem.BarBackColor = GuiConst_PIXEL_ON;
+ sgl.CurItem.ForeColorIndex = 0xFFFF;
+ sgl.CurItem.BackColorIndex = 0xFFFF;
+ sgl.CurItem.BarForeColorIndex = 0xFFFF;
+ sgl.CurItem.BarBackColorIndex = 0xFFFF;
+
+
+ for (N = 0; N < 3; N++)
+ {
+ sgl.CurItem.TextPar[N].BitFlags = GuiLib_BITFLAG_TRANSPARENT;
+ sgl.CurItem.TextPar[N].Alignment = GuiLib_ALIGN_LEFT;
+ sgl.CurItem.TextPar[N].BackBoxSizeX = 0;
+ sgl.CurItem.TextPar[N].FontIndex = 0;
+ sgl.CurItem.TextPar[N].Ps = GuiLib_PS_ON;
+ }
+
+ sgl.CurItem.FormatFieldWidth = 10;
+ sgl.CurItem.FormatDecimals = 0;
+ sgl.CurItem.FormatAlignment = GuiLib_FORMAT_ALIGNMENT_RIGHT;
+ sgl.CurItem.FormatFormat = GuiLib_FORMAT_DEC;
+
+#ifdef GuiConst_BLINK_SUPPORT_ON
+#ifndef GuiConst_BLINK_FIELDS_OFF
+ for (N = 0; N < GuiConst_BLINK_FIELDS_MAX; N++)
+ {
+ sgl.BlinkTextItems[N].InUse = 0;
+ sgl.BlinkTextItems[N].Active = 0;
+ }
+#endif
+#endif
+
+#ifdef GuiConst_ITEM_TOUCHAREA_INUSE
+ sgl.TouchAreaCnt = 0;
+#endif
+
+#ifdef GuiConst_ITEM_SCROLLBOX_INUSE
+ for (M = 0; M < GuiConst_SCROLLITEM_BOXES_MAX; M++)
+ {
+ sgl.ScrollBoxesAry[M].InUse = GuiLib_SCROLL_STRUCTURE_UNDEF;
+ for (N = 0; N < GuiConst_SCROLLITEM_MARKERS_MAX; N++)
+ {
+ sgl.ScrollBoxesAry[M].MarkerColor[N] = GuiConst_PIXEL_ON;
+ sgl.ScrollBoxesAry[M].MarkerColorTransparent[N] = 1;
+ }
+ }
+#endif
+
+#ifdef GuiConst_ITEM_GRAPH_INUSE
+ for (N = 0; N < GuiConst_GRAPH_MAX; N++)
+ sgl.GraphAry[N].InUse = GuiLib_GRAPH_STRUCTURE_UNDEF;
+#endif
+
+ sgl.BaseLayerDrawing = 1;
+#ifdef GuiConst_ITEM_GRAPHICS_LAYER_FILTER_INUSE
+ GraphicsLayer_Pop(GuiLib_GRAPHICS_LAYER_BASE);
+ for (N = 0; N < GuiConst_GRAPHICS_LAYER_MAX; N++)
+ {
+ sgl.GraphicsLayerList[N].InUse = GuiLib_GRAPHICS_LAYER_UNDEF;
+ sgl.GraphicsFilterList[N].InUse = GuiLib_GRAPHICS_FILTER_UNDEF;
+ }
+#endif
+
+#ifdef GuiConst_BITMAP_SUPPORT_ON
+ sgl.GlobalBackgrBitmapIndex = 0;
+ for (N = 0; N < GuiConst_MAX_BACKGROUND_BITMAPS; N++)
+ sgl.BackgrBitmapAry[N].InUse = 0;
+#endif
+
+ if (ResetAutoRedraw)
+ AutoRedraw_Destroy();
+#ifdef GuiConst_CURSOR_SUPPORT_ON
+ else
+ AutoRedraw_ResetCursor();
+#endif
+
+ sgl.DrawingLevel = 0;
+ sgl.TopLevelStructure = 0;
+
+#ifdef GuiConst_TEXTBOX_FIELDS_ON
+ sgl.CurItem.CompPars.CompTextBox.ScrollIndex = 0;
+ sgl.CurItem.CompPars.CompTextBox.ScrollPos = 0;
+ for (N = 0; N < GuiConst_TEXTBOX_FIELDS_MAX; N++)
+ sgl.TextBoxScrollPositions[N].index = -1;
+#endif
+
+ sgl.CoordOrigoX = sgl.DisplayOrigoX + sgl.LayerOrigoX;
+ sgl.CoordOrigoY = sgl.DisplayOrigoY + sgl.LayerOrigoY;
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+ sgl.CurItem.ClipRectX1 = sgl.DisplayActiveAreaX1;
+ sgl.CurItem.ClipRectY1 = sgl.DisplayActiveAreaY1;
+ sgl.CurItem.ClipRectX2 = sgl.DisplayActiveAreaX2;
+ sgl.CurItem.ClipRectY2 = sgl.DisplayActiveAreaY2;
+ sgl.ActiveAreaX1 = sgl.DisplayActiveAreaX1;
+ sgl.ActiveAreaY1 = sgl.DisplayActiveAreaY1;
+ sgl.ActiveAreaX2 = sgl.DisplayActiveAreaX2;
+ sgl.ActiveAreaY2 = sgl.DisplayActiveAreaY2;
+ if (sgl.DisplayWriting)
+ {
+ if ((sgl.DisplayActiveAreaX1 != 0) || (sgl.DisplayActiveAreaY1 != 0) ||
+ (sgl.DisplayActiveAreaX2 != GuiConst_DISPLAY_WIDTH - 1) ||
+ (sgl.DisplayActiveAreaY2 != GuiConst_DISPLAY_HEIGHT - 1))
+ GuiLib_SetClipping(sgl.DisplayActiveAreaX1, sgl.DisplayActiveAreaY1,
+ sgl.DisplayActiveAreaX2, sgl.DisplayActiveAreaY2);
+ else
+ GuiLib_ResetClipping();
+ }
+#endif
+#ifdef GuiConst_CURSOR_SUPPORT_ON
+ sgl.CurItem.CursorFieldLevel = 0;
+#endif
+ sgl.DisplayLevel = 0;
+ sgl.InitialDrawing = 1;
+ sgl.SwapColors = 0;
+ DrawStructure((GuiLib_StructPtr) StructureToCall,
+ GuiLib_COL_INVERT_IF_CURSOR);
+ ResetLayerBufPtr();
+ sgl.InitialDrawing = 0;
+ sgl.CoordOrigoX = sgl.DisplayOrigoX + sgl.LayerOrigoX;
+ sgl.CoordOrigoY = sgl.DisplayOrigoY + sgl.LayerOrigoY;
+
+#ifdef GuiConst_CLIPPING_SUPPORT_ON
+ if (sgl.DisplayWriting)
+ GuiLib_ResetClipping();
+#endif
+ }
+
+#ifdef GuiConst_CURSOR_SUPPORT_ON
+ if (sgl.CursorFieldFound == -1)
+ {
+ sgl.CursorInUse = 0;
+ GuiLib_ActiveCursorFieldNo = -1;
+ }
+ else if (sgl.CursorInUse)
+ {
+ if (sgl.CursorActiveFieldFound == 0)
+ {
+ GuiLib_ActiveCursorFieldNo = sgl.CursorFieldFound;
+
+ DrawCursorItem(1);
+ }
+ }
+#endif
+
+#ifdef GuiConst_BLINK_SUPPORT_ON
+ sgl.BlinkBoxInverted = 0;
+#endif
+
+ GuiDisplay_Unlock();
+}
+
+//------------------------------------------------------------------------------
+GuiConst_INT16S CheckLanguageIndex(
+ GuiConst_INT16S LanguageIndex)
+{
+ if ((LanguageIndex < 0) || (LanguageIndex > GuiConst_LANGUAGE_CNT - 1))
+ LanguageIndex = 0;
+
+#ifdef GuiConst_LANGUAGE_SOME_ACTIVE
+ if (!ReadByte(GuiFont_LanguageActive[LanguageIndex]))
+ LanguageIndex = GuiConst_LANGUAGE_FIRST;
+#endif
+
+ return(LanguageIndex);
+}
+
+//------------------------------------------------------------------------------
+GuiConst_TEXT PrefixLocate *GuiLib_GetTextLanguagePtr(
+ const GuiConst_INT16U StructureNdx,
+ GuiConst_INT16U TextNo,
+ GuiConst_INT16S LanguageIndex)
+{
+ GuiConst_INT16U I;
+ GuiConst_INT16S ItemNdx;
+ GuiConst_INT8U ItemCnt;
+ GuiLib_StructPtr StructureToCall;
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ GuiConst_INT8U ItemSizeBuf[2];
+ GuiConst_INT16U ItemSize;
+#endif
+
+ StructureToCall =
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ GetRemoteStructData(StructureNdx);
+#else
+ (GuiLib_StructPtr)ReadWord(GuiStruct_StructPtrList[StructureNdx]);
+#endif
+
+ if (StructureToCall != 0)
+ {
+ LanguageIndex = CheckLanguageIndex(LanguageIndex);
+
+ sgl.ItemDataPtr = (GuiConst_INT8U PrefixLocate *)StructureToCall;
+ ItemCnt = GetItemByte(&sgl.ItemDataPtr);
+
+ I = 0;
+ for (ItemNdx = 0; ItemNdx < ItemCnt; ItemNdx++)
+ {
+#ifdef GuiConst_REMOTE_STRUCT_DATA
+ GuiLib_RemoteDataReadBlock(
+ sgl.RemoteStructOffset,
+ 2,
+ (GuiConst_INT8U*)&ItemSizeBuf);
+ ItemSize = (256 * (GuiConst_INT16U)ItemSizeBuf[1]) + ItemSizeBuf[0];
+ sgl.RemoteStructOffset += 2;
+ GuiLib_RemoteDataReadBlock(
+ sgl.RemoteStructOffset,
+ ItemSize,
+ sgl.GuiLib_RemoteItemBuffer);
+ sgl.RemoteStructOffset += ItemSize;
+ sgl.ItemDataPtr = &sgl.GuiLib_RemoteItemBuffer[0];
+#endif
+
+ ReadItem(LanguageIndex);
+
+ if ((sgl.CurItem.ItemType == GuiLib_ITEM_TEXT) ||
+ (sgl.CurItem.ItemType == GuiLib_ITEM_TEXTBLOCK))
+ {
+ if (I == TextNo)
+ {
+#ifdef GuiConst_CHARMODE_ANSI
+ return (GuiConst_TEXT PrefixLocate *) sgl.CurItem.TextPtr[0];
+#else
+ #ifdef GuiConst_ICC_COMPILER
+ ExtractUnicodeString((GuiConst_INT8U *)sgl.CurItem.TextPtr[0],
+ sgl.CurItem.TextLength[0]);
+ #else
+ #ifdef GuiConst_CODEVISION_COMPILER
+ ExtractUnicodeString((GuiConst_INT8U *)sgl.CurItem.TextPtr[0],
+ sgl.CurItem.TextLength[0]);
+ #else
+ ExtractUnicodeString((GuiConst_INT8U PrefixRom *)sgl.CurItem.TextPtr[0],
+ sgl.CurItem.TextLength[0]);
+ #endif
+ #endif
+
+ return (sgl.UnicodeTextBuf);
+#endif
+ }
+ I++;
+ }
+ }
+ }
+
+ return (0);
+}
+
+//------------------------------------------------------------------------------
+GuiConst_TEXT PrefixLocate *GuiLib_GetTextPtr(
+ const GuiConst_INT16U StructureNdx,
+ GuiConst_INT16U TextNo)
+{
+ return (GuiLib_GetTextLanguagePtr(StructureNdx, TextNo, GuiLib_LanguageIndex));
+}
+
+//------------------------------------------------------------------------------
+GuiConst_INT16U GuiLib_GetTextWidth(
+ GuiConst_TEXT PrefixLocate *String,
+ GuiLib_FontRecConstPtr Font,
+ GuiConst_INT8U PsWriting)
+{
+ GuiLib_ItemRec TextData;
+ GuiConst_INT16U CharCnt;
+
+ if ((String[0] != 0) && (Font != 0))
+ {
+ TextData.TextPar[0].Ps = PsWriting;
+ sgl.CurItem.TextPar[0].Ps = TextData.TextPar[0].Ps;
+#ifdef GuiConst_CHARMODE_ANSI
+ CharCnt = strlen(String);
+#else
+ CharCnt = GuiLib_UnicodeStrLen(String);
+#endif
+ sgl.CurFont = (GuiLib_FontRecPtr)Font;
+#ifdef GuiConst_DISP_VAR_NOW
+ displayVarNow = 1;
+#endif
+
+#ifdef GuiConst_CODEVISION_COMPILER
+ PrepareText((GuiConst_TEXT *)String, CharCnt, 0);
+#else
+#ifdef GuiConst_RENESAS_COMPILER_FAR
+ PrepareText((GuiConst_TEXT PrefixGeneric *)String, CharCnt, 0);
+#else
+ PrepareText(String, CharCnt, 0);
+#endif
+#endif
+#ifdef GuiConst_DISP_VAR_NOW
+ displayVarNow = 0;
+#endif
+
+ return (TextPixelLength(TextData.TextPar[0].Ps, CharCnt, 0));
+ }
+
+ return (0);
+}
+
+//---------------------------------------------------------------
+static GuiConst_TEXT GetCharCode(
+ GuiConst_TEXT PrefixRom * CharPtr,
+ GuiConst_INT16U CharCnt,
+ GuiConst_INT16U CharNo,
+ GuiConst_INT16U OmitCtrlCode)
+{
+ GuiConst_INT16U P;
+ GuiConst_TEXT CharCode, PreviousCharCode;
+
+ if (CharCnt > GuiConst_MAX_TEXT_LEN)
+ CharCnt = GuiConst_MAX_TEXT_LEN;
+
+ if (CharNo > CharCnt)
+ return 0;
+
+ if (CharCnt > GuiConst_MAX_TEXT_LEN)
+ CharCnt = GuiConst_MAX_TEXT_LEN;
+
+ if (OmitCtrlCode)
+ {
+ for (P = 0; P < CharNo + 1; P++)
+ {
+#ifdef GuiConst_CHARMODE_ANSI
+ #ifdef GuiConst_AVRGCC_COMPILER
+ CharCode = (unsigned GuiConst_CHAR) ReadBytePtr(CharPtr);
+ #else
+ #ifdef GuiConst_ICC_COMPILER
+ CharCode = *((GuiConst_INT8U PrefixRom *)CharPtr);
+ #else
+ #ifdef GuiConst_CODEVISION_COMPILER
+ CharCode = *((GuiConst_INT8U PrefixRom *)CharPtr);
+ #else
+ CharCode = (unsigned GuiConst_TEXT) *CharPtr;
+ #endif
+ #endif
+ #endif
+#else
+ CharCode = *((GuiConst_INT16U PrefixLocate *)CharPtr);
+#endif
+
+ if (P)
+ {
+ if ((CharCode == GuiLib_LINEFEED) ||
+ ((CharCode == ' ') && (PreviousCharCode == ' ')) ||
+ ((CharCode == ' ') && (PreviousCharCode == '-')))
+ CharNo++;
+ }
+ PreviousCharCode = CharCode;
+
+ CharPtr++;
+ }
+ }
+ else
+ {
+ CharPtr += CharNo;
+
+#ifdef GuiConst_CHARMODE_ANSI
+ #ifdef GuiConst_AVRGCC_COMPILER
+ CharCode = (unsigned GuiConst_CHAR) ReadBytePtr(CharPtr);
+ #else
+ #ifdef GuiConst_ICC_COMPILER
+ CharCode = *((GuiConst_INT8U PrefixRom *)CharPtr);
+ #else
+ #ifdef GuiConst_CODEVISION_COMPILER
+ CharCode = *((GuiConst_INT8U PrefixRom *)CharPtr);
+ #else
+ CharCode = (unsigned GuiConst_TEXT) *CharPtr;
+ #endif
+ #endif
+ #endif
+#else
+ CharCode = *((GuiConst_INT16U PrefixLocate *)CharPtr);
+#endif
+ }
+
+ return (GuiConst_TEXT)CharCode;
+}
+
+//------------------------------------------------------------------------------
+GuiConst_TEXT GuiLib_GetCharCode(
+ const GuiConst_INT16U StructureNdx,
+ GuiConst_INT16U TextNo,
+ GuiConst_INT16U CharNo,
+ GuiConst_INT16U OmitCtrlCode)
+{
+ GuiConst_TEXT PrefixRom * CharPtr;
+
+ CharPtr = GuiLib_GetTextPtr(StructureNdx, TextNo);
+
+ if (CharPtr == 0) return 0;
+
+#ifdef GuiConst_CHARMODE_ANSI
+ return GetCharCode(CharPtr,
+ strlen(CharPtr),
+ CharNo,
+ OmitCtrlCode);
+#else
+ return GetCharCode(CharPtr,
+ GuiLib_UnicodeStrLen(CharPtr),
+ CharNo,
+ OmitCtrlCode);
+#endif
+}
+
+//------------------------------------------------------------------------------
+#ifdef GuiConst_BLINK_SUPPORT_ON
+GuiConst_TEXT GuiLib_GetBlinkingCharCode(
+ GuiConst_INT16U BlinkFieldNo,
+ GuiConst_INT16U CharNo,
+ GuiConst_INT16U OmitCtrlCode)
+{
+#ifndef GuiConst_BLINK_FIELDS_OFF
+ GuiConst_INT16U StrLen;
+
+ if (BlinkFieldNo >= GuiConst_BLINK_FIELDS_MAX)
+ return 0;
+
+ if (sgl.BlinkTextItems[BlinkFieldNo].InUse)
+ {
+ #ifdef GuiConst_CHARMODE_ANSI
+ StrLen = strlen((GuiConst_TEXT*)sgl.BlinkTextItems[BlinkFieldNo].TextPtr);
+ #else
+ #ifdef GuiConst_CODEVISION_COMPILER
+ StrLen = GuiLib_UnicodeStrLen(
+ (GuiConst_TEXT*)sgl.BlinkTextItems[BlinkFieldNo].TextPtr);
+ #else
+ StrLen = GuiLib_UnicodeStrLen((GuiConst_TEXT*)sgl.BlinkTextItems[BlinkFieldNo].TextPtr);
+ #endif
+ #endif
+
+ return GetCharCode((GuiConst_TEXT PrefixRom *)sgl.BlinkTextItems[BlinkFieldNo].TextPtr,
+ StrLen,
+ CharNo,
+ OmitCtrlCode);
+ }
+ else
+#endif
+ return 0;
+}
+#endif
+
+//------------------------------------------------------------------------------
+void GuiLib_SetLanguage(
+ GuiConst_INT16S NewLanguage)
+{
+ GuiLib_LanguageIndex = CheckLanguageIndex(NewLanguage);
+}
+
+//------------------------------------------------------------------------------
+static void InvertBox(void)
+{
+ if (sgl.DisplayWriting)
+ GuiLib_InvertBox(sgl.InvertBoxX1, sgl.InvertBoxY1, sgl.InvertBoxX2, sgl.InvertBoxY2);
+ sgl.InvertBoxOn = !sgl.InvertBoxOn;
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_InvertBoxStart(
+ GuiConst_INT16S X1,
+ GuiConst_INT16S Y1,
+ GuiConst_INT16S X2,
+ GuiConst_INT16S Y2)
+{
+ GuiLib_InvertBoxStop();
+ sgl.InvertBoxX1 = X1;
+ sgl.InvertBoxY1 = Y1;
+ sgl.InvertBoxX2 = X2;
+ sgl.InvertBoxY2 = Y2;
+ InvertBox();
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_InvertBoxStop(void)
+{
+ if (sgl.InvertBoxOn)
+ InvertBox();
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_Refresh(void)
+{
+#ifdef WANT_DOUBLE_BUFFERING // Otherwise we are writing direct to the display - no need for this code
+ GuiConst_INT16S N, L;
+ GuiConst_INT8U RedrawBottomLevel;
+ ItemMemory RemMemory;
+ GuiConst_INT8U ColorInvert;
+
+ GuiDisplay_Lock();
+
+ sgl.RefreshClock++;
+
+ RedrawBottomLevel = 0;
+
+ N = AutoRedraw_Reset();
+
+ memcpy(&RemMemory, &sgl.Memory, sizeof(ItemMemory));
+
+ while (N != -1)
+ {
+#ifdef GuiConst_CURSOR_SUPPORT_ON
+ if (!AutoRedraw_IsOnlyCursor(N))
+#endif
+ {
+ if (AutoRedraw_VarChanged(N) != 0)
+ {
+ memcpy(&sgl.CurItem, AutoRedraw_GetItem(N), sizeof(GuiLib_ItemRec));
+ memcpy(&sgl.Memory, AutoRedraw_GetItemMemory(N), sizeof(ItemMemory));
+
+ AutoRedraw_UpdateVar(N);
+
+ ColorInvert = GuiLib_COL_INVERT_IF_CURSOR;
+
+#ifdef GuiConst_CURSOR_SUPPORT_ON
+ if (AutoRedraw_CheckCursorInheritance(N) == 0)
+ ColorInvert = GuiLib_COL_INVERT_ON;
+#endif
+
+ L = AutoRedraw_GetLevel(N);
+
+ if (AutoRedraw_ItemIsStruct(N))
+ {
+ N = AutoRedraw_DeleteStruct(N);
+ sgl.AutoRedrawUpdate = GuiLib_TRUE;
+ if (sgl.AutoRedrawInsertPoint >= 0)
+ N = AutoRedraw_GetNext(N);
+ }
+ else
+ {
+ sgl.AutoRedrawUpdate = GuiLib_FALSE;
+ N = AutoRedraw_GetNext(N);
+ }
+
+#ifdef GuiConst_BITMAP_SUPPORT_ON
+ UpdateBackgroundBitmap();
+#endif
+
+ sgl.DisplayLevel = 0;
+ sgl.SwapColors = 0;
+
+#ifdef GuiConst_BLINK_SUPPORT_ON
+#ifndef GuiConst_BLINK_FIELDS_OFF
+ if ((sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_BLINKTEXTFIELD) &&
+ (sgl.CurItem.BlinkFieldNo < GuiConst_BLINK_FIELDS_MAX) &&
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].InUse &&
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].Active &&
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].BlinkBoxInverted)
+ GuiLib_InvertBox(sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].BlinkBoxX1,
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].BlinkBoxY1,
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].BlinkBoxX2,
+ sgl.BlinkTextItems[sgl.CurItem.BlinkFieldNo].BlinkBoxY2);
+#endif
+#endif
+
+ DrawItem(ColorInvert);
+
+ if (L == 0)
+ RedrawBottomLevel = 1;
+
+ sgl.AutoRedrawUpdate = GuiLib_FALSE;
+ }
+ else
+ N = AutoRedraw_GetNext(N);
+ }
+#ifdef GuiConst_CURSOR_SUPPORT_ON
+ else
+ N = AutoRedraw_GetNext(N);
+#endif
+ }
+
+ memcpy(&sgl.Memory, &RemMemory, sizeof(ItemMemory));
+
+
+ if ((sgl.DrawingLevel > 0) && RedrawBottomLevel && (sgl.TopLevelStructure != 0))
+ {
+ sgl.DisplayLevel = 0;
+ sgl.SwapColors = 0;
+ DrawStructure(sgl.TopLevelStructure, GuiLib_COL_INVERT_IF_CURSOR);
+ ResetLayerBufPtr();
+ }
+
+#ifdef GuiConst_BLINK_SUPPORT_ON
+#ifndef GuiConst_BLINK_FIELDS_OFF
+ for (N = 0; N < GuiConst_BLINK_FIELDS_MAX; N++)
+ if (sgl.BlinkTextItems[N].InUse &&
+ sgl.BlinkTextItems[N].Active)
+ {
+ if (sgl.BlinkTextItems[N].BlinkBoxInverted !=
+ sgl.BlinkTextItems[N].BlinkBoxLast)
+ {
+ GuiLib_InvertBox(sgl.BlinkTextItems[N].BlinkBoxX1,
+ sgl.BlinkTextItems[N].BlinkBoxY1,
+ sgl.BlinkTextItems[N].BlinkBoxX2,
+ sgl.BlinkTextItems[N].BlinkBoxY2);
+ sgl.BlinkTextItems[N].BlinkBoxInverted =
+ sgl.BlinkTextItems[N].BlinkBoxLast;
+ }
+ if (sgl.BlinkTextItems[N].BlinkBoxState < 255)
+ {
+ sgl.BlinkTextItems[N].BlinkBoxState--;
+ if (sgl.BlinkTextItems[N].BlinkBoxState == 0)
+ {
+ sgl.BlinkTextItems[N].BlinkBoxState = sgl.BlinkTextItems[N].BlinkBoxRate;
+ if (sgl.DisplayWriting)
+ {
+ GuiLib_InvertBox(sgl.BlinkTextItems[N].BlinkBoxX1,
+ sgl.BlinkTextItems[N].BlinkBoxY1,
+ sgl.BlinkTextItems[N].BlinkBoxX2,
+ sgl.BlinkTextItems[N].BlinkBoxY2);
+ sgl.BlinkTextItems[N].BlinkBoxInverted =
+ !sgl.BlinkTextItems[N].BlinkBoxInverted;
+ sgl.BlinkTextItems[N].BlinkBoxLast =
+ sgl.BlinkTextItems[N].BlinkBoxInverted;
+ }
+ }
+ }
+ }
+ if (sgl.BlinkBoxRate)
+ {
+ if (sgl.BlinkBoxState < 255)
+ sgl.BlinkBoxState--;
+ if (sgl.BlinkBoxState == 0)
+ {
+ sgl.BlinkBoxState = sgl.BlinkBoxRate;
+ BlinkBox();
+ }
+ }
+#endif
+#endif
+
+ GuiDisplay_Unlock();
+
+ GuiDisplay_Refresh();
+#endif // WANT_DOUBLE_BUFFERING
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_DrawChar(
+ GuiConst_INT16S X,
+ GuiConst_INT16S Y,
+ GuiConst_INT16U FontNo,
+ GuiConst_TEXT Character,
+ GuiConst_INTCOLOR Color)
+{
+ GuiLib_FontRecPtr Font;
+#ifndef GuiConst_REMOTE_FONT_DATA
+ GuiConst_INT8U PrefixRom *CharPtr;
+#endif
+ GuiConst_INT16S X1,Y1,X2,Y2;
+#ifdef GuiConst_REMOTE_FONT_DATA
+ GuiConst_INT32U CharNdx;
+#else
+#ifdef GuiConst_CHARMODE_UNICODE
+ GuiConst_INT32U CharNdx;
+#endif
+#endif
+
+ Font = (GuiLib_FontRecPtr) ReadWord(GuiFont_FontList[FontNo]);
+
+ Y -= ReadByte(Font->BaseLine);
+
+#ifdef GuiConst_CHARMODE_ANSI
+ #ifdef GuiConst_REMOTE_FONT_DATA
+ if ((Character < Font->FirstChar) || (Character > Font->LastChar))
+ CharNdx =
+ (GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[Font->IllegalCharNdx];
+ else
+ CharNdx =
+ (GuiConst_INT32U PrefixRom)GuiFont_ChPtrList[Font->FirstCharNdx +
+ (GuiConst_INT16U)Character - (GuiConst_INT16U)Font->FirstChar];
+ DrawChar(X, Y, Font, CharNdx, Color, 0);
+ #else
+ if ((Character < ReadByte(Font->FirstChar)) ||
+ (Character > ReadByte(Font->LastChar)))
+ CharPtr = (GuiConst_INT8U PrefixRom *)ReadWord(
+ GuiFont_ChPtrList[ReadWord(Font->IllegalCharNdx)]);
+ else
+ CharPtr = (GuiConst_INT8U PrefixRom *)ReadWord(
+ GuiFont_ChPtrList[ReadWord(Font->FirstCharNdx) +
+ (GuiConst_INT16U)Character -
+ (GuiConst_INT16U)ReadByte(Font->FirstChar)]);
+ DrawChar(X, Y, Font, CharPtr, Color, 0);
+ #endif
+#else
+ CharNdx = GetCharNdx(Font, Character);
+ #ifdef GuiConst_REMOTE_FONT_DATA
+ DrawChar(X, Y, Font, CharNdx, Color, 0);
+ #else
+ CharPtr = (GuiConst_INT8U PrefixRom *)ReadWord(GuiFont_ChPtrList[CharNdx]);
+ DrawChar(X, Y, Font, CharPtr, Color, 0);
+ #endif
+#endif
+
+#ifdef GuiConst_REMOTE_FONT_DATA
+ X1 = X + sgl.GuiLib_RemoteFontBuffer[GuiLib_CHR_XLEFT_OFS];
+ X2 = X1 + sgl.GuiLib_RemoteFontBuffer[GuiLib_CHR_XWIDTH_OFS] - 1;
+ Y1 = Y + sgl.GuiLib_RemoteFontBuffer[GuiLib_CHR_YTOP_OFS];
+ Y2 = Y1 + sgl.GuiLib_RemoteFontBuffer[GuiLib_CHR_YHEIGHT_OFS] - 1;
+#else
+ X1 = X + ReadBytePtr(CharPtr + GuiLib_CHR_XLEFT_OFS);
+ X2 = X1 + ReadBytePtr(CharPtr + GuiLib_CHR_XWIDTH_OFS) - 1;
+ Y1 = Y + ReadBytePtr(CharPtr + GuiLib_CHR_YTOP_OFS);
+ Y2 = Y1 + ReadBytePtr(CharPtr + GuiLib_CHR_YHEIGHT_OFS) - 1;
+#endif
+
+ GuiLib_MarkDisplayBoxRepaint(X1,Y1,X2,Y2);
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_DrawStr(
+ GuiConst_INT16S X,
+ GuiConst_INT16S Y,
+ GuiConst_INT16U FontNo,
+ GuiConst_TEXT *String,
+ GuiConst_INT8U Alignment,
+ GuiConst_INT8U PsWriting,
+ GuiConst_INT8U Transparent,
+ GuiConst_INT8U Underlining,
+ GuiConst_INT16S BackBoxSizeX,
+ GuiConst_INT16S BackBoxSizeY1,
+ GuiConst_INT16S BackBoxSizeY2,
+ GuiConst_INT8U BackBorderPixels,
+ GuiConst_INTCOLOR ForeColor,
+ GuiConst_INTCOLOR BackColor)
+{
+ if (FontNo >= GuiFont_FontCnt)
+ return;
+ if (*String == 0)
+ return;
+
+ SetCurFont(FontNo);
+
+#ifdef GuiConst_AVRGCC_COMPILER
+ #ifdef GuiConst_CHARMODE_ANSI
+ sgl.CurItem.TextPtr[0] = (GuiConst_INT8U *)String;
+ #else
+ sgl.CurItem.TextPtr[0] = (GuiConst_INT16U *)String;
+ #endif
+#else
+#ifdef GuiConst_ICC_COMPILER
+ #ifdef GuiConst_CHARMODE_ANSI
+ sgl.CurItem.TextPtr[0] = (GuiConst_INT8U *)String;
+ #else
+ sgl.CurItem.TextPtr[0] = (GuiConst_INT16U *)String;
+ #endif
+#else
+#ifdef GuiConst_CODEVISION_COMPILER
+ #ifdef GuiConst_CHARMODE_ANSI
+ sgl.CurItem.TextPtr[0] = (GuiConst_INT8U *)String;
+ #else
+ sgl.CurItem.TextPtr[0] = (GuiConst_INT16U *)String;
+ #endif
+#else
+#ifdef GuiConst_RENESAS_COMPILER_FAR
+ #ifdef GuiConst_CHARMODE_ANSI
+ sgl.CurItem.TextPtr[0] = (GuiConst_INT8U PrefixLocate *)String;
+ #else
+ sgl.CurItem.TextPtr[0] = (GuiConst_INT16U PrefixLocate *)String;
+ #endif
+#else
+ sgl.CurItem.TextPtr[0] = String;
+#endif
+#endif
+#endif
+#endif
+
+ sgl.CurItem.TextLength[0] = 0;
+ while (*String != 0)
+ {
+ sgl.CurItem.TextLength[0]++;
+ String++;
+ }
+ sgl.CurItem.X1 = X;
+ sgl.CurItem.Y1 = Y;
+ sgl.CurItem.TextPar[0].FontIndex = FontNo;
+ sgl.CurItem.TextPar[0].Alignment = Alignment;
+ sgl.CurItem.TextPar[0].Ps = PsWriting;
+ sgl.CurItem.TextPar[0].BitFlags = 0;
+ if (Underlining)
+ sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_UNDERLINE;
+ sgl.CurItem.TextPar[0].BackBoxSizeX = BackBoxSizeX;
+ sgl.CurItem.TextPar[0].BackBoxSizeY1 = BackBoxSizeY1;
+ sgl.CurItem.TextPar[0].BackBoxSizeY2 = BackBoxSizeY2;
+ sgl.CurItem.TextPar[0].BackBorderPixels = BackBorderPixels;
+ if (sgl.CurItem.TextPar[0].BackBoxSizeX > 0)
+ DrawBackBox(BackColor, Transparent, 0);
+
+#ifdef GuiConst_DISP_VAR_NOW
+ displayVarNow = 1;
+#endif
+
+ DrawText(sgl.CurItem.TextPtr[0],
+ sgl.CurItem.TextLength[0],
+ 0,
+ ForeColor,
+ BackColor,
+ Transparent);
+
+#ifdef GuiConst_DISP_VAR_NOW
+ displayVarNow = 0;
+#endif
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_DrawVar(
+ GuiConst_INT16S X,
+ GuiConst_INT16S Y,
+ GuiConst_INT16U FontNo,
+ void PrefixLocate *VarPtr,
+ GuiConst_INT8U VarType,
+ GuiConst_INT8U FormatterFormat,
+ GuiConst_INT8U FormatterFieldWidth,
+ GuiConst_INT8U FormatterAlignment,
+ GuiConst_INT8U FormatterDecimals,
+ GuiConst_INT8U FormatterShowSign,
+ GuiConst_INT8U FormatterZeroPadding,
+ GuiConst_INT8U FormatterTrailingZeros,
+ GuiConst_INT8U FormatterThousandsSeparator,
+ GuiConst_INT8U Alignment,
+ GuiConst_INT8U PsWriting,
+ GuiConst_INT8U Transparent,
+ GuiConst_INT8U Underlining,
+ GuiConst_INT16S BackBoxSizeX,
+ GuiConst_INT16S BackBoxSizeY1,
+ GuiConst_INT16S BackBoxSizeY2,
+ GuiConst_INT8U BackBorderPixels,
+ GuiConst_INTCOLOR ForeColor,
+ GuiConst_INTCOLOR BackColor)
+{
+ GuiConst_INT32S VarValue;
+ GuiConst_INT16U StrLen;
+#ifndef GuiConst_CHARMODE_ANSI
+ GuiConst_INT16U P;
+#endif
+ GuiConst_TEXT PrefixGeneric *CharPtr;
+
+ if (FontNo >= GuiFont_FontCnt)
+ return;
+
+ SetCurFont(FontNo);
+
+ sgl.CurItem.VarPtr = VarPtr;
+ sgl.CurItem.VarType = VarType;
+ sgl.CurItem.FormatFormat = FormatterFormat;
+ sgl.CurItem.FormatFieldWidth = FormatterFieldWidth;
+ sgl.CurItem.FormatAlignment = FormatterAlignment;
+ sgl.CurItem.FormatDecimals = FormatterDecimals;
+ sgl.CurItem.TextPar[0].BitFlags = 0;
+ if (FormatterShowSign)
+ sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_FORMATSHOWSIGN;
+ if (FormatterZeroPadding)
+ sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_FORMATZEROPADDING;
+ if (FormatterTrailingZeros)
+ sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_FORMATTRAILINGZEROS;
+ if (FormatterThousandsSeparator)
+ sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_FORMATTHOUSANDSSEP;
+ sgl.CurItem.X1 = X;
+ sgl.CurItem.Y1 = Y;
+ sgl.CurItem.TextPar[0].FontIndex = FontNo;
+ sgl.CurItem.TextPar[0].Alignment = Alignment;
+ sgl.CurItem.TextPar[0].Ps = PsWriting;
+ if (Underlining)
+ sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_UNDERLINE;
+ sgl.CurItem.TextPar[0].BackBoxSizeX = BackBoxSizeX;
+ sgl.CurItem.TextPar[0].BackBoxSizeY1 = BackBoxSizeY1;
+ sgl.CurItem.TextPar[0].BackBoxSizeY2 = BackBoxSizeY2;
+ sgl.CurItem.TextPar[0].BackBorderPixels = BackBorderPixels;
+ if (sgl.CurItem.TextPar[0].BackBoxSizeX > 0)
+ DrawBackBox(BackColor, Transparent, 0);
+
+#ifdef GuiConst_DISP_VAR_NOW
+ displayVarNow = 1;
+#endif
+
+ if (sgl.CurItem.VarType == GuiLib_VAR_STRING)
+ {
+ CharPtr = (GuiConst_TEXT PrefixLocate *)sgl.CurItem.VarPtr;
+#ifdef GuiConst_CHARMODE_ANSI
+ StrLen = strlen(CharPtr);
+#else
+#ifdef GuiConst_CODEVISION_COMPILER
+ StrLen = GuiLib_UnicodeStrLen((GuiConst_TEXT*)CharPtr);
+#else
+ StrLen = GuiLib_UnicodeStrLen(CharPtr);
+#endif
+#endif
+ }
+ else
+ {
+ VarValue = ReadVar(sgl.CurItem.VarPtr, sgl.CurItem.VarType);
+ StrLen = DataNumStr(VarValue, sgl.CurItem.VarType, 0);
+#ifdef GuiConst_CHARMODE_ANSI
+ CharPtr = (GuiConst_TEXT PrefixGeneric *) sgl.VarNumTextStr;
+#else
+ for (P = 0; P <= StrLen; P++)
+ sgl.VarNumUnicodeTextStr[P] = sgl.VarNumTextStr[P];
+ CharPtr = (GuiConst_TEXT PrefixGeneric *) sgl.VarNumUnicodeTextStr;
+#endif
+ }
+
+ DrawText(CharPtr,
+ StrLen,
+ 0,
+ ForeColor,
+ BackColor,
+ Transparent);
+
+#ifdef GuiConst_DISP_VAR_NOW
+ displayVarNow = 0;
+#endif
+}
+
+//------------------------------------------------------------------------------
+void GuiLib_TestPattern(void)
+{
+ GuiLib_HLine(0, 31, 0, GuiConst_PIXEL_ON);
+ GuiLib_VLine(0, 1, 31, GuiConst_PIXEL_ON);
+ GuiLib_HLine(2, 8, 2, GuiConst_PIXEL_ON);
+ GuiLib_HLine(11, 16, 2, GuiConst_PIXEL_ON);
+ GuiLib_VLine(4, 4, 10, GuiConst_PIXEL_ON);
+ GuiLib_VLine(4, 13, 18, GuiConst_PIXEL_ON);
+}
+
+#include "GuiComponents.h"
+
+#ifdef GuiConst_REMOTE_DATA
+//------------------------------------------------------------------------------
+GuiConst_INT8U GuiLib_RemoteCheck(void)
+{
+ union
+ {
+ GuiConst_INT8U Bytes[4];
+ GuiConst_INT32U IdInFile;
+ } RemoteIdUnion;
+ GuiConst_INT8U ok;
+
+ GuiLib_RemoteDataReadBlock(0, 4, RemoteIdUnion.Bytes);
+ ok = (RemoteIdUnion.IdInFile == GuiConst_REMOTE_ID);
+
+#ifdef GuiConst_REMOTE_TEXT_DATA
+ GuiLib_RemoteTextReadBlock(0, 4, RemoteIdUnion.Bytes);
+ ok = ok && (RemoteIdUnion.IdInFile == GuiConst_REMOTE_ID);
+#endif
+
+ return (ok);
+}
+#endif
+
+