Single Photo displayed on LPC4088
Dependencies: DMBasicGUI DMSupport
Diff: easyGUIFixed/GuiItems.h
- Revision:
- 0:9140ec6aa604
diff -r 000000000000 -r 9140ec6aa604 easyGUIFixed/GuiItems.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/easyGUIFixed/GuiItems.h Fri Jul 28 14:19:12 2017 +0000 @@ -0,0 +1,5704 @@ +/* ************************************************************************ */ +/* */ +/* (C)2004-2015 IBIS Solutions ApS */ +/* sales@easyGUI.com */ +/* www.easyGUI.com */ +/* */ +/* v6.0.9.005 */ +/* */ +/* GuiLib.c include file - do NOT reference it in your linker setup */ +/* */ +/* ************************************************************************ */ + +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ +static GuiConst_INT8U GetItemByte( + GuiConst_INT8U *PrefixLocate*PrefixLocate ItemDataPtrPtr) +{ + GuiConst_INT8U D; +#ifdef GuiConst_AVRGCC_COMPILER + D = ReadBytePtr(*ItemDataPtrPtr); +#else +#ifdef GuiConst_AVR_COMPILER_FLASH_RAM + GuiConst_INT8U PrefixRom * ItemFlashPtr = + (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; +#else +#ifdef GuiConst_ICC_COMPILER + GuiConst_INT8U PrefixRom * ItemFlashPtr = + (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; +#else +#ifdef GuiConst_CODEVISION_COMPILER + GuiConst_INT8U PrefixRom * ItemFlashPtr; + ItemFlashPtr = (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; +#else + D = **ItemDataPtrPtr; +#endif +#endif +#endif +#endif + (*ItemDataPtrPtr)++; + return (D); +} +//------------------------------------------------------------------------------ +static GuiConst_INT16S GetItemWord( + GuiConst_INT8U *PrefixLocate*PrefixLocate ItemDataPtrPtr) +{ + GuiConst_INT16U D; + +#ifdef GuiConst_AVRGCC_COMPILER + D = ReadBytePtr(*ItemDataPtrPtr); + (*ItemDataPtrPtr)++; + D += 0x0100 * (GuiConst_INT16U)ReadBytePtr(*ItemDataPtrPtr); +#else +#ifdef GuiConst_AVR_COMPILER_FLASH_RAM + GuiConst_INT8U PrefixRom * ItemFlashPtr = + (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x0100 * (*ItemFlashPtr); +#else +#ifdef GuiConst_ICC_COMPILER + GuiConst_INT8U PrefixRom * ItemFlashPtr = + (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x0100 * (*ItemFlashPtr); +#else +#ifdef GuiConst_CODEVISION_COMPILER + GuiConst_INT8U PrefixRom * ItemFlashPtr; + ItemFlashPtr = (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x0100 * (*ItemFlashPtr); +#else + D = **ItemDataPtrPtr; + (*ItemDataPtrPtr)++; + D += 0x0100 * (GuiConst_INT16U)**ItemDataPtrPtr; +#endif +#endif +#endif +#endif + (*ItemDataPtrPtr)++; + return ((GuiConst_INT16S) D); +} +//------------------------------------------------------------------------------ +#ifdef GuiLib_COLOR_BYTESIZE_3 +static GuiConst_INT32S GetItemTriple( + GuiConst_INT8U *PrefixLocate*PrefixLocate ItemDataPtrPtr) +{ + GuiConst_INT32U D; + +#ifdef GuiConst_AVRGCC_COMPILER + D = ReadBytePtr(*ItemDataPtrPtr); + (*ItemDataPtrPtr)++; + D += 0x00000100 * (GuiConst_INT32U)ReadBytePtr(*ItemDataPtrPtr); + (*ItemDataPtrPtr)++; + D += 0x00010000 * (GuiConst_INT32U)ReadBytePtr(*ItemDataPtrPtr); +#else +#ifdef GuiConst_AVR_COMPILER_FLASH_RAM + GuiConst_INT8U PrefixRom * ItemFlashPtr = + (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00000100 * (*ItemFlashPtr); + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00010000 * (*ItemFlashPtr); +#else +#ifdef GuiConst_ICC_COMPILER + GuiConst_INT8U PrefixRom * ItemFlashPtr = + (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00000100 * (*ItemFlashPtr); + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00010000 * (*ItemFlashPtr); +#else +#ifdef GuiConst_CODEVISION_COMPILER + GuiConst_INT8U PrefixRom * ItemFlashPtr; + ItemFlashPtr = (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00000100 * (*ItemFlashPtr); + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00010000 * (*ItemFlashPtr); +#else + D = **ItemDataPtrPtr; + (*ItemDataPtrPtr)++; + D += 0x00000100 * (GuiConst_INT32U)**ItemDataPtrPtr; + (*ItemDataPtrPtr)++; + D += 0x00010000 * (GuiConst_INT32U)**ItemDataPtrPtr; +#endif +#endif +#endif +#endif + (*ItemDataPtrPtr)++; + return ((GuiConst_INT32S) D); +} +#endif + +#ifdef GuiLib_GETITEMLONG +//------------------------------------------------------------------------------ +static GuiConst_INT32S GetItemLong( + GuiConst_INT8U *PrefixLocate*PrefixLocate ItemDataPtrPtr) +{ + GuiConst_INT32U D; + +#ifdef GuiConst_AVRGCC_COMPILER + D = ReadBytePtr(*ItemDataPtrPtr); + (*ItemDataPtrPtr)++; + D += 0x00000100 * (GuiConst_INT32U)ReadBytePtr(*ItemDataPtrPtr); + (*ItemDataPtrPtr)++; + D += 0x00010000 * (GuiConst_INT32U)ReadBytePtr(*ItemDataPtrPtr); + (*ItemDataPtrPtr)++; + D += 0x01000000 * (GuiConst_INT32U)ReadBytePtr(*ItemDataPtrPtr); +#else +#ifdef GuiConst_AVR_COMPILER_FLASH_RAM + GuiConst_INT8U PrefixRom * ItemFlashPtr = + (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00000100 * (*ItemFlashPtr); + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00010000 * (*ItemFlashPtr); + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x01000000 * (*ItemFlashPtr); +#else +#ifdef GuiConst_ICC_COMPILER + GuiConst_INT8U PrefixRom * ItemFlashPtr = + (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00000100 * (*ItemFlashPtr); + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00010000 * (*ItemFlashPtr); + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x01000000 * (*ItemFlashPtr); +#else +#ifdef GuiConst_CODEVISION_COMPILER + GuiConst_INT8U PrefixRom * ItemFlashPtr; + ItemFlashPtr = (GuiConst_INT8U PrefixRom *)*ItemDataPtrPtr; + D = *ItemFlashPtr; + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00000100 * (*ItemFlashPtr); + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x00010000 * (*ItemFlashPtr); + (*ItemDataPtrPtr)++; + ItemFlashPtr++; + D += 0x01000000 * (*ItemFlashPtr); +#else + D = **ItemDataPtrPtr; + (*ItemDataPtrPtr)++; + D += 0x00000100 * (GuiConst_INT32U)**ItemDataPtrPtr; + (*ItemDataPtrPtr)++; + D += 0x00010000 * (GuiConst_INT32U)**ItemDataPtrPtr; + (*ItemDataPtrPtr)++; + D += 0x01000000 * (GuiConst_INT32U)**ItemDataPtrPtr; +#endif +#endif +#endif +#endif + (*ItemDataPtrPtr)++; + return ((GuiConst_INT32S) D); +} +#endif + +//------------------------------------------------------------------------------ +#ifdef GuiLib_COLOR_BYTESIZE_1 +#define GetItemColor GetItemByte +#endif +#ifdef GuiLib_COLOR_BYTESIZE_2 +#define GetItemColor GetItemWord +#endif +#ifdef GuiLib_COLOR_BYTESIZE_3 +#define GetItemColor GetItemTriple +#endif + +//------------------------------------------------------------------------------ +GuiConst_TEXT PrefixGeneric *GetItemTextPtr(GuiConst_INT8U index) +{ +#ifndef GuiConst_REMOTE_TEXT_DATA +#ifdef GuiConst_REMOTE_STRUCT_DATA + GuiConst_INT16U TxtReadSize; +#endif +#endif + + if (index > 2) + return NULL; + +#ifdef GuiConst_REMOTE_TEXT_DATA + sgl.CurItem.TextLength[index] = GetRemoteText(sgl.CurItem.TextIndex[index]); + sgl.CurItem.TextPtr[index] = &sgl.GuiLib_RemoteTextBuffer[0]; + +#else +#ifdef GuiConst_REMOTE_STRUCT_DATA + + TxtReadSize = sgl.CurItem.TextLength[index] + 1; +#ifndef GuiConst_CHARMODE_ANSI + TxtReadSize *= 2; +#endif + + GuiLib_RemoteDataReadBlock(sgl.CurItem.TextOffset[index], + TxtReadSize, + (GuiConst_INT8U PrefixGeneric*)&sgl.GuiLib_RemoteStructText); + sgl.CurItem.TextPtr[index] = (GuiConst_TEXT PrefixGeneric*)&sgl.GuiLib_RemoteStructText; +#endif +#endif // GuiConst_REMOTE_TEXT_DATA + + return sgl.CurItem.TextPtr[index]; + + +} + +//------------------------------------------------------------------------------ +#ifdef GuiConst_ITEM_RADIOBUTTON_INUSE +#define GuiItem_TEMP_PTR_NEEDED +#endif +#ifdef GuiConst_ITEM_BUTTON_INUSE +#ifndef GuiItem_TEMP_PTR_NEEDED +#define GuiItem_TEMP_PTR_NEEDED +#endif +#endif +#ifdef GuiConst_ITEM_CHECKBOX_INUSE +#ifndef GuiItem_TEMP_PTR_NEEDED +#define GuiItem_TEMP_PTR_NEEDED +#endif +#endif + +static void DrawItem( + GuiConst_INT8U ColorInvert) +{ + GuiConst_INT16U StructToCallIndex; + GuiConst_INT32S VarValue; + GuiConst_INT16S I, N; +#ifdef GuiConst_ITEM_CHECKBOX_INUSE + GuiConst_INT8U CheckmarkMode; +#endif +#ifdef GuiConst_ITEM_RADIOBUTTON_INUSE + GuiConst_INT16S RemYMemory; +#endif +#ifdef GuiConst_ITEM_BUTTON_INUSE + GuiConst_INT8U DisabledGlyphColorInUse; + GuiConst_INT8U DisabledTextColorInUse; + GuiConst_INT16S CX, CY; + GuiConst_INT16S RemX1, RemY1; + GuiConst_INT16S GX1, GX2, GY1, GY2; + GuiConst_INTCOLOR ButtonColor; +#ifdef GuiConst_CLIPPING_SUPPORT_ON + GuiConst_INT16S RemClippingX1, RemClippingY1, RemClippingX2, RemClippingY2; +#endif // GuiConst_CLIPPING_SUPPORT_ON +#endif + GuiConst_INT16U StrLen; +#ifdef GuiItem_TEMP_PTR_NEEDED + TextParRec TempTextPar; +#endif +#ifdef GuiConst_CURSOR_SUPPORT_ON + GuiConst_INT8U IsCursorField; + GuiConst_INT8U FoundActiveCursorField; +#endif + GuiConst_INTCOLOR ForeColor; + GuiConst_INTCOLOR BackColor; + GuiConst_INT8U BackColorTransp; + GuiConst_INT32S BackColor2; +#ifndef GuiConst_CHARMODE_ANSI + GuiConst_INT16U P; +#endif + GuiConst_TEXT PrefixGeneric *CharPtr; + GuiConst_INT16S X1, X2, Y1, Y2; +#ifdef GuiConst_ITEM_GRAPHICS_LAYER_FILTER_INUSE + GuiConst_INT16S CX1, CX2, CY1, CY2; + GuiConst_INT16S Y; + GuiConst_INT16S SourceLayerIndexNo; + GuiConst_INT16S DestLayerIndexNo; + GuiConst_INT8U PrefixLocate *DestAddress; + GuiConst_INT16U DestLineSize; + GuiConst_INT16S DestX; + GuiConst_INT16S DestY; + GuiConst_INT16U DestWidth; + GuiConst_INT16U DestHeight; + GuiConst_INT8U PrefixLocate *SourceAddress; + GuiConst_INT16U SourceLineSize; + GuiConst_INT16S SourceX; + GuiConst_INT16S SourceY; + GuiConst_INT16U SourceWidth; + GuiConst_INT16U SourceHeight; + GuiConst_INT32S FilterPars[10]; +#endif +#ifdef GuiConst_ITEM_STRUCTCOND_INUSE + GuiConst_INT8U FirstRound; +#endif +#ifdef GuiConst_ITEM_TOUCHAREA_INUSE + GuiConst_INT32S TouchSearch; + GuiConst_INT32S TouchIndex; +#endif +#ifdef GuiConst_TEXTBOX_FIELDS_ON + GuiConst_INT16S found; + GuiConst_INT16S PrefixLocate *ScrollPos; +#endif + +#ifdef GuiConst_REL_COORD_ORIGO_INUSE + if (!sgl.InitialDrawing) + { + sgl.CoordOrigoX = sgl.CurItem.CoordOrigoX; + sgl.CoordOrigoY = sgl.CurItem.CoordOrigoY; + } +#endif +#ifdef GuiConst_CLIPPING_SUPPORT_ON + if (!sgl.InitialDrawing && sgl.DisplayWriting) + GuiLib_SetClipping(sgl.CurItem.ClipRectX1, sgl.CurItem.ClipRectY1, + sgl.CurItem.ClipRectX2, sgl.CurItem.ClipRectY2); +#endif + + SetCurFont(sgl.CurItem.TextPar[0].FontIndex); + +#ifdef GuiConst_CURSOR_SUPPORT_ON + IsCursorField = (sgl.CursorInUse && (sgl.CurItem.CursorFieldNo >= 0)); + FoundActiveCursorField = + (IsCursorField && (GuiLib_ActiveCursorFieldNo == sgl.CurItem.CursorFieldNo)); + if (FoundActiveCursorField) + sgl.CursorActiveFieldFound = 1; +#endif + + sgl.AutoRedrawSaveIndex = -1; + + if ((sgl.InitialDrawing) || (sgl.AutoRedrawUpdate == GuiLib_TRUE)) + { +#ifdef GuiConst_CURSOR_SUPPORT_ON + if ((sgl.CurItem.CursorFieldNo >= 0) && (sgl.CursorFieldFound == -1)) + sgl.CursorFieldFound = sgl.CurItem.CursorFieldNo; + + if (IsCursorField) + { + sgl.CurItem.CursorFieldLevel++; + +#ifdef GuiConst_ITEM_SCROLLBOX_INUSE + if (sgl.NextScrollLineReading) + { + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_FIELDSCROLLBOX; + sgl.CurItem.CursorScrollBoxIndex = sgl.GlobalScrollBoxIndex; + } + else +#endif + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_FIELDSCROLLBOX; + +#ifndef GuiConst_CURSOR_FIELDS_OFF + if (!(sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_AUTOREDRAWFIELD)) + sgl.AutoRedrawSaveIndex = AutoRedraw_InsertCursor(&sgl.CurItem, 0, sgl.DisplayLevel); +#endif + } +#endif // GuiConst_CURSOR_SUPPORT_ON + + if (sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_AUTOREDRAWFIELD) + { + sgl.AutoRedrawSaveIndex = AutoRedraw_Insert(&sgl.CurItem, 0, sgl.DisplayLevel); + +#ifdef GuiConst_CURSOR_SUPPORT_ON + if (IsCursorField) + AutoRedraw_SetAsCursor(sgl.AutoRedrawSaveIndex); +#endif // GuiConst_CURSOR_SUPPORT_ON + } + } + + switch (ColorInvert) + { + case GuiLib_COL_INVERT_OFF: + sgl.SwapColors = 0; + break; + + case GuiLib_COL_INVERT_ON: + sgl.SwapColors = 1; + break; + + case GuiLib_COL_INVERT_IF_CURSOR: +#ifdef GuiConst_CURSOR_SUPPORT_ON + if (FoundActiveCursorField) + sgl.SwapColors = 1; +#else + sgl.SwapColors = 0; +#endif + break; + } + if (sgl.SwapColors) + { + ForeColor = sgl.CurItem.BarForeColor; + BackColor = sgl.CurItem.BarBackColor; + BackColorTransp = + ((sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_BARTRANSPARENT) > 0); + } + else + { + ForeColor = sgl.CurItem.ForeColor; + BackColor = sgl.CurItem.BackColor; + BackColorTransp = + ((sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_TRANSPARENT) > 0); + } + + sgl.CurItem.Drawn = 0; + switch (sgl.CurItem.ItemType) + { + case GuiLib_ITEM_CLEARAREA: + if (sgl.DisplayWriting) + { + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + X2 = sgl.CurItem.X2; + Y2 = sgl.CurItem.Y2; + OrderCoord(&X1, &X2); + OrderCoord(&Y1, &Y2); + if (!BackColorTransp) + GuiLib_FillBox(X1, Y1, X2, Y2, BackColor); + UpdateDrawLimits(X1, Y1, X2, Y2); + } + + break; + + case GuiLib_ITEM_TEXT: + if (sgl.DisplayWriting) + { + if (sgl.CurItem.TextPar[0].BackBoxSizeX > 0) + { + DrawBackBox(BackColor, BackColorTransp, 0); + UpdateDrawLimits(sgl.BbX1, sgl.BbY1, sgl.BbX2, sgl.BbY2); + } + + DRAW_ROM_TEXT(GetItemTextPtr(0), + sgl.CurItem.TextLength[0], + 0, + ForeColor, + BackColor, + BackColorTransp); + + UpdateDrawLimits(sgl.FontWriteX1, sgl.FontWriteY1, sgl.FontWriteX2, sgl.FontWriteY2); + } + + break; + + case GuiLib_ITEM_TEXTBLOCK: + if (sgl.DisplayWriting) + { +#ifdef GuiConst_ITEM_TEXTBLOCK_INUSE +#ifdef GuiConst_TEXTBOX_FIELDS_ON + ScrollPos = TextBox_Scroll_GetPosRec( + sgl.CurItem.CompPars.CompTextBox.ScrollIndex); + + if (ScrollPos != NULL) + sgl.CurItem.CompPars.CompTextBox.ScrollPos = *ScrollPos; +#endif + DRAW_ROM_TEXTBLOCK(GetItemTextPtr(0), + sgl.CurItem.TextLength[0], + 0, + ForeColor, + BackColor, + BackColorTransp); + +#ifdef GuiConst_TEXTBOX_FIELDS_ON + if (ScrollPos != NULL) + *ScrollPos = sgl.CurItem.CompPars.CompTextBox.ScrollPos; +#endif + + UpdateDrawLimits(sgl.CurItem.X1, sgl.CurItem.Y1, sgl.CurItem.X2, sgl.CurItem.Y2); +#endif + } + + break; + + case GuiLib_ITEM_VAR: + if (sgl.DisplayWriting) + { +#ifdef GuiConst_DISP_VAR_NOW + displayVarNow = 1; +#endif + + if (sgl.CurItem.TextPar[0].BackBoxSizeX > 0) + { + DrawBackBox(BackColor, BackColorTransp, 0); + UpdateDrawLimits(sgl.BbX1, sgl.BbY1, sgl.BbX2, sgl.BbY2); + } + + if (sgl.CurItem.VarPtr != 0) + { + if (sgl.CurItem.VarType == GuiLib_VAR_STRING) + { + CharPtr = (GuiConst_TEXT PrefixGeneric *)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 + } + +#ifdef GuiConst_CHARMODE_ANSI + strcpy(sgl.AnsiTextBuf, CharPtr); + DrawText(sgl.AnsiTextBuf, + StrLen, + 0, + ForeColor, + BackColor, + BackColorTransp); +#else + GuiLib_UnicodeStrCpy(sgl.UnicodeTextBuf, CharPtr); + DrawText(sgl.UnicodeTextBuf, + StrLen, + 0, + ForeColor, + BackColor, + BackColorTransp); +#endif + } + +#ifdef GuiConst_DISP_VAR_NOW + displayVarNow = 0; +#endif + + UpdateDrawLimits(sgl.FontWriteX1, sgl.FontWriteY1, sgl.FontWriteX2, sgl.FontWriteY2); + } + + break; + + case GuiLib_ITEM_VARBLOCK: + if (sgl.DisplayWriting) + { +#ifdef GuiConst_ITEM_TEXTBLOCK_INUSE +#ifdef GuiConst_DISP_VAR_NOW + displayVarNow = 1; +#endif + + if (sgl.CurItem.VarPtr != 0) + { + if (sgl.CurItem.VarType == GuiLib_VAR_STRING) + { + CharPtr = (GuiConst_TEXT PrefixGeneric *)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 + } +#ifdef GuiConst_TEXTBOX_FIELDS_ON + ScrollPos = TextBox_Scroll_GetPosRec( + sgl.CurItem.CompPars.CompTextBox.ScrollIndex); + + if (ScrollPos != NULL) + sgl.CurItem.CompPars.CompTextBox.ScrollPos = *ScrollPos; +#endif + +#ifdef GuiConst_CHARMODE_ANSI + strcpy(sgl.AnsiTextBuf, CharPtr); + DrawTextBlock(sgl.AnsiTextBuf, + StrLen, + 0, + ForeColor, + BackColor, + BackColorTransp); +#else + GuiLib_UnicodeStrCpy(sgl.UnicodeTextBuf, CharPtr); + DrawTextBlock(sgl.UnicodeTextBuf, + StrLen, + 0, + ForeColor, + BackColor, + BackColorTransp); +#endif + +#ifdef GuiConst_TEXTBOX_FIELDS_ON + if (ScrollPos != NULL) + *ScrollPos = sgl.CurItem.CompPars.CompTextBox.ScrollPos; +#endif + + } + +#ifdef GuiConst_DISP_VAR_NOW + displayVarNow = 0; +#endif + + UpdateDrawLimits(sgl.CurItem.X1, sgl.CurItem.Y1, sgl.CurItem.X2, sgl.CurItem.Y2); +#endif + } + + break; + + case GuiLib_ITEM_DOT: + if (sgl.DisplayWriting) + { + GuiLib_Dot(sgl.CurItem.X1, sgl.CurItem.Y1, ForeColor); + UpdateDrawLimits(sgl.CurItem.X1, sgl.CurItem.Y1, sgl.CurItem.X1, sgl.CurItem.Y1); + } + + break; + + case GuiLib_ITEM_LINE: + if (sgl.DisplayWriting) + { + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + X2 = sgl.CurItem.X2; + Y2 = sgl.CurItem.Y2; + if (sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_PATTERNEDLINE) + GuiLib_LinePattern(X1, Y1, X2, Y2, sgl.CurItem.LinePattern, ForeColor); + else + GuiLib_Line(X1, Y1, X2, Y2, ForeColor); + UpdateDrawLimits(X1, Y1, X2, Y2); + } + break; + + case GuiLib_ITEM_FRAME: + if (sgl.DisplayWriting) + { + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + X2 = sgl.CurItem.X2; + Y2 = sgl.CurItem.Y2; + OrderCoord(&X1, &X2); + OrderCoord(&Y1, &Y2); + if (sgl.CurItem.FrameThickness == 0) + N = sgl.ThicknessMemory; + else + N = sgl.CurItem.FrameThickness; + DrawBorderBox(X1, Y1, X2, Y2, ForeColor, BackColor, BackColorTransp, N); + UpdateDrawLimits(X1, Y1, X2, Y2); + } + + break; + + case GuiLib_ITEM_ROUNDEDFRAME: + if (sgl.DisplayWriting) + { + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + X2 = sgl.CurItem.X2; + Y2 = sgl.CurItem.Y2; + OrderCoord(&X1, &X2); + OrderCoord(&Y1, &Y2); + + if (BackColorTransp) + BackColor2 = GuiLib_NO_COLOR; + else + BackColor2 = BackColor; + + if (sgl.CurItem.R1 <= 0) + DrawBorderBox( + X1, Y1, X2, Y2, + ForeColor, BackColor, BackColorTransp, 1); + else + { + Ellipse( + X1 + sgl.CurItem.R1, Y1 + sgl.CurItem.R1, sgl.CurItem.R1, sgl.CurItem.R1, + ForeColor, BackColor2, 0, 0, 1, 0); + if (X2 - X1 + 1 - 2 * sgl.CurItem.R1 > 0) + { + GuiLib_HLine(X1 + sgl.CurItem.R1, X2 - sgl.CurItem.R1, Y1, ForeColor); + if (!BackColorTransp) + GuiLib_FillBox( + X1 + sgl.CurItem.R1, Y1 + 1, X2 - sgl.CurItem.R1, Y1 + sgl.CurItem.R1, + BackColor); + } + Ellipse( + X2 - sgl.CurItem.R1, Y1 + sgl.CurItem.R1, sgl.CurItem.R1, sgl.CurItem.R1, + ForeColor, BackColor2, 0, 0, 0, 1); + if (Y2 - Y1 + 1 - 2 * sgl.CurItem.R1 > 0) + { + GuiLib_VLine(X1, Y1 + sgl.CurItem.R1, Y2 - sgl.CurItem.R1, ForeColor); + if (!BackColorTransp) + GuiLib_FillBox( + X1 + 1, Y1 + sgl.CurItem.R1, X2 - 1, Y2 - sgl.CurItem.R1, BackColor); + GuiLib_VLine(X2 , Y1 + sgl.CurItem.R1, Y2 - sgl.CurItem.R1, ForeColor); + } + Ellipse( + X1 + sgl.CurItem.R1, Y2 - sgl.CurItem.R1, sgl.CurItem.R1, sgl.CurItem.R1, + ForeColor, BackColor2, 0, 1, 0, 0); + if (X2 - X1 + 1 - 2 * sgl.CurItem.R1 > 0) + { + if (!BackColorTransp) + GuiLib_FillBox( + X1 + sgl.CurItem.R1, Y2 - sgl.CurItem.R1, X2 - sgl.CurItem.R1, Y2 - 1, + BackColor); + GuiLib_HLine(X1 + sgl.CurItem.R1, X2 - sgl.CurItem.R1, Y2, ForeColor); + } + Ellipse( + X2 - sgl.CurItem.R1, Y2 - sgl.CurItem.R1, sgl.CurItem.R1, sgl.CurItem.R1, + ForeColor, BackColor2, 1, 0, 0, 0); + } + } + break; + + case GuiLib_ITEM_BLOCK: + if (sgl.DisplayWriting) + { + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + X2 = sgl.CurItem.X2; + Y2 = sgl.CurItem.Y2; + OrderCoord(&X1, &X2); + OrderCoord(&Y1, &Y2); + GuiLib_FillBox(X1, Y1, X2, Y2, ForeColor); + UpdateDrawLimits(X1, Y1, X2, Y2); + } + + break; + + case GuiLib_ITEM_ROUNDEDBLOCK: + if (sgl.DisplayWriting) + { + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + X2 = sgl.CurItem.X2; + Y2 = sgl.CurItem.Y2; + OrderCoord(&X1, &X2); + OrderCoord(&Y1, &Y2); + + if (sgl.CurItem.R1 <= 0) + GuiLib_FillBox(X1, Y1, X2, Y2, ForeColor); + else + { + Ellipse( + X1 + sgl.CurItem.R1, Y1 + sgl.CurItem.R1, sgl.CurItem.R1, sgl.CurItem.R1, + ForeColor, ForeColor, 0, 0, 1, 0); + if (X2 - X1 + 1 - 2 * sgl.CurItem.R1 > 0) + GuiLib_FillBox( + X1 + sgl.CurItem.R1, Y1, X2 - sgl.CurItem.R1, Y1 + sgl.CurItem.R1, + ForeColor); + Ellipse( + X2 - sgl.CurItem.R1, Y1 + sgl.CurItem.R1, sgl.CurItem.R1, sgl.CurItem.R1, + ForeColor, ForeColor, 0, 0, 0, 1); + if (Y2 - Y1 + 1 - 2 * sgl.CurItem.R1 > 0) + GuiLib_FillBox(X1, Y1 + sgl.CurItem.R1, X2, Y2 - sgl.CurItem.R1, ForeColor); + Ellipse( + X1 + sgl.CurItem.R1, Y2 - sgl.CurItem.R1, sgl.CurItem.R1, sgl.CurItem.R1, + ForeColor, ForeColor, 0, 1, 0, 0); + if (X2 - X1 + 1 - 2 * sgl.CurItem.R1 > 0) + GuiLib_FillBox( + X1 + sgl.CurItem.R1, Y2 - sgl.CurItem.R1, X2 - sgl.CurItem.R1, Y2, + ForeColor); + Ellipse( + X2 - sgl.CurItem.R1, Y2 - sgl.CurItem.R1, sgl.CurItem.R1, sgl.CurItem.R1, + ForeColor, ForeColor, 1, 0, 0, 0); + } + } + break; + + case GuiLib_ITEM_CIRCLE: + if (sgl.DisplayWriting && (sgl.CurItem.R1 >= 0)) + { + if (BackColorTransp) + BackColor2 = GuiLib_NO_COLOR; + else + BackColor2 = BackColor; + if ((sgl.CurItem.FrameThickness == 0xFF) && + !(sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_CIRCLE_IF)) + { + Ellipse(sgl.CurItem.X1 + sgl.CurItem.R1, + sgl.CurItem.Y1, + sgl.CurItem.R1, + sgl.CurItem.R1, + ForeColor, BackColor2, + 1, 1, 1, 1); + UpdateDrawLimits(sgl.CurItem.X1, + sgl.CurItem.Y1 - sgl.CurItem.R1, + sgl.CurItem.X1 + 2 * sgl.CurItem.R1, + sgl.CurItem.Y1 + sgl.CurItem.R1); + } + else + { + Circle(sgl.CurItem.X1 + sgl.CurItem.R1, + sgl.CurItem.Y1, + sgl.CurItem.R1, + ForeColor, + sgl.CurItem.FrameThickness & 0x01, + sgl.CurItem.FrameThickness & 0x02, + sgl.CurItem.FrameThickness & 0x04, + sgl.CurItem.FrameThickness & 0x08, + sgl.CurItem.FrameThickness & 0x10, + sgl.CurItem.FrameThickness & 0x20, + sgl.CurItem.FrameThickness & 0x40, + sgl.CurItem.FrameThickness & 0x80, + sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_CIRCLE_IF); + X1 = sgl.CurItem.X1 + sgl.CurItem.R1; + Y1 = sgl.CurItem.Y1; + X2 = sgl.CurItem.X1 + sgl.CurItem.R1; + Y2 = sgl.CurItem.Y1; + if (sgl.CurItem.FrameThickness & 0xC3) + X2 += sgl.CurItem.R1; + if (sgl.CurItem.FrameThickness & 0x3C) + X1 -= sgl.CurItem.R1; + if (sgl.CurItem.FrameThickness & 0xF0) + Y1 -= sgl.CurItem.R1; + if (sgl.CurItem.FrameThickness & 0x0F) + Y2 += sgl.CurItem.R1; + UpdateDrawLimits(X1, Y1, X2, Y2); + } + } + break; + + case GuiLib_ITEM_QUARTERCIRCLE: + if (sgl.DisplayWriting && (sgl.CurItem.R1 >= 0)) + { + if (BackColorTransp) + BackColor2 = GuiLib_NO_COLOR; + else + BackColor2 = BackColor; + + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + Ellipse(X1 + sgl.CurItem.R1, + Y1, + sgl.CurItem.R1, + sgl.CurItem.R1, + ForeColor, BackColor2, + (sgl.CurItem.FrameThickness == 0), + (sgl.CurItem.FrameThickness == 1), + (sgl.CurItem.FrameThickness == 2), + (sgl.CurItem.FrameThickness == 3)); + + switch (sgl.CurItem.FrameThickness) + { + case 1: + X1 += sgl.CurItem.R1; + break; + case 2: + X1 += sgl.CurItem.R1; + Y1 += sgl.CurItem.R1; + break; + case 3: + Y1 += sgl.CurItem.R1; + break; + } + UpdateDrawLimits(sgl.CurItem.X1, + sgl.CurItem.Y1, + sgl.CurItem.X1 + sgl.CurItem.R1, + sgl.CurItem.Y1 + sgl.CurItem.R1); + } + break; + + case GuiLib_ITEM_ELLIPSE: + if (sgl.DisplayWriting && (sgl.CurItem.R1 >= 0) && (sgl.CurItem.R2 >= 0)) + { + if (BackColorTransp) + BackColor2 = GuiLib_NO_COLOR; + else + BackColor2 = BackColor; + Ellipse(sgl.CurItem.X1 + sgl.CurItem.R1, + sgl.CurItem.Y1, + sgl.CurItem.R1, + sgl.CurItem.R2, + ForeColor, BackColor2, 1, 1, 1, 1); + + UpdateDrawLimits(sgl.CurItem.X1, + sgl.CurItem.Y1 - sgl.CurItem.R2, + sgl.CurItem.X1 + 2 * sgl.CurItem.R1, + sgl.CurItem.Y1 + sgl.CurItem.R2); + } + break; + + case GuiLib_ITEM_QUARTERELLIPSE: + if (sgl.DisplayWriting && (sgl.CurItem.R1 >= 0) && (sgl.CurItem.R2 >= 0)) + { + if (BackColorTransp) + BackColor2 = GuiLib_NO_COLOR; + else + BackColor2 = BackColor; + + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + Ellipse(X1 + sgl.CurItem.R1, + Y1, + sgl.CurItem.R1, + sgl.CurItem.R2, + ForeColor, BackColor2, + (sgl.CurItem.FrameThickness == 0), + (sgl.CurItem.FrameThickness == 1), + (sgl.CurItem.FrameThickness == 2), + (sgl.CurItem.FrameThickness == 3)); + + switch (sgl.CurItem.FrameThickness) + { + case 1: + X1 += sgl.CurItem.R1; + break; + case 2: + X1 += sgl.CurItem.R1; + Y1 += sgl.CurItem.R2; + break; + case 3: + Y1 += sgl.CurItem.R2; + break; + } + UpdateDrawLimits(sgl.CurItem.X1, + sgl.CurItem.Y1, + sgl.CurItem.X1 + sgl.CurItem.R1, + sgl.CurItem.Y1 + sgl.CurItem.R2); + } + break; + + case GuiLib_ITEM_BITMAP: + case GuiLib_ITEM_BACKGROUND: +#ifdef GuiConst_BITMAP_SUPPORT_ON + if (sgl.DisplayWriting) + { + if (sgl.CommonByte6 & 0x02) + BackColor2 = sgl.CurItem.CompPars.CompBitmap.TranspColor; + else + BackColor2 = -1; + GuiLib_ShowBitmap(sgl.CurItem.StructToCallIndex, + sgl.CurItem.X1, + sgl.CurItem.Y1, + BackColor2); + UpdateDrawLimits(sgl.CurItem.X1, sgl.CurItem.Y1, + sgl.BitmapWriteX2, sgl.BitmapWriteY2); + } + + if (sgl.CurItem.ItemType == GuiLib_ITEM_BACKGROUND) + { + sgl.BackgrBitmapAry[sgl.GlobalBackgrBitmapIndex].InUse = 1; + sgl.BackgrBitmapAry[sgl.GlobalBackgrBitmapIndex].Index = + sgl.CurItem.StructToCallIndex; + sgl.BackgrBitmapAry[sgl.GlobalBackgrBitmapIndex].X = sgl.CurItem.X1; + sgl.BackgrBitmapAry[sgl.GlobalBackgrBitmapIndex].Y = sgl.CurItem.Y1; + if (sgl.GlobalBackgrBitmapIndex < GuiConst_MAX_BACKGROUND_BITMAPS - 1) + sgl.GlobalBackgrBitmapIndex++; + } +#endif + + break; + + case GuiLib_ITEM_ACTIVEAREA: + if (sgl.DisplayWriting) + { +#ifdef GuiConst_CLIPPING_SUPPORT_ON + if (sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_CLIPPING) + { + sgl.CurItem.ClipRectX1 = sgl.CurItem.X1; + sgl.CurItem.ClipRectY1 = sgl.CurItem.Y1; + sgl.CurItem.ClipRectX2 = sgl.CurItem.X2; + sgl.CurItem.ClipRectY2 = sgl.CurItem.Y2; + sgl.ActiveAreaX1 = sgl.CurItem.X1; + sgl.ActiveAreaY1 = sgl.CurItem.Y1; + sgl.ActiveAreaX2 = sgl.CurItem.X2; + sgl.ActiveAreaY2 = sgl.CurItem.Y2; + OrderCoord(&sgl.ActiveAreaX1, &sgl.ActiveAreaX2); + OrderCoord(&sgl.ActiveAreaY1, &sgl.ActiveAreaY2); +#ifdef GuiConst_DISPLAY_ACTIVE_AREA_CLIPPING + if (sgl.ActiveAreaX1 < sgl.DisplayActiveAreaX1) + sgl.ActiveAreaX1 = sgl.DisplayActiveAreaX1; + if (sgl.ActiveAreaY1 < sgl.DisplayActiveAreaY1) + sgl.ActiveAreaY1 = sgl.DisplayActiveAreaY1; + if (sgl.ActiveAreaX2 > sgl.DisplayActiveAreaX2) + sgl.ActiveAreaX2 = sgl.DisplayActiveAreaX2; + if (sgl.ActiveAreaY2 > sgl.DisplayActiveAreaY2) + sgl.ActiveAreaY2 = sgl.DisplayActiveAreaY2; +#endif + GuiLib_SetClipping(sgl.ActiveAreaX1, sgl.ActiveAreaY1, + sgl.ActiveAreaX2, sgl.ActiveAreaY2); + } +#endif + +#ifdef GuiConst_CLIPPING_SUPPORT_ON +#ifdef GuiConst_REL_COORD_ORIGO_INUSE + if (sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_ACTIVEAREARELCOORD) + { + sgl.CurItem.ClipRectX1 += sgl.CoordOrigoX; + sgl.CurItem.ClipRectY1 += sgl.CoordOrigoY; + sgl.CurItem.ClipRectX2 += sgl.CoordOrigoX; + sgl.CurItem.ClipRectY2 += sgl.CoordOrigoY; + } +#endif +#endif + + sgl.CoordOrigoX = sgl.DisplayOrigoX + sgl.LayerOrigoX; + sgl.CoordOrigoY = sgl.DisplayOrigoY + sgl.LayerOrigoY; + if (sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_ACTIVEAREARELCOORD) + { + sgl.CoordOrigoX += sgl.CurItem.X1; + sgl.CoordOrigoY += sgl.CurItem.Y1; + } +#ifdef GuiConst_REL_COORD_ORIGO_INUSE + sgl.CurItem.CoordOrigoX = sgl.CoordOrigoX; + sgl.CurItem.CoordOrigoY = sgl.CoordOrigoY; +#endif + +#ifdef GuiConst_CLIPPING_SUPPORT_ON +#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 +#endif + } + break; + + case GuiLib_ITEM_CLIPRECT: +#ifdef GuiConst_CLIPPING_SUPPORT_ON + if (sgl.DisplayWriting) + { + if (sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_CLIPPING) + { + sgl.CurItem.ClipRectX1 = sgl.CurItem.X1; + sgl.CurItem.ClipRectY1 = sgl.CurItem.Y1; + sgl.CurItem.ClipRectX2 = sgl.CurItem.X2; + sgl.CurItem.ClipRectY2 = sgl.CurItem.Y2; + } + StartClipping( + (sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_CLIPPING) != 0); + } +#endif + break; + + case GuiLib_ITEM_STRUCTURE: + case GuiLib_ITEM_STRUCTARRAY: + case GuiLib_ITEM_STRUCTCOND: + if (sgl.DisplayWriting && (sgl.CurItem.TextPar[0].BackBoxSizeX > 0)) + { + DrawBackBox(BackColor, BackColorTransp, 0); + UpdateDrawLimits(sgl.BbX1, sgl.BbY1, sgl.BbX2, sgl.BbY2); + } + + StructToCallIndex = sgl.CurItem.StructToCallIndex; + if (sgl.CurItem.ItemType == GuiLib_ITEM_STRUCTARRAY) + { + if (StructToCallIndex != 0xFFFF) + { + VarValue = ReadVar(sgl.CurItem.VarPtr, sgl.CurItem.VarType); + + I = sgl.CurItem.CompPars.StructCall.IndexCount; + while (I > 0) + { + if (ReadWord(GuiStruct_StructNdxList[StructToCallIndex]) == + VarValue) + break; + + StructToCallIndex++; + I--; + } + if (I == 0) + { + if (ReadWord(GuiStruct_StructNdxList[sgl.CurItem.StructToCallIndex]) == 0xFFFF) + StructToCallIndex = sgl.CurItem.StructToCallIndex; + else + StructToCallIndex = 0xFFFF; + } + } + } +#ifdef GuiConst_ITEM_STRUCTCOND_INUSE + else if (sgl.CurItem.ItemType == GuiLib_ITEM_STRUCTCOND) + { + VarValue = ReadVar(sgl.CurItem.VarPtr, sgl.CurItem.VarType); + + I = sgl.CurItem.CompPars.StructCall.IndexCount - 1; + FirstRound = 1; + while (I >= 0) + { + if ((VarValue >= sgl.CurItem.CompPars.StructCall.IndexFirst[I]) && + (VarValue <= sgl.CurItem.CompPars.StructCall.IndexLast[I]) && + ((sgl.CurItem.CompPars.StructCall.IndexFirst[I] == + sgl.CurItem.CompPars.StructCall.IndexLast[I]) || + !FirstRound)) + { + StructToCallIndex = sgl.CurItem.CompPars.StructCall.CallIndex[I]; + break; + } + + I--; + + if ((I == -1) && FirstRound) + { + FirstRound = 0; + I = sgl.CurItem.CompPars.StructCall.IndexCount - 1; + } + } + } +#endif + DrawSubStruct(StructToCallIndex, ColorInvert, 0); + break; + +#ifdef GuiConst_ITEM_TOUCHAREA_INUSE + case GuiLib_ITEM_TOUCHAREA: + TouchIndex = -1; + for (TouchSearch = 0; TouchSearch < sgl.TouchAreaCnt; TouchSearch++) + if (sgl.TouchAreas[TouchSearch].IndexNo == + sgl.CurItem.CompPars.CompTouch.AreaNo) + { + TouchIndex = TouchSearch; + break; + } + if (TouchIndex == -1) + { + TouchIndex = sgl.TouchAreaCnt; + sgl.TouchAreaCnt++; + } + sgl.TouchAreas[TouchIndex].IndexNo = sgl.CurItem.CompPars.CompTouch.AreaNo; + sgl.TouchAreas[TouchIndex].X1 = sgl.CurItem.X1; + sgl.TouchAreas[TouchIndex].Y1 = sgl.CurItem.Y1; + sgl.TouchAreas[TouchIndex].X2 = sgl.CurItem.X2; + sgl.TouchAreas[TouchIndex].Y2 = sgl.CurItem.Y2; + OrderCoord(&sgl.TouchAreas[TouchIndex].X1, &sgl.TouchAreas[TouchIndex].X2); + OrderCoord(&sgl.TouchAreas[TouchIndex].Y1, &sgl.TouchAreas[TouchIndex].Y2); + + break; +#endif + + case GuiLib_ITEM_POSCALLBACK: + for (I = 0; I < GuiConst_POSCALLBACK_CNT; I++) + if (sgl.PosCallbacks[I].InUse && + (sgl.PosCallbacks[I].IndexNo == sgl.CurItem.PosCallbackNo) && + (sgl.PosCallbacks[I].PosCallbackFunc != 0)) + { + (*sgl.PosCallbacks[I].PosCallbackFunc)(sgl.CurItem.PosCallbackNo, + sgl.CurItem.X1, + sgl.CurItem.Y1); + break; + } + break; + +#ifdef GuiConst_ITEM_SCROLLBOX_INUSE + case GuiLib_ITEM_SCROLLBOX: + break; +#endif + +#ifdef GuiConst_ITEM_CHECKBOX_INUSE + case GuiLib_ITEM_CHECKBOX: + PrepareInternalStruct(); + + GuiVarCompInt1 = sgl.CurItem.CompPars.CompCheckBox.Size; + sgl.Memory.C[0] = ForeColor; + + Y2 = sgl.CurItem.Y1 + sgl.CurItem.CompPars.CompCheckBox.Size - 1; + switch (sgl.CurItem.CompPars.CompCheckBox.Style) + { + case GuiLib_CHECKBOX_FLAT: + if (BackColorTransp) + DrawSubStruct(GuiStructCOMP_CBFLATTRANSP, 0, 1); + else + DrawSubStruct(GuiStructCOMP_CBFLAT, 0, 1); + break; + case GuiLib_CHECKBOX_3D: + DrawSubStruct(GuiStructCOMP_CB3D, 0, 1); + if (!BackColorTransp) + DrawSubStruct(GuiStructCOMP_CB3DINNER, 0, 1); + break; + case GuiLib_CHECKBOX_ICON: + TempTextPar = sgl.CurItem.TextPar[0]; + SetCurFont(sgl.CurItem.CompPars.CompCheckBox.IconFont); + sgl.CurItem.X1 = sgl.CurItem.X1 + sgl.CurItem.CompPars.CompCheckBox.IconOffsetX; + sgl.CurItem.Y1 = sgl.CurItem.Y1 + sgl.CurItem.CompPars.CompCheckBox.IconOffsetY; + sgl.CurItem.TextPar[0].Alignment = GuiLib_ALIGN_LEFT; + sgl.CurItem.TextPar[0].Ps = GuiLib_PS_OFF; + sgl.CurItem.TextPar[0].BitFlags = 0; + sgl.CurItem.TextPar[0].BackBoxSizeX = 0; + sgl.CurItem.TextPar[0].BackBorderPixels = 0; + DrawText(sgl.CurItem.CompPars.CompCheckBox.IconPtr, + 1, + 0, + ForeColor, + BackColor, + BackColorTransp); + Y2 = sgl.FontWriteY2; + sgl.CurItem.TextPar[0] = TempTextPar; + break; + case GuiLib_CHECKBOX_BITMAP: + if (sgl.CurItem.CompPars.CompCheckBox.BitmapIsTransparent) + BackColor2 = sgl.CurItem.CompPars.CompCheckBox.BitmapTranspColor; + else + BackColor2 = -1; + GuiLib_ShowBitmap(sgl.CurItem.CompPars.CompCheckBox.BitmapIndex, + sgl.CurItem.X1, sgl.CurItem.Y1, + BackColor2); + break; + } + + if ((sgl.CurItem.VarPtr != 0) && (sgl.CurItem.VarType != GuiLib_VAR_STRING)) + { + VarValue = ReadVar(sgl.CurItem.VarPtr, sgl.CurItem.VarType); + + if (VarValue != 0) + CheckmarkMode = 1; + else if ((sgl.CurItem.CompPars.CompCheckBox.Style == GuiLib_CHECKBOX_NONE) && + (!BackColorTransp)) + CheckmarkMode = 2; + else + CheckmarkMode = 0; + + if (CheckmarkMode > 0) + { + GuiVarCompInt1 = sgl.CurItem.CompPars.CompCheckBox.Size; + if (CheckmarkMode == 1) + sgl.Memory.C[0] = sgl.CurItem.CompPars.CompCheckBox.MarkColor; + else + sgl.Memory.C[0] = BackColor; + + switch (sgl.CurItem.CompPars.CompCheckBox.MarkStyle) + { + case GuiLib_CHECKBOX_MARK_CHECKED: + GuiVarCompInt1 = + (sgl.CurItem.CompPars.CompCheckBox.Size / 2) - + ((sgl.CurItem.CompPars.CompCheckBox.Size - 6) / 6); + GuiVarCompInt2 = + (sgl.CurItem.CompPars.CompCheckBox.Size / + 2) + + ((sgl.CurItem.CompPars.CompCheckBox.Size - 8) / 6); + GuiVarCompInt3 = GuiVarCompInt2 - + ((sgl.CurItem.CompPars.CompCheckBox.Size - 1) / 5); + GuiVarCompInt4 = -GuiVarCompInt3; + GuiVarCompInt5 = -((GuiVarCompInt3 - 1) / 2); + if (((sgl.CurItem.CompPars.CompCheckBox.Style == + GuiLib_CHECKBOX_FLAT) || + (sgl.CurItem.CompPars.CompCheckBox.Style == + GuiLib_CHECKBOX_3D) || + (sgl.CurItem.CompPars.CompCheckBox.Style == + GuiLib_CHECKBOX_NONE)) && + (sgl.CurItem.CompPars.CompCheckBox.Size <= 10)) + DrawSubStruct(GuiStructCOMP_CBMCHSMALL, 0, 1); + else + DrawSubStruct(GuiStructCOMP_CBMCHBIG, 0, 1); + break; + case GuiLib_CHECKBOX_MARK_CROSSED: + if ((sgl.CurItem.CompPars.CompCheckBox.Style == + GuiLib_CHECKBOX_FLAT) && + (sgl.CurItem.CompPars.CompCheckBox.Size <= 8)) + DrawSubStruct(GuiStructCOMP_CBMCRFLSMALL, 0, 1); + else if (((sgl.CurItem.CompPars.CompCheckBox.Style == + GuiLib_CHECKBOX_3D) || + (sgl.CurItem.CompPars.CompCheckBox.Style == + GuiLib_CHECKBOX_NONE)) && + (sgl.CurItem.CompPars.CompCheckBox.Size <= 8)) + DrawSubStruct(GuiStructCOMP_CBMCR3DSMALL, 0, 1); + else + DrawSubStruct(GuiStructCOMP_CBMCRBIG, 0, 1); + break; + case GuiLib_CHECKBOX_MARK_FILLED: + if (sgl.CurItem.CompPars.CompCheckBox.Style == GuiLib_CHECKBOX_FLAT) + DrawSubStruct(GuiStructCOMP_CBMFIFLAT, 0, 1); + else + DrawSubStruct(GuiStructCOMP_CBMFI3D, 0, 1); + break; + case GuiLib_CHECKBOX_MARK_ICON: + TempTextPar = sgl.CurItem.TextPar[0]; + SetCurFont(sgl.CurItem.CompPars.CompCheckBox.MarkIconFont); + sgl.CurItem.X1 = sgl.CurItem.X1 + + sgl.CurItem.CompPars.CompCheckBox.MarkOffsetX; + sgl.CurItem.Y1 = Y2 + + sgl.CurItem.CompPars.CompCheckBox.MarkOffsetY; + sgl.CurItem.TextPar[0].Alignment = GuiLib_ALIGN_LEFT; + sgl.CurItem.TextPar[0].Ps = GuiLib_PS_OFF; + sgl.CurItem.TextPar[0].BitFlags = 0; + sgl.CurItem.TextPar[0].BackBoxSizeX = 0; + sgl.CurItem.TextPar[0].BackBorderPixels = 0; + if (CheckmarkMode == 1) + DrawText(sgl.CurItem.CompPars.CompCheckBox.MarkIconPtr, + 1, + 0, + sgl.CurItem.CompPars.CompCheckBox.MarkColor, + 0, + 1); + else + DrawText(sgl.CurItem.CompPars.CompCheckBox.MarkIconPtr, + 1, + 0, + BackColor, + 0, + 2); + sgl.CurItem.TextPar[0] = TempTextPar; + break; + case GuiLib_CHECKBOX_MARK_BITMAP: + if (CheckmarkMode == 1) + { + if (sgl.CurItem.CompPars.CompCheckBox.MarkBitmapIsTransparent) + BackColor2 = sgl.CurItem.CompPars.CompCheckBox.MarkBitmapTranspColor; + else + BackColor2 = -1; + GuiLib_ShowBitmap(sgl.CurItem.CompPars.CompCheckBox.MarkBitmapIndex, + sgl.CurItem.X1 + + sgl.CurItem.CompPars.CompCheckBox.MarkOffsetX, + sgl.CurItem.Y1 + + sgl.CurItem.CompPars.CompCheckBox.MarkOffsetY, + BackColor2); + } + else + { + ReadBitmapSizes(sgl.CurItem.CompPars.CompCheckBox.MarkBitmapIndex); + GuiLib_FillBox(sgl.CurItem.X1, sgl.CurItem.Y1, + sgl.CurItem.X1 + sgl.BitmapSizeX -1, sgl.CurItem.Y1 + sgl.BitmapSizeY - 1, + BackColor); + } + break; + } + } + } + break; +#endif + +#ifdef GuiConst_ITEM_RADIOBUTTON_INUSE + case GuiLib_ITEM_RADIOBUTTON: + PrepareInternalStruct(); + + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + RemYMemory = sgl.Memory.Y[GuiLib_MEMORY_CNT]; + + if ((sgl.CurItem.VarPtr != 0) && + (sgl.CurItem.VarType != GuiLib_VAR_STRING)) + VarValue = ReadVar(sgl.CurItem.VarPtr, sgl.CurItem.VarType); + else + VarValue = -1; + + for (N = 0; N < sgl.CurItem.CompPars.CompRadioButton.Count; N++) + { + GuiVarCompInt1 = sgl.CurItem.CompPars.CompRadioButton.Size; + sgl.Memory.C[0] = ForeColor; + switch (sgl.CurItem.CompPars.CompRadioButton.Style) + { + case GuiLib_RADIOBUTTON_FLAT: + if (BackColorTransp) + DrawSubStruct(GuiStructCOMP_RBFLATTRANSP, 0, 1); + else + DrawSubStruct(GuiStructCOMP_RBFLAT, 0, 1); + break; + case GuiLib_RADIOBUTTON_3D: + if (!BackColorTransp) + DrawSubStruct(GuiStructCOMP_RB3DINNER, 0, 1); + DrawSubStruct(GuiStructCOMP_RB3D, 0, 1); + break; + case GuiLib_RADIOBUTTON_ICON: + TempTextPar = sgl.CurItem.TextPar[0]; + SetCurFont(sgl.CurItem.CompPars.CompRadioButton.IconFont); + sgl.CurItem.X1 = X1 + sgl.CurItem.CompPars.CompRadioButton.IconOffsetX; + sgl.CurItem.Y1 = Y1 + sgl.CurItem.CompPars.CompRadioButton.IconOffsetY + + sgl.CurFont->BaseLine; + sgl.CurItem.TextPar[0].Alignment = GuiLib_ALIGN_LEFT; + sgl.CurItem.TextPar[0].Ps = GuiLib_PS_OFF; + sgl.CurItem.TextPar[0].BitFlags = 0; + sgl.CurItem.TextPar[0].BackBoxSizeX = 0; + sgl.CurItem.TextPar[0].BackBorderPixels = 0; + DrawText(sgl.CurItem.CompPars.CompRadioButton.IconPtr, + 1, + 0, + ForeColor, + BackColor, + BackColorTransp); + sgl.CurItem.TextPar[0] = TempTextPar; + break; + case GuiLib_RADIOBUTTON_BITMAP: + if (sgl.CurItem.CompPars.CompRadioButton.BitmapIsTransparent) + BackColor2 = sgl.CurItem.CompPars.CompRadioButton.BitmapTranspColor; + else + BackColor2 = -1; + GuiLib_ShowBitmap(sgl.CurItem.CompPars.CompRadioButton.BitmapIndex, + X1, Y1, + BackColor2); + break; + } + + if (VarValue == N) + { + GuiVarCompInt1 = sgl.CurItem.CompPars.CompRadioButton.Size; + GuiVarCompInt2 = sgl.CurItem.CompPars.CompRadioButton.Size - 3; + if (sgl.CurItem.CompPars.CompRadioButton.Style == + GuiLib_RADIOBUTTON_FLAT) + GuiVarCompInt2++; + sgl.Memory.C[0] = sgl.CurItem.CompPars.CompRadioButton.MarkColor; + switch (sgl.CurItem.CompPars.CompRadioButton.MarkStyle) + { + case GuiLib_RADIOBUTTON_MARK_STANDARD: + if (GuiVarCompInt1 <= 1) + DrawSubStruct(GuiStructCOMP_RBMSQUA, 0, 1); + else if (sgl.CurItem.CompPars.CompRadioButton.Style == + GuiLib_RADIOBUTTON_FLAT) + DrawSubStruct(GuiStructCOMP_RBMFLAT, 0, 1); + else + DrawSubStruct(GuiStructCOMP_RBM3D, 0, 1); + break; + case GuiLib_RADIOBUTTON_MARK_ICON: + TempTextPar = sgl.CurItem.TextPar[0]; + SetCurFont(sgl.CurItem.CompPars.CompRadioButton.MarkIconFont); + sgl.CurItem.X1 = X1 + sgl.CurItem.CompPars.CompRadioButton.MarkOffsetX; + sgl.CurItem.Y1 = Y1 + sgl.CurItem.CompPars.CompRadioButton.MarkOffsetY + + sgl.CurFont->BaseLine; + sgl.CurItem.TextPar[0].Alignment = GuiLib_ALIGN_LEFT; + sgl.CurItem.TextPar[0].Ps = GuiLib_PS_OFF; + sgl.CurItem.TextPar[0].BitFlags = 0; + sgl.CurItem.TextPar[0].BackBoxSizeX = 0; + sgl.CurItem.TextPar[0].BackBorderPixels = 0; + DrawText(sgl.CurItem.CompPars.CompRadioButton.MarkIconPtr, + 1, + 0, + ForeColor, + BackColor, + BackColorTransp); + sgl.CurItem.TextPar[0] = TempTextPar; + break; + case GuiLib_RADIOBUTTON_MARK_BITMAP: + if (sgl.CurItem.CompPars.CompRadioButton.MarkBitmapIsTransparent) + BackColor2 = sgl.CurItem.CompPars.CompRadioButton.MarkBitmapTranspColor; + else + BackColor2 = -1; + GuiLib_ShowBitmap(sgl.CurItem.CompPars.CompRadioButton.MarkBitmapIndex, + X1 + + sgl.CurItem.CompPars.CompRadioButton.MarkOffsetX, + Y1 + + sgl.CurItem.CompPars.CompRadioButton.MarkOffsetY, + BackColor2); + break; + } + } + + Y1 += sgl.CurItem.CompPars.CompRadioButton.InterDistance; + sgl.Memory.Y[GuiLib_MEMORY_CNT] += + sgl.CurItem.CompPars.CompRadioButton.InterDistance; + } + + sgl.Memory.Y[GuiLib_MEMORY_CNT] = RemYMemory; + break; +#endif + +#ifdef GuiConst_ITEM_BUTTON_INUSE + case GuiLib_ITEM_BUTTON: + PrepareInternalStruct(); + + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + X2 = sgl.CurItem.X2; + Y2 = sgl.CurItem.Y2; + RemX1 = sgl.CurItem.X1; + RemY1 = sgl.CurItem.Y1; + + GuiVarCompInt1 = X2 - X1 + 1; + GuiVarCompInt2 = Y2 - Y1 + 1; + GuiVarCompInt3 = sgl.CurItem.R1; + GuiVarCompInt4 = GuiVarCompInt1 - sgl.CurItem.R1; + GuiVarCompInt5 = GuiVarCompInt2 - sgl.CurItem.R1; + + sgl.Memory.C[0] = ForeColor; + sgl.Memory.C[1] = BackColor; + + if (sgl.ButtonColorOverride == GuiLib_TRUE) + sgl.Memory.C[2] = sgl.DisabledButtonColor; + else + sgl.Memory.C[2] = GuiLib_DesaturatePixelColor(BackColor,800); + + if ((sgl.CurItem.VarPtr != 0) && + (sgl.CurItem.VarType != GuiLib_VAR_STRING)) + { + VarValue = ReadVar(sgl.CurItem.VarPtr, sgl.CurItem.VarType); + if ((VarValue < GuiLib_BUTTON_STATE_UP) || + (VarValue > GuiLib_BUTTON_STATE_DISABLED)) + VarValue = GuiLib_BUTTON_STATE_UP; + } + else + VarValue = GuiLib_BUTTON_STATE_UP; + + DisabledGlyphColorInUse = 0; + DisabledTextColorInUse = 0; + switch (sgl.CurItem.CompPars.CompButton.BodyStyle) + { + case GuiLib_BUTTON_BODY_FLAT: + switch (VarValue) + { + case 0 : + if (sgl.CurItem.R1 == 0) + DrawSubStruct(GuiStructCOMP_BUFLAT0, 0, 1); + else + DrawSubStruct(GuiStructCOMP_BUFLATR0, 0, 1); + break; + case 1 : + if (sgl.CurItem.R1 == 0) + DrawSubStruct(GuiStructCOMP_BUFLAT1, 0, 1); + else + DrawSubStruct(GuiStructCOMP_BUFLATR1, 0, 1); + break; + case 2 : + if (sgl.CurItem.R1 == 0) + DrawSubStruct(GuiStructCOMP_BUFLAT2, 0, 1); + else + DrawSubStruct(GuiStructCOMP_BUFLATR2, 0, 1); + DisabledGlyphColorInUse = + (sgl.CurItem.CompPars.CompButton.GlyphLikeUp & 0x02); + DisabledTextColorInUse = + (sgl.CurItem.CompPars.CompButton.TextLikeUp & 0x08); + break; + } + break; + case GuiLib_BUTTON_BODY_3D: + switch (VarValue) + { + case 0 : + if (sgl.CurItem.R1 == 0) + DrawSubStruct(GuiStructCOMP_BU3D0, 0, 1); + else + DrawSubStruct(GuiStructCOMP_BU3DR0, 0, 1); + break; + case 1 : + if (sgl.CurItem.R1 == 0) + DrawSubStruct(GuiStructCOMP_BU3D1, 0, 1); + else + DrawSubStruct(GuiStructCOMP_BU3DR1, 0, 1); + break; + case 2 : + if (sgl.CurItem.R1 == 0) + DrawSubStruct(GuiStructCOMP_BU3D2, 0, 1); + else + DrawSubStruct(GuiStructCOMP_BU3DR2, 0, 1); + DisabledGlyphColorInUse = + !(sgl.CurItem.CompPars.CompButton.GlyphLikeUp & 0x02); + DisabledTextColorInUse = + !(sgl.CurItem.CompPars.CompButton.TextLikeUp & 0x08); + break; + } + break; + case GuiLib_BUTTON_BODY_ICON: + TempTextPar = sgl.CurItem.TextPar[VarValue]; + SetCurFont(sgl.CurItem.CompPars.CompButton.BodyIconFont[VarValue]); + sgl.CurItem.X1 = + X1 + + sgl.CurItem.CompPars.CompButton.BodyIconOffsetX[VarValue]; + sgl.CurItem.Y1 = + Y1 + + sgl.CurItem.CompPars.CompButton.BodyIconOffsetY[VarValue] + + sgl.CurFont->BaseLine; + sgl.CurItem.TextPar[VarValue].Alignment = GuiLib_ALIGN_LEFT; + sgl.CurItem.TextPar[VarValue].Ps = GuiLib_PS_OFF; + sgl.CurItem.TextPar[VarValue].BitFlags = 0; + sgl.CurItem.TextPar[VarValue].BackBoxSizeX = 0; + sgl.CurItem.TextPar[VarValue].BackBorderPixels = 0; + DrawText(sgl.CurItem.CompPars.CompButton.BodyIconPtr[VarValue], + 1, + VarValue, + ForeColor, + BackColor, + BackColorTransp); + sgl.CurItem.TextPar[VarValue] = TempTextPar; + X1 = sgl.FontWriteX1; + Y1 = sgl.FontWriteY1; + X2 = sgl.FontWriteX2; + Y2 = sgl.FontWriteY2; + break; + case GuiLib_BUTTON_BODY_BITMAP: + if (sgl.CurItem.CompPars.CompButton.BodyBitmapIsTransparent[VarValue]) + BackColor2 = + sgl.CurItem.CompPars.CompButton.BodyBitmapTranspColor[VarValue]; + else + BackColor2 = -1; + GuiLib_ShowBitmap(sgl.CurItem.CompPars.CompButton.BodyBitmapIndex[VarValue], + X1, Y1, + BackColor2); + X2 = sgl.BitmapWriteX2; + Y2 = sgl.BitmapWriteY2; + break; + } + + CX = (X1 + X2) / 2; + CY = (Y1 + Y2) / 2; + +#ifdef GuiConst_CLIPPING_SUPPORT_ON + RemClippingX1 = sgl.CurItem.ClipRectX1; + RemClippingY1 = sgl.CurItem.ClipRectY1; + RemClippingX2 = sgl.CurItem.ClipRectX2; + RemClippingY2 = sgl.CurItem.ClipRectY2; + sgl.CurItem.ClipRectX1 = GuiLib_GET_MAX(sgl.CurItem.ClipRectX1, X1); + sgl.CurItem.ClipRectY1 = GuiLib_GET_MAX(sgl.CurItem.ClipRectY1, Y1); + sgl.CurItem.ClipRectX2 = GuiLib_GET_MIN(sgl.CurItem.ClipRectX2, X2); + sgl.CurItem.ClipRectY2 = GuiLib_GET_MIN(sgl.CurItem.ClipRectY2, Y2); + GuiLib_SetClipping(sgl.CurItem.ClipRectX1, sgl.CurItem.ClipRectY1, + sgl.CurItem.ClipRectX2, sgl.CurItem.ClipRectY2); +#endif // GuiConst_CLIPPING_SUPPORT_ON + + if (sgl.CurItem.CompPars.CompButton.Layout != GuiLib_BUTTON_LAYOUT_TEXT) + { + switch (sgl.CurItem.CompPars.CompButton.Layout) + { + case GuiLib_BUTTON_LAYOUT_GLYPH: + GX1 = CX; + GY1 = CY; + break; + case GuiLib_BUTTON_LAYOUT_GLYPHLEFT: + GX1 = X1 + GuiLib_GET_MIN((Y2 - Y1) / 2, (X2 - X1) / 4); + GY1 = CY; + break; + case GuiLib_BUTTON_LAYOUT_GLYPHRIGHT: + GX1 = X2 - GuiLib_GET_MIN((Y2 - Y1) / 2, (X2 - X1) / 4); + GY1 = CY; + break; + case GuiLib_BUTTON_LAYOUT_GLYPHTOP: + GX1 = CX; + GY1 = Y1 + ((Y2 - Y1) / 4); + break; + case GuiLib_BUTTON_LAYOUT_GLYPHBOTTOM: + GX1 = CX; + GY1 = Y2 - ((Y2 - Y1) / 4); + break; + } + switch (sgl.CurItem.CompPars.CompButton.GlyphStyle) + { + case GuiLib_BUTTON_GLYPH_ICON: + TempTextPar = sgl.CurItem.TextPar[VarValue]; + SetCurFont(sgl.CurItem.CompPars.CompButton.GlyphIconFont[VarValue]); + sgl.CurItem.X1 = + GX1 + + sgl.CurItem.CompPars.CompButton.GlyphIconOffsetX[VarValue]; + sgl.CurItem.Y1 = + GY1 + + sgl.CurItem.CompPars.CompButton.GlyphIconOffsetY[VarValue] + + GuiLib_FONT_MID_Y(sgl.CurFont->BaseLine, sgl.CurFont->TopLine); + sgl.CurItem.TextPar[VarValue].Alignment = GuiLib_ALIGN_CENTER; + sgl.CurItem.TextPar[VarValue].Ps = GuiLib_PS_OFF; + sgl.CurItem.TextPar[VarValue].BitFlags = 0; + sgl.CurItem.TextPar[VarValue].BackBoxSizeX = 0; + sgl.CurItem.TextPar[VarValue].BackBorderPixels = 0; + if (DisabledGlyphColorInUse) + ButtonColor = GuiLib_MiddlePixelColor( + sgl.CurItem.CompPars.CompButton.GlyphIconColor[VarValue], + sgl.Memory.C[2], + 800); + else + ButtonColor = sgl.CurItem.CompPars.CompButton.GlyphIconColor[VarValue]; + DrawText(sgl.CurItem.CompPars.CompButton.GlyphIconPtr[VarValue], + 1, + VarValue, + ButtonColor, + 0, + GuiLib_TRUE); + sgl.CurItem.TextPar[VarValue] = TempTextPar; + GX1 = sgl.FontWriteX1; + GY1 = sgl.FontWriteY1; + GX2 = sgl.FontWriteX2; + GY2 = sgl.FontWriteY2; + break; + case GuiLib_BUTTON_GLYPH_BITMAP: + ReadBitmapSizes(sgl.CurItem.CompPars.CompButton.GlyphBitmapIndex[VarValue]); + GX1 -= sgl.BitmapSizeX / 2; + GY1 -= sgl.BitmapSizeY / 2; + + GX1 += sgl.CurItem.CompPars.CompButton.GlyphBitmapOffsetX[VarValue]; + GY1 += sgl.CurItem.CompPars.CompButton.GlyphBitmapOffsetY[VarValue]; + if (sgl.CurItem.CompPars.CompButton.GlyphBitmapIsTransparent[VarValue]) + BackColor2 = sgl.CurItem.CompPars.CompButton.GlyphBitmapTranspColor[VarValue]; + else + BackColor2 = -1; + GuiLib_ShowBitmap(sgl.CurItem.CompPars.CompButton.GlyphBitmapIndex[VarValue], + GX1, GY1, + BackColor2); + GX2 = sgl.BitmapWriteX2; + GY2 = sgl.BitmapWriteY2; + break; + } + } + + if (sgl.CurItem.CompPars.CompButton.Layout != GuiLib_BUTTON_LAYOUT_GLYPH) + { + TempTextPar = sgl.CurItem.TextPar[VarValue]; + SetCurFont(sgl.CurItem.TextPar[VarValue].FontIndex); + switch (sgl.CurItem.CompPars.CompButton.Layout) + { + case GuiLib_BUTTON_LAYOUT_TEXT: + sgl.CurItem.X1 = CX; + sgl.CurItem.Y1 = CY; + break; + case GuiLib_BUTTON_LAYOUT_GLYPHLEFT: + sgl.CurItem.X1 = X2 - ((X2 - GX2 + 1) / 2); + sgl.CurItem.Y1 = CY; + break; + case GuiLib_BUTTON_LAYOUT_GLYPHRIGHT: + sgl.CurItem.X1 = X1 + ((GX1 - X1 + 1) / 2); + sgl.CurItem.Y1 = CY; + break; + case GuiLib_BUTTON_LAYOUT_GLYPHTOP: + sgl.CurItem.X1 = CX; + sgl.CurItem.Y1 = Y2 - ((Y2 - GY2 + 1) / 2); + break; + case GuiLib_BUTTON_LAYOUT_GLYPHBOTTOM: + sgl.CurItem.X1 = CX; + sgl.CurItem.Y1 = Y1 + ((GY1 - Y1 + 1) / 2); + break; + } + sgl.CurItem.Y1 += + GuiLib_FONT_MID_Y(sgl.CurFont->BaseLine, sgl.CurFont->TopLine); + sgl.CurItem.TextPar[VarValue].Alignment = GuiLib_ALIGN_CENTER; + sgl.CurItem.TextPar[VarValue].BitFlags = 0; + sgl.CurItem.TextPar[VarValue].BackBoxSizeX = 0; + sgl.CurItem.TextPar[VarValue].BackBorderPixels = 0; + if (DisabledTextColorInUse) + ButtonColor = GuiLib_MiddlePixelColor( + sgl.CurItem.CompPars.CompButton.TextColor[VarValue], + sgl.Memory.C[2], + 800); + else + ButtonColor = sgl.CurItem.CompPars.CompButton.TextColor[VarValue]; + DRAW_ROM_TEXT(GetItemTextPtr(VarValue), + sgl.CurItem.TextLength[VarValue], + VarValue, + ButtonColor, + 0, + GuiLib_TRUE); + sgl.CurItem.TextPar[VarValue] = TempTextPar; + } + + sgl.CurItem.X1 = RemX1; + sgl.CurItem.Y1 = RemY1; + +#ifdef GuiConst_CLIPPING_SUPPORT_ON + sgl.CurItem.ClipRectX1 = RemClippingX1; + sgl.CurItem.ClipRectY1 = RemClippingY1; + sgl.CurItem.ClipRectX2 = RemClippingX2; + sgl.CurItem.ClipRectY2 = RemClippingY2; + GuiLib_SetClipping(sgl.CurItem.ClipRectX1, sgl.CurItem.ClipRectY1, + sgl.CurItem.ClipRectX2, sgl.CurItem.ClipRectY2); +#endif // GuiConst_CLIPPING_SUPPORT_ON + + break; +#endif + +#ifdef GuiConst_ITEM_PANEL_INUSE + case GuiLib_ITEM_PANEL: + PrepareInternalStruct(); + + X1 = sgl.CurItem.X1; + Y1 = sgl.CurItem.Y1; + X2 = sgl.CurItem.X2; + Y2 = sgl.CurItem.Y2; + OrderCoord(&X1, &X2); + OrderCoord(&Y1, &Y2); + + GuiVarCompInt1 = X2 - X1 + 1; + GuiVarCompInt2 = Y2 - Y1 + 1; + GuiVarCompInt3 = sgl.CurItem.R1; + GuiVarCompInt4 = GuiVarCompInt1 - sgl.CurItem.R1; + GuiVarCompInt5 = GuiVarCompInt2 - sgl.CurItem.R1; + + sgl.Memory.C[0] = ForeColor; + switch (sgl.CurItem.CompPars.CompPanel.Style) + { + case GuiLib_PANEL_FLAT: + if (sgl.CurItem.R1 == 0) + { + if (BackColorTransp) + DrawSubStruct(GuiStructCOMP_PAFLATTRANSP, 0, 1); + else + DrawSubStruct(GuiStructCOMP_PAFLAT, 0, 1); + } + else + { + if (BackColorTransp) + DrawSubStruct(GuiStructCOMP_PAFLATTRANSPR, 0, 1); + else + DrawSubStruct(GuiStructCOMP_PAFLATR, 0, 1); + } + break; + + case GuiLib_PANEL_3D_RAISED: + if (sgl.CurItem.R1 == 0) + { + if (!BackColorTransp) + DrawSubStruct(GuiStructCOMP_PA3DINNER, 0, 1); + DrawSubStruct(GuiStructCOMP_PA3DRAIS, 0, 1); + } + else + { + if (!BackColorTransp) + DrawSubStruct(GuiStructCOMP_PA3DINNERR, 0, 1); + DrawSubStruct(GuiStructCOMP_PA3DRAISR, 0, 1); + } + break; + + case GuiLib_PANEL_3D_LOWERED: + if (sgl.CurItem.R1 == 0) + { + if (!BackColorTransp) + DrawSubStruct(GuiStructCOMP_PA3DINNER, 0, 1); + DrawSubStruct(GuiStructCOMP_PA3DLOW, 0, 1); + } + else + { + if (!BackColorTransp) + DrawSubStruct(GuiStructCOMP_PA3DINNERR, 0, 1); + DrawSubStruct(GuiStructCOMP_PA3DLOWR, 0, 1); + } + break; + + case GuiLib_PANEL_EMBOSSED_RAISED: + if (!BackColorTransp) + DrawSubStruct(GuiStructCOMP_PA3DINNER, 0, 1); + DrawSubStruct(GuiStructCOMP_PAEMBRAIS, 0, 1); + break; + + case GuiLib_PANEL_EMBOSSED_LOWERED: + if (!BackColorTransp) + DrawSubStruct(GuiStructCOMP_PA3DINNER, 0, 1); + DrawSubStruct(GuiStructCOMP_PAEMBLOW, 0, 1); + break; + } + break; +#endif + +#ifdef GuiConst_ITEM_GRAPH_INUSE + case GuiLib_ITEM_GRAPH: + break; +#endif + +#ifdef GuiConst_ITEM_GRAPHICS_LAYER_FILTER_INUSE + case GuiLib_ITEM_GRAPHICSLAYER: +#ifdef GuiLib_LAYERS_SUPPORTED + if (sgl.DisplayWriting) + { + sgl.LayerOrigoX = 0; + sgl.LayerOrigoY = 0; + sgl.CoordOrigoX = sgl.DisplayOrigoX + sgl.LayerOrigoX; + sgl.CoordOrigoY = sgl.DisplayOrigoY + sgl.LayerOrigoY; + + X1 = sgl.CurItem.X1; + X2 = sgl.CurItem.X2; + Y1 = sgl.CurItem.Y1; + Y2 = sgl.CurItem.Y2; + GuiLib_COORD_ADJUST(X1, Y1); + GuiLib_COORD_ADJUST(X2, Y2); + OrderCoord(&X1, &X2); + OrderCoord(&Y1, &Y2); + + switch (sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].SizeMode) + { + case GuiLib_GRAPHICS_LAYER_SIZE_COORD: + X1 = GuiLib_GET_MINMAX(X1, 0, GuiConst_DISPLAY_WIDTH_HW - 1); + Y1 = GuiLib_GET_MINMAX(Y1, 0, GuiConst_DISPLAY_HEIGHT_HW - 1); + X2 = GuiLib_GET_MINMAX(X2, 0, GuiConst_DISPLAY_WIDTH_HW - 1); + Y2 = GuiLib_GET_MINMAX(Y2, 0, GuiConst_DISPLAY_HEIGHT_HW - 1); + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].X = GuiLib_GET_MINMAX( + X1, 0, GuiConst_DISPLAY_WIDTH_HW); + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Y = GuiLib_GET_MINMAX( + Y1, 0, GuiConst_DISPLAY_HEIGHT_HW); + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Width = X2 - X1 + 1; + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Height = Y2 - Y1 + 1; + break; + + case GuiLib_GRAPHICS_LAYER_SIZE_SCREEN: + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].X = 0; + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Y = 0; + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Width = + GuiConst_DISPLAY_WIDTH_HW; + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Height = + GuiConst_DISPLAY_HEIGHT_HW; + break; + + case GuiLib_GRAPHICS_LAYER_SIZE_CLIP: + CX1 = sgl.CurItem.ClipRectX1; + CX2 = sgl.CurItem.ClipRectX2; + CY1 = sgl.CurItem.ClipRectY1; + CY2 = sgl.CurItem.ClipRectY2; + GuiLib_COORD_ADJUST(CX1, CY1); + GuiLib_COORD_ADJUST(CX2, CY2); + OrderCoord(&CX1, &CX2); + OrderCoord(&CY1, &CY2); + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].X = CX1; + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Y = CY1; + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Width = CX2 - CX1 + 1; + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Height = CY2 - CY1 + 1; + break; + } + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].LineSize = + GuiConst_PIXEL_BYTE_SIZE * + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Width; + sgl.CurItem.ClipRectX1 = 0; + sgl.CurItem.ClipRectY1 = 0; + sgl.CurItem.ClipRectX2 = + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Width - 1; + sgl.CurItem.ClipRectY2 = + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Height - 1; +#ifdef GuiConst_CLIPPING_SUPPORT_ON + StartClipping(1); +#endif + sgl.LayerOrigoX = -sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].X; + sgl.LayerOrigoY = -sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Y; + sgl.CoordOrigoX = sgl.DisplayOrigoX + sgl.LayerOrigoX; + sgl.CoordOrigoY = sgl.DisplayOrigoY + sgl.LayerOrigoY; + + if (GraphicsLayer_Push(sgl.GlobalGraphicsLayerIndex)) + { + switch (sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].InitMode) + { + case GuiLib_GRAPHICS_LAYER_INIT_NONE: + break; + + case GuiLib_GRAPHICS_LAYER_INIT_COL: + GuiLib_FillBox( + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].X, + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Y, + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].X + + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Width - 1, + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Y + + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Height - 1, + BackColor); + break; + + case GuiLib_GRAPHICS_LAYER_INIT_COPY: + GraphicsLayer_Copy( + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].BaseAddress, + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].LineSize, + 0, + 0, +#ifdef GuiConst_DISPLAY_BUFFER_EASYGUI +#ifdef GuiLib_COLOR_UNIT_16 + (GuiConst_INT8U*)GuiLib_DisplayBuf.Bytes, +#else + (GuiConst_INT8U*)GuiLib_DisplayBuf, +#endif +#else // GuiConst_DISPLAY_BUFFER_EASYGUI + 0, +#endif // GuiConst_DISPLAY_BUFFER_EASYGUI + GuiConst_BYTES_PR_LINE, + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].X, + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Y, + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Width, + sgl.GraphicsLayerList[sgl.GlobalGraphicsLayerIndex].Height); + break; + } + } + } +#endif + break; + + case GuiLib_ITEM_GRAPHICSFILTER: +#ifdef GuiLib_LAYERS_SUPPORTED + if (sgl.DisplayWriting) + { + sgl.LayerOrigoX = 0; + sgl.LayerOrigoY = 0; + sgl.CoordOrigoX = sgl.DisplayOrigoX + sgl.LayerOrigoX; + sgl.CoordOrigoY = sgl.DisplayOrigoY + sgl.LayerOrigoY; + + SourceLayerIndexNo = IndexOfGraphicsLayer( + sgl.GraphicsFilterList[sgl.GlobalGraphicsFilterIndex].SourceLayerIndexNo); + DestLayerIndexNo = IndexOfGraphicsLayer( + sgl.GraphicsFilterList[sgl.GlobalGraphicsFilterIndex].DestLayerIndexNo); + if (SourceLayerIndexNo != DestLayerIndexNo) + { + if (SourceLayerIndexNo == GuiLib_GRAPHICS_LAYER_BASE) + { +#ifdef GuiConst_DISPLAY_BUFFER_EASYGUI +#ifdef GuiLib_COLOR_UNIT_16 + SourceAddress = &(GuiLib_DisplayBuf.Bytes[0][0]); +#else + #ifdef GuiConst_COLOR_DEPTH_2 + #ifdef GuiConst_BYTE_HORIZONTAL + #ifdef GuiConst_COLOR_PLANES_2 + SourceAddress = &(GuiLib_DisplayBuf[0][0][0]); + #else + SourceAddress = &(GuiLib_DisplayBuf[0][0]); + #endif + #else + #ifdef GuiConst_COLOR_PLANES_2 + SourceAddress = &(GuiLib_DisplayBuf[0][0][0]); + #else + SourceAddress = &(GuiLib_DisplayBuf[0][0]); + #endif + #endif + #else + SourceAddress = &(GuiLib_DisplayBuf[0][0]); + #endif +#endif // GuiLib_COLOR_UNIT_16 +#else // GuiConst_DISPLAY_BUFFER_EASYGUI + SourceAddress = 0; +#endif // GuiConst_DISPLAY_BUFFER_EASYGUI + SourceLineSize = GuiConst_BYTES_PR_LINE; + SourceX = 0; + SourceY = 0; + SourceWidth = GuiConst_DISPLAY_WIDTH_HW; + SourceHeight = GuiConst_DISPLAY_HEIGHT_HW; + } + else + { + SourceAddress = sgl.GraphicsLayerList[SourceLayerIndexNo].BaseAddress; + SourceLineSize = sgl.GraphicsLayerList[SourceLayerIndexNo].LineSize; + SourceX = sgl.GraphicsLayerList[SourceLayerIndexNo].X; + SourceY = sgl.GraphicsLayerList[SourceLayerIndexNo].Y; + SourceWidth = sgl.GraphicsLayerList[SourceLayerIndexNo].Width; + SourceHeight = sgl.GraphicsLayerList[SourceLayerIndexNo].Height; + } + if (DestLayerIndexNo == GuiLib_GRAPHICS_LAYER_BASE) + { +#ifdef GuiConst_DISPLAY_BUFFER_EASYGUI +#ifdef GuiLib_COLOR_UNIT_16 + DestAddress = &(GuiLib_DisplayBuf.Bytes[0][0]); +#else + #ifdef GuiConst_COLOR_DEPTH_2 + #ifdef GuiConst_BYTE_HORIZONTAL + #ifdef GuiConst_COLOR_PLANES_2 + DestAddress = &(GuiLib_DisplayBuf[0][0][0]); + #else + DestAddress = &(GuiLib_DisplayBuf[0][0]); + #endif + #else + #ifdef GuiConst_COLOR_PLANES_2 + DestAddress = &(GuiLib_DisplayBuf[0][0][0]); + #else + DestAddress = &(GuiLib_DisplayBuf[0][0]); + #endif + #endif + #else + DestAddress = &(GuiLib_DisplayBuf[0][0]); + #endif +#endif +#else // GuiConst_DISPLAY_BUFFER_EASYGUI + DestAddress = 0; +#endif // GuiConst_DISPLAY_BUFFER_EASYGUI + DestLineSize = GuiConst_BYTES_PR_LINE; + DestX = SourceX; + DestY = SourceY; + DestWidth = SourceWidth; + DestHeight = SourceHeight; + } + else + { + DestAddress = sgl.GraphicsLayerList[DestLayerIndexNo].BaseAddress; + DestLineSize = sgl.GraphicsLayerList[DestLayerIndexNo].LineSize; + DestX = sgl.GraphicsLayerList[DestLayerIndexNo].X; + DestY = sgl.GraphicsLayerList[DestLayerIndexNo].Y; + DestWidth = sgl.GraphicsLayerList[DestLayerIndexNo].Width; + DestHeight = sgl.GraphicsLayerList[DestLayerIndexNo].Height; + } + + if ((DestX <= SourceX) && (DestY <= SourceY) && + (DestX + DestWidth >= SourceX + SourceWidth) && + (DestY + DestHeight >= SourceY + SourceHeight) && + (sgl.GraphicsFilterList[sgl.GlobalGraphicsFilterIndex]. + GraphicsFilterFunc != 0)) + { + if (DestLayerIndexNo != GuiLib_GRAPHICS_LAYER_BASE) + { + DestX = SourceX - DestX; + DestY = SourceY - DestY; + } + if (SourceLayerIndexNo != GuiLib_GRAPHICS_LAYER_BASE) + { + SourceX = 0; + SourceY = 0; + } + + for (I = 0; I <= 9; I++) + { + if (sgl.GraphicsFilterList[sgl.GlobalGraphicsFilterIndex].ParVarType[I] == + GuiLib_VAR_NONE) + FilterPars[I] = + sgl.GraphicsFilterList[sgl.GlobalGraphicsFilterIndex].ParValueNum[I]; + else + FilterPars[I] = ReadVar( + sgl.GraphicsFilterList[sgl.GlobalGraphicsFilterIndex].ParVarPtr[I], + sgl.GraphicsFilterList[sgl.GlobalGraphicsFilterIndex].ParVarType[I]); + } + sgl.GraphicsFilterList[sgl.GlobalGraphicsFilterIndex].GraphicsFilterFunc( + DestAddress + DestY * DestLineSize + + DestX * GuiConst_PIXEL_BYTE_SIZE, + DestLineSize, + SourceAddress + SourceY * SourceLineSize + + SourceX * GuiConst_PIXEL_BYTE_SIZE, + SourceLineSize, + sgl.GraphicsLayerList[SourceLayerIndexNo].Width, + sgl.GraphicsLayerList[SourceLayerIndexNo].Height, + FilterPars); + } + + GraphicsLayer_Pop( + sgl.GraphicsFilterList[sgl.GlobalGraphicsFilterIndex].ContAtLayerIndexNo); + MarkDisplayBoxRepaint( + DestX, + DestY, + DestX + sgl.GraphicsLayerList[SourceLayerIndexNo].Width - 1, + DestY + sgl.GraphicsLayerList[SourceLayerIndexNo].Height - 1); + } + else + GraphicsLayer_Pop(GuiLib_GRAPHICS_LAYER_BASE); + + if (sgl.BaseLayerDrawing) + { + sgl.LayerOrigoX = 0; + sgl.LayerOrigoY = 0; + } + else + { + I = sgl.GraphicsLayerLifo[sgl.GraphicsLayerLifoCnt - 1]; + sgl.LayerOrigoX = -sgl.GraphicsLayerList[I].X; + sgl.LayerOrigoY = -sgl.GraphicsLayerList[I].Y; + } + sgl.CoordOrigoX = sgl.DisplayOrigoX + sgl.LayerOrigoX; + sgl.CoordOrigoY = sgl.DisplayOrigoY + sgl.LayerOrigoY; + + if (sgl.BaseLayerDrawing) + { +#ifdef GuiConst_CLIPPING_SUPPORT_ON + StartClipping(0); +#endif + } + else + { + I = sgl.GraphicsLayerLifo[sgl.GraphicsLayerLifoCnt - 1]; + sgl.CurItem.ClipRectX1 = 0; + sgl.CurItem.ClipRectY1 = 0; + sgl.CurItem.ClipRectX2 = sgl.GraphicsLayerList[I].Width - 1; + sgl.CurItem.ClipRectY2 = sgl.GraphicsLayerList[I].Height - 1; +#ifdef GuiConst_CLIPPING_SUPPORT_ON + StartClipping(1); +#endif + } + } +#endif + break; +#endif + } + + if (sgl.CurItem.UpdateType == GuiLib_UPDATE_ON_CHANGE) + if ((sgl.InitialDrawing) || (sgl.AutoRedrawUpdate == GuiLib_TRUE)) + AutoRedraw_UpdateOnChange(sgl.AutoRedrawSaveIndex); + + if (sgl.AutoRedrawSaveIndex >= 0) + AutoRedraw_UpdateDrawn(sgl.AutoRedrawSaveIndex, &sgl.CurItem); + +#ifdef GuiConst_TEXTBOX_FIELDS_ON + if (((sgl.CurItem.ItemType == GuiLib_ITEM_TEXTBLOCK) || + (sgl.CurItem.ItemType == GuiLib_ITEM_VARBLOCK)) && + (sgl.CurItem.CompPars.CompTextBox.ScrollIndex != 0xFF)) + { + found = AutoRedraw_GetTextBox( + sgl.CurItem.CompPars.CompTextBox.ScrollIndex, -1); + if (found == -1) + { + if (sgl.AutoRedrawSaveIndex >= 0) + AutoRedraw_SetAsTextBox(sgl.AutoRedrawSaveIndex); + else + AutoRedraw_InsertTextBox(&sgl.CurItem, 0, sgl.DisplayLevel); + } + + found = 0; + + for (N = 0; N < GuiConst_TEXTBOX_FIELDS_MAX; N++) + { + if (sgl.TextBoxScrollPositions[N].index == + sgl.CurItem.CompPars.CompTextBox.ScrollIndex) + { + found = 1; + break; + } + } + + if (found == 0) + { + for (N = 0; N < GuiConst_TEXTBOX_FIELDS_MAX; N++) + { + if (sgl.TextBoxScrollPositions[N].index == -1) + { + sgl.TextBoxScrollPositions[N].index = + sgl.CurItem.CompPars.CompTextBox.ScrollIndex; + sgl.TextBoxScrollPositions[N].pos = + sgl.CurItem.CompPars.CompTextBox.ScrollPos; + break; + } + } + } + } +#endif + +#ifdef GuiConst_CURSOR_SUPPORT_ON + if (sgl.InitialDrawing && IsCursorField) + sgl.CurItem.CursorFieldLevel--; + + if ((ColorInvert == GuiLib_COL_INVERT_IF_CURSOR) && FoundActiveCursorField) + sgl.SwapColors = 0; +#endif + +#ifdef GuiConst_REL_COORD_ORIGO_INUSE + if (!sgl.InitialDrawing) + { + sgl.CoordOrigoX = sgl.DisplayOrigoX + sgl.LayerOrigoX; + sgl.CoordOrigoY = sgl.DisplayOrigoY + sgl.LayerOrigoY; + } +#endif +#ifdef GuiConst_CLIPPING_SUPPORT_ON + if (!sgl.InitialDrawing && sgl.DisplayWriting) + GuiLib_ResetClipping(); +#endif +} +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ +static void ReadItem(GuiConst_INT16S LanguageIndex) +{ + GuiConst_INT16S X; + GuiConst_INT16S N; + GuiConst_INT16S I,J; + GuiConst_INTCOLOR TmpForeColor, TmpBackColor; + GuiConst_INTCOLOR PrefixLocate *ColVarPtr; + GuiConst_INT16U ColVarPtrIdx, PtrIdx; + GuiConst_INT16U TmpColIdx; + GuiConst_INT16U TmpForeColIdx; +#ifdef GuiConst_ADV_CONTROLS + GuiConst_INT16U TmpBackColIdx; +#endif + GuiConst_INT8U B1; + GuiConst_INT16U W1; +#ifdef GuiConst_REMOTE_TEXT_DATA + GuiConst_INT16U Ti; +#endif + GuiConst_INT16U TxtSize; +#ifndef GuiConst_REMOTE_TEXT_DATA + GuiConst_INT16U TxtSum1, TxtSum2; +#endif +#ifdef GuiConst_REMOTE_STRUCT_DATA + GuiConst_INT16U TxtReadSize; +#endif +#ifdef GuiConst_BLINK_SUPPORT_ON + GuiConst_INT8S BS2; +#endif +#ifdef GuiConst_ITEM_SCROLLBOX_INUSE + GuiConst_INT8U ScrollBoxIndex; +#ifndef GuiConst_SCROLLITEM_BAR_NONE +#ifdef GuiConst_REMOTE_BITMAP_DATA + GuiConst_INT8U * PixelDataPtr; + GuiConst_INT8U BitmapHeader[4]; +#else + GuiConst_INT8U PrefixRom * PixelDataPtr; +#endif // GuiConst_REMOTE_BITMAP_DATA +#endif // GuiConst_SCROLLITEM_BAR_NONE +#endif // GuiConst_ITEM_SCROLLBOX_INUSE +#ifdef GuiConst_ADV_COMPONENTS + GuiConst_INT8U L; +#endif +#ifdef GuiConst_ITEM_GRAPH_INUSE + GuiConst_INT8U GraphIndex; + GuiConst_INT8U Axis; + GuiConst_INT8U B; +#endif +#ifdef GuiConst_ITEM_GRAPHICS_LAYER_FILTER_INUSE + GuiConst_INT8U GraphicsLayerIndex; + GuiConst_INT8U GraphicsFilterIndex; +#endif +#ifdef GuiConst_ITEM_STRUCTCOND_INUSE + GuiConst_INT16U CondI; +#endif + GuiConst_INT8U ColMemoryFore; + GuiConst_INT8U ColMemoryBack; + + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_INUSE; + +#ifdef GuiConst_REL_COORD_ORIGO_INUSE + if (sgl.DisplayLevel == 0) + { + sgl.CurItem.CoordOrigoX = sgl.CoordOrigoX; + sgl.CurItem.CoordOrigoY = sgl.CoordOrigoY; + } +#endif + + sgl.CommonByte0 = GetItemByte(&sgl.ItemDataPtr); + sgl.CommonByte1 = GetItemByte(&sgl.ItemDataPtr); + sgl.CommonByte2 = GetItemByte(&sgl.ItemDataPtr); + sgl.CommonByte3 = GetItemByte(&sgl.ItemDataPtr); + sgl.CommonByte4 = GetItemByte(&sgl.ItemDataPtr); + sgl.CommonByte5 = GetItemByte(&sgl.ItemDataPtr); + sgl.CommonByte6 = GetItemByte(&sgl.ItemDataPtr); + sgl.CommonByte7 = GetItemByte(&sgl.ItemDataPtr); + + sgl.CurItem.ItemType = sgl.CommonByte0 & 0x3F; + if (sgl.CurItem.ItemType < 32) + sgl.ItemTypeBit1 = (GuiConst_INT32U)0x00000001 << (sgl.CurItem.ItemType & 0x1F); + else + sgl.ItemTypeBit1 = 0; + if (sgl.CurItem.ItemType >= 32) + sgl.ItemTypeBit2 = (GuiConst_INT32U)0x00000001 << (sgl.CurItem.ItemType - 32); + else + sgl.ItemTypeBit2 = 0; + + if (sgl.CommonByte7 & 0x20) + { + B1 = GetItemByte(&sgl.ItemDataPtr); + if (B1 & 0x01) + sgl.CurItem.ForeColorEnhance = GetItemWord(&sgl.ItemDataPtr); + if (B1 & 0x02) + sgl.CurItem.BackColorEnhance = GetItemWord(&sgl.ItemDataPtr); + if (B1 & 0x04) + sgl.CurItem.BarForeColorEnhance = GetItemWord(&sgl.ItemDataPtr); + if (B1 & 0x08) + sgl.CurItem.BarBackColorEnhance = GetItemWord(&sgl.ItemDataPtr); + } + else + { + sgl.CurItem.ForeColorEnhance = 0; + sgl.CurItem.BackColorEnhance = 0; + sgl.CurItem.BarForeColorEnhance = 0; + sgl.CurItem.BarBackColorEnhance = 0; + } + if (sgl.CommonByte7 & 0x40) + { + ColMemoryFore = GetItemByte(&sgl.ItemDataPtr); + ColMemoryBack = GetItemByte(&sgl.ItemDataPtr); + } + else + { + ColMemoryFore = 0; + ColMemoryBack = 0; + } + + TmpForeColor = sgl.CurItem.ForeColor; + TmpForeColIdx = sgl.CurItem.ForeColorIndex; + + TmpBackColor = sgl.CurItem.BackColor; +#ifdef GuiConst_ADV_CONTROLS + TmpBackColIdx = sgl.CurItem.BackColorIndex; +#endif + + if ((sgl.ItemTypeBit1 & (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_STRUCTURE + + GuiLib_ITEMBIT_STRUCTARRAY + + GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK + + GuiLib_ITEMBIT_SCROLLBOX + + GuiLib_ITEMBIT_GRAPH)) || + (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))) + { + B1 = ColMemoryFore & 0x03; + if (B1) + { + sgl.CurItem.ForeColor = sgl.Memory.C[B1-1]; + sgl.CurItem.ForeColorIndex = sgl.ColMemoryIndex[B1-1]; + } + else + { + TmpColIdx = sgl.CurItem.ForeColorIndex; + sgl.CurItem.ForeColorIndex = 0xFFFF; + switch (sgl.CommonByte3 & 0x07) + { + case GuiLib_COLOR_FORE: + sgl.CurItem.ForeColor = GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.CurItem.ForeColor = GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.CurItem.ForeColor = (GuiConst_INTCOLOR)GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.CurItem.ForeColor = TmpBackColor; + break; + case GuiLib_COLOR_TABLE: + sgl.CurItem.ForeColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + { + sgl.CurItem.ForeColor = GuiConst_PIXEL_ON; + } + else + { + sgl.CurItem.ForeColor = *ColVarPtr; + sgl.CurItem.ForeColorIndex = ColVarPtrIdx; + } + break; + default: + sgl.CurItem.ForeColorIndex = TmpColIdx; + break; + } + } + if (sgl.CurItem.ForeColorEnhance > 0) + sgl.CurItem.ForeColor = GuiLib_BrightenPixelColor( + sgl.CurItem.ForeColor, sgl.CurItem.ForeColorEnhance); + else if (sgl.CurItem.ForeColorEnhance < 0) + sgl.CurItem.ForeColor = GuiLib_DarkenPixelColor( + sgl.CurItem.ForeColor, -sgl.CurItem.ForeColorEnhance); + + B1 = ColMemoryFore & 0x30; + if (B1) + { + sgl.CurItem.BarForeColor = sgl.Memory.C[B1-1]; + sgl.CurItem.BarForeColorIndex = sgl.ColMemoryIndex[B1-1]; + } + else + { + TmpColIdx = sgl.CurItem.BarForeColorIndex; + sgl.CurItem.BarForeColorIndex = 0xFFFF; + switch ((sgl.CommonByte5 >> 1) & 0x07) + { + case GuiLib_COLOR_FORE: + sgl.CurItem.BarForeColor = GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.CurItem.BarForeColor = GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.CurItem.BarForeColor = (GuiConst_INTCOLOR)GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.CurItem.BarForeColor = sgl.CurItem.BackColor; + break; + case GuiLib_COLOR_TABLE: + sgl.CurItem.BarForeColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + { + sgl.CurItem.BarForeColor = GuiConst_PIXEL_ON; + } + else + { + sgl.CurItem.BarForeColor = *ColVarPtr; + sgl.CurItem.BarForeColorIndex = ColVarPtrIdx; + } + break; + default: + sgl.CurItem.BarForeColorIndex = TmpColIdx; + break; + } + } + if (sgl.CurItem.BarForeColorEnhance > 0) + sgl.CurItem.BarForeColor = GuiLib_BrightenPixelColor( + sgl.CurItem.BarForeColor, sgl.CurItem.BarForeColorEnhance); + else if (sgl.CurItem.BarForeColorEnhance < 0) + sgl.CurItem.BarForeColor = GuiLib_DarkenPixelColor( + sgl.CurItem.BarForeColor, -sgl.CurItem.BarForeColorEnhance); + } + + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_CLEARAREA + + GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK + + GuiLib_ITEMBIT_FRAME + + GuiLib_ITEMBIT_CIRCLE + + GuiLib_ITEMBIT_ELLIPSE + + GuiLib_ITEMBIT_STRUCTURE + + GuiLib_ITEMBIT_STRUCTARRAY + + GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK + + GuiLib_ITEMBIT_SCROLLBOX + + GuiLib_ITEMBIT_GRAPH + + GuiLib_ITEMBIT_GRAPHICSLAYER)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_ROUNDEDFRAME + + 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))) + { + B1 = ColMemoryBack & 0x03; + if (B1) + { + sgl.CurItem.BackColor = sgl.Memory.C[B1-1]; + sgl.CurItem.BackColorIndex = sgl.ColMemoryIndex[B1-1]; + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_TRANSPARENT; + } + else + { + TmpColIdx = sgl.CurItem.BackColorIndex; + sgl.CurItem.BackColorIndex = 0xFFFF; + switch ((sgl.CommonByte3 >> 3) & 0x07) + { + case GuiLib_COLOR_FORE: + sgl.CurItem.BackColor = GuiConst_PIXEL_ON; + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_TRANSPARENT; + break; + case GuiLib_COLOR_BACK: + sgl.CurItem.BackColor = GuiConst_PIXEL_OFF; + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_TRANSPARENT; + break; + case GuiLib_COLOR_OTHER: + sgl.CurItem.BackColor = GetItemColor(&sgl.ItemDataPtr); + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_TRANSPARENT; + break; + case GuiLib_COLOR_INVERT: + sgl.CurItem.BackColor = TmpForeColor; + sgl.CurItem.BackColorIndex = TmpForeColIdx; + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_TRANSPARENT; + break; + case GuiLib_COLOR_TRANSP: + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_TRANSPARENT; + break; + case GuiLib_COLOR_TABLE: + sgl.CurItem.BackColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_TRANSPARENT; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + { + sgl.CurItem.BackColor = GuiConst_PIXEL_ON; + } + else + { + sgl.CurItem.BackColor = *ColVarPtr; + sgl.CurItem.BackColorIndex = ColVarPtrIdx; + } + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_TRANSPARENT; + break; + default: + sgl.CurItem.BackColorIndex = TmpColIdx; + break; + } + } + if (sgl.CurItem.BackColorEnhance > 0) + sgl.CurItem.BackColor = GuiLib_BrightenPixelColor( + sgl.CurItem.BackColor, sgl.CurItem.BackColorEnhance); + else if (sgl.CurItem.BackColorEnhance < 0) + sgl.CurItem.BackColor = GuiLib_DarkenPixelColor( + sgl.CurItem.BackColor, -sgl.CurItem.BackColorEnhance); + + B1 = ColMemoryBack & 0x30; + if (B1) + { + sgl.CurItem.BarBackColor = sgl.Memory.C[B1-1]; + sgl.CurItem.BarBackColorIndex = sgl.ColMemoryIndex[B1-1]; + } + else + { + TmpColIdx = sgl.CurItem.BarBackColorIndex; + sgl.CurItem.BarBackColorIndex = 0xFFFF; + switch ((sgl.CommonByte5 >> 4) & 0x07) + { + case GuiLib_COLOR_FORE: + sgl.CurItem.BarBackColor = GuiConst_PIXEL_ON; + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_BARTRANSPARENT; + break; + case GuiLib_COLOR_BACK: + sgl.CurItem.BarBackColor = GuiConst_PIXEL_OFF; + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_BARTRANSPARENT; + break; + case GuiLib_COLOR_OTHER: + sgl.CurItem.BarBackColor = GetItemColor(&sgl.ItemDataPtr); + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_BARTRANSPARENT; + break; + case GuiLib_COLOR_INVERT: + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_BARTRANSPARENT; + sgl.CurItem.BarBackColor = sgl.CurItem.ForeColor; + break; + case GuiLib_COLOR_TRANSP: + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_BARTRANSPARENT; + break; + case GuiLib_COLOR_TABLE: + sgl.CurItem.BarBackColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_BARTRANSPARENT; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate*)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + { + sgl.CurItem.BarBackColor = GuiConst_PIXEL_ON; + } + else + { + sgl.CurItem.BarBackColor = *ColVarPtr; + sgl.CurItem.BarBackColorIndex = ColVarPtrIdx; + } + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_BARTRANSPARENT; + break; + default: + sgl.CurItem.BarBackColorIndex = TmpColIdx; + break; + } + } + if (sgl.CurItem.BarBackColorEnhance > 0) + sgl.CurItem.BarBackColor = GuiLib_BrightenPixelColor( + sgl.CurItem.BarBackColor, sgl.CurItem.BarBackColorEnhance); + else if (sgl.CurItem.BarBackColorEnhance < 0) + sgl.CurItem.BarBackColor = GuiLib_DarkenPixelColor( + sgl.CurItem.BarBackColor, -sgl.CurItem.BarBackColorEnhance); + } + +#ifdef GuiConst_COLOR_DEPTH_1 + #ifdef GuiConst_BITMAP_SUPPORT_ON + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_BITMAP + + GuiLib_ITEMBIT_BACKGROUND)) && + (sgl.CommonByte6 & 0x02)) + sgl.CurItem.CompPars.CompBitmap.TranspColor = (sgl.CommonByte6 >> 2) & 0x01; + #endif +#else + #ifdef GuiConst_BITMAP_SUPPORT_ON + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_BITMAP + + GuiLib_ITEMBIT_BACKGROUND)) && + (sgl.CommonByte6 & 0x02)) + { + sgl.CurItem.CompPars.CompBitmap.TranspColor = GetItemColor(&sgl.ItemDataPtr); + } + #endif +#endif + + B1 = ColMemoryFore & 0x0C; + if (B1) + { + sgl.Memory.C[B1 - 1] = sgl.CurItem.ForeColor; + sgl.ColMemoryIndex[B1 - 1] = sgl.CurItem.ForeColorIndex; + } + B1 = ColMemoryFore & 0xC0; + if (B1) + { + sgl.Memory.C[B1 - 1] = sgl.CurItem.BarForeColor; + sgl.ColMemoryIndex[B1 - 1] = sgl.CurItem.BarForeColorIndex; + } + B1 = ColMemoryBack & 0x0C; + if (B1) + { + sgl.Memory.C[B1 - 1] = sgl.CurItem.BackColor; + sgl.ColMemoryIndex[B1 - 1] = sgl.CurItem.BackColorIndex; + } + B1 = ColMemoryBack & 0xC0; + if (B1) + { + sgl.Memory.C[B1 - 1] = sgl.CurItem.BarBackColor; + sgl.ColMemoryIndex[B1 - 1] = sgl.CurItem.BarBackColorIndex; + } + + if (sgl.CommonByte0 & 0x40) + B1 = GetItemByte(&sgl.ItemDataPtr); + else + B1 = 0; + sgl.X1MemoryRead = B1 & 0x03; + sgl.X1MemoryWrite = (B1 >> 2) & 0x03; + sgl.Y1MemoryRead = (B1 >> 4) & 0x03; + sgl.Y1MemoryWrite = (B1 >> 6) & 0x03; + if (sgl.CommonByte0 & 0x80) + B1 = GetItemByte(&sgl.ItemDataPtr); + else + B1 = 0; + sgl.X2MemoryRead = B1 & 0x03; + sgl.X2MemoryWrite = (B1 >> 2) & 0x03; + sgl.Y2MemoryRead = (B1 >> 4) & 0x03; + sgl.Y2MemoryWrite = (B1 >> 6) & 0x03; + if (sgl.CommonByte7 & 0x01) + B1 = GetItemByte(&sgl.ItemDataPtr); + else + B1 = 0; + sgl.R1MemoryRead = B1 & 0x03; + sgl.R1MemoryWrite = (B1 >> 2) & 0x03; + sgl.R2MemoryRead = (B1 >> 4) & 0x03; + sgl.R2MemoryWrite = (B1 >> 6) & 0x03; + if (sgl.CommonByte7 & 0x80) + { + if (sgl.X1MemoryRead) + sgl.X1MemoryRead += GuiLib_MEMORY_CNT; + if (sgl.X1MemoryWrite) + sgl.X1MemoryWrite += GuiLib_MEMORY_CNT; + if (sgl.Y1MemoryRead) + sgl.Y1MemoryRead += GuiLib_MEMORY_CNT; + if (sgl.Y1MemoryWrite) + sgl.Y1MemoryWrite += GuiLib_MEMORY_CNT; + if (sgl.X2MemoryRead) + sgl.X2MemoryRead += GuiLib_MEMORY_CNT; + if (sgl.X2MemoryWrite) + sgl.X2MemoryWrite += GuiLib_MEMORY_CNT; + if (sgl.Y2MemoryRead) + sgl.Y2MemoryRead += GuiLib_MEMORY_CNT; + if (sgl.Y2MemoryWrite) + sgl.Y2MemoryWrite += GuiLib_MEMORY_CNT; + if (sgl.R1MemoryRead) + sgl.R1MemoryRead += GuiLib_MEMORY_CNT; + if (sgl.R1MemoryWrite) + sgl.R1MemoryWrite += GuiLib_MEMORY_CNT; + if (sgl.R2MemoryRead) + sgl.R2MemoryRead += GuiLib_MEMORY_CNT; + if (sgl.R2MemoryWrite) + sgl.R2MemoryWrite += GuiLib_MEMORY_CNT; + } + + if (sgl.CommonByte6 & 0x01) + B1 = GetItemByte(&sgl.ItemDataPtr); + else + B1 = 0; + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK + + GuiLib_ITEMBIT_STRUCTURE + + GuiLib_ITEMBIT_STRUCTARRAY + + GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_STRUCTCOND))) + sgl.CurItem.TextPar[0].BackBorderPixels = B1; + else + sgl.CurItem.TextPar[0].BackBorderPixels = 0; + + if (sgl.CommonByte6 & 0x08) + { + N = GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.TextPar[0].BackBoxSizeY1 = GetItemByte(&sgl.ItemDataPtr); + sgl.CurItem.TextPar[0].BackBoxSizeY2 = GetItemByte(&sgl.ItemDataPtr); + } + else + N = 0; + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_STRUCTURE + + GuiLib_ITEMBIT_STRUCTARRAY + + GuiLib_ITEMBIT_VAR)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_STRUCTCOND))) + sgl.CurItem.TextPar[0].BackBoxSizeX = N; + else + sgl.CurItem.TextPar[0].BackBoxSizeX = 0; +#ifdef GuiConst_ITEM_SCROLLBOX_INUSE + if (sgl.ItemTypeBit1 & GuiLib_ITEMBIT_SCROLLBOX) + { + if (sgl.NextScrollLineReading) + if (sgl.CommonByte6 & 0x08) + { + sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].LineSizeX = + sgl.CurItem.TextPar[0].BackBoxSizeX; + sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].LineSizeY = + sgl.CurItem.TextPar[0].BackBoxSizeY1; + sgl.ScrollBoxesAry[sgl.GlobalScrollBoxIndex].LineSizeY2 = + sgl.CurItem.TextPar[0].BackBoxSizeY2; + } + } +#endif + + sgl.X1Mode = sgl.CommonByte1 & 0x03; + sgl.Y1Mode = (sgl.CommonByte1 >> 2) & 0x03; + sgl.X2Mode = (sgl.CommonByte1 >> 4) & 0x03; + sgl.Y2Mode = (sgl.CommonByte1 >> 6) & 0x03; + sgl.R1Mode = (sgl.CommonByte7 >> 1) & 0x03; + sgl.R2Mode = (sgl.CommonByte7 >> 3) & 0x03; + + if (sgl.CommonByte2 & 0x01) + sgl.ItemX1 = GetItemWord(&sgl.ItemDataPtr); + else + sgl.ItemX1 = 0; + if (sgl.CommonByte2 & 0x02) + sgl.ItemY1 = GetItemWord(&sgl.ItemDataPtr); + else + sgl.ItemY1 = 0; + if (sgl.CommonByte2 & 0x04) + sgl.ItemX2 = GetItemWord(&sgl.ItemDataPtr); + else + sgl.ItemX2 = 0; + if (sgl.CommonByte2 & 0x08) + sgl.ItemY2 = GetItemWord(&sgl.ItemDataPtr); + else + sgl.ItemY2 = 0; + if (sgl.CommonByte6 & 0x10) + sgl.ItemR1 = GetItemWord(&sgl.ItemDataPtr); + else + sgl.ItemR1 = 0; + if (sgl.CommonByte6 & 0x20) + sgl.ItemR2 = GetItemWord(&sgl.ItemDataPtr); + else + sgl.ItemR2 = 0; + + if (sgl.CommonByte2 & 0x10) + { + sgl.X1VarIdx = GetItemWord(&sgl.ItemDataPtr); + if (sgl.X1VarIdx >= GuiStruct_VarPtrCnt) + sgl.X1VarIdx = 0; + } + if (sgl.CommonByte2 & 0x20) + { + sgl.Y1VarIdx = GetItemWord(&sgl.ItemDataPtr); + if (sgl.Y1VarIdx >= GuiStruct_VarPtrCnt) + sgl.Y1VarIdx = 0; + } + if (sgl.CommonByte2 & 0x40) + { + sgl.X2VarIdx = GetItemWord(&sgl.ItemDataPtr); + if (sgl.X2VarIdx >= GuiStruct_VarPtrCnt) + sgl.X2VarIdx = 0; + } + if (sgl.CommonByte2 & 0x80) + { + sgl.Y2VarIdx = GetItemWord(&sgl.ItemDataPtr); + if (sgl.Y2VarIdx >= GuiStruct_VarPtrCnt) + sgl.Y2VarIdx = 0; + } + if (sgl.CommonByte6 & 0x40) + { + sgl.R1VarIdx = GetItemWord(&sgl.ItemDataPtr); + if (sgl.R1VarIdx >= GuiStruct_VarPtrCnt) + sgl.R1VarIdx = 0; + } + if (sgl.CommonByte6 & 0x80) + { + sgl.R2VarIdx = GetItemWord(&sgl.ItemDataPtr); + if (sgl.R2VarIdx >= GuiStruct_VarPtrCnt) + sgl.R2VarIdx = 0; + } + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_CLEARAREA + + GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK + + 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))) + { + B1 = (sgl.CommonByte3 >> 6) & 0x03; + if (B1 != GuiLib_ALIGN_NOCHANGE) + sgl.CurItem.TextPar[0].Alignment = B1; + } + + B1 = sgl.CommonByte4 & 0x03; + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK + + GuiLib_ITEMBIT_STRUCTURE + + GuiLib_ITEMBIT_STRUCTARRAY + + GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_EDITBOX + + GuiLib_ITEMBIT_MEMO + + GuiLib_ITEMBIT_LISTBOX + + GuiLib_ITEMBIT_COMBOBOX + + GuiLib_ITEMBIT_PROGRESSBAR + + GuiLib_ITEMBIT_STRUCTCOND))) + { + if (B1 != GuiLib_PS_NOCHANGE) + sgl.CurItem.TextPar[0].Ps = B1; + } + + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK + + GuiLib_ITEMBIT_STRUCTURE + + GuiLib_ITEMBIT_STRUCTARRAY + + GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_EDITBOX + + GuiLib_ITEMBIT_MEMO + + GuiLib_ITEMBIT_LISTBOX + + GuiLib_ITEMBIT_COMBOBOX + + GuiLib_ITEMBIT_PROGRESSBAR + + GuiLib_ITEMBIT_STRUCTCOND))) + { + if (sgl.CommonByte4 & 0x10) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_UNDERLINE; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_UNDERLINE; + } + else if (sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_LINE + + GuiLib_ITEMBIT_CIRCLE)) + { + if (sgl.CommonByte4 & 0x10) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_PATTERNEDLINE; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_PATTERNEDLINE; + } + + if (sgl.CommonByte4 & 0x20) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_AUTOREDRAWFIELD; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_AUTOREDRAWFIELD; + +#ifdef GuiConst_CURSOR_SUPPORT_ON + if (sgl.CommonByte4 & 0x40) + sgl.CurItem.CursorFieldNo = GetItemByte(&sgl.ItemDataPtr); + else + sgl.CurItem.CursorFieldNo = -1; +#endif + +#ifdef GuiConst_BLINK_SUPPORT_ON + if (sgl.CommonByte5 & 0x01) + BS2 = GetItemByte(&sgl.ItemDataPtr); + else + BS2 = -1; + if (sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK + + GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK)) + sgl.CurItem.BlinkFieldNo = BS2; + else + sgl.CurItem.BlinkFieldNo = -1; +#endif + + if (sgl.CommonByte4 & 0x80) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_TRANSLATION; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_TRANSLATION; + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK + + GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_BUTTON))) + { + if (sgl.CommonByte5 & 0x80) + B1 = GetItemByte(&sgl.ItemDataPtr); + else + { + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK)) || + (sgl.CommonByte4 & 0x80)) + I = LanguageIndex; + else + I = 0; + B1 = ReadByte(GuiFont_LanguageTextDir[I]); + } + } + else + B1 = 0; + if (B1) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_REVERSEWRITING; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_REVERSEWRITING; + + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_LINE)) && + (sgl.CurItem.TextPar[0].BitFlags & GuiLib_BITFLAG_PATTERNEDLINE)) + sgl.CurItem.LinePattern = GetItemByte(&sgl.ItemDataPtr); + +#ifdef GuiConst_BLINK_SUPPORT_ON + if (sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK + + GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK)) + { + if (sgl.CommonByte5 & 0x01) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_BLINKTEXTFIELD; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_BLINKTEXTFIELD; + } +#endif + + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_BUTTON))) + sgl.CurItem.TextCnt = GetItemByte(&sgl.ItemDataPtr); + else + sgl.CurItem.TextCnt = 1; + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK + + GuiLib_ITEMBIT_STRUCTURE + + GuiLib_ITEMBIT_STRUCTARRAY + + GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK + + GuiLib_ITEMBIT_SCROLLBOX + + GuiLib_ITEMBIT_GRAPH)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_BUTTON + + GuiLib_ITEMBIT_EDITBOX + + GuiLib_ITEMBIT_LISTBOX + + GuiLib_ITEMBIT_COMBOBOX + + GuiLib_ITEMBIT_PROGRESSBAR + + GuiLib_ITEMBIT_STRUCTCOND))) + { + if (sgl.CurItem.ItemType == GuiLib_ITEM_BUTTON) + J = 3; + else + J = 1; + for (I = 0; I < J; I++) + { + B1 = GetItemByte(&sgl.ItemDataPtr); + if (B1 != 0xFF) + sgl.CurItem.TextPar[I].FontIndex = B1 + 1; + } + } + + if (sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXTBLOCK + + GuiLib_ITEMBIT_VARBLOCK)) + { +#ifdef GuiConst_TEXTBOX_FIELDS_ON + sgl.CurItem.CompPars.CompTextBox.ScrollPos = 0; + sgl.CurItem.CompPars.CompTextBox.ScrollIndex = GetItemByte(&sgl.ItemDataPtr); +#else + B1 = GetItemByte(&sgl.ItemDataPtr); +#endif + } + + sgl.CurItem.UpdateType = GuiLib_AUTOREDRAW_MODE; + + if (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_CHECKBOX + + GuiLib_ITEMBIT_RADIOBUTTON + + GuiLib_ITEMBIT_BUTTON + + GuiLib_ITEMBIT_EDITBOX + + GuiLib_ITEMBIT_LISTBOX + + GuiLib_ITEMBIT_COMBOBOX + + GuiLib_ITEMBIT_PROGRESSBAR)) + { + PtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (PtrIdx >= GuiStruct_VarPtrCnt) + PtrIdx = 0; + + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_AUTOREDRAWFIELD; + sgl.CurItem.UpdateType = GuiLib_UPDATE_ON_CHANGE; + sgl.CurItem.VarPtr = (void PrefixLocate *)ReadWord(GuiStruct_VarPtrList[PtrIdx]); + sgl.CurItem.VarType = ReadByte(GuiStruct_VarTypeList[PtrIdx]); + } + + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_STRUCTARRAY + + GuiLib_ITEMBIT_VAR + + GuiLib_ITEMBIT_VARBLOCK)) || + (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_STRUCTCOND)) + { + PtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (PtrIdx >= GuiStruct_VarPtrCnt) + PtrIdx = 0; + + sgl.CurItem.UpdateType = GuiLib_AUTOREDRAW_MODE; + sgl.CurItem.VarPtr = (void PrefixLocate *)ReadWord(GuiStruct_VarPtrList[PtrIdx]); + sgl.CurItem.VarType = ReadByte(GuiStruct_VarTypeList[PtrIdx]); + + } + +#ifdef GuiConst_AUTOREDRAW_ON_CHANGE + if ((sgl.CommonByte4 & 0x20) && + ((sgl.ItemTypeBit1 & (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)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_ROUNDEDFRAME + + GuiLib_ITEMBIT_ROUNDEDBLOCK + + GuiLib_ITEMBIT_QUARTERCIRCLE + + GuiLib_ITEMBIT_QUARTERELLIPSE)))) + { + PtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (PtrIdx >= GuiStruct_VarPtrCnt) + PtrIdx = 0; + + sgl.CurItem.UpdateType = GuiLib_AUTOREDRAW_MODE; + sgl.CurItem.VarPtr = (void PrefixLocate *)ReadWord(GuiStruct_VarPtrList[PtrIdx]); + sgl.CurItem.VarType = ReadByte(GuiStruct_VarTypeList[PtrIdx]); + } +#endif + + if (sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_FRAME + + GuiLib_ITEMBIT_CIRCLE + + GuiLib_ITEMBIT_ELLIPSE)) + { + sgl.CurItem.FrameThickness = GetItemByte(&sgl.ItemDataPtr); + } + + if (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_QUARTERCIRCLE + + GuiLib_ITEMBIT_QUARTERELLIPSE)) + { + sgl.CurItem.FrameThickness = GetItemByte(&sgl.ItemDataPtr) % 4; + } + + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_STRUCTARRAY)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_STRUCTCOND))) + sgl.CurItem.CompPars.StructCall.IndexCount = GetItemWord(&sgl.ItemDataPtr); + +#ifdef GuiConst_ITEM_STRUCTCOND_INUSE + if (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_STRUCTCOND) + { + for (CondI = 0; CondI < sgl.CurItem.CompPars.StructCall.IndexCount; CondI++) + { + sgl.CurItem.CompPars.StructCall.IndexFirst[CondI] = GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.StructCall.IndexLast[CondI] = GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.StructCall.CallIndex[CondI] = GetItemWord(&sgl.ItemDataPtr); + } + } +#endif + + if (sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_ACTIVEAREA + + GuiLib_ITEMBIT_CLIPRECT)) + { + B1 = GetItemByte(&sgl.ItemDataPtr); + if (B1 & 0x01) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_CLIPPING; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_CLIPPING; + if (B1 & 0x02) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_ACTIVEAREARELCOORD; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_ACTIVEAREARELCOORD; + } + + if (sgl.ItemTypeBit1 & GuiLib_ITEMBIT_FORMATTER) + { + sgl.CurItem.FormatFormat = GetItemByte(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + if (B1 & 0x01) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_FORMATSHOWSIGN; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_FORMATSHOWSIGN; + if (B1 & 0x02) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_FORMATZEROPADDING; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_FORMATZEROPADDING; + sgl.CurItem.FormatAlignment = (B1 >> 2) & 0x03; + if (B1 & 0x10) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_FORMATTRAILINGZEROS; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_FORMATTRAILINGZEROS; + if (B1 & 0x20) + sgl.CurItem.TextPar[0].BitFlags |= GuiLib_BITFLAG_FORMATTHOUSANDSSEP; + else + sgl.CurItem.TextPar[0].BitFlags &= ~GuiLib_BITFLAG_FORMATTHOUSANDSSEP; + sgl.CurItem.FormatFieldWidth = GetItemByte(&sgl.ItemDataPtr); + sgl.CurItem.FormatDecimals = GetItemByte(&sgl.ItemDataPtr); + } + + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_STRUCTURE + + GuiLib_ITEMBIT_STRUCTARRAY + + GuiLib_ITEMBIT_BITMAP + + GuiLib_ITEMBIT_BACKGROUND)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_STRUCTCOND))) + sgl.CurItem.StructToCallIndex = GetItemWord(&sgl.ItemDataPtr); + +#ifdef GuiConst_ITEM_TEXTBLOCK_INUSE + if (sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXTBLOCK + + GuiLib_ITEMBIT_VARBLOCK)) + { + sgl.CurItem.CompPars.CompTextBox.HorzAlignment = GetItemByte(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompTextBox.VertAlignment = GetItemByte(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompTextBox.LineDist = GetItemByte(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompTextBox.LineDistRelToFont = GetItemByte(&sgl.ItemDataPtr); + } +#endif + +#ifdef GuiConst_ITEM_TOUCHAREA_INUSE + if (sgl.ItemTypeBit1 & GuiLib_ITEMBIT_TOUCHAREA) + sgl.CurItem.CompPars.CompTouch.AreaNo = GetItemWord(&sgl.ItemDataPtr); +#endif + + if (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_POSCALLBACK) + sgl.CurItem.PosCallbackNo = GetItemWord(&sgl.ItemDataPtr); + +#ifdef GuiConst_ITEM_SCROLLBOX_INUSE + if (sgl.ItemTypeBit1 & GuiLib_ITEMBIT_SCROLLBOX) + { + ScrollBoxIndex = GetItemByte(&sgl.ItemDataPtr); + sgl.GlobalScrollBoxIndex = ScrollBoxIndex; + sgl.ScrollBoxesAry[ScrollBoxIndex].InUse = GuiLib_SCROLL_STRUCTURE_READ; + sgl.ScrollBoxesAry[ScrollBoxIndex].ScrollBoxType = GetItemByte(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].MakeUpStructIndex = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].ScrollVisibleLines = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].LineVerticalOffset = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].LineOffsetX = GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].LineOffsetY = GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].LineSizeX = GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].LineSizeY = GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].LineStructIndex = GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].LineStructOffsetX = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].LineStructOffsetY = + GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColorTransparent = 0; + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColorIndex = 0xFFFF; + + switch (B1) + { + case GuiLib_COLOR_NOCHANGE: + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColor = sgl.CurItem.ForeColor; + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColorIndex = sgl.CurItem.ForeColorIndex; + break; + case GuiLib_COLOR_FORE: + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColor = GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColor = GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColor = (GuiConst_INTCOLOR) + GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColor = TmpForeColor; + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColorIndex = TmpForeColIdx; + break; + case GuiLib_COLOR_TRANSP: + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColorTransparent = 1; + break; + case GuiLib_COLOR_TABLE: + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColor = GuiConst_PIXEL_ON; + else + { + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColor = *ColVarPtr; + sgl.ScrollBoxesAry[ScrollBoxIndex].LineColorIndex = ColVarPtrIdx; + } + break; + } + sgl.ScrollBoxesAry[ScrollBoxIndex].WrapMode = GetItemByte(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].ScrollStartOfs = GetItemByte(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].ScrollMode = GetItemByte(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].LineMarkerCount = GetItemByte(&sgl.ItemDataPtr); + for (L = 0; L < sgl.ScrollBoxesAry[ScrollBoxIndex].LineMarkerCount; L++) + { + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorIndex[L] = 0xFFFF; + B1 = GetItemByte(&sgl.ItemDataPtr); + switch (B1) + { + case GuiLib_COLOR_NOCHANGE: + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColor[L] = sgl.CurItem.BackColor; + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorIndex[L] = sgl.CurItem.BackColorIndex; + break; + case GuiLib_COLOR_FORE: + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColor[L] = GuiConst_PIXEL_ON; + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorTransparent[L] = 0; + break; + case GuiLib_COLOR_BACK: + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColor[L] = GuiConst_PIXEL_OFF; + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorTransparent[L] = 0; + break; + case GuiLib_COLOR_OTHER: + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColor[L] = (GuiConst_INTCOLOR) + GetItemColor(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorTransparent[L] = 0; + break; + case GuiLib_COLOR_INVERT: + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColor[L] = TmpForeColor; + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorIndex[L] = TmpForeColIdx; + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorTransparent[L] = 0; + break; + case GuiLib_COLOR_TRANSP: + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorTransparent[L] = 1; + break; + case GuiLib_COLOR_TABLE: + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColor[L] = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorTransparent[L] = 0; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColor[L] = GuiConst_PIXEL_ON; + else + { + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColor[L] = *ColVarPtr; + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorIndex[L] = ColVarPtrIdx; + } + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerColorTransparent[L] = 0; + break; + } + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerStructIndex[L] = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerDrawingOrder[L] = + GetItemByte(&sgl.ItemDataPtr); + if (L || (sgl.ScrollBoxesAry[ScrollBoxIndex].ScrollBoxType)) + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerSize[L] = 0; + else + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerSize[L] = 1; + sgl.ScrollBoxesAry[ScrollBoxIndex].MarkerStartLine[L] = 0; + } + + sgl.ScrollBoxesAry[ScrollBoxIndex].BarType = GetItemByte(&sgl.ItemDataPtr); +#ifndef GuiConst_SCROLLITEM_BAR_NONE + if (sgl.ScrollBoxesAry[ScrollBoxIndex].BarType != GuiLib_MARKER_NONE) + { + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMode = GetItemByte(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarPositionX = GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarPositionY = GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarSizeX = GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarSizeY = GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarStructIndex = GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + switch (B1 & 0x07) + { + case GuiLib_COLOR_NOCHANGE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarForeColor = sgl.CurItem.ForeColor; + break; + case GuiLib_COLOR_FORE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarForeColor = GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarForeColor = GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarForeColor = (GuiConst_INTCOLOR) + GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarForeColor = TmpBackColor; + break; + case GuiLib_COLOR_TRANSP: + break; + case GuiLib_COLOR_TABLE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarForeColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.ScrollBoxesAry[ScrollBoxIndex].BarForeColor = GuiConst_PIXEL_ON; + else + sgl.ScrollBoxesAry[ScrollBoxIndex].BarForeColor = *ColVarPtr; + break; + } + sgl.ScrollBoxesAry[ScrollBoxIndex].BarTransparent = 0; + switch ((B1 & 0x38) >> 3) + { + case GuiLib_COLOR_NOCHANGE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarBackColor = sgl.CurItem.ForeColor; + break; + case GuiLib_COLOR_FORE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarBackColor = GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarBackColor = GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarBackColor = (GuiConst_INTCOLOR) + GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarBackColor = TmpForeColor; + break; + case GuiLib_COLOR_TRANSP: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarTransparent = 1; + break; + case GuiLib_COLOR_TABLE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarBackColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.ScrollBoxesAry[ScrollBoxIndex].BarBackColor = GuiConst_PIXEL_ON; + else + sgl.ScrollBoxesAry[ScrollBoxIndex].BarBackColor = *ColVarPtr; + break; + } + sgl.ScrollBoxesAry[ScrollBoxIndex].BarThickness = GetItemByte(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerLeftOffset = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerRightOffset = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerTopOffset = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBottomOffset = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarIconPtr = + (GuiConst_TEXT PrefixRom *)sgl.ItemDataPtr; +#ifdef GuiConst_CHARMODE_ANSI + sgl.ItemDataPtr++; +#else + sgl.ItemDataPtr += 2; +#endif + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerIconFont = + GetItemByte(&sgl.ItemDataPtr) + 1; + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerIconOffsetX = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerIconOffsetY = + GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + switch (B1 & 0x07) + { + case GuiLib_COLOR_NOCHANGE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerForeColor = sgl.CurItem.ForeColor; + break; + case GuiLib_COLOR_FORE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerForeColor = GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerForeColor = + GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerForeColor = + (GuiConst_INTCOLOR)GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerForeColor = TmpBackColor; + break; + case GuiLib_COLOR_TRANSP: + break; + case GuiLib_COLOR_TABLE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerForeColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerForeColor = GuiConst_PIXEL_ON; + else + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerForeColor = *ColVarPtr; + break; + } + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerTransparent = 0; + switch ((B1 & 0x38) >> 3) + { + case GuiLib_COLOR_NOCHANGE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBackColor = sgl.CurItem.BackColor; + break; + + case GuiLib_COLOR_FORE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBackColor = GuiConst_PIXEL_ON; + break; + + case GuiLib_COLOR_BACK: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBackColor = + GuiConst_PIXEL_OFF; + break; + + case GuiLib_COLOR_OTHER: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBackColor = + (GuiConst_INTCOLOR)GetItemColor(&sgl.ItemDataPtr); + break; + + case GuiLib_COLOR_INVERT: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBackColor = TmpForeColor; + break; + + case GuiLib_COLOR_TRANSP: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerTransparent = 1; + break; + case GuiLib_COLOR_TABLE: + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBackColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBackColor = GuiConst_PIXEL_ON; + else + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBackColor = *ColVarPtr; + break; + } + if (sgl.ScrollBoxesAry[ScrollBoxIndex].BarType == GuiLib_MARKER_BITMAP) + { + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBitmapIndex = + GetItemWord(&sgl.ItemDataPtr); +#ifdef GuiConst_REMOTE_BITMAP_DATA + GuiLib_RemoteDataReadBlock( + (GuiConst_INT32U PrefixRom)GuiStruct_BitmapPtrList[ + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBitmapIndex], 4, + BitmapHeader); + PixelDataPtr = &BitmapHeader[0] + 2; +#else + PixelDataPtr = (GuiConst_INT8U PrefixRom *)ReadWord(GuiStruct_BitmapPtrList[ + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBitmapIndex]) + 2; +#endif + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBitmapHeight = + (GuiConst_INT16S)*PixelDataPtr; + PixelDataPtr++; + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBitmapHeight += + 256*(GuiConst_INT16S)*PixelDataPtr; + B1 = GetItemByte(&sgl.ItemDataPtr); +#ifdef GuiConst_BITMAP_SUPPORT_ON + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBitmapIsTransparent = + (B1 & 0x01); + if (sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBitmapIsTransparent) +#ifdef GuiConst_COLOR_DEPTH_1 + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBitmapTranspColor = + (B1 >> 1) & 0x01; +#else + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBitmapTranspColor = + GetItemColor(&sgl.ItemDataPtr); +#endif +#else + sgl.ScrollBoxesAry[ScrollBoxIndex].BarMarkerBitmapIsTransparent = 0; +#endif + } + } +#endif + + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorType = GetItemByte(&sgl.ItemDataPtr); +#ifndef GuiConst_SCROLLITEM_INDICATOR_NONE + if (sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorType != GuiLib_INDICATOR_NONE) + { + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMode = GetItemByte(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorPositionX = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorPositionY = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorSizeX = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorSizeY = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorStructIndex = + GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + switch (B1 & 0x07) + { + case GuiLib_COLOR_NOCHANGE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorForeColor = sgl.CurItem.ForeColor; + break; + case GuiLib_COLOR_FORE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorForeColor = GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorForeColor = + GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorForeColor = + (GuiConst_INTCOLOR)GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorForeColor = TmpBackColor; + break; + case GuiLib_COLOR_TRANSP: + break; + case GuiLib_COLOR_TABLE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorForeColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorForeColor = GuiConst_PIXEL_ON; + else + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorForeColor = *ColVarPtr; + break; + } + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorTransparent = 0; + switch ((B1 & 0x38) >> 3) + { + case GuiLib_COLOR_NOCHANGE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorBackColor = sgl.CurItem.BackColor; + break; + case GuiLib_COLOR_FORE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorBackColor = GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorBackColor = + GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorBackColor = + (GuiConst_INTCOLOR)GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorBackColor = TmpForeColor; + break; + case GuiLib_COLOR_TRANSP: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorTransparent = 1; + break; + case GuiLib_COLOR_TABLE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorBackColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorBackColor = GuiConst_PIXEL_ON; + else + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorBackColor = *ColVarPtr; + break; + } + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorThickness = + GetItemByte(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerLeftOffset = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerRightOffset = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerTopOffset = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBottomOffset = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorIconPtr = + (GuiConst_TEXT PrefixRom *)sgl.ItemDataPtr; +#ifdef GuiConst_CHARMODE_ANSI + sgl.ItemDataPtr++; +#else + sgl.ItemDataPtr += 2; +#endif + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerIconFont = + GetItemByte(&sgl.ItemDataPtr) + 1; + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerIconOffsetX = + GetItemWord(&sgl.ItemDataPtr); + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerIconOffsetY = + GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + switch (B1 & 0x07) + { + case GuiLib_COLOR_NOCHANGE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerForeColor = + sgl.CurItem.ForeColor; + break; + case GuiLib_COLOR_FORE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerForeColor = + GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerForeColor = + GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerForeColor = + (GuiConst_INTCOLOR)GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerForeColor = + TmpBackColor; + break; + case GuiLib_COLOR_TRANSP: + break; + case GuiLib_COLOR_TABLE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerForeColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerForeColor = GuiConst_PIXEL_ON; + else + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerForeColor = *ColVarPtr; + break; + } + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerTransparent = 0; + switch ((B1 & 0x38) >> 3) + { + case GuiLib_COLOR_NOCHANGE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBackColor = + sgl.CurItem.BackColor; + break; + case GuiLib_COLOR_FORE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBackColor = + GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBackColor = + GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBackColor = + (GuiConst_INTCOLOR)GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBackColor = + TmpForeColor; + break; + case GuiLib_COLOR_TRANSP: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerTransparent = 1; + break; + case GuiLib_COLOR_TABLE: + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBackColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBackColor = GuiConst_PIXEL_ON; + else + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBackColor = *ColVarPtr; + break; + } + if (sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorType == GuiLib_MARKER_BITMAP) + { + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBitmapIndex = + GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); +#ifdef GuiConst_BITMAP_SUPPORT_ON + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBitmapIsTransparent = + (B1 & 0x01); + if (sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBitmapIsTransparent) +#ifdef GuiConst_COLOR_DEPTH_1 + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBitmapTranspColor = + (B1 >> 1) & 0x01; +#else + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBitmapTranspColor = + GetItemColor(&sgl.ItemDataPtr); +#endif +#else + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorMarkerBitmapIsTransparent = 0; +#endif + } + sgl.ScrollBoxesAry[ScrollBoxIndex].IndicatorLine = -1; + } +#endif + } +#endif + +#ifdef GuiConst_ITEM_GRAPH_INUSE + if (sgl.ItemTypeBit1 & GuiLib_ITEMBIT_GRAPH) + { + GraphIndex = GetItemByte(&sgl.ItemDataPtr); + sgl.GlobalGraphIndex = GraphIndex; + + sgl.GraphAry[GraphIndex].InUse = GuiLib_GRAPH_STRUCTURE_USED; + sgl.GraphAry[GraphIndex].OriginOffsetX = GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].OriginOffsetY = GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].ForeColor = sgl.CurItem.ForeColor; + sgl.GraphAry[GraphIndex].BackColor = sgl.CurItem.BackColor; + + for (Axis = GuiLib_GRAPHAXIS_X; Axis <= GuiLib_GRAPHAXIS_Y; Axis++) + { + sgl.GraphAry[GraphIndex].GraphAxesCnt[Axis] = GetItemByte(&sgl.ItemDataPtr); + for (L = 0; L < sgl.GraphAry[GraphIndex].GraphAxesCnt[Axis]; L++) + { + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].BitFlags = 0; + B = GetItemByte(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].Visible = 1; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].Line = B & 0x01; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].LineBetweenAxes = (B >> 7) & 0x01; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].LineNegative = (B >> 1) & 0x01; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].Arrow = (B >> 2) & 0x01; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].TicksMajor = (B >> 3) & 0x01; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].TicksMinor = (B >> 4) & 0x01; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].Numbers = (B >> 5) & 0x01; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersAtOrigo = (B >> 6) & 0x01; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].Offset = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].ArrowLength = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].ArrowWidth = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].TicksMajorLength = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].TicksMajorWidth = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].TicksMinorLength = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].TicksMinorWidth = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersMinValue = + GetItemLong(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersMinValueOrg = + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersMinValue; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersMaxValue = + GetItemLong(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersMaxValueOrg = + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersMaxValue; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersStepMajor = + GetItemLong(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersStepMinor = + GetItemLong(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersOffset = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].NumbersAtEnd = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].FormatFieldWidth = + GetItemByte(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].FormatDecimals = + GetItemByte(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].FormatAlignment = + GetItemByte(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].FormatFormat = + GetItemByte(&sgl.ItemDataPtr); + B = GetItemByte(&sgl.ItemDataPtr); + if (B & 0x01) + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].BitFlags |= GuiLib_BITFLAG_FORMATSHOWSIGN; + else + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].BitFlags &= ~GuiLib_BITFLAG_FORMATSHOWSIGN; + if (B & 0x02) + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].BitFlags |= GuiLib_BITFLAG_FORMATZEROPADDING; + else + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].BitFlags &= ~GuiLib_BITFLAG_FORMATZEROPADDING; + if (B & 0x04) + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].BitFlags |= GuiLib_BITFLAG_FORMATTRAILINGZEROS; + else + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].BitFlags &= ~GuiLib_BITFLAG_FORMATTRAILINGZEROS; + if (B & 0x08) + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].BitFlags |= GuiLib_BITFLAG_FORMATTHOUSANDSSEP; + else + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].BitFlags &= ~GuiLib_BITFLAG_FORMATTHOUSANDSSEP; + sgl.GraphAry[GraphIndex].GraphAxes[L][Axis].Scale = 10000; + } + } + + sgl.GraphAry[GraphIndex].GraphDataSetCnt = GetItemByte(&sgl.ItemDataPtr); + for (L = 0; L < sgl.GraphAry[GraphIndex].GraphDataSetCnt; L++) + { + sgl.GraphAry[GraphIndex].GraphDataSets[L].DataSize = 0; + sgl.GraphAry[GraphIndex].GraphDataSets[L].DataFirst = 0; + sgl.GraphAry[GraphIndex].GraphDataSets[L].DataCount = 0; + sgl.GraphAry[GraphIndex].GraphDataSets[L].AxisIndexX = 0; + sgl.GraphAry[GraphIndex].GraphDataSets[L].AxisIndexY = 0; + sgl.GraphAry[GraphIndex].GraphDataSets[L].Visible = 1; + sgl.GraphAry[GraphIndex].GraphDataSets[L].Representation = + GetItemByte(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphDataSets[L].Width = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphAry[GraphIndex].GraphDataSets[L].Thickness = + GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + switch (B1 & 0x07) + { + case GuiLib_COLOR_NOCHANGE: + sgl.GraphAry[GraphIndex].GraphDataSets[L].ForeColor = sgl.CurItem.ForeColor; + break; + case GuiLib_COLOR_FORE: + sgl.GraphAry[GraphIndex].GraphDataSets[L].ForeColor = GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.GraphAry[GraphIndex].GraphDataSets[L].ForeColor = GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.GraphAry[GraphIndex].GraphDataSets[L].ForeColor = (GuiConst_INTCOLOR) + GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.GraphAry[GraphIndex].GraphDataSets[L].ForeColor = TmpBackColor; + break; + case GuiLib_COLOR_TRANSP: + break; + case GuiLib_COLOR_TABLE: + sgl.GraphAry[GraphIndex].GraphDataSets[L].ForeColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.GraphAry[GraphIndex].GraphDataSets[L].ForeColor = GuiConst_PIXEL_ON; + else + sgl.GraphAry[GraphIndex].GraphDataSets[L].ForeColor = *ColVarPtr; + break; + } + sgl.GraphAry[GraphIndex].GraphDataSets[L].BackColorTransparent = 0; + switch ((B1 & 0x38) >> 3) + { + case GuiLib_COLOR_NOCHANGE: + sgl.GraphAry[GraphIndex].GraphDataSets[L].BackColor = sgl.CurItem.BackColor; + break; + case GuiLib_COLOR_FORE: + sgl.GraphAry[GraphIndex].GraphDataSets[L].BackColor = GuiConst_PIXEL_ON; + break; + case GuiLib_COLOR_BACK: + sgl.GraphAry[GraphIndex].GraphDataSets[L].BackColor = GuiConst_PIXEL_OFF; + break; + case GuiLib_COLOR_OTHER: + sgl.GraphAry[GraphIndex].GraphDataSets[L].BackColor = (GuiConst_INTCOLOR) + GetItemColor(&sgl.ItemDataPtr); + break; + case GuiLib_COLOR_INVERT: + sgl.GraphAry[GraphIndex].GraphDataSets[L].BackColor = TmpForeColor; + break; + case GuiLib_COLOR_TRANSP: + sgl.GraphAry[GraphIndex].GraphDataSets[L].BackColorTransparent = 1; + break; + case GuiLib_COLOR_TABLE: + sgl.GraphAry[GraphIndex].GraphDataSets[L].BackColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + sgl.GraphAry[GraphIndex].GraphDataSets[L].BackColor = GuiConst_PIXEL_ON; + else + sgl.GraphAry[GraphIndex].GraphDataSets[L].BackColor = *ColVarPtr; + break; + } + } + } +#endif + +#ifdef GuiConst_ITEM_GRAPHICS_LAYER_FILTER_INUSE + if (sgl.ItemTypeBit1 & GuiLib_ITEMBIT_GRAPHICSLAYER) + { + GraphicsLayerIndex = GetItemByte(&sgl.ItemDataPtr); + sgl.GlobalGraphicsLayerIndex = GraphicsLayerIndex; + + sgl.GraphicsLayerList[GraphicsLayerIndex].InUse = GuiLib_GRAPHICS_LAYER_USED; + sgl.GraphicsLayerList[GraphicsLayerIndex].SizeMode = GetItemByte(&sgl.ItemDataPtr); + sgl.GraphicsLayerList[GraphicsLayerIndex].InitMode = GetItemByte(&sgl.ItemDataPtr); + } + + if (sgl.ItemTypeBit1 & GuiLib_ITEMBIT_GRAPHICSFILTER) + { + GraphicsFilterIndex = GetItemByte(&sgl.ItemDataPtr); + sgl.GlobalGraphicsFilterIndex = GraphicsFilterIndex; + + sgl.GraphicsFilterList[GraphicsFilterIndex].InUse = GuiLib_GRAPHICS_FILTER_USED; + sgl.GraphicsFilterList[GraphicsFilterIndex].SourceLayerIndexNo = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphicsFilterList[GraphicsFilterIndex].DestLayerIndexNo = + GetItemWord(&sgl.ItemDataPtr); + sgl.GraphicsFilterList[GraphicsFilterIndex].ContAtLayerIndexNo = + GetItemWord(&sgl.ItemDataPtr); + for (I = 0; I <= 9; I++) + { + B1 = GetItemByte(&sgl.ItemDataPtr); + if (B1 == 0) + { + sgl.GraphicsFilterList[GraphicsFilterIndex].ParVarType[I] = GuiLib_VAR_NONE; + sgl.GraphicsFilterList[GraphicsFilterIndex].ParVarPtr[I] = 0; + sgl.GraphicsFilterList[GraphicsFilterIndex].ParValueNum[I] = + GetItemLong(&sgl.ItemDataPtr); + } + else + { + PtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (PtrIdx >= GuiStruct_VarPtrCnt) + PtrIdx = 0; + + sgl.GraphicsFilterList[GraphicsFilterIndex].ParVarType[I] = + ReadByte(GuiStruct_VarTypeList[PtrIdx]); + sgl.GraphicsFilterList[GraphicsFilterIndex].ParVarPtr[I] = + (void*)ReadWord(GuiStruct_VarPtrList[PtrIdx]); + sgl.GraphicsFilterList[GraphicsFilterIndex].ParValueNum[I] = 0; + } + } + } +#endif + +#ifdef GuiConst_ITEM_CHECKBOX_INUSE + if (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_CHECKBOX) + { + sgl.CurItem.CompPars.CompCheckBox.Style = GetItemByte(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompCheckBox.Size = GetItemByte(&sgl.ItemDataPtr); + switch (sgl.CurItem.CompPars.CompCheckBox.Style) + { + case GuiLib_CHECKBOX_ICON: + sgl.CurItem.CompPars.CompCheckBox.IconPtr = + (GuiConst_TEXT PrefixRom *)sgl.ItemDataPtr; + #ifdef GuiConst_CHARMODE_ANSI + sgl.ItemDataPtr++; + #else + sgl.ItemDataPtr += 2; + #endif + sgl.CurItem.CompPars.CompCheckBox.IconFont = GetItemByte(&sgl.ItemDataPtr) + 1; + sgl.CurItem.CompPars.CompCheckBox.IconOffsetX = GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompCheckBox.IconOffsetY = GetItemWord(&sgl.ItemDataPtr); + break; + case GuiLib_CHECKBOX_BITMAP: + sgl.CurItem.CompPars.CompCheckBox.BitmapIndex = GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + #ifdef GuiConst_BITMAP_SUPPORT_ON + sgl.CurItem.CompPars.CompCheckBox.BitmapIsTransparent = (B1 & 0x01); + if (sgl.CurItem.CompPars.CompCheckBox.BitmapIsTransparent) + #ifdef GuiConst_COLOR_DEPTH_1 + sgl.CurItem.CompPars.CompCheckBox.BitmapTranspColor = (B1 >> 1) & 0x01; + #else + sgl.CurItem.CompPars.CompCheckBox.BitmapTranspColor = + GetItemColor(&sgl.ItemDataPtr); + #endif + #else + sgl.CurItem.CompPars.CompCheckBox.BitmapIsTransparent = 0; + #endif + break; + } + + sgl.CurItem.CompPars.CompCheckBox.MarkStyle = GetItemByte(&sgl.ItemDataPtr); + if (sgl.CurItem.CompPars.CompCheckBox.MarkStyle != GuiLib_CHECKBOX_MARK_BITMAP) + { + B1 = GetItemByte(&sgl.ItemDataPtr); + switch (B1 & 0x07) + { + case GuiLib_COLOR_NOCHANGE: + sgl.CurItem.CompPars.CompCheckBox.MarkColor = sgl.CurItem.ForeColor; + sgl.CurItem.CompPars.CompCheckBox.MarkColorIndex = sgl.CurItem.ForeColorIndex; + break; + case GuiLib_COLOR_FORE: + sgl.CurItem.CompPars.CompCheckBox.MarkColor = GuiConst_PIXEL_ON; + sgl.CurItem.CompPars.CompCheckBox.MarkColorIndex = 0xFFFF; + break; + case GuiLib_COLOR_BACK: + sgl.CurItem.CompPars.CompCheckBox.MarkColor = GuiConst_PIXEL_OFF; + sgl.CurItem.CompPars.CompCheckBox.MarkColorIndex = 0xFFFF; + break; + case GuiLib_COLOR_OTHER: + sgl.CurItem.CompPars.CompCheckBox.MarkColor = (GuiConst_INTCOLOR) + GetItemColor(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompCheckBox.MarkColorIndex = 0xFFFF; + break; + case GuiLib_COLOR_INVERT: + sgl.CurItem.CompPars.CompCheckBox.MarkColor = TmpBackColor; + sgl.CurItem.CompPars.CompCheckBox.MarkColorIndex = TmpBackColIdx; + break; + case GuiLib_COLOR_TRANSP: + break; + case GuiLib_COLOR_TABLE: + sgl.CurItem.CompPars.CompCheckBox.MarkColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + sgl.CurItem.CompPars.CompCheckBox.MarkColorIndex = 0xFFFF; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR*)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + { + sgl.CurItem.CompPars.CompCheckBox.MarkColor = GuiConst_PIXEL_ON; + sgl.CurItem.CompPars.CompCheckBox.MarkColorIndex = 0xFFFF; + } + else + { + sgl.CurItem.CompPars.CompCheckBox.MarkColor = *ColVarPtr; + sgl.CurItem.CompPars.CompCheckBox.MarkColorIndex = ColVarPtrIdx; + } + break; + } + } + switch (sgl.CurItem.CompPars.CompCheckBox.MarkStyle) + { + case GuiLib_CHECKBOX_MARK_ICON: + sgl.CurItem.CompPars.CompCheckBox.MarkIconPtr = + (GuiConst_TEXT PrefixRom *)sgl.ItemDataPtr; + #ifdef GuiConst_CHARMODE_ANSI + sgl.ItemDataPtr++; + #else + sgl.ItemDataPtr += 2; + #endif + sgl.CurItem.CompPars.CompCheckBox.MarkIconFont = + GetItemByte(&sgl.ItemDataPtr) + 1; + sgl.CurItem.CompPars.CompCheckBox.MarkOffsetX = + GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompCheckBox.MarkOffsetY = + GetItemWord(&sgl.ItemDataPtr); + break; + case GuiLib_CHECKBOX_MARK_BITMAP: + sgl.CurItem.CompPars.CompCheckBox.MarkBitmapIndex = + GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + #ifdef GuiConst_BITMAP_SUPPORT_ON + sgl.CurItem.CompPars.CompCheckBox.MarkBitmapIsTransparent = (B1 & 0x01); + if (sgl.CurItem.CompPars.CompCheckBox.MarkBitmapIsTransparent) + #ifdef GuiConst_COLOR_DEPTH_1 + sgl.CurItem.CompPars.CompCheckBox.MarkBitmapTranspColor = + (B1 >> 1) & 0x01; + #else + sgl.CurItem.CompPars.CompCheckBox.MarkBitmapTranspColor = + GetItemColor(&sgl.ItemDataPtr); + #endif + #else + sgl.CurItem.CompPars.CompCheckBox.MarkBitmapIsTransparent = 0; + #endif + sgl.CurItem.CompPars.CompCheckBox.MarkOffsetX = + GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompCheckBox.MarkOffsetY = + GetItemWord(&sgl.ItemDataPtr); + break; + } + } +#endif + +#ifdef GuiConst_ITEM_RADIOBUTTON_INUSE + if (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_RADIOBUTTON) + { + sgl.CurItem.CompPars.CompRadioButton.Style = GetItemByte(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompRadioButton.Size = GetItemByte(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompRadioButton.Count = GetItemByte(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompRadioButton.InterDistance = GetItemWord(&sgl.ItemDataPtr); + switch (sgl.CurItem.CompPars.CompRadioButton.Style) + { + case GuiLib_RADIOBUTTON_ICON: + sgl.CurItem.CompPars.CompRadioButton.IconPtr = + (GuiConst_TEXT PrefixRom *)sgl.ItemDataPtr; + #ifdef GuiConst_CHARMODE_ANSI + sgl.ItemDataPtr++; + #else + sgl.ItemDataPtr += 2; + #endif + sgl.CurItem.CompPars.CompRadioButton.IconFont = GetItemByte(&sgl.ItemDataPtr) + 1; + sgl.CurItem.CompPars.CompRadioButton.IconOffsetX = GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompRadioButton.IconOffsetY = GetItemWord(&sgl.ItemDataPtr); + break; + case GuiLib_RADIOBUTTON_BITMAP: + sgl.CurItem.CompPars.CompRadioButton.BitmapIndex = GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + #ifdef GuiConst_BITMAP_SUPPORT_ON + sgl.CurItem.CompPars.CompRadioButton.BitmapIsTransparent = (B1 & 0x01); + if (sgl.CurItem.CompPars.CompRadioButton.BitmapIsTransparent) + #ifdef GuiConst_COLOR_DEPTH_1 + sgl.CurItem.CompPars.CompRadioButton.BitmapTranspColor = (B1 >> 1) & 0x01; + #else + sgl.CurItem.CompPars.CompRadioButton.BitmapTranspColor = + GetItemColor(&sgl.ItemDataPtr); + #endif + #else + sgl.CurItem.CompPars.CompRadioButton.BitmapIsTransparent = 0; + #endif + break; + } + + sgl.CurItem.CompPars.CompRadioButton.MarkStyle = GetItemByte(&sgl.ItemDataPtr); + if (sgl.CurItem.CompPars.CompRadioButton.MarkStyle != GuiLib_RADIOBUTTON_MARK_BITMAP) + { + B1 = GetItemByte(&sgl.ItemDataPtr); + switch (B1 & 0x07) + { + case GuiLib_COLOR_NOCHANGE: + sgl.CurItem.CompPars.CompRadioButton.MarkColor = sgl.CurItem.ForeColor; + sgl.CurItem.CompPars.CompRadioButton.MarkColorIndex = sgl.CurItem.ForeColorIndex; + break; + case GuiLib_COLOR_FORE: + sgl.CurItem.CompPars.CompRadioButton.MarkColor = GuiConst_PIXEL_ON; + sgl.CurItem.CompPars.CompRadioButton.MarkColorIndex = 0xFFFF; + break; + case GuiLib_COLOR_BACK: + sgl.CurItem.CompPars.CompRadioButton.MarkColor = GuiConst_PIXEL_OFF; + sgl.CurItem.CompPars.CompRadioButton.MarkColorIndex = 0xFFFF; + break; + case GuiLib_COLOR_OTHER: + sgl.CurItem.CompPars.CompRadioButton.MarkColor = (GuiConst_INTCOLOR) + GetItemColor(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompRadioButton.MarkColorIndex = 0xFFFF; + break; + case GuiLib_COLOR_INVERT: + sgl.CurItem.CompPars.CompRadioButton.MarkColor = TmpBackColor; + sgl.CurItem.CompPars.CompRadioButton.MarkColorIndex = TmpBackColIdx; + break; + case GuiLib_COLOR_TRANSP: + break; + case GuiLib_COLOR_TABLE: + sgl.CurItem.CompPars.CompRadioButton.MarkColor = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + sgl.CurItem.CompPars.CompRadioButton.MarkColorIndex = 0xFFFF; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + { + sgl.CurItem.CompPars.CompRadioButton.MarkColor = GuiConst_PIXEL_ON; + sgl.CurItem.CompPars.CompRadioButton.MarkColorIndex = 0xFFFF; + } + else + { + sgl.CurItem.CompPars.CompRadioButton.MarkColor = *ColVarPtr; + sgl.CurItem.CompPars.CompRadioButton.MarkColorIndex = ColVarPtrIdx; + } + break; + } + } + switch (sgl.CurItem.CompPars.CompRadioButton.MarkStyle) + { + case GuiLib_RADIOBUTTON_MARK_ICON: + sgl.CurItem.CompPars.CompRadioButton.MarkIconPtr = + (GuiConst_TEXT PrefixRom *)sgl.ItemDataPtr; + #ifdef GuiConst_CHARMODE_ANSI + sgl.ItemDataPtr++; + #else + sgl.ItemDataPtr += 2; + #endif + sgl.CurItem.CompPars.CompRadioButton.MarkIconFont = + GetItemByte(&sgl.ItemDataPtr) + 1; + sgl.CurItem.CompPars.CompRadioButton.MarkOffsetX = + GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompRadioButton.MarkOffsetY = + GetItemWord(&sgl.ItemDataPtr); + break; + case GuiLib_RADIOBUTTON_MARK_BITMAP: + sgl.CurItem.CompPars.CompRadioButton.MarkBitmapIndex = + GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + #ifdef GuiConst_BITMAP_SUPPORT_ON + sgl.CurItem.CompPars.CompRadioButton.MarkBitmapIsTransparent = (B1 & 0x01); + if (sgl.CurItem.CompPars.CompRadioButton.MarkBitmapIsTransparent) + #ifdef GuiConst_COLOR_DEPTH_1 + sgl.CurItem.CompPars.CompRadioButton.MarkBitmapTranspColor = + (B1 >> 1) & 0x01; + #else + sgl.CurItem.CompPars.CompRadioButton.MarkBitmapTranspColor = + GetItemColor(&sgl.ItemDataPtr); + #endif + #else + sgl.CurItem.CompPars.CompRadioButton.MarkBitmapIsTransparent = 0; + #endif + sgl.CurItem.CompPars.CompRadioButton.MarkOffsetX = + GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompRadioButton.MarkOffsetY = + GetItemWord(&sgl.ItemDataPtr); + break; + } + } +#endif + +#ifdef GuiConst_ITEM_BUTTON_INUSE + if (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_BUTTON) + { + sgl.CurItem.CompPars.CompButton.Layout = GetItemByte(&sgl.ItemDataPtr); + + sgl.CurItem.CompPars.CompButton.BodyStyle = GetItemByte(&sgl.ItemDataPtr); + if ((sgl.CurItem.CompPars.CompButton.BodyStyle == GuiLib_BUTTON_BODY_ICON) || + (sgl.CurItem.CompPars.CompButton.BodyStyle == GuiLib_BUTTON_BODY_BITMAP)) + { + sgl.CurItem.CompPars.CompButton.BodyLikeUp = GetItemByte(&sgl.ItemDataPtr); + for (I = 0; I < 3; I++) + if ((I == 0) || + ((I == 1) && !(sgl.CurItem.CompPars.CompButton.BodyLikeUp & 0x01)) || + ((I == 2) && !(sgl.CurItem.CompPars.CompButton.BodyLikeUp & 0x02))) + { + switch (sgl.CurItem.CompPars.CompButton.BodyStyle) + { + case GuiLib_BUTTON_BODY_ICON: + sgl.CurItem.CompPars.CompButton.BodyIconPtr[I] = + (GuiConst_TEXT PrefixRom *)sgl.ItemDataPtr; + #ifdef GuiConst_CHARMODE_ANSI + sgl.ItemDataPtr++; + #else + sgl.ItemDataPtr += 2; + #endif + sgl.CurItem.CompPars.CompButton.BodyIconFont[I] = + GetItemByte(&sgl.ItemDataPtr) + 1; + sgl.CurItem.CompPars.CompButton.BodyIconOffsetX[I] = + GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompButton.BodyIconOffsetY[I] = + GetItemWord(&sgl.ItemDataPtr); + break; + case GuiLib_BUTTON_BODY_BITMAP: + sgl.CurItem.CompPars.CompButton.BodyBitmapIndex[I] = + GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + #ifdef GuiConst_BITMAP_SUPPORT_ON + sgl.CurItem.CompPars.CompButton.BodyBitmapIsTransparent[I] = + (B1 & 0x01); + if (sgl.CurItem.CompPars.CompButton.BodyBitmapIsTransparent[I]) + #ifdef GuiConst_COLOR_DEPTH_1 + sgl.CurItem.CompPars.CompButton.BodyBitmapTranspColor[I] = + (B1 >> 1) & 0x01; + #else + sgl.CurItem.CompPars.CompButton.BodyBitmapTranspColor[I] = + GetItemColor(&sgl.ItemDataPtr); + #endif + #else + sgl.CurItem.CompPars.CompButton.BodyBitmapIsTransparent[I] = 0; + #endif + break; + } + } + else + { + switch (sgl.CurItem.CompPars.CompButton.BodyStyle) + { + case GuiLib_BUTTON_BODY_ICON: + sgl.CurItem.CompPars.CompButton.BodyIconPtr[I] = + sgl.CurItem.CompPars.CompButton.BodyIconPtr[0]; + sgl.CurItem.CompPars.CompButton.BodyIconFont[I] = + sgl.CurItem.CompPars.CompButton.BodyIconFont[0]; + sgl.CurItem.CompPars.CompButton.BodyIconOffsetX[I] = + sgl.CurItem.CompPars.CompButton.BodyIconOffsetX[0]; + sgl.CurItem.CompPars.CompButton.BodyIconOffsetY[I] = + sgl.CurItem.CompPars.CompButton.BodyIconOffsetY[0]; + break; + case GuiLib_BUTTON_BODY_BITMAP: + sgl.CurItem.CompPars.CompButton.BodyBitmapIndex[I] = + sgl.CurItem.CompPars.CompButton.BodyBitmapIndex[0]; + sgl.CurItem.CompPars.CompButton.BodyBitmapIsTransparent[I] = + sgl.CurItem.CompPars.CompButton.BodyBitmapIsTransparent[0]; + sgl.CurItem.CompPars.CompButton.BodyBitmapTranspColor[I] = + sgl.CurItem.CompPars.CompButton.BodyBitmapTranspColor[0]; + break; + } + } + } + + if (sgl.CurItem.CompPars.CompButton.Layout != GuiLib_BUTTON_LAYOUT_GLYPH) + { + sgl.CurItem.CompPars.CompButton.TextLikeUp = GetItemByte(&sgl.ItemDataPtr); + for (I = 0; I < 3; I++) + { + if ((I == 0) || + ((I == 1) && !(sgl.CurItem.CompPars.CompButton.TextLikeUp & 0x04)) || + ((I == 2) && !(sgl.CurItem.CompPars.CompButton.TextLikeUp & 0x08))) + { + B1 = GetItemByte(&sgl.ItemDataPtr); + switch (B1 & 0x07) + { + case GuiLib_COLOR_NOCHANGE: + sgl.CurItem.CompPars.CompButton.TextColor[I] = sgl.CurItem.ForeColor; + sgl.CurItem.CompPars.CompButton.TextColorIndex[I] = sgl.CurItem.ForeColorIndex; + break; + case GuiLib_COLOR_FORE: + sgl.CurItem.CompPars.CompButton.TextColor[I] = GuiConst_PIXEL_ON; + sgl.CurItem.CompPars.CompButton.TextColorIndex[I] = 0xFFFF; + break; + case GuiLib_COLOR_BACK: + sgl.CurItem.CompPars.CompButton.TextColor[I] = GuiConst_PIXEL_OFF; + sgl.CurItem.CompPars.CompButton.TextColorIndex[I] = 0xFFFF; + break; + case GuiLib_COLOR_OTHER: + sgl.CurItem.CompPars.CompButton.TextColor[I] = + (GuiConst_INTCOLOR)GetItemColor(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompButton.TextColorIndex[I] = 0xFFFF; + break; + case GuiLib_COLOR_INVERT: + sgl.CurItem.CompPars.CompButton.TextColor[I] = TmpBackColor; + sgl.CurItem.CompPars.CompButton.TextColorIndex[I] = TmpBackColIdx; + break; + case GuiLib_COLOR_TRANSP: + break; + case GuiLib_COLOR_TABLE: + sgl.CurItem.CompPars.CompButton.TextColor[I] = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + sgl.CurItem.CompPars.CompButton.TextColorIndex[I] = 0xFFFF; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR*)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + { + sgl.CurItem.CompPars.CompButton.TextColor[I] = GuiConst_PIXEL_ON; + sgl.CurItem.CompPars.CompButton.TextColorIndex[I] = 0xFFFF; + } + else + { + sgl.CurItem.CompPars.CompButton.TextColor[I] = *ColVarPtr; + sgl.CurItem.CompPars.CompButton.TextColorIndex[I] = ColVarPtrIdx; + } + break; + } + + B1 = GetItemByte(&sgl.ItemDataPtr); + if (B1 & 0x04) + sgl.CurItem.TextPar[I].BitFlags |= GuiLib_BITFLAG_UNDERLINE; + else + sgl.CurItem.TextPar[I].BitFlags &= ~GuiLib_BITFLAG_UNDERLINE; + B1 = B1 & 0x03; + if (B1 != GuiLib_PS_NOCHANGE) + sgl.CurItem.TextPar[I].Ps = B1; + } + else + { + sgl.CurItem.CompPars.CompButton.TextColor[I] = + sgl.CurItem.CompPars.CompButton.TextColor[0]; + sgl.CurItem.TextPar[I] = sgl.CurItem.TextPar[0]; + } + } + } + + if (sgl.CurItem.CompPars.CompButton.Layout != GuiLib_BUTTON_LAYOUT_TEXT) + { + sgl.CurItem.CompPars.CompButton.GlyphStyle = GetItemByte(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompButton.GlyphLikeUp = GetItemByte(&sgl.ItemDataPtr); + for (I = 0; I < 3; I++) + if ((I == 0) || + ((I == 1) && !(sgl.CurItem.CompPars.CompButton.GlyphLikeUp & 0x01)) || + ((I == 2) && !(sgl.CurItem.CompPars.CompButton.GlyphLikeUp & 0x02))) + { + switch (sgl.CurItem.CompPars.CompButton.GlyphStyle) + { + case GuiLib_BUTTON_GLYPH_ICON: + B1 = GetItemByte(&sgl.ItemDataPtr); + switch (B1 & 0x07) + { + case GuiLib_COLOR_NOCHANGE: + sgl.CurItem.CompPars.CompButton.GlyphIconColor[I] = sgl.CurItem.ForeColor; + sgl.CurItem.CompPars.CompButton.GlyphIconColorIndex[I] = sgl.CurItem.ForeColorIndex; + break; + case GuiLib_COLOR_FORE: + sgl.CurItem.CompPars.CompButton.GlyphIconColor[I] = GuiConst_PIXEL_ON; + sgl.CurItem.CompPars.CompButton.GlyphIconColorIndex[I] = 0xFFFF; + break; + case GuiLib_COLOR_BACK: + sgl.CurItem.CompPars.CompButton.GlyphIconColor[I] = GuiConst_PIXEL_OFF; + sgl.CurItem.CompPars.CompButton.GlyphIconColorIndex[I] = 0xFFFF; + break; + case GuiLib_COLOR_OTHER: + sgl.CurItem.CompPars.CompButton.GlyphIconColor[I] = + (GuiConst_INTCOLOR)GetItemColor(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompButton.GlyphIconColorIndex[I] = 0xFFFF; + break; + case GuiLib_COLOR_INVERT: + sgl.CurItem.CompPars.CompButton.GlyphIconColor[I] = TmpBackColor; + sgl.CurItem.CompPars.CompButton.GlyphIconColorIndex[I] = TmpBackColIdx; + break; + case GuiLib_COLOR_TRANSP: + break; + case GuiLib_COLOR_TABLE: + sgl.CurItem.CompPars.CompButton.GlyphIconColor[I] = + GuiStruct_ColorTable[GetItemByte(&sgl.ItemDataPtr)]; + sgl.CurItem.CompPars.CompButton.GlyphIconColorIndex[I] = 0xFFFF; + break; + case GuiLib_COLOR_VAR: + ColVarPtrIdx = GetItemWord(&sgl.ItemDataPtr); + if (ColVarPtrIdx >= GuiStruct_VarPtrCnt) + ColVarPtrIdx = 0; + ColVarPtr = (GuiConst_INTCOLOR*)ReadWord(GuiStruct_VarPtrList[ColVarPtrIdx]); + if (ColVarPtr == 0) + { + sgl.CurItem.CompPars.CompButton.GlyphIconColor[I] = GuiConst_PIXEL_ON; + sgl.CurItem.CompPars.CompButton.GlyphIconColorIndex[I] = 0xFFFF; + } + else + { + sgl.CurItem.CompPars.CompButton.GlyphIconColor[I] = *ColVarPtr; + sgl.CurItem.CompPars.CompButton.GlyphIconColorIndex[I] = ColVarPtrIdx; + } + break; + } + + sgl.CurItem.CompPars.CompButton.GlyphIconPtr[I] = + (GuiConst_TEXT PrefixRom *)sgl.ItemDataPtr; + #ifdef GuiConst_CHARMODE_ANSI + sgl.ItemDataPtr++; + #else + sgl.ItemDataPtr += 2; + #endif + sgl.CurItem.CompPars.CompButton.GlyphIconFont[I] = + GetItemByte(&sgl.ItemDataPtr) + 1; + sgl.CurItem.CompPars.CompButton.GlyphIconOffsetX[I] = + GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompButton.GlyphIconOffsetY[I] = + GetItemWord(&sgl.ItemDataPtr); + break; + case GuiLib_BUTTON_GLYPH_BITMAP: + sgl.CurItem.CompPars.CompButton.GlyphBitmapIndex[I] = + GetItemWord(&sgl.ItemDataPtr); + B1 = GetItemByte(&sgl.ItemDataPtr); + #ifdef GuiConst_BITMAP_SUPPORT_ON + sgl.CurItem.CompPars.CompButton.GlyphBitmapIsTransparent[I] = + (B1 & 0x01); + if (sgl.CurItem.CompPars.CompButton.GlyphBitmapIsTransparent[I]) + #ifdef GuiConst_COLOR_DEPTH_1 + sgl.CurItem.CompPars.CompButton.GlyphBitmapTranspColor[I] = + (B1 >> 1) & 0x01; + #else + sgl.CurItem.CompPars.CompButton.GlyphBitmapTranspColor[I] = + GetItemColor(&sgl.ItemDataPtr); + #endif + #else + sgl.CurItem.CompPars.CompButton.GlyphBitmapIsTransparent[I] = 0; + #endif + sgl.CurItem.CompPars.CompButton.GlyphBitmapOffsetX[I] = + GetItemWord(&sgl.ItemDataPtr); + sgl.CurItem.CompPars.CompButton.GlyphBitmapOffsetY[I] = + GetItemWord(&sgl.ItemDataPtr); + break; + } + } + else + { + switch (sgl.CurItem.CompPars.CompButton.GlyphStyle) + { + case GuiLib_BUTTON_GLYPH_ICON: + sgl.CurItem.CompPars.CompButton.GlyphIconColor[I] = + sgl.CurItem.CompPars.CompButton.GlyphIconColor[0]; + sgl.CurItem.CompPars.CompButton.GlyphIconPtr[I] = + sgl.CurItem.CompPars.CompButton.GlyphIconPtr[0]; + sgl.CurItem.CompPars.CompButton.GlyphIconFont[I] = + sgl.CurItem.CompPars.CompButton.GlyphIconFont[0]; + sgl.CurItem.CompPars.CompButton.GlyphIconOffsetX[I] = + sgl.CurItem.CompPars.CompButton.GlyphIconOffsetX[0]; + sgl.CurItem.CompPars.CompButton.GlyphIconOffsetY[I] = + sgl.CurItem.CompPars.CompButton.GlyphIconOffsetY[0]; + break; + case GuiLib_BUTTON_GLYPH_BITMAP: + sgl.CurItem.CompPars.CompButton.GlyphBitmapIndex[I] = + sgl.CurItem.CompPars.CompButton.GlyphBitmapIndex[0]; + sgl.CurItem.CompPars.CompButton.GlyphBitmapIsTransparent[I] = + sgl.CurItem.CompPars.CompButton.GlyphBitmapIsTransparent[0]; + sgl.CurItem.CompPars.CompButton.GlyphBitmapTranspColor[I] = + sgl.CurItem.CompPars.CompButton.GlyphBitmapTranspColor[0]; + sgl.CurItem.CompPars.CompButton.GlyphBitmapOffsetX[I] = + sgl.CurItem.CompPars.CompButton.GlyphBitmapOffsetX[0]; + sgl.CurItem.CompPars.CompButton.GlyphBitmapOffsetY[I] = + sgl.CurItem.CompPars.CompButton.GlyphBitmapOffsetY[0]; + break; + } + } + } + } +#endif + +#ifdef GuiConst_ITEM_PANEL_INUSE + if (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_PANEL) + { + sgl.CurItem.CompPars.CompPanel.Style = GetItemByte(&sgl.ItemDataPtr); + } +#endif + + if ((sgl.ItemTypeBit1 & (GuiLib_ITEMBIT_TEXT + + GuiLib_ITEMBIT_TEXTBLOCK)) || + (sgl.ItemTypeBit2 & (GuiLib_ITEMBIT_BUTTON))) + { + if (sgl.CommonByte4 & 0x80) + { +#ifdef GuiConst_LANGUAGE_ALL_ACTIVE + N = GuiConst_LANGUAGE_CNT; + W1 = LanguageIndex; +#else + N = GuiConst_LANGUAGE_ACTIVE_CNT; + W1 = ReadWord(GuiFont_LanguageIndex[LanguageIndex]); +#endif + } + else + { + N = 1; + W1 = 0; + } + + J = 0; + for (I = 0; I < sgl.CurItem.TextCnt; I++) + { +#ifndef GuiConst_REMOTE_TEXT_DATA + TxtSum1 = 0; + TxtSum2 = 0; +#endif + for (X = 0; X < N; X++) + { +#ifdef GuiConst_REMOTE_TEXT_DATA + Ti = GetItemWord(&sgl.ItemDataPtr); + if (X == W1) + { + sgl.CurItem.TextLength[J] = GetRemoteText(Ti); + sgl.CurItem.TextIndex[J] = Ti; + sgl.CurItem.TextPtr[J] = &sgl.GuiLib_RemoteTextBuffer[0]; + } +#else + TxtSize = GetItemByte(&sgl.ItemDataPtr); + if (TxtSize == 0xFF) + TxtSize = GetItemWord(&sgl.ItemDataPtr); + + if (X == W1) + { + sgl.CurItem.TextLength[J] = GuiLib_GET_MIN(TxtSize, GuiConst_MAX_TEXT_LEN); +#ifdef GuiConst_REMOTE_STRUCT_DATA + TxtReadSize = sgl.CurItem.TextLength[J] + 1; +#ifndef GuiConst_CHARMODE_ANSI + TxtReadSize *= 2; +#endif +#endif + } + + TxtSize++; +#ifndef GuiConst_CHARMODE_ANSI + TxtSize *= 2; +#endif + +#ifndef GuiConst_REMOTE_TEXT_DATA + if (X < W1) + TxtSum1 += TxtSize; + else + TxtSum2 += TxtSize; +#endif +#endif // GuiConst_REMOTE_TEXT_DATA + } + +#ifndef GuiConst_REMOTE_TEXT_DATA +#ifdef GuiConst_REMOTE_STRUCT_DATA + sgl.RemoteStructOffset += TxtSum1; + GuiLib_RemoteDataReadBlock( + sgl.RemoteStructOffset, + TxtReadSize, + (GuiConst_INT8U*)&sgl.GuiLib_RemoteStructText); + sgl.CurItem.TextOffset[J] = sgl.RemoteStructOffset; + sgl.CurItem.TextPtr[J] = (GuiConst_TEXT PrefixGeneric *)&sgl.GuiLib_RemoteStructText; + sgl.RemoteStructOffset += TxtSum2; +#else + sgl.ItemDataPtr += TxtSum1; + sgl.CurItem.TextPtr[J] = (GuiConst_TEXT PrefixGeneric *)(sgl.ItemDataPtr); + sgl.ItemDataPtr += TxtSum2; +#endif +#endif // GuiConst_REMOTE_TEXT_DATA + +#ifdef GuiConst_ITEM_BUTTON_INUSE + if ((sgl.ItemTypeBit2 & GuiLib_ITEMBIT_BUTTON) && + (((I == 0) && (sgl.CurItem.CompPars.CompButton.TextLikeUp & 0x01)) || + ((I == 1) && (sgl.CurItem.CompPars.CompButton.TextLikeUp & 0x02)))) + J++; +#endif + J++; + } + +#ifdef GuiConst_ITEM_BUTTON_INUSE + if (sgl.ItemTypeBit2 & GuiLib_ITEMBIT_BUTTON) + { + if (sgl.CurItem.CompPars.CompButton.TextLikeUp & 0x01) + { + sgl.CurItem.TextLength[1] = sgl.CurItem.TextLength[0]; + sgl.CurItem.TextPtr[1] = sgl.CurItem.TextPtr[0]; + +#ifdef GuiConst_REMOTE_TEXT_DATA + sgl.CurItem.TextIndex[1] = sgl.CurItem.TextIndex[0]; +#else +#ifdef GuiConst_REMOTE_STRUCT_DATA + sgl.CurItem.TextOffset[1] = sgl.CurItem.TextOffset[0]; +#endif +#endif + + } + if (sgl.CurItem.CompPars.CompButton.TextLikeUp & 0x02) + { + sgl.CurItem.TextLength[2] = sgl.CurItem.TextLength[0]; + sgl.CurItem.TextPtr[2] = sgl.CurItem.TextPtr[0]; + +#ifdef GuiConst_REMOTE_TEXT_DATA + sgl.CurItem.TextIndex[2] = sgl.CurItem.TextIndex[0]; +#else +#ifdef GuiConst_REMOTE_STRUCT_DATA + sgl.CurItem.TextOffset[2] = sgl.CurItem.TextOffset[0]; +#endif +#endif + } + } +#endif + } +} +//------------------------------------------------------------------------------ +static GuiConst_INT16S VarStrCmp( + GuiConst_INT8U PrefixLocate *S1, + GuiConst_INT8U PrefixLocate *S2) +{ + GuiConst_INT16S len = 0; + +#ifdef GuiConst_CHARMODE_ANSI + 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 ((len++) < GuiConst_AUTOREDRAW_MAX_VAR_SIZE); +#else + GuiConst_INT16U T1, T2, T3; + + do + { + T1 = *S1++; + T3 = *S1++; + T1 |= T3 << 8; + + T2 = *S2++; + T3 = *S2++; + T2 |= T3 << 8; + + if (T1 < T2) + return (-1); + else if (T1 > T2) + return (1); + else if (T1 == 0) + return (0); + } + while ((len++) < GuiConst_AUTOREDRAW_MAX_VAR_SIZE); +#endif + return (1); +} +//------------------------------------------------------------------------------ +void AutoRedraw_Init(void) +{ + GuiConst_INT16S I; + + for (I=0;I<GuiConst_MAX_DYNAMIC_ITEMS;I++) + { + sgl.AutoRedraw[I].Next = -1; + sgl.AutoRedraw[I].Prev = -1; + sgl.AutoRedraw[I].Valid = ITEM_NONE; + } + + sgl.AutoRedrawCount = 0; + sgl.AutoRedrawFirst = -1; + sgl.AutoRedrawLast = -1; + sgl.AutoRedrawCount = 0; + sgl.AutoRedrawParent = -1; + sgl.AutoRedrawUpdate = GuiLib_FALSE; + sgl.AutoRedrawInsertPoint = GuiConst_MAX_DYNAMIC_ITEMS; + sgl.AutoRedrawLatest = -1; + + return; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_Reset(void) +{ + sgl.AutoRedrawNext = sgl.AutoRedrawFirst; + + return sgl.AutoRedrawNext; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_GetNext(GuiConst_INT16S I) +{ + GuiConst_INT16S N, result; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + + result = -1; + + N = sgl.AutoRedraw[I].Next; + while ((N >= 0) && (N < GuiConst_MAX_DYNAMIC_ITEMS)) + { + if ((sgl.AutoRedraw[N].Valid & ITEM_AUTOREDRAW) == ITEM_AUTOREDRAW) + { + result = N; + break; + } + else if (sgl.AutoRedraw[N].Valid == ITEM_NONE) + break; + else + { + N = sgl.AutoRedraw[N].Next; + if ((N < 0) || (N >= GuiConst_MAX_DYNAMIC_ITEMS)) + break; + } + } + + return result; +} +//------------------------------------------------------------------------------ +GuiConst_INT8S AutoRedraw_ItemIsStruct(GuiConst_INT16S I) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return GuiLib_FALSE; + + if ((sgl.AutoRedraw[I].Valid & ITEM_AUTOREDRAW) == ITEM_AUTOREDRAW) + { + if ((sgl.AutoRedraw[I].Item.ItemType == GuiLib_ITEM_STRUCTARRAY) || + (sgl.AutoRedraw[I].Item.ItemType == GuiLib_ITEM_STRUCTCOND)) + return GuiLib_TRUE; + else + return GuiLib_FALSE; + } + else + return GuiLib_FALSE; +} +//------------------------------------------------------------------------------ +GuiConst_INT8S AutoRedraw_GetLevel(GuiConst_INT16S I) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + + if ((sgl.AutoRedraw[I].Valid & ITEM_AUTOREDRAW) == ITEM_AUTOREDRAW) + return sgl.AutoRedraw[I].Level; + else + return 0; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_Add(PrefixLocate GuiLib_ItemRec * PrefixLocate Item, GuiConst_INT16S Struct, GuiConst_INT8U Level) +{ + GuiConst_INT16S I, N; + + I = -1; + + if (sgl.AutoRedrawCount < GuiConst_MAX_DYNAMIC_ITEMS) + { + + if (sgl.AutoRedrawFirst == -1) + { + I = 0; + sgl.AutoRedrawFirst = 0; + sgl.AutoRedrawLast = -1; + sgl.AutoRedrawNext = 0; + } + else + { + for (N=0;N<GuiConst_MAX_DYNAMIC_ITEMS;N++) + { + if (sgl.AutoRedraw[N].Valid == ITEM_NONE) + { + I = N; + break; + } + } + } + + if (I >= 0) + { + sgl.AutoRedraw[I].Next = -1; + sgl.AutoRedraw[I].Prev = sgl.AutoRedrawLast; + sgl.AutoRedraw[I].Valid = ITEM_AUTOREDRAW; + sgl.AutoRedraw[I].Parent = sgl.AutoRedrawParent; + sgl.AutoRedraw[I].Level = Level; + memcpy(&sgl.AutoRedraw[I].Item, Item, sizeof(GuiLib_ItemRec)); + memcpy(&sgl.AutoRedraw[I].Memory, &sgl.Memory, sizeof(ItemMemory)); + + if ((sgl.AutoRedrawLast >= 0) + && (sgl.AutoRedrawLast < GuiConst_MAX_DYNAMIC_ITEMS)) + sgl.AutoRedraw[sgl.AutoRedrawLast].Next = I; + + sgl.AutoRedrawCount++; + sgl.AutoRedrawLast = I; + sgl.AutoRedrawLatest = I; + } + + } + + return I; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_Insert(PrefixLocate GuiLib_ItemRec * PrefixLocate Item, + GuiConst_INT16S Struct, + GuiConst_INT8U Level) +{ + GuiConst_INT16S I, N; + + if ((sgl.AutoRedrawFirst == -1) || + (sgl.AutoRedrawInsertPoint >= GuiConst_MAX_DYNAMIC_ITEMS)) + { + return AutoRedraw_Add(Item, Struct, Level); + } + + if (sgl.AutoRedrawCount < GuiConst_MAX_DYNAMIC_ITEMS) + { + I = -1; + + for (N=0;N<GuiConst_MAX_DYNAMIC_ITEMS;N++) + { + if (sgl.AutoRedraw[N].Valid == ITEM_NONE) + { + I = N; + break; + } + } + } + else + return -1; + + if (I >= 0) + { + if (sgl.AutoRedrawInsertPoint < 0) + { + sgl.AutoRedraw[I].Next = sgl.AutoRedrawFirst; + sgl.AutoRedraw[I].Prev = -1; + } + else + { + sgl.AutoRedraw[I].Next = sgl.AutoRedraw[sgl.AutoRedrawInsertPoint].Next; + sgl.AutoRedraw[I].Prev = sgl.AutoRedrawInsertPoint; + sgl.AutoRedraw[sgl.AutoRedraw[I].Prev].Next = I; + } + + if (sgl.AutoRedraw[I].Next != -1) + sgl.AutoRedraw[sgl.AutoRedraw[I].Next].Prev = I; + + sgl.AutoRedraw[I].Valid = ITEM_AUTOREDRAW; + sgl.AutoRedraw[I].Parent = sgl.AutoRedrawParent; + sgl.AutoRedraw[I].Level = Level; + + memcpy(&sgl.AutoRedraw[I].Item, Item, sizeof(GuiLib_ItemRec)); + memcpy(&sgl.AutoRedraw[I].Memory, &sgl.Memory, sizeof(ItemMemory)); + + if (sgl.AutoRedraw[I].Next == -1) + sgl.AutoRedrawLast = I; + + if (sgl.AutoRedraw[I].Prev == -1) + sgl.AutoRedrawFirst = I; + + sgl.AutoRedrawInsertPoint = I; + sgl.AutoRedrawLatest = I; + sgl.AutoRedrawCount++; + } + + return I; +} +//------------------------------------------------------------------------------ +void AutoRedraw_UpdateDrawn(GuiConst_INT16S I, PrefixLocate GuiLib_ItemRec * PrefixLocate Item) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return; + + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + { + sgl.AutoRedraw[I].Item.Drawn = Item->Drawn; + sgl.AutoRedraw[I].Item.DrawnX1 = Item->DrawnX1; + sgl.AutoRedraw[I].Item.DrawnY1 = Item->DrawnY1; + sgl.AutoRedraw[I].Item.DrawnX2 = Item->DrawnX2; + sgl.AutoRedraw[I].Item.DrawnY2 = Item->DrawnY2; + } + + return; +} +//------------------------------------------------------------------------------ +void AutoRedraw_Delete(GuiConst_INT16S I) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return; + + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + { + if (sgl.AutoRedrawLast == I) + sgl.AutoRedrawLast = sgl.AutoRedraw[I].Prev; + + if (sgl.AutoRedrawFirst == I) + sgl.AutoRedrawFirst = sgl.AutoRedraw[I].Next; + + if (sgl.AutoRedraw[I].Prev != -1) + sgl.AutoRedraw[sgl.AutoRedraw[I].Prev].Next = sgl.AutoRedraw[I].Next; + + if (sgl.AutoRedraw[I].Next != -1) + sgl.AutoRedraw[sgl.AutoRedraw[I].Next].Prev = sgl.AutoRedraw[I].Prev; + + sgl.AutoRedraw[I].Next = -1; + sgl.AutoRedraw[I].Prev = -1; + sgl.AutoRedraw[I].Valid = ITEM_NONE; + + sgl.AutoRedrawCount--; + } + + return; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_DeleteStruct(GuiConst_INT16S Struct_id) +{ + GuiConst_INT16S I, N, X; + + I = sgl.AutoRedrawFirst; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + + if ((Struct_id < 0) || (Struct_id >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + + if (sgl.AutoRedraw[Struct_id].Valid == ITEM_NONE) + return -1; + + while (sgl.AutoRedraw[I].Valid != ITEM_NONE) + { + N = sgl.AutoRedraw[I].Next; + if (sgl.AutoRedraw[I].Parent == Struct_id) + { + X = AutoRedraw_DeleteStruct(I); + if ((X >= 0) && (X < GuiConst_MAX_DYNAMIC_ITEMS)) + N = sgl.AutoRedraw[X].Next; + } + + I = N; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + break; + } + + sgl.AutoRedrawInsertPoint = sgl.AutoRedraw[Struct_id].Prev; + + AutoRedraw_Delete(Struct_id); + + if (sgl.AutoRedrawInsertPoint >= 0) + return sgl.AutoRedrawInsertPoint; + else + return sgl.AutoRedrawFirst; +} +//------------------------------------------------------------------------------ +void AutoRedraw_Destroy(void) +{ + GuiConst_INT16S I; + + for (I=0;I<GuiConst_MAX_DYNAMIC_ITEMS;I++) + { + sgl.AutoRedraw[I].Next = -1; + sgl.AutoRedraw[I].Prev = -1; + sgl.AutoRedraw[I].Valid = ITEM_NONE; + } + + sgl.AutoRedrawCount = 0; + sgl.AutoRedrawFirst = -1; + sgl.AutoRedrawLast = -1; + sgl.AutoRedrawCount = 0; + sgl.AutoRedrawParent = -1; + sgl.AutoRedrawUpdate = GuiLib_FALSE; + sgl.AutoRedrawInsertPoint = GuiConst_MAX_DYNAMIC_ITEMS; + sgl.AutoRedrawLatest = -1; + + return; +} +//------------------------------------------------------------------------------ +PrefixLocate GuiLib_ItemRec *AutoRedraw_GetItem(GuiConst_INT16S I) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return NULL; + else + return &sgl.AutoRedraw[I].Item; +} +//------------------------------------------------------------------------------ +PrefixLocate ItemMemory *AutoRedraw_GetItemMemory(GuiConst_INT16S I) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return NULL; + else + return &sgl.AutoRedraw[I].Memory; +} +//------------------------------------------------------------------------------ +void AutoRedraw_UpdateOnChange(GuiConst_INT16S I) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return; + + if ((sgl.AutoRedraw[I].Valid & ITEM_AUTOREDRAW) == ITEM_AUTOREDRAW) + { + sgl.AutoRedraw[I].ValueSize = 0; + + if (sgl.AutoRedraw[I].Item.UpdateType == GuiLib_UPDATE_ON_CHANGE) + { + if (sgl.AutoRedraw[I].Item.VarPtr != 0) + { + switch (sgl.AutoRedraw[I].Item.VarType) + { + case GuiLib_VAR_BOOL: + case GuiLib_VAR_UNSIGNED_CHAR: + case GuiLib_VAR_SIGNED_CHAR: + sgl.AutoRedraw[I].ValueSize = 1; + break; + + case GuiLib_VAR_UNSIGNED_INT: + case GuiLib_VAR_SIGNED_INT: + sgl.AutoRedraw[I].ValueSize = 2; + break; + + case GuiLib_VAR_UNSIGNED_LONG: + case GuiLib_VAR_SIGNED_LONG: + case GuiLib_VAR_FLOAT: + sgl.AutoRedraw[I].ValueSize = 4; + break; + + case GuiLib_VAR_DOUBLE: + sgl.AutoRedraw[I].ValueSize = 8; + break; + + case GuiLib_VAR_COLOR: + sgl.AutoRedraw[I].ValueSize = + GuiConst_PIXEL_BYTE_SIZE; + break; + + case GuiLib_VAR_STRING: + sgl.AutoRedraw[I].ValueSize = + GuiLib_AUTOREDRAW_MAX_VAR_SIZE; + break; + + default: + sgl.AutoRedraw[I].ValueSize = 0; + } + if (sgl.AutoRedraw[I].ValueSize > 0) + { + memcpy(&sgl.AutoRedraw[I].Value[0], + sgl.AutoRedraw[I].Item.VarPtr, + sgl.AutoRedraw[I].ValueSize); + } + } + } + } + + return; +} +//------------------------------------------------------------------------------ +GuiConst_INT8S RefreshColorVariable(GuiConst_INTCOLOR PrefixLocate *comp, GuiConst_INT16U idx) +{ + GuiConst_INTCOLOR PrefixLocate *ColVarPtr; + GuiConst_INTCOLOR ColVal; + GuiConst_INT8S changed = GuiLib_FALSE; + + if (idx != 0xFFFF) + { + if (idx < GuiStruct_VarPtrCnt) + { + ColVarPtr = (GuiConst_INTCOLOR PrefixLocate *)ReadWord(GuiStruct_VarPtrList[idx]); + if (ColVarPtr != 0) + { + ColVal = *ColVarPtr; + if (*comp != ColVal) + { + *comp = ColVal; + changed = GuiLib_TRUE; + } + } + } + } + + return changed; +} +//------------------------------------------------------------------------------ +GuiConst_INT8S AutoRedraw_VarChanged(GuiConst_INT16S I) +{ + GuiLib_ItemRecPtr Item; + GuiConst_INT16S VarChange; + GuiConst_INT8S changed; + + changed = GuiLib_FALSE; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return changed; + + if ((sgl.AutoRedraw[I].Valid & ITEM_AUTOREDRAW) == ITEM_AUTOREDRAW) + { + Item = &sgl.AutoRedraw[I].Item; + if (Item->UpdateType == GuiLib_UPDATE_ON_CHANGE) + { + if ((Item->TextPar[0].BitFlags & GuiLib_BITFLAG_INUSE) && + (Item->VarPtr != 0)) + { + VarChange = 0; + if (sgl.AutoRedraw[I].ValueSize > 0) + { + if (Item->VarType == GuiLib_VAR_STRING) + VarChange = VarStrCmp(&sgl.AutoRedraw[I].Value[0], + (GuiConst_INT8U PrefixLocate *)Item->VarPtr); + else + VarChange = + memcmp(&sgl.AutoRedraw[I].Value[0], + Item->VarPtr, + sgl.AutoRedraw[I].ValueSize); + } + if ((sgl.AutoRedraw[I].ValueSize == 0) || (VarChange != 0)) + changed = GuiLib_TRUE; + } + } + else + changed = GuiLib_TRUE; + + changed |= RefreshColorVariable(&Item->ForeColor, Item->ForeColorIndex); + changed |= RefreshColorVariable(&Item->BackColor, Item->BackColorIndex); + changed |= RefreshColorVariable(&Item->BarForeColor, Item->BarForeColorIndex); + changed |= RefreshColorVariable(&Item->BarBackColor, Item->BarBackColorIndex); + +#ifdef GuiConst_ITEM_RADIOBUTTON_INUSE + if (Item->ItemType == GuiLib_ITEM_RADIOBUTTON) + changed |= RefreshColorVariable(&Item->CompPars.CompRadioButton.MarkColor, + Item->CompPars.CompRadioButton.MarkColorIndex); +#endif +#ifdef GuiConst_ITEM_CHECKBOX_INUSE + if (Item->ItemType == GuiLib_ITEM_CHECKBOX) + changed |= RefreshColorVariable(&Item->CompPars.CompCheckBox.MarkColor, + Item->CompPars.CompCheckBox.MarkColorIndex); +#endif +#ifdef GuiConst_ITEM_BUTTON_INUSE + if (Item->ItemType == GuiLib_ITEM_BUTTON) + { + GuiConst_INT32S state; + + if ((sgl.CurItem.VarPtr != 0) && + (sgl.CurItem.VarType != GuiLib_VAR_STRING)) + { + state = ReadVar(Item->VarPtr, Item->VarType); + if ((state < GuiLib_BUTTON_STATE_UP) || + (state > GuiLib_BUTTON_STATE_DISABLED)) + state = GuiLib_BUTTON_STATE_UP; + } + else + state = GuiLib_BUTTON_STATE_UP; + + + changed |= RefreshColorVariable(&Item->CompPars.CompButton.TextColor[state], + Item->CompPars.CompButton.TextColorIndex[state]); + + changed |= RefreshColorVariable(&Item->CompPars.CompButton.GlyphIconColor[state], + Item->CompPars.CompButton.GlyphIconColorIndex[state]); + } +#endif + } + + return changed; +} +//------------------------------------------------------------------------------ +void AutoRedraw_UpdateVar(GuiConst_INT16S I) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return; + + if ((sgl.AutoRedraw[I].Valid & ITEM_AUTOREDRAW) == ITEM_AUTOREDRAW) + { + if (sgl.AutoRedraw[I].Item.UpdateType == GuiLib_UPDATE_ON_CHANGE) + { + if ((sgl.AutoRedraw[I].Item.TextPar[0].BitFlags & GuiLib_BITFLAG_INUSE) && + (sgl.AutoRedraw[I].Item.VarPtr != 0)) + { + if (sgl.AutoRedraw[I].ValueSize > 0) + { + memcpy(&sgl.AutoRedraw[I].Value[0], + sgl.AutoRedraw[I].Item.VarPtr, + sgl.AutoRedraw[I].ValueSize); + } + } + } + } + + return; +} + +#ifdef GuiConst_TEXTBOX_FIELDS_ON + +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_InsertTextBox(PrefixLocate GuiLib_ItemRec * PrefixLocate Item, + GuiConst_INT16S Struct, + GuiConst_INT8U Level) +{ + GuiConst_INT16S I; + + I = AutoRedraw_Insert(Item, Struct, Level); + + if (I != -1) + sgl.AutoRedraw[I].Valid = ITEM_TEXTBOX; + + return I; +}//------------------------------------------------------------------------------ +void AutoRedraw_SetAsTextBox(GuiConst_INT16S I) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return; + + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + sgl.AutoRedraw[I].Valid |= ITEM_TEXTBOX; + + return; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_GetTextBox(GuiConst_INT8S T, GuiConst_INT16S I) +{ + if (I == -1) + { + I = sgl.AutoRedrawFirst; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + } + else + { + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + + if (sgl.AutoRedraw[I].Valid == ITEM_NONE) + return -1; + + I = sgl.AutoRedraw[I].Next; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + } + + while (I != -1) + { + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + { + if ((sgl.AutoRedraw[I].Valid & ITEM_TEXTBOX) == ITEM_TEXTBOX) + { + if (sgl.AutoRedraw[I].Item.CompPars.CompTextBox.ScrollIndex == T) + break; + } + I = sgl.AutoRedraw[I].Next; + } + else + return -1; + } + + return I; +} + +#endif // GuiConst_TEXTBOX_FIELDS_ON +#ifdef GuiConst_CURSOR_SUPPORT_ON +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_InsertCursor(PrefixLocate GuiLib_ItemRec * PrefixLocate Item, + GuiConst_INT16S Struct, + GuiConst_INT8U Level) +{ + GuiConst_INT16S I; + + I = AutoRedraw_Insert(Item, Struct, Level); + + if (I != -1) + sgl.AutoRedraw[I].Valid = ITEM_CURSOR; + + return I; +} +//------------------------------------------------------------------------------ +void AutoRedraw_SetAsCursor(GuiConst_INT16S I) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return; + + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + sgl.AutoRedraw[I].Valid |= ITEM_CURSOR; + + return; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_IsOnlyCursor(GuiConst_INT16S I) +{ + GuiConst_INT16S ret = GuiLib_FALSE; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return ret; + + if (sgl.AutoRedraw[I].Valid == ITEM_CURSOR) + ret = GuiLib_TRUE; + + return ret; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_GetCursor(GuiConst_INT8S C, GuiConst_INT16S I) +{ + if (I == -1) + { + I = sgl.AutoRedrawFirst; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + } + else + { + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + + if (sgl.AutoRedraw[I].Valid == ITEM_NONE) + return -1; + + I = sgl.AutoRedraw[I].Next; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + } + + while (I != -1) + { + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + { + if ((sgl.AutoRedraw[I].Valid & ITEM_CURSOR) == ITEM_CURSOR) + { + if (sgl.AutoRedraw[I].Item.CursorFieldNo == C) + break; + } + I = sgl.AutoRedraw[I].Next; + } + else + return -1; + } + + return I; +} +//------------------------------------------------------------------------------ +GuiConst_INT8S AutoRedraw_GetCursorNumber(GuiConst_INT16S I) +{ + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + + if (sgl.AutoRedraw[I].Valid & ITEM_CURSOR) + return sgl.AutoRedraw[I].Item.CursorFieldNo; + + return -1; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_GetFirstCursor(void) +{ + GuiConst_INT16S I, result; + GuiConst_INT8S C; + + I = sgl.AutoRedrawFirst; + C = 0x7F; + + result = -1; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return result; + + while (I != -1) + { + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + { + if ((sgl.AutoRedraw[I].Valid & ITEM_CURSOR) == ITEM_CURSOR) + { + if (sgl.AutoRedraw[I].Item.CursorFieldNo < C) + { + C = sgl.AutoRedraw[I].Item.CursorFieldNo; + result = I; + } + } + I = sgl.AutoRedraw[I].Next; + } + else + return -1; + } + + return result; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_GetLastCursor(void) +{ + GuiConst_INT16S I, result; + GuiConst_INT8S C; + + I = sgl.AutoRedrawFirst; + C = 0; + + result = -1; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return result; + + while (I != -1) + { + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + { + if ((sgl.AutoRedraw[I].Valid & ITEM_CURSOR) == ITEM_CURSOR) + { + if (sgl.AutoRedraw[I].Item.CursorFieldNo > C) + { + C = sgl.AutoRedraw[I].Item.CursorFieldNo; + result = I; + } + } + I = sgl.AutoRedraw[I].Next; + } + else + return -1; + } + + return result; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_GetNextCursor(GuiConst_INT8S C) +{ + GuiConst_INT16S I, result; + GuiConst_INT8S closest; + + I = sgl.AutoRedrawFirst; + closest = 0x7f; + + result = -1; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return result; + + while (I != -1) + { + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + { + if ((sgl.AutoRedraw[I].Valid & ITEM_CURSOR) == ITEM_CURSOR) + { + if ((sgl.AutoRedraw[I].Item.CursorFieldNo > C) + && (sgl.AutoRedraw[I].Item.CursorFieldNo <= closest)) + { + closest = sgl.AutoRedraw[I].Item.CursorFieldNo; + result = I; + } + } + I = sgl.AutoRedraw[I].Next; + } + else + return -1; + } + + return result; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_GetPrevCursor(GuiConst_INT8S C) +{ + GuiConst_INT16S I, result; + GuiConst_INT8S closest; + + I = sgl.AutoRedrawFirst; + closest = 0; + + result = -1; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return result; + + while (I != -1) + { + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + { + if ((sgl.AutoRedraw[I].Valid & ITEM_CURSOR) == ITEM_CURSOR) + { + if ((sgl.AutoRedraw[I].Item.CursorFieldNo < C) + && (sgl.AutoRedraw[I].Item.CursorFieldNo >= closest)) + { + closest = sgl.AutoRedraw[I].Item.CursorFieldNo; + result = I; + } + } + I = sgl.AutoRedraw[I].Next; + } + else + return -1; + } + + return result; +} +//------------------------------------------------------------------------------ +GuiConst_INT16S AutoRedraw_CheckCursorInheritance(GuiConst_INT16S N) +{ + GuiConst_INT16S I, J, result; + GuiConst_INT16S cursor_id; + + if (GuiLib_ActiveCursorFieldNo < 0) + return -1; + + if ((N < 0) || (N >= GuiConst_MAX_DYNAMIC_ITEMS)) + return -1; + + if (sgl.AutoRedraw[N].Valid == ITEM_NONE) + return -1; + + I = sgl.AutoRedraw[N].Parent; + result = 1; + + while (result == 1) + { + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + { + result = -1; + break; + } + + if (sgl.AutoRedraw[I].Valid != ITEM_NONE) + { + if ((sgl.AutoRedraw[I].Valid & ITEM_CURSOR) == ITEM_CURSOR) + { + cursor_id = sgl.AutoRedraw[I].Item.CursorFieldNo; + + if (cursor_id == GuiLib_ActiveCursorFieldNo) + { + result = 0; + break; + } + } + J = sgl.AutoRedraw[I].Parent; + if (J == I) + result = -1; + I = J; + } + else + { + result = -1; + break; + } + + } + + return result; +} +//------------------------------------------------------------------------------ +void AutoRedraw_ResetCursor(void) +{ + GuiConst_INT16S I; + + I = sgl.AutoRedrawFirst; + + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + return; + + while ((sgl.AutoRedraw[I].Valid & ITEM_AUTOREDRAW) == ITEM_AUTOREDRAW) + { + sgl.AutoRedraw[I].Item.CursorFieldNo = GuiLib_NO_CURSOR; + + I = sgl.AutoRedraw[I].Next; + if ((I < 0) || (I >= GuiConst_MAX_DYNAMIC_ITEMS)) + break; + } + + return; +} +#endif // GuiConst_CURSOR_SUPPORT_ON +