diff --git a/KOL_ASM_NOUNICODE.inc b/KOL_ASM_NOUNICODE.inc new file mode 100644 index 0000000..d4ac15a --- /dev/null +++ b/KOL_ASM_NOUNICODE.inc @@ -0,0 +1,4347 @@ +//------------------------------------------------------------------------------ +// KOL_ASM_NOUNICODE.inc (to inlude in KOL.pas) +// v 3.141592 + +// this part of code is for case when ASM_VERSION is enabled and the symbol +// UNICODE_CTRLS is NOT defined (functions, procedures and methods which work +// with AnsiStrings only) + +const comctl32_const: PKOLChar = 'comctl32'; + InitCommonControlsEx_const: PKOLChar = 'InitCommonControlsEx'; +procedure DoInitCommonControls( dwICC: DWORD ); +asm + PUSH EAX // dwICC + CALL InitCommonControls + MOV EAX, [ComCtl32_Module] + TEST EAX, EAX + JNZ @@1 + PUSH [comctl32_const] + CALL LoadLibrary + MOV [ComCtl32_Module], EAX +@@1:PUSH [InitCommonControlsEx_const] + PUSH EAX + CALL GetProcAddress + XCHG ECX, EAX + {$IFDEF SAFE_CODE} + POP EDX + JECXZ @@fin + PUSH EDX + {$ENDIF} + PUSH 8 // dwSize + PUSH ESP // @ ICC + CALL ECX // Proc( @ ICC ) + POP ECX + POP ECX +@@fin: +end; + +function ShowMsg( const S: KOLString; Flags: DWORD ): DWORD; +asm + push edx // Flags + mov ecx, [Applet] + {$IFDEF SNAPMOUSE2DFLTBTN} + {$IFDEF SAFE_CODE} + jecxz @@0 + {$ENDIF} + pushad + xchg eax, ecx + mov edx, offset[WndProcSnapMouse2DfltBtn] + call TControl.AttachProc + popad +@@0: + {$ENDIF} + mov edx, 0 + {$IFDEF SAFE_CODE} + jecxz @@1 + {$ENDIF} + mov edx, [ecx].TControl.fHandle + mov ecx, [ecx].TControl.fCaption +@@1: push ecx // Title + push eax // S + push edx // Wnd + call MessageBox + {$IFDEF SNAPMOUSE2DFLTBTN} + mov ecx, [Applet] + {$IFDEF SAFE_CODE} + jecxz @@2 + {$ENDIF} + pushad + xchg eax, ecx + mov edx, offset[WndProcSnapMouse2DfltBtn] + call TControl.DetachProc + popad +@@2: + {$ENDIF} +end; + +procedure TGraphicTool.SetFontName(const Value: KOLString); +asm + PUSH EAX + LEA EAX, [EAX].fData.Font.Name + XOR ECX, ECX + MOV CL, 32 + PUSH EAX + PUSH ECX + PUSH EDX + CALL StrLComp + //TEST EAX, EAX + POP EDX + POP ECX + POP EAX + JZ @@exit + CALL StrLCopy + POP EAX + PUSH EAX + CALL Changed +@@exit: POP EAX +end; + +{$IFDEF TEXT_EXTENT_OLD} +function TCanvas.TextExtent(const Text: KOLString): TSize; +asm + PUSH EBX + PUSH ESI + MOV EBX, EAX + PUSH ECX + PUSH ECX // prepare @Result + MOV EAX, EDX + CALL System.@LStrLen + PUSH EAX // prepare Length(Text) + CALL EDX2PChar + PUSH EDX // prepare PChar(Text) + {$IFDEF SAFE_CODE} + MOV EAX, EBX + CALL RefInc + {$ENDIF} + PUSH HandleValid or FontValid + PUSH EBX + CALL RequiredState + XCHG ESI, EAX + TEST ESI, ESI // ESI = fHandle before + JNZ @@1 + PUSH ESI + CALL CreateCompatibleDC + MOV EDX, EBX + XCHG EAX, EDX // EAX := @Self; EDX := DC + CALL SetHandle +//****************************************************** // Added By M.Gerasimov + CMP WORD PTR [EBX].TCanvas.fIsPaintDC, 0 + JNZ @@2 + XOR ESI,ESI +@@2: +//****************************************************** +@@1: + PUSH HandleValid or FontValid + PUSH EBX + CALL RequiredState + PUSH EAX // prepare DC + CALL Windows.GetTextExtentPoint32A // KOL_ANSI + POP EDX // @ Result + {$IFDEF FIX_ITALIC_TEXT_WIDTH} + MOV ECX, [EBX].fFont + //JECXZ @@0 + CMP [ECX].TGraphicTool.fData.Font.Italic, 0 + JZ @@0 + MOV EAX, [EDX].TSize.cy + SHR EAX, 2 + ADD DWORD PTR [EDX], EAX +@@0: {$ENDIF} + TEST ESI, ESI + JNZ @@exit + XOR EDX, EDX + XCHG EAX, EBX + CALL SetHandle +@@exit: + {$IFDEF SAFE_CODE} + PUSH EAX + XCHG EAX, EBX + CALL RefDec + POP EAX + {$ENDIF} + POP ESI + POP EBX +end; +{$ELSE TEXT_EXTENT_NEW} +function TCanvas.TextExtent(const Text: KOLString): TSize; +asm + PUSH ESI + {$IFDEF FIX_ITALIC_TEXT_WIDTH} + PUSH EBX + MOV EBX, ECX + {$ENDIF} + XCHG ESI, EAX // ESI = @Self: PCanvas + CALL EDX2PChar + PUSH ECX + PUSH EDX + + XCHG EAX, EDX + CALL StrLen + XCHG [ESP], EAX + PUSH EAX + + PUSH HandleValid or FontValid + PUSH ESI + CALL TCanvas.RequiredState + PUSH [ESI].TCanvas.fHandle + CALL GetTextExtentPoint32 + {$IFDEF FIX_ITALIC_TEXT_WIDTH} + CMP [ESI].TGraphicTool.fData.Font.Italic, 0 + JZ @@1 + MOV EAX, [EBX].TSize.cy + SHR EAX, 2 + ADD DWORD PTR [EBX].TSize, EAX +@@1: POP EBX + {$ENDIF} + POP ESI +end; +{$ENDIF TEXT_EXTENT_NEW} + +procedure TCanvas.TextOut(X, Y: Integer; const Text: KOLString); stdcall; +asm + PUSH EBX + MOV EBX, [EBP+8] + + MOV EAX, [Text] + PUSH EAX + CALL System.@LStrLen + XCHG EAX, [ESP] // prepare Length(Text) + + //CALL System.@LStrToPChar // string does not need to be null-terminated ! + PUSH EAX // prepare PChar(Text) + PUSH [Y] // prepare Y + PUSH [X] // prepare X + + PUSH HandleValid or FontValid or BrushValid or ChangingCanvas + PUSH EBX + CALL RequiredState + PUSH EAX // prepare fHandle + CALL Windows.TextOutA // KOL_ANSI + + POP EBX +end; + +function Int2Hex( Value : DWord; Digits : Integer ) : KOLString; +asm // EAX = Value + // EDX = Digits + // ECX = @Result + PUSH 0 + ADD ESP, -0Ch + PUSH EDI + PUSH ECX + LEA EDI, [ESP+8+0Fh] // EBX := @Buf[ 15 ] + {$IFDEF SMALLEST_CODE} + {$ELSE} + AND EDX, $F + {$ENDIF} +@@loop: DEC EDI + DEC EDX + PUSH EAX + {$IFDEF PARANOIA} DB $24, $0F {$ELSE} AND AL, 0Fh {$ENDIF} + AAM + DB $D5, $11 //AAD + ADD AL, $30 + STOSB + DEC EDI + POP EAX + SHR EAX, 4 + JNZ @@loop + TEST EDX, EDX + JG @@loop + POP EAX // EAX = @Result + MOV EDX, EDI // EDX = @resulting string + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + POP EDI + ADD ESP, 10h +end; + +function Hex2Int( const Value : AnsiString) : Integer; +asm + CALL EAX2PChar + PUSH ESI + XCHG ESI, EAX + XOR EDX, EDX + TEST ESI, ESI + JE @@exit + LODSB + {$IFDEF PARANOIA} DB $3C, '$' {$ELSE} CMP AL, '$' {$ENDIF} + JNE @@1 +@@0: LODSB +@@1: TEST AL, AL + JE @@exit + {$IFDEF PARANOIA} DB $2C, '0' {$ELSE} SUB AL, '0' {$ENDIF} + {$IFDEF PARANOIA} DB $3C, 9 {$ELSE} CMP AL, '9' - '0' {$ENDIF} + JBE @@3 + + {$IFDEF PARANOIA} DB $2C, $11 {$ELSE} SUB AL, 'A' - '0' {$ENDIF} + {$IFDEF PARANOIA} DB $3C, 5 {$ELSE} CMP AL, 'F' - 'A' {$ENDIF} + JBE @@2 + + {$IFDEF PARANOIA} DB $2C, 32 {$ELSE} SUB AL, 32 {$ENDIF} + {$IFDEF PARANOIA} DB $3C, 5 {$ELSE} CMP AL, 'F' - 'A' {$ENDIF} + JA @@exit +@@2: + {$IFDEF PARANOIA} DB $04, 0Ah {$ELSE} ADD AL, 0Ah {$ENDIF} +@@3: + SHL EDX, 4 + ADD DL, AL + JMP @@0 + +@@exit: XCHG EAX, EDX + POP ESI +end; + +function Int2Str( Value : Integer ) : KOLString; +asm + XOR ECX, ECX + PUSH ECX + ADD ESP, -0Ch + + PUSH EBX + LEA EBX, [ESP + 15 + 4] + PUSH EDX + CMP EAX, ECX + PUSHFD + JGE @@1 + NEG EAX +@@1: + MOV CL, 10 + +@@2: + DEC EBX + XOR EDX, EDX + DIV ECX + ADD DL, 30h + MOV [EBX], DL + TEST EAX, EAX + JNZ @@2 + + POPFD + JGE @@3 + + DEC EBX + MOV byte ptr [EBX], '-' +@@3: + POP EAX + MOV EDX, EBX + {$IFDEF _D2009orHigher} + XOR ECX, ECX // TODO: safe to destory twice? + {$ENDIF} + CALL System.@LStrFromPChar + + POP EBX + ADD ESP, 10h +end; + +function Int2Ths( I : Integer ) : AnsiString; +asm + PUSH EBP + MOV EBP, ESP + PUSH EAX + PUSH EDX + CALL Int2Str + POP EDX + POP EAX + TEST EAX, EAX + JGE @@0 + NEG EAX +@@0: + CMP EAX, 1000 + JL @@Exit + PUSH EDX + MOV EAX, [EDX] + PUSH EAX + CALL System.@LStrLen // EAX = Length(Result) + POP EDX + PUSH EDX // EDX = @Result[ 1 ] + XOR ECX, ECX + +@@1: + ROL ECX, 8 + DEC EAX + MOV CL, [EDX+EAX] + JZ @@fin + CMP ECX, 300000h + JL @@1 + + PUSH ECX + XOR ECX, ECX + MOV CL, [ThsSeparator] + JMP @@1 + +@@fin: CMP CL, '-' + JNE @@fin1 + CMP CH, [ThsSeparator] + JNE @@fin1 + MOV CH, 0 // this corrects -,ddd,... +@@fin1: CMP ECX, 01000000h + JGE @@fin2 + INC EAX + ROL ECX, 8 + JMP @@fin1 +@@fin2: PUSH ECX + + LEA EDX, [ESP+EAX] + MOV EAX, [EBP-4] + {$IFDEF _D2009orHigher} + XOR ECX, ECX // TODO: safe to change ecx? + {$ENDIF} + CALL System.@LStrFromPChar +@@Exit: + MOV ESP, EBP + POP EBP +end; + +function Int2Digs( Value, Digits : Integer ) : KOLString; +asm + PUSH EBP + MOV EBP, ESP + PUSH EDX // [EBP-4] = Digits + PUSH ECX + MOV EDX, ECX + CALL Int2Str + POP ECX + PUSH ECX // [EBP-8] = @Result + MOV EAX, [ECX] + PUSH EAX + CALL System.@LStrLen + POP EDX // EDX = @Result[1] + MOV ECX, EAX // ECX = Length( Result ) + ADD EAX, EAX + SUB ESP, EAX + MOV EAX, ESP + PUSHAD + CALL StrCopy + POPAD + MOV EDX, EAX + ADD ESP, -100 + CMP byte ptr [EDX], '-' + PUSHFD + JNE @@1 + INC EDX +@@1: + MOV EAX, [EBP-4] // EAX = Digits + CMP ECX, EAX + JGE @@2 + DEC EDX + MOV byte ptr [EDX], '0' + INC ECX + JMP @@1 +@@2: + POPFD + JNE @@3 + DEC EDX + MOV byte ptr [EDX], '-' +@@3: + MOV EAX, [EBP-8] + {$IFDEF _D2009orHigher} + XOR ECX, ECX // TODO: eax or ecx affect result? + {$ENDIF} + CALL System.@LStrFromPChar + MOV ESP, EBP + POP EBP +end; + +function Num2Bytes( Value : Double ) : KOLString; +asm PUSH EBX + PUSH ESI + PUSH EDI + MOV EBX, ESP + MOV ESI, EAX + MOV ECX, 4 + MOV EDX, 'TGMk' +@@1: FLD [Value] +@@10: FICOM dword ptr [@@1024] + FSTSW AX + SAHF + JB @@2 + FIDIV dword ptr [@@1024] + FST [Value] + WAIT + TEST DL, 20h + JE @@ror + AND DL, not 20h + JMP @@nxt +@@1024: DD 1024 +@@100: DD 100 +@@ror: ROR EDX, 8 +@@nxt: LOOP @@10 +@@2: TEST DL, 20h + JZ @@3 + MOV DL, 0 +@@3: MOV DH, 0 + PUSH DX + MOV EDI, ESP + FLD ST(0) + CALL System.@TRUNC + {$IFDEF _D2orD3} + PUSH 0 + {$ELSE} + PUSH EDX + {$ENDIF} + PUSH EAX + FILD qword ptr [ESP] + POP EDX + POP EDX + MOV EDX, ESI + CALL Int2Str + FSUBP ST(1), ST + FIMUL dword ptr [@@100] + CALL System.@TRUNC + TEST EAX, EAX + JZ @@4 + XOR ECX, ECX + MOV CL, 0Ah + CDQ + IDIV ECX + TEST EDX, EDX + JZ @@5 + MOV AH, DL + SHL EAX, 16 + ADD EAX, '00. ' + PUSH EAX + MOV EDI, ESP + INC EDI + JMP @@4 +@@5: SHL EAX, 8 + ADD AX, '0.' + PUSH AX + MOV EDI, ESP +@@4: MOV EAX, [ESI] + CALL System.@LStrLen + ADD ESP, -100 + SUB EDI, EAX + PUSH ESI + PUSH EDI + MOV ESI, [ESI] + MOV ECX, EAX + REP MOVSB + POP EDX + POP EAX + {$IFDEF _D2009orHigher} + XOR ECX, ECX // TODO: IDIV + {$ENDIF} + CALL System.@LStrFromPChar + MOV ESP, EBX + POP EDI + POP ESI + POP EBX +end; + +function S2Int( S: PKOLChar ): Integer; +asm + XCHG EDX, EAX + XOR EAX, EAX + TEST EDX, EDX + JZ @@exit + + XOR ECX, ECX + MOV CL, [EDX] + INC EDX + CMP CL, '-' + PUSHFD + JE @@0 +@@1: CMP CL, '+' + JNE @@2 +@@0: MOV CL, [EDX] + INC EDX +@@2: SUB CL, '0' + CMP CL, '9'-'0' + JA @@fin + LEA EAX, [EAX+EAX*4] // + LEA EAX, [ECX+EAX*2] // + JMP @@0 +@@fin: POPFD + JNE @@exit + NEG EAX +@@exit: +end; + +function Str2Int(const Value : KOLString) : Integer; +asm + CALL EAX2PChar + CALL S2Int +end; + +function TrimLeft(const S: Ansistring): Ansistring; +asm + XCHG EAX, EDX + CALL EDX2PChar + DEC EDX +@@1: INC EDX + MOVZX ECX, byte ptr [EDX] + JECXZ @@fin + CMP CL, ' ' + JBE @@1 +@@fin: + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar +end; + +function TrimRight(const S: Ansistring): Ansistring; +asm + PUSH EDX + PUSH EAX + + PUSH EAX + CALL System.@LStrLen + XCHG EAX, [ESP] + CALL EAX2PChar + POP ECX + INC ECX +@@1: DEC ECX + MOV DL, [EAX+ECX] + JL @@fin + CMP DL, ' ' + JBE @@1 +@@fin: + INC ECX + POP EAX + XOR EDX, EDX + INC EDX + CALL System.@LStrCopy +end; + +function CopyEnd( const S : AnsiString; Idx : Integer ) : AnsiString; +asm + PUSH ECX + PUSH EAX + PUSH EDX + + CALL System.@LStrLen + + POP EDX + TEST EDX, EDX + JG @@1 + XOR EDX, EDX + INC EDX +@@1: + SUB EAX, EDX + MOV ECX, EAX + + POP EAX + JGE @@ret_end + + POP EAX + JL System.@LStrClr + +@@ret_end: + INC ECX + CALL System.@LStrCopy +end; + +function CopyTail( const S : AnsiString; Len : Integer ) : AnsiString; +asm + PUSH ECX + PUSH EAX + PUSH EDX + CALL System.@LStrLen + POP ECX + CMP ECX, EAX + {$IFDEF USE_CMOV} + CMOVG ECX, EAX + {$ELSE} + JLE @@1 + MOV ECX, EAX +@@1: {$ENDIF} + + MOV EDX, EAX + SUB EDX, ECX + INC EDX + POP EAX + CALL System.@LStrCopy +end; + +procedure DeleteTail( var S : AnsiString; Len : Integer ); +asm + PUSH EAX + PUSH EDX + MOV EAX, [EAX] + CALL System.@LStrLen + POP ECX + CMP ECX, EAX + {$IFDEF USE_CMOV} + CMOVG ECX, EAX + {$ELSE} + JLE @@1 + MOV ECX, EAX +@@1: {$ENDIF} + + MOV EDX, EAX + SUB EDX, ECX + INC EDX + POP EAX + CALL System.@LStrDelete +end; + +{$IFnDEF TEST_INDEXOFCHARS_COMPAT} +function IndexOfChar( const S : KOLString; Chr : KOLChar ) : Integer; +asm + CALL EAX2PChar + PUSH EAX + MOV ECX, [EAX-4] + CALL StrScanLen + POP EDX + JZ @@1 + LEA EDX, [EAX+1] +@@1: SUB EAX, EDX +end; +{$ENDIF} + +function IndexOfCharsMin( const S, Chars : AnsiString ) : Integer; +asm PUSH ESI + PUSH EBX + PUSH EAX + CALL EDX2PChar + MOV ESI, EDX + + OR EBX, -1 + MOV ECX, [EDX-4] + JECXZ @@EXIT + +@@1: LODSB + + XCHG EDX, EAX + POP EAX + PUSH EAX + + PUSH ECX + CALL IndexOfChar + POP ECX + TEST EAX, EAX + JLE @@NEXT + + TEST EBX, EBX + JLE @@ASGN + CMP EAX, EBX + JGE @@NEXT +@@ASGN: + XCHG EAX, EBX +@@NEXT: LOOP @@1 + +@@EXIT: XCHG EAX, EBX + POP ECX + POP EBX + POP ESI +end; + +function Parse( var S : AnsiString; const Separators : AnsiString ) : AnsiString; +asm + PUSH EBX + PUSH ESI + PUSH EDI + MOV EDI, ECX + XCHG ESI, EAX + MOV EAX, [ESI] + CALL IndexOfCharsMin + XCHG EBX, EAX + TEST EBX, EBX + JG @@1 + MOV EAX, [ESI] + CALL System.@LStrLen + XCHG EBX, EAX + INC EBX +@@1: + XOR EDX, EDX + INC EDX + PUSH EDX + + PUSH EDI + MOV ECX, EBX + DEC ECX + MOV EAX, [ESI] + CALL System.@LStrCopy + XCHG EAX, ESI + MOV ECX, EBX + POP EDX + CALL System.@LStrDelete + POP EDI + POP ESI + POP EBX +end; + +function _StrSatisfy( S, Mask : PKOLChar ) : Boolean; +asm + TEST EAX, EAX + JZ @@exit + XCHG ECX, EAX + // EDX <- Mask + // ECX <- S + XOR EAX, EAX + MOV AL, '*' +@@rest_satisfy: + PUSH ECX + PUSH EDX + +@@nx_char: + MOV AH, [EDX] + OR AH, [ECX] + JZ @@fin //@@ret_true + + MOV AH, 0 + + CMP word ptr [EDX], AX //'*' + JE @@fin //@@ret_true + + CMP byte ptr [ECX], AH + JNE @@10 + + DEC EDX +@@1: + INC EDX + CMP byte ptr [EDX], AL //'*' + JE @@1 + + CMP byte ptr [EDX], AH + SETZ AL + JMP @@fin + +@@10: CMP byte ptr [EDX], AH + JE @@ret_false + + CMP byte ptr [EDX], '?' + JNE @@11 + +@@go_nx_char: + INC ECX + INC EDX + JMP @@nx_char + +@@11: + CMP byte ptr [EDX], AL //'*' + JNE @@20 + + INC EDX +@@12: CMP byte ptr [ECX], AH + JE @@ret_false + + CALL @@rest_satisfy + TEST AL, AL + JNE @@fin + MOV AL, '*' + + INC ECX + JMP @@12 + +@@20: MOV AH, [EDX] + XOR AH, [ECX] + + JE @@go_nx_char +@@ret_false: + XOR EAX, EAX + +@@fin: + POP EDX + POP ECX +@@exit: +end; + +function StrSatisfy( const S, Mask: AnsiString ): Boolean; +asm + PUSH ESI + TEST EAX, EAX + JZ @@exit + + XCHG ESI, EAX + + XCHG EAX, EDX + TEST EAX, EAX + JZ @@exit + + CALL EAX2PChar + + PUSH 0 + MOV EDX, ESP + CALL AnsiLowerCase + + XCHG EAX, ESI + CALL EAX2PChar + + PUSH 0 + MOV EDX, ESP + CALL AnsiLowerCase + + POP EAX + POP EDX + PUSH EDX + PUSH EAX + CALL _StrSatisfy + + XCHG ESI, EAX + + CALL RemoveStr + CALL RemoveStr + XCHG EAX, ESI + +@@exit: + POP ESI +end; + +function _2StrSatisfy( S, Mask: PAnsiChar ): Boolean; +asm // // + PUSH EBX + PUSH ECX + XCHG EBX, EAX + PUSH 0 + MOV EAX, ESP + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + PUSH 0 + MOV EAX, ESP + MOV EDX, EBX + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + POP EAX + POP EDX + PUSH EDX + PUSH EAX + CALL StrSatisfy + XCHG EBX, EAX + CALL RemoveStr + CALL RemoveStr + XCHG EAX, EBX + POP ECX + POP EBX +end; + +function SkipSpaces( P: PKOLChar ): PKOLChar; +asm + DEC EAX +@@loop: INC EAX + CMP byte ptr [EAX], 0 + JE @@exit + CMP byte ptr [EAX], ' ' + JBE @@loop +@@exit: +end; + +function SkipParam(P: PKOLChar): PKOLChar; +asm + CALL SkipSpaces +@@while: CMP byte ptr [EAX], ' ' + JBE @@exit + CMP byte ptr [EAX], '"' + JNE @@incP_goLoop +@@untilQuot: + INC EAX + CMP byte ptr [EAX], 0 + JE @@exit + CMP byte ptr [EAX], '"' + JNE @@untilQuot +@@incP_goLoop: + INC EAX + JMP @@while +@@exit: +end; + +function ParamCount: Integer; +asm + CALL GetCommandLine + OR EDX, -1 +@@while: INC EDX + CALL SkipParam + CALL SkipSpaces + CMP byte ptr [EAX], 0 + JNE @@while + XCHG EAX, EDX +end; + +function __DelimiterLast( Str: PAnsiChar; Delimiters: PAnsiChar ): PAnsiChar; +asm + PUSH ESI + + CALL EAX2PChar + + MOV ESI, EDX + MOV EDX, EAX + +@@tolast: + CMP byte ptr [EAX], 0 + JZ @@next1 + INC EAX + JMP @@tolast + +@@next1: + PUSH EAX + +@@next: + LODSB + TEST AL, AL + JZ @@exit + + PUSH EDX + XCHG EDX, EAX + CALL StrRScan + POP EDX + + TEST EAX, EAX + JZ @@next + + POP ECX + CMP byte ptr [ECX], 0 + JZ @@next1 + + CMP EAX, ECX + JG @@next1 + + PUSH ECX + JLE @@next + +@@exit: POP EAX + POP ESI +end; + +function DelimiterLast( const Str, Delimiters: KOLString ): Integer; +asm + CALL EAX2PChar + CALL EDX2PChar + PUSH EAX + CALL __DelimiterLast + POP EDX + SUB EAX, EDX + INC EAX +end; + +function StrIsStartingFrom( Str, Pattern: PKOLChar ): Boolean; +asm + {$IFDEF F_P} + MOV EAX, [Str] + MOV EDX, [Pattern] + {$ENDIF F_P} + XOR ECX, ECX + @@1: + MOV CL, [EDX] // pattern[ i ] + INC EDX + MOV CH, [EAX] // str[ i ] + INC EAX + JECXZ @@2 // str = pattern; CL = #0, CH = #0 + CMP CL, CH + JE @@1 + @@2: + TEST CL, CL + SETZ AL +end {$IFDEF F_P} [ 'EAX', 'EDX', 'ECX' ] {$ENDIF}; + +function Format( const fmt: KOLString; params: array of const ): AnsiString; +asm + PUSH ESI + PUSH EDI + PUSH EBX + MOV EBX, ESP + {$IFDEF UNICODE_CTRLS} + ADD ESP, -2048 + {$ELSE} + ADD ESP, -1024 + {$ENDIF} + MOV ESI, ESP + + INC ECX + JZ @@2 +@@1: + MOV EDI, [EDX + ECX*8 - 8] + PUSH EDI + LOOP @@1 +@@2: + PUSH ESP + PUSH EAX + PUSH ESI + + CALL wvsprintf + + MOV EDX, ESI + MOV EAX, @Result + {$IFDEF _D2009orHigher} + PUSH ECX + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + {$IFDEF _D2009orHigher} + POP ECX + {$ENDIF} + + MOV ESP, EBX + POP EBX + POP EDI + POP ESI +end; + +function FileExists( const FileName : KOLString ) : Boolean; +const size_TWin32FindData = sizeof( {$IFDEF UNICODE_CTRLS} TWin32FindDataW {$ELSE} TWin32FindDataA {$ENDIF} ); + Size_TFindFileData = (sizeof(TFindFileData) + 3) and not 3; +asm +{$IFDEF FILE_EXISTS_EX} + PUSH EBX + MOV BL, 0 + PUSH EAX + PUSH SEM_NOOPENFILEERRORBOX or SEM_FAILCRITICALERRORS + CALL SetErrorMode + XCHG EAX, [ESP] + SUB ESP, Size_TFindFileData + MOV EDX, ESP + CALL Find_First + TEST AL, AL + JZ @@fin + MOV EAX, ESP + CALL Find_Close + TEST byte ptr [ESP].TFindFileData.dwFileAttributes, FILE_ATTRIBUTE_DIRECTORY + JNZ @@fin + PUSH ESP + LEA EAX, [ESP+4].TFindFileData.ftLastWriteTime + PUSH EAX + CALL FileTimeToLocalFileTime + LEA EAX, [ESP+8] + PUSH EAX + INC EAX + INC EAX + PUSH EAX + SUB EAX, 10 + PUSH EAX + CALL FileTimeToDOSDateTime + TEST EAX, EAX + SETNZ BL +@@fin: ADD ESP, Size_TFindFileData + CALL SetErrorMode + XCHG EAX, EBX + POP EBX +{$ELSE} + CALL EAX2PChar + PUSH EAX + CALL GetFileAttributes + INC EAX + JZ @@exit + DEC EAX + {$IFDEF PARANOIA} DB $24, FILE_ATTRIBUTE_DIRECTORY {$ELSE} AND AL, FILE_ATTRIBUTE_DIRECTORY {$ENDIF} + SETZ AL +@@exit: +{$ENDIF} +end; + +function DiskPresent( const DrivePath: KOLString ): Boolean; +asm + PUSH EBX + MOV BH, 0 + TEST EAX, EAX + JZ @@dirExists + CMP byte ptr [EAX], '\' + JZ @@dirExists + PUSH EAX + PUSH EAX + CALL GetDriveType + CMP AL, DRIVE_REMOVABLE + JE @@setErrMode + CMP AL, DRIVE_CDROM + JE @@setErrMode + CMP AL, DRIVE_RAMDISK + JNE @@popPath_dirExists +@@setErrMode: + INC BH + PUSH SEM_NOOPENFILEERRORBOX or SEM_FAILCRITICALERRORS + CALL SetErrorMode + XCHG [ESP], EAX + PUSH EAX +@@popPath_dirExists: + POP EAX +@@dirExists: + CALL DirectoryExists + MOV BL, AL + TEST BH, BH + JZ @@exit + CALL SetErrorMode +@@exit: XCHG EAX, EBX + POP EBX +end; + +function GetStartDir : AnsiString; +asm + PUSH EBX + MOV EBX, EAX + + XOR EAX, EAX + MOV AH, 2 + SUB ESP, EAX + MOV EDX, ESP + PUSH EAX + PUSH EDX + PUSH 0 + CALL GetModuleFileName // in KOL_ANSI + + LEA EDX, [ESP + EAX] +@@1: DEC EDX + CMP byte ptr [EDX], '\' + JNZ @@1 + + INC EDX + MOV byte ptr [EDX], 0 + + MOV EAX, EBX + MOV EDX, ESP + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar // AnsiSafe! + + ADD ESP, 200h + POP EBX +end; + +function IncludeTrailingChar( const S: KOLString; C: KOLChar ): KOLString; +asm + push edx + push ecx + xchg ecx, eax + xchg edx, ecx + call System.@LStrAsg + pop eax + pop edx + mov ecx, [eax] + jecxz @@1 + add ecx, [ecx-4] + dec ecx + cmp byte ptr [ecx], dl + jz @@exit +@@1: + push eax + push 0 + mov eax, esp + {$IFDEF _D2009orHigher} + //push ecx + xor ecx, ecx + {$ENDIF} + call System.@LStrFromChar + {$IFDEF _D2009orHigher} + //pop ecx + {$ENDIF} + mov edx, [esp] + mov eax, [esp+4] + call System.@LStrCat + call RemoveStr + pop eax +@@exit: +end; + +const + DirDelimiters: PAnsiChar = ':\/'; +function ExtractFileName( const Path : AnsiString ) : AnsiString; +asm + PUSH EDX + PUSH EAX + MOV EDX, [DirDelimiters] + CALL __DelimiterLast + POP EDX + CMP byte ptr [EAX], 0 + JZ @@1 + XCHG EDX, EAX + INC EDX +@@1: POP EAX + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar // Safe! +end; + +function ExtractFileNameWOext( const Path : KOLString ) : KOLString; +asm + push ebx + + push edx + push eax + call ExtractFileName + pop edx // Path - не нужен больше + mov eax, [esp] // eax = Result = ExtractFileName(Path) + mov eax, [eax] + push 0 + mov edx, esp + call ExtractFileExt + mov eax, [esp] + call System.@LStrLen + xchg ebx, eax // ebx = Length(ExtractFileExt(Result)) + call RemoveStr // ExtractFileExt - больше не нужен + mov eax, [esp] + mov eax, [eax] + call System.@LStrLen // eax = Length(Result) + sub eax, ebx + xchg ecx, eax + xor edx, edx + inc edx + mov eax, [esp] + mov eax, [eax] + call System.@LStrCopy + + pop ebx +end; + +const + ExtDelimeters: PAnsiChar = '.'; + +function ExtractFileExt( const Path : KOLString ) : KOLString; +asm + PUSH EDX + MOV EDX, [ExtDelimeters] + CALL EAX2PChar + CALL __DelimiterLast +@@1: XCHG EDX, EAX + POP EAX + {$IFDEF _D2009orHigher} + PUSH ECX + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + {$IFDEF _D2009orHigher} + POP ECX // this routine hasn't touch ECX + {$ENDIF} +end; + +function ReplaceExt( const Path, NewExt: KOLString ): KOLString; +asm + push ecx // result + push edx // NewExt + push eax // Path + + push 0 + mov edx, esp + call ExtractFilePath + pop eax + xchg [esp], eax // eax=Path, Path in stack replaced with ExtractFilePath(Path) + + push 0 + mov edx, esp + call ExtractFileNameWOext + // now stack conatins: result,NewExt,ExtractFilePath(Path),ExtractFileNameWOext(Path)<-ESP + + mov eax, [esp+12] + mov edx, esp + push dword ptr [edx+4] // ExtractFilePath(Path) + push dword ptr [edx] // ExtractFileNameWOext(Path) + push dword ptr [edx+8] // NewExt + mov edx, 3 + call System.@LStrCatN + call RemoveStr + call RemoveStr + pop ecx + pop ecx +end; + +function GetSystemDir: KOLString; +asm + PUSH EBX + XCHG EBX, EAX + SUB ESP, MAX_PATH + MOV EAX, ESP + PUSH MAX_PATH + PUSH EAX + CALL GetSystemDirectory + MOV EAX, EBX + MOV EDX, ESP + CALL System.@LStrFromPChar + MOV EDX, EBX + MOV EAX, [EDX] + CALL IncludeTrailingPathDelimiter + ADD ESP, MAX_PATH + POP EBX +end; + +function GetWindowsDir : KOLString; +asm + PUSH EBX + XCHG EBX, EAX + SUB ESP, MAX_PATH + MOV EAX, ESP + PUSH MAX_PATH + PUSH EAX + CALL GetWindowsDirectory + MOV EAX, EBX + MOV EDX, ESP + CALL System.@LStrFromPChar + MOV EDX, EBX + MOV EAX, [EDX] + CALL IncludeTrailingPathDelimiter + ADD ESP, MAX_PATH + POP EBX +end; + +function GetWorkDir : KOLString; +asm + PUSH EBX + XCHG EBX, EAX + SUB ESP, MAX_PATH + PUSH ESP + PUSH MAX_PATH + CALL GetCurrentDirectory + MOV EAX, EBX + MOV EDX, ESP + CALL System.@LStrFromPChar + MOV EDX, EBX + MOV EAX, [EDX] + CALL IncludeTrailingPathDelimiter + ADD ESP, MAX_PATH + POP EBX +end; + +function GetTempDir : KOLString; +asm + push eax + sub esp, 264 + push esp + push 261 + call GetTempPath + mov edx, esp + mov eax, [esp+264] + {$IFDEF _D2009orHigher} + xor ecx, ecx + {$ENDIF} + call System.@LStrFromPChar + add esp, 264 + pop edx + mov eax, [edx] + call IncludeTrailingPathDelimiter +end; + +function CreateTempFile( const DirPath, Prefix: KOLString ): KOLString; +asm + push ecx + call EAX2PCHAR + call EDX2PCHAR + sub esp, 264 + push esp + push 0 + push edx + push eax + call GetTempFileName + mov eax, [esp+264] + mov edx, esp + {$IFDEF _D2009orHigher} + xor ecx, ecx // ecx is argument + {$ENDIF} + call System.@LStrFromPChar + add esp, 268 +end; + +function FindFilter( const Filter: AnsiString): AnsiString; +asm + XCHG EAX, EDX + PUSH EAX + CALL System.@LStrAsg + POP EAX + CMP dword ptr [EAX], 0 + JNE @@exit + LEA EDX, @@mask_all + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + JE System.@LStrFromPChar +@@mask_all: DB '*.*',0 +@@exit: +end; + +procedure TDirList.ScanDirectoryEx(const DirPath, Filters: AnsiString; + Attr: DWord); +asm + PUSH EBX + MOV EBX, EAX + + PUSHAD + LEA EAX, [EBX].fFilters + CALL Free_And_Nil + + CALL NewStrList + MOV [EBX].fFilters, EAX + POPAD + + PUSHAD + PUSH 0 + MOV EAX, ESP + MOV EDX, ECX + CALL System.@LStrLAsg +@@1: MOV ECX, [ESP] + JECXZ @@2 + MOV EAX, ESP + MOV EDX, offset[@@semicolon] + PUSH 0 + MOV ECX, ESP + CALL Parse + MOV EAX, [ESP] + MOV EDX, ESP + CALL Trim + POP EDX + PUSH EDX + TEST EDX, EDX + JZ @@filt_added + MOV EAX, [EBX].fFilters + CALL TStrList.Add +@@filt_added: + CALL RemoveStr + JMP @@1 + + // ';' string literal + {$IFDEF _D2009orHigher} + DW 0, 1 + {$ENDIF} + DD -1, 1 +@@semicolon: + DB ';',0 + +@@2: POP ECX + POPAD + XOR ECX, ECX + PUSH [Attr] + CALL ScanDirectory + POP EBX +@@exit: +end; + +procedure _FillStrList; // Эта часть кода общая для двух следующих процедур +asm +/////////////////////////////// + OR EAX,0 + JE @@EXIT //ERROR +// LEA EAX,[EAX-IniBufferSize] +// JE @@EXIT +// возможна нехватка Буфера... в принципе не ошибка :) +// возвращаем что влезло... +@@LOOP: + LEA EAX,[ESI+4] + CALL StrLen + MOV [ESI],EAX + LEA EDX,[ESI+4] + INC EAX + ADD ESI,EAX + + MOV EAX,EDI + + CALL TStrList.ADD + + CMP byte ptr [ESI+4],0 + JNE @@LOOP + +@@EXIT: + POP EAX + CALL System.@FreeMem + + + POP ECX + POP EBX + POP EDI + POP ESI +end; + +procedure TIniFile.GetSectionNames(Names: PStrList); +asm + PUSH ESI + PUSH EDI + PUSH EBX + PUSH ECX + + MOV EBX,EAX + MOV EAX, IniBufferStrSize + MOV EDI,EDX + + CALL System.@GetMem + MOV ESI,EAX + PUSH EAX + + PUSH [EBX].fFileName + MOV EAX,IniBufferSize + PUSH EAX + + LEA EAX,[ESI+4] + PUSH EAX + + CALL GetPrivateProfileSectionNames + JMP _FillStrList +end; + +procedure TIniFile.SectionData(Names: PStrList); +asm + PUSH ESI + PUSH EDI + PUSH EBX + PUSH ECX + + MOV EBX,EAX + MOV EAX, IniBufferStrSize + MOV EDI,EDX + + CALL System.@GetMem + MOV ESI,EAX + PUSH EAX + + OR [EBX].fMode,0 + JNE @@DOWrite + + PUSH [EBX].fFileName + MOV EAX,IniBufferSize + PUSH EAX + + LEA EAX,[ESI+4] + PUSH EAX + PUSH [EBX].fSection + + CALL GetPrivateProfileSection + JMP _FillStrList + +@@DOWrite: + + PUSH EBX + PUSH ESI + PUSH EDX + PUSH EBP + + MOV EDX,0 + MOV EBP,[EDI].TStrList.fCount + MOV EBX,IniBufferSize-2 // оставим место для #0#0 + +{ECM+++>} OR EBP,EBP // otherwise GetPChars when StrList.Count = 0 crashed + +@@LOOP: + JE @@ENDLOOP + + OR EBX,EBX + JE @@ENDLOOP + + PUSH EDX + MOV EAX,EDI + CALL TStrList.GetPChars + + PUSH EAX + CALL StrLen + POP EAX + + XOR ECX,-1 + MOV EDX,ESI + + SUB EBX,ECX + JA @@L1 + ADD ECX,EBX + XOR EBX,EBX +@@L1: + + ADD ESI,ECX + + CALL MOVE +@@L2: + POP EDX + INC EDX + DEC EBP + JMP @@LOOP +@@ENDLOOP: + MOV WORD PTR [ESI],0 + + POP EBP + POP EDX + POP ESI + POP EBX + MOV EAX,EBX + CALL ClearSection + + PUSH [EBX].fFileName + PUSH ESI + PUSH [EBX].fSection + + CALL WritePrivateProfileSection + + POP EAX + CALL System.@FreeMem + + POP ECX + POP EBX + POP EDI + POP ESI + +end; + +function _NewControl( AParent: PControl; ControlClassName: PKOLChar; + Style: DWORD; Ctl3D: Boolean; + Actions: TCommandActionsParam ): PControl; +const szActions = sizeof(TCommandActions); +asm + PUSH EBX + PUSH EAX // push AParent + PUSH ECX // push Style + MOVZX ECX, [Ctl3D] + PUSH [Actions] + CALL _NewWindowed + XCHG EBX, EAX + {$IFDEF USE_FLAGS} + OR [EBX].TControl.fFlagsG3, (1 shl G3_IsControl) + {$ELSE} + INC [EBX].TControl.fIsControl + {$ENDIF} + POP EDX // pop Style + OR EDX, WS_CLIPSIBLINGS or WS_CLIPCHILDREN + //INC [EBX].TControl.fVerticalAlign + MOV byte ptr [EBX].TControl.fLookTabKeys, $0F + TEST [EBX].TControl.fCtl3D_child, 1 + JZ @@noCtl3D + AND EDX, not WS_BORDER + OR byte ptr [EBX].TControl.fExStyle + 1, WS_EX_CLIENTEDGE shr 8 +@@noCtl3D: + MOV [EBX].TControl.fStyle, EDX + {$IFDEF USE_FLAGS} + {$ELSE} + TEST EDX, WS_VISIBLE + SETNZ AL + MOV [EBX].TControl.fVisible, AL + TEST EDX, WS_TABSTOP + SETNZ AL + MOV [EBX].TControl.fTabstop, AL + {$ENDIF USE_FLAGS} + POP ECX // pop AParent + JECXZ @@noParent + + PUSH ESI + PUSH EDI + PUSH ECX + LEA ESI, [ECX].TControl.fMargin + LEA EDI, [EBX].TControl.fBoundsRect + LODSB + MOVSX EAX, AL + {$IFNDEF SMALLEST_CODE} + PUSH EAX + MOVSX ECX, byte ptr [ESI+2] + ADD EAX, ECX // AParent.fClientLeft + {$ENDIF} + STOSD // fBoundsRect.Left + {$IFNDEF SMALLEST_CODE} + POP EAX + PUSH EAX + MOVSX ECX, byte ptr [ESI+0] + ADD EAX, ECX // AParent.fClientTop + {$ENDIF} + STOSD // fBoundsRect.Top + {$IFNDEF SMALLEST_CODE} + XCHG EDX, EAX + POP EAX + {$ENDIF} + ADD EAX, 64 + STOSD // fBoundsRect.Right + {$IFNDEF SMALLEST_CODE} + XCHG EAX, EDX + ADD EAX, 64 + {$ENDIF} + STOSD // fBoundsRect.Bottom} + POP ECX + MOV EAX, [ECX].TControl.fCursor + STOSD + POP EDI + POP ESI + + XCHG EAX, ECX + CALL TControl.ParentForm + XCHG ECX, EAX + JECXZ @@noParentForm + INC [ECX].TControl.fTabOrder + MOV DX, WORD PTR [ECX].TControl.fTabOrder + MOV WORD PTR [EBX].TControl.fTabOrder, DX + TEST [EBX].TControl.fStyle, WS_TABSTOP + JZ @@CurrentControl_set + CMP [ECX].TControl.DF.fCurrentControl, 0 + JNZ @@CurrentControl_set + MOV [ECX].TControl.DF.fCurrentControl, EBX +@@CurrentControl_set: +@@noParentForm: +@@noParent: + MOVZX EDX, [CtlIdCount] + INC [CtlIdCount] + MOV [EBX].TControl.fMenu, EDX + MOV EDX, offset[WndProcCtrl] + MOV EAX, EBX + CALL TControl.AttachProc + XCHG EAX, EBX + POP EBX + {$IFDEF DEBUG_ALTSPC} + PUSH EAX + CALL DumpWindowed + POP EAX + {$ENDIF} +end; + +const StaticClass: Array[0..6] of AnsiChar=('S','T','A','T','I','C',#0); +function NewLabel( AParent: PControl; const Caption: KOLString ): PControl; +asm + PUSH EDX + + PUSH 0 + {$IFDEF PACK_COMMANDACTIONS} + PUSH [LabelActions_Packed] + {$ELSE} + PUSH offset[LabelActions] + {$ENDIF} + MOV ECX, WS_VISIBLE or WS_CHILD or SS_LEFTNOWORDWRAP or SS_NOPREFIX or SS_NOTIFY + MOV EDX, offset[StaticClass] + CALL _NewControl + MOV word ptr [EAX].TControl.aAutoSzX, $101 + {$IFDEF USE_FLAGS} + OR [EAX].TControl.fFlagsG1, (1 shl G1_SizeRedraw) or (1 shl G1_IsStaticControl) + {$ELSE} + INC [EAX].TControl.fIsStaticControl + INC [EAX].TControl.fSizeRedraw + {$ENDIF} + MOV EDX, [EAX].TControl.fBoundsRect.Top + ADD EDX, 22 + MOV [EAX].TControl.fBoundsRect.Bottom, EDX + POP EDX + PUSH EAX + CALL TControl.SetCaption + POP EAX + +{$IFDEF GRAPHCTL_XPSTYLES} + PUSH EAX + MOV EDX, offset[XP_Themes_For_Label] + CALL Attach_WM_THEMECHANGED + POP EAX +{$ENDIF} +end; + +function NewGroupbox( AParent: PControl; const Caption: KOLString ): PControl; +asm + PUSH EDX + PUSH 0 + {$IFDEF PACK_COMMANDACTIONS} + PUSH [ButtonActions_Packed] + {$ELSE} + PUSH offset[ButtonActions] + {$ENDIF} + MOV EDX, offset[ButtonClass] + MOV ECX, WS_VISIBLE or WS_CHILD or BS_GROUPBOX or WS_CLIPCHILDREN or WS_CLIPSIBLINGS + CALL _NewControl + OR [EAX].TControl.fExStyle, WS_EX_CONTROLPARENT + MOV EDX, [EAX].TControl.fBoundsRect.Left + ADD EDX, 100 + MOV [EAX].TControl.fBoundsRect.Right, EDX + MOV EDX, [EAX].TControl.fBoundsRect.Top + ADD EDX, 100 + MOV [EAX].TControl.fBoundsRect.Bottom, EDX + MOV byte ptr [EAX].TControl.fClientTop, 22 + XOR EDX, EDX + {$IFDEF USE_FLAGS} + AND [EAX].TControl.fStyle.f2_Style, not(1 shl F2_Tabstop) + {$ELSE} + MOV [EAX].TControl.fTabstop, DL + {$ENDIF USE_FLAGS} + MOV DL, 2 + ADD [EAX].TControl.fClientBottom, DL + ADD [EAX].TControl.fClientLeft, DL + ADD [EAX].TControl.fClientRight, DL + POP EDX + PUSH EAX + CALL TControl.SetCaption + POP EAX + PUSH EAX + {$IFDEF USE_FLAGS} + OR [EAX].TControl.fFlagsG5, 1 shl G5_IsGroupbox + {$ELSE} + INC [EAX].TControl.fIsGroupBox + {$ENDIF} + MOV EDX, offset[WndProcDoEraseBkgnd] + CALL TControl.AttachProc + POP EAX + +{$IFDEF GRAPHCTL_XPSTYLES} + PUSH EAX + MOV EDX, offset[XP_Themes_For_GroupBox] + CALL Attach_WM_THEMECHANGED + POP EAX +{$ENDIF} +end; + +function NewPanel( AParent: PControl; EdgeStyle: TEdgeStyle ): PControl; +const CreateStyle = WS_VISIBLE or WS_CHILD or SS_LEFTNOWORDWRAP or + SS_NOPREFIX or SS_NOTIFY; +asm +{$IFDEF GRAPHCTL_XPSTYLES} + MOVZX EDX, EdgeStyle + PUSH EDX +{$ENDIF} + + PUSH EDX + MOV EDX, offset[StaticClass] + MOV ECX, CreateStyle + PUSH 0 + {$IFDEF PACK_COMMANDACTIONS} + PUSH [LabelActions_Packed] + {$ELSE} + PUSH offset[LabelActions] + {$ENDIF} + CALL _NewControl + //INC byte ptr [EAX].TControl.aAutoSzX + //INC byte ptr [EAX].TControl.aAutoSzY + MOV word ptr [EAX].TControl.aAutoSzX, $101 + ADD [EAX].TControl.fBoundsRect.Right, 100-64 + ADD [EAX].TControl.fBoundsRect.Bottom, 100-64 + OR byte ptr [EAX].TControl.fExStyle+2, 1 + POP ECX + CMP CL, 1 + JG @@exit + JE @@sunken + OR byte ptr [EAX].TControl.fStyle+2, $40 +{$IFDEF GRAPHCTL_XPSTYLES} + JMP @@visual +{$ELSE} + RET +{$ENDIF} +@@sunken: + OR byte ptr [EAX].TControl.fStyle+1, $10 +@@exit: + +{$IFDEF GRAPHCTL_XPSTYLES} +@@visual: + CMP AppTheming, TRUE + JNE @@es_none_ + CMP CL, 1 + JG @@es_none_ + JE @@not_sunken + AND byte ptr [EAX].TControl.fStyle+2, $00 + JNE @@es_none_ +@@not_sunken: + AND byte ptr [EAX].TControl.fStyle+1, $00 +@@es_none_: + POP EDX + PUSH EAX + CALL TControl.SetEdgeStyle + POP EAX + PUSH EAX + MOV EDX, offset[XP_Themes_For_Panel] + CALL Attach_WM_THEMECHANGED + POP EAX +{$ENDIF} +end; + +const ListBoxClass : Array[ 0..7 ] of AnsiChar = ( 'L','I','S','T','B','O','X',#0 ); +function NewListbox( AParent: PControl; Options: TListOptions ): PControl; +asm + PUSH EAX + PUSH EDX + MOV EAX, ESP + MOV EDX, offset[ListFlags] + XOR ECX, ECX + MOV CL, 11 + CALL MakeFlags + POP EDX + OR EAX, WS_VISIBLE or WS_CHILD or WS_TABSTOP or WS_BORDER or WS_VSCROLL or LBS_NOTIFY + XCHG ECX, EAX + POP EAX + PUSH 1 + {$IFDEF PACK_COMMANDACTIONS} + PUSH [ListActions_Packed] + {$ELSE} + PUSH offset[ListActions] + {$ENDIF} + MOV EDX, offset[ListBoxClass] + CALL _NewControl + {$IFDEF PACK_COMMANDACTIONS} + MOV EDX, [EAX].TControl.fCommandActions + MOV [EDX].TCommandActionsObj.aClear, offset[ClearListbox] + {$ENDIF} + ADD [EAX].TControl.fBoundsRect.Right, 100 + ADD [EAX].TControl.fBoundsRect.Bottom, 200-64 + MOV [EAX].TControl.fColor, clWindow + MOV [EAX].TControl.fLookTabKeys, 3 +end; + +procedure CreateComboboxWnd( Combo: PControl ); +//const PrevProcStr: PAnsiChar = 'PREV_PROC'; //************ Remarked By M.Gerasimov +asm + PUSH EDI + PUSH EBX + XCHG EBX, EAX + PUSH GW_CHILD + PUSH [EBX].TControl.fHandle +@@getwindow: + CALL GetWindow + TEST EAX, EAX + JZ @@fin + PUSH offset[WndFuncCombo] + PUSH GWL_WNDPROC + PUSH EAX + XCHG EDI, EAX + CALL SetWindowLong + PUSH EAX + PUSH offset [ID_PREVPROC] // + PUSH EDI + CALL SetProp +@@2getnext: + PUSH GW_HWNDNEXT + PUSH EDI + JMP @@getwindow +@@fin: POP EBX + POP EDI +end; + +{$IFDEF WNDPROCTREEVIEW_OLDASMVERSION} +function WndProcTreeView( Self_: PControl; var Msg: TMsg; var Rslt: Integer ): Boolean; +asm //cmd //opd + CMP word ptr [EDX].TMsg.message, WM_NOTIFY + JNZ @@ret_false + PUSH EBX + XCHG EBX, EAX + MOV EDX, [EDX].TMsg.lParam + {$IFDEF EVENTS_DYNAMIC} + MOV EAX, [EBX].TControl.EV + LEA EAX, [EAX].TEvents.fOnTVBeginDrag + {$ELSE} + LEA EAX, [EBX].TControl.EV.fOnTVBeginDrag + {$ENDIF} + CMP word ptr [EDX].TNMTreeView.hdr.code, NM_RCLICK + JNE @@chk_TVN_BEGINDRAG + PUSH ECX + PUSH ECX + PUSH ESP + CALL GetCursorPos + MOV EAX, EBX + MOV EDX, ESP + MOV ECX, EDX + CALL TControl.Screen2Client + POP EAX + AND EAX, $FFFF + POP EDX + SHL EDX, 16 + OR EAX, EDX + PUSH EAX + CALL GetShiftState + PUSH EAX + PUSH WM_RBUTTONUP + PUSH [EBX].TControl.fHandle + CALL PostMessage + JMP @@2fin_false1 + +@@chk_TVN_BEGINDRAG: + {$IFDEF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_BEGINDRAGW + JZ @@event_drag + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_BEGINRDRAGW + JZ @@event_drag + {$ENDIF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_BEGINDRAG + JZ @@event_drag + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_BEGINRDRAG + JNZ @@chk_BEGINLABELEDIT +@@event_drag: + MOV EDX, [EDX].TNMTreeView.itemNew.hItem +@@event_call: + MOV ECX, [EAX].TMethod.Code + JECXZ @@2fin_false1 + MOV EAX, [EAX].TMethod.Data + XCHG EBX, ECX + XCHG EDX, ECX + CALL EBX +@@2fin_false1: JMP @@fin_false +@@chk_BEGINLABELEDIT: + {$IFDEF EVENTS_DYNAMIC} + MOV EAX, [EBX].TControl.EV + LEA EAX, [EAX].TEvents.FOnTVBeginEdit + {$ELSE} + LEA EAX, [EBX].TControl.EV.fOnTVBeginEdit + {$ENDIF} + {$IFDEF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_BEGINLABELEDITW + JZ @@beginlabeledit + {$ENDIF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_BEGINLABELEDIT + JNZ @@chk_ITEMEXPANDED //@@chk_DELETEITEM +@@beginlabeledit: + {$IFDEF USE_FLAGS} + TEST [EBX].TControl.fFlagsG6, 1 shl G6_Dragging + {$ELSE} + CMP [EBX].TControl.fDragging, 0 + {$ENDIF} + JZ @@allow_LABELEDIT + XOR EAX, EAX + INC EAX + MOV [ECX], EAX + JMP @@ret_true + +@@allow_LABELEDIT: + PUSH ECX // @Rslt + + MOV ECX, [EAX].TMethod.Code + JECXZ @@2fin_false1 + PUSH EBX + XCHG EBX, ECX + MOV EDX, [EDX].TTVDispInfo.item.hItem + XCHG EDX, ECX + MOV EAX, [EAX].TMethod.Data + CALL EBX + TEST AL, AL + SETZ AL // Rslt := not event result; + POP EBX + JMP @@ret_EAX + +@@call_EBX: + CALL EBX +@@2fin_false: + JMP @@fin_false +@@chk_ITEMEXPANDED: + {$IFDEF EVENTS_DYNAMIC} + MOV EAX, [EBX].TControl.EV + LEA EAX, [EAX].TEvents.fOnTVExpanded + {$ELSE} + LEA EAX, [EBX].TControl.EV.fOnTVExpanded + {$ENDIF} + {$IFDEF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_ITEMEXPANDEDW + JZ @@itemexpanded + {$ENDIF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_ITEMEXPANDED + JNZ @@chk_SELCHANGING +@@itemexpanded: + MOV ECX, [EAX].TMethod.Code + JECXZ @@2fin_false + CMP [EDX].TNMTreeView.action, TVE_EXPAND + PUSH ECX + SETZ CL + XCHG ECX, [ESP] + JMP @@event_drag +@@chk_SELCHANGING: + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_SELCHANGING + JNE @@chk_ITEMEXPANDING + XCHG EAX, ECX + {$IFDEF EVENTS_DYNAMIC} + MOV ECX, [EBX].TControl.EV + MOV ECX, [ECX].TEvents.fOnTVSelChanging.TMethod.Code + {$ELSE} + MOV ECX, [EBX].TControl.EV.fOnTVSelChanging.TMethod.Code + {$ENDIF} +@@2fin_false2: + JECXZ @@2fin_false + PUSH EAX //@Rslt + PUSH [EDX].TNMTreeView.itemNew.hItem + XCHG ECX, EBX //EBX=OnTVSelChanging.Code ECX=Sender + XCHG ECX, EDX //EDX=Sender ECX=Msg + MOV ECX, [ECX].TNMTreeView.itemOld.hItem + {$IFDEF EVENTS_DYNAMIC} + MOV EAX, [EDX].TControl.EV + MOV EAX, [EAX].TEvents.fOnTVSelChanging.TMethod.Data + {$ELSE} + MOV EAX, [EDX].TControl.EV.fOnTVSelChanging.TMethod.Data + {$ENDIF} + CALL EBX + XOR AL, 1 + MOVZX EAX, AL + JMP @@ret_EAX + +@@chk_ITEMEXPANDING: + {$IFDEF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_ITEMEXPANDINGW + JZ @@itemexpanding + {$ENDIF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_ITEMEXPANDING + JNE @@chk_ENDLABELEDIT +@@itemexpanding: + XCHG EAX, ECX + {$IFDEF EVENTS_DYNAMIC} + MOV ECX, [EBX].TControl.EV + MOV ECX, [ECX].TEvents.fOnTVExpanding.TMethod.Code + {$ELSE} + MOV ECX, [EBX].TControl.EV.fOnTVExpanding.TMethod.Code + {$ENDIF} + JECXZ @@2fin_false2 + PUSH EAX // @Rslt + CMP [EDX].TNMTreeView.action, TVE_EXPAND + PUSH ECX + SETZ CL + XCHG ECX, [ESP] + XCHG ECX, EBX //EBX=OnTVExpanding.Code ECX=Seneder + XCHG EDX, ECX //ECX=Msg EDX=Sender + MOV ECX, [ECX].TNMTreeView.itemNew.hItem //ECX=Item + {$IFDEF EVENTS_DYNAMIC} + MOV EAX, [EDX].TControl.EV + MOV EAX, [EAX].TEvents.fOnTVExpanding.TMethod.Data + {$ELSE} + MOV EAX, [EDX].TControl.EV.fOnTVExpanding.TMethod.Data //EAX=object + {$ENDIF} +@@111: + CALL EBX +@@ret_EAX: + POP EDX //EDX=@Rslt + MOVZX EAX, AL + NEG EAX + MOV [EDX], EAX +@@ret_true: + MOV AL, 1 + POP EBX + RET +@@chk_ENDLABELEDIT: + {$IFDEF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_ENDLABELEDITW + JZ @@endlabeledit + {$ENDIF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_ENDLABELEDIT + JNZ @@chk_SELCHANGED +@@endlabeledit: + XCHG EAX, ECX + {$IFDEF EVENTS_DYNAMIC} + MOV ECX, [EBX].TControl.EV + MOV ECX, [ECX].TEvents.fOnTVEndEdit.TMethod.Code + {$ELSE} + MOV ECX, [EBX].TControl.EV.fOnTVEndEdit.TMethod.Code + {$ENDIF} + JECXZ @@ret_1 + PUSH EAX + PUSH EBX + PUSH 0 + + XCHG EDX, EBX + MOV EAX, [EBX].TTVDispInfo.item.pszText + PUSH EDX + PUSH ECX + XCHG EAX, EDX + {$IFDEF UNICODE_CTRLS} + CMP [EBX].TNMTreeView.hdr.code, TVN_ENDLABELEDITW + JNZ @@endlabeleditA + CALL TControl.TVGetItemTextW + JMP @@NewTxt_ready +@@endlabeleditA: + {$ENDIF UNICODE_CTRLS} + TEST EDX, EDX + JNZ @@prepare_NewTxt + // NewTxt := [EDX].TControl.TVItemText[ hItem ] + LEA ECX, [ESP + 8] + MOV EDX, [EBX].TTVDispInfo.item.hItem + CALL TControl.TVGetItemText + JMP @@NewTxt_ready +@@prepare_NewTxt: + LEA EAX, [ESP+8] + {$IFDEF _D2009orHigher} + PUSH ECX + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + {$IFDEF _D2009orHigher} + POP ECX + {$ENDIF} +@@NewTxt_ready: + POP ECX + POP EDX + POP EAX + PUSH EAX + PUSH EAX + {$IFDEF EVENTS_DYNAMIC} + MOV EAX, [EDX].TControl.EV + MOV EAX, [EAX].TEvents.fOnTVEndEdit.TMethod.Data + {$ELSE} + MOV EAX, [EDX].TControl.EV.fOnTVEndEdit.TMethod.Data + {$ENDIF} + MOV EBX, [EBX].TTVDispInfo.item.hItem + XCHG ECX, EBX + CALL EBX + XCHG EBX, EAX + CALL RemoveStr + XCHG EAX, EBX + POP EBX + JMP @@ret_EAX +@@ret_1: + INC ECX + MOV [EAX], ECX + JMP @@ret_true + +@@chk_SELCHANGED: + {$IFDEF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_SELCHANGEDW + JZ @@selchanged + {$ENDIF UNICODE_CTRLS} + CMP word ptr [EDX].TNMTreeView.hdr.code, TVN_SELCHANGED + JNZ @@fin_false +@@selchanged: + XCHG EAX, EBX + CALL TControl.DoSelChange + +@@fin_false: + POP EBX +@@ret_false: + XOR EAX, EAX +end; +{$ELSE NEW VERSION OF WndProcTreeView} +function WndProcTreeView( Self_: PControl; var Msg: TMsg; var Rslt: Integer ): Boolean; +asm + PUSH ESI + PUSH EDI + MOV EDI, ECX // EDI -> Rslt + XOR ECX, ECX + CMP WORD PTR [EDX].TMsg.message, WM_NOTIFY + JNZ @@ret_false1 + XCHG ESI, EAX + MOV EDX, [EDX].TMsg.lParam + CMP WORD PTR [EDX].TNMTreeView.hdr.code, NM_RCLICK + JNE @@chk_TVN_BEGINDRAG + PUSH ECX + PUSH ECX + PUSH ESP + CALL GetCursorPos + MOV EAX, ESI + MOV EDX, ESP + MOV ECX, EDX + CALL TControl.Screen2Client + POP EDX + POP EAX + SHLD EAX, EDX, 16 + PUSH EAX + CALL GetShiftState + PUSH EAX + PUSH WM_RBUTTONUP + PUSH ESI + CALL TControl.PostMsg + JMP @@ret_false1 +@@prepareCallEvent: + STC + MOV EDX, ESI + {$IFDEF EVENTS_DYNAMIC} + MOV ESI, [ESI].TControl.EV + LEA ECX, [ESI+ECX*8].TEvents.fOnTVBeginDrag + {$ELSE} + LEA ECX, [ESI+ECX*8].TControl.EV.fOnTVBeginDrag + {$ENDIF} + MOV EAX, [ECX].TMethod.Data + MOV ECX, [ECX].TMethod.Code + JECXZ @@noEvent + MOV ESI, ECX + AND EAX, EAX +@@noEvent: + RET +@@chk_TVN_BEGINDRAG: /////////////////////////////////////////////////////////// + CMP WORD PTR [EDX].TNMTreeView.hdr.code, TVN_BEGINDRAG + JE @@beginDrag + CMP WORD PTR [EDX].TNMTreeView.hdr.code, TVN_BEGINRDRAG + JNE @@chk_TVNBEGINLABELEDIT +@@beginDrag: + PUSH [EDX].TNMTreeView.itemNew.hItem + CALL @@prepareCallEvent + POP ECX + JC @@ret_false1 +@@justEventCall: + CALL ESI +@@RsltEAX_ResultFalse: + MOV [EDI], EAX + XOR EAX, EAX + POP EDI + POP ESI + RET +@@chk_TVNBEGINLABELEDIT: /////////////////////////////////////////////////////// + INC ECX // -> FOnTVBeginEdit + CMP WORD PTR [EDX].TNMTreeView.hdr.code, TVN_BEGINLABELEDIT + JNE @@chk_ENDLABELEDIT + /////////////////////////////////////////////////////////////////////// + XOR EAX, EAX + INC EAX + {$IFDEF USE_FLAGS} + TEST [ESI].TControl.fFlagsG6, 1 shl G6_Dragging + {$ELSE} + CMP [ESI].TControl.fDragging, 0 + {$ENDIF} + JNZ @@rsltEAX_ResultTrue + PUSH [EDX].TTVDispInfo.item.hItem + CALL @@prepareCallEvent + POP ECX + JC @@ret_false1 + CALL ESI +@@rsltEAX_ResultTrue: + MOV [EDI], EAX +@@ResultTrue: + MOV AL, 1 + POP EDI + POP ESI + RET +@@chk_ENDLABELEDIT: + INC ECX // -> fOnTVEndEdit + CMP WORD PTR [EDX].TNMTreeView.hdr.code, TVN_ENDLABELEDIT + JNE @@chk_ITEMEXPANDING + MOV EAX, [EDX].TTVDispInfo.item.pszText + TEST EAX, EAX + JZ @@ResultTrue + PUSH EAX + PUSH [EDX].TTVDispInfo.item.hItem + CALL @@prepareCallEvent + POP ECX + JNC @@justEventCall +@@Rslt1_ResultTrue: + XOR EAX, EAX + INC EAX + JMP @@RsltEAX_ResultFalse +@@chk_ITEMEXPANDING: /////////////////////////////////////////////////////////// + INC ECX // -> FOnTVExpanding + CMP WORD PTR [EDX].TNMTreeView.hdr.code, TVN_ITEMEXPANDING + JNE @@chk_ITEMEXPANDED +@@expanding_expanded: + CMP [EDX].TNMTreeView.action, TVE_EXPAND + SETZ AL + PUSH EAX + PUSH [EDX].TNMTreeView.itemNew.hItem +@@event3: + CALL @@prepareCallEvent + POP ECX + JNC @@justEventCall + POP EAX + JMP @@ret_false1 +@@chk_ITEMEXPANDED: //////////////////////////////////////////////////////////// + INC ECX // -> FOnTVExpanded + CMP [EDX].TNMTreeView.hdr.code, TVN_ITEMEXPANDED + JE @@expanding_expanded + /////////////////////////////////////////////////////////////////////// + INC ECX // -> FOnTVSelChanging + CMP [EDX].TNMTreeView.hdr.code, TVN_SELCHANGING + JNE @@chk_TVN_SELCHANGED + PUSH [EDX].TNMTreeView.itemNew.hItem + PUSH [EDX].TNMTreeView.itemOld.hItem + JMP @@event3 +@@chk_TVN_SELCHANGED: + CMP [EDX].TNMTreeView.hdr.code, TVN_SELCHANGED + JNE @@ret_false1 + XCHG EAX, ESI + CALL TControl.DoSelChange +@@ret_false1: + XOR EAX, EAX + POP EDI + POP ESI +end; +{$ENDIF} + +function NewTabControl( AParent: PControl; const Tabs: array of PKOLChar; Options: TTabControlOptions; + ImgList: PImageList; ImgList1stIdx: Integer ): PControl; +const lenf=high(TabControlFlags); //+++ +asm //cmd //opd + PUSH EBX + PUSH ESI + PUSH EDI + XCHG EBX, EAX + PUSH EDX + PUSH ECX + LEA EAX, [Options] + MOV EDX, offset[TabControlFlags] + XOR ECX, ECX + MOV CL, lenf + CALL MakeFlags + TEST byte ptr [Options], 4 + JZ @@0 + OR EAX, WS_TABSTOP or TCS_FOCUSONBUTTONDOWN +@@0: OR EAX, WS_CHILD or WS_CLIPSIBLINGS or WS_CLIPCHILDREN or WS_VISIBLE + XCHG ECX, EAX + XCHG EAX, EBX + MOV EDX, offset[WC_TABCONTROL] + PUSH 1 + {$IFDEF PACK_COMMANDACTIONS} + PUSH [TabControlActions_Packed] + {$ELSE} + PUSH offset[TabControlActions] + {$ENDIF} + CALL _NewCommonControl + MOV EBX, EAX + TEST [Options], 2 shl (tcoBorder - 1) + JNZ @@borderfixed + AND [EBX].TControl.fExStyle, not WS_EX_CLIENTEDGE +@@borderfixed: + MOV EDX, offset[WndProcTabControl] + CALL TControl.AttachProc + ADD [EBX].TControl.fBoundsRect.Right, 100-64 + ADD [EBX].TControl.fBoundsRect.Bottom, 100-64 + MOV ECX, [ImgList] + JECXZ @@2 + XCHG EAX, ECX + CALL TImageList.GetHandle + PUSH EAX + PUSH 0 + PUSH TCM_SETIMAGELIST + PUSH EBX + CALL TControl.Perform +@@2: + POP EDI // EDI = High(Tabs) + POP ESI // ESI = Tabs + XOR EDX, EDX // EDX := 0 (=I) + MOV EAX, [ImgList1stIdx] //(=II) +@@loop: + CMP EDX, EDI + JG @@e_loop + PUSH EAX + PUSH EDX + PUSH EAX + LODSD + XCHG ECX, EAX + MOV EAX, EBX + CALL TControl.TC_Insert + POP EDX + POP EAX + INC EAX + INC EDX + JMP @@loop +@@e_loop: + MOV byte ptr [EBX].TControl.fLookTabKeys, 1 + XCHG EAX, EBX + POP EDI + POP ESI + POP EBX +end; + +function NewToolbar( AParent: PControl; Align: TControlAlign; Options: TToolbarOptions; + Bitmap: HBitmap; const Buttons: array of PKOLChar; + const BtnImgIdxArray: array of Integer ) : PControl; +const szTBButton = Sizeof( TTBButton ); + Option3DBorder = 1 shl Ord( tbo3DBorder ); +asm //cmd //opd + PUSH EDI + MOVZX EDX, DL + PUSH EDX // Align + PUSH EAX // AParent + + XOR EAX, EAX + TEST CL, Option3DBorder + SETNZ AL + PUSH EAX + + PUSH ECX // Options + + MOV AL, ICC_BAR_CLASSES + CALL DoInitCommonControls + + MOV EAX, ESP + MOV EDX, offset[ToolbarOptions] + XOR ECX, ECX + MOV CL, 6 + CALL MakeFlags + POP EDX + + {$IFDEF COMMANDACTIONS_OBJ} + PUSH TOOLBAR_ACTIONS + {$ELSE} + PUSH 0 //: actions : = nil + {$ENDIF} + XCHG ECX, EAX // ECX = MakeFlags(...) + MOV EDI, ECX + MOV EAX, [ESP+8] // EAX = AParent + MOV EDX, [ESP+12] // EDX = Align + OR ECX, [EDX*4+offset ToolbarAligns] + OR ECX, WS_CHILD or WS_VISIBLE or TBSTYLE_TOOLTIPS + MOV EDX, offset[ TOOLBARCLASSNAME ] + CALL _NewCommonControl + {$IFDEF COMMANDACTIONS_OBJ} + MOV EDX, [EAX].TControl.fCommandActions + MOV [EDX].TCommandActionsObj.aClear, offset[ClearToolbar] + MOV [EDX].TCommandActionsObj.aGetCount, TB_BUTTONCOUNT + {$ELSE} + MOV [EAX].TControl.fCommandActions.aClear, offset[ClearToolbar] + MOV [EAX].TControl.fCommandActions.aGetCount, TB_BUTTONCOUNT + {$ENDIF} + {$IFDEF USE_FLAGS} + OR [EAX].TControl.fFlagsG5, 1 shl G5_IsButton + {$ELSE} + INC [EAX].TControl.fIsButton + {$ENDIF} + POP EDX // pop AParent + POP EDX // EDX = Align + PUSH EDX + TEST EDX, EDX + JE @@zero_bounds + ADD [EAX].TControl.fBoundsRect.Bottom, 26-64 + ADD [EAX].TControl.fBoundsRect.Right, 1000-64 + JMP @@bounds_ready +@@zero_bounds: + MOV [EAX].TControl.fBoundsRect.Left, EDX + MOV [EAX].TControl.fBoundsRect.Top, EDX + MOV [EAX].TControl.fBoundsRect.Right, EDX + MOV [EAX].TControl.fBoundsRect.Bottom, EDX +@@bounds_ready: + PUSH EBX + PUSH ESI + XCHG EBX, EAX + MOV ESI, offset[TControl.Perform] + PUSH 0 + PUSH 0 + PUSH TB_GETEXTENDEDSTYLE + PUSH EBX + CALL ESI + OR EAX, TBSTYLE_EX_DRAWDDARROWS + PUSH EAX + PUSH 0 + PUSH TB_SETEXTENDEDSTYLE + PUSH EBX + CALL ESI + MOV EDX, offset[WndProcToolbarCtrl] + MOV EAX, EBX + CALL TControl.AttachProc + MOV EDX, offset[WndProcDoEraseBkgnd] + MOV EAX, EBX + CALL TControl.AttachProc + PUSH 0 + PUSH szTBButton + PUSH TB_BUTTONSTRUCTSIZE + PUSH EBX + CALL ESI + PUSH 0 + MOVSX EAX, [EBX].TControl.fMargin + PUSH EAX + PUSH TB_SETINDENT + PUSH EBX + CALL ESI + MOV EAX, [ESP+8] // Align + {$IFDEF PARANOIA} DB $2C, 1 {$ELSE} SUB AL, 1 {$ENDIF} + JL @@bounds_correct + JE @@corr_right + {$IFDEF PARANOIA} DB $2C, 2 {$ELSE} SUB AL, 2 {$ENDIF} + JNE @@corr_bottom + @@corr_right: + MOV EDX, [EBX].TControl.fBoundsRect.Left + ADD EDX, 24 + MOV [EBX].TControl.fBoundsRect.Right, EDX + JMP @@bounds_correct + @@corr_bottom: + MOV EDX, [EBX].TControl.fBoundsRect.Top + ADD EDX, 22 + MOV [EBX].TControl.fBoundsrect.Bottom, EDX + @@bounds_correct: + {$IFnDEF TBBUTTONS_DFLT_NOAUTOSIZE} + MOV byte ptr [EBX].TControl.DF.fDefaultTBBtnStyle, TBSTYLE_AUTOSIZE + {$ENDIF} + MOV EDX, [Bitmap] + TEST EDX, EDX + JZ @@bitmap_added + MOV EAX, EBX + CALL TControl.TBAddBitmap + @@bitmap_added: + + PUSH dword ptr [BtnImgIdxArray] + PUSH dword ptr [BtnImgIdxArray-4] + MOV ECX, [Buttons-4] + MOV EDX, [Buttons] + MOV EAX, EBX + CALL TControl.TBAddButtons + + PUSH 0 + PUSH 0 + PUSH WM_SIZE + PUSH EBX + CALL ESI + // --- + {+|ecm|} + // --- + MOV EDX,EDI + OR EDX,[EBX].TControl.FStyle + MOV EAX,EBX + CALL TControl.SetStyle + // --- + {/+|ecm|} + // --- + XCHG EAX, EBX + POP ESI + POP EBX + POP EDX + POP EDI +end; + +function WndProcDateTimePickerNotify( Self_: PControl; var Msg: TMsg; var Rslt: Integer ): Boolean; +type + TStrStr = record + param_Date: TDateTime; + param_PtrToAccept: PInteger; + Accept: Integer; + UserString: String; + end; +const Size_TStrStr = sizeof( TStrStr ); +asm + PUSH ESI + PUSH EDI + MOV EDI, EDX + CMP WORD PTR [EDI].TMsg.message, WM_NOTIFY + JNZ @@ret_false + {$IFDEF EVENTS_DYNAMIC} + MOV ESI, [EAX].TControl.EV + {$ENDIF} + MOV ECX, [EDI].TMsg.lParam + MOV EDX, [ECX].TNMHdr.code + CMP EDX, DTN_DROPDOWN + JNZ @@chk_DTN_CLOSEUP + {$IFDEF EVENTS_DYNAMIC} + LEA ECX, [ESI].TEvents.fOnDropDown.TMethod.Code + {$ELSE} + LEA ECX, [EAX].TControl.EV.fOnDropDown.TMethod.Code + {$ENDIF} +@@event1: + MOV EDX, [ECX].TMethod.Data + MOV ECX, [ECX].TMethod.Code + {$IFDEF NIL_EVENTS} + JECXZ @@ret_false + {$ENDIF} + XCHG EAX, EDX + CALL ECX + JMP @@ret_false +@@chk_DTN_CLOSEUP: ///////////////////////////////////////////////////////////// + {$IFDEF EVENTS_DYNAMIC} + LEA ECX, [ESI].TEvents.fOnCloseUp.TMethod.Code + {$ELSE} + LEA ECX, [EAX].TControl.EV.fOnCloseUp.TMethod.Code + {$ENDIF} + CMP EDX, DTN_CLOSEUP + JE @@event1 +//////////////////////////////////////////////////////////////////////////////// + {$IFDEF EVENTS_DYNAMIC} + LEA ECX, [ESI].TEvents.fOnChangeCtl.TMethod.Code + {$ELSE} + LEA ECX, [EAX].TControl.EV.fOnChangeCtl.TMethod.Code + {$ENDIF} + CMP EDX, DTN_DATETIMECHANGE + JE @@event1 + CMP EDX, DTN_USERSTRING + JNE @@ret_false +//////////////////////////////////////////////////////////////////////////////// + {$IFDEF EVENTS_DYNAMIC} + MOV ECX, [ESI].TEvents.fOnDTPUserString.TMethod.Code + MOV EDX, [ESI].TEvents.fOnDTPUserString.TMethod.Data + {$ELSE} + MOV ECX, [EAX].TControl.EV.fOnDTPUserString.TMethod.Code + MOV EDX, [EAX].TControl.EV.fOnDTPUserString.TMethod.Data + {$ENDIF} + {$IFDEF NIL_EVENTS} + JECXZ @@ret_false + {$ENDIF} + SUB ESP, Size_TStrStr + MOV ESI, ESP + PUSHAD + CALL TControl.GetDateTime + FSTP QWORD PTR [ESI].TStrStr.param_Date + WAIT + //POPAD + //PUSHAD + LEA EAX, [ESI].TStrStr.UserString + AND dword ptr [EAX], 0 + MOV EDI, [EDI].TMsg.lParam + MOV EDX, [EDI].TNMDateTimeString.pszUserString + CALL System.@LStrFromPChar + LEA EAX, [ESI].TStrStr.Accept + MOV byte ptr [EAX], 1 + MOV [ESI].TStrStr.param_PtrToAccept, EAX + POPAD + MOV ESI, ECX + MOV ECX, [ESI].TStrStr.UserString + XCHG EAX, EDX + CALL ESI + MOV EAX, [ESP].TStrStr.Accept + AND EAX, 1 + MOV [EDI].TNMDateTimeString.dwFlags, EAX + LEA EAX, [ESI].TStrStr.UserString + CALL System.@LStrClr + ADD ESP, Size_TStrStr +@@ret_false: + XOR EAX, EAX + POP EDI + POP ESI +end; + +function TControl.GetWindowHandle: HWnd; +asm + MOV ECX, [EAX].fHandle + JECXZ @@1 + XCHG EAX, ECX + RET +@@1: + PUSH EBX + MOV EBX, EAX + {$IFDEF USE_FLAGS} + TEST [EBX].fFlagsG4, 1 shl G4_CreateVisible + {$ELSE} + CMP [EBX].fCreateVisible, 0 + {$ENDIF} + JNZ @@2 + + XOR EDX, EDX + CALL TControl.Set_Visible + + MOV EAX, EBX + CALL CallTControlCreateWindow + { This is a call to Pascal piece of code, which + calls virtual method TControl.CreateWindow } + + {$IFDEF USE_FLAGS} + OR [EBX].fFlagsG4, 1 shl G4_CreateHidden + {$ELSE} + INC [EBX].fCreateHidden + {$ENDIF} + JMP @@0 + +@@2: CALL CallTControlCreateWindow +@@0: MOV EAX, [EBX].fHandle + POP EBX +end; + +function TControl.CreateWindow: Boolean; +type PCreateWndParams = ^TCreateWndParams; +const + CS_OFF = CS_OWNDC or CS_CLASSDC or CS_PARENTDC or CS_GLOBALCLASS; + CS_ON = 0; //CS_VREDRAW or CS_HREDRAW; + szWndClass = sizeof( TWndClass ); + int_IDC_ARROW = integer( IDC_ARROW ); +asm + PUSH EBX + XCHG EBX, EAX + {$IFDEF DEBUG_CREATEWINDOW} + MOV EAX, EBX + CALL Debug_CreateWindow1 + {$ENDIF} + MOV ECX, [EBX].fParent + JECXZ @@chk_handle + XCHG EAX, ECX + CALL GetWindowHandle + TEST EAX, EAX + JZ @@ret_0 +@@chk_handle: + MOV ECX, [EBX].fHandle + JECXZ @@prepare_Params + MOV EAX, EBX + {$IFDEF USE_FLAGS} + TEST [EBX].fFlagsG4, 1 shl G4_CreateHidden + {$ELSE} + CMP [EBX].fCreateHidden, 0 + {$ENDIF} + JZ @@create_children + CALL CreateChildWindows + MOV EAX, EBX + MOV DL, 1 + CALL Set_Visible + {$IFDEF USE_FLAGS} + AND [EBX].fFlagsG4, not(1 shl G4_CreateHidden) + {$ELSE} + MOV [EBX].fCreateHidden, 0 + {$ENDIF} + JMP @@ret_true +@@create_children: + CALL CreateChildWindows +@@ret_true: + MOV AL, 1 +@@ret_0: + POP EBX + RET +@@prepare_params: + {$IFDEF USE_GRAPHCTLS} + {$IFDEF USE_FLAGS} + TEST [EBX].fFlagsG6, 1 shl G6_GraphicCtl + SETNZ AL + JNZ @@ret_0 + {$ELSE} + MOV AL, [EBX].fWindowed + CMP AL, 0 + JZ @@ret_0 + {$ENDIF} + {$ENDIF} + PUSH EBP + MOV EBP, ESP + + PUSH ECX // Params.WindowClass.lpszClassName := nil + PUSH ECX // Params.WindowClass.lpszMenuName := nil + PUSH ECX // Params.WindowClass.hbrBackground := 0 + PUSH int_IDC_ARROW + PUSH ECX + CALL LoadCursor + PUSH EAX // Params.WindowClass.hCursor := LoadCursor( 0, IDC_ARROW ) + XOR ECX, ECX + PUSH ECX // Params.WindowClass.hIcon := 0 + PUSH [hInstance]// Params.WindowClass.hInstance := hInstance + PUSH ECX // Params.WindowClass.cbWndExtra := 0 + PUSH ECX // Params.WindowClass.cbClsExtra := 0 + {$IFDEF SAFE_CODE} + PUSH [EBX].fDefWndProc // Params.WindowClass.lpfnWndProc := fDefWndProc + {$ELSE} + PUSH 0 + {$ENDIF} + PUSH [EBX].fClsStyle // Params.WindowClass.style := fStyle + ADD ESP, -64 + PUSH ECX + MOV EAX, EBX + MOV EDX, ESP + CALL get_ClassName + POP EDX + MOV EAX, ESP + PUSH EDX + //CALL StrPCopy // StrPCopy( Params.WinClsNamBuf, ClassName ) + CALL StrCopy + CALL RemoveStr + PUSH 0 // Params.Param := nil + PUSH [hInstance] // Params.Inst := hInstance + PUSH [EBX].fMenu // Params.Menu := fMenu + MOV DL, 1 + MOV EAX, EBX + CALL GetParentWnd + PUSH EAX // Params.WndParent := GetParentWnd( True ) + + MOV ECX, CW_USEDEFAULT + MOV EAX, [EBX].fBoundsRect.Bottom + MOV EDX, [EBX].fBoundsRect.Top + SUB EAX, EDX + JNZ @@1 + MOV EAX, ECX +@@1: PUSH EAX // Params.Height := Height | CW_UseDefault + MOV EAX, [EBX].fBoundsRect.Right + SUB EAX, [EBX].fBoundsRect.Left + {$IFDEF USE_CMOV} + CMOVZ EAX, ECX + {$ELSE} + JNZ @@2 + MOV EAX, ECX +@@2: {$ENDIF} + + PUSH EAX // Params.Width := Width | CW_UseDefault + MOV EAX, [EBX].fBoundsRect.Left + {$IFDEF USE_FLAGS} + TEST [EBX].fFlagsG3, 1 shl G3_IsControl + {$ELSE} + CMP [EBX].fIsControl, CL + {$ENDIF} + JNZ @@3 + {$IFDEF USE_FLAGS} + TEST [EBX].fFlagsG2, (1 shl G2_ChangedPos) + {$ELSE} + TEST byte ptr [EBX].fChangedPosSz, 3 + {$ENDIF USE_FLAGS} + JNZ @@3 + MOV EDX, ECX + XCHG EAX, ECX +@@3: PUSH EDX // Params.Y := Top | CW_UseDefault + PUSH EAX // Params.X := Left | CW_UseDefault + PUSH [EBX].fStyle // Params.Style := fStyle + PUSH [EBX].fCaption // Params.Caption := fCaption + LEA EAX, [ESP+40] + PUSH EAX // Params.WinClassName := @Params.WinClsNamBuf + PUSH [EBX].fExStyle // Params.ExStyle := fExStyle + + MOV ECX, [EBX].fControlClassName + JECXZ @@registerClass + LEA EAX, [ESP].TCreateWndParams.WindowClass + PUSH EAX // @Params.WindowClass + PUSH ECX // fControlClassName + PUSH [hInstance] // hInstance + CALL GetClassInfo + MOV EAX, [ESP].TCreateWndParams.Inst + MOV [ESP].TCreateWndParams.WindowClass.hInstance, EAX + AND [ESP].TCreateWndParams.WindowClass.style, not CS_OFF +@@registerClass: + CMP [EBX].fDefWndProc, 0 + JNE @@fDefWndProc_ready + MOV EAX, [ESP].TCreateWndParams.WindowClass.lpfnWndProc + MOV [EBX].fDefWndProc, EAX +@@fDefWndProc_ready: + MOV ECX, [ESP].TCreateWndParams.WndParent + TEST ECX, ECX + JNZ @@registerClass1 + TEST byte ptr [ESP].TCreateWndParams.Style+3, $40 + XCHG EAX, ECX + JNZ @@fin +@@registerClass1: + MOV EAX, [ESP].TCreateWndParams.WinClassName + MOV EDX, [ESP].TCreateWndParams.WindowClass.hInstance + ADD ESP, -szWndClass + PUSH ESP + PUSH EAX + PUSH EDX + CALL GetClassInfo + ADD ESP, szWndClass + TEST EAX, EAX + JNZ @@registered + MOV EAX, [ESP].TCreateWndParams.WinClassName + MOV [ESP].TCreateWndParams.WindowClass.lpszClassName, EAX + MOV [ESP].TCreateWndParams.WindowClass.lpfnWndProc, offset WndFunc + LEA EAX, [ESP].TCreateWndParams.WindowClass + PUSH EAX + CALL RegisterClass + TEST EAX, EAX + JZ @@fin +@@registered: + MOV [CreatingWindow], EBX + {$IFDEF DEBUG_CREATEWINDOW} + MOV EAX, EBX + MOV EDX, ESP + CALL Debug_CreateWindow2 + {$ENDIF} + CALL CreateWindowEx + MOV [EBX].fHandle, EAX + TEST EAX, EAX + JZ @@fin + PUSH EAX + {$IFDEF USE_PROP} + PUSH offset ID_SELF + {$ELSE} + PUSH GWL_USERDATA + {$ENDIF} + PUSH EAX + + PUSH 0 + PUSH $10002 //UIS_CLEAR or (UISF_HIDEFOCUS shl 16) + PUSH $0128 //WM_UPDATEUISTATE + PUSH EAX + CALL SendMessage + + {$IFDEF USE_PROP} + CALL GetProp + {$ELSE} + CALL GetWindowLong + {$ENDIF} + XCHG ECX, EAX + POP EAX + INC ECX + LOOP @@propSet + MOV [CreatingWindow], ECX + PUSH EBX + {$IFDEF USE_PROP} + PUSH offset ID_SELF + PUSH EAX + CALL SetProp + {$ELSE} + PUSH GWL_USERDATA + PUSH EAX + CALL SetWindowLong + {$ENDIF} +@@propSet: + {$IFDEF SMALLEST_CODE} + {$ELSE} + {$IFDEF USE_FLAGS} + TEST [EBX].fFlagsG3, 1 shl G3_IsControl + {$ELSE} + CMP [EBX].fIsControl, 0 + {$ENDIF} + JNZ @@iconSet + MOV EAX, EBX + CALL GetIcon + PUSH EAX + PUSH 1 + PUSH WM_SETICON + PUSH EBX + CALL Perform +@@iconSet: + {$ENDIF} + MOV ECX, [EBX].PP.fCreateWndExt + {$IFDEF NIL_EVENTS} + JECXZ @@dblbufcreate + {$ENDIF} + MOV EAX, EBX + CALL ECX +@@dblbufcreate: +@@applyfont: + MOV EAX, EBX + CALL [ApplyFont2Wnd_Proc] + MOV EAX, EBX + CALL [ApplyFont2Wnd_Proc] +@@createchildren: + XCHG EAX, EBX + CALL CreateChildWindows + MOV AL, 1 +@@fin: + MOV ESP, EBP + POP EBP +@@ret_false: + POP EBX +end; + + +function WndProcKeybd( Self_: PControl; var Msg: TMsg; var Rslt: Integer): Boolean; +asm + PUSH EBX + MOV ECX, [EDX].TMsg.message + SUB CX, $100 + CMP ECX, 5 + JA @@fin_false + XCHG EBX, EAX // EBX = @Self + XCHG EAX, ECX // EAX = message - WM_KEYFIRST + {$IFDEF EVENTS_DYNAMIC} + MOV ECX, [EBX].TControl.EV + LEA ECX, [ECX].TEvents.fOnKeyUp + {$ELSE} + LEA ECX, [EBX].TControl.EV.fOnKeyUp + {$ENDIF} + JZ @@event + {$IFDEF PARANOIA} DB $34, 1 {$ELSE} XOR AL, 1 {$ENDIF} + JZ @@event + //LEA ECX, [EBX].TControl.EV.fOnKeyDown + ADD ECX, 8 + {$IFDEF PARANOIA} DB $34, 1 {$ELSE} XOR AL, 1 {$ENDIF} + JZ @@event + {$IFDEF PARANOIA} DB $34, 4 {$ELSE} XOR AL, 4 {$ENDIF} + JZ @@event + //LEA ECX, [EBX].TControl.EV.fOnChar + SUB ECX, 24 + {$IFDEF PARANOIA} DB $34, 6 {$ELSE} XOR AL, 2 xor 4 {$ENDIF} + JZ @@event + {$IFDEF PARANOIA} DB $34, 4 {$ELSE} XOR AL, 6 xor 2 {$ENDIF} + JNZ @@fin_false +@@event: + {$IFDEF NIL_EVENTS} + CMP word ptr [ECX].TMethod.Code+2, 0 + JZ @@fin_false + {$ENDIF} + PUSH EDX + PUSH ECX + LEA ECX, [EDX].TMsg.wParam + PUSH ECX + CALL GetShiftState + POP ECX // @wParam + XCHG EAX, [ESP] // ShiftState; EAX=@event + MOV EDX, EBX // @Self + MOV EBX, [EAX].TMethod.Code + MOV EAX, [EAX].TMethod.Data + CALL EBX + + POP EDX + MOV ECX, [EDX].TMsg.wParam + JECXZ @@fin_true + +@@fin_false: + XOR EAX, EAX + POP EBX + RET + +@@fin_true: + MOV AL, 1 + POP EBX +end; + +function TControl.GetCaption: KOLString; +asm + PUSH EBX + PUSH EDI + XCHG EBX, EAX + MOV EDI, EDX + {$IFDEF USE_FLAGS} + TEST [EBX].fFlagsG1, (1 shl G1_IgnoreWndCaption) + {$ELSE} + CMP [EBX].fIgnoreWndCaption, 0 + {$ENDIF USE_FLAGS} + JNZ @@getFCaption + MOV ECX, [EBX].fHandle + JECXZ @@getFCaption +@@getWndCaption: + PUSH ECX + CALL GetWindowTextLength + PUSH EAX + XCHG EDX, EAX + LEA EAX, [EBX].fCaption + CALL System.@LStrSetLength + POP ECX + JECXZ @@getFCaption + INC ECX + PUSH ECX + PUSH [EBX].fCaption + PUSH [EBX].fHandle + CALL GetWindowText +@@getFCaption: + MOV EDX, [EBX].fCaption + XCHG EAX, EDI + {$IFNDEF UNICODE_CTRLS} + CALL System.@LStrAsg + {$ELSE} + CALL System.@WStrFromPChar + {$ENDIF} +@@exit: + POP EDI + POP EBX +end; + +function TControl.get_ClassName: AnsiString; +asm + PUSH EBX + XCHG EBX, EAX + XCHG EAX, EDX + MOV EDX, [EBX].fControlClassName + PUSH EAX + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar // EAX^ := String(EDX) + POP EAX + {$IFDEF USE_FLAGS} + TEST [EBX].fFlagsG6, 1 shl G6_CtlClassNameChg + {$ELSE} + CMP [EBX].fCtlClsNameChg, 0 + {$ENDIF} + JNZ @@exit + MOV ECX, [EAX] + MOV EDX, offset[ @@obj ] + CALL System.@LStrCat3 // EAX^ := EDX + ECX + JMP @@exit + + {$IFDEF _D2009orHigher} + DW 1252, 1 // CP_ANSI_LATIN1, Byte // TODO: CP_ACP + {$ENDIF} + DD -1, 4 // FFFFFFFF 04000000 obj_, 0 +@@obj: DB 'obj_', 0 +@@exit: + POP EBX +end; + +function TControl.GetItems(Idx: Integer): AnsiString; +asm + PUSH ESI + PUSH EDI + PUSH EBX + PUSH EBP + MOV EBP, ESP + + MOV EBX, EAX // @Self + MOV ESI, EDX // Idx + MOV EDI, ECX // @Result + + CALL Item2Pos + PUSH 0 // push 0 + PUSH EAX // store Pos + + XCHG EDX, EAX + MOV EAX, EBX + CALL Pos2Item // EAX = Idx' + XCHG ESI, EAX // ESI = Idx' + + XOR EAX, EAX + {$IFDEF COMMANDACTIONS_OBJ} + MOV ECX, [EBX].fCommandActions + MOVZX ECX, [ECX].TCommandActionsObj.aGetItemLength + {$ELSE} + MOVZX ECX, [EBX].fCommandActions.aGetItemLength + {$ENDIF} + JECXZ @@ret_empty + + PUSH ECX // push aGetItemLength + + PUSH EBX + CALL Perform + + TEST EAX, EAX + JZ @@ret_empty + + PUSH EAX // save L + ADD EAX, 4 + + CALL System.@GetMem // GetMem( L+4 ) + POP EDX // restore L + LEA ECX, [EDX+1] + MOV dword ptr [EAX], ECX + {$IFDEF COMMANDACTIONS_OBJ} + MOV ECX, [EBX].fCommandActions + MOVZX ECX, [ECX].TCommandActionsObj.aGetItemText + {$ELSE} + MOVZX ECX, [EBX].fCommandActions.aGetItemText + {$ENDIF} + JECXZ @@ret_buf + + PUSH EDX // save L + + PUSH EAX + PUSH EAX // push Buf + PUSH ESI // push Idx + + PUSH ECX // push aGetItemText + PUSH EBX + CALL Perform + POP EAX + + POP EDX +@@ret_buf: + MOV byte ptr [EAX + EDX], 0 // Buf[ L ] := #0 + +@@ret_empty: // EAX = 0 + XCHG EDX, EAX + MOV EAX, EDI + PUSH EDX + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + POP ECX + JECXZ @@exit + XCHG EAX, ECX + CALL System.@FreeMem +@@exit: + MOV ESP, EBP + POP EBP + POP EBX + POP EDI + POP ESI +end; + +procedure TControl.SetItems(Idx: Integer; const Value: AnsiString); +asm + PUSH EDI + PUSH EBX + XCHG EBX, EAX + XCHG EDI, EDX // EDI = Idx + CALL ECX2PChar + PUSH ECX // @Value[1] + + {$IFDEF COMMANDACTIONS_OBJ} + MOV ECX, [EBX].fCommandActions + MOVZX ECX, [ECX].TCommandActionsObj.aSetItemText + {$ELSE} + MOVZX ECX, [EBX].fCommandActions.aSetItemText + {$ENDIF} + JECXZ @@1 + + PUSH 0 + PUSH ECX + + MOV EDX, EDI + MOV EAX, EBX + CALL Item2Pos + PUSH EAX // store Strt + + MOV EDX, EDI + INC EDX + MOV EAX, EBX + CALL Item2Pos + POP EDX // EDX = Strt + + SUB EAX, EDX + PUSH EAX // store L + + MOV EAX, EBX + CALL SetSelStart + + POP EDX // EDX = L + PUSH EBX // prepare @Self for Perform + XCHG EAX, EBX + CALL SetSelLength + + // @Value[1] already in stack, + // 0 already in stack + // aSetItemText already in stack + // @Self already in stack + + CALL Perform + JMP @@exit + +@@1: // @Value[1] in stack already + POP EDX + {$IFDEF COMMANDACTIONS_OBJ} + MOV ECX, [EBX].fCommandActions + MOVZX ECX, [ECX].TCommandActionsObj.aDeleteItem + {$ELSE} + MOVZX ECX, [EBX].fCommandActions.aDeleteItem + {$ENDIF} + JECXZ @@exit + + {$IFNDEF NOT_FIX_CURINDEX} + PUSH ESI + PUSH EBP + + PUSH EDX + + MOV EAX, EBX // +AK + CALL GetCurIndex // +AK + XCHG ESI, EAX // ESI = TmpCurIdx + + MOV EAX, EBX + MOV EDX, EDI + CALL GetItemData + XCHG EBP, EAX // EBP = TmpData + + MOV EDX, EDI + MOV EAX, EBX + CALL Delete + + MOV EAX, EBX // *AK + MOV EDX, EDI + POP ECX + CALL Insert + + MOV ECX, EBP // ECX = TmpData + MOV EDX, EDI + MOV EAX, EBX + CALL SetItemData + + XCHG EAX, EBX // +AK + MOV EDX, ESI // +AK + CALL SetCurIndex // +AK + + POP EBP + POP ESI + {$ELSE NOT_FIX_CURINDEX} + PUSH EDX + + MOV EDX, EDI + MOV EAX, EBX + CALL Delete + + XCHG EAX, EBX + XCHG EDX, EDI + + POP ECX + CALL Insert + {$ENDIF NOT_FIX_CURINDEX} + +@@exit: + POP EBX + POP EDI +end; + +function TControl.Add(const S: KOLString): Integer; +asm + PUSH EBX + MOV EBX, EAX // EBX = @Self + + {$IFDEF COMMANDACTIONS_OBJ} + MOV ECX, [EBX].fCommandActions + MOVZX ECX, [ECX].TCommandActionsObj.aAddItem + {$ELSE} + MOVZX ECX, [EBX].fCommandActions.aAddItem // ECX = aAddItem + {$ENDIF} + JECXZ @@chk_addtext + + CALL EDX2PChar + PUSH EDX + PUSH 0 + PUSH ECX + PUSH EBX + CALL Perform + PUSH EAX + + MOV EAX, EBX + CALL TControl.GetItemsCount + XCHG EAX, ECX + LOOP @@ret_EAX + + XCHG EAX, EBX + INC ECX + XOR EDX, EDX + CALL TControl.SetItemSelected +@@ret_EAX: + POP EAX + JMP @@exit + +@@chk_addtext: + {$IFDEF COMMANDACTIONS_OBJ} + MOV ECX, [EBX].fCommandActions + MOV ECX, [ECX].TCommandActionsObj.aAddText + {$ELSE} + MOV ECX, [EBX].fCommandActions.aAddText + {$ENDIF} + JECXZ @@add_text_simple + + CALL ECX + JMP @@exit_0 + +@@add_text_simple: + LEA EAX, [EBX].fCaption + CALL System.@LStrCat + MOV EDX, [EBX].fCaption + MOV EAX, EBX + CALL SetCaption + +@@exit_0: + XOR EAX, EAX +@@exit: + POP EBX +end; + +function TControl.Insert(Idx: Integer; const S: AnsiString): Integer; +asm + CALL ECX2PChar + PUSH ECX + {$IFDEF COMMANDACTIONS_OBJ} + MOV ECX, [EAX].fCommandActions + MOVZX ECX, [ECX].TCommandActionsObj.aInsertItem + {$ELSE} + MOVZX ECX, [EAX].fCommandActions.aInsertItem + {$ENDIF} + JECXZ @@exit_1 + + PUSH EDX + PUSH ECX + PUSH EAX + CALL Perform + RET + +@@exit_1:OR EAX, -1 + POP ECX +end; + +procedure TTrayIcon.SetTooltip(const Value: AnsiString); +asm + PUSH EBX + XCHG EBX, EAX + MOV EAX, [EBX].fTooltip + PUSH EDX + CALL System.@LStrCmp + POP EDX + JE @@exit + LEA EAX, [EBX].fTooltip + CALL System.@LStrAsg + CMP [EBX].fActive, 0 + JE @@exit + XOR EDX, EDX + INC EDX // EDX = NIM_MODIFY + XCHG EAX, EBX + CALL SetTrayIcon +@@exit: + POP EBX +end; + +procedure TTrayIcon.SetTrayIcon(const Value: DWORD); +const sz_tid = sizeof( TNotifyIconData ); +asm + CMP [AppletTerminated], 0 + JE @@1 + MOV DL, NIM_DELETE +@@1: + PUSH EBX + PUSH ESI + MOV ESI, EAX + MOV EBX, EDX + + XOR ECX, ECX + PUSH ECX + ADD ESP, -60 + MOV EDX, [ESI].fToolTip + CALL EDX2PChar + MOV EAX, ESP + MOV CL, 63 + CALL StrLCopy + + PUSH [ESI].fIcon + PUSH CM_TRAYICON + XOR EDX, EDX + CMP BL, NIM_DELETE + JE @@2 + MOV DL, NIF_ICON or NIF_MESSAGE or NIF_TIP +@@2: PUSH EDX + PUSH ESI + MOV EAX, [ESI].FWnd + TEST EAX, EAX + JNZ @@3 + MOV EAX, [ESI].fControl + MOV EAX, [EAX].TControl.fHandle +@@3: + PUSH EAX + PUSH sz_tid + + PUSH ESP + PUSH EBX + CALL Shell_NotifyIcon + + ADD ESP, sz_tid + POP ESI + POP EBX +@@exit: +end; + +function WndProcJustOneNotify( Control: PControl; var Msg: TMsg; var Rslt: Integer ) : Boolean; +asm + PUSH EBP + MOV EBP, ESP + PUSHAD + CALL WndProcJustOne + POPAD + XOR EAX, EAX + PUSH ECX + MOV ECX, [EDX].TMsg.message + SUB ECX, [JustOneMsg] + POP ECX + JNE @@exit + MOV [ECX], EAX + CMP [OnAnotherInstance].TMethod.Code, EAX + JE @@exit_1 + + //MOV EAX, (MAX_PATH + 3) and 0FFFFCh + MOV AH, 2 + SUB ESP, EAX + + MOV ECX, ESP + PUSH EAX + PUSH ECX + PUSH [EDX].TMsg.lParam + CALL GetWindowText + + MOV EDX, ESP + PUSH 0 + MOV EAX, ESP + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + + MOV EDX, [ESP] + MOV EAX, [OnAnotherInstance].TMethod.Data + CALL [OnAnotherInstance].TMethod.Code + + MOV EAX, ESP + CALL System.@LStrClr +@@exit_1: + MOV AL, 1 +@@exit: + MOV ESP, EBP + POP EBP +end; + +function JustOneNotify( Wnd: PControl; const Identifier : AnsiString; + const aOnAnotherInstance: TOnAnotherInstance ) : Boolean; +asm + PUSHAD + MOV EBP, ESP + + XCHG EAX, EDX + PUSH EAX + CALL System.@LStrLen + POP EDX + ADD EAX, EAX + SUB ESP, EAX + MOV EAX, ESP + CALL StrPCopy + PUSH '.ega' + PUSH 'sseM' + PUSH ESP + CALL RegisterWindowMessage + MOV [JustOneMsg], EAX + TEST EAX, EAX + MOV ESP, EBP + POPAD + JE @@exit_f + PUSHAD + CALL JustOne + DEC AL + POPAD + JZ @@exit_t + PUSH EBX + XCHG EBX, EAX + XOR EDX, EDX + XCHG [EBX].TControl.fCaption, EDX + PUSH EDX + CALL GetCommandLine + XCHG EDX, EAX + LEA EAX, [EBX].TControl.fCaption + {$IFDEF _D2009orHigher} + PUSH ECX + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + {$IFDEF _D2009orHigher} + POP ECX + {$ENDIF} + MOV EAX, EBX + MOV EDX, [EBX].TControl.fCaption + CALL TControl.SetCaption + MOV EAX, EBX + CALL TControl.GetWindowHandle + TEST EAX, EAX + JZ @@rest_cap + PUSH BSM_APPLICATIONS + MOV EDX, ESP + PUSH EAX + PUSH 0 + PUSH [JustOneMsg] + PUSH EDX + PUSH BSF_QUERY or BSF_IGNORECURRENTTASK + CALL BroadcastSystemMessage + POP EDX +@@rest_cap: + LEA EAX, [EBX].TControl.fCaption + CALL System.@LStrClr + POP EDX + MOV [EBX].TControl.fCaption, EDX + MOV EAX, EBX + CALL TControl.SetCaption + POP EBX +@@exit_f: + XOR EAX, EAX + JMP @@exit +@@exit_t: + PUSHAD + LEA ESI, [aOnAnotherInstance] + LEA EDI, [OnAnotherInstance] + MOVSD + MOVSD + MOV EDX, offset[WndProcJustOneNotify] + CALL TControl.AttachProc + POPAD + MOV AL, 1 +@@exit: +end; + +function TStrList.AppendToFile(const FileName: Ansistring): Boolean; +asm + PUSH EBX + MOV EBX, EDX + PUSH 0 + MOV EDX, ESP + CALL GetTextStr + XCHG EAX, EBX + MOV EDX, ofOpenWrite or ofOpenAlways + CALL FileCreate + MOV EBX, EAX + INC EAX + JZ @@exit + DEC EAX + XOR EDX, EDX + XOR ECX, ECX + MOV CL, spEnd + CALL FileSeek + POP EAX + PUSH EAX + CALL System.@LStrLen + XCHG ECX, EAX + MOV EAX, EBX + POP EDX + PUSH EDX + CALL FileWrite + XCHG EAX, EBX + CALL FileClose +@@exit: + CALL RemoveStr + POP EBX +end; + +function TStrList.LoadFromFile(const FileName: AnsiString): Boolean; +asm + PUSH EAX + XCHG EAX, EDX + MOV EDX, ofOpenRead or ofShareDenyWrite or ofOpenExisting + CALL FileCreate + INC EAX + JZ @@exit + DEC EAX + PUSH EBX + XCHG EBX, EAX + PUSH 0 + PUSH EBX + CALL GetFileSize + XOR EDX, EDX + PUSH EDX + XCHG ECX, EAX + MOV EAX, ESP + PUSH ECX + {$IFDEF _D2} + CALL _LStrFromPCharLen + {$ELSE} + {$IFDEF _D2009orHigher} + PUSH EDX // ushort 0, CodePage? + {$ENDIF} + CALL System.@LStrFromPCharLen + {$ENDIF} + POP ECX + MOV EAX, EBX + POP EDX + PUSH EDX + CALL FileRead + XCHG EAX, EBX + CALL FileClose + POP EDX + POP EBX + POP EAX + PUSH EDX + XOR ECX, ECX + CALL SetText + CALL RemoveStr + PUSH EDX + MOV AL, 1 +@@exit: POP EDX +end; + +function TStrList.SaveToFile(const FileName: Ansistring): Boolean; +asm + PUSH EBX + PUSH EAX + XCHG EAX, EDX + MOV EDX, ofOpenWrite or ofCreateAlways + CALL FileCreate + INC EAX + JZ @@exit + DEC EAX + XCHG EBX, EAX + POP EAX + PUSH 0 + MOV EDX, ESP + CALL GetTextStr + POP EAX + PUSH EAX + CALL System.@LStrLen + XCHG ECX, EAX + POP EDX + PUSH EDX + MOV EAX, EBX + CALL FileWrite + PUSH EBX + CALL SetEndOfFile + XCHG EAX, EBX + CALL FileClose + CALL RemoveStr + PUSH EDX + INC EAX +@@exit: + POP EDX + POP EBX +end; + +procedure TControl.SetStatusText(Index: Integer; const Value: KOLString); +asm + PUSHAD + MOV EBX, EDX // EBX = Index + MOV ESI, EAX // ESI = @Self + PUSH Value // prepare value for call at the end of procedure + PUSH EBX // prepare Index for call at the end of procedure + MOV ECX, [ESI].fStatusCtl + MOV EBP, ECX + INC ECX + LOOP @@status_created + CALL GetClientHeight + PUSH EAX // ch = old client height + MOV EAX, ESI + CALL _NewStatusBar + MOV [ESI].fStatusCtl, EAX + XCHG EBP, EAX + XOR EDX, EDX + PUSH EDX + INC DH + DEC EDX + CMP EBX, EDX + SETZ DL + NEG EDX + PUSH EDX + PUSH SB_SIMPLE + PUSH EBP + CALL TControl.Perform + ADD ESP, -16 + PUSH ESP + PUSH [EBP].fHandle + CALL GetWindowRect + POP EAX + POP EDX + POP EAX + POP EAX + SUB EAX, EDX + MOV [ESI].fClientBottom, AL + POP EDX // ch + PUSH 0 + PUSH 0 + PUSH WM_SIZE + PUSH EBP + MOV EAX, ESI + CALL TControl.SetClientHeight + CALL TControl.Perform +@@status_created: + CMP EBX, 255 + JGE @@not_simple + PUSH 0 + PUSH 0 + PUSH SB_GETPARTS + PUSH EBP + CALL Perform + CMP EAX, EBX + JG @@reset_simple + MOV EAX, ESI + CALL GetWidth + CDQ + MOV ECX, EBX + INC ECX + IDIV ECX + MOV EDX, EAX + ADD ESP, -1024 + /////////////////// + MOV ECX, EBX + MOV EDI, ESP + JECXZ @@2 +@@store_loo: + STOSD + ADD EAX, EDX + LOOP @@store_loo +@@2: + OR dword ptr [ESP+EBX*4], -1 + PUSH ESP + INC EBX + PUSH EBX + PUSH SB_SETPARTS + PUSH EBP + CALL Perform + //////////////////// + ADD ESP, 1024 +@@reset_simple: + PUSH 0 + PUSH 0 + PUSH SB_SIMPLE + PUSH EBP + CALL Perform +@@not_simple: + PUSH SB_SETTEXT + PUSH EBP + CALL Perform + POPAD +end; + +function TOpenSaveDialog.Execute: Boolean; +asm + PUSH EBX + XCHG EBX, EAX + + XOR ECX, ECX + {$IFDEF OpenSaveDialog_Extended} + MOVZX EAX, [EBX].NoPlaceBar + PUSH EAX + PUSH ECX + PUSH ECX + PUSH [EBX].TemplateName + PUSH [EBX].HookProc + {$ELSE} + PUSH ECX // prepare lpTemplateName = nil + PUSH ECX // prepare lpfnHook = nil + {$ENDIF} + PUSH EBX // prepare lCustData = @Self + MOV EDX, [EBX].FDefExtension + CALL EDX2PChar + PUSH EDX // prepare lpstrDefExt = FDefExtension + PUSH ECX // prepare nFileExtension, nFileOffset: Word = 0, 0 + // prepare flags: + LEA EAX, [EBX].FOptions + MOV EDX, Offset[@@OpenSaveFlags] + {$IFDEF OpenSaveDialog_Extended} + MOV CL, 14 + {$ELSE} + MOV CL, 12 + {$ENDIF} + CALL MakeFlags + XOR ECX, ECX + OR EAX, OFN_EXPLORER or OFN_LONGNAMES or OFN_ENABLESIZING + PUSH EAX // push Flags + PUSH [EBX].FTitle // prepare lpstrTitle + PUSH [EBX].FInitialDir // prepare lpstrInitialDir + PUSH ECX // prepare nMaxFileTitle = 0 + PUSH ECX // prepare lpstrFileTitle = nil + TEST AH, 2 // MultiSelect? + MOV EAX, 65520 + JNZ @@1 + MOV AX, MAX_PATH+2 +@@1: PUSH EAX // prepare nMaxFile + CALL System.@GetMem + POP ECX + PUSH ECX + PUSH EAX // prepare lpStrFile + XOR EDX, EDX + +@@2: MOV EDX, [EBX].fFileName // no, fill it initilly by FileName + CALL EDX2PChar + DEC ECX // added 5 october 2003 to prevent possible error if FileName too big + CALL StrLCopy + XOR EDX, EDX + + PUSH [EBX].FFilterIndex // prepare nFilterIndex + PUSH EDX // prepare nMaxCustFilter + PUSH EDX // prepare lpstrCustomFilter + PUSH EDX // prepare lpstrFilter = nil + MOV EAX, ESP + OR EDX, [EBX].FFilter + JZ @@5 + + MOV ECX, offset[@@0] + CALL System.@LStrCat3 // prepare lpStrFilter = FFilter + #0 + POP EAX + PUSH EAX + XOR EDX, EDX +@@3: INC EAX // filter is not starting from ';' or '|'... + CMP [EAX], DL + JZ @@5 + CMP byte ptr [EAX], '|' + JNZ @@3 +@@4: MOV [EAX], DL + JMP @@3 +@@OpenSaveFlags: + DD OFN_CREATEPROMPT, OFN_EXTENSIONDIFFERENT, OFN_FILEMUSTEXIST + DD OFN_HIDEREADONLY, OFN_NOCHANGEDIR, OFN_NODEREFERENCELINKS + DD OFN_ALLOWMULTISELECT, OFN_NONETWORKBUTTON, OFN_NOREADONLYRETURN + DD OFN_OVERWRITEPROMPT, OFN_PATHMUSTEXIST, OFN_READONLY, OFN_NOVALIDATE + {$IFDEF OpenSaveDialog_Extended} + DD OFN_ENABLETEMPLATE, OFN_ENABLEHOOK + {$ENDIF} + + {$IFDEF _D2009orHigher} + DW 0, 1 + {$ENDIF} + DD -1, 1 +@@0: DB 0 + + +@@5: + PUSH [hInstance] // prepare hInstance + + MOV ECX, [EBX].TControl.fWnd + INC ECX + LOOP @@6 + MOV ECX, [Applet] + JECXZ @@6 + MOV ECX, [ECX].TControl.fHandle +@@6: PUSH ECX // prepare hWndOwner + {$IFDEF OpenSaveDialog_Extended} + CALL WinVer + CMP AL, wvNT + MOV DL, 76+12 + JA @@6a + CMP AL, wvME + JE @@6a + MOV DL, 76 +@@6a: MOVZX EAX, DL + PUSH EAX + {$ELSE} + PUSH 76 // prepare lStructSize + {$ENDIF} + + PUSH ESP + CMP [EBX].TControl.FOpenDialog, 0 + JZ @@7 + CALL GetOpenFileName + JMP @@8 +@@7: CALL GetSaveFileName +@@8: + PUSH EAX + XOR EDX, EDX + TEST EAX, EAX + JZ @@10 + + MOV EAX, [ESP+4].TOpenFileName.nFilterIndex + MOV [EBX].FFilterIndex, EAX + + TEST BYTE PTR [ESP+4].TOpenFileName.Flags, OFN_READONLY + SETNZ AL + MOV [EBX].fOpenReadOnly, AL + + MOV EAX, [ESP+4].TOpenFileName.lpstrFile + MOV EDX, EAX + XOR ECX, ECX + + TEST [EBX].FOptions, 1 shl OSAllowMultiSelect + JZ @@10 + + DEC EAX +@@9: INC EAX + CMP byte ptr [EAX], CL + JNZ @@9 + CMP byte ptr [EAX+1], CL + JZ @@10 + MOV byte ptr [EAX], 13 + JMP @@9 + +@@10: + LEA EAX, [EBX].FFileName + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + MOV EAX, [ESP+4].TOpenFileName.lpstrFile + CALL System.@FreeMem // v1.86 +AK + + LEA EAX, [ESP+4].TOpenFileName.lpstrFilter + CALL System.@LStrClr + + POP EAX + {$IFDEF OpenSaveDialog_Extended} + ADD ESP, 76+12 + {$ELSE} + ADD ESP, 76 + {$ENDIF} + POP EBX +end; + +function TOpenDirDialog.Execute: Boolean; +asm + PUSH EBX + XCHG EBX, EAX + XOR ECX, ECX + PUSH ECX // prepare iImage = 0 + PUSH EBX // prepare lParam = @Self + PUSH [EBX].FCallBack // prepare lpfn = FCallBack + LEA EAX, [EBX].FOptions + MOV EDX, Offset[@@FlagsArray] + MOV CL, 8 + CALL MakeFlags + PUSH EAX // prepare ulFlags = Options + PUSH [EBX].FTitle // prepare lpszTitle + LEA EAX, [EBX].FBuf + PUSH EAX // prepare pszDisplayName + PUSH 0 // prepare pidlRoot + MOV ECX, [EBX].fWnd + INC ECX + LOOP @@1 + MOV ECX, Applet + JECXZ @@1 + MOV ECX, [ECX].TControl.fHandle +@@1: PUSH ECX // prepare hwndOwner + PUSH ESP + CALL SHBrowseForFolderA + ADD ESP, 32 + TEST EAX, EAX + JZ @@exit + PUSH EAX + LEA EDX, [EBX].FBuf + PUSH EDX + PUSH EAX + CALL SHGetPathFromIDListA + CALL CoTaskMemFree + MOV AL, 1 + JMP @@fin +@@FlagsArray: + DD BIF_BROWSEFORCOMPUTER, BIF_BROWSEFORPRINTER, BIF_DONTGOBELOWDOMAIN + DD BIF_RETURNFSANCESTORS, BIF_RETURNONLYFSDIRS, BIF_STATUSTEXT + DD BIF_BROWSEINCLUDEFILES, BIF_EDITBOX, BIF_NEWDIALOGSTYLE +@@exit: XOR EAX, EAX +@@fin: + POP EBX +end; + +function OpenDirSelChangeCallBack( Wnd: HWnd; Msg: DWORD; lParam, lpData: LParam ): + Integer; stdcall; +asm + MOV EAX, [lpData] + MOV ECX, [EAX].TOpenDirDialog.FOnSelChanged.TMethod.Code + JECXZ @@exit + LEA EDX, [EAX].TOpenDirDialog.FBuf + PUSH EDX + PUSH [lParam] + CALL SHGetPathFromIDListA + MOV EDX, [lpData] + LEA ECX, [EDX].TOpenDirDialog.FBuf + PUSH 0 + PUSH ESP + LEA EAX, [EDX].TOpenDirDialog.FStatusText + PUSH EAX + MOV EAX, [EDX].TOpenDirDialog.FOnSelChanged.TMethod.Data + CALL dword ptr [EDX].TOpenDirDialog.FOnSelChanged.TMethod.Code + PUSH 0 + PUSH BFFM_ENABLEOK + PUSH [Wnd] + CALL SendMessage +@@1: MOV EDX, [lpData] + MOV ECX, [EDX].TOpenDirDialog.FStatusText + JECXZ @@exit + PUSH ECX + PUSH 0 + PUSH BFFM_SETSTATUSTEXT + PUSH [Wnd] + CALL SendMessage +@@exit: XOR EAX, EAX +end; + +function TControl.TBAddInsButtons(Idx: Integer; const Buttons: array of PKOLChar; + const BtnImgIdxArray: array of Integer): Integer; stdcall; +asm { [EBP+$8] = @Self + [EBP+$C] = Idx + [EBP+$10] = Buttons + [EBP+$14] = High(Butons) + [EBP+$18] = BtnImgIdxArray + [EBP+$1C] = High(BtnImgIdxArray) } + PUSH EBX + PUSH ESI + PUSH EDI + OR EBX, -1 + MOV EAX, 20 + MOV ECX, [EBP+$14] + CMP ECX, EBX + JLE @@fin + INC ECX + MUL ECX + CALL System.@GetMem + PUSH EAX // save AB to FreeMem after + MOV EDX, EBX + DEC EDX // nBmp := -2 + MOV ECX, [EBP+$14] + INC ECX + JZ @@exit + MOV ECX, [EBP+$1C] + INC ECX + JZ @@1 + MOV ECX, [BtnImgIdxArray] + MOV EDX, [ECX] + DEC EDX // nBmp := BtnImgIdxArray[ 0 ] - 1 +@@1: MOV ECX, [EBP+$14] + INC ECX + MOV ESI, [Buttons] + MOV EDI, EAX // EDI = PAB + PUSH 0 // N:=0 in [EBP-$14] +@@loop: + LODSD + TEST EAX, EAX + JZ @@break + PUSH ECX + CMP word ptr [EAX], '-' + JNE @@2 + OR EAX, -1 + STOSD + MOV EAX, [ToolbarsIDcmd] + TEST EBX, EBX + {$IFDEF USE_CMOV} + CMOVL EBX, EAX + {$ELSE} + JGE @@b0 + MOV EBX, EAX +@@b0: {$ENDIF} + STOSD + XOR EAX, EAX + INC AH // TBSTYLE_SEP = 1 + STOSD + DEC AH + STOSD + DEC EAX + JMP @@3 + {$IFDEF _D2009orHigher} + DW 0, 1 + {$ENDIF} + DD -1, 1 +@@0: DB 0 +@@2: + INC EDX // Inc( nBmp ) + PUSH EAX + MOV EAX, [EBP+$1C] + MOV ECX, [EBP-$14] + CMP EAX, ECX + MOV EAX, EDX + JL @@21 + MOV EAX, [BtnImgIdxArray] + MOV EAX, [EAX+ECX*4] +@@21: STOSD + TEST EDX, EDX + JGE @@2a + DEC EDX +@@2a: + MOV EAX, [ToolbarsIDcmd] + STOSD + TEST EBX, EBX + {$IFDEF USE_CMOV} + CMOVL EBX, EAX + {$ELSE} + JGE @@210 + MOV EBX, EAX +@@210: {$ENDIF} + MOV ECX, [EBP+8] + MOV AH, BYTE PTR [ECX].TControl.DF.fDefaultTBBtnStyle + POP ECX + MOV AL, 4 // AL=fsState=_ENABLED, AH=fsStyle=_AUTOSIZE if fDefaultTBBtnStyle contains + CMP byte ptr [ECX], '^' + JNE @@22 + OR AH, TBSTYLE_DROPDOWN + INC ECX +@@22: CMP byte ptr [ECX], '-' + JZ @@23 + CMP byte ptr [ECX], '+' + JNZ @@24 + MOV AL, TBSTATE_ENABLED or TBSTATE_CHECKED +@@23: INC ECX + OR AH, TBSTYLE_CHECK + CMP byte ptr [ECX], '!' + JNZ @@24 + OR AH, TBSTYLE_GROUP + INC ECX +@@24: {$IFDEF TOOLBAR_DOT_NOAUTOSIZE_BUTTON} + CMP byte ptr [ECX], '.' + JNZ @@25 + AND AH, not TBSTYLE_AUTOSIZE + INC ECX +@@25: + {$ENDIF TOOLBAR_DOT_NOAUTOSIZE_BUTTON} + STOSD + MOV EAX, [EBP+8] + STOSD + OR EAX, -1 + CMP word ptr [ECX], ' ' + JZ @@3 + CMP byte ptr [ECX], 0 + JZ @@3 + PUSH EDX + PUSH 0 + MOV EDX, ECX + MOV EAX, ESP + {$IFDEF _D2009orHigher} + PUSH ECX + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + {$IFDEF _D2009orHigher} + POP ECX + {$ENDIF} + MOV EAX, ESP + MOV EDX, offset[@@0] + CALL System.@LStrCat + PUSH dword ptr [ESP] + PUSH 0 + PUSH TB_ADDSTRING + PUSH dword ptr [EBP+8] + CALL Perform + STOSD + CALL RemoveStr + POP EDX + JMP @@30 +@@3: STOSD +@@30: INC dword ptr [EBP-$14] + INC [ToolbarsIDcmd] + POP ECX + DEC ECX + JNZ @@loop +@@break: + POP ECX + JECXZ @@exit + PUSH dword ptr [ESP] + MOV EAX, [Idx] + TEST EAX, EAX + JGE @@31 + PUSH ECX + PUSH TB_ADDBUTTONS + JMP @@32 +@@31: + PUSH EAX + PUSH TB_INSERTBUTTON +@@32: + PUSH dword ptr [EBP+8] + CALL Perform +@@exit: + POP EAX + CALL System.@FreeMem +@@fin: + POP EDI + POP ESI + XCHG EAX, EBX + POP EBX +end; + +function TControl.TBGetButtonText( BtnID: Integer ): AnsiString; +asm + PUSH ECX + ADD ESP, -1024 + PUSH ESP + PUSH EAX + CALL GetTBBtnGoodID + POP EDX + PUSH EAX + PUSH TB_GETBUTTONTEXT + PUSH EDX + CALL Perform + TEST EAX, EAX + JLE @@2 + MOV EDX, ESP + JMP @@1 +@@2: XOR EDX, EDX +@@1: MOV EAX, [ESP+1024] + {$IFDEF _D2009orHigher} + XOR ECX, ECX + {$ENDIF} + CALL System.@LStrFromPChar + ADD ESP, 1028 +end; + +procedure TBitmap.LoadFromResourceName(Inst: DWORD; ResName: PAnsiChar); +asm + PUSH EBX + MOV EBX, EAX + PUSHAD + CALL Clear + POPAD + XOR EAX, EAX + PUSH ECX + MOVZX ECX, [EBX].fHandleType + INC ECX + LOOP @@1 + MOV AH, LR_CREATEDIBSECTION shr 8 // = $2000 +@@1: MOV AL, LR_DEFAULTSIZE // = $40 + POP ECX + PUSH EAX + PUSH 0 + PUSH 0 + PUSH IMAGE_BITMAP + PUSH ECX + PUSH EDX + CALL LoadImage + TEST EAX, EAX + JZ @@exit + XCHG EDX, EAX + XCHG EAX, EBX + CALL SetHandle +@@exit: POP EBX +end; +{$ENDIF} diff --git a/MsgDecode.pas b/MsgDecode.pas new file mode 100644 index 0000000..7f53615 --- /dev/null +++ b/MsgDecode.pas @@ -0,0 +1,4957 @@ +type + TMessageDecoded = ( + cWM_NULL, // = $0000; + cWM_CREATE, // = $0001; + cWM_DESTROY, // = $0002; + cWM_MOVE, // = $0003; + cWM_0004, + cWM_SIZE, // = $0005; + cWM_ACTIVATE, // = $0006; + cWM_SETFOCUS, // = $0007; + cWM_KILLFOCUS, // = $0008; + cWM_0009, + cWM_ENABLE, // = $000A; + cWM_SETREDRAW, // = $000B; + cWM_SETTEXT, // = $000C; + cWM_GETTEXT, // = $000D; + cWM_GETTEXTLENGTH,// = $000E; + cWM_PAINT, // = $000F; + cWM_CLOSE, // = $0010; + cWM_QUERYENDSESSION,// = $0011; + cWM_QUIT, // = $0012; + cWM_QUERYOPEN, // = $0013; + cWM_ERASEBKGND, // = $0014; + cWM_SYSCOLORCHANGE,// = $0015; + cWM_ENDSESSION, // = $0016; + cWM_SYSTEMERROR, // = $0017; + cWM_SHOWWINDOW, // = $0018; + cWM_CTLCOLOR, // = $0019; + cWM_WININICHANGE,// = $001A; + //WM_SETTINGCHANGE = WM_WININICHANGE; + cWM_DEVMODECHANGE,// = $001B; + cWM_ACTIVATEAPP, // = $001C; + cWM_FONTCHANGE, // = $001D; + cWM_TIMECHANGE, // = $001E; + cWM_CANCELMODE, // = $001F; + cWM_SETCURSOR, // = $0020; + cWM_MOUSEACTIVATE,// = $0021; + cWM_CHILDACTIVATE,// = $0022; + cWM_QUEUESYNC, // = $0023; + cWM_GETMINMAXINFO,// = $0024; + cWM_0025, + cWM_PAINTICON, // = $0026; + cWM_ICONERASEBKGND,// = $0027; + cWM_NEXTDLGCTL, // = $0028; + cWM_0029, + cWM_SPOOLERSTATUS,// = $002A; + cWM_DRAWITEM, // = $002B; + cWM_MEASUREITEM, // = $002C; + cWM_DELETEITEM, // = $002D; + cWM_VKEYTOITEM, // = $002E; + cWM_CHARTOITEM, // = $002F; + cWM_SETFONT, // = $0030; + cWM_GETFONT, // = $0031; + cWM_SETHOTKEY, // = $0032; + cWM_GETHOTKEY, // = $0033; + cWM_0034, + cWM_0035, + cWM_0036, + cWM_QUERYDRAGICON,// = $0037; + cWM_0038, + cWM_COMPAREITEM, // = $0039; + cWM_003A, + cWM_003B, + cWM_003C, + cWM_GETOBJECT, // = $003D; + cWM_003E, + cWM_003F, + cWM_0040, + cWM_COMPACTING, // = $0041; + cWM_0042, + cWM_0043, + cWM_COMMNOTIFY, // = $0044; { obsolete in Win32} + cWM_0045, + cWM_WINDOWPOSCHANGING,// = $0046; + cWM_WINDOWPOSCHANGED,// = $0047; + cWM_POWER, // = $0048; + cWM_0049, + cWM_COPYDATA, // = $004A; + cWM_CANCELJOURNAL,// = $004B; + cWM_004C, + cWM_004D, + cWM_NOTIFY, // = $004E; + cWM_004F, + cWM_INPUTLANGCHANGEREQUEST,// = $0050; + cWM_INPUTLANGCHANGE,// = $0051; + cWM_TCARD, // = $0052; + cWM_HELP, // = $0053; + cWM_USERCHANGED, // = $0054; + cWM_NOTIFYFORMAT, // = $0055; + cWM_0056, + cWM_0057, + cWM_0058, + cWM_0059, + cWM_005A, + cWM_005B, + cWM_005C, + cWM_005D, + cWM_005E, + cWM_005F, + cWM_0060, + cWM_0061, + cWM_0062, + cWM_0063, + cWM_0064, + cWM_0065, + cWM_0066, + cWM_0067, + cWM_0068, + cWM_0069, + cWM_006A, + cWM_006B, + cWM_006C, + cWM_006D, + cWM_006E, + cWM_006F, + cWM_0070, + cWM_0071, + cWM_0072, + cWM_0073, + cWM_0074, + cWM_0075, + cWM_0076, + cWM_0077, + cWM_0078, + cWM_0079, + cWM_007A, + cWM_CONTEXTMENU, // = $007B; + cWM_STYLECHANGING,// = $007C; + cWM_STYLECHANGED, // = $007D; + cWM_DISPLAYCHANGE,// = $007E; + cWM_GETICON, // = $007F; + cWM_SETICON, // = $0080; + cWM_NCCREATE, // = $0081; + cWM_NCDESTROY, // = $0082; + cWM_NCCALCSIZE, // = $0083; + cWM_NCHITTEST, // = $0084; + cWM_NCPAINT, // = $0085; + cWM_NCACTIVATE, // = $0086; + cWM_GETDLGCODE, // = $0087; + cWM_0088, + cWM_0089, + cWM_008A, + cWM_008B, + cWM_008C, + cWM_008D, + cWM_008E, + cWM_008F, + cWM_0090, + cWM_0091, + cWM_0092, + cWM_0093, + cWM_0094, + cWM_0095, + cWM_0096, + cWM_0097, + cWM_0098, + cWM_0099, + cWM_009A, + cWM_009B, + cWM_009C, + cWM_009D, + cWM_009E, + cWM_009F, + cWM_NCMOUSEMOVE, // = $00A0; + cWM_NCLBUTTONDOWN, // = $00A1; + cWM_NCLBUTTONUP, // = $00A2; + cWM_NCLBUTTONDBLCLK,// = $00A3; + cWM_NCRBUTTONDOWN, // = $00A4; + cWM_NCRBUTTONUP, // = $00A5; + cWM_NCRBUTTONDBLCLK,// = $00A6; + cWM_NCMBUTTONDOWN, // = $00A7; + cWM_NCMBUTTONUP, // = $00A8; + cWM_NCMBUTTONDBLCLK,// = $00A9; + cWM_00AA, + cWM_NCXBUTTONDOWN, // = $00AB; + cWM_NCXBUTTONUP, // = $00AC; + cWM_NCXBUTTONDBLCLK,// = $00AD; + cWM_00AE, + cWM_00AF, + cEM_GETSEL, // = $00B0; + cEM_SETSEL, // = $00B1; + cEM_GETRECT, // = $00B2; + cEM_SETRECT, // = $00B3; + cEM_SETRECTNP, // = $00B4; + cEM_SCROLL, // = $00B5; + cEM_LINESCROLL, // = $00B6; + cEM_SCROLLCARET, // = $00B7; + cEM_GETMODIFY, // = $00B8; + cEM_SETMODIFY, // = $00B9; + cEM_GETLINECOUNT, // = $00BA; + cEM_LINEINDEX, // = $00BB; + cEM_SETHANDLE, // = $00BC; + cEM_GETHANDLE, // = $00BD; + cEM_GETTHUMB, // = $00BE; + cWM_00BF, + cWM_00C0, + cEM_LINELENGTH, // = $00C1; + cEM_REPLACESEL, // = $00C2; + cWM_00C3, + cEM_GETLINE, // = $00C4; + cEM_LIMITTEXT, // = $00C5; + cEM_CANUNDO, // = $00C6; + cEM_UNDO, // = $00C7; + cEM_FMTLINES, // = $00C8; + cEM_LINEFROMCHAR, // = $00C9; + cWM_00CA, + cEM_SETTABSTOPS, // = $00CB; + cEM_SETPASSWORDCHAR,// = $00CC; + cEM_EMPTYUNDOBUFFER,// = $00CD; + cEM_GETFIRSTVISIBLELINE,// = $00CE; + cEM_SETREADONLY, // = $00CF; + cEM_SETWORDBREAKPROC,// = $00D0; + cEM_GETWORDBREAKPROC,// = $00D1; + cEM_GETPASSWORDCHAR,// = $00D2; + cEM_SETMARGINS, // = 211; + cEM_GETMARGINS, // = 212; + //EM_SETLIMITTEXT = EM_LIMITTEXT; //win40 Name change + cEM_GETLIMITTEXT, // = 213; + cEM_POSFROMCHAR, // = 214; + cEM_CHARFROMPOS, // = 215; + cEM_SETIMESTATUS, // = 216; + cEM_GETIMESTATUS, // = 217; = $D9; + cWM_00DA, + cWM_00DB, + cWM_00DC, + cWM_00DD, + cWM_00DE, + cWM_00DF, + cWM_00E0, + cWM_00E1, + cWM_00E2, + cWM_00E3, + cWM_00E4, + cWM_00E5, + cWM_00E6, + cWM_00E7, + cWM_00E8, + cWM_00E9, + cWM_00EA, + cWM_00EB, + cWM_00EC, + cWM_00ED, + cWM_00EE, + cWM_00EF, + cBM_GETCHECK, // = $00F0; + cBM_SETCHECK, // = $00F1; + cBM_GETSTATE, // = $00F2; + cBM_SETSTATE, // = $00F3; + cBM_SETSTYLE, // = $00F4; + cBM_CLICK, // = $00F5; + cBM_GETIMAGE, // = $00F6; + cBM_SETIMAGE, // = $00F7; + cWM_00F8, + cWM_00F9, + cWM_00FA, + cWM_00FB, + cWM_00FC, + cWM_00FD, + cWM_00FE, + cWM_INPUT, // = $00FF; + //WM_KEYFIRST = $0100; + cWM_KEYDOWN, // = $0100; + cWM_KEYUP, // = $0101; + cWM_CHAR, // = $0102; + cWM_DEADCHAR, // = $0103; + cWM_SYSKEYDOWN, // = $0104; + cWM_SYSKEYUP, // = $0105; + cWM_SYSCHAR, // = $0106; + cWM_SYSDEADCHAR, // = $0107; + cWM_KEYLAST, // = $0108; + cWM_0109, + cWM_010A, + cWM_010B, + cWM_010C, + cWM_IME_STARTCOMPOSITION, // = $010D; + cWM_IME_ENDCOMPOSITION, // = $010E; + cWM_IME_COMPOSITION, // = $010F; + cWM_INITDIALOG, // = $0110; + cWM_COMMAND, // = $0111; + cWM_SYSCOMMAND, // = $0112; + cWM_TIMER, // = $0113; + cWM_HSCROLL, // = $0114; + cWM_VSCROLL, // = $0115; + cWM_INITMENU, // = $0116; + cWM_INITMENUPOPUP, // = $0117; + cWM_0118, + cWM_0119, + cWM_011A, + cWM_011B, + cWM_011C, + cWM_011D, + cWM_011E, + cWM_MENUSELECT, // = $011F; + cWM_MENUCHAR, // = $0120; + cWM_ENTERIDLE, // = $0121; + cWM_MENURBUTTONUP, // = $0122; + cWM_MENUDRAG, // = $0123; + cWM_MENUGETOBJECT, // = $0124; + cWM_UNINITMENUPOPUP, // = $0125; + cWM_MENUCOMMAND, // = $0126; + cWM_CHANGEUISTATE, // = $0127; + cWM_UPDATEUISTATE, // = $0128; + cWM_QUERYUISTATE, // = $0129; + cWM_012A, + cWM_012B, + cWM_012C, + cWM_012D, + cWM_012E, + cWM_012F, + cWM_0130, + cWM_0131, + cWM_CTLCOLORMSGBOX, // = $0132; + cWM_CTLCOLOREDIT, // = $0133; + cWM_CTLCOLORLISTBOX, // = $0134; + cWM_CTLCOLORBTN, // = $0135; + cWM_CTLCOLORDLG, // = $0136; + cWM_CTLCOLORSCROLLBAR, // = $0137; + cWM_CTLCOLORSTATIC, // = $0138; + cWM_0139, + cWM_013A, + cWM_013B, + cWM_013C, + cWM_013D, + cWM_013E, + cWM_013F, + cCB_GETEDITSEL, // = $0140; + cCB_LIMITTEXT, // = $0141; + cCB_SETEDITSEL, // = $0142; + cCB_ADDSTRING, // = $0143; + cCB_DELETESTRING, // = $0144; + cCB_DIR, // = $0145; + cCB_GETCOUNT, // = $0146; + cCB_GETCURSEL, // = $0147; + cCB_GETLBTEXT, // = $0148; + cCB_GETLBTEXTLEN, // = $0149; + cCB_INSERTSTRING, // = $014A; + cCB_RESETCONTENT, // = $014B; + cCB_FINDSTRING, // = $014C; + cCB_SELECTSTRING, // = $014D; + cCB_SETCURSEL, // = $014E; + cCB_SHOWDROPDOWN, // = $014F; + cCB_GETITEMDATA, // = $0150; + cCB_SETITEMDATA, // = $0151; + cCB_GETDROPPEDCONTROLRECT,// = $0152; + cCB_SETITEMHEIGHT, // = $0153; + cCB_GETITEMHEIGHT, // = $0154; + cCB_SETEXTENDEDUI, // = $0155; + cCB_GETEXTENDEDUI, // = $0156; + cCB_GETDROPPEDSTATE, // = $0157; + cCB_FINDSTRINGEXACT, // = $0158; + cCB_SETLOCALE, // = 345; + cCB_GETLOCALE, // = 346; + cCB_GETTOPINDEX, // = 347; + cCB_SETTOPINDEX, // = 348; + cCB_GETHORIZONTALEXTENT, // = 349; + cCB_SETHORIZONTALEXTENT, // = 350; + cCB_GETDROPPEDWIDTH, // = 351; + cCB_SETDROPPEDWIDTH, // = 352; + cCB_INITSTORAGE, // = 353; + cCB_MSGMAX, // = 354; = $162 + cWM_0163, + cWM_0164, + cWM_0165, + cWM_0166, + cWM_0167, + cWM_0168, + cWM_0169, + cWM_016A, + cWM_016B, + cWM_016C, + cWM_016D, + cWM_016E, + cWM_016F, + cWM_0170, + cWM_0171, + cWM_0172, + cWM_0173, + cWM_0174, + cWM_0175, + cWM_0176, + cWM_0177, + cWM_0178, + cWM_0179, + cWM_017A, + cWM_017B, + cWM_017C, + cWM_017D, + cWM_017E, + cWM_017F, + cLB_ADDSTRING, // = $0180; + cLB_INSERTSTRING, // = $0181; + cLB_DELETESTRING, // = $0182; + cLB_SELITEMRANGEEX, // = $0183; + cLB_RESETCONTENT, // = $0184; + cLB_SETSEL, // = $0185; + cLB_SETCURSEL, // = $0186; + cLB_GETSEL, // = $0187; + cLB_GETCURSEL, // = $0188; + cLB_GETTEXT, // = $0189; + cLB_GETTEXTLEN, // = $018A; + cLB_GETCOUNT, // = $018B; + cLB_SELECTSTRING, // = $018C; + cLB_DIR, // = $018D; + cLB_GETTOPINDEX, // = $018E; + cLB_FINDSTRING, // = $018F; + cLB_GETSELCOUNT, // = $0190; + cLB_GETSELITEMS, // = $0191; + cLB_SETTABSTOPS, // = $0192; + cLB_GETHORIZONTALEXTENT,// = $0193; + cLB_SETHORIZONTALEXTENT,// = $0194; + cLB_SETCOLUMNWIDTH, // = $0195; + cLB_ADDFILE, // = $0196; + cLB_SETTOPINDEX, // = $0197; + cLB_GETITEMRECT, // = $0198; + cLB_GETITEMDATA, // = $0199; + cLB_SETITEMDATA, // = $019A; + cLB_SELITEMRANGE, // = $019B; + cLB_SETANCHORINDEX, // = $019C; + cLB_GETANCHORINDEX, // = $019D; + cLB_SETCARETINDEX, // = $019E; + cLB_GETCARETINDEX, // = $019F; + cLB_SETITEMHEIGHT, // = $01A0; + cLB_GETITEMHEIGHT, // = $01A1; + cLB_FINDSTRINGEXACT,// = $01A2; + cWM_01A3, + cWM_01A4, + cLB_SETLOCALE, // = $01A5; + cLB_GETLOCALE, // = $01A6; + cLB_SETCOUNT, // = $01A7; + cLB_INITSTORAGE, // = $01A8; + cLB_ITEMFROMPOINT, // = $01A9; + cWM_01AA, + cWM_01AB, + cWM_01AC, + cWM_01AD, + cWM_01AE, + cWM_01AF, + cWM_01B0, + cWM_01B1, + cWM_01B2, + cWM_01B3, + cWM_01B4, + cWM_01B5, + cWM_01B6, + cWM_01B7, + cWM_01B8, + cWM_01B9, + cWM_01BA, + cWM_01BB, + cWM_01BC, + cWM_01BD, + cWM_01BE, + cWM_01BF, + cWM_01C0, + cWM_01C1, + cWM_01C2, + cWM_01C3, + cWM_01C4, + cWM_01C5, + cWM_01C6, + cWM_01C7, + cWM_01C8, + cWM_01C9, + cWM_01CA, + cWM_01CB, + cWM_01CC, + cWM_01CD, + cWM_01CE, + cWM_01CF, + cWM_01D0, + cWM_01D1, + cWM_01D2, + cWM_01D3, + cWM_01D4, + cWM_01D5, + cWM_01D6, + cWM_01D7, + cWM_01D8, + cWM_01D9, + cWM_01DA, + cWM_01DB, + cWM_01DC, + cWM_01DD, + cWM_01DE, + cWM_01DF, + cWM_01E0, + cWM_01E1, + cWM_01E2, + cWM_01E3, + cWM_01E4, + cWM_01E5, + cWM_01E6, + cWM_01E7, + cWM_01E8, + cWM_01E9, + cWM_01EA, + cWM_01EB, + cWM_01EC, + cWM_01ED, + cWM_01EE, + cWM_01EF, + cWM_01F0, + cWM_01F1, + cWM_01F2, + cWM_01F3, + cWM_01F4, + cWM_01F5, + cWM_01F6, + cWM_01F7, + cWM_01F8, + cWM_01F9, + cWM_01FA, + cWM_01FB, + cWM_01FC, + cWM_01FD, + cWM_01FE, + cWM_01FF, + cWM_MOUSEMOVE, // = $0200; WM_MOUSEFIRST + cWM_LBUTTONDOWN, // = $0201; + cWM_LBUTTONUP, // = $0202; + cWM_LBUTTONDBLCLK, // = $0203; + cWM_RBUTTONDOWN, // = $0204; + cWM_RBUTTONUP, // = $0205; + cWM_RBUTTONDBLCLK, // = $0206; + cWM_MBUTTONDOWN, // = $0207; + cWM_MBUTTONUP, // = $0208; + cWM_MBUTTONDBLCLK, // = $0209; + cWM_MOUSEWHEEL, // = $020A; WM_MOUSELAST + cWM_020B, + cWM_020C, + cWM_020D, + cWM_020E, + cWM_020F, + cWM_PARENTNOTIFY, // = $0210; + cWM_ENTERMENULOOP, // = $0211; + cWM_EXITMENULOOP, // = $0212; + cWM_NEXTMENU, // = $0213; + cWM_SIZING, // = 532; = $214 + cWM_CAPTURECHANGED, // = 533; + cWM_MOVING, // = 534; + cWM_POWERBROADCAST, // = 536; + cWM_DEVICECHANGE, // = 537; = $218 + cWM_0219, + cWM_021A, + cWM_021B, + cWM_021C, + cWM_021D, + cWM_021E, + cWM_021F, + cWM_MDICREATE, // = $0220; + cWM_MDIDESTROY, // = $0221; + cWM_MDIACTIVATE, // = $0222; + cWM_MDIRESTORE, // = $0223; + cWM_MDINEXT, // = $0224; + cWM_MDIMAXIMIZE, // = $0225; + cWM_MDITILE, // = $0226; + cWM_MDICASCADE, // = $0227; + cWM_MDIICONARRANGE, // = $0228; + cWM_MDIGETACTIVE, // = $0229; + cWM_022A, + cWM_022B, + cWM_022C, + cWM_022D, + cWM_022E, + cWM_022F, + cWM_MDISETMENU, // = $0230; + cWM_ENTERSIZEMOVE, // = $0231; + cWM_EXITSIZEMOVE, // = $0232; + cWM_DROPFILES, // = $0233; + cWM_MDIREFRESHMENU, // = $0234; + cWM_0235, + cWM_0236, + cWM_0237, + cWM_0238, + cWM_0239, + cWM_023A, + cWM_023B, + cWM_023C, + cWM_023D, + cWM_023E, + cWM_023F, + cWM_0240, + cWM_0241, + cWM_0242, + cWM_0243, + cWM_0244, + cWM_0245, + cWM_0246, + cWM_0247, + cWM_0248, + cWM_0249, + cWM_024A, + cWM_024B, + cWM_024C, + cWM_024D, + cWM_024E, + cWM_024F, + cWM_0250, + cWM_0251, + cWM_0252, + cWM_0253, + cWM_0254, + cWM_0255, + cWM_0256, + cWM_0257, + cWM_0258, + cWM_0259, + cWM_025A, + cWM_025B, + cWM_025C, + cWM_025D, + cWM_025E, + cWM_025F, + cWM_0260, + cWM_0261, + cWM_0262, + cWM_0263, + cWM_0264, + cWM_0265, + cWM_0266, + cWM_0267, + cWM_0268, + cWM_0269, + cWM_026A, + cWM_026B, + cWM_026C, + cWM_026D, + cWM_026E, + cWM_026F, + cWM_0270, + cWM_0271, + cWM_0272, + cWM_0273, + cWM_0274, + cWM_0275, + cWM_0276, + cWM_0277, + cWM_0278, + cWM_0279, + cWM_027A, + cWM_027B, + cWM_027C, + cWM_027D, + cWM_027E, + cWM_027F, + cWM_0280, + cWM_IME_SETCONTEXT, // = $0281; + cWM_IME_NOTIFY, // = $0282; + cWM_IME_CONTROL, // = $0283; + cWM_IME_COMPOSITIONFULL,// = $0284; + cWM_IME_SELECT, // = $0285; + cWM_IME_CHAR, // = $0286; + cWM_0287, + cWM_IME_REQUEST, // = $0288; + cWM_0289, + cWM_028A, + cWM_028B, + cWM_028C, + cWM_028D, + cWM_028E, + cWM_028F, + cWM_IME_KEYDOWN, // = $0290; + cWM_IME_KEYUP, // = $0291; + cWM_0292, + cWM_0293, + cWM_0294, + cWM_0295, + cWM_0296, + cWM_0297, + cWM_0298, + cWM_0299, + cWM_029A, + cWM_029B, + cWM_029C, + cWM_029D, + cWM_029E, + cWM_029F, + cWM_NCMOUSEHOVER, // = $02A0; + cWM_MOUSEHOVER, // = $02A1; + cWM_NCMOUSELEAVE, // = $02A2; + cWM_MOUSELEAVE, // = $02A3; + cWM_02A4, + cWM_02A5, + cWM_02A6, + cWM_02A7, + cWM_02A8, + cWM_02A9, + cWM_02AA, + cWM_02AB, + cWM_02AC, + cWM_02AD, + cWM_02AE, + cWM_02AF, + cWM_02B0, + cWM_WTSSESSION_CHANGE, // = $02B1; + cWM_02B2, + cWM_02B3, + cWM_02B4, + cWM_02B5, + cWM_02B6, + cWM_02B7, + cWM_02B8, + cWM_02B9, + cWM_02BA, + cWM_02BB, + cWM_02BC, + cWM_02BD, + cWM_02BE, + cWM_02BF, + cWM_TABLET_FIRST, // = $02C0; + cWM_02C1, + cWM_02C2, + cWM_02C3, + cWM_02C4, + cWM_02C5, + cWM_02C6, + cWM_02C7, + cWM_02C8, + cWM_02C9, + cWM_02CA, + cWM_02CB, + cWM_02CC, + cWM_02CD, + cWM_02CE, + cWM_02CF, + cWM_02D0, + cWM_02D1, + cWM_02D2, + cWM_02D3, + cWM_02D4, + cWM_02D5, + cWM_02D6, + cWM_02D7, + cWM_02D8, + cWM_02D9, + cWM_02DA, + cWM_02DB, + cWM_02DC, + cWM_02DD, + cWM_02DE, + cWM_TABLET_LAST, // = $02DF; + cWM_02E0, + cWM_02E1, + cWM_02E2, + cWM_02E3, + cWM_02E4, + cWM_02E5, + cWM_02E6, + cWM_02E7, + cWM_02E8, + cWM_02E9, + cWM_02EA, + cWM_02EB, + cWM_02EC, + cWM_02ED, + cWM_02EE, + cWM_02EF, + cWM_02F0, + cWM_02F1, + cWM_02F2, + cWM_02F3, + cWM_02F4, + cWM_02F5, + cWM_02F6, + cWM_02F7, + cWM_02F8, + cWM_02F9, + cWM_02FA, + cWM_02FB, + cWM_02FC, + cWM_02FD, + cWM_02FE, + cWM_02FF, + cWM_CUT, // = $0300; + cWM_COPY, // = $0301; + cWM_PASTE, // = $0302; + cWM_CLEAR, // = $0303; + cWM_UNDO, // = $0304; + cWM_RENDERFORMAT, // = $0305; + cWM_RENDERALLFORMATS, // = $0306; + cWM_DESTROYCLIPBOARD, // = $0307; + cWM_DRAWCLIPBOARD, // = $0308; + cWM_PAINTCLIPBOARD, // = $0309; + cWM_VSCROLLCLIPBOARD, // = $030A; + cWM_SIZECLIPBOARD, // = $030B; + cWM_ASKCBFORMATNAME, // = $030C; + cWM_CHANGECBCHAIN, // = $030D; + cWM_HSCROLLCLIPBOARD, // = $030E; + cWM_QUERYNEWPALETTE, // = $030F; + cWM_PALETTEISCHANGING, // = $0310; + cWM_PALETTECHANGED, // = $0311; + cWM_HOTKEY, // = $0312; + cWM_0313, + cWM_0314, + cWM_0315, + cWM_0316, + cWM_0317, + cWM_0318, + cWM_APPCOMMAND, // = $0319; + cWM_THEMECHANGED, // = $031A; + cWM_031B, + cWM_031C, + cWM_031D, + cWM_031E, + cWM_031F, + cWM_0320, + cWM_0321, + cWM_0322, + cWM_0323, + cWM_0324, + cWM_0325, + cWM_0326, + cWM_0327, + cWM_0328, + cWM_0329, + cWM_032A, + cWM_032B, + cWM_032C, + cWM_032D, + cWM_032E, + cWM_032F, + cWM_0330, + cWM_0331, + cWM_0332, + cWM_0333, + cWM_0334, + cWM_0335, + cWM_0336, + cWM_0337, + cWM_0338, + cWM_0339, + cWM_033A, + cWM_033B, + cWM_033C, + cWM_033D, + cWM_033E, + cWM_033F, + cWM_0340, + cWM_0341, + cWM_0342, + cWM_0343, + cWM_0344, + cWM_0345, + cWM_0346, + cWM_0347, + cWM_0348, + cWM_0349, + cWM_034A, + cWM_034B, + cWM_034C, + cWM_034D, + cWM_034E, + cWM_034F, + cWM_0350, + cWM_0351, + cWM_0352, + cWM_0353, + cWM_0354, + cWM_0355, + cWM_0356, + cWM_0357, + cWM_0358, + cWM_0359, + cWM_035A, + cWM_035B, + cWM_035C, + cWM_035D, + cWM_035E, + cWM_035F, + cWM_0360, + cWM_0361, + cWM_0362, + cWM_0363, + cWM_0364, + cWM_0365, + cWM_0366, + cWM_0367, + cWM_0368, + cWM_0369, + cWM_036A, + cWM_036B, + cWM_036C, + cWM_036D, + cWM_036E, + cWM_036F, + cWM_0370, + cWM_0371, + cWM_0372, + cWM_0373, + cWM_0374, + cWM_0375, + cWM_0376, + cWM_0377, + cWM_0378, + cWM_0379, + cWM_037A, + cWM_037B, + cWM_037C, + cWM_037D, + cWM_037E, + cWM_037F, + cWM_PENWINFIRST, // = $0380; + cWM_0381, + cWM_0382, + cWM_0383, + cWM_0384, + cWM_0385, + cWM_0386, + cWM_0387, + cWM_0388, + cWM_0389, + cWM_038A, + cWM_038B, + cWM_038C, + cWM_038D, + cWM_038E, + cWM_PENWINLAST, // = $038F; + cWM_COALESCE_FIRST, // = $0390; + cWM_0391, + cWM_0392, + cWM_0393, + cWM_0394, + cWM_0395, + cWM_0396, + cWM_0397, + cWM_0398, + cWM_0399, + cWM_039A, + cWM_039B, + cWM_039C, + cWM_039D, + cWM_039E, + cWM_COALESCE_LAST, // = $039F; + cWM_03A0, + cWM_03A1, + cWM_03A2, + cWM_03A3, + cWM_03A4, + cWM_03A5, + cWM_03A6, + cWM_03A7, + cWM_03A8, + cWM_03A9, + cWM_03AA, + cWM_03AB, + cWM_03AC, + cWM_03AD, + cWM_03AE, + cWM_03AF, + cWM_03B0, + cWM_03B1, + cWM_03B2, + cWM_03B3, + cWM_03B4, + cWM_03B5, + cWM_03B6, + cWM_03B7, + cWM_03B8, + cWM_03B9, + cWM_03BA, + cWM_03BB, + cWM_03BC, + cWM_03BD, + cWM_03BE, + cWM_03BF, + cWM_03C0, + cWM_03C1, + cWM_03C2, + cWM_03C3, + cWM_03C4, + cWM_03C5, + cWM_03C6, + cWM_03C7, + cWM_03C8, + cWM_03C9, + cWM_03CA, + cWM_03CB, + cWM_03CC, + cWM_03CD, + cWM_03CE, + cWM_03CF, + cWM_03D0, + cWM_03D1, + cWM_03D2, + cWM_03D3, + cWM_03D4, + cWM_03D5, + cWM_03D6, + cWM_03D7, + cWM_03D8, + cWM_03D9, + cWM_03DA, + cWM_03DB, + cWM_03DC, + cWM_03DD, + cWM_03DE, + cWM_03DF, + cWM_DDE_INITIATE, // = WM_DDE_FIRST + 0; WM_DDE_FIRST = $03E0; + cWM_DDE_TERMINATE, // = WM_DDE_FIRST + 1; + cWM_DDE_ADVISE, // = WM_DDE_FIRST + 2; + cWM_DDE_UNADVISE, // = WM_DDE_FIRST + 3; + cWM_DDE_ACK, // = WM_DDE_FIRST + 4; + cWM_DDE_DATA, // = WM_DDE_FIRST + 5; + cWM_DDE_REQUEST, // = WM_DDE_FIRST + 6; + cWM_DDE_POKE, // = WM_DDE_FIRST + 7; + cWM_DDE_EXECUTE, // = WM_DDE_FIRST + 8; WM_DDE_LAST + cWM_03E9, + cWM_03EA, + cWM_03EB, + cWM_03EC, + cWM_03ED, + cWM_03EE, + cWM_03EF, + cWM_03F0, + cWM_03F1, + cWM_03F2, + cWM_03F3, + cWM_03F4, + cWM_03F5, + cWM_03F6, + cWM_03F7, + cWM_03F8, + cWM_03F9, + cWM_03FA, + cWM_03FB, + cWM_03FC, + cWM_03FD, + cWM_03FE, + cWM_03FF, + cWM_USER, // = $0400; + cWM_0401, + cWM_0402, + cWM_0403, + cWM_0404, + cWM_0405, + cWM_0406, + cWM_0407, + cWM_0408, + cWM_0409, + cWM_040A, + cWM_040B, + cWM_040C, + cWM_040D, + cWM_040E, + cWM_040F, + cWM_0410, + cWM_0411, + cWM_0412, + cWM_0413, + cWM_0414, + cWM_0415, + cWM_0416, + cWM_0417, + cWM_0418, + cWM_0419, + cWM_041A, + cWM_041B, + cWM_041C, + cWM_041D, + cWM_041E, + cWM_041F, + cWM_0420, + cWM_0421, + cWM_0422, + cWM_0423, + cWM_0424, + cWM_0425, + cWM_0426, + cWM_0427, + cWM_0428, + cWM_0429, + cWM_042A, + cWM_042B, + cWM_042C, + cWM_042D, + cWM_042E, + cWM_042F, + cWM_0430, + cWM_0431, + cWM_0432, + cWM_0433, + cWM_0434, + cWM_0435, + cWM_0436, + cWM_0437, + cWM_0438, + cWM_0439, + cWM_043A, + cWM_043B, + cWM_043C, + cWM_043D, + cWM_043E, + cWM_043F, + cWM_0440, + cWM_0441, + cWM_0442, + cWM_0443, + cWM_0444, + cWM_0445, + cWM_0446, + cWM_0447, + cWM_0448, + cWM_0449, + cWM_044A, + cWM_044B, + cWM_044C, + cWM_044D, + cWM_044E, + cWM_044F, + cWM_0450, + cWM_0451, + cWM_0452, + cWM_0453, + cWM_0454, + cWM_0455, + cWM_0456, + cWM_0457, + cWM_0458, + cWM_0459, + cWM_045A, + cWM_045B, + cWM_045C, + cWM_045D, + cWM_045E, + cWM_045F, + cWM_0460, + cWM_0461, + cWM_0462, + cWM_0463, + cWM_0464, + cWM_0465, + cWM_0466, + cWM_0467, + cWM_0468, + cWM_0469, + cWM_046A, + cWM_046B, + cWM_046C, + cWM_046D, + cWM_046E, + cWM_046F, + cWM_0470, + cWM_0471, + cWM_0472, + cWM_0473, + cWM_0474, + cWM_0475, + cWM_0476, + cWM_0477, + cWM_0478, + cWM_0479, + cWM_047A, + cWM_047B, + cWM_047C, + cWM_047D, + cWM_047E, + cWM_047F, + cWM_0480, + cWM_0481, + cWM_0482, + cWM_0483, + cWM_0484, + cWM_0485, + cWM_0486, + cWM_0487, + cWM_0488, + cWM_0489, + cWM_048A, + cWM_048B, + cWM_048C, + cWM_048D, + cWM_048E, + cWM_048F, + cWM_0490, + cWM_0491, + cWM_0492, + cWM_0493, + cWM_0494, + cWM_0495, + cWM_0496, + cWM_0497, + cWM_0498, + cWM_0499, + cWM_049A, + cWM_049B, + cWM_049C, + cWM_049D, + cWM_049E, + cWM_049F, + cWM_04A0, + cWM_04A1, + cWM_04A2, + cWM_04A3, + cWM_04A4, + cWM_04A5, + cWM_04A6, + cWM_04A7, + cWM_04A8, + cWM_04A9, + cWM_04AA, + cWM_04AB, + cWM_04AC, + cWM_04AD, + cWM_04AE, + cWM_04AF, + cWM_04B0, + cWM_04B1, + cWM_04B2, + cWM_04B3, + cWM_04B4, + cWM_04B5, + cWM_04B6, + cWM_04B7, + cWM_04B8, + cWM_04B9, + cWM_04BA, + cWM_04BB, + cWM_04BC, + cWM_04BD, + cWM_04BE, + cWM_04BF, + cWM_04C0, + cWM_04C1, + cWM_04C2, + cWM_04C3, + cWM_04C4, + cWM_04C5, + cWM_04C6, + cWM_04C7, + cWM_04C8, + cWM_04C9, + cWM_04CA, + cWM_04CB, + cWM_04CC, + cWM_04CD, + cWM_04CE, + cWM_04CF, + cWM_04D0, + cWM_04D1, + cWM_04D2, + cWM_04D3, + cWM_04D4, + cWM_04D5, + cWM_04D6, + cWM_04D7, + cWM_04D8, + cWM_04D9, + cWM_04DA, + cWM_04DB, + cWM_04DC, + cWM_04DD, + cWM_04DE, + cWM_04DF, + cWM_04E0, + cWM_04E1, + cWM_04E2, + cWM_04E3, + cWM_04E4, + cWM_04E5, + cWM_04E6, + cWM_04E7, + cWM_04E8, + cWM_04E9, + cWM_04EA, + cWM_04EB, + cWM_04EC, + cWM_04ED, + cWM_04EE, + cWM_04EF, + cWM_04F0, + cWM_04F1, + cWM_04F2, + cWM_04F3, + cWM_04F4, + cWM_04F5, + cWM_04F6, + cWM_04F7, + cWM_04F8, + cWM_04F9, + cWM_04FA, + cWM_04FB, + cWM_04FC, + cWM_04FD, + cWM_04FE, + cWM_04FF, + cWM_0500, + cWM_0501, + cWM_0502, + cWM_0503, + cWM_0504, + cWM_0505, + cWM_0506, + cWM_0507, + cWM_0508, + cWM_0509, + cWM_050A, + cWM_050B, + cWM_050C, + cWM_050D, + cWM_050E, + cWM_050F, + cWM_0510, + cWM_0511, + cWM_0512, + cWM_0513, + cWM_0514, + cWM_0515, + cWM_0516, + cWM_0517, + cWM_0518, + cWM_0519, + cWM_051A, + cWM_051B, + cWM_051C, + cWM_051D, + cWM_051E, + cWM_051F, + cWM_0520, + cWM_0521, + cWM_0522, + cWM_0523, + cWM_0524, + cWM_0525, + cWM_0526, + cWM_0527, + cWM_0528, + cWM_0529, + cWM_052A, + cWM_052B, + cWM_052C, + cWM_052D, + cWM_052E, + cWM_052F, + cWM_0530, + cWM_0531, + cWM_0532, + cWM_0533, + cWM_0534, + cWM_0535, + cWM_0536, + cWM_0537, + cWM_0538, + cWM_0539, + cWM_053A, + cWM_053B, + cWM_053C, + cWM_053D, + cWM_053E, + cWM_053F, + cWM_0540, + cWM_0541, + cWM_0542, + cWM_0543, + cWM_0544, + cWM_0545, + cWM_0546, + cWM_0547, + cWM_0548, + cWM_0549, + cWM_054A, + cWM_054B, + cWM_054C, + cWM_054D, + cWM_054E, + cWM_054F, + cWM_0550, + cWM_0551, + cWM_0552, + cWM_0553, + cWM_0554, + cWM_0555, + cWM_0556, + cWM_0557, + cWM_0558, + cWM_0559, + cWM_055A, + cWM_055B, + cWM_055C, + cWM_055D, + cWM_055E, + cWM_055F, + cWM_0560, + cWM_0561, + cWM_0562, + cWM_0563, + cWM_0564, + cWM_0565, + cWM_0566, + cWM_0567, + cWM_0568, + cWM_0569, + cWM_056A, + cWM_056B, + cWM_056C, + cWM_056D, + cWM_056E, + cWM_056F, + cWM_0570, + cWM_0571, + cWM_0572, + cWM_0573, + cWM_0574, + cWM_0575, + cWM_0576, + cWM_0577, + cWM_0578, + cWM_0579, + cWM_057A, + cWM_057B, + cWM_057C, + cWM_057D, + cWM_057E, + cWM_057F, + cWM_0580, + cWM_0581, + cWM_0582, + cWM_0583, + cWM_0584, + cWM_0585, + cWM_0586, + cWM_0587, + cWM_0588, + cWM_0589, + cWM_058A, + cWM_058B, + cWM_058C, + cWM_058D, + cWM_058E, + cWM_058F, + cWM_0590, + cWM_0591, + cWM_0592, + cWM_0593, + cWM_0594, + cWM_0595, + cWM_0596, + cWM_0597, + cWM_0598, + cWM_0599, + cWM_059A, + cWM_059B, + cWM_059C, + cWM_059D, + cWM_059E, + cWM_059F, + cWM_05A0, + cWM_05A1, + cWM_05A2, + cWM_05A3, + cWM_05A4, + cWM_05A5, + cWM_05A6, + cWM_05A7, + cWM_05A8, + cWM_05A9, + cWM_05AA, + cWM_05AB, + cWM_05AC, + cWM_05AD, + cWM_05AE, + cWM_05AF, + cWM_05B0, + cWM_05B1, + cWM_05B2, + cWM_05B3, + cWM_05B4, + cWM_05B5, + cWM_05B6, + cWM_05B7, + cWM_05B8, + cWM_05B9, + cWM_05BA, + cWM_05BB, + cWM_05BC, + cWM_05BD, + cWM_05BE, + cWM_05BF, + cWM_05C0, + cWM_05C1, + cWM_05C2, + cWM_05C3, + cWM_05C4, + cWM_05C5, + cWM_05C6, + cWM_05C7, + cWM_05C8, + cWM_05C9, + cWM_05CA, + cWM_05CB, + cWM_05CC, + cWM_05CD, + cWM_05CE, + cWM_05CF, + cWM_05D0, + cWM_05D1, + cWM_05D2, + cWM_05D3, + cWM_05D4, + cWM_05D5, + cWM_05D6, + cWM_05D7, + cWM_05D8, + cWM_05D9, + cWM_05DA, + cWM_05DB, + cWM_05DC, + cWM_05DD, + cWM_05DE, + cWM_05DF, + cWM_05E0, + cWM_05E1, + cWM_05E2, + cWM_05E3, + cWM_05E4, + cWM_05E5, + cWM_05E6, + cWM_05E7, + cWM_05E8, + cWM_05E9, + cWM_05EA, + cWM_05EB, + cWM_05EC, + cWM_05ED, + cWM_05EE, + cWM_05EF, + cWM_05F0, + cWM_05F1, + cWM_05F2, + cWM_05F3, + cWM_05F4, + cWM_05F5, + cWM_05F6, + cWM_05F7, + cWM_05F8, + cWM_05F9, + cWM_05FA, + cWM_05FB, + cWM_05FC, + cWM_05FD, + cWM_05FE, + cWM_05FF, + cWM_0600, + cWM_0601, + cWM_0602, + cWM_0603, + cWM_0604, + cWM_0605, + cWM_0606, + cWM_0607, + cWM_0608, + cWM_0609, + cWM_060A, + cWM_060B, + cWM_060C, + cWM_060D, + cWM_060E, + cWM_060F, + cWM_0610, + cWM_0611, + cWM_0612, + cWM_0613, + cWM_0614, + cWM_0615, + cWM_0616, + cWM_0617, + cWM_0618, + cWM_0619, + cWM_061A, + cWM_061B, + cWM_061C, + cWM_061D, + cWM_061E, + cWM_061F, + cWM_0620, + cWM_0621, + cWM_0622, + cWM_0623, + cWM_0624, + cWM_0625, + cWM_0626, + cWM_0627, + cWM_0628, + cWM_0629, + cWM_062A, + cWM_062B, + cWM_062C, + cWM_062D, + cWM_062E, + cWM_062F, + cWM_0630, + cWM_0631, + cWM_0632, + cWM_0633, + cWM_0634, + cWM_0635, + cWM_0636, + cWM_0637, + cWM_0638, + cWM_0639, + cWM_063A, + cWM_063B, + cWM_063C, + cWM_063D, + cWM_063E, + cWM_063F, + cWM_0640, + cWM_0641, + cWM_0642, + cWM_0643, + cWM_0644, + cWM_0645, + cWM_0646, + cWM_0647, + cWM_0648, + cWM_0649, + cWM_064A, + cWM_064B, + cWM_064C, + cWM_064D, + cWM_064E, + cWM_064F, + cWM_0650, + cWM_0651, + cWM_0652, + cWM_0653, + cWM_0654, + cWM_0655, + cWM_0656, + cWM_0657, + cWM_0658, + cWM_0659, + cWM_065A, + cWM_065B, + cWM_065C, + cWM_065D, + cWM_065E, + cWM_065F, + cWM_0660, + cWM_0661, + cWM_0662, + cWM_0663, + cWM_0664, + cWM_0665, + cWM_0666, + cWM_0667, + cWM_0668, + cWM_0669, + cWM_066A, + cWM_066B, + cWM_066C, + cWM_066D, + cWM_066E, + cWM_066F, + cWM_0670, + cWM_0671, + cWM_0672, + cWM_0673, + cWM_0674, + cWM_0675, + cWM_0676, + cWM_0677, + cWM_0678, + cWM_0679, + cWM_067A, + cWM_067B, + cWM_067C, + cWM_067D, + cWM_067E, + cWM_067F, + cWM_0680, + cWM_0681, + cWM_0682, + cWM_0683, + cWM_0684, + cWM_0685, + cWM_0686, + cWM_0687, + cWM_0688, + cWM_0689, + cWM_068A, + cWM_068B, + cWM_068C, + cWM_068D, + cWM_068E, + cWM_068F, + cWM_0690, + cWM_0691, + cWM_0692, + cWM_0693, + cWM_0694, + cWM_0695, + cWM_0696, + cWM_0697, + cWM_0698, + cWM_0699, + cWM_069A, + cWM_069B, + cWM_069C, + cWM_069D, + cWM_069E, + cWM_069F, + cWM_06A0, + cWM_06A1, + cWM_06A2, + cWM_06A3, + cWM_06A4, + cWM_06A5, + cWM_06A6, + cWM_06A7, + cWM_06A8, + cWM_06A9, + cWM_06AA, + cWM_06AB, + cWM_06AC, + cWM_06AD, + cWM_06AE, + cWM_06AF, + cWM_06B0, + cWM_06B1, + cWM_06B2, + cWM_06B3, + cWM_06B4, + cWM_06B5, + cWM_06B6, + cWM_06B7, + cWM_06B8, + cWM_06B9, + cWM_06BA, + cWM_06BB, + cWM_06BC, + cWM_06BD, + cWM_06BE, + cWM_06BF, + cWM_06C0, + cWM_06C1, + cWM_06C2, + cWM_06C3, + cWM_06C4, + cWM_06C5, + cWM_06C6, + cWM_06C7, + cWM_06C8, + cWM_06C9, + cWM_06CA, + cWM_06CB, + cWM_06CC, + cWM_06CD, + cWM_06CE, + cWM_06CF, + cWM_06D0, + cWM_06D1, + cWM_06D2, + cWM_06D3, + cWM_06D4, + cWM_06D5, + cWM_06D6, + cWM_06D7, + cWM_06D8, + cWM_06D9, + cWM_06DA, + cWM_06DB, + cWM_06DC, + cWM_06DD, + cWM_06DE, + cWM_06DF, + cWM_06E0, + cWM_06E1, + cWM_06E2, + cWM_06E3, + cWM_06E4, + cWM_06E5, + cWM_06E6, + cWM_06E7, + cWM_06E8, + cWM_06E9, + cWM_06EA, + cWM_06EB, + cWM_06EC, + cWM_06ED, + cWM_06EE, + cWM_06EF, + cWM_06F0, + cWM_06F1, + cWM_06F2, + cWM_06F3, + cWM_06F4, + cWM_06F5, + cWM_06F6, + cWM_06F7, + cWM_06F8, + cWM_06F9, + cWM_06FA, + cWM_06FB, + cWM_06FC, + cWM_06FD, + cWM_06FE, + cWM_06FF, + cWM_0700, + cWM_0701, + cWM_0702, + cWM_0703, + cWM_0704, + cWM_0705, + cWM_0706, + cWM_0707, + cWM_0708, + cWM_0709, + cWM_070A, + cWM_070B, + cWM_070C, + cWM_070D, + cWM_070E, + cWM_070F, + cWM_0710, + cWM_0711, + cWM_0712, + cWM_0713, + cWM_0714, + cWM_0715, + cWM_0716, + cWM_0717, + cWM_0718, + cWM_0719, + cWM_071A, + cWM_071B, + cWM_071C, + cWM_071D, + cWM_071E, + cWM_071F, + cWM_0720, + cWM_0721, + cWM_0722, + cWM_0723, + cWM_0724, + cWM_0725, + cWM_0726, + cWM_0727, + cWM_0728, + cWM_0729, + cWM_072A, + cWM_072B, + cWM_072C, + cWM_072D, + cWM_072E, + cWM_072F, + cWM_0730, + cWM_0731, + cWM_0732, + cWM_0733, + cWM_0734, + cWM_0735, + cWM_0736, + cWM_0737, + cWM_0738, + cWM_0739, + cWM_073A, + cWM_073B, + cWM_073C, + cWM_073D, + cWM_073E, + cWM_073F, + cWM_0740, + cWM_0741, + cWM_0742, + cWM_0743, + cWM_0744, + cWM_0745, + cWM_0746, + cWM_0747, + cWM_0748, + cWM_0749, + cWM_074A, + cWM_074B, + cWM_074C, + cWM_074D, + cWM_074E, + cWM_074F, + cWM_0750, + cWM_0751, + cWM_0752, + cWM_0753, + cWM_0754, + cWM_0755, + cWM_0756, + cWM_0757, + cWM_0758, + cWM_0759, + cWM_075A, + cWM_075B, + cWM_075C, + cWM_075D, + cWM_075E, + cWM_075F, + cWM_0760, + cWM_0761, + cWM_0762, + cWM_0763, + cWM_0764, + cWM_0765, + cWM_0766, + cWM_0767, + cWM_0768, + cWM_0769, + cWM_076A, + cWM_076B, + cWM_076C, + cWM_076D, + cWM_076E, + cWM_076F, + cWM_0770, + cWM_0771, + cWM_0772, + cWM_0773, + cWM_0774, + cWM_0775, + cWM_0776, + cWM_0777, + cWM_0778, + cWM_0779, + cWM_077A, + cWM_077B, + cWM_077C, + cWM_077D, + cWM_077E, + cWM_077F, + cWM_0780, + cWM_0781, + cWM_0782, + cWM_0783, + cWM_0784, + cWM_0785, + cWM_0786, + cWM_0787, + cWM_0788, + cWM_0789, + cWM_078A, + cWM_078B, + cWM_078C, + cWM_078D, + cWM_078E, + cWM_078F, + cWM_0790, + cWM_PRINT, // = 791; + cWM_PRINTCLIENT, // = 792; + cWM_0793, + cWM_0794, + cWM_0795, + cWM_0796, + cWM_0797, + cWM_0798, + cWM_0799, + cWM_079A, + cWM_079B, + cWM_079C, + cWM_079D, + cWM_079E, + cWM_079F, + cWM_07A0, + cWM_07A1, + cWM_07A2, + cWM_07A3, + cWM_07A4, + cWM_07A5, + cWM_07A6, + cWM_07A7, + cWM_07A8, + cWM_07A9, + cWM_07AA, + cWM_07AB, + cWM_07AC, + cWM_07AD, + cWM_07AE, + cWM_07AF, + cWM_07B0, + cWM_07B1, + cWM_07B2, + cWM_07B3, + cWM_07B4, + cWM_07B5, + cWM_07B6, + cWM_07B7, + cWM_07B8, + cWM_07B9, + cWM_07BA, + cWM_07BB, + cWM_07BC, + cWM_07BD, + cWM_07BE, + cWM_07BF, + cWM_07C0, + cWM_07C1, + cWM_07C2, + cWM_07C3, + cWM_07C4, + cWM_07C5, + cWM_07C6, + cWM_07C7, + cWM_07C8, + cWM_07C9, + cWM_07CA, + cWM_07CB, + cWM_07CC, + cWM_07CD, + cWM_07CE, + cWM_07CF, + cWM_07D0, + cWM_07D1, + cWM_07D2, + cWM_07D3, + cWM_07D4, + cWM_07D5, + cWM_07D6, + cWM_07D7, + cWM_07D8, + cWM_07D9, + cWM_07DA, + cWM_07DB, + cWM_07DC, + cWM_07DD, + cWM_07DE, + cWM_07DF, + cWM_07E0, + cWM_07E1, + cWM_07E2, + cWM_07E3, + cWM_07E4, + cWM_07E5, + cWM_07E6, + cWM_07E7, + cWM_07E8, + cWM_07E9, + cWM_07EA, + cWM_07EB, + cWM_07EC, + cWM_07ED, + cWM_07EE, + cWM_07EF, + cWM_07F0, + cWM_07F1, + cWM_07F2, + cWM_07F3, + cWM_07F4, + cWM_07F5, + cWM_07F6, + cWM_07F7, + cWM_07F8, + cWM_07F9, + cWM_07FA, + cWM_07FB, + cWM_07FC, + cWM_07FD, + cWM_07FE, + cWM_07FF, + cWM_0800, + cWM_0801, + cWM_0802, + cWM_0803, + cWM_0804, + cWM_0805, + cWM_0806, + cWM_0807, + cWM_0808, + cWM_0809, + cWM_080A, + cWM_080B, + cWM_080C, + cWM_080D, + cWM_080E, + cWM_080F, + cWM_0810, + cWM_0811, + cWM_0812, + cWM_0813, + cWM_0814, + cWM_0815, + cWM_0816, + cWM_0817, + cWM_0818, + cWM_0819, + cWM_081A, + cWM_081B, + cWM_081C, + cWM_081D, + cWM_081E, + cWM_081F, + cWM_0820, + cWM_0821, + cWM_0822, + cWM_0823, + cWM_0824, + cWM_0825, + cWM_0826, + cWM_0827, + cWM_0828, + cWM_0829, + cWM_082A, + cWM_082B, + cWM_082C, + cWM_082D, + cWM_082E, + cWM_082F, + cWM_0830, + cWM_0831, + cWM_0832, + cWM_0833, + cWM_0834, + cWM_0835, + cWM_0836, + cWM_0837, + cWM_0838, + cWM_0839, + cWM_083A, + cWM_083B, + cWM_083C, + cWM_083D, + cWM_083E, + cWM_083F, + cWM_0840, + cWM_0841, + cWM_0842, + cWM_0843, + cWM_0844, + cWM_0845, + cWM_0846, + cWM_0847, + cWM_0848, + cWM_0849, + cWM_084A, + cWM_084B, + cWM_084C, + cWM_084D, + cWM_084E, + cWM_084F, + cWM_0850, + cWM_0851, + cWM_0852, + cWM_0853, + cWM_0854, + cWM_0855, + cWM_HANDHELDFIRST, // = 856; + cWM_0857, + cWM_0858, + cWM_0859, + cWM_085A, + cWM_085B, + cWM_085C, + cWM_085D, + cWM_085E, + cWM_085F, + cWM_0860, + cWM_0861, + cWM_0862, + cWM_HANDHELDLAST, // = 863; + cWM_0864, + cWM_0865, + cWM_0866, + cWM_0867, + cWM_0868, + cWM_0869, + cWM_086A, + cWM_086B, + cWM_086C, + cWM_086D, + cWM_086E, + cWM_086F, + cWM_0870, + cWM_0871, + cWM_0872, + cWM_0873, + cWM_0874, + cWM_0875, + cWM_0876, + cWM_0877, + cWM_0878, + cWM_0879, + cWM_087A, + cWM_087B, + cWM_087C, + cWM_087D, + cWM_087E, + cWM_087F, + cWM_0880, + cWM_0881, + cWM_0882, + cWM_0883, + cWM_0884, + cWM_0885, + cWM_0886, + cWM_0887, + cWM_0888, + cWM_0889, + cWM_088A, + cWM_088B, + cWM_088C, + cWM_088D, + cWM_088E, + cWM_088F, + cWM_0890, + cWM_0891, + cWM_0892, + cWM_0893, + cWM_0894, + cWM_0895, + cWM_0896, + cWM_0897, + cWM_0898, + cWM_0899, + cWM_089A, + cWM_089B, + cWM_089C, + cWM_089D, + cWM_089E, + cWM_089F, + cWM_08A0, + cWM_08A1, + cWM_08A2, + cWM_08A3, + cWM_08A4, + cWM_08A5, + cWM_08A6, + cWM_08A7, + cWM_08A8, + cWM_08A9, + cWM_08AA, + cWM_08AB, + cWM_08AC, + cWM_08AD, + cWM_08AE, + cWM_08AF, + cWM_08B0, + cWM_08B1, + cWM_08B2, + cWM_08B3, + cWM_08B4, + cWM_08B5, + cWM_08B6, + cWM_08B7, + cWM_08B8, + cWM_08B9, + cWM_08BA, + cWM_08BB, + cWM_08BC, + cWM_08BD, + cWM_08BE, + cWM_08BF, + cWM_08C0, + cWM_08C1, + cWM_08C2, + cWM_08C3, + cWM_08C4, + cWM_08C5, + cWM_08C6, + cWM_08C7, + cWM_08C8, + cWM_08C9, + cWM_08CA, + cWM_08CB, + cWM_08CC, + cWM_08CD, + cWM_08CE, + cWM_08CF, + cWM_08D0, + cWM_08D1, + cWM_08D2, + cWM_08D3, + cWM_08D4, + cWM_08D5, + cWM_08D6, + cWM_08D7, + cWM_08D8, + cWM_08D9, + cWM_08DA, + cWM_08DB, + cWM_08DC, + cWM_08DD, + cWM_08DE, + cWM_08DF, + cWM_08E0, + cWM_08E1, + cWM_08E2, + cWM_08E3, + cWM_08E4, + cWM_08E5, + cWM_08E6, + cWM_08E7, + cWM_08E8, + cWM_08E9, + cWM_08EA, + cWM_08EB, + cWM_08EC, + cWM_08ED, + cWM_08EE, + cWM_08EF, + cWM_08F0, + cWM_08F1, + cWM_08F2, + cWM_08F3, + cWM_08F4, + cWM_08F5, + cWM_08F6, + cWM_08F7, + cWM_08F8, + cWM_08F9, + cWM_08FA, + cWM_08FB, + cWM_08FC, + cWM_08FD, + cWM_08FE, + cWM_08FF, + cWM_0900, + cWM_0901, + cWM_0902, + cWM_0903, + cWM_0904, + cWM_0905, + cWM_0906, + cWM_0907, + cWM_0908, + cWM_0909, + cWM_090A, + cWM_090B, + cWM_090C, + cWM_090D, + cWM_090E, + cWM_090F, + cWM_0910, + cWM_0911, + cWM_0912, + cWM_0913, + cWM_0914, + cWM_0915, + cWM_0916, + cWM_0917, + cWM_0918, + cWM_0919, + cWM_091A, + cWM_091B, + cWM_091C, + cWM_091D, + cWM_091E, + cWM_091F, + cWM_0920, + cWM_0921, + cWM_0922, + cWM_0923, + cWM_0924, + cWM_0925, + cWM_0926, + cWM_0927, + cWM_0928, + cWM_0929, + cWM_092A, + cWM_092B, + cWM_092C, + cWM_092D, + cWM_092E, + cWM_092F, + cWM_0930, + cWM_0931, + cWM_0932, + cWM_0933, + cWM_0934, + cWM_0935, + cWM_0936, + cWM_0937, + cWM_0938, + cWM_0939, + cWM_093A, + cWM_093B, + cWM_093C, + cWM_093D, + cWM_093E, + cWM_093F, + cWM_0940, + cWM_0941, + cWM_0942, + cWM_0943, + cWM_0944, + cWM_0945, + cWM_0946, + cWM_0947, + cWM_0948, + cWM_0949, + cWM_094A, + cWM_094B, + cWM_094C, + cWM_094D, + cWM_094E, + cWM_094F, + cWM_0950, + cWM_0951, + cWM_0952, + cWM_0953, + cWM_0954, + cWM_0955, + cWM_0956, + cWM_0957, + cWM_0958, + cWM_0959, + cWM_095A, + cWM_095B, + cWM_095C, + cWM_095D, + cWM_095E, + cWM_095F, + cWM_0960, + cWM_0961, + cWM_0962, + cWM_0963, + cWM_0964, + cWM_0965, + cWM_0966, + cWM_0967, + cWM_0968, + cWM_0969, + cWM_096A, + cWM_096B, + cWM_096C, + cWM_096D, + cWM_096E, + cWM_096F, + cWM_0970, + cWM_0971, + cWM_0972, + cWM_0973, + cWM_0974, + cWM_0975, + cWM_0976, + cWM_0977, + cWM_0978, + cWM_0979, + cWM_097A, + cWM_097B, + cWM_097C, + cWM_097D, + cWM_097E, + cWM_097F, + cWM_0980, + cWM_0981, + cWM_0982, + cWM_0983, + cWM_0984, + cWM_0985, + cWM_0986, + cWM_0987, + cWM_0988, + cWM_0989, + cWM_098A, + cWM_098B, + cWM_098C, + cWM_098D, + cWM_098E, + cWM_098F, + cWM_0990, + cWM_0991, + cWM_0992, + cWM_0993, + cWM_0994, + cWM_0995, + cWM_0996, + cWM_0997, + cWM_0998, + cWM_0999, + cWM_099A, + cWM_099B, + cWM_099C, + cWM_099D, + cWM_099E, + cWM_099F, + cWM_09A0, + cWM_09A1, + cWM_09A2, + cWM_09A3, + cWM_09A4, + cWM_09A5, + cWM_09A6, + cWM_09A7, + cWM_09A8, + cWM_09A9, + cWM_09AA, + cWM_09AB, + cWM_09AC, + cWM_09AD, + cWM_09AE, + cWM_09AF, + cWM_09B0, + cWM_09B1, + cWM_09B2, + cWM_09B3, + cWM_09B4, + cWM_09B5, + cWM_09B6, + cWM_09B7, + cWM_09B8, + cWM_09B9, + cWM_09BA, + cWM_09BB, + cWM_09BC, + cWM_09BD, + cWM_09BE, + cWM_09BF, + cWM_09C0, + cWM_09C1, + cWM_09C2, + cWM_09C3, + cWM_09C4, + cWM_09C5, + cWM_09C6, + cWM_09C7, + cWM_09C8, + cWM_09C9, + cWM_09CA, + cWM_09CB, + cWM_09CC, + cWM_09CD, + cWM_09CE, + cWM_09CF, + cWM_09D0, + cWM_09D1, + cWM_09D2, + cWM_09D3, + cWM_09D4, + cWM_09D5, + cWM_09D6, + cWM_09D7, + cWM_09D8, + cWM_09D9, + cWM_09DA, + cWM_09DB, + cWM_09DC, + cWM_09DD, + cWM_09DE, + cWM_09DF, + cWM_09E0, + cWM_09E1, + cWM_09E2, + cWM_09E3, + cWM_09E4, + cWM_09E5, + cWM_09E6, + cWM_09E7, + cWM_09E8, + cWM_09E9, + cWM_09EA, + cWM_09EB, + cWM_09EC, + cWM_09ED, + cWM_09EE, + cWM_09EF, + cWM_09F0, + cWM_09F1, + cWM_09F2, + cWM_09F3, + cWM_09F4, + cWM_09F5, + cWM_09F6, + cWM_09F7, + cWM_09F8, + cWM_09F9, + cWM_09FA, + cWM_09FB, + cWM_09FC, + cWM_09FD, + cWM_09FE, + cWM_09FF, + cWM_0A00, + cWM_0A01, + cWM_0A02, + cWM_0A03, + cWM_0A04, + cWM_0A05, + cWM_0A06, + cWM_0A07, + cWM_0A08, + cWM_0A09, + cWM_0A0A, + cWM_0A0B, + cWM_0A0C, + cWM_0A0D, + cWM_0A0E, + cWM_0A0F, + cWM_0A10, + cWM_0A11, + cWM_0A12, + cWM_0A13, + cWM_0A14, + cWM_0A15, + cWM_0A16, + cWM_0A17, + cWM_0A18, + cWM_0A19, + cWM_0A1A, + cWM_0A1B, + cWM_0A1C, + cWM_0A1D, + cWM_0A1E, + cWM_0A1F, + cWM_0A20, + cWM_0A21, + cWM_0A22, + cWM_0A23, + cWM_0A24, + cWM_0A25, + cWM_0A26, + cWM_0A27, + cWM_0A28, + cWM_0A29, + cWM_0A2A, + cWM_0A2B, + cWM_0A2C, + cWM_0A2D, + cWM_0A2E, + cWM_0A2F, + cWM_0A30, + cWM_0A31, + cWM_0A32, + cWM_0A33, + cWM_0A34, + cWM_0A35, + cWM_0A36, + cWM_0A37, + cWM_0A38, + cWM_0A39, + cWM_0A3A, + cWM_0A3B, + cWM_0A3C, + cWM_0A3D, + cWM_0A3E, + cWM_0A3F, + cWM_0A40, + cWM_0A41, + cWM_0A42, + cWM_0A43, + cWM_0A44, + cWM_0A45, + cWM_0A46, + cWM_0A47, + cWM_0A48, + cWM_0A49, + cWM_0A4A, + cWM_0A4B, + cWM_0A4C, + cWM_0A4D, + cWM_0A4E, + cWM_0A4F, + cWM_0A50, + cWM_0A51, + cWM_0A52, + cWM_0A53, + cWM_0A54, + cWM_0A55, + cWM_0A56, + cWM_0A57, + cWM_0A58, + cWM_0A59, + cWM_0A5A, + cWM_0A5B, + cWM_0A5C, + cWM_0A5D, + cWM_0A5E, + cWM_0A5F, + cWM_0A60, + cWM_0A61, + cWM_0A62, + cWM_0A63, + cWM_0A64, + cWM_0A65, + cWM_0A66, + cWM_0A67, + cWM_0A68, + cWM_0A69, + cWM_0A6A, + cWM_0A6B, + cWM_0A6C, + cWM_0A6D, + cWM_0A6E, + cWM_0A6F, + cWM_0A70, + cWM_0A71, + cWM_0A72, + cWM_0A73, + cWM_0A74, + cWM_0A75, + cWM_0A76, + cWM_0A77, + cWM_0A78, + cWM_0A79, + cWM_0A7A, + cWM_0A7B, + cWM_0A7C, + cWM_0A7D, + cWM_0A7E, + cWM_0A7F, + cWM_0A80, + cWM_0A81, + cWM_0A82, + cWM_0A83, + cWM_0A84, + cWM_0A85, + cWM_0A86, + cWM_0A87, + cWM_0A88, + cWM_0A89, + cWM_0A8A, + cWM_0A8B, + cWM_0A8C, + cWM_0A8D, + cWM_0A8E, + cWM_0A8F, + cWM_0A90, + cWM_0A91, + cWM_0A92, + cWM_0A93, + cWM_0A94, + cWM_0A95, + cWM_0A96, + cWM_0A97, + cWM_0A98, + cWM_0A99, + cWM_0A9A, + cWM_0A9B, + cWM_0A9C, + cWM_0A9D, + cWM_0A9E, + cWM_0A9F, + cWM_0AA0, + cWM_0AA1, + cWM_0AA2, + cWM_0AA3, + cWM_0AA4, + cWM_0AA5, + cWM_0AA6, + cWM_0AA7, + cWM_0AA8, + cWM_0AA9, + cWM_0AAA, + cWM_0AAB, + cWM_0AAC, + cWM_0AAD, + cWM_0AAE, + cWM_0AAF, + cWM_0AB0, + cWM_0AB1, + cWM_0AB2, + cWM_0AB3, + cWM_0AB4, + cWM_0AB5, + cWM_0AB6, + cWM_0AB7, + cWM_0AB8, + cWM_0AB9, + cWM_0ABA, + cWM_0ABB, + cWM_0ABC, + cWM_0ABD, + cWM_0ABE, + cWM_0ABF, + cWM_0AC0, + cWM_0AC1, + cWM_0AC2, + cWM_0AC3, + cWM_0AC4, + cWM_0AC5, + cWM_0AC6, + cWM_0AC7, + cWM_0AC8, + cWM_0AC9, + cWM_0ACA, + cWM_0ACB, + cWM_0ACC, + cWM_0ACD, + cWM_0ACE, + cWM_0ACF, + cWM_0AD0, + cWM_0AD1, + cWM_0AD2, + cWM_0AD3, + cWM_0AD4, + cWM_0AD5, + cWM_0AD6, + cWM_0AD7, + cWM_0AD8, + cWM_0AD9, + cWM_0ADA, + cWM_0ADB, + cWM_0ADC, + cWM_0ADD, + cWM_0ADE, + cWM_0ADF, + cWM_0AE0, + cWM_0AE1, + cWM_0AE2, + cWM_0AE3, + cWM_0AE4, + cWM_0AE5, + cWM_0AE6, + cWM_0AE7, + cWM_0AE8, + cWM_0AE9, + cWM_0AEA, + cWM_0AEB, + cWM_0AEC, + cWM_0AED, + cWM_0AEE, + cWM_0AEF, + cWM_0AF0, + cWM_0AF1, + cWM_0AF2, + cWM_0AF3, + cWM_0AF4, + cWM_0AF5, + cWM_0AF6, + cWM_0AF7, + cWM_0AF8, + cWM_0AF9, + cWM_0AFA, + cWM_0AFB, + cWM_0AFC, + cWM_0AFD, + cWM_0AFE, + cWM_0AFF, + cWM_0B00, + cWM_0B01, + cWM_0B02, + cWM_0B03, + cWM_0B04, + cWM_0B05, + cWM_0B06, + cWM_0B07, + cWM_0B08, + cWM_0B09, + cWM_0B0A, + cWM_0B0B, + cWM_0B0C, + cWM_0B0D, + cWM_0B0E, + cWM_0B0F, + cWM_0B10, + cWM_0B11, + cWM_0B12, + cWM_0B13, + cWM_0B14, + cWM_0B15, + cWM_0B16, + cWM_0B17, + cWM_0B18, + cWM_0B19, + cWM_0B1A, + cWM_0B1B, + cWM_0B1C, + cWM_0B1D, + cWM_0B1E, + cWM_0B1F, + cWM_0B20, + cWM_0B21, + cWM_0B22, + cWM_0B23, + cWM_0B24, + cWM_0B25, + cWM_0B26, + cWM_0B27, + cWM_0B28, + cWM_0B29, + cWM_0B2A, + cWM_0B2B, + cWM_0B2C, + cWM_0B2D, + cWM_0B2E, + cWM_0B2F, + cWM_0B30, + cWM_0B31, + cWM_0B32, + cWM_0B33, + cWM_0B34, + cWM_0B35, + cWM_0B36, + cWM_0B37, + cWM_0B38, + cWM_0B39, + cWM_0B3A, + cWM_0B3B, + cWM_0B3C, + cWM_0B3D, + cWM_0B3E, + cWM_0B3F, + cWM_0B40, + cWM_0B41, + cWM_0B42, + cWM_0B43, + cWM_0B44, + cWM_0B45, + cWM_0B46, + cWM_0B47, + cWM_0B48, + cWM_0B49, + cWM_0B4A, + cWM_0B4B, + cWM_0B4C, + cWM_0B4D, + cWM_0B4E, + cWM_0B4F, + cWM_0B50, + cWM_0B51, + cWM_0B52, + cWM_0B53, + cWM_0B54, + cWM_0B55, + cWM_0B56, + cWM_0B57, + cWM_0B58, + cWM_0B59, + cWM_0B5A, + cWM_0B5B, + cWM_0B5C, + cWM_0B5D, + cWM_0B5E, + cWM_0B5F, + cWM_0B60, + cWM_0B61, + cWM_0B62, + cWM_0B63, + cWM_0B64, + cWM_0B65, + cWM_0B66, + cWM_0B67, + cWM_0B68, + cWM_0B69, + cWM_0B6A, + cWM_0B6B, + cWM_0B6C, + cWM_0B6D, + cWM_0B6E, + cWM_0B6F, + cWM_0B70, + cWM_0B71, + cWM_0B72, + cWM_0B73, + cWM_0B74, + cWM_0B75, + cWM_0B76, + cWM_0B77, + cWM_0B78, + cWM_0B79, + cWM_0B7A, + cWM_0B7B, + cWM_0B7C, + cWM_0B7D, + cWM_0B7E, + cWM_0B7F, + cWM_0B80, + cWM_0B81, + cWM_0B82, + cWM_0B83, + cWM_0B84, + cWM_0B85, + cWM_0B86, + cWM_0B87, + cWM_0B88, + cWM_0B89, + cWM_0B8A, + cWM_0B8B, + cWM_0B8C, + cWM_0B8D, + cWM_0B8E, + cWM_0B8F, + cWM_0B90, + cWM_0B91, + cWM_0B92, + cWM_0B93, + cWM_0B94, + cWM_0B95, + cWM_0B96, + cWM_0B97, + cWM_0B98, + cWM_0B99, + cWM_0B9A, + cWM_0B9B, + cWM_0B9C, + cWM_0B9D, + cWM_0B9E, + cWM_0B9F, + cWM_0BA0, + cWM_0BA1, + cWM_0BA2, + cWM_0BA3, + cWM_0BA4, + cWM_0BA5, + cWM_0BA6, + cWM_0BA7, + cWM_0BA8, + cWM_0BA9, + cWM_0BAA, + cWM_0BAB, + cWM_0BAC, + cWM_0BAD, + cWM_0BAE, + cWM_0BAF, + cWM_0BB0, + cWM_0BB1, + cWM_0BB2, + cWM_0BB3, + cWM_0BB4, + cWM_0BB5, + cWM_0BB6, + cWM_0BB7, + cWM_0BB8, + cWM_0BB9, + cWM_0BBA, + cWM_0BBB, + cWM_0BBC, + cWM_0BBD, + cWM_0BBE, + cWM_0BBF, + cWM_0BC0, + cWM_0BC1, + cWM_0BC2, + cWM_0BC3, + cWM_0BC4, + cWM_0BC5, + cWM_0BC6, + cWM_0BC7, + cWM_0BC8, + cWM_0BC9, + cWM_0BCA, + cWM_0BCB, + cWM_0BCC, + cWM_0BCD, + cWM_0BCE, + cWM_0BCF, + cWM_0BD0, + cWM_0BD1, + cWM_0BD2, + cWM_0BD3, + cWM_0BD4, + cWM_0BD5, + cWM_0BD6, + cWM_0BD7, + cWM_0BD8, + cWM_0BD9, + cWM_0BDA, + cWM_0BDB, + cWM_0BDC, + cWM_0BDD, + cWM_0BDE, + cWM_0BDF, + cWM_0BE0, + cWM_0BE1, + cWM_0BE2, + cWM_0BE3, + cWM_0BE4, + cWM_0BE5, + cWM_0BE6, + cWM_0BE7, + cWM_0BE8, + cWM_0BE9, + cWM_0BEA, + cWM_0BEB, + cWM_0BEC, + cWM_0BED, + cWM_0BEE, + cWM_0BEF, + cWM_0BF0, + cWM_0BF1, + cWM_0BF2, + cWM_0BF3, + cWM_0BF4, + cWM_0BF5, + cWM_0BF6, + cWM_0BF7, + cWM_0BF8, + cWM_0BF9, + cWM_0BFA, + cWM_0BFB, + cWM_0BFC, + cWM_0BFD, + cWM_0BFE, + cWM_0BFF, + cWM_0C00, + cWM_0C01, + cWM_0C02, + cWM_0C03, + cWM_0C04, + cWM_0C05, + cWM_0C06, + cWM_0C07, + cWM_0C08, + cWM_0C09, + cWM_0C0A, + cWM_0C0B, + cWM_0C0C, + cWM_0C0D, + cWM_0C0E, + cWM_0C0F, + cWM_0C10, + cWM_0C11, + cWM_0C12, + cWM_0C13, + cWM_0C14, + cWM_0C15, + cWM_0C16, + cWM_0C17, + cWM_0C18, + cWM_0C19, + cWM_0C1A, + cWM_0C1B, + cWM_0C1C, + cWM_0C1D, + cWM_0C1E, + cWM_0C1F, + cWM_0C20, + cWM_0C21, + cWM_0C22, + cWM_0C23, + cWM_0C24, + cWM_0C25, + cWM_0C26, + cWM_0C27, + cWM_0C28, + cWM_0C29, + cWM_0C2A, + cWM_0C2B, + cWM_0C2C, + cWM_0C2D, + cWM_0C2E, + cWM_0C2F, + cWM_0C30, + cWM_0C31, + cWM_0C32, + cWM_0C33, + cWM_0C34, + cWM_0C35, + cWM_0C36, + cWM_0C37, + cWM_0C38, + cWM_0C39, + cWM_0C3A, + cWM_0C3B, + cWM_0C3C, + cWM_0C3D, + cWM_0C3E, + cWM_0C3F, + cWM_0C40, + cWM_0C41, + cWM_0C42, + cWM_0C43, + cWM_0C44, + cWM_0C45, + cWM_0C46, + cWM_0C47, + cWM_0C48, + cWM_0C49, + cWM_0C4A, + cWM_0C4B, + cWM_0C4C, + cWM_0C4D, + cWM_0C4E, + cWM_0C4F, + cWM_0C50, + cWM_0C51, + cWM_0C52, + cWM_0C53, + cWM_0C54, + cWM_0C55, + cWM_0C56, + cWM_0C57, + cWM_0C58, + cWM_0C59, + cWM_0C5A, + cWM_0C5B, + cWM_0C5C, + cWM_0C5D, + cWM_0C5E, + cWM_0C5F, + cWM_0C60, + cWM_0C61, + cWM_0C62, + cWM_0C63, + cWM_0C64, + cWM_0C65, + cWM_0C66, + cWM_0C67, + cWM_0C68, + cWM_0C69, + cWM_0C6A, + cWM_0C6B, + cWM_0C6C, + cWM_0C6D, + cWM_0C6E, + cWM_0C6F, + cWM_0C70, + cWM_0C71, + cWM_0C72, + cWM_0C73, + cWM_0C74, + cWM_0C75, + cWM_0C76, + cWM_0C77, + cWM_0C78, + cWM_0C79, + cWM_0C7A, + cWM_0C7B, + cWM_0C7C, + cWM_0C7D, + cWM_0C7E, + cWM_0C7F, + cWM_0C80, + cWM_0C81, + cWM_0C82, + cWM_0C83, + cWM_0C84, + cWM_0C85, + cWM_0C86, + cWM_0C87, + cWM_0C88, + cWM_0C89, + cWM_0C8A, + cWM_0C8B, + cWM_0C8C, + cWM_0C8D, + cWM_0C8E, + cWM_0C8F, + cWM_0C90, + cWM_0C91, + cWM_0C92, + cWM_0C93, + cWM_0C94, + cWM_0C95, + cWM_0C96, + cWM_0C97, + cWM_0C98, + cWM_0C99, + cWM_0C9A, + cWM_0C9B, + cWM_0C9C, + cWM_0C9D, + cWM_0C9E, + cWM_0C9F, + cWM_0CA0, + cWM_0CA1, + cWM_0CA2, + cWM_0CA3, + cWM_0CA4, + cWM_0CA5, + cWM_0CA6, + cWM_0CA7, + cWM_0CA8, + cWM_0CA9, + cWM_0CAA, + cWM_0CAB, + cWM_0CAC, + cWM_0CAD, + cWM_0CAE, + cWM_0CAF, + cWM_0CB0, + cWM_0CB1, + cWM_0CB2, + cWM_0CB3, + cWM_0CB4, + cWM_0CB5, + cWM_0CB6, + cWM_0CB7, + cWM_0CB8, + cWM_0CB9, + cWM_0CBA, + cWM_0CBB, + cWM_0CBC, + cWM_0CBD, + cWM_0CBE, + cWM_0CBF, + cWM_0CC0, + cWM_0CC1, + cWM_0CC2, + cWM_0CC3, + cWM_0CC4, + cWM_0CC5, + cWM_0CC6, + cWM_0CC7, + cWM_0CC8, + cWM_0CC9, + cWM_0CCA, + cWM_0CCB, + cWM_0CCC, + cWM_0CCD, + cWM_0CCE, + cWM_0CCF, + cWM_0CD0, + cWM_0CD1, + cWM_0CD2, + cWM_0CD3, + cWM_0CD4, + cWM_0CD5, + cWM_0CD6, + cWM_0CD7, + cWM_0CD8, + cWM_0CD9, + cWM_0CDA, + cWM_0CDB, + cWM_0CDC, + cWM_0CDD, + cWM_0CDE, + cWM_0CDF, + cWM_0CE0, + cWM_0CE1, + cWM_0CE2, + cWM_0CE3, + cWM_0CE4, + cWM_0CE5, + cWM_0CE6, + cWM_0CE7, + cWM_0CE8, + cWM_0CE9, + cWM_0CEA, + cWM_0CEB, + cWM_0CEC, + cWM_0CED, + cWM_0CEE, + cWM_0CEF, + cWM_0CF0, + cWM_0CF1, + cWM_0CF2, + cWM_0CF3, + cWM_0CF4, + cWM_0CF5, + cWM_0CF6, + cWM_0CF7, + cWM_0CF8, + cWM_0CF9, + cWM_0CFA, + cWM_0CFB, + cWM_0CFC, + cWM_0CFD, + cWM_0CFE, + cWM_0CFF, + cWM_0D00, + cWM_0D01, + cWM_0D02, + cWM_0D03, + cWM_0D04, + cWM_0D05, + cWM_0D06, + cWM_0D07, + cWM_0D08, + cWM_0D09, + cWM_0D0A, + cWM_0D0B, + cWM_0D0C, + cWM_0D0D, + cWM_0D0E, + cWM_0D0F, + cWM_0D10, + cWM_0D11, + cWM_0D12, + cWM_0D13, + cWM_0D14, + cWM_0D15, + cWM_0D16, + cWM_0D17, + cWM_0D18, + cWM_0D19, + cWM_0D1A, + cWM_0D1B, + cWM_0D1C, + cWM_0D1D, + cWM_0D1E, + cWM_0D1F, + cWM_0D20, + cWM_0D21, + cWM_0D22, + cWM_0D23, + cWM_0D24, + cWM_0D25, + cWM_0D26, + cWM_0D27, + cWM_0D28, + cWM_0D29, + cWM_0D2A, + cWM_0D2B, + cWM_0D2C, + cWM_0D2D, + cWM_0D2E, + cWM_0D2F, + cWM_0D30, + cWM_0D31, + cWM_0D32, + cWM_0D33, + cWM_0D34, + cWM_0D35, + cWM_0D36, + cWM_0D37, + cWM_0D38, + cWM_0D39, + cWM_0D3A, + cWM_0D3B, + cWM_0D3C, + cWM_0D3D, + cWM_0D3E, + cWM_0D3F, + cWM_0D40, + cWM_0D41, + cWM_0D42, + cWM_0D43, + cWM_0D44, + cWM_0D45, + cWM_0D46, + cWM_0D47, + cWM_0D48, + cWM_0D49, + cWM_0D4A, + cWM_0D4B, + cWM_0D4C, + cWM_0D4D, + cWM_0D4E, + cWM_0D4F, + cWM_0D50, + cWM_0D51, + cWM_0D52, + cWM_0D53, + cWM_0D54, + cWM_0D55, + cWM_0D56, + cWM_0D57, + cWM_0D58, + cWM_0D59, + cWM_0D5A, + cWM_0D5B, + cWM_0D5C, + cWM_0D5D, + cWM_0D5E, + cWM_0D5F, + cWM_0D60, + cWM_0D61, + cWM_0D62, + cWM_0D63, + cWM_0D64, + cWM_0D65, + cWM_0D66, + cWM_0D67, + cWM_0D68, + cWM_0D69, + cWM_0D6A, + cWM_0D6B, + cWM_0D6C, + cWM_0D6D, + cWM_0D6E, + cWM_0D6F, + cWM_0D70, + cWM_0D71, + cWM_0D72, + cWM_0D73, + cWM_0D74, + cWM_0D75, + cWM_0D76, + cWM_0D77, + cWM_0D78, + cWM_0D79, + cWM_0D7A, + cWM_0D7B, + cWM_0D7C, + cWM_0D7D, + cWM_0D7E, + cWM_0D7F, + cWM_0D80, + cWM_0D81, + cWM_0D82, + cWM_0D83, + cWM_0D84, + cWM_0D85, + cWM_0D86, + cWM_0D87, + cWM_0D88, + cWM_0D89, + cWM_0D8A, + cWM_0D8B, + cWM_0D8C, + cWM_0D8D, + cWM_0D8E, + cWM_0D8F, + cWM_0D90, + cWM_0D91, + cWM_0D92, + cWM_0D93, + cWM_0D94, + cWM_0D95, + cWM_0D96, + cWM_0D97, + cWM_0D98, + cWM_0D99, + cWM_0D9A, + cWM_0D9B, + cWM_0D9C, + cWM_0D9D, + cWM_0D9E, + cWM_0D9F, + cWM_0DA0, + cWM_0DA1, + cWM_0DA2, + cWM_0DA3, + cWM_0DA4, + cWM_0DA5, + cWM_0DA6, + cWM_0DA7, + cWM_0DA8, + cWM_0DA9, + cWM_0DAA, + cWM_0DAB, + cWM_0DAC, + cWM_0DAD, + cWM_0DAE, + cWM_0DAF, + cWM_0DB0, + cWM_0DB1, + cWM_0DB2, + cWM_0DB3, + cWM_0DB4, + cWM_0DB5, + cWM_0DB6, + cWM_0DB7, + cWM_0DB8, + cWM_0DB9, + cWM_0DBA, + cWM_0DBB, + cWM_0DBC, + cWM_0DBD, + cWM_0DBE, + cWM_0DBF, + cWM_0DC0, + cWM_0DC1, + cWM_0DC2, + cWM_0DC3, + cWM_0DC4, + cWM_0DC5, + cWM_0DC6, + cWM_0DC7, + cWM_0DC8, + cWM_0DC9, + cWM_0DCA, + cWM_0DCB, + cWM_0DCC, + cWM_0DCD, + cWM_0DCE, + cWM_0DCF, + cWM_0DD0, + cWM_0DD1, + cWM_0DD2, + cWM_0DD3, + cWM_0DD4, + cWM_0DD5, + cWM_0DD6, + cWM_0DD7, + cWM_0DD8, + cWM_0DD9, + cWM_0DDA, + cWM_0DDB, + cWM_0DDC, + cWM_0DDD, + cWM_0DDE, + cWM_0DDF, + cWM_0DE0, + cWM_0DE1, + cWM_0DE2, + cWM_0DE3, + cWM_0DE4, + cWM_0DE5, + cWM_0DE6, + cWM_0DE7, + cWM_0DE8, + cWM_0DE9, + cWM_0DEA, + cWM_0DEB, + cWM_0DEC, + cWM_0DED, + cWM_0DEE, + cWM_0DEF, + cWM_0DF0, + cWM_0DF1, + cWM_0DF2, + cWM_0DF3, + cWM_0DF4, + cWM_0DF5, + cWM_0DF6, + cWM_0DF7, + cWM_0DF8, + cWM_0DF9, + cWM_0DFA, + cWM_0DFB, + cWM_0DFC, + cWM_0DFD, + cWM_0DFE, + cWM_0DFF, + cWM_0E00, + cWM_0E01, + cWM_0E02, + cWM_0E03, + cWM_0E04, + cWM_0E05, + cWM_0E06, + cWM_0E07, + cWM_0E08, + cWM_0E09, + cWM_0E0A, + cWM_0E0B, + cWM_0E0C, + cWM_0E0D, + cWM_0E0E, + cWM_0E0F, + cWM_0E10, + cWM_0E11, + cWM_0E12, + cWM_0E13, + cWM_0E14, + cWM_0E15, + cWM_0E16, + cWM_0E17, + cWM_0E18, + cWM_0E19, + cWM_0E1A, + cWM_0E1B, + cWM_0E1C, + cWM_0E1D, + cWM_0E1E, + cWM_0E1F, + cWM_0E20, + cWM_0E21, + cWM_0E22, + cWM_0E23, + cWM_0E24, + cWM_0E25, + cWM_0E26, + cWM_0E27, + cWM_0E28, + cWM_0E29, + cWM_0E2A, + cWM_0E2B, + cWM_0E2C, + cWM_0E2D, + cWM_0E2E, + cWM_0E2F, + cWM_0E30, + cWM_0E31, + cWM_0E32, + cWM_0E33, + cWM_0E34, + cWM_0E35, + cWM_0E36, + cWM_0E37, + cWM_0E38, + cWM_0E39, + cWM_0E3A, + cWM_0E3B, + cWM_0E3C, + cWM_0E3D, + cWM_0E3E, + cWM_0E3F, + cWM_0E40, + cWM_0E41, + cWM_0E42, + cWM_0E43, + cWM_0E44, + cWM_0E45, + cWM_0E46, + cWM_0E47, + cWM_0E48, + cWM_0E49, + cWM_0E4A, + cWM_0E4B, + cWM_0E4C, + cWM_0E4D, + cWM_0E4E, + cWM_0E4F, + cWM_0E50, + cWM_0E51, + cWM_0E52, + cWM_0E53, + cWM_0E54, + cWM_0E55, + cWM_0E56, + cWM_0E57, + cWM_0E58, + cWM_0E59, + cWM_0E5A, + cWM_0E5B, + cWM_0E5C, + cWM_0E5D, + cWM_0E5E, + cWM_0E5F, + cWM_0E60, + cWM_0E61, + cWM_0E62, + cWM_0E63, + cWM_0E64, + cWM_0E65, + cWM_0E66, + cWM_0E67, + cWM_0E68, + cWM_0E69, + cWM_0E6A, + cWM_0E6B, + cWM_0E6C, + cWM_0E6D, + cWM_0E6E, + cWM_0E6F, + cWM_0E70, + cWM_0E71, + cWM_0E72, + cWM_0E73, + cWM_0E74, + cWM_0E75, + cWM_0E76, + cWM_0E77, + cWM_0E78, + cWM_0E79, + cWM_0E7A, + cWM_0E7B, + cWM_0E7C, + cWM_0E7D, + cWM_0E7E, + cWM_0E7F, + cWM_0E80, + cWM_0E81, + cWM_0E82, + cWM_0E83, + cWM_0E84, + cWM_0E85, + cWM_0E86, + cWM_0E87, + cWM_0E88, + cWM_0E89, + cWM_0E8A, + cWM_0E8B, + cWM_0E8C, + cWM_0E8D, + cWM_0E8E, + cWM_0E8F, + cWM_0E90, + cWM_0E91, + cWM_0E92, + cWM_0E93, + cWM_0E94, + cWM_0E95, + cWM_0E96, + cWM_0E97, + cWM_0E98, + cWM_0E99, + cWM_0E9A, + cWM_0E9B, + cWM_0E9C, + cWM_0E9D, + cWM_0E9E, + cWM_0E9F, + cWM_0EA0, + cWM_0EA1, + cWM_0EA2, + cWM_0EA3, + cWM_0EA4, + cWM_0EA5, + cWM_0EA6, + cWM_0EA7, + cWM_0EA8, + cWM_0EA9, + cWM_0EAA, + cWM_0EAB, + cWM_0EAC, + cWM_0EAD, + cWM_0EAE, + cWM_0EAF, + cWM_0EB0, + cWM_0EB1, + cWM_0EB2, + cWM_0EB3, + cWM_0EB4, + cWM_0EB5, + cWM_0EB6, + cWM_0EB7, + cWM_0EB8, + cWM_0EB9, + cWM_0EBA, + cWM_0EBB, + cWM_0EBC, + cWM_0EBD, + cWM_0EBE, + cWM_0EBF, + cWM_0EC0, + cWM_0EC1, + cWM_0EC2, + cWM_0EC3, + cWM_0EC4, + cWM_0EC5, + cWM_0EC6, + cWM_0EC7, + cWM_0EC8, + cWM_0EC9, + cWM_0ECA, + cWM_0ECB, + cWM_0ECC, + cWM_0ECD, + cWM_0ECE, + cWM_0ECF, + cWM_0ED0, + cWM_0ED1, + cWM_0ED2, + cWM_0ED3, + cWM_0ED4, + cWM_0ED5, + cWM_0ED6, + cWM_0ED7, + cWM_0ED8, + cWM_0ED9, + cWM_0EDA, + cWM_0EDB, + cWM_0EDC, + cWM_0EDD, + cWM_0EDE, + cWM_0EDF, + cWM_0EE0, + cWM_0EE1, + cWM_0EE2, + cWM_0EE3, + cWM_0EE4, + cWM_0EE5, + cWM_0EE6, + cWM_0EE7, + cWM_0EE8, + cWM_0EE9, + cWM_0EEA, + cWM_0EEB, + cWM_0EEC, + cWM_0EED, + cWM_0EEE, + cWM_0EEF, + cWM_0EF0, + cWM_0EF1, + cWM_0EF2, + cWM_0EF3, + cWM_0EF4, + cWM_0EF5, + cWM_0EF6, + cWM_0EF7, + cWM_0EF8, + cWM_0EF9, + cWM_0EFA, + cWM_0EFB, + cWM_0EFC, + cWM_0EFD, + cWM_0EFE, + cWM_0EFF, + cWM_0F00, + cWM_0F01, + cWM_0F02, + cWM_0F03, + cWM_0F04, + cWM_0F05, + cWM_0F06, + cWM_0F07, + cWM_0F08, + cWM_0F09, + cWM_0F0A, + cWM_0F0B, + cWM_0F0C, + cWM_0F0D, + cWM_0F0E, + cWM_0F0F, + cWM_0F10, + cWM_0F11, + cWM_0F12, + cWM_0F13, + cWM_0F14, + cWM_0F15, + cWM_0F16, + cWM_0F17, + cWM_0F18, + cWM_0F19, + cWM_0F1A, + cWM_0F1B, + cWM_0F1C, + cWM_0F1D, + cWM_0F1E, + cWM_0F1F, + cWM_0F20, + cWM_0F21, + cWM_0F22, + cWM_0F23, + cWM_0F24, + cWM_0F25, + cWM_0F26, + cWM_0F27, + cWM_0F28, + cWM_0F29, + cWM_0F2A, + cWM_0F2B, + cWM_0F2C, + cWM_0F2D, + cWM_0F2E, + cWM_0F2F, + cWM_0F30, + cWM_0F31, + cWM_0F32, + cWM_0F33, + cWM_0F34, + cWM_0F35, + cWM_0F36, + cWM_0F37, + cWM_0F38, + cWM_0F39, + cWM_0F3A, + cWM_0F3B, + cWM_0F3C, + cWM_0F3D, + cWM_0F3E, + cWM_0F3F, + cWM_0F40, + cWM_0F41, + cWM_0F42, + cWM_0F43, + cWM_0F44, + cWM_0F45, + cWM_0F46, + cWM_0F47, + cWM_0F48, + cWM_0F49, + cWM_0F4A, + cWM_0F4B, + cWM_0F4C, + cWM_0F4D, + cWM_0F4E, + cWM_0F4F, + cWM_0F50, + cWM_0F51, + cWM_0F52, + cWM_0F53, + cWM_0F54, + cWM_0F55, + cWM_0F56, + cWM_0F57, + cWM_0F58, + cWM_0F59, + cWM_0F5A, + cWM_0F5B, + cWM_0F5C, + cWM_0F5D, + cWM_0F5E, + cWM_0F5F, + cWM_0F60, + cWM_0F61, + cWM_0F62, + cWM_0F63, + cWM_0F64, + cWM_0F65, + cWM_0F66, + cWM_0F67, + cWM_0F68, + cWM_0F69, + cWM_0F6A, + cWM_0F6B, + cWM_0F6C, + cWM_0F6D, + cWM_0F6E, + cWM_0F6F, + cWM_0F70, + cWM_0F71, + cWM_0F72, + cWM_0F73, + cWM_0F74, + cWM_0F75, + cWM_0F76, + cWM_0F77, + cWM_0F78, + cWM_0F79, + cWM_0F7A, + cWM_0F7B, + cWM_0F7C, + cWM_0F7D, + cWM_0F7E, + cWM_0F7F, + cWM_0F80, + cWM_0F81, + cWM_0F82, + cWM_0F83, + cWM_0F84, + cWM_0F85, + cWM_0F86, + cWM_0F87, + cWM_0F88, + cWM_0F89, + cWM_0F8A, + cWM_0F8B, + cWM_0F8C, + cWM_0F8D, + cWM_0F8E, + cWM_0F8F, + cWM_0F90, + cWM_0F91, + cWM_0F92, + cWM_0F93, + cWM_0F94, + cWM_0F95, + cWM_0F96, + cWM_0F97, + cWM_0F98, + cWM_0F99, + cWM_0F9A, + cWM_0F9B, + cWM_0F9C, + cWM_0F9D, + cWM_0F9E, + cWM_0F9F, + cWM_0FA0, + cWM_0FA1, + cWM_0FA2, + cWM_0FA3, + cWM_0FA4, + cWM_0FA5, + cWM_0FA6, + cWM_0FA7, + cWM_0FA8, + cWM_0FA9, + cWM_0FAA, + cWM_0FAB, + cWM_0FAC, + cWM_0FAD, + cWM_0FAE, + cWM_0FAF, + cWM_0FB0, + cWM_0FB1, + cWM_0FB2, + cWM_0FB3, + cWM_0FB4, + cWM_0FB5, + cWM_0FB6, + cWM_0FB7, + cWM_0FB8, + cWM_0FB9, + cWM_0FBA, + cWM_0FBB, + cWM_0FBC, + cWM_0FBD, + cWM_0FBE, + cWM_0FBF, + cWM_0FC0, + cWM_0FC1, + cWM_0FC2, + cWM_0FC3, + cWM_0FC4, + cWM_0FC5, + cWM_0FC6, + cWM_0FC7, + cWM_0FC8, + cWM_0FC9, + cWM_0FCA, + cWM_0FCB, + cWM_0FCC, + cWM_0FCD, + cWM_0FCE, + cWM_0FCF, + cWM_0FD0, + cWM_0FD1, + cWM_0FD2, + cWM_0FD3, + cWM_0FD4, + cWM_0FD5, + cWM_0FD6, + cWM_0FD7, + cWM_0FD8, + cWM_0FD9, + cWM_0FDA, + cWM_0FDB, + cWM_0FDC, + cWM_0FDD, + cWM_0FDE, + cWM_0FDF, + cWM_0FE0, + cWM_0FE1, + cWM_0FE2, + cWM_0FE3, + cWM_0FE4, + cWM_0FE5, + cWM_0FE6, + cWM_0FE7, + cWM_0FE8, + cWM_0FE9, + cWM_0FEA, + cWM_0FEB, + cWM_0FEC, + cWM_0FED, + cWM_0FEE, + cWM_0FEF, + cWM_0FF0, + cWM_0FF1, + cWM_0FF2, + cWM_0FF3, + cWM_0FF4, + cWM_0FF5, + cWM_0FF6, + cWM_0FF7, + cWM_0FF8, + cWM_0FF9, + cWM_0FFA, + cWM_0FFB, + cWM_0FFC, + cWM_0FFD, + cWM_0FFE, + cWM_0FFF, + //LVM_FIRST = $1000; { ListView messages } + cLVM_GETBKCOLOR, // = LVM_FIRST + 0; + cLVM_SETBKCOLOR, // = LVM_FIRST + 1; + cLVM_GETIMAGELIST, // = LVM_FIRST + 2; + cLVM_SETIMAGELIST, // = LVM_FIRST + 3; + cLVM_GETITEMCOUNT, // = LVM_FIRST + 4; + cLVM_GETITEMA, // = LVM_FIRST + 5; + cLVM_SETITEMA, // = LVM_FIRST + 6; + cLVM_INSERTITEMA, // = LVM_FIRST + 7; + cLVM_DELETEITEM, // = LVM_FIRST + 8; + cLVM_DELETEALLITEMS, // = LVM_FIRST + 9; + cLVM_GETCALLBACKMASK,// = LVM_FIRST + 10; + cLVM_SETCALLBACKMASK,// = LVM_FIRST + 11; + cLVM_GETNEXTITEM, // = LVM_FIRST + 12; + cLVM_FINDITEMA, // = LVM_FIRST + 13; + cLVM_GETITEMRECT, // = LVM_FIRST + 14; + cLVM_SETITEMPOSITION,// = LVM_FIRST + 15; + cLVM_GETITEMPOSITION,// = LVM_FIRST + 16; + cLVM_GETSTRINGWIDTHA,// = LVM_FIRST + 17; + cLVM_HITTEST, // = LVM_FIRST + 18; + cLVM_ENSUREVISIBLE, // = LVM_FIRST + 19; + cLVM_SCROLL, // = LVM_FIRST + 20; + cLVM_REDRAWITEMS, // = LVM_FIRST + 21; + cLVM_ARRANGE, // = LVM_FIRST + 22; + cLVM_EDITLABELA, // = LVM_FIRST + 23; + cWM_1018, + cLVM_GETCOLUMNA, // = LVM_FIRST + 25; + cLVM_SETCOLUMNA, // = LVM_FIRST + 26; + cLVM_INSERTCOLUMNA, // = LVM_FIRST + 27; + cLVM_DELETECOLUMN, // = LVM_FIRST + 28; + cLVM_GETCOLUMNWIDTH, // = LVM_FIRST + 29; + cLVM_SETCOLUMNWIDTH, // = LVM_FIRST + 30; + cLVM_GETHEADER, // = LVM_FIRST + 31; + cWM_1020, + cLVM_CREATEDRAGIMAGE,// = LVM_FIRST + 33; + cLVM_GETVIEWRECT, // = LVM_FIRST + 34; + cLVM_GETTEXTCOLOR, // = LVM_FIRST + 35; + cLVM_SETTEXTCOLOR, // = LVM_FIRST + 36; + cLVM_GETTEXTBKCOLOR, // = LVM_FIRST + 37; + cLVM_SETTEXTBKCOLOR, // = LVM_FIRST + 38; + cLVM_GETTOPINDEX, // = LVM_FIRST + 39; + cLVM_GETCOUNTPERPAGE,// = LVM_FIRST + 40; + cLVM_GETORIGIN, // = LVM_FIRST + 41; + cLVM_UPDATE, // = LVM_FIRST + 42; + cLVM_SETITEMSTATE, // = LVM_FIRST + 43; + cLVM_GETITEMSTATE, // = LVM_FIRST + 44; + cLVM_GETITEMTEXTA, // = LVM_FIRST + 45; + cLVM_SETITEMTEXTA, // = LVM_FIRST + 46; + cLVM_SETITEMCOUNT, // = LVM_FIRST + 47; + cLVM_SORTITEMS, // = LVM_FIRST + 48; + cLVM_SETITEMPOSITION32, // = LVM_FIRST + 49; + cLVM_GETSELECTEDCOUNT, // = LVM_FIRST + 50; + cLVM_GETITEMSPACING, // = LVM_FIRST + 51; + cLVM_GETISEARCHSTRINGA, // = LVM_FIRST + 52; + cLVM_SETICONSPACING, // = LVM_FIRST + 53; + cLVM_SETEXTENDEDLISTVIEWSTYLE, // = LVM_FIRST + 54; + cLVM_GETEXTENDEDLISTVIEWSTYLE, // = LVM_FIRST + 55; + cLVM_GETSUBITEMRECT, // = LVM_FIRST + 56; + cLVM_SUBITEMHITTEST, // = LVM_FIRST + 57; + cLVM_SETCOLUMNORDERARRAY, // = LVM_FIRST + 58; + cLVM_GETCOLUMNORDERARRAY, // = LVM_FIRST + 59; + cLVM_SETHOTITEM, // = LVM_FIRST + 60; + cLVM_GETHOTITEM, // = LVM_FIRST + 61; + cLVM_SETHOTCURSOR, // = LVM_FIRST + 62; + cLVM_GETHOTCURSOR, // = LVM_FIRST + 63; + cLVM_APPROXIMATEVIEWRECT, // = LVM_FIRST + 64; + cLVM_SETWORKAREA, // = LVM_FIRST + 65; + cLVM_GETSELECTIONMARK, // = LVM_FIRST + 66; + cLVM_SETSELECTIONMARK, // = LVM_FIRST + 67; + cLVM_SETBKIMAGEA, // = LVM_FIRST + 68; + cLVM_GETBKIMAGEA, // = LVM_FIRST + 69; + cLVM_GETWORKAREAS, // = LVM_FIRST + 70; + cLVM_SETHOVERTIME, // = LVM_FIRST + 71; + cLVM_GETHOVERTIME, // = LVM_FIRST + 72; + cLVM_GETNUMBEROFWORKAREAS, // = LVM_FIRST + 73; + cLVM_SETTOOLTIPS, // = LVM_FIRST + 74; + cLVM_GETITEMW, // = LVM_FIRST + 75; + cLVM_SETITEMW, // = LVM_FIRST + 76; + cLVM_INSERTITEMW, // = LVM_FIRST + 77; + cLVM_GETTOOLTIPS, // = LVM_FIRST + 78; + cWM_104F, + cWM_1050, + cLVM_SORTITEMSEX, // = LVM_FIRST + 81; + cWM_1052, + cLVM_FINDITEMW, // = LVM_FIRST + 83; + cWM_1054, + cWM_1055, + cWM_1056, + cLVM_GETSTRINGWIDTHW, // = LVM_FIRST + 87; + cWM_1058, + cWM_1059, + cWM_105A, + cWM_105B, + cWM_105C, + cWM_105D, + cWM_105E, + cLVM_GETCOLUMNW, // = LVM_FIRST + 95; + cLVM_SETCOLUMNW, // = LVM_FIRST + 96; + cLVM_INSERTCOLUMNW, // = LVM_FIRST + 97; + cWM_1062, + cWM_1063, + cWM_1064, + cWM_1065, + cWM_1066, + cWM_1067, + cWM_1068, + cWM_1069, + cWM_106A, + cWM_106B, + cWM_106C, + cWM_106D, + cWM_106E, + cWM_106F, + cWM_1070, + cWM_1071, + cWM_1072, + cLVM_GETITEMTEXTW, // = LVM_FIRST + 115; + cLVM_SETITEMTEXTW, // = LVM_FIRST + 116; + cLVM_GETISEARCHSTRINGW,// = LVM_FIRST + 117; + cLVM_EDITLABELW, // = LVM_FIRST + 118; + cWM_1077, + cWM_1078, + cWM_1079, + cWM_107A, + cWM_107B, + cWM_107C, + cWM_107D, + cWM_107E, + cWM_107F, + cWM_1080, + cWM_1081, + cWM_1082, + cWM_1083, + cWM_1084, + cWM_1085, + cWM_1086, + cWM_1087, + cWM_1088, + cWM_1089, + cLVM_SETBKIMAGEW, // = LVM_FIRST + 138; + cLVM_GETBKIMAGEW, // = LVM_FIRST + 139; + cWM_108C, + cWM_108D, + cWM_108E, + cWM_108F, + cWM_1090, + cWM_1091, + cWM_1092, + cWM_1093, + cWM_1094, + cWM_1095, + cWM_1096, + cWM_1097, + cWM_1098, + cWM_1099, + cWM_109A, + cWM_109B, + cWM_109C, + cWM_109D, + cWM_109E, + cWM_109F, + cWM_10A0, + cWM_10A1, + cWM_10A2, + cWM_10A3, + cWM_10A4, + cWM_10A5, + cWM_10A6, + cWM_10A7, + cWM_10A8, + cWM_10A9, + cWM_10AA, + cWM_10AB, + cWM_10AC, + cWM_10AD, + cWM_10AE, + cWM_10AF, + cWM_10B0, + cWM_10B1, + cWM_10B2, + cWM_10B3, + cWM_10B4, + cWM_10B5, + cWM_10B6, + cWM_10B7, + cWM_10B8, + cWM_10B9, + cWM_10BA, + cWM_10BB, + cWM_10BC, + cWM_10BD, + cWM_10BE, + cWM_10BF, + cWM_10C0, + cWM_10C1, + cWM_10C2, + cWM_10C3, + cWM_10C4, + cWM_10C5, + cWM_10C6, + cWM_10C7, + cWM_10C8, + cWM_10C9, + cWM_10CA, + cWM_10CB, + cWM_10CC, + cWM_10CD, + cWM_10CE, + cWM_10CF, + cWM_10D0, + cWM_10D1, + cWM_10D2, + cWM_10D3, + cWM_10D4, + cWM_10D5, + cWM_10D6, + cWM_10D7, + cWM_10D8, + cWM_10D9, + cWM_10DA, + cWM_10DB, + cWM_10DC, + cWM_10DD, + cWM_10DE, + cWM_10DF, + cWM_10E0, + cWM_10E1, + cWM_10E2, + cWM_10E3, + cWM_10E4, + cWM_10E5, + cWM_10E6, + cWM_10E7, + cWM_10E8, + cWM_10E9, + cWM_10EA, + cWM_10EB, + cWM_10EC, + cWM_10ED, + cWM_10EE, + cWM_10EF, + cWM_10F0, + cWM_10F1, + cWM_10F2, + cWM_10F3, + cWM_10F4, + cWM_10F5, + cWM_10F6, + cWM_10F7, + cWM_10F8, + cWM_10F9, + cWM_10FA, + cWM_10FB, + cWM_10FC, + cWM_10FD, + cWM_10FE, + cWM_10FF, + //TV_FIRST = $1100; { TreeView messages } + cTVM_INSERTITEMA, // = TV_FIRST + 0; + cTVM_DELETEITEM, // = TV_FIRST + 1; + cTVM_EXPAND, // = TV_FIRST + 2; + cWM_1103, + cTVM_GETITEMRECT, // = TV_FIRST + 4; + cTVM_GETCOUNT, // = TV_FIRST + 5; + cTVM_GETINDENT, // = TV_FIRST + 6; + cTVM_SETINDENT, // = TV_FIRST + 7; + cTVM_GETIMAGELIST, // = TV_FIRST + 8; + cTVM_SETIMAGELIST, // = TV_FIRST + 9; + cTVM_GETNEXTITEM, // = TV_FIRST + 10; + cTVM_SELECTITEM, // = TV_FIRST + 11; + cTVM_GETITEMA, // = TV_FIRST + 12; + cTVM_SETITEMA, // = TV_FIRST + 13; + cTVM_EDITLABELA, // = TV_FIRST + 14; + cTVM_GETEDITCONTROL, // = TV_FIRST + 15; + cTVM_GETVISIBLECOUNT,// = TV_FIRST + 16; + cTVM_HITTEST, // = TV_FIRST + 17; + cTVM_CREATEDRAGIMAGE,// = TV_FIRST + 18; + cTVM_SORTCHILDREN, // = TV_FIRST + 19; + cTVM_ENSUREVISIBLE, // = TV_FIRST + 20; + cTVM_SORTCHILDRENCB, // = TV_FIRST + 21; + cTVM_ENDEDITLABELNOW,// = TV_FIRST + 22; + cTVM_GETISEARCHSTRINGA, // = TV_FIRST + 23; + cTVM_SETTOOLTIPS, // = TV_FIRST + 24; + cTVM_GETTOOLTIPS, // = TV_FIRST + 25; + cTVM_SETINSERTMARK, // = TV_FIRST + 26; + cTVM_SETITEMHEIGHT, // = TV_FIRST + 27; + cTVM_GETITEMHEIGHT, // = TV_FIRST + 28; + cTVM_SETBKCOLOR, // = TV_FIRST + 29; + cTVM_SETTEXTCOLOR, // = TV_FIRST + 30; + cTVM_GETBKCOLOR, // = TV_FIRST + 31; + cTVM_GETTEXTCOLOR, // = TV_FIRST + 32; + cTVM_SETSCROLLTIME, // = TV_FIRST + 33; + cTVM_GETSCROLLTIME, // = TV_FIRST + 34; + cWM_1123, + cWM_1124, + cTVM_SETINSERTMARKCOLOR, // = TV_FIRST + 37; + cTVM_GETINSERTMARKCOLOR, // = TV_FIRST + 38; + cWM_1127, + cTVM_SETLINECOLOR, // = TV_FIRST + 40; + cWM_1129, + cWM_112A, + cWM_112B, + cWM_112C, + cWM_112D, + cWM_112E, + cWM_112F, + cWM_1130, + cWM_1131, + cTVM_INSERTITEMW, // = TV_FIRST + 50; + cWM_1133, + cWM_1134, + cWM_1135, + cWM_1136, + cWM_1137, + cWM_1138, + cWM_1139, + cWM_113A, + cWM_113B, + cWM_113C, + cWM_113D, + cTVM_GETITEMW, // = TV_FIRST + 62; + cTVM_SETITEMW, // = TV_FIRST + 63; + cTVM_GETISEARCHSTRINGW, // = TV_FIRST + 64; + cTVM_EDITLABELW, // = TV_FIRST + 65; + cWM_1142, + cWM_1143, + cWM_1144, + cWM_1145, + cWM_1146, + cWM_1147, + cWM_1148, + cWM_1149, + cWM_114A, + cWM_114B, + cWM_114C, + cWM_114D, + cWM_114E, + cWM_114F, + cWM_1150, + cWM_1151, + cWM_1152, + cWM_1153, + cWM_1154, + cWM_1155, + cWM_1156, + cWM_1157, + cWM_1158, + cWM_1159, + cWM_115A, + cWM_115B, + cWM_115C, + cWM_115D, + cWM_115E, + cWM_115F, + cWM_1160, + cWM_1161, + cWM_1162, + cWM_1163, + cWM_1164, + cWM_1165, + cWM_1166, + cWM_1167, + cWM_1168, + cWM_1169, + cWM_116A, + cWM_116B, + cWM_116C, + cWM_116D, + cWM_116E, + cWM_116F, + cWM_1170, + cWM_1171, + cWM_1172, + cWM_1173, + cWM_1174, + cWM_1175, + cWM_1176, + cWM_1177, + cWM_1178, + cWM_1179, + cWM_117A, + cWM_117B, + cWM_117C, + cWM_117D, + cWM_117E, + cWM_117F, + cWM_1180, + cWM_1181, + cWM_1182, + cWM_1183, + cWM_1184, + cWM_1185, + cWM_1186, + cWM_1187, + cWM_1188, + cWM_1189, + cWM_118A, + cWM_118B, + cWM_118C, + cWM_118D, + cWM_118E, + cWM_118F, + cWM_1190, + cWM_1191, + cWM_1192, + cWM_1193, + cWM_1194, + cWM_1195, + cWM_1196, + cWM_1197, + cWM_1198, + cWM_1199, + cWM_119A, + cWM_119B, + cWM_119C, + cWM_119D, + cWM_119E, + cWM_119F, + cWM_11A0, + cWM_11A1, + cWM_11A2, + cWM_11A3, + cWM_11A4, + cWM_11A5, + cWM_11A6, + cWM_11A7, + cWM_11A8, + cWM_11A9, + cWM_11AA, + cWM_11AB, + cWM_11AC, + cWM_11AD, + cWM_11AE, + cWM_11AF, + cWM_11B0, + cWM_11B1, + cWM_11B2, + cWM_11B3, + cWM_11B4, + cWM_11B5, + cWM_11B6, + cWM_11B7, + cWM_11B8, + cWM_11B9, + cWM_11BA, + cWM_11BB, + cWM_11BC, + cWM_11BD, + cWM_11BE, + cWM_11BF, + cWM_11C0, + cWM_11C1, + cWM_11C2, + cWM_11C3, + cWM_11C4, + cWM_11C5, + cWM_11C6, + cWM_11C7, + cWM_11C8, + cWM_11C9, + cWM_11CA, + cWM_11CB, + cWM_11CC, + cWM_11CD, + cWM_11CE, + cWM_11CF, + cWM_11D0, + cWM_11D1, + cWM_11D2, + cWM_11D3, + cWM_11D4, + cWM_11D5, + cWM_11D6, + cWM_11D7, + cWM_11D8, + cWM_11D9, + cWM_11DA, + cWM_11DB, + cWM_11DC, + cWM_11DD, + cWM_11DE, + cWM_11DF, + cWM_11E0, + cWM_11E1, + cWM_11E2, + cWM_11E3, + cWM_11E4, + cWM_11E5, + cWM_11E6, + cWM_11E7, + cWM_11E8, + cWM_11E9, + cWM_11EA, + cWM_11EB, + cWM_11EC, + cWM_11ED, + cWM_11EE, + cWM_11EF, + cWM_11F0, + cWM_11F1, + cWM_11F2, + cWM_11F3, + cWM_11F4, + cWM_11F5, + cWM_11F6, + cWM_11F7, + cWM_11F8, + cWM_11F9, + cWM_11FA, + cWM_11FB, + cWM_11FC, + cWM_11FD, + cWM_11FE, + cWM_11FF, + cHDM_FIRST, // = $1200; { Header messages } + cWM_1201, + cWM_1202, + cHDM_GETITEMA, // = HDM_FIRST + 3; + cWM_1204, + cWM_1205, + cHDM_HITTEST, // = HDM_FIRST + 6; + cHDM_GETITEMRECT, // = HDM_FIRST + 7; + cHDM_SETIMAGELIST, // = HDM_FIRST + 8; + cHDM_GETIMAGELIST, // = HDM_FIRST + 9; + cWM_120A, + cHDM_GETITEMW, // = HDM_FIRST + 11; + cWM_120C, + cWM_120D, + cWM_120E, + cHDM_ORDERTOINDEX, // = HDM_FIRST + 15; + cHDM_CREATEDRAGIMAGE, // = HDM_FIRST + 16; // wparam = which item = by index; + cHDM_GETORDERARRAY, // = HDM_FIRST + 17; + cHDM_SETORDERARRAY, // = HDM_FIRST + 18; + cHDM_SETHOTDIVIDER, // = HDM_FIRST + 19; + cWM_1214, + cWM_1215, + cWM_1216, + cWM_1217, + cWM_1218, + cWM_1219, + cWM_121A, + cWM_121B, + cWM_121C, + cWM_121D, + cWM_121E, + cWM_121F, + cWM_1220, + cWM_1221, + cWM_1222, + cWM_1223, + cWM_1224, + cWM_1225, + cWM_1226, + cWM_1227, + cWM_1228, + cWM_1229, + cWM_122A, + cWM_122B, + cWM_122C, + cWM_122D, + cWM_122E, + cWM_122F, + cWM_1230, + cWM_1231, + cWM_1232, + cWM_1233, + cWM_1234, + cWM_1235, + cWM_1236, + cWM_1237, + cWM_1238, + cWM_1239, + cWM_123A, + cWM_123B, + cWM_123C, + cWM_123D, + cWM_123E, + cWM_123F, + cWM_1240, + cWM_1241, + cWM_1242, + cWM_1243, + cWM_1244, + cWM_1245, + cWM_1246, + cWM_1247, + cWM_1248, + cWM_1249, + cWM_124A, + cWM_124B, + cWM_124C, + cWM_124D, + cWM_124E, + cWM_124F, + cWM_1250, + cWM_1251, + cWM_1252, + cWM_1253, + cWM_1254, + cWM_1255, + cWM_1256, + cWM_1257, + cWM_1258, + cWM_1259, + cWM_125A, + cWM_125B, + cWM_125C, + cWM_125D, + cWM_125E, + cWM_125F, + cWM_1260, + cWM_1261, + cWM_1262, + cWM_1263, + cWM_1264, + cWM_1265, + cWM_1266, + cWM_1267, + cWM_1268, + cWM_1269, + cWM_126A, + cWM_126B, + cWM_126C, + cWM_126D, + cWM_126E, + cWM_126F, + cWM_1270, + cWM_1271, + cWM_1272, + cWM_1273, + cWM_1274, + cWM_1275, + cWM_1276, + cWM_1277, + cWM_1278, + cWM_1279, + cWM_127A, + cWM_127B, + cWM_127C, + cWM_127D, + cWM_127E, + cWM_127F, + cWM_1280, + cWM_1281, + cWM_1282, + cWM_1283, + cWM_1284, + cWM_1285, + cWM_1286, + cWM_1287, + cWM_1288, + cWM_1289, + cWM_128A, + cWM_128B, + cWM_128C, + cWM_128D, + cWM_128E, + cWM_128F, + cWM_1290, + cWM_1291, + cWM_1292, + cWM_1293, + cWM_1294, + cWM_1295, + cWM_1296, + cWM_1297, + cWM_1298, + cWM_1299, + cWM_129A, + cWM_129B, + cWM_129C, + cWM_129D, + cWM_129E, + cWM_129F, + cWM_12A0, + cWM_12A1, + cWM_12A2, + cWM_12A3, + cWM_12A4, + cWM_12A5, + cWM_12A6, + cWM_12A7, + cWM_12A8, + cWM_12A9, + cWM_12AA, + cWM_12AB, + cWM_12AC, + cWM_12AD, + cWM_12AE, + cWM_12AF, + cWM_12B0, + cWM_12B1, + cWM_12B2, + cWM_12B3, + cWM_12B4, + cWM_12B5, + cWM_12B6, + cWM_12B7, + cWM_12B8, + cWM_12B9, + cWM_12BA, + cWM_12BB, + cWM_12BC, + cWM_12BD, + cWM_12BE, + cWM_12BF, + cWM_12C0, + cWM_12C1, + cWM_12C2, + cWM_12C3, + cWM_12C4, + cWM_12C5, + cWM_12C6, + cWM_12C7, + cWM_12C8, + cWM_12C9, + cWM_12CA, + cWM_12CB, + cWM_12CC, + cWM_12CD, + cWM_12CE, + cWM_12CF, + cWM_12D0, + cWM_12D1, + cWM_12D2, + cWM_12D3, + cWM_12D4, + cWM_12D5, + cWM_12D6, + cWM_12D7, + cWM_12D8, + cWM_12D9, + cWM_12DA, + cWM_12DB, + cWM_12DC, + cWM_12DD, + cWM_12DE, + cWM_12DF, + cWM_12E0, + cWM_12E1, + cWM_12E2, + cWM_12E3, + cWM_12E4, + cWM_12E5, + cWM_12E6, + cWM_12E7, + cWM_12E8, + cWM_12E9, + cWM_12EA, + cWM_12EB, + cWM_12EC, + cWM_12ED, + cWM_12EE, + cWM_12EF, + cWM_12F0, + cWM_12F1, + cWM_12F2, + cWM_12F3, + cWM_12F4, + cWM_12F5, + cWM_12F6, + cWM_12F7, + cWM_12F8, + cWM_12F9, + cWM_12FA, + cWM_12FB, + cWM_12FC, + cWM_12FD, + cWM_12FE, + cWM_12FF, + cTCM_FIRST, // = $1300; { Tab control messages } + cWM_1301, + cTCM_GETIMAGELIST, // = TCM_FIRST + 2; + cTCM_SETIMAGELIST, // = TCM_FIRST + 3; + cTCM_GETITEMCOUNT, // = TCM_FIRST + 4; + cTCM_GETITEMA, // = TCM_FIRST + 5; + cTCM_SETITEMA, // = TCM_FIRST + 6; + cTCM_INSERTITEMA, // = TCM_FIRST + 7; + cTCM_DELETEITEM, // = TCM_FIRST + 8; + cTCM_DELETEALLITEMS, // = TCM_FIRST + 9; + cTCM_GETITEMRECT, // = TCM_FIRST + 10; + cTCM_GETCURSEL, // = TCM_FIRST + 11; + cTCM_SETCURSEL, // = TCM_FIRST + 12; + cTCM_HITTEST, // = TCM_FIRST + 13; + cTCM_SETITEMEXTRA, // = TCM_FIRST + 14; + cWM_130F, + cWM_1310, + cWM_1311, + cWM_1312, + cWM_1313, + cWM_1314, + cWM_1315, + cWM_1316, + cWM_1317, + cWM_1318, + cWM_1319, + cWM_131A, + cWM_131B, + cWM_131C, + cWM_131D, + cWM_131E, + cWM_131F, + cWM_1320, + cWM_1321, + cWM_1322, + cWM_1323, + cWM_1324, + cWM_1325, + cWM_1326, + cWM_1327, + cTCM_ADJUSTRECT, // = TCM_FIRST + 40; + cTCM_SETITEMSIZE, // = TCM_FIRST + 41; + cTCM_REMOVEIMAGE, // = TCM_FIRST + 42; + cTCM_SETPADDING, // = TCM_FIRST + 43; + cTCM_GETROWCOUNT, // = TCM_FIRST + 44; + cTCM_GETTOOLTIPS, // = TCM_FIRST + 45; + cTCM_SETTOOLTIPS, // = TCM_FIRST + 46; + cTCM_GETCURFOCUS, // = TCM_FIRST + 47; + cTCM_SETCURFOCUS, // = TCM_FIRST + 48; + cTCM_SETMINTABWIDTH, // = TCM_FIRST + 49; + cTCM_DESELECTALL, // = TCM_FIRST + 50; + cTCM_HIGHLIGHTITEM, // = TCM_FIRST + 51; + cTCM_SETEXTENDEDSTYLE, // = TCM_FIRST + 52; // optional wParam == mask + cTCM_GETEXTENDEDSTYLE, // = TCM_FIRST + 53; + cWM_1336, + cWM_1337, + cWM_1338, + cWM_1339, + cWM_133A, + cWM_133B, + cTCM_GETITEMW, // = TCM_FIRST + 60; + cTCM_SETITEMW, // = TCM_FIRST + 61; + cTCM_INSERTITEMW // = TCM_FIRST + 62; + (* + cCCM_FIRST = $2000; { Common control shared messages } + cCCM_SETBKCOLOR = CCM_FIRST + 1; // lParam is bkColor + cCCM_SETCOLORSCHEME = CCM_FIRST + 2; // lParam is color scheme + cCCM_GETCOLORSCHEME = CCM_FIRST + 3; // fills in COLORSCHEME pointed to by lParam + cCCM_GETDROPTARGET = CCM_FIRST + 4; + cCCM_SETUNICODEFORMAT = CCM_FIRST + 5; + cCCM_GETUNICODEFORMAT = CCM_FIRST + 6; + //WM_APP = $8000; + *) + ); + + PMsgDecoded = ^TMsgDecoded; + TMsgDecoded = packed record + hwnd: HWND; + Cmessage: TMessageDecoded; + _filler: Word; + wParam: WPARAM; + lParam: LPARAM; + time: DWORD; + pt: TPoint; + end; +