Changeset 214:a8fed3e56433

Show
Ignore:
Timestamp:
05/17/08 13:23:59 (5 months ago)
Author:
Frank Benoit <benoit@tionex.de>
branch:
default
Message:

Fix link error and added missing switch defaults

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • dwt/custom/StyledText.d

    r213 r214  
    50055005                case DWT.COMPOSITION_CHANGED: handleCompositionChanged(event); break; 
    50065006                case DWT.COMPOSITION_OFFSET: handleCompositionOffset(event); break; 
     5007                default: 
    50075008            } 
    50085009        } 

  • dwt/graphics/TextLayout.d

    r213 r214  
    10051005                    break; 
    10061006                } 
     1007                default: 
    10071008            } 
    10081009            if (brush !is color) Gdip.SolidBrush_delete(cast(Gdip.SolidBrush)brush); 
    …… 
    11091110                    break; 
    11101111                } 
     1112                default: 
    11111113            } 
    11121114        } 
    …… 
    11891191                case DWT.BORDER_DASH: lineStyle = Gdip.DashStyleDash; break; 
    11901192                case DWT.BORDER_DOT: lineStyle = Gdip.DashStyleDot; break; 
     1193                default: 
    11911194            } 
    11921195            auto pen = Gdip.Pen_new(cast(Gdip.Brush)brush, lineWidth); 
    …… 
    12361239                case DWT.BORDER_DASH: lineStyle = OS.PS_DASH; break; 
    12371240                case DWT.BORDER_DOT: lineStyle = OS.PS_DOT; break; 
     1241                default: 
    12381242            } 
    12391243            LOGBRUSH logBrush; 

  • dwt/internal/win32/OS.d

    r213 r214  
    23092309 
    23102310 
    2311 //PORTING_LEFT 
    2312 /++ 
    2313 /** Ansi/Unicode wrappers */ 
    2314  
    2315 public static const int /*long*/ AddFontResourceEx (TCHAR lpszFilename, int fl, int /*long*/ pdv) { 
    2316     if (IsUnicode) { 
    2317         char [] lpszFilename1 = lpszFilename is null ? null : lpszFilename.chars; 
    2318         return AddFontResourceExW (lpszFilename1, fl, pdv); 
    2319     } 
    2320     byte [] lpszFilename1 = lpszFilename is null ? null : lpszFilename.bytes; 
    2321     return AddFontResourceExA (lpszFilename1, fl, pdv); 
    2322 } 
    2323  
    2324 public static const int /*long*/ AssocQueryString(int flags, int str, TCHAR pszAssoc, TCHAR pszExtra, TCHAR pszOut, int[] pcchOut) { 
    2325     if (IsUnicode) { 
    2326         char [] pszAssoc1 = pszAssoc is null ? null : pszAssoc.chars; 
    2327         char [] pszExtra1 = pszExtra is null ? null : pszExtra.chars; 
    2328         char [] pszOut1 = pszOut is null ? null : pszOut.chars; 
    2329         return AssocQueryStringW (flags, str, pszAssoc1, pszExtra1, pszOut1, pcchOut); 
    2330     } 
    2331     byte [] pszAssoc1 = pszAssoc is null ? null : pszAssoc.bytes; 
    2332     byte [] pszExtra1 = pszExtra is null ? null : pszExtra.bytes; 
    2333     byte [] pszOut1 = pszOut is null ? null : pszOut.bytes; 
    2334     return AssocQueryStringA (flags, str, pszAssoc1, pszExtra1, pszOut1, pcchOut); 
    2335 } 
    2336  
    2337 public static const int /*long*/ CallWindowProc (int /*long*/ lpPrevWndFunc, int /*long*/ hWnd, int Msg, int /*long*/ wParam, int /*long*/ lParam) { 
    2338     if (IsUnicode) return CallWindowProcW (lpPrevWndFunc, hWnd, Msg, wParam, lParam); 
    2339     return CallWindowProcA (lpPrevWndFunc, hWnd, Msg, wParam, lParam); 
    2340 } 
    2341  
    2342 public static final short CharUpper (short ch) { 
    2343     if (IsUnicode) return CharUpperW (ch); 
    2344     return CharUpperA (ch); 
    2345 } 
    2346  
    2347 public static final short CharLower (short ch) { 
    2348     if (IsUnicode) return CharLowerW (ch); 
    2349     return CharLowerA (ch); 
    2350 } 
    2351  
    2352 public static final BOOL ChooseColor (CHOOSECOLOR lpcc) { 
    2353     if (IsUnicode) return ChooseColorW (lpcc); 
    2354     return ChooseColorA (lpcc); 
    2355 } 
    2356  
    2357 public static final BOOL ChooseFont (CHOOSEFONT chooseFont) { 
    2358     if (IsUnicode) return ChooseFontW (chooseFont); 
    2359     return ChooseFontA (chooseFont); 
    2360 } 
    2361  
    2362 public static const int /*long*/ CreateActCtx (ACTCTX pActCtx) { 
    2363     if (IsUnicode) return CreateActCtxW (pActCtx); 
    2364     return CreateActCtxA (pActCtx); 
    2365 } 
    2366  
    2367 public static const int /*long*/ CreateAcceleratorTable (byte [] lpaccl, int cEntries) { 
    2368     if (IsUnicode) return CreateAcceleratorTableW (lpaccl, cEntries); 
    2369     return CreateAcceleratorTableA (lpaccl, cEntries); 
    2370 } 
    2371  
    2372 public static const int /*long*/ CreateDC (TCHAR lpszDriver, TCHAR lpszDevice, int /*long*/ lpszOutput, int /*long*/ lpInitData) { 
    2373     if (IsUnicode) { 
    2374         char [] lpszDriver1 = lpszDriver is null ? null : lpszDriver.chars; 
    2375         char [] lpszDevice1 = lpszDevice is null ? null : lpszDevice.chars; 
    2376         return CreateDCW (lpszDriver1, lpszDevice1, lpszOutput, lpInitData); 
    2377     } 
    2378     byte [] lpszDriver1 = lpszDriver is null ? null : lpszDriver.bytes; 
    2379     byte [] lpszDevice1 = lpszDevice is null ? null : lpszDevice.bytes; 
    2380     return CreateDCA (lpszDriver1, lpszDevice1, lpszOutput, lpInitData); 
    2381 } 
    2382  
    2383 public static const int /*long*/ CreateFontIndirect (int /*long*/ lplf) { 
    2384     if (IsUnicode) return CreateFontIndirectW (lplf); 
    2385     return CreateFontIndirectA (lplf); 
    2386 } 
    2387  
    2388 public static const int /*long*/ CreateFontIndirect (LOGFONT lplf) { 
    2389     if (IsUnicode) return CreateFontIndirectW ((LOGFONTW)lplf); 
    2390     return CreateFontIndirectA ((LOGFONTA)lplf); 
    2391 } 
    2392  
    2393 public static final BOOL CreateProcess (int /*long*/ lpApplicationName, int /*long*/ lpCommandLine, int /*long*/ lpProcessAttributes, int /*long*/ lpThreadAttributes, BOOL bInheritHandles, int dwCreationFlags, int /*long*/ lpEnvironment, int /*long*/ lpCurrentDirectory, STARTUPINFO lpStartupInfo, PROCESS_INFORMATION lpProcessInformation) { 
    2394     if (IsUnicode) return CreateProcessW (lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation); 
    2395     return CreateProcessA (lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation); 
    2396 } 
    2397  
    2398 public static const int /*long*/ CreateWindowEx (int dwExStyle, TCHAR lpClassName, TCHAR lpWindowName, int dwStyle, int X, int Y, int nWidth, int nHeight, int /*long*/ hWndParent, int /*long*/ hMenu, int /*long*/ hInstance, CREATESTRUCT lpParam) { 
    2399     if (IsUnicode) { 
    2400         char [] lpClassName1 = lpClassName is null ? null : lpClassName.chars; 
    2401         char [] lpWindowName1 = lpWindowName is null ? null : lpWindowName.chars; 
    2402         return CreateWindowExW (dwExStyle, lpClassName1, lpWindowName1, dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); 
    2403     } 
    2404     byte [] lpClassName1 = lpClassName is null ? null : lpClassName.bytes; 
    2405     byte [] lpWindowName1 = lpWindowName is null ? null : lpWindowName.bytes; 
    2406     return CreateWindowExA (dwExStyle, lpClassName1, lpWindowName1, dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); 
    2407 } 
    2408  
    2409 public static const int /*long*/ DefMDIChildProc (int /*long*/ hWnd, int Msg, int /*long*/ wParam, int /*long*/ lParam) { 
    2410     if (IsUnicode) return DefMDIChildProcW (hWnd, Msg, wParam, lParam); 
    2411     return DefMDIChildProcA (hWnd, Msg, wParam, lParam); 
    2412 } 
    2413  
    2414 public static const int /*long*/ DefFrameProc (int /*long*/ hWnd, int /*long*/ hWndMDIClient, int Msg, int /*long*/ wParam, int /*long*/ lParam) { 
    2415     if (IsUnicode) return DefFrameProcW (hWnd, hWndMDIClient, Msg, wParam, lParam); 
    2416     return DefFrameProcA (hWnd, hWndMDIClient, Msg, wParam, lParam); 
    2417 } 
    2418 public static const int /*long*/ DefWindowProc (int /*long*/ hWnd, int Msg, int /*long*/ wParam, int /*long*/ lParam) { 
    2419     if (IsUnicode) return DefWindowProcW (hWnd, Msg, wParam, lParam); 
    2420     return DefWindowProcA (hWnd, Msg, wParam, lParam); 
    2421 } 
    2422  
    2423 public static const int /*long*/ DispatchMessage (MSG lpmsg) { 
    2424     if (IsUnicode) return DispatchMessageW (lpmsg); 
    2425     return DispatchMessageA (lpmsg); 
    2426 } 
    2427  
    2428 public static const int DragQueryFile (int /*long*/ hDrop, int iFile, TCHAR lpszFile, int cch) { 
    2429     if (IsUnicode) { 
    2430         char [] lpszFile1 = lpszFile is null ? null : lpszFile.chars; 
    2431         return DragQueryFileW (hDrop, iFile, lpszFile1, cch); 
    2432     } 
    2433     byte [] lpszFile1 = lpszFile is null ? null : lpszFile.bytes; 
    2434     return DragQueryFileA (hDrop, iFile, lpszFile1, cch); 
    2435 } 
    2436  
    2437 public static final BOOL DrawState (int /*long*/ hdc, int /*long*/ hbr, int /*long*/ lpOutputFunc, int /*long*/ lData, int /*long*/ wData, int x, int y, int cx, int cy, int fuFlags) { 
    2438     if (IsUnicode) return DrawStateW (hdc, hbr, lpOutputFunc, lData, wData, x, y, cx, cy, fuFlags); 
    2439     return DrawStateA (hdc, hbr, lpOutputFunc, lData, wData, x, y, cx, cy, fuFlags); 
    2440 } 
    2441  
    2442 public static const int DrawText (int /*long*/ hDC, TCHAR lpString, int nCount, RECT lpRect, int uFormat) { 
    2443     if (IsUnicode) { 
    2444         char [] lpString1 = lpString is null ? null : lpString.chars; 
    2445         return DrawTextW (hDC, lpString1, nCount, lpRect, uFormat); 
    2446     } 
    2447     byte [] lpString1 = lpString is null ? null : lpString.bytes; 
    2448     return DrawTextA (hDC, lpString1, nCount, lpRect, uFormat); 
    2449 } 
    2450  
    2451 public static const int EnumFontFamilies (int /*long*/ hdc, TCHAR lpszFamily, int /*long*/ lpEnumFontFamProc, int /*long*/ lParam) { 
    2452     if (IsUnicode) { 
    2453         char [] lpszFamily1 = lpszFamily is null ? null : lpszFamily.chars; 
    2454         return EnumFontFamiliesW (hdc, lpszFamily1, lpEnumFontFamProc, lParam); 
    2455     } 
    2456     byte [] lpszFamily1 = lpszFamily is null ? null : lpszFamily.bytes; 
    2457     return EnumFontFamiliesA (hdc, lpszFamily1, lpEnumFontFamProc, lParam); 
    2458 } 
    2459  
    2460 public static const int EnumFontFamiliesEx (int /*long*/ hdc, LOGFONT lpLogfont, int /*long*/ lpEnumFontFamExProc, int /*long*/ lParam, int dwFlags) { 
    2461     if (IsUnicode) return EnumFontFamiliesExW (hdc, (LOGFONTW)lpLogfont, lpEnumFontFamExProc, lParam, dwFlags); 
    2462     return EnumFontFamiliesExA (hdc, (LOGFONTA)lpLogfont, lpEnumFontFamExProc, lParam, dwFlags); 
    2463 } 
    2464  
    2465 public static final BOOL EnumSystemLocales (int /*long*/ lpLocaleEnumProc, int dwFlags) { 
    2466     if (IsUnicode) return EnumSystemLocalesW (lpLocaleEnumProc, dwFlags); 
    2467     return EnumSystemLocalesA (lpLocaleEnumProc, dwFlags); 
    2468 } 
    2469  
    2470 public static final BOOL EnumSystemLanguageGroups (int /*long*/ pLangGroupEnumProc, int dwFlags, int /*long*/ lParam) { 
    2471     if (IsUnicode) return EnumSystemLanguageGroupsW (pLangGroupEnumProc, dwFlags, lParam); 
    2472     return EnumSystemLanguageGroupsA (pLangGroupEnumProc, dwFlags, lParam); 
    2473 } 
    2474  
    2475 public static const int ExpandEnvironmentStrings (TCHAR lpSrc, TCHAR lpDst, int nSize) { 
    2476     if (IsUnicode) { 
    2477         char [] lpSrc1 = lpSrc is null ? null : lpSrc.chars; 
    2478         char [] lpDst1 = lpDst is null ? null : lpDst.chars; 
    2479         return ExpandEnvironmentStringsW (lpSrc1, lpDst1, nSize); 
    2480     } 
    2481     byte [] lpSrc1 = lpSrc is null ? null : lpSrc.bytes; 
    2482     byte [] lpDst1 = lpDst is null ? null : lpDst.bytes; 
    2483     return ExpandEnvironmentStringsA (lpSrc1, lpDst1, nSize); 
    2484 } 
    2485  
    2486 public static const int ExtractIconEx (TCHAR lpszFile, int nIconIndex, int /*long*/ [] phiconLarge, int /*long*/ [] phiconSmall, int nIcons) { 
    2487     if (IsUnicode) { 
    2488         char [] lpszFile1 = lpszFile is null ? null : lpszFile.chars; 
    2489         return ExtractIconExW (lpszFile1, nIconIndex, phiconLarge, phiconSmall, nIcons); 
    2490     } 
    2491     byte [] lpszFile1 = lpszFile is null ? null : lpszFile.bytes; 
    2492     return ExtractIconExA (lpszFile1, nIconIndex, phiconLarge, phiconSmall, nIcons); 
    2493 } 
    2494  
    2495 public static final BOOL ExtTextOut(int /*long*/ hdc, int X, int Y, int fuOptions, RECT lprc, TCHAR lpString, int cbCount, int[] lpDx) { 
    2496     if (IsUnicode) { 
    2497         char [] lpString1 = lpString is null ? null : lpString.chars; 
    2498         return ExtTextOutW (hdc, X, Y, fuOptions, lprc, lpString1, cbCount, lpDx); 
    2499     } 
    2500     byte [] lpString1 = lpString is null ? null : lpString.bytes; 
    2501     return ExtTextOutA (hdc, X, Y, fuOptions, lprc, lpString1, cbCount, lpDx); 
    2502 } 
    2503  
    2504 public static const int /*long*/ FindWindow (TCHAR lpClassName, TCHAR lpWindowName) { 
    2505     if (IsUnicode) { 
    2506         char [] lpClassName1 = lpClassName is null ? null : lpClassName.chars; 
    2507         char [] lpWindowName1 = lpWindowName is null ? null : lpWindowName.chars; 
    2508         return FindWindowW (lpClassName1, lpWindowName1); 
    2509     } 
    2510     byte [] lpClassName1 = lpClassName is null ? null : lpClassName.bytes; 
    2511     byte [] lpWindowName1 = lpWindowName is null ? null : lpWindowName.bytes; 
    2512     return FindWindowA (lpClassName1, lpWindowName1); 
    2513 } 
    2514  
    2515 public static const int FormatMessage (int dwFlags, int /*long*/ lpSource, int dwMessageId, int dwLanguageId, int[] lpBuffer, int nSize, int /*long*/ Arguments) { 
    2516     if (IsUnicode) { 
    2517         return FormatMessageW (dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments); 
    2518     } 
    2519     return FormatMessageA (dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments); 
    2520 } 
    2521  
    2522 public static final BOOL GetCharABCWidths (int /*long*/ hdc, int iFirstChar, int iLastChar, int [] lpabc) { 
    2523     if (IsUnicode) return GetCharABCWidthsW (hdc,iFirstChar, iLastChar, lpabc); 
    2524     return GetCharABCWidthsA (hdc,iFirstChar, iLastChar, lpabc); 
    2525 } 
    2526  
    2527 public static const int GetCharacterPlacement (int /*long*/ hdc, TCHAR lpString, int nCount, int nMaxExtent, GCP_RESULTS lpResults, int dwFlags) { 
    2528     if (IsUnicode) { 
    2529         char [] lpString1 = lpString is null ? null : lpString.chars; 
    2530         return GetCharacterPlacementW (hdc, lpString1, nCount, nMaxExtent, lpResults, dwFlags); 
    2531     } 
    2532     byte [] lpString1 = lpString is null ? null : lpString.bytes; 
    2533     return GetCharacterPlacementA (hdc, lpString1, nCount, nMaxExtent, lpResults, dwFlags); 
    2534 } 
    2535  
    2536 public static final BOOL GetCharWidth (int /*long*/ hdc, int iFirstChar, int iLastChar, int [] lpabc) { 
    2537     if (IsUnicode) return GetCharWidthW (hdc,iFirstChar, iLastChar, lpabc); 
    2538     return GetCharWidthA (hdc,iFirstChar, iLastChar, lpabc); 
    2539 } 
    2540  
    2541 public static final BOOL GetClassInfo (int /*long*/ hInstance, TCHAR lpClassName, WNDCLASS lpWndClass) { 
    2542     if (IsUnicode) { 
    2543         char [] lpClassName1 = lpClassName is null ? null : lpClassName.chars; 
    2544         return GetClassInfoW (hInstance, lpClassName1, lpWndClass); 
    2545     } 
    2546     byte [] lpClassName1 = lpClassName is null ? null : lpClassName.bytes; 
    2547     return GetClassInfoA (hInstance, lpClassName1, lpWndClass); 
    2548 } 
    2549  
    2550 public static const int GetClassName (int /*long*/ hWnd, TCHAR lpClassName, int nMaxCount) { 
    2551     if (IsUnicode) { 
    2552         char [] lpClassName1 = lpClassName is null ? null : lpClassName.chars; 
    2553         return GetClassNameW (hWnd, lpClassName1, nMaxCount); 
    2554     } 
    2555     byte [] lpClassName1 = lpClassName is null ? null : lpClassName.bytes; 
    2556     return GetClassNameA (hWnd, lpClassName1, nMaxCount); 
    2557 } 
    2558  
    2559 public static const int GetClipboardFormatName (int format, TCHAR lpszFormatName, int cchMaxCount) { 
    2560     if (IsUnicode) { 
    2561         char [] lpszFormatName1 = lpszFormatName is null ? null : lpszFormatName.chars; 
    2562         return GetClipboardFormatNameW (format, lpszFormatName1, cchMaxCount); 
    2563     } 
    2564     byte [] lpszFormatName1 = lpszFormatName is null ? null : lpszFormatName.bytes; 
    2565     return GetClipboardFormatNameA (format, lpszFormatName1, cchMaxCount); 
    2566 } 
    2567  
    2568 public static const int GetDateFormat (int Locale, int dwFlags, SYSTEMTIME lpDate, TCHAR lpFormat, TCHAR lpDateStr, int cchDate) { 
    2569     if (IsUnicode) { 
    2570         char [] lpString1 = lpFormat is null ? null : lpFormat.chars; 
    2571         char [] lpString2 = lpDateStr is null ? null : lpDateStr.chars; 
    2572         return GetDateFormatW (Locale, dwFlags, lpDate, lpString1, lpString2, cchDate); 
    2573     } 
    2574     byte [] lpString1 = lpFormat is null ? null : lpFormat.bytes; 
    2575     byte [] lpString2 = lpDateStr is null ? null : lpDateStr.bytes; 
    2576     return GetDateFormatA (Locale, dwFlags, lpDate, lpString1, lpString2, cchDate); 
    2577 } 
    2578  
    2579 public static const int GetKeyNameText (int lParam, TCHAR lpString, int nSize) { 
    2580     if (IsUnicode) { 
    2581         char [] lpString1 = lpString is null ? null : lpString.chars; 
    2582         return GetKeyNameTextW (lParam, lpString1, nSize); 
    2583     } 
    2584     byte [] lpString1 = lpString is null ? null : lpString.bytes; 
    2585     return GetKeyNameTextA (lParam, lpString1, nSize); 
    2586 } 
    2587  
    2588 public static const int GetLocaleInfo (int Locale, int LCType, TCHAR lpLCData, int cchData) { 
    2589     if (IsUnicode) { 
    2590         char [] lpLCData1 = lpLCData is null ? null : lpLCData.chars; 
    2591         return GetLocaleInfoW (Locale, LCType, lpLCData1, cchData); 
    2592     } 
    2593     byte [] lpLCData1 = lpLCData is null ? null : lpLCData.bytes; 
    2594     return GetLocaleInfoA (Locale, LCType, lpLCData1, cchData); 
    2595 } 
    2596  
    2597 public static final BOOL GetMenuItemInfo (int /*long*/ hMenu, int uItem, BOOL fByPosition, MENUITEMINFO lpmii) { 
    2598     if (IsUnicode) return GetMenuItemInfoW (hMenu, uItem, fByPosition, lpmii); 
    2599     return GetMenuItemInfoA (hMenu, uItem, fByPosition, lpmii); 
    2600 } 
    2601  
    2602 public static final BOOL GetMessage (MSG lpMsg, int /*long*/ hWnd, int wMsgFilterMin, int wMsgFilterMax) { 
    2603     if (IsUnicode) return GetMessageW (lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax); 
    2604     return GetMessageA (lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax); 
    2605 } 
    2606  
    2607 public static const int GetModuleFileName (int /*long*/ hModule, TCHAR lpFilename, int inSize) { 
    2608     if (IsUnicode) { 
    2609         char [] lpFilename1 = lpFilename is null ? null : lpFilename.chars; 
    2610         return GetModuleFileNameW (hModule, lpFilename1, inSize); 
    2611     } 
    2612     byte [] lpFilename1 = lpFilename is null ? null : lpFilename.bytes; 
    2613     return GetModuleFileNameA (hModule, lpFilename1, inSize); 
    2614 } 
    2615  
    2616 public static const int /*long*/ GetModuleHandle (TCHAR lpModuleName) { 
    2617     if (IsUnicode) { 
    2618         char [] lpModuleName1 = lpModuleName is null ? null : lpModuleName.chars; 
    2619         return GetModuleHandleW (lpModuleName1); 
    2620     } 
    2621     byte [] lpModuleName1 = lpModuleName is null ? null : lpModuleName.bytes; 
    2622     return GetModuleHandleA (lpModuleName1); 
    2623 } 
    2624  
    2625 public static final BOOL GetMonitorInfo (int /*long*/ hmonitor, MONITORINFO lpmi) { 
    2626     if (IsUnicode) return GetMonitorInfoW (hmonitor, lpmi); 
    2627     return GetMonitorInfoA (hmonitor, lpmi); 
    2628 } 
    2629  
    2630 public static const int GetObject (int /*long*/ hgdiobj, int cbBuffer, BITMAP lpvObject) { 
    2631     if (IsUnicode) return GetObjectW (hgdiobj, cbBuffer, lpvObject); 
    2632     return GetObjectA (hgdiobj, cbBuffer, lpvObject); 
    2633 } 
    2634  
    2635 public static const int GetObject (int /*long*/ hgdiobj, int cbBuffer, DIBSECTION lpvObject) { 
    2636     if (IsUnicode) return GetObjectW (hgdiobj, cbBuffer, lpvObject); 
    2637     return GetObjectA (hgdiobj, cbBuffer, lpvObject); 
    2638 } 
    2639  
    2640 public static const int GetObject (int /*long*/ hgdiobj, int cbBuffer, EXTLOGPEN lpvObject) { 
    2641     if (IsUnicode) return GetObjectW (hgdiobj, cbBuffer, lpvObject); 
    2642     return GetObjectA (hgdiobj, cbBuffer, lpvObject); 
    2643 } 
    2644  
    2645 public static const int GetObject (int /*long*/ hgdiobj, int cbBuffer, LOGBRUSH lpvObject) { 
    2646     if (IsUnicode) return GetObjectW (hgdiobj, cbBuffer, lpvObject); 
    2647     return GetObjectA (hgdiobj, cbBuffer, lpvObject); 
    2648 } 
    2649  
    2650 public static const int GetObject (int /*long*/ hgdiobj, int cbBuffer, LOGFONT lpvObject) { 
    2651     if (IsUnicode) return GetObjectW (hgdiobj, cbBuffer, (LOGFONTW)lpvObject); 
    2652     return GetObjectA (hgdiobj, cbBuffer, (LOGFONTA)lpvObject); 
    2653 } 
    2654  
    2655 public static const int GetObject (int /*long*/ hgdiobj, int cbBuffer, LOGPEN lpvObject) { 
    2656     if (IsUnicode) return GetObjectW (hgdiobj, cbBuffer, lpvObject); 
    2657     return GetObjectA (hgdiobj, cbBuffer, lpvObject); 
    2658 } 
    2659  
    2660 public static const int GetObject (int /*long*/ hgdiobj, int cbBuffer, int /*long*/ lpvObject) { 
    2661     if (IsUnicode) return GetObjectW (hgdiobj, cbBuffer, lpvObject); 
    2662     return GetObjectA (hgdiobj, cbBuffer, lpvObject); 
    2663 } 
    2664  
    2665 public static final BOOL GetOpenFileName (OPENFILENAME lpofn) { 
    2666     if (IsUnicode) return GetOpenFileNameW (lpofn); 
    2667     return GetOpenFileNameA (lpofn); 
    2668 } 
    2669  
    2670 public static const int GetProfileString (TCHAR lpAppName, TCHAR lpKeyName, TCHAR lpDefault, TCHAR lpReturnedString, int nSize) { 
    2671     if (IsUnicode) { 
    2672         char [] lpAppName1 = lpAppName is null ? null : lpAppName.chars; 
    2673         char [] lpKeyName1 = lpKeyName is null ? null : lpKeyName.chars; 
    2674         char [] lpDefault1 = lpDefault is null ? null : lpDefault.chars; 
    2675         char [] lpReturnedString1 = lpReturnedString is null ? null : lpReturnedString.chars; 
    2676         return GetProfileStringW (lpAppName1, lpKeyName1, lpDefault1, lpReturnedString1, nSize); 
    2677     } 
    2678     byte [] lpAppName1 = lpAppName is null ? null : lpAppName.bytes; 
    2679     byte [] lpKeyName1 = lpKeyName is null ? null : lpKeyName.bytes; 
    2680     byte [] lpDefault1 = lpDefault is null ? null : lpDefault.bytes; 
    2681     byte [] lpReturnedString1 = lpReturnedString is null ? null : lpReturnedString.bytes; 
    2682     return GetProfileStringA (lpAppName1, lpKeyName1, lpDefault1, lpReturnedString1, nSize); 
    2683 } 
    2684  
    2685 public static int /*long*/ GetProp (int /*long*/ hWnd, int /*long*/ lpString) { 
    2686     if (IsUnicode) return GetPropW (hWnd, lpString); 
    2687     return GetPropA (hWnd, lpString); 
    2688 } 
    2689  
    2690 public static final BOOL GetSaveFileName (OPENFILENAME lpofn) { 
    2691     if (IsUnicode) return GetSaveFileNameW (lpofn); 
    2692     return GetSaveFileNameA (lpofn); 
    2693 } 
    2694  
    2695 public static final void GetStartupInfo (STARTUPINFO lpStartupInfo) { 
    2696     if (IsUnicode) { 
    2697         GetStartupInfoW (lpStartupInfo); 
    2698     } else { 
    2699         GetStartupInfoA (lpStartupInfo); 
    2700     } 
    2701 } 
    2702  
    2703 public static final BOOL GetTextExtentPoint32 (int /*long*/ hdc, TCHAR lpString, int cbString, SIZE lpSize) { 
    2704     if (IsUnicode) { 
    2705         char [] lpString1 = lpString is null ? null : lpString.chars; 
    2706         return GetTextExtentPoint32W (hdc, lpString1, cbString, lpSize); 
    2707     } 
    2708     byte [] lpString1 = lpString is null ? null : lpString.bytes; 
    2709     return GetTextExtentPoint32A (hdc, lpString1, cbString, lpSize); 
    2710 } 
    2711  
    2712 public static final BOOL GetTextMetrics (int /*long*/ hdc, TEXTMETRIC lptm) { 
    2713     if (IsUnicode) return GetTextMetricsW (hdc, (TEXTMETRICW)lptm); 
    2714     return GetTextMetricsA (hdc, (TEXTMETRICA)lptm); 
    2715 } 
    2716  
    2717 public static const int GetTimeFormat (int Locale, int dwFlags, SYSTEMTIME lpTime, TCHAR lpFormat, TCHAR lpTimeStr, int cchTime) { 
    2718     if (IsUnicode) { 
    2719         char [] lpString1 = lpFormat is null ? null : lpFormat.chars; 
    2720         char [] lpString2 = lpTimeStr is null ? null : lpTimeStr.chars; 
    2721         return GetTimeFormatW (Locale, dwFlags, lpTime, lpString1, lpString2, cchTime); 
    2722     } 
    2723     byte [] lpString1 = lpFormat is null ? null : lpFormat.bytes; 
    2724     byte [] lpString2 = lpTimeStr is null ? null : lpTimeStr.bytes; 
    2725     return GetTimeFormatA (Locale, dwFlags, lpTime, lpString1, lpString2, cchTime); 
    2726 } 
    2727  
    2728 public static final BOOL GetVersionEx (OSVERSIONINFO lpVersionInfo) { 
    2729     if (IsUnicode) return GetVersionExW ((OSVERSIONINFOW)lpVersionInfo); 
    2730     return GetVersionExA ((OSVERSIONINFOA)lpVersionInfo); 
    2731 } 
    2732  
    2733 public static final BOOL GetVersionEx (OSVERSIONINFOEX lpVersionInfo) { 
    2734     if (IsUnicode) return GetVersionExW ((OSVERSIONINFOEXW)lpVersionInfo); 
    2735     return GetVersionExA ((OSVERSIONINFOEXA)lpVersionInfo); 
    2736 } 
    2737  
    2738 public static const int GetWindowLong (int /*long*/ hWnd, int nIndex) { 
    2739     if (IsUnicode) return GetWindowLongW (hWnd, nIndex); 
    2740     return GetWindowLongA (hWnd, nIndex); 
    2741 } 
    2742  
    2743 public static const int /*long*/ GetWindowLongPtr (int /*long*/ hWnd, int nIndex) { 
    2744     if (IsUnicode) return GetWindowLongPtrW (hWnd, nIndex); 
    2745     return GetWindowLongPtrA (hWnd, nIndex); 
    2746 } 
    2747  
    2748 public static const int GetWindowText (int /*long*/ hWnd, TCHAR lpString, int nMaxCount) { 
    2749     if (IsUnicode) { 
    2750         char [] lpString1 = lpString is null ? null : lpString.chars; 
    2751         return GetWindowTextW (hWnd, lpString1, nMaxCount); 
    2752     } 
    2753     byte [] lpString1 = lpString is null ? null : lpString.bytes; 
    2754     return GetWindowTextA (hWnd, lpString1, nMaxCount); 
    2755 } 
    2756  
    2757 public static const int GetWindowTextLength (int /*long*/ hWnd) { 
    2758     if (IsUnicode) return GetWindowTextLengthW (hWnd); 
    2759     return GetWindowTextLengthA (hWnd); 
    2760 } 
    2761  
    2762 public static const int GlobalAddAtom (TCHAR lpString) { 
    2763     if (IsUnicode) { 
    2764         char [] lpString1 = lpString is null ? null : lpString.chars; 
    2765         return GlobalAddAtomW (lpString1); 
    2766     } 
    2767     byte [] lpString1 = lpString is null ? null : lpString.bytes; 
    2768     return GlobalAddAtomA (lpString1); 
    2769 } 
    2770  
    2771 public static final BOOL ImmGetCompositionFont (int /*long*/ hIMC, LOGFONT lplf) { 
    2772     if (IsUnicode) return ImmGetCompositionFontW (hIMC, (LOGFONTW)lplf); 
    2773     return ImmGetCompositionFontA (hIMC, (LOGFONTA)lplf); 
    2774 } 
    2775  
    2776 public static final BOOL ImmSetCompositionFont (int /*long*/ hIMC, LOGFONT lplf) { 
    2777     if (IsUnicode) return ImmSetCompositionFontW (hIMC, (LOGFONTW)lplf); 
    2778     return ImmSetCompositionFontA (hIMC, (LOGFONTA)lplf); 
    2779 } 
    2780  
    2781 public static const int ImmGetCompositionString (int /*long*/ hIMC, int dwIndex, TCHAR lpBuf, int dwBufLen) { 
    2782     if (IsUnicode) { 
    2783         char [] lpBuf1 = lpBuf is null ? null : lpBuf.chars; 
    2784         return ImmGetCompositionStringW (hIMC, dwIndex, lpBuf1, dwBufLen); 
    2785     } 
    2786     byte [] lpBuf1 = lpBuf is null ? null : lpBuf.bytes; 
    2787     return ImmGetCompositionStringA (hIMC, dwIndex, lpBuf1, dwBufLen); 
    2788 } 
    2789  
    2790 public static final BOOL InsertMenu (int /*long*/ hMenu, int uPosition, int uFlags, int /*long*/ uIDNewItem, TCHAR lpNewItem) { 
    2791     if (IsUnicode) { 
    2792         char [] lpNewItem1 = lpNewItem is null ? null : lpNewItem.chars; 
    2793         return InsertMenuW (hMenu, uPosition, uFlags, uIDNewItem, lpNewItem1); 
    2794     } 
    2795     byte [] lpNewItem1 = lpNewItem is null ? null : lpNewItem.bytes; 
    2796     return InsertMenuA (hMenu, uPosition, uFlags, uIDNewItem, lpNewItem1); 
    2797 } 
    2798  
    2799 public static final BOOL InsertMenuItem (int /*long*/ hMenu, int uItem, BOOL fByPosition, MENUITEMINFO lpmii) { 
    2800     if (IsUnicode) return InsertMenuItemW (hMenu, uItem, fByPosition, lpmii); 
    2801     return InsertMenuItemA (hMenu, uItem, fByPosition, lpmii); 
    2802 } 
    2803  
    2804 public static const int /*long*/ LoadBitmap (int /*long*/ hInstance, int /*long*/ lpBitmapName) { 
    2805     if (IsUnicode) return LoadBitmapW (hInstance, lpBitmapName); 
    2806     return LoadBitmapA (hInstance, lpBitmapName); 
    2807 } 
    2808  
    2809 public static const int /*long*/ LoadCursor (int /*long*/ hInstance, int /*long*/ lpCursorName) { 
    2810     if (IsUnicode) return LoadCursorW (hInstance, lpCursorName); 
    2811     return LoadCursorA (hInstance, lpCursorName); 
    2812 } 
    2813  
    2814 public static const int /*long*/ LoadIcon (int /*long*/ hInstance, int /*long*/ lpIconName) { 
    2815     if (IsUnicode) return LoadIconW (hInstance, lpIconName); 
    2816     return LoadIconA (hInstance, lpIconName); 
    2817 } 
    2818  
    2819 public static const int /*long*/ LoadImage (int /*long*/ hinst, TCHAR lpszName, int uType, int cxDesired, int cyDesired, int fuLoad) { 
    2820     if (IsUnicode) { 
    2821         char [] lpszName1 = lpszName is null ? null : lpszName.chars; 
    2822         return LoadImageW (hinst, lpszName1, uType, cxDesired, cyDesired, fuLoad); 
    2823     } 
    2824     byte [] lpszName1 = lpszName is null ? null : lpszName.bytes; 
    2825     return LoadImageA (hinst, lpszName1, uType, cxDesired, cyDesired, fuLoad); 
    2826 } 
    2827  
    2828 public static const int /*long*/ LoadImage (int /*long*/ hinst, int /*long*/ lpszName, int uType, int cxDesired, int cyDesired, int fuLoad) { 
    2829     if (IsUnicode) return LoadImageW (hinst, lpszName, uType, cxDesired, cyDesired, fuLoad); 
    2830     return LoadImageA (hinst, lpszName, uType, cxDesired, cyDesired, fuLoad); 
    2831 } 
    2832  
    2833 public static const int /*long*/ LoadLibrary (TCHAR lpLibFileName) { 
    2834     if (IsUnicode) { 
    2835         char [] lpLibFileName1 = lpLibFileName is null ? null : lpLibFileName.chars; 
    2836         return LoadLibraryW (lpLibFileName1); 
    2837     } 
    2838     byte [] lpLibFileName1 = lpLibFileName is null ? null : lpLibFileName.bytes; 
    2839     return LoadLibraryA (lpLibFileName1); 
    2840 } 
    2841  
    2842 public static const int LoadString (int /*long*/ hinst, int uID, TCHAR lpBuffer, int nBufferMax) { 
    2843     if (IsUnicode) { 
    2844         char [] lpBuffer1 = lpBuffer is null ? null : lpBuffer.chars; 
    2845         return LoadStringW (hinst, uID, lpBuffer1, nBufferMax); 
    2846     } 
    2847     byte [] lpBuffer1 = lpBuffer is null ? null : lpBuffer.bytes; 
    2848     return LoadStringA (hinst, uID, lpBuffer1, nBufferMax); 
    2849 } 
    2850  
    2851 public static const int MapVirtualKey (int uCode, int uMapType) { 
    2852     if (IsUnicode) return MapVirtualKeyW (uCode, uMapType); 
    2853     return MapVirtualKeyA (uCode, uMapType); 
    2854 } 
    2855  
    2856 public static const int MessageBox (int /*long*/ hWnd, TCHAR lpText, TCHAR lpCaption, int uType) { 
    2857     if (IsUnicode) { 
    2858         char [] lpText1 = lpText is null ? null : lpText.chars; 
    2859         char [] lpCaption1 = lpCaption is null ? null : lpCaption.chars; 
    2860         return MessageBoxW (hWnd, lpText1, lpCaption1, uType); 
    2861     } 
    2862     byte [] lpText1 = lpText is null ? null : lpText.bytes; 
    2863     byte [] lpCaption1 = lpCaption is null ? null : lpCaption.bytes; 
    2864     return MessageBoxA (hWnd, lpText1, lpCaption1, uType); 
    2865 } 
    2866  
    2867 public static final void MoveMemory (int /*long*/ Destination, TCHAR Source, int Length) { 
    2868     if (IsUnicode) { 
    2869         char [] Source1 = Source is null ? null : Source.chars; 
    2870         MoveMemory (Destination, Source1, Length); 
    2871     } else { 
    2872         byte [] Source1 = Source is null ? null : Source.bytes; 
    2873         MoveMemory (Destination, Source1, Length); 
    2874     } 
    2875 } 
    2876  
    2877 public static final void MoveMemory (TCHAR Destination, int /*long*/ Source, int Length) { 
    2878     if (IsUnicode) { 
    2879         char [] Destination1 = Destination is null ? null : Destination.chars; 
    2880         MoveMemory (Destination1, Source, Length); 
    2881     } else { 
    2882         byte [] Destination1 = Destination is null ? null : Destination.bytes; 
    2883         MoveMemory (Destination1, Source, Length); 
    2884     } 
    2885 } 
    2886  
    2887 public static final void MoveMemory (int /*long*/ Destination, LOGFONT Source, int Length) { 
    2888     if (IsUnicode) { 
    2889         MoveMemory (Destination, (LOGFONTW)Source, Length); 
    2890     } else { 
    2891         MoveMemory (Destination, (LOGFONTA)Source, Length); 
    2892     } 
    2893 } 
    2894  
    2895 public static final void MoveMemory (LOGFONT Destination, int /*long*/ Source, int Length) { 
    2896     if (IsUnicode) { 
    2897         MoveMemory ((LOGFONTW)Destination, Source, Length); 
    2898     } else { 
    2899         MoveMemory ((LOGFONTA)Destination, Source, Length); 
    2900     } 
    2901 } 
    2902  
    2903 public static final void MoveMemory (int /*long*/ Destination, NMTTDISPINFO Source, int Length) { 
    2904     if (IsUnicode) { 
    2905         MoveMemory (Destination, (NMTTDISPINFOW)Source, Length); 
    2906     } else { 
    2907         MoveMemory (Destination, (NMTTDISPINFOA)Source, Length); 
    2908     } 
    2909 } 
    2910  
    2911 public static final void MoveMemory (NMTTDISPINFO Destination, int /*long*/ Source, int Length) { 
    2912     if (IsUnicode) { 
    2913         MoveMemory ((NMTTDISPINFOW)Destination, Source, Length); 
    2914     } else { 
    2915         MoveMemory ((NMTTDISPINFOA)Destination, Source, Length); 
    2916     } 
    2917 } 
    2918  
    2919 public static final void MoveMemory (TEXTMETRIC Destination, int /*long*/ Source, int Length) { 
    2920     if (IsUnicode) { 
    2921         MoveMemory ((TEXTMETRICW)Destination, Source, Length); 
    2922     } else { 
    2923         MoveMemory ((TEXTMETRICA)Destination, Source, Length); 
    2924     } 
    2925 } 
    2926  
    2927 public static final BOOL PeekMessage (MSG lpMsg, int /*long*/ hWnd, int wMsgFilterMin, int wMsgFilterMax, int wRemoveMsg) { 
    2928     if (IsUnicode) return PeekMessageW (lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg); 
    2929     return PeekMessageA (lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg); 
    2930 } 
    2931  
    2932 public static final BOOL PostMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, int /*long*/ lParam) { 
    2933     if (IsUnicode) return PostMessageW (hWnd, Msg, wParam, lParam); 
    2934     return PostMessageA (hWnd, Msg, wParam, lParam); 
    2935 } 
    2936  
    2937 public static final BOOL PostThreadMessage (int idThread, int Msg, int /*long*/ wParam, int /*long*/ lParam) { 
    2938     if (IsUnicode) return PostThreadMessageW (idThread, Msg, wParam, lParam); 
    2939     return PostThreadMessageA (idThread, Msg, wParam, lParam); 
    2940 } 
    2941  
    2942 public static final BOOL PrintDlg (PRINTDLG lppd) { 
    2943     if (IsUnicode) return PrintDlgW (lppd); 
    2944     return PrintDlgA (lppd); 
    2945 } 
    2946  
    2947 public static const int RegEnumKeyEx (int /*long*/ hKey, int dwIndex, TCHAR lpName, int [] lpcName, int [] lpReserved, TCHAR lpClass, int [] lpcClass, FILETIME lpftLastWriteTime) { 
    2948     if (IsUnicode) { 
    2949         char [] lpName1 = lpName is null ? null : lpName.chars; 
    2950         char [] lpClass1 = lpClass is null ? null : lpClass.chars; 
    2951         return RegEnumKeyExW (hKey, dwIndex, lpName1, lpcName, lpReserved, lpClass1, lpcClass, lpftLastWriteTime); 
    2952     } 
    2953     byte [] lpName1 = lpName is null ? null : lpName.bytes; 
    2954     byte [] lpClass1 = lpClass is null ? null : lpClass.bytes; 
    2955     return RegEnumKeyExA (hKey, dwIndex, lpName1, lpcName, lpReserved, lpClass1, lpcClass, lpftLastWriteTime); 
    2956 } 
    2957  
    2958 public static const int RegisterClass (WNDCLASS lpWndClass) { 
    2959     if (IsUnicode) return RegisterClassW (lpWndClass); 
    2960     return RegisterClassA (lpWndClass); 
    2961 } 
    2962  
    2963 public static const int RegisterClipboardFormat (TCHAR lpszFormat) { 
    2964     if (IsUnicode) { 
    2965         char [] lpszFormat1 = lpszFormat is null ? null : lpszFormat.chars; 
    2966         return RegisterClipboardFormatW (lpszFormat1); 
    2967     } 
    2968     byte [] lpszFormat1 = lpszFormat is null ? null : lpszFormat.bytes; 
    2969     return RegisterClipboardFormatA (lpszFormat1); 
    2970 } 
    2971  
    2972 public static const int RegisterWindowMessage (TCHAR lpString) { 
    2973     if (IsUnicode) { 
    2974         char [] lpString1 = lpString is null ? null : lpString.chars; 
    2975         return RegisterWindowMessageW (lpString1); 
    2976     } 
    2977     byte [] lpString1 = lpString is null ? null : lpString.bytes; 
    2978     return RegisterWindowMessageA (lpString1); 
    2979 } 
    2980  
    2981 public static const int RegOpenKeyEx (int /*long*/ hKey, TCHAR lpSubKey, int ulOptions, int samDesired, int /*long*/[] phkResult) { 
    2982     if (IsUnicode) { 
    2983         char [] lpSubKey1 = lpSubKey is null ? null : lpSubKey.chars; 
    2984         return RegOpenKeyExW (hKey, lpSubKey1, ulOptions, samDesired, phkResult); 
    2985     } 
    2986     byte [] lpSubKey1 = lpSubKey is null ? null : lpSubKey.bytes; 
    2987     return RegOpenKeyExA (hKey, lpSubKey1, ulOptions, samDesired, phkResult); 
    2988 } 
    2989  
    2990 public static const int RegQueryInfoKey (int /*long*/ hKey, int /*long*/ lpClass, int[] lpcbClass, int /*long*/ lpReserved, int[] lpSubKeys, int[] lpcbMaxSubKeyLen, int[] lpcbMaxClassLen, int[] lpcValues, int[] lpcbMaxValueNameLen, int[] lpcbMaxValueLen, int[] lpcbSecurityDescriptor, int /*long*/ lpftLastWriteTime){ 
    2991     if (IsUnicode) return RegQueryInfoKeyW (hKey, lpClass, lpcbClass, lpReserved, lpSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen, lpcbMaxValueLen, lpcbSecurityDescriptor, lpftLastWriteTime); 
    2992     return RegQueryInfoKeyA (hKey, lpClass, lpcbClass, lpReserved, lpSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen, lpcbMaxValueLen, lpcbSecurityDescriptor, lpftLastWriteTime); 
    2993 } 
    2994  
    2995 public static const int RegQueryValueEx (int /*long*/ hKey, TCHAR lpValueName, int /*long*/ lpReserved, int[] lpType, TCHAR lpData, int[] lpcbData) { 
    2996     if (IsUnicode) { 
    2997         char [] lpValueName1 = lpValueName is null ? null : lpValueName.chars; 
    2998         char [] lpData1 = lpData is null ? null : lpData.chars; 
    2999         return RegQueryValueExW (hKey, lpValueName1, lpReserved, lpType, lpData1, lpcbData); 
    3000     } 
    3001     byte [] lpValueName1 = lpValueName is null ? null : lpValueName.bytes; 
    3002     byte [] lpData1 = lpData is null ? null : lpData.bytes; 
    3003     return RegQueryValueExA (hKey, lpValueName1, lpReserved, lpType, lpData1, lpcbData); 
    3004 } 
    3005  
    3006 public static const int RegQueryValueEx (int /*long*/ hKey, TCHAR lpValueName, int /*long*/ lpReserved, int[] lpType, int [] lpData, int[] lpcbData) { 
    3007     if (IsUnicode) { 
    3008         char [] lpValueName1 = lpValueName is null ? null : lpValueName.chars; 
    3009         return RegQueryValueExW (hKey, lpValueName1, lpReserved, lpType, lpData, lpcbData); 
    3010     } 
    3011     byte [] lpValueName1 = lpValueName is null ? null : lpValueName.bytes; 
    3012     return RegQueryValueExA (hKey, lpValueName1, lpReserved, lpType, lpData, lpcbData); 
    3013 } 
    3014  
    3015 public static const int /*long*/ RemoveProp  (int /*long*/ hWnd, int /*long*/ lpString){ 
    3016     if (IsUnicode) return RemovePropW (hWnd, lpString); 
    3017     return RemovePropA (hWnd, lpString); 
    3018 } 
    3019  
    3020 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, TCHAR lParam) { 
    3021     if (IsUnicode) { 
    3022         char [] lParam1 = lParam is null ? null : lParam.chars; 
    3023         return SendMessageW (hWnd, Msg, wParam, lParam1); 
    3024     } 
    3025     byte [] lParam1 = lParam is null ? null : lParam.bytes; 
    3026     return SendMessageA (hWnd, Msg, wParam, lParam1); 
    3027 } 
    3028  
    3029 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int [] wParam, int [] lParam) { 
    3030     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3031     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3032 } 
    3033  
    3034 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, SIZE lParam) { 
    3035     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3036     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3037 } 
    3038  
    3039 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ [] wParam, int /*long*/ lParam) { 
    3040     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3041     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3042 } 
    3043  
    3044 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, int [] lParam) { 
    3045     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3046     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3047 } 
    3048  
    3049 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, char [] lParam) { 
    3050     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3051     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3052 } 
    3053  
    3054 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, short [] lParam) { 
    3055     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3056     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3057 } 
    3058  
    3059 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, int /*long*/ lParam) { 
    3060     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3061     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3062 } 
    3063  
    3064 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, LITEM lParam) { 
    3065     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3066     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3067 } 
    3068  
    3069 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, LVCOLUMN lParam) { 
    3070     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3071     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3072 } 
    3073  
    3074 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, LVHITTESTINFO lParam) { 
    3075     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3076     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3077 } 
    3078  
    3079 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, LVITEM lParam) { 
    3080     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3081     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3082 } 
    3083  
    3084 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, MARGINS lParam) { 
    3085     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3086     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3087 } 
    3088  
    3089 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, POINT lParam) { 
    3090     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3091     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3092 } 
    3093  
    3094 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, REBARBANDINFO lParam) { 
    3095     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3096     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3097 } 
    3098  
    3099 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, RECT lParam) { 
    3100     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3101     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3102 } 
    3103  
    3104 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, SYSTEMTIME lParam) { 
    3105     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3106     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3107 } 
    3108  
    3109 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, TBBUTTON lParam) { 
    3110     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3111     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3112 } 
    3113  
    3114 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, TBBUTTONINFO lParam) { 
    3115     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3116     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3117 } 
    3118  
    3119 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, TCITEM lParam) { 
    3120     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3121     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3122 } 
    3123  
    3124 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, TOOLINFO lParam) { 
    3125     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3126     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3127 } 
    3128  
    3129 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, TVHITTESTINFO lParam) { 
    3130     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3131     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3132 } 
    3133  
    3134 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, TVINSERTSTRUCT lParam) { 
    3135     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3136     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3137 } 
    3138  
    3139 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, TVITEM lParam) { 
    3140     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3141     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3142 } 
    3143  
    3144 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, TVSORTCB lParam) { 
    3145     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3146     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3147 } 
    3148  
    3149 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, UDACCEL lParam) { 
    3150     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3151     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3152 } 
    3153  
    3154 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, HDHITTESTINFO lParam) { 
    3155     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3156     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3157 } 
    3158  
    3159 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, HDITEM lParam) { 
    3160     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3161     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3162 } 
    3163  
    3164 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, HDLAYOUT lParam) { 
    3165     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3166     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3167 } 
    3168  
    3169 public static const int /*long*/ SendMessage (int /*long*/ hWnd, int Msg, int /*long*/ wParam, BUTTON_IMAGELIST lParam) { 
    3170     if (IsUnicode) return SendMessageW (hWnd, Msg, wParam, lParam); 
    3171     return SendMessageA (hWnd, Msg, wParam, lParam); 
    3172 } 
    3173  
    3174 public static final BOOL SetMenuItemInfo (int /*long*/ hMenu, int uItem, BOOL fByPosition, MENUITEMINFO lpmii) { 
    3175     if (IsUnicode) return SetMenuItemInfoW (hMenu, uItem, fByPosition, lpmii); 
    3176     return SetMenuItemInfoA (hMenu, uItem, fByPosition, lpmii); 
    3177 } 
    3178  
    3179 public static BOOL SetProp (int /*long*/ hWnd, int /*long*/ lpString, int /*long*/ hData) { 
    3180     if (IsUnicode) return SetPropW (hWnd, lpString, hData); 
    3181     return SetPropA (hWnd, lpString, hData); 
    3182 } 
    3183  
    3184 public static const int SetWindowLong (int /*long*/ hWnd, int nIndex, int dwNewLong) { 
    3185     if (IsUnicode) return SetWindowLongW (hWnd, nIndex, dwNewLong); 
    3186     return SetWindowLongA (hWnd, nIndex, dwNewLong); 
    3187 } 
    3188  
    3189 public static const int /*long*/ SetWindowLongPtr (int /*long*/ hWnd, int nIndex, int /*long*/ dwNewLong) { 
    3190     if (IsUnicode) return SetWindowLongPtrW (hWnd, nIndex, dwNewLong); 
    3191     return SetWindowLongPtrA (hWnd, nIndex, dwNewLong); 
    3192 } 
    3193  
    3194 public static const int /*long*/ SetWindowsHookEx (int idHook, int /*long*/ lpfn, int /*long*/ hMod, int dwThreadId) { 
    3195     if (IsUnicode) return SetWindowsHookExW (idHook, lpfn, hMod, dwThreadId); 
    3196     return SetWindowsHookExA (idHook, lpfn, hMod, dwThreadId); 
    3197 } 
    3198  
    3199 public static final BOOL SetWindowText (int /*long*/ hWnd, TCHAR lpString) { 
    3200     if (IsUnicode) { 
    3201         char [] lpString1 = lpString is null ? null : lpString.chars; 
    3202         return SetWindowTextW (hWnd, lpString1); 
    3203     } 
    3204     byte [] lpString1 = lpString is null ? null : lpString.bytes; 
    3205     return SetWindowTextA (hWnd, lpString1); 
    3206 } 
    3207