home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 10 / ioProg_10.iso / soft / sdk20 / jsdk05.cab / Src / Win32Api / Kernel32.java < prev    next >
Encoding:
Java Source  |  1997-09-25  |  67.0 KB  |  1,391 lines
  1. // Copyright (C) 1997 Microsoft Corporation  All Rights Reserved
  2.  
  3. // These classes provide direct, low-overhead access to commonly used
  4. // Windows api. These classes use the new J/Direct feature.
  5. //
  6. // Information on how to use J/Direct to write your own declarations
  7. // can be found in the Microsoft SDK for Java 2.0.
  8.  
  9. package com.ms.win32;
  10.  
  11. /** @security(checkClassLinking=on) */
  12. public class Kernel32 {
  13.         /** @dll.import("KERNEL32", auto) */
  14.         public native static short AddAtom (String lpString);
  15.  
  16.         /** @dll.import("KERNEL32",auto) */
  17.         public native static boolean AllocConsole ();
  18.  
  19.         /** @dll.import("KERNEL32",auto) */
  20.         public native static boolean AreFileApisANSI ();
  21.  
  22.         /** @dll.import("KERNEL32",auto) */
  23.         public native static boolean BackupRead (int hFile, byte[] lpBuffer, int nNumberOfBytesToRead, int[] lpNumberOfBytesRead, boolean bAbort, boolean bProcessSecurity, int[] lpContext);
  24.  
  25.         /** @dll.import("KERNEL32",auto) */
  26.         public native static boolean BackupRead (int hFile, Object lpBuffer, int nNumberOfBytesToRead, int[] lpNumberOfBytesRead, boolean bAbort, boolean bProcessSecurity, int[] lpContext);
  27.  
  28.         /** @dll.import("KERNEL32",auto) */
  29.         public native static boolean BackupSeek (int hFile, int dwLowBytesToSeek, int dwHighBytesToSeek, int[] lpdwLowByteSeeked, int[] lpdwHighByteSeeked, int[] lpContext);
  30.  
  31.         /** @dll.import("KERNEL32",auto) */
  32.         public native static boolean BackupWrite (int hFile, byte[] lpBuffer, int nNumberOfBytesToWrite, int[] lpNumberOfBytesWritten, boolean bAbort, boolean bProcessSecurity, int[] lpContext);
  33.  
  34.         /** @dll.import("KERNEL32",auto) */
  35.         public native static boolean BackupWrite (int hFile, Object lpBuffer, int nNumberOfBytesToWrite, int[] lpNumberOfBytesWritten, boolean bAbort, boolean bProcessSecurity, int[] lpContext);
  36.  
  37.         /** @dll.import("KERNEL32",auto) */
  38.         public native static boolean Beep (int dwFreq, int dwDuration);
  39.  
  40.         /** @dll.import("KERNEL32", auto) */
  41.         public native static int BeginUpdateResource (String pFileName, boolean bDeleteExistingResources);
  42.  
  43.         /** @dll.import("KERNEL32", auto) */
  44.         public native static boolean BuildCommDCBAndTimeouts (String lpDef, DCB lpDCB, COMMTIMEOUTS lpCommTimeouts);
  45.  
  46.         /** @dll.import("KERNEL32", auto) */
  47.         public native static boolean BuildCommDCB (String lpDef, DCB lpDCB);
  48.  
  49.         /** @dll.import("KERNEL32", auto) */
  50.         public native static boolean CallNamedPipe (String lpNamedPipeName, Object lpInBuffer, int nInBufferSize, Object lpOutBuffer, int nOutBufferSize, int[] lpBytesRead, int nTimeOut);
  51.  
  52.         /** @dll.import("KERNEL32",auto) */
  53.         public native static boolean CancelIo (int hFile);
  54.  
  55.         /** @dll.import("KERNEL32",auto) */
  56.         public native static boolean CancelWaitableTimer (int hTimer);
  57.  
  58.         /** @dll.import("KERNEL32",auto) */
  59.         public native static boolean ClearCommBreak (int hFile);
  60.  
  61.         /** @dll.import("KERNEL32",auto) */
  62.         public native static boolean ClearCommError (int hFile, int[] lpErrors, COMSTAT lpStat);
  63.  
  64.         /** @dll.import("KERNEL32",auto) */
  65.         public native static boolean CloseHandle (int hObject);
  66.  
  67.  
  68.  
  69.         /** @dll.import("KERNEL32",auto) */
  70.         public native static int CompareFileTime (FILETIME lpFileTime1, FILETIME lpFileTime2);
  71.  
  72.         /** @dll.import("KERNEL32", auto) */
  73.         public native static int CompareString (int Locale, int dwCmpFlags, String lpString1, int cchCount1, String lpString2, int cchCount2);
  74.  
  75.         /** @dll.import("KERNEL32",auto) */
  76.         public native static boolean ConnectNamedPipe (int hNamedPipe, OVERLAPPED lpOverlapped);
  77.  
  78.         /** @dll.import("KERNEL32",auto) */
  79.         public native static boolean ContinueDebugEvent (int dwProcessId, int dwThreadId, int dwContinueStatus);
  80.  
  81.         /** @dll.import("KERNEL32",auto) */
  82.         public native static int ConvertDefaultLocale (int Locale);
  83.  
  84.         /** @dll.import("KERNEL32",auto) */
  85.         public native static int ConvertThreadToFiber (int lpParameter);
  86.  
  87.  
  88.         private static int expandCoord(COORD c)
  89.         {
  90.             return ( ((int)c.X) & 0xffff ) | ( ((int)c.Y) << 16);
  91.         }
  92.  
  93.  
  94.         /** @dll.import("KERNEL32", auto) */
  95.         public native static boolean CopyFileEx (String lpExistingFileName, String lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine, int lpData, int[] pbCancel, int dwCopyFlags);
  96.  
  97.         /** @dll.import("KERNEL32", auto) */
  98.         public native static boolean CopyFile (String lpExistingFileName, String lpNewFileName, boolean bFailIfExists);
  99.  
  100.         /** @dll.import("KERNEL32",auto) */
  101.         public native static int CreateConsoleScreenBuffer (int dwDesiredAccess, int dwShareMode, SECURITY_ATTRIBUTES lpSecurityAttributes, int dwFlags, int lpScreenBufferData);
  102.  
  103.         /** @dll.import("KERNEL32", auto) */
  104.         public native static boolean CreateDirectoryEx (String lpTemplateDirectory, String lpNewDirectory, SECURITY_ATTRIBUTES lpSecurityAttributes);
  105.  
  106.         /** @dll.import("KERNEL32", auto) */
  107.         public native static boolean CreateDirectory (String lpPathName, SECURITY_ATTRIBUTES lpSecurityAttributes);
  108.  
  109.         /** @dll.import("KERNEL32", auto) */
  110.         public native static int CreateEvent (SECURITY_ATTRIBUTES lpEventAttributes, boolean bManualReset, boolean bInitialState, String lpName);
  111.  
  112.         /** @dll.import("KERNEL32",auto) */
  113.         public native static int CreateFiber (int dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, int lpParameter);
  114.  
  115.         /** @dll.import("KERNEL32",auto) */
  116.         public native static int CreateFiber (int dwStackSize, com.ms.dll.Callback lpStartAddress, int lpParameter);
  117.  
  118.         /** @dll.import("KERNEL32", auto) */
  119.         public native static int CreateFileMapping (int hFile, SECURITY_ATTRIBUTES lpFileMappingAttributes, int flProtect, int dwMaximumSizeHigh, int dwMaximumSizeLow, String lpName);
  120.  
  121.         /** @dll.import("KERNEL32", auto) */
  122.         public native static int CreateFile (String lpFileName, int dwDesiredAccess, int dwShareMode, SECURITY_ATTRIBUTES lpSecurityAttributes, int dwCreationDisposition, int dwFlagsAndAttributes, int hTemplateFile);
  123.  
  124.         /** @dll.import("KERNEL32",auto) */
  125.         public native static int CreateIoCompletionPort (int FileHandle, int ExistingCompletionPort, int CompletionKey, int NumberOfConcurrentThreads);
  126.  
  127.         /** @dll.import("KERNEL32", auto) */
  128.         public native static int CreateMailslot (String lpName, int nMaxMessageSize, int lReadTimeout, SECURITY_ATTRIBUTES lpSecurityAttributes);
  129.  
  130.         /** @dll.import("KERNEL32", auto) */
  131.         public native static int CreateMutex (SECURITY_ATTRIBUTES lpMutexAttributes, boolean bInitialOwner, String lpName);
  132.  
  133.         /** @dll.import("KERNEL32", auto) */
  134.         public native static int CreateNamedPipe (String lpName, int dwOpenMode, int dwPipeMode, int nMaxInstances, int nOutBufferSize, int nInBufferSize, int nDefaultTimeOut, SECURITY_ATTRIBUTES lpSecurityAttributes);
  135.  
  136.         /** @dll.import("KERNEL32",auto) */
  137.         public native static boolean CreatePipe (int[] hReadPipe, int[] hWritePipe, SECURITY_ATTRIBUTES lpPipeAttributes, int nSize);
  138.  
  139.         /** @dll.import("KERNEL32", auto) */
  140.         public native static boolean CreateProcess (String lpApplicationName, String lpCommandLine, SECURITY_ATTRIBUTES lpProcessAttributes, SECURITY_ATTRIBUTES lpThreadAttributes, boolean bInheritHandles, int dwCreationFlags, int lpEnvironment, String lpCurrentDirectory, STARTUPINFO lpStartupInfo, PROCESS_INFORMATION lpProcessInformation);
  141.  
  142.         /** @dll.import("KERNEL32",auto) */
  143.         public native static int CreateRemoteThread (int hProcess, SECURITY_ATTRIBUTES lpThreadAttributes, int dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, int lpParameter, int dwCreationFlags, int[] lpThreadId);
  144.  
  145.         /** @dll.import("KERNEL32", auto) */
  146.         public native static int CreateSemaphore (SECURITY_ATTRIBUTES lpSemaphoreAttributes, int lInitialCount, int lMaximumCount, String lpName);
  147.  
  148.         /** @dll.import("KERNEL32",auto) */
  149.         public native static int CreateTapePartition (int hDevice, int dwPartitionMethod, int dwCount, int dwSize);
  150.  
  151.         /** @dll.import("KERNEL32",auto) */
  152.         public native static int CreateThread (SECURITY_ATTRIBUTES lpThreadAttributes, int dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, int lpParameter, int dwCreationFlags, int[] lpThreadId);
  153.  
  154.         /** @dll.import("KERNEL32", auto) */
  155.         public native static int CreateWaitableTimer (SECURITY_ATTRIBUTES lpTimerAttributes, boolean bManualReset, String lpTimerName);
  156.  
  157.         /** @dll.import("KERNEL32",auto) */
  158.         public native static boolean DebugActiveProcess (int dwProcessId);
  159.  
  160.         /** @dll.import("KERNEL32",auto) */
  161.         public native static void DebugBreak ();
  162.  
  163.         /** @dll.import("KERNEL32", auto) */
  164.         public native static boolean DefineDosDevice (int dwFlags, String lpDeviceName, String lpTargetPath);
  165.  
  166.         /** @dll.import("KERNEL32",auto) */
  167.         public native static short DeleteAtom (short nAtom);
  168.  
  169.  
  170.  
  171.         /** @dll.import("KERNEL32",auto) */
  172.         public native static void DeleteFiber (int lpFiber);
  173.  
  174.         /** @dll.import("KERNEL32", auto) */
  175.         public native static boolean DeleteFile (String lpFileName);
  176.  
  177.         /** @dll.import("KERNEL32",auto) */
  178.         public native static boolean DeviceIoControl (int hDevice, int dwIoControlCode, int lpInBuffer, int nInBufferSize, int lpOutBuffer, int nOutBufferSize, int[] lpBytesReturned, OVERLAPPED lpOverlapped);
  179.  
  180.         /** @dll.import("KERNEL32",auto) */
  181.         public native static boolean DeviceIoControl (int hDevice, int dwIoControlCode, Object lpInBuffer, int nInBufferSize, Object lpOutBuffer, int nOutBufferSize, int[] lpBytesReturned, OVERLAPPED lpOverlapped);
  182.  
  183.         /** @dll.import("KERNEL32",auto) */
  184.         public native static boolean DisableThreadLibraryCalls (int hLibModule);
  185.  
  186.         /** @dll.import("KERNEL32",auto) */
  187.         public native static boolean DisconnectNamedPipe (int hNamedPipe);
  188.  
  189.         /** @dll.import("KERNEL32",auto) */
  190.         public native static boolean DosDateTimeToFileTime (short wFatDate, short wFatTime, FILETIME lpFileTime);
  191.  
  192.         /** @dll.import("KERNEL32",auto) */
  193.         public native static boolean DuplicateHandle (int hSourceProcessHandle, int hSourceHandle, int hTargetProcessHandle, int[] lpTargetHandle, int dwDesiredAccess, boolean bInheritHandle, int dwOptions);
  194.  
  195.         /** @dll.import("KERNEL32",auto) */
  196.         public native static boolean EndUpdateResource (int hUpdate, boolean fDiscard);
  197.  
  198.  
  199.  
  200.         /** @dll.import("KERNEL32",auto) */
  201.         public native static boolean EnumCalendarInfo (CALINFO_ENUMPROC lpCalInfoEnumProc, int Locale, int Calendar, int CalType);
  202.  
  203.         /** @dll.import("KERNEL32",auto) */
  204.         public native static boolean EnumDateFormats (DATEFMT_ENUMPROC lpDateFmtEnumProc, int Locale, int dwFlags);
  205.  
  206.         /** @dll.import("KERNEL32", auto) */
  207.         public native static boolean EnumResourceLanguages (int hModule, String lpType, String lpName, ENUMRESLANGPROC lpEnumFunc, int lParam);
  208.  
  209.         /** @dll.import("KERNEL32", auto) */
  210.         public native static boolean EnumResourceNames (int hModule, String lpType, ENUMRESNAMEPROC lpEnumFunc, int lParam);
  211.  
  212.         /** @dll.import("KERNEL32",auto) */
  213.         public native static boolean EnumResourceTypes (int hModule, ENUMRESTYPEPROC lpEnumFunc, int lParam);
  214.  
  215.         /** @dll.import("KERNEL32",auto) */
  216.         public native static boolean EnumSystemCodePages (CODEPAGE_ENUMPROC lpCodePageEnumProc, int dwFlags);
  217.  
  218.         /** @dll.import("KERNEL32",auto) */
  219.         public native static boolean EnumSystemLocales (LOCALE_ENUMPROC lpLocaleEnumProc, int dwFlags);
  220.  
  221.         /** @dll.import("KERNEL32",auto) */
  222.         public native static boolean EnumTimeFormats (TIMEFMT_ENUMPROC lpTimeFmtEnumProc, int Locale, int dwFlags);
  223.  
  224.         /** @dll.import("KERNEL32",auto) */
  225.         public native static int EraseTape (int hDevice, int dwEraseType, boolean bImmediate);
  226.  
  227.         /** @dll.import("KERNEL32",auto) */
  228.         public native static boolean EscapeCommFunction (int hFile, int dwFunc);
  229.  
  230.         /** @dll.import("KERNEL32",auto) */
  231.         public native static void ExitProcess (int uExitCode);
  232.  
  233.         /** @dll.import("KERNEL32",auto) */
  234.         public native static void ExitThread (int dwExitCode);
  235.  
  236.         /** @dll.import("KERNEL32", auto) */
  237.         public native static int ExpandEnvironmentStrings (String lpSrc, StringBuffer lpDst, int nSize);
  238.  
  239.         /** @dll.import("KERNEL32", auto) */
  240.         public native static void FatalAppExit (int uAction, String lpMessageText);
  241.  
  242.         /** @dll.import("KERNEL32",auto) */
  243.         public native static void FatalExit (int ExitCode);
  244.  
  245.         /** @dll.import("KERNEL32",auto) */
  246.         public native static boolean FileTimeToDosDateTime (FILETIME lpFileTime, short[] lpFatDate, short[] lpFatTime);
  247.  
  248.         /** @dll.import("KERNEL32",auto) */
  249.         public native static boolean FileTimeToLocalFileTime (FILETIME lpFileTime, FILETIME lpLocalFileTime);
  250.  
  251.         /** @dll.import("KERNEL32",auto) */
  252.         public native static boolean FileTimeToSystemTime (FILETIME lpFileTime, SYSTEMTIME lpSystemTime);
  253.  
  254.         /** @dll.import("KERNEL32", auto, entrypoint="FillConsoleOutputAttribute") */
  255.         private native static boolean FillConsoleOutputAttribute_I (int hConsoleOutput, short wAttribute, int nLength, int dwWriteCoord, int[] lpNumberOfAttrsWritten);
  256.           
  257.         public static boolean FillConsoleOutputAttribute (int hConsoleOutput, short wAttribute, int nLength, COORD dwWriteCoord, int[] lpNumberOfAttrsWritten)
  258.         {
  259.            return FillConsoleOutputAttribute_I (hConsoleOutput, wAttribute, nLength, expandCoord(dwWriteCoord), lpNumberOfAttrsWritten);
  260.         }
  261.  
  262.         /** @dll.import("KERNEL32", auto, entrypoint="FillConsoleOutputCharacter") */
  263.         private native static boolean FillConsoleOutputCharacter_I (int hConsoleOutput, char cCharacter, int nLength, int dwWriteCoord, int[] lpNumberOfCharsWritten);
  264.  
  265.         public static boolean FillConsoleOutputCharacter (int hConsoleOutput, char cCharacter, int nLength, COORD dwWriteCoord, int[] lpNumberOfCharsWritten)
  266.         {
  267.            return FillConsoleOutputCharacter_I (hConsoleOutput, cCharacter, nLength, expandCoord(dwWriteCoord), lpNumberOfCharsWritten);
  268.         }
  269.  
  270.         /** @dll.import("KERNEL32", auto) */
  271.         public native static short FindAtom (String lpString);
  272.  
  273.         /** @dll.import("KERNEL32",auto) */
  274.         public native static boolean FindClose (int hFindFile);
  275.  
  276.         /** @dll.import("KERNEL32",auto) */
  277.         public native static boolean FindCloseChangeNotification (int hChangeHandle);
  278.  
  279.         /** @dll.import("KERNEL32", auto) */
  280.         public native static int FindFirstChangeNotification (String lpPathName, boolean bWatchSubtree, int dwNotifyFilter);
  281.  
  282.         /** @dll.import("KERNEL32", auto, setLastError) */
  283.         public native static int FindFirstFileEx (String lpFileName, int fInfoLevelId, Object lpFindFileData, int fSearchOp, Object lpSearchFilter, int dwAdditionalFlags);
  284.  
  285.         /** @dll.import("KERNEL32", auto, setLastError) */
  286.         public native static int FindFirstFile (String lpFileName, WIN32_FIND_DATA lpFindFileData);
  287.  
  288.         /** @dll.import("KERNEL32",auto) */
  289.         public native static boolean FindNextChangeNotification (int hChangeHandle);
  290.  
  291.         /** @dll.import("KERNEL32",auto,setLastError) */
  292.         public native static boolean FindNextFile (int hFindFile, WIN32_FIND_DATA lpFindFileData);
  293.  
  294.         /** @dll.import("KERNEL32", auto) */
  295.         public native static int FindResourceEx (int hModule, String lpType, String lpName, short wLanguage);
  296.  
  297.         /** @dll.import("KERNEL32", auto) */
  298.         public native static int FindResource (int hModule, String lpName, String lpType);
  299.  
  300.         /** @dll.import("KERNEL32",auto) */
  301.         public native static boolean FlushConsoleInputBuffer (int hConsoleInput);
  302.  
  303.         /** @dll.import("KERNEL32",auto) */
  304.         public native static boolean FlushFileBuffers (int hFile);
  305.  
  306.         /** @dll.import("KERNEL32",auto) */
  307.         public native static boolean FlushInstructionCache (int hProcess, int lpBaseAddress, int dwSize);
  308.  
  309.         /** @dll.import("KERNEL32",auto) */
  310.         public native static boolean FlushViewOfFile (int lpBaseAddress, int dwNumberOfBytesToFlush);
  311.  
  312.         /** @dll.import("KERNEL32", auto) */
  313.         public native static int FoldString (int dwMapFlags, String lpSrcStr, int cchSrc, StringBuffer lpDestStr, int cchDest);
  314.  
  315.  
  316.  
  317.         /** @dll.import("KERNEL32",auto) */
  318.         public native static boolean FreeConsole ();
  319.  
  320.         /** @dll.import("KERNEL32", auto) */
  321.         public native static boolean FreeEnvironmentStrings (int anonymous0);
  322.  
  323.         /** @dll.import("KERNEL32",auto) */
  324.         public native static boolean FreeLibrary (int hLibModule);
  325.  
  326.         /** @dll.import("KERNEL32",auto) */
  327.         public native static void FreeLibraryAndExitThread (int hLibModule, int dwExitCode);
  328.  
  329.         /** @dll.import("KERNEL32",auto) */
  330.         public native static boolean FreeResource (int hResData);
  331.  
  332.         /** @dll.import("KERNEL32",auto) */
  333.         public native static boolean GenerateConsoleCtrlEvent (int dwCtrlEvent, int dwProcessGroupId);
  334.  
  335.         /** @dll.import("KERNEL32",auto) */
  336.         public native static int GetACP ();
  337.  
  338.         /** @dll.import("KERNEL32", auto) */
  339.         public native static int GetAtomName (short nAtom, StringBuffer lpBuffer, int nSize);
  340.  
  341.         /** @dll.import("KERNEL32", auto) */
  342.         public native static boolean GetBinaryType (String lpApplicationName, int[] lpBinaryType);
  343.  
  344.         /** @dll.import("KERNEL32",auto) */
  345.         public native static boolean GetCPInfo (int CodePage, CPINFO lpCPInfo);
  346.  
  347.  
  348.  
  349.         /** @dll.import("KERNEL32",auto) */
  350.         public native static boolean GetCommMask (int hFile, int[] lpEvtMask);
  351.  
  352.         /** @dll.import("KERNEL32",auto) */
  353.         public native static boolean GetCommModemStatus (int hFile, int[] lpModemStat);
  354.  
  355.  
  356.  
  357.         /** @dll.import("KERNEL32",auto) */
  358.         public native static boolean GetCommState (int hFile, DCB lpDCB);
  359.  
  360.         /** @dll.import("KERNEL32",auto) */
  361.         public native static boolean GetCommTimeouts (int hFile, COMMTIMEOUTS lpCommTimeouts);
  362.  
  363.         /** @dll.import("KERNEL32",auto) */
  364.         public native static int GetCommandLine ();
  365.  
  366.         /** @dll.import("KERNEL32", auto) */
  367.         public native static int GetCompressedFileSize (String lpFileName, int[] lpFileSizeHigh);
  368.  
  369.         /** @dll.import("KERNEL32", auto) */
  370.         public native static boolean GetComputerName (StringBuffer lpBuffer, int[] nSize);
  371.  
  372.         /** @dll.import("KERNEL32",auto) */
  373.         public native static int GetConsoleCP ();
  374.  
  375.         /** @dll.import("KERNEL32",auto) */
  376.         public native static boolean GetConsoleCursorInfo (int hConsoleOutput, CONSOLE_CURSOR_INFO lpConsoleCursorInfo);
  377.  
  378.         /** @dll.import("KERNEL32",auto) */
  379.         public native static boolean GetConsoleMode (int hConsoleHandle, int[] lpMode);
  380.  
  381.         /** @dll.import("KERNEL32",auto) */
  382.         public native static int GetConsoleOutputCP ();
  383.  
  384.         /** @dll.import("KERNEL32",auto) */
  385.         public native static boolean GetConsoleScreenBufferInfo (int hConsoleOutput, CONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo);
  386.  
  387.         /** @dll.import("KERNEL32", auto) */
  388.         public native static int GetConsoleTitle (StringBuffer lpConsoleTitle, int nSize);
  389.  
  390.         /** @dll.import("KERNEL32", auto) */
  391.         public native static int GetCurrencyFormat (int Locale, int dwFlags, String lpValue, CURRENCYFMT lpFormat, StringBuffer lpCurrencyStr, int cchCurrency);
  392.  
  393.         /** @dll.import("KERNEL32", auto) */
  394.         public native static int GetCurrentDirectory (int nBufferLength, StringBuffer lpBuffer);
  395.  
  396.         /** @dll.import("KERNEL32",auto) */
  397.         public native static int GetCurrentProcess ();
  398.  
  399.         /** @dll.import("KERNEL32",auto) */
  400.         public native static int GetCurrentProcessId ();
  401.  
  402.         /** @dll.import("KERNEL32",auto) */
  403.         public native static int GetCurrentThread ();
  404.  
  405.         /** @dll.import("KERNEL32",auto) */
  406.         public native static int GetCurrentThreadId ();
  407.  
  408.         /** @dll.import("KERNEL32", auto) */
  409.         public native static int GetDateFormat (int Locale, int dwFlags, SYSTEMTIME lpDate, String lpFormat, StringBuffer lpDateStr, int cchDate);
  410.  
  411.  
  412.  
  413.         /** @dll.import("KERNEL32", auto) */
  414.         public native static boolean GetDiskFreeSpaceEx (String lpDirectoryName, long[] lpFreeBytesAvailableToCaller, long[] lpTotalNumberOfBytes, long[] lpTotalNumberOfFreeBytes);
  415.  
  416.         /** @dll.import("KERNEL32", auto) */
  417.         public native static boolean GetDiskFreeSpace (String lpRootPathName, int[] lpSectorsPerCluster, int[] lpBytesPerSector, int[] lpNumberOfFreeClusters, int[] lpTotalNumberOfClusters);
  418.  
  419.         /** @dll.import("KERNEL32", auto) */
  420.         public native static int GetDriveType (String lpRootPathName);
  421.  
  422.         /** @dll.import("KERNEL32",auto) */
  423.         public native static int GetEnvironmentStrings ();
  424.  
  425.         /** @dll.import("KERNEL32", auto) */
  426.         public native static int GetEnvironmentVariable (String lpName, StringBuffer lpBuffer, int nSize);
  427.  
  428.         /** @dll.import("KERNEL32",auto) */
  429.         public native static boolean GetExitCodeProcess (int hProcess, int[] lpExitCode);
  430.  
  431.         /** @dll.import("KERNEL32",auto) */
  432.         public native static boolean GetExitCodeThread (int hThread, int[] lpExitCode);
  433.  
  434.         /** @dll.import("KERNEL32", auto) */
  435.         public native static boolean GetFileAttributesEx (String lpFileName, int fInfoLevelId, Object lpFileInformation);
  436.  
  437.         /** @dll.import("KERNEL32", auto) */
  438.         public native static int GetFileAttributes (String lpFileName);
  439.  
  440.         /** @dll.import("KERNEL32",auto) */
  441.         public native static boolean GetFileInformationByHandle (int hFile, BY_HANDLE_FILE_INFORMATION lpFileInformation);
  442.  
  443.         /** @dll.import("KERNEL32",auto) */
  444.         public native static int GetFileSize (int hFile, int[] lpFileSizeHigh);
  445.  
  446.         /** @dll.import("KERNEL32",auto) */
  447.         public native static boolean GetFileTime (int hFile, FILETIME lpCreationTime, FILETIME lpLastAccessTime, FILETIME lpLastWriteTime);
  448.  
  449.         /** @dll.import("KERNEL32",auto) */
  450.         public native static int GetFileType (int hFile);
  451.  
  452.         /** @dll.import("KERNEL32", auto) */
  453.         public native static int GetFullPathName (String lpFileName, int nBufferLength, StringBuffer lpBuffer, int lpFilePart);
  454.  
  455.         /** @dll.import("KERNEL32",auto) */
  456.         public native static boolean GetHandleInformation (int hObject, int[] lpdwFlags);
  457.  
  458.         /** @dll.import("KERNEL32",auto, entrypoint="GetLargestConsoleWindowSize") */
  459.         private native static int GetLargestConsoleWindowSize_I (int hConsoleOutput);
  460.  
  461.         public static COORD GetLargestConsoleWindowSize (int hConsoleOutput)
  462.           {
  463.               int coord_val = GetLargestConsoleWindowSize_I (hConsoleOutput);
  464.               COORD c = new COORD();
  465.               c.X = (short) (coord_val >> 16);
  466.               c.Y = (short) (coord_val & 0xFFFF);
  467.               return c;
  468.           }
  469.  
  470.         /** @dll.import("KERNEL32",auto) */
  471.         public native static int GetLastError ();
  472.  
  473.         /** @dll.import("KERNEL32",auto) */
  474.         public native static void GetLocalTime (SYSTEMTIME lpSystemTime);
  475.  
  476.         /** @dll.import("KERNEL32", auto) */
  477.         public native static int GetLocaleInfo (int Locale, int LCType, StringBuffer lpLCData, int cchData);
  478.  
  479.         /** @dll.import("KERNEL32", auto) */
  480.         public native static int GetLogicalDriveStrings (int nBufferLength, Object lpBuffer);
  481.  
  482.         /** @dll.import("KERNEL32",auto) */
  483.         public native static int GetLogicalDrives ();
  484.  
  485.         /** @dll.import("KERNEL32",auto) */
  486.         public native static boolean GetMailslotInfo (int hMailslot, int[] lpMaxMessageSize, int[] lpNextSize, int[] lpMessageCount, int[] lpReadTimeout);
  487.  
  488.         /** @dll.import("KERNEL32", auto) */
  489.         public native static int GetModuleFileName (int hModule, StringBuffer lpFilename, int nSize);
  490.  
  491.         /** @dll.import("KERNEL32", auto) */
  492.         public native static int GetModuleHandle (String lpModuleName);
  493.  
  494.         /** @dll.import("KERNEL32", auto) */
  495.         public native static boolean GetNamedPipeHandleState (int hNamedPipe, int[] lpState, int[] lpCurInstances, int[] lpMaxCollectionCount, int[] lpCollectDataTimeout, StringBuffer lpUserName, int nMaxUserNameSize);
  496.  
  497.         /** @dll.import("KERNEL32",auto) */
  498.         public native static boolean GetNamedPipeInfo (int hNamedPipe, int[] lpFlags, int[] lpOutBufferSize, int[] lpInBufferSize, int[] lpMaxInstances);
  499.  
  500.         /** @dll.import("KERNEL32", auto) */
  501.         public native static int GetNumberFormat (int Locale, int dwFlags, String lpValue, NUMBERFMT lpFormat, StringBuffer lpNumberStr, int cchNumber);
  502.  
  503.         /** @dll.import("KERNEL32",auto) */
  504.         public native static boolean GetNumberOfConsoleInputEvents (int hConsoleInput, int[] lpNumberOfEvents);
  505.  
  506.         /** @dll.import("KERNEL32",auto) */
  507.         public native static boolean GetNumberOfConsoleMouseButtons (int[] lpNumberOfMouseButtons);
  508.  
  509.         /** @dll.import("KERNEL32",auto) */
  510.         public native static int GetOEMCP ();
  511.  
  512.         /** @dll.import("KERNEL32",auto) */
  513.         public native static boolean GetOverlappedResult (int hFile, OVERLAPPED lpOverlapped, int[] lpNumberOfBytesTransferred, boolean bWait);
  514.  
  515.         /** @dll.import("KERNEL32",auto) */
  516.         public native static int GetPriorityClass (int hProcess);
  517.  
  518.         /** @dll.import("KERNEL32", auto) */
  519.         public native static int GetPrivateProfileInt (String lpAppName, String lpKeyName, int nDefault, String lpFileName);
  520.  
  521.         /** @dll.import("KERNEL32", auto) */
  522.         public native static int GetPrivateProfileSectionNames (Object lpszReturnBuffer, int nSize, String lpFileName);
  523.  
  524.         /** @dll.import("KERNEL32", auto) */
  525.         public native static int GetPrivateProfileSection (String lpAppName, Object lpReturnedString, int nSize, String lpFileName);
  526.  
  527.         /** @dll.import("KERNEL32", auto) */
  528.         public native static int GetPrivateProfileString (String lpAppName, String lpKeyName, String lpDefault, StringBuffer lpReturnedString, int nSize, String lpFileName);
  529.  
  530.         /** @dll.import("KERNEL32", auto) */
  531.         public native static boolean GetPrivateProfileStruct (String lpszSection, String lpszKey, Object lpStruct, int uSizeStruct, String szFile);
  532.  
  533.         /** @dll.import("KERNEL32", ansi) */
  534.         public native static int GetProcAddress (int hModule, String lpProcName);
  535.  
  536.         /** @dll.import("KERNEL32",auto) */
  537.         public native static boolean GetProcessAffinityMask (int hProcess, int[] lpProcessAffinityMask, int[] lpSystemAffinityMask);
  538.  
  539.         /** @dll.import("KERNEL32",auto) */
  540.         public native static int GetProcessHeap ();
  541.  
  542.         /** @dll.import("KERNEL32",auto) */
  543.         public native static int GetProcessHeaps (int NumberOfHeaps, int[] ProcessHeaps);
  544.  
  545.         /** @dll.import("KERNEL32",auto) */
  546.         public native static boolean GetProcessPriorityBoost (int hProcess, boolean[] pDisablePriorityBoost);
  547.  
  548.         /** @dll.import("KERNEL32",auto) */
  549.         public native static boolean GetProcessShutdownParameters (int[] lpdwLevel, int[] lpdwFlags);
  550.  
  551.         /** @dll.import("KERNEL32",auto) */
  552.         public native static boolean GetProcessTimes (int hProcess, FILETIME lpCreationTime, FILETIME lpExitTime, FILETIME lpKernelTime, FILETIME lpUserTime);
  553.  
  554.         /** @dll.import("KERNEL32",auto) */
  555.         public native static int GetProcessVersion (int ProcessId);
  556.  
  557.         /** @dll.import("KERNEL32",auto) */
  558.         public native static boolean GetProcessWorkingSetSize (int hProcess, int[] lpMinimumWorkingSetSize, int[] lpMaximumWorkingSetSize);
  559.  
  560.         /** @dll.import("KERNEL32", auto) */
  561.         public native static int GetProfileInt (String lpAppName, String lpKeyName, int nDefault);
  562.  
  563.         /** @dll.import("KERNEL32", auto) */
  564.         public native static int GetProfileSection (String lpAppName, Object lpReturnedString, int nSize);
  565.  
  566.         /** @dll.import("KERNEL32", auto) */
  567.         public native static int GetProfileString (String lpAppName, String lpKeyName, String lpDefault, StringBuffer lpReturnedString, int nSize);
  568.  
  569.         /** @dll.import("KERNEL32",auto) */
  570.         public native static boolean GetQueuedCompletionStatus (int CompletionPort, int[] lpNumberOfBytesTransferred, int[] lpCompletionKey, OVERLAPPED lpOverlapped, int dwMilliseconds);
  571.  
  572.         /** @dll.import("KERNEL32", auto) */
  573.         public native static int GetShortPathName (String lpszLongPath, StringBuffer lpszShortPath, int cchBuffer);
  574.  
  575.         /** @dll.import("KERNEL32",entrypoint="GetStartupInfo") */
  576.         private native static void GetStartupInfo_I (STARTUPINFO_I lpStartupInfo);
  577.  
  578.         public static void GetStartupInfo(STARTUPINFO lpStartupInfo)
  579.         {
  580.             STARTUPINFO_I sii = new STARTUPINFO_I();
  581.             sii.cb = com.ms.dll.DllLib.sizeOf(sii.getClass());
  582.             GetStartupInfo_I(sii);
  583.             lpStartupInfo.cb                = sii.cb;
  584.             lpStartupInfo.lpReserved        = com.ms.dll.DllLib.ptrToString(sii.lpReserved);
  585.             lpStartupInfo.lpDesktop         = com.ms.dll.DllLib.ptrToString(sii.lpDesktop);
  586.             lpStartupInfo.lpTitle           = com.ms.dll.DllLib.ptrToString(sii.lpTitle);
  587.             lpStartupInfo.dwX               = sii.dwX;
  588.             lpStartupInfo.dwY               = sii.dwY;
  589.             lpStartupInfo.dwXSize           = sii.dwXSize;
  590.             lpStartupInfo.dwYSize           = sii.dwYSize;
  591.             lpStartupInfo.dwXCountChars     = sii.dwXCountChars;
  592.             lpStartupInfo.dwYCountChars     = sii.dwYCountChars;
  593.             lpStartupInfo.dwFillAttribute   = sii.dwFillAttribute;
  594.             lpStartupInfo.dwFlags           = sii.dwFlags;
  595.             lpStartupInfo.wShowWindow       = sii.wShowWindow;
  596.             lpStartupInfo.cbReserved2       = sii.cbReserved2;
  597.             lpStartupInfo.lpReserved2       = sii.lpReserved2;
  598.             lpStartupInfo.hStdInput         = sii.hStdInput;
  599.             lpStartupInfo.hStdOutput        = sii.hStdOutput;
  600.             lpStartupInfo.hStdError         = sii.hStdError;
  601.         }
  602.  
  603.         /** @dll.import("KERNEL32",auto) */
  604.         public native static int GetStdHandle (int nStdHandle);
  605.  
  606.         /** @dll.import("KERNEL32", auto) */
  607.         public native static boolean GetStringTypeEx (int Locale, int dwInfoType, String lpSrcStr, int cchSrc, short[] lpCharType);
  608.  
  609.         /** @dll.import("KERNEL32", auto) */
  610.         public native static boolean GetStringType (int dwInfoType, String lpSrcStr, int cchSrc, short[] lpCharType);
  611.  
  612.         /** @dll.import("KERNEL32",auto) */
  613.         public native static int GetSystemDefaultLCID ();
  614.  
  615.         /** @dll.import("KERNEL32",auto) */
  616.         public native static short GetSystemDefaultLangID ();
  617.  
  618.         /** @dll.import("KERNEL32", auto) */
  619.         public native static int GetSystemDirectory (StringBuffer lpBuffer, int uSize);
  620.  
  621.         /** @dll.import("KERNEL32", auto) */
  622.         public native static void GetSystemInfo(SYSTEM_INFO lpSystemInfo);
  623.  
  624.         /** @dll.import("KERNEL32",auto) */
  625.         public native static boolean GetSystemPowerStatus (SYSTEM_POWER_STATUS lpSystemPowerStatus);
  626.  
  627.         /** @dll.import("KERNEL32",auto) */
  628.         public native static void GetSystemTime (SYSTEMTIME lpSystemTime);
  629.  
  630.         /** @dll.import("KERNEL32",auto) */
  631.         public native static boolean GetSystemTimeAdjustment (int[] lpTimeAdjustment, int[] lpTimeIncrement, boolean[] lpTimeAdjustmentDisabled);
  632.  
  633.         /** @dll.import("KERNEL32",auto) */
  634.         public native static void GetSystemTimeAsFileTime (FILETIME lpSystemTimeAsFileTime);
  635.  
  636.         /** @dll.import("KERNEL32",auto) */
  637.         public native static int GetTapeParameters (int hDevice, int dwOperation, int[] lpdwSize, Object lpTapeInformation);
  638.  
  639.         /** @dll.import("KERNEL32",auto) */
  640.         public native static int GetTapePosition (int hDevice, int dwPositionType, int[] lpdwPartition, int[] lpdwOffsetLow, int[] lpdwOffsetHigh);
  641.  
  642.         /** @dll.import("KERNEL32",auto) */
  643.         public native static int GetTapeStatus (int hDevice);
  644.  
  645.         /** @dll.import("KERNEL32", auto) */
  646.         public native static int GetTempFileName (String lpPathName, String lpPrefixString, int uUnique, StringBuffer lpTempFileName);
  647.  
  648.         /** @dll.import("KERNEL32", auto) */
  649.         public native static int GetTempPath (int nBufferLength, StringBuffer lpBuffer);
  650.  
  651.  
  652.  
  653.         /** @dll.import("KERNEL32",auto) */
  654.         public native static int GetThreadLocale ();
  655.  
  656.         /** @dll.import("KERNEL32",auto) */
  657.         public native static int GetThreadPriority (int hThread);
  658.  
  659.         /** @dll.import("KERNEL32",auto) */
  660.         public native static boolean GetThreadPriorityBoost (int hThread, boolean[] pDisablePriorityBoost);
  661.  
  662.  
  663.         /** @dll.import("KERNEL32",auto) */
  664.         public native static boolean GetThreadTimes (int hThread, FILETIME lpCreationTime, FILETIME lpExitTime, FILETIME lpKernelTime, FILETIME lpUserTime);
  665.  
  666.         /** @dll.import("KERNEL32",auto) */
  667.         public native static int GetTickCount ();
  668.  
  669.         /** @dll.import("KERNEL32", auto) */
  670.         public native static int GetTimeFormat (int Locale, int dwFlags, SYSTEMTIME lpTime, String lpFormat, StringBuffer lpTimeStr, int cchTime);
  671.  
  672.         /** @dll.import("KERNEL32",auto) */
  673.         public native static int GetTimeZoneInformation (TIME_ZONE_INFORMATION lpTimeZoneInformation);
  674.  
  675.         /** @dll.import("KERNEL32",auto) */
  676.         public native static int GetUserDefaultLCID ();
  677.  
  678.         /** @dll.import("KERNEL32",auto) */
  679.         public native static short GetUserDefaultLangID ();
  680.  
  681.         /** @dll.import("KERNEL32",auto) */
  682.         public native static int GetVersion ();
  683.  
  684.         /** @dll.import("KERNEL32",auto) */
  685.         public native static boolean GetVersionEx (OSVERSIONINFO lpVersionInformation);
  686.  
  687.         /** @dll.import("KERNEL32", auto) */
  688.         public native static boolean GetVolumeInformation (String lpRootPathName, StringBuffer lpVolumeNameBuffer, int nVolumeNameSize, int[] lpVolumeSerialNumber, int[] lpMaximumComponentLength, int[] lpFileSystemFlags, StringBuffer lpFileSystemNameBuffer, int nFileSystemNameSize);
  689.  
  690.         /** @dll.import("KERNEL32", auto) */
  691.         public native static int GetWindowsDirectory (StringBuffer lpBuffer, int uSize);
  692.  
  693.         /** @dll.import("KERNEL32", auto) */
  694.         public native static short GlobalAddAtom (String lpString);
  695.  
  696.         /** @dll.import("KERNEL32",auto) */
  697.         public native static int GlobalAlloc (int uFlags, int dwBytes);
  698.  
  699.         /** @dll.import("KERNEL32",auto) */
  700.         public native static int GlobalCompact (int dwMinFree);
  701.  
  702.         /** @dll.import("KERNEL32",auto) */
  703.         public native static short GlobalDeleteAtom (short nAtom);
  704.  
  705.         /** @dll.import("KERNEL32", auto) */
  706.         public native static short GlobalFindAtom (String lpString);
  707.  
  708.         /** @dll.import("KERNEL32",auto) */
  709.         public native static void GlobalFix (int hMem);
  710.  
  711.         /** @dll.import("KERNEL32",auto) */
  712.         public native static int GlobalFlags (int hMem);
  713.  
  714.         /** @dll.import("KERNEL32",auto) */
  715.         public native static int GlobalFree (int hMem);
  716.  
  717.         /** @dll.import("KERNEL32", auto) */
  718.         public native static int GlobalGetAtomName (short nAtom, StringBuffer lpBuffer, int nSize);
  719.  
  720.         /** @dll.import("KERNEL32",auto) */
  721.         public native static int GlobalHandle (int pMem);
  722.  
  723.         /** @dll.import("KERNEL32",auto) */
  724.         public native static int GlobalLock (int hMem);
  725.  
  726.         /** @dll.import("KERNEL32",auto) */
  727.         public native static void GlobalMemoryStatus (MEMORYSTATUS lpBuffer);
  728.  
  729.         /** @dll.import("KERNEL32",auto) */
  730.         public native static int GlobalReAlloc (int hMem, int dwBytes, int uFlags);
  731.  
  732.         /** @dll.import("KERNEL32",auto) */
  733.         public native static int GlobalSize (int hMem);
  734.  
  735.         /** @dll.import("KERNEL32",auto) */
  736.         public native static boolean GlobalUnWire (int hMem);
  737.  
  738.         /** @dll.import("KERNEL32",auto) */
  739.         public native static void GlobalUnfix (int hMem);
  740.  
  741.         /** @dll.import("KERNEL32",auto) */
  742.         public native static boolean GlobalUnlock (int hMem);
  743.  
  744.         /** @dll.import("KERNEL32",auto) */
  745.         public native static int GlobalWire (int hMem);
  746.  
  747.         /** @dll.import("KERNEL32",auto) */
  748.         public native static int HeapAlloc (int hHeap, int dwFlags, int dwBytes);
  749.  
  750.         /** @dll.import("KERNEL32",auto) */
  751.         public native static int HeapCompact (int hHeap, int dwFlags);
  752.  
  753.         /** @dll.import("KERNEL32",auto) */
  754.         public native static int HeapCreate (int flOptions, int dwInitialSize, int dwMaximumSize);
  755.  
  756.         /** @dll.import("KERNEL32",auto) */
  757.         public native static boolean HeapDestroy (int hHeap);
  758.  
  759.         /** @dll.import("KERNEL32",auto) */
  760.         public native static boolean HeapFree (int hHeap, int dwFlags, int lpMem);
  761.  
  762.         /** @dll.import("KERNEL32",auto) */
  763.         public native static boolean HeapLock (int hHeap);
  764.  
  765.         /** @dll.import("KERNEL32",auto) */
  766.         public native static int HeapReAlloc (int hHeap, int dwFlags, int lpMem, int dwBytes);
  767.  
  768.         /** @dll.import("KERNEL32",auto) */
  769.         public native static int HeapSize (int hHeap, int dwFlags, int lpMem);
  770.  
  771.         /** @dll.import("KERNEL32",auto) */
  772.         public native static boolean HeapUnlock (int hHeap);
  773.  
  774.         /** @dll.import("KERNEL32",auto) */
  775.         public native static boolean HeapValidate (int hHeap, int dwFlags, int lpMem);
  776.  
  777.  
  778.         /** @dll.import("KERNEL32",auto) */
  779.         public native static boolean InitAtomTable (int nSize);
  780.  
  781.  
  782.         /** @dll.import("KERNEL32",auto) */
  783.         public native static boolean IsBadCodePtr (int lpfn);
  784.  
  785.         /** @dll.import("KERNEL32",auto) */
  786.         public native static boolean IsBadHugeReadPtr (int lp, int ucb);
  787.  
  788.         /** @dll.import("KERNEL32",auto) */
  789.         public native static boolean IsBadHugeWritePtr (int lp, int ucb);
  790.  
  791.         /** @dll.import("KERNEL32",auto) */
  792.         public native static boolean IsBadReadPtr (int lp, int ucb);
  793.  
  794.         /** @dll.import("KERNEL32", auto) */
  795.         public native static boolean IsBadStringPtr (int lpsz, int ucchMax);
  796.  
  797.         /** @dll.import("KERNEL32",auto) */
  798.         public native static boolean IsBadWritePtr (int lp, int ucb);
  799.  
  800.         /** @dll.import("KERNEL32",auto) */
  801.         public native static boolean IsDBCSLeadByte (byte TestChar);
  802.  
  803.         /** @dll.import("KERNEL32",auto) */
  804.         public native static boolean IsDBCSLeadByteEx (int CodePage, byte TestChar);
  805.  
  806.         /** @dll.import("KERNEL32",auto) */
  807.         public native static boolean IsProcessorFeaturePresent (int ProcessorFeature);
  808.  
  809.         /** @dll.import("KERNEL32",auto) */
  810.         public native static boolean IsValidCodePage (int CodePage);
  811.  
  812.         /** @dll.import("KERNEL32",auto) */
  813.         public native static boolean IsValidLocale (int Locale, int dwFlags);
  814.  
  815.         /** @dll.import("KERNEL32", auto) */
  816.         public native static int LCMapString (int Locale, int dwMapFlags, String lpSrcStr, int cchSrc, StringBuffer lpDestStr, int cchDest);
  817.  
  818.  
  819.  
  820.         /** @dll.import("KERNEL32", auto,setLastError) */
  821.         public native static int LoadLibraryEx (String lpLibFileName, int hFile, int dwFlags);
  822.  
  823.         /** @dll.import("KERNEL32", auto,setLastError) */
  824.         public native static int LoadLibrary (String lpLibFileName);
  825.  
  826.  
  827.         /** @dll.import("KERNEL32",auto) */
  828.         public native static int LoadResource (int hModule, int hResInfo);
  829.  
  830.         /** @dll.import("KERNEL32",auto) */
  831.         public native static int LocalAlloc (int uFlags, int uBytes);
  832.  
  833.         /** @dll.import("KERNEL32",auto) */
  834.         public native static int LocalCompact (int uMinFree);
  835.  
  836.         /** @dll.import("KERNEL32",auto) */
  837.         public native static boolean LocalFileTimeToFileTime (FILETIME lpLocalFileTime, FILETIME lpFileTime);
  838.  
  839.         /** @dll.import("KERNEL32",auto) */
  840.         public native static int LocalFlags (int hMem);
  841.  
  842.         /** @dll.import("KERNEL32",auto) */
  843.         public native static int LocalFree (int hMem);
  844.  
  845.         /** @dll.import("KERNEL32",auto) */
  846.         public native static int LocalHandle (int pMem);
  847.  
  848.         /** @dll.import("KERNEL32",auto) */
  849.         public native static int LocalLock (int hMem);
  850.  
  851.         /** @dll.import("KERNEL32",auto) */
  852.         public native static int LocalReAlloc (int hMem, int uBytes, int uFlags);
  853.  
  854.         /** @dll.import("KERNEL32",auto) */
  855.         public native static int LocalShrink (int hMem, int cbNewSize);
  856.  
  857.         /** @dll.import("KERNEL32",auto) */
  858.         public native static int LocalSize (int hMem);
  859.  
  860.         /** @dll.import("KERNEL32",auto) */
  861.         public native static boolean LocalUnlock (int hMem);
  862.  
  863.         /** @dll.import("KERNEL32",auto) */
  864.         public native static boolean LockFile (int hFile, int dwFileOffsetLow, int dwFileOffsetHigh, int nNumberOfBytesToLockLow, int nNumberOfBytesToLockHigh);
  865.  
  866.         /** @dll.import("KERNEL32",auto) */
  867.         public native static boolean LockFileEx (int hFile, int dwFlags, int dwReserved, int nNumberOfBytesToLockLow, int nNumberOfBytesToLockHigh, OVERLAPPED lpOverlapped);
  868.  
  869.         /** @dll.import("KERNEL32",auto) */
  870.         public native static int LockResource (int hResData);
  871.  
  872.         /** @dll.import("KERNEL32",auto) */
  873.         public native static int MapViewOfFile (int hFileMappingObject, int dwDesiredAccess, int dwFileOffsetHigh, int dwFileOffsetLow, int dwNumberOfBytesToMap);
  874.  
  875.         /** @dll.import("KERNEL32",auto) */
  876.         public native static int MapViewOfFileEx (int hFileMappingObject, int dwDesiredAccess, int dwFileOffsetHigh, int dwFileOffsetLow, int dwNumberOfBytesToMap, int lpBaseAddress);
  877.  
  878.         /** @dll.import("KERNEL32", auto) */
  879.         public native static boolean MoveFileEx (String lpExistingFileName, String lpNewFileName, int dwFlags);
  880.  
  881.         /** @dll.import("KERNEL32", auto) */
  882.         public native static boolean MoveFile (String lpExistingFileName, String lpNewFileName);
  883.  
  884.         /** @dll.import("KERNEL32",auto) */
  885.         public native static int MulDiv (int nNumber, int nNumerator, int nDenominator);
  886.  
  887.         /////** @dll.import("KERNEL32", auto) */
  888.         ////public native static int MultiByteToWideChar (int CodePage, int dwFlags, String lpMultiByteStr, int cchMultiByte, StringBuffer lpWideCharStr, int cchWideChar);
  889.  
  890.         /** @dll.import("KERNEL32", auto) */
  891.         public native static int OpenEvent (int dwDesiredAccess, boolean bInheritHandle, String lpName);
  892.  
  893.         /** @dll.import("KERNEL32", ansi) */
  894.         public native static int OpenFile (String lpFileName, OFSTRUCT lpReOpenBuff, int uStyle);
  895.  
  896.         /** @dll.import("KERNEL32", auto) */
  897.         public native static int OpenFileMapping (int dwDesiredAccess, boolean bInheritHandle, String lpName);
  898.  
  899.         /** @dll.import("KERNEL32", auto) */
  900.         public native static int OpenMutex (int dwDesiredAccess, boolean bInheritHandle, String lpName);
  901.  
  902.         /** @dll.import("KERNEL32",auto) */
  903.         public native static int OpenProcess (int dwDesiredAccess, boolean bInheritHandle, int dwProcessId);
  904.  
  905.         /** @dll.import("KERNEL32", auto) */
  906.         public native static int OpenSemaphore (int dwDesiredAccess, boolean bInheritHandle, String lpName);
  907.  
  908.         /** @dll.import("KERNEL32", auto) */
  909.         public native static int OpenWaitableTimer (int dwDesiredAccess, boolean bInheritHandle, String lpTimerName);
  910.  
  911.         /** @dll.import("KERNEL32", auto) */
  912.         public native static void OutputDebugString (String lpOutputString);
  913.  
  914.  
  915.         /** @dll.import("KERNEL32",auto) */
  916.         public native static boolean PeekNamedPipe (int hNamedPipe, Object lpBuffer, int nBufferSize, int[] lpBytesRead, int[] lpTotalBytesAvail, int[] lpBytesLeftThisMessage);
  917.  
  918.         /** @dll.import("KERNEL32",auto) */
  919.         public native static boolean PostQueuedCompletionStatus (int CompletionPort, int dwNumberOfBytesTransferred, int dwCompletionKey, OVERLAPPED lpOverlapped);
  920.  
  921.         /** @dll.import("KERNEL32",auto) */
  922.         public native static int PrepareTape (int hDevice, int dwOperation, boolean bImmediate);
  923.  
  924.         /** @dll.import("KERNEL32",auto) */
  925.         public native static boolean PulseEvent (int hEvent);
  926.  
  927.         /** @dll.import("KERNEL32",auto) */
  928.         public native static boolean PurgeComm (int hFile, int dwFlags);
  929.  
  930.         /** @dll.import("KERNEL32", auto) */
  931.         public native static int QueryDosDevice (String lpDeviceName, Object lpTargetPath, int ucchMax);
  932.  
  933.         /** @dll.import("KERNEL32", auto) */
  934.         public native static boolean QueryPerformanceCounter(long[] lpPerformanceCount);
  935.  
  936.         /** @dll.import("KERNEL32", auto) */
  937.         public native static boolean QueryPerformanceFrequency(long[] lpPerformanceFreq);
  938.  
  939.         /** @dll.import("KERNEL32",auto) */
  940.         public native static int QueueUserAPC (PAPCFUNC pfnAPC, int hThread, int dwData);
  941.  
  942.  
  943.  
  944.         /** @dll.import("KERNEL32",auto, entrypoint="ReadConsoleOutputAttribute") */
  945.         private native static boolean ReadConsoleOutputAttribute_I (int hConsoleOutput, short[] lpAttribute, int nLength, int dwReadCoord, int[] lpNumberOfAttrsRead);
  946.           
  947.         public static boolean ReadConsoleOutputAttribute (int hConsoleOutput, short[] lpAttribute, int nLength, COORD dwReadCoord, int[] lpNumberOfAttrsRead)
  948.         {
  949.            return ReadConsoleOutputAttribute_I (hConsoleOutput, lpAttribute, nLength, expandCoord(dwReadCoord), lpNumberOfAttrsRead);
  950.         }
  951.           
  952.         /** @dll.import("KERNEL32", auto, entrypoint="ReadConsoleOutputCharacter") */
  953.         private native static boolean ReadConsoleOutputCharacter_I (int hConsoleOutput, StringBuffer lpCharacter, int nLength, int dwReadCoord, int[] lpNumberOfCharsRead);
  954.           
  955.         public static boolean ReadConsoleOutputCharacter (int hConsoleOutput, StringBuffer lpCharacter, int nLength, COORD dwReadCoord, int[] lpNumberOfCharsRead)
  956.         {
  957.            return ReadConsoleOutputCharacter_I (hConsoleOutput, lpCharacter, nLength, expandCoord(dwReadCoord), lpNumberOfCharsRead);
  958.         }
  959.  
  960.         /** @dll.import("KERNEL32",auto) */
  961.         public native static boolean ReadConsole (int hConsoleInput, Object lpBuffer, int nNumberOfCharsToRead, int[] lpNumberOfCharsRead, int lpReserved);
  962.  
  963.         /** @dll.import("KERNEL32", unicode) */
  964.         public native static boolean ReadDirectoryChangesW (int hDirectory, Object lpBuffer, int nBufferLength, boolean bWatchSubtree, int dwNotifyFilter, int[] lpBytesReturned, OVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
  965.  
  966.         /** @dll.import("KERNEL32",auto) */
  967.         public native static boolean ReadFile (int hFile, Object lpBuffer, int nNumberOfBytesToRead, int[] lpNumberOfBytesRead, OVERLAPPED lpOverlapped);
  968.  
  969.         /** @dll.import("KERNEL32",auto) */
  970.         public native static boolean ReadFileEx (int hFile, Object lpBuffer, int nNumberOfBytesToRead, OVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
  971.  
  972.         /** @dll.import("KERNEL32",auto) */
  973.         public native static boolean ReadProcessMemory (int hProcess, int lpBaseAddress, Object lpBuffer, int nSize, int[] lpNumberOfBytesRead);
  974.  
  975.         /** @dll.import("KERNEL32",auto) */
  976.         public native static boolean ReleaseMutex (int hMutex);
  977.  
  978.         /** @dll.import("KERNEL32",auto) */
  979.         public native static boolean ReleaseSemaphore (int hSemaphore, int lReleaseCount, int[] lpPreviousCount);
  980.  
  981.         /** @dll.import("KERNEL32", auto) */
  982.         public native static boolean RemoveDirectory (String lpPathName);
  983.  
  984.         /** @dll.import("KERNEL32",auto) */
  985.         public native static boolean ResetEvent (int hEvent);
  986.  
  987.         /** @dll.import("KERNEL32",auto) */
  988.         public native static int ResumeThread (int hThread);
  989.  
  990.  
  991.         /** @dll.import("KERNEL32", auto) */
  992.         public native static int SearchPath (String lpPath, String lpFileName, String lpExtension, int nBufferLength, StringBuffer lpBuffer, int lpFilePart);
  993.  
  994.         /** @dll.import("KERNEL32",auto) */
  995.         public native static boolean SetCommBreak (int hFile);
  996.  
  997.  
  998.  
  999.         /** @dll.import("KERNEL32",auto) */
  1000.         public native static boolean SetCommMask (int hFile, int dwEvtMask);
  1001.  
  1002.         /** @dll.import("KERNEL32",auto) */
  1003.         public native static boolean SetCommState (int hFile, DCB lpDCB);
  1004.  
  1005.         /** @dll.import("KERNEL32",auto) */
  1006.         public native static boolean SetCommTimeouts (int hFile, COMMTIMEOUTS lpCommTimeouts);
  1007.  
  1008.         /** @dll.import("KERNEL32", auto) */
  1009.         public native static boolean SetComputerName (String lpComputerName);
  1010.  
  1011.         /** @dll.import("KERNEL32",auto) */
  1012.         public native static boolean SetConsoleActiveScreenBuffer (int hConsoleOutput);
  1013.  
  1014.         /** @dll.import("KERNEL32",auto) */
  1015.         public native static boolean SetConsoleCP (int wCodePageID);
  1016.  
  1017.         /** @dll.import("KERNEL32",auto) */
  1018.         public native static boolean SetConsoleCtrlHandler (PHANDLER_ROUTINE HandlerRoutine, boolean Add);
  1019.  
  1020.         /** @dll.import("KERNEL32",auto) */
  1021.         public native static boolean SetConsoleCursorInfo (int hConsoleOutput, CONSOLE_CURSOR_INFO lpConsoleCursorInfo);
  1022.  
  1023.         /** @dll.import("KERNEL32",auto, entrypoint="SetConsoleCursorPosition") */
  1024.         private native static boolean SetConsoleCursorPosition_I (int hConsoleOutput, int dwCursorPosition);
  1025.           
  1026.         public static boolean SetConsoleCursorPosition (int hConsoleOutput, COORD dwCursorPosition)
  1027.         {
  1028.            return SetConsoleCursorPosition_I (hConsoleOutput, expandCoord(dwCursorPosition));
  1029.         }
  1030.           
  1031.         /** @dll.import("KERNEL32",auto) */
  1032.         public native static boolean SetConsoleMode (int hConsoleHandle, int dwMode);
  1033.  
  1034.         /** @dll.import("KERNEL32",auto) */
  1035.         public native static boolean SetConsoleOutputCP (int wCodePageID);
  1036.  
  1037.         /** @dll.import("KERNEL32",auto, entrypoint="SetConsoleScreenBufferSize") */
  1038.         private native static boolean SetConsoleScreenBufferSize_I (int hConsoleOutput, int dwSize);
  1039.           
  1040.         public static boolean SetConsoleScreenBufferSize (int hConsoleOutput, COORD dwSize)
  1041.         {
  1042.            return SetConsoleScreenBufferSize_I (hConsoleOutput, expandCoord(dwSize));
  1043.         }
  1044.  
  1045.         /** @dll.import("KERNEL32",auto) */
  1046.         public native static boolean SetConsoleTextAttribute (int hConsoleOutput, short wAttributes);
  1047.  
  1048.         /** @dll.import("KERNEL32", auto) */
  1049.         public native static boolean SetConsoleTitle (String lpConsoleTitle);
  1050.  
  1051.         /** @dll.import("KERNEL32",auto) */
  1052.         public native static boolean SetConsoleWindowInfo (int hConsoleOutput, boolean bAbsolute, SMALL_RECT lpConsoleWindow);
  1053.  
  1054.         /** @dll.import("KERNEL32", auto) */
  1055.         public native static boolean SetCurrentDirectory (String lpPathName);
  1056.  
  1057.  
  1058.  
  1059.         /** @dll.import("KERNEL32",auto) */
  1060.         public native static boolean SetEndOfFile (int hFile);
  1061.  
  1062.         /** @dll.import("KERNEL32", auto) */
  1063.         public native static boolean SetEnvironmentVariable (String lpName, String lpValue);
  1064.  
  1065.         /** @dll.import("KERNEL32",auto) */
  1066.         public native static int SetErrorMode (int uMode);
  1067.  
  1068.         /** @dll.import("KERNEL32",auto) */
  1069.         public native static boolean SetEvent (int hEvent);
  1070.  
  1071.         /** @dll.import("KERNEL32",auto) */
  1072.         public native static void SetFileApisToANSI ();
  1073.  
  1074.         /** @dll.import("KERNEL32",auto) */
  1075.         public native static void SetFileApisToOEM ();
  1076.  
  1077.         /** @dll.import("KERNEL32", auto) */
  1078.         public native static boolean SetFileAttributes (String lpFileName, int dwFileAttributes);
  1079.  
  1080.         /** @dll.import("KERNEL32",auto) */
  1081.         public native static int SetFilePointer (int hFile, int lDistanceToMove, int[] lpDistanceToMoveHigh, int dwMoveMethod);
  1082.  
  1083.         /** @dll.import("KERNEL32",auto) */
  1084.         public native static boolean SetFileTime (int hFile, FILETIME lpCreationTime, FILETIME lpLastAccessTime, FILETIME lpLastWriteTime);
  1085.  
  1086.         /** @dll.import("KERNEL32",auto) */
  1087.         public native static int SetHandleCount (int uNumber);
  1088.  
  1089.         /** @dll.import("KERNEL32",auto) */
  1090.         public native static boolean SetHandleInformation (int hObject, int dwMask, int dwFlags);
  1091.  
  1092.         /** @dll.import("KERNEL32",auto) */
  1093.         public native static void SetLastError (int dwErrCode);
  1094.  
  1095.         /** @dll.import("KERNEL32",auto) */
  1096.         public native static boolean SetLocalTime (SYSTEMTIME lpSystemTime);
  1097.  
  1098.         /** @dll.import("KERNEL32", auto) */
  1099.         public native static boolean SetLocaleInfo (int Locale, int LCType, String lpLCData);
  1100.  
  1101.         /** @dll.import("KERNEL32",auto) */
  1102.         public native static boolean SetMailslotInfo (int hMailslot, int lReadTimeout);
  1103.  
  1104.         /** @dll.import("KERNEL32",auto) */
  1105.         public native static boolean SetNamedPipeHandleState (int hNamedPipe, int[] lpMode, int[] lpMaxCollectionCount, int[] lpCollectDataTimeout);
  1106.  
  1107.         /** @dll.import("KERNEL32",auto) */
  1108.         public native static boolean SetPriorityClass (int hProcess, int dwPriorityClass);
  1109.  
  1110.         /** @dll.import("KERNEL32",auto) */
  1111.         public native static boolean SetProcessAffinityMask (int hProcess, int dwProcessAffinityMask);
  1112.  
  1113.         /** @dll.import("KERNEL32",auto) */
  1114.         public native static boolean SetProcessPriorityBoost (int hProcess, boolean bDisablePriorityBoost);
  1115.  
  1116.         /** @dll.import("KERNEL32",auto) */
  1117.         public native static boolean SetProcessShutdownParameters (int dwLevel, int dwFlags);
  1118.  
  1119.         /** @dll.import("KERNEL32",auto) */
  1120.         public native static boolean SetProcessWorkingSetSize (int hProcess, int dwMinimumWorkingSetSize, int dwMaximumWorkingSetSize);
  1121.  
  1122.         /** @dll.import("KERNEL32",auto) */
  1123.         public native static boolean SetStdHandle (int nStdHandle, int hHandle);
  1124.  
  1125.         /** @dll.import("KERNEL32",auto) */
  1126.         public native static boolean SetSystemPowerState (boolean fSuspend, boolean fForce);
  1127.  
  1128.         /** @dll.import("KERNEL32",auto) */
  1129.         public native static boolean SetSystemTime (SYSTEMTIME lpSystemTime);
  1130.  
  1131.         /** @dll.import("KERNEL32",auto) */
  1132.         public native static boolean SetSystemTimeAdjustment (int dwTimeAdjustment, boolean bTimeAdjustmentDisabled);
  1133.  
  1134.         /** @dll.import("KERNEL32",auto) */
  1135.         public native static int SetTapeParameters (int hDevice, int dwOperation, Object lpTapeInformation);
  1136.  
  1137.         /** @dll.import("KERNEL32",auto) */
  1138.         public native static int SetTapePosition (int hDevice, int dwPositionMethod, int dwPartition, int dwOffsetLow, int dwOffsetHigh, boolean bImmediate);
  1139.  
  1140.         /** @dll.import("KERNEL32",auto) */
  1141.         public native static int SetThreadAffinityMask (int hThread, int dwThreadAffinityMask);
  1142.  
  1143.  
  1144.  
  1145.         /** @dll.import("KERNEL32",auto) */
  1146.         public native static int SetThreadIdealProcessor (int hThread, int dwIdealProcessor);
  1147.  
  1148.         /** @dll.import("KERNEL32",auto) */
  1149.         public native static boolean SetThreadLocale (int Locale);
  1150.  
  1151.         /** @dll.import("KERNEL32",auto) */
  1152.         public native static boolean SetThreadPriority (int hThread, int nPriority);
  1153.  
  1154.         /** @dll.import("KERNEL32",auto) */
  1155.         public native static boolean SetThreadPriorityBoost (int hThread, boolean bDisablePriorityBoost);
  1156.  
  1157.         /** @dll.import("KERNEL32",auto) */
  1158.         public native static boolean SetTimeZoneInformation (TIME_ZONE_INFORMATION lpTimeZoneInformation);
  1159.  
  1160.  
  1161.         /** @dll.import("KERNEL32", auto) */
  1162.         public native static boolean SetVolumeLabel (String lpRootPathName, String lpVolumeName);
  1163.  
  1164.         /** @dll.import("KERNEL32", auto) */
  1165.         public native static boolean SetWaitableTimer(int hTimer, long[] pDueTime, int lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, int pArgToCompletionRoutine, boolean fResume);
  1166.  
  1167.         /** @dll.import("KERNEL32",auto) */
  1168.         public native static boolean SetupComm (int hFile, int dwInQueue, int dwOutQueue);
  1169.  
  1170.         /** @dll.import("KERNEL32",auto) */
  1171.         public native static int SignalObjectAndWait (int hObjectToSignal, int hObjectToWaitOn, int dwMilliseconds, boolean bAlertable);
  1172.  
  1173.         /** @dll.import("KERNEL32",auto) */
  1174.         public native static int SizeofResource (int hModule, int hResInfo);
  1175.  
  1176.         /** @dll.import("KERNEL32",auto) */
  1177.         public native static void Sleep (int dwMilliseconds);
  1178.  
  1179.         /** @dll.import("KERNEL32",auto) */
  1180.         public native static int SleepEx (int dwMilliseconds, boolean bAlertable);
  1181.  
  1182.         /** @dll.import("KERNEL32",auto) */
  1183.         public native static int SuspendThread (int hThread);
  1184.  
  1185.         /** @dll.import("KERNEL32",auto) */
  1186.         public native static void SwitchToFiber (int lpFiber);
  1187.  
  1188.         /** @dll.import("KERNEL32",auto) */
  1189.         public native static boolean SwitchToThread ();
  1190.  
  1191.         /** @dll.import("KERNEL32",auto) */
  1192.         public native static boolean SystemTimeToFileTime (SYSTEMTIME lpSystemTime, FILETIME lpFileTime);
  1193.  
  1194.         /** @dll.import("KERNEL32",auto) */
  1195.         public native static boolean SystemTimeToTzSpecificLocalTime (TIME_ZONE_INFORMATION lpTimeZoneInformation, SYSTEMTIME lpUniversalTime, SYSTEMTIME lpLocalTime);
  1196.  
  1197.         /** @dll.import("KERNEL32",auto) */
  1198.         public native static boolean TerminateProcess (int hProcess, int uExitCode);
  1199.  
  1200.         /** @dll.import("KERNEL32",auto) */
  1201.         public native static boolean TerminateThread (int hThread, int dwExitCode);
  1202.  
  1203.         /** @dll.import("KERNEL32",auto) */
  1204.         public native static int TlsAlloc ();
  1205.  
  1206.         /** @dll.import("KERNEL32",auto) */
  1207.         public native static boolean TlsFree (int dwTlsIndex);
  1208.  
  1209.         /** @dll.import("KERNEL32",auto) */
  1210.         public native static int TlsGetValue (int dwTlsIndex);
  1211.  
  1212.         /** @dll.import("KERNEL32",auto) */
  1213.         public native static boolean TlsSetValue (int dwTlsIndex, int lpTlsValue);
  1214.  
  1215.         /** @dll.import("KERNEL32",auto) */
  1216.         public native static boolean TransactNamedPipe (int hNamedPipe, Object lpInBuffer, int nInBufferSize, Object lpOutBuffer, int nOutBufferSize, int[] lpBytesRead, OVERLAPPED lpOverlapped);
  1217.  
  1218.         /** @dll.import("KERNEL32", ansi) */
  1219.         public native static boolean TransmitCommChar (int hFile, char cChar);
  1220.  
  1221.  
  1222.  
  1223.         /** @dll.import("KERNEL32",auto) */
  1224.         public native static boolean UnlockFile (int hFile, int dwFileOffsetLow, int dwFileOffsetHigh, int nNumberOfBytesToUnlockLow, int nNumberOfBytesToUnlockHigh);
  1225.  
  1226.         /** @dll.import("KERNEL32",auto) */
  1227.         public native static boolean UnlockFileEx (int hFile, int dwReserved, int nNumberOfBytesToUnlockLow, int nNumberOfBytesToUnlockHigh, OVERLAPPED lpOverlapped);
  1228.  
  1229.         /** @dll.import("KERNEL32",auto) */
  1230.         public native static boolean UnmapViewOfFile (int lpBaseAddress);
  1231.  
  1232.         /** @dll.import("KERNEL32", auto) */
  1233.         public native static boolean UpdateResource (int hUpdate, String lpType, String lpName, short wLanguage, int lpData, int cbData);
  1234.  
  1235.         /** @dll.import("KERNEL32", auto) */
  1236.         public native static int VerLanguageName (int wLang, StringBuffer szLang, int nSize);
  1237.  
  1238.         /** @dll.import("KERNEL32",auto) */
  1239.         public native static int VirtualAlloc (int lpAddress, int dwSize, int flAllocationType, int flProtect);
  1240.  
  1241.         /** @dll.import("KERNEL32",auto) */
  1242.         public native static int VirtualAllocEx (int hProcess, int lpAddress, int dwSize, int flAllocationType, int flProtect);
  1243.  
  1244.         /** @dll.import("KERNEL32",auto) */
  1245.         public native static boolean VirtualFree (int lpAddress, int dwSize, int dwFreeType);
  1246.  
  1247.         /** @dll.import("KERNEL32",auto) */
  1248.         public native static boolean VirtualFreeEx (int hProcess, int lpAddress, int dwSize, int dwFreeType);
  1249.  
  1250.         /** @dll.import("KERNEL32",auto) */
  1251.         public native static boolean VirtualLock (int lpAddress, int dwSize);
  1252.  
  1253.         /** @dll.import("KERNEL32",auto) */
  1254.         public native static boolean VirtualProtect (int lpAddress, int dwSize, int flNewProtect, int[] lpflOldProtect);
  1255.  
  1256.         /** @dll.import("KERNEL32",auto) */
  1257.         public native static boolean VirtualProtectEx (int hProcess, int lpAddress, int dwSize, int flNewProtect, int[] lpflOldProtect);
  1258.  
  1259.         /** @dll.import("KERNEL32",auto) */
  1260.         public native static int VirtualQuery (int lpAddress, MEMORY_BASIC_INFORMATION lpBuffer, int dwLength);
  1261.  
  1262.         /** @dll.import("KERNEL32",auto) */
  1263.         public native static int VirtualQueryEx (int hProcess, int lpAddress, MEMORY_BASIC_INFORMATION lpBuffer, int dwLength);
  1264.  
  1265.         /** @dll.import("KERNEL32",auto) */
  1266.         public native static boolean VirtualUnlock (int lpAddress, int dwSize);
  1267.  
  1268.         /** @dll.import("KERNEL32",auto) */
  1269.         public native static boolean WaitCommEvent (int hFile, int[] lpEvtMask, OVERLAPPED lpOverlapped);
  1270.  
  1271.  
  1272.  
  1273.         /** @dll.import("KERNEL32",auto) */
  1274.         public native static int WaitForMultipleObjects (int nCount, int[] lpHandles, boolean bWaitAll, int dwMilliseconds);
  1275.  
  1276.         /** @dll.import("KERNEL32",auto) */
  1277.         public native static int WaitForMultipleObjectsEx (int nCount, int[] lpHandles, boolean bWaitAll, int dwMilliseconds, boolean bAlertable);
  1278.  
  1279.         /** @dll.import("KERNEL32",auto) */
  1280.         public native static int WaitForSingleObject (int hHandle, int dwMilliseconds);
  1281.  
  1282.         /** @dll.import("KERNEL32",auto) */
  1283.         public native static int WaitForSingleObjectEx (int hHandle, int dwMilliseconds, boolean bAlertable);
  1284.  
  1285.         /** @dll.import("KERNEL32", auto) */
  1286.         public native static boolean WaitNamedPipe (String lpNamedPipeName, int nTimeOut);
  1287.  
  1288. ////        /** @dll.import("KERNEL32", ansi) */
  1289. ////        public native static int WideCharToMultiByte (int CodePage, int dwFlags, String lpWideCharStr, int cchWideChar, StringBuffer lpMultiByteStr, int cchMultiByte, String lpDefaultChar, boolean[] lpUsedDefaultChar);
  1290.  
  1291.           /** @dll.import("KERNEL32", ansi) */
  1292.           public native static int WinExec (String lpCmdLine, int uCmdShow);
  1293.  
  1294.  
  1295.         /** @dll.import("KERNEL32",auto, entrypoint="WriteConsoleOutputAttribute") */
  1296.         private native static boolean WriteConsoleOutputAttribute_I (int hConsoleOutput, short[] lpAttribute, int nLength, int dwWriteCoord, int[] lpNumberOfAttrsWritten);
  1297.  
  1298.         public static boolean WriteConsoleOutputAttribute (int hConsoleOutput, short[] lpAttribute, int nLength, COORD dwWriteCoord, int[] lpNumberOfAttrsWritten)
  1299.         {
  1300.            return WriteConsoleOutputAttribute_I (hConsoleOutput, lpAttribute, nLength, expandCoord(dwWriteCoord), lpNumberOfAttrsWritten);
  1301.         }
  1302.  
  1303.         /** @dll.import("KERNEL32", auto, entrypoint="WriteConsoleOutputCharacter") */
  1304.         private native static boolean WriteConsoleOutputCharacter_I (int hConsoleOutput, String lpCharacter, int nLength, int dwWriteCoord, int[] lpNumberOfCharsWritten);
  1305.           
  1306.         public static boolean WriteConsoleOutputCharacter (int hConsoleOutput, String lpCharacter, int nLength, COORD dwWriteCoord, int[] lpNumberOfCharsWritten)
  1307.         {
  1308.            return WriteConsoleOutputCharacter_I (hConsoleOutput, lpCharacter, nLength, expandCoord(dwWriteCoord), lpNumberOfCharsWritten);
  1309.         }
  1310.           
  1311.         /** @dll.import("KERNEL32",auto) */
  1312.         public native static boolean WriteConsole (int hConsoleOutput, char[] lpBuffer, int nNumberOfCharsToWrite, int[] lpNumberOfCharsWritten, int lpReserved);
  1313.  
  1314.         /** @dll.import("KERNEL32",auto) */
  1315.         public native static boolean WriteFile (int hFile, Object lpBuffer, int nNumberOfBytesToWrite, int[] lpNumberOfBytesWritten, OVERLAPPED lpOverlapped);
  1316.  
  1317.         /** @dll.import("KERNEL32",auto) */
  1318.         public native static boolean WriteFileEx (int hFile, Object lpBuffer, int nNumberOfBytesToWrite, OVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
  1319.  
  1320.         /** @dll.import("KERNEL32", auto) */
  1321.         public native static boolean WritePrivateProfileSection (String lpAppName, String lpString, String lpFileName);
  1322.  
  1323.         /** @dll.import("KERNEL32", auto) */
  1324.         public native static boolean WritePrivateProfileString (String lpAppName, String lpKeyName, String lpString, String lpFileName);
  1325.  
  1326.         /** @dll.import("KERNEL32", auto) */
  1327.         public native static boolean WritePrivateProfileStruct (String lpszSection, String lpszKey, Object lpStruct, int uSizeStruct, String szFile);
  1328.  
  1329.         /** @dll.import("KERNEL32",auto) */
  1330.         public native static boolean WriteProcessMemory (int hProcess, int lpBaseAddress, Object lpBuffer, int nSize, int[] lpNumberOfBytesWritten);
  1331.  
  1332.         /** @dll.import("KERNEL32", auto) */
  1333.         public native static boolean WriteProfileSection (String lpAppName, String lpString);
  1334.  
  1335.         /** @dll.import("KERNEL32", auto) */
  1336.         public native static boolean WriteProfileString (String lpAppName, String lpKeyName, String lpString);
  1337.  
  1338.         /** @dll.import("KERNEL32",auto) */
  1339.         public native static int WriteTapemark (int hDevice, int dwTapemarkType, int dwTapemarkCount, boolean bImmediate);
  1340.  
  1341.         /** @dll.import("KERNEL32",auto) */
  1342.         public native static int _hread (int hFile, Object lpBuffer, int lBytes);
  1343.  
  1344.         /** @dll.import("KERNEL32", ansi) */
  1345.         public native static int _hwrite (int hFile, Object lpBuffer, int lBytes);
  1346.  
  1347.         /** @dll.import("KERNEL32",auto) */
  1348.         public native static int _lclose (int hFile);
  1349.  
  1350.         /** @dll.import("KERNEL32", ansi) */
  1351.         public native static int _lcreat (String lpPathName, int iAttribute);
  1352.  
  1353.         /** @dll.import("KERNEL32",auto) */
  1354.         public native static int _llseek (int hFile, int lOffset, int iOrigin);
  1355.  
  1356.         /** @dll.import("KERNEL32", ansi) */
  1357.         public native static int _lopen (String lpPathName, int iReadWrite);
  1358.  
  1359.         /** @dll.import("KERNEL32",auto) */
  1360.         public native static int _lread (int hFile, int lpBuffer, int uBytes);
  1361.  
  1362.         /** @dll.import("KERNEL32",auto) */
  1363.         public native static int _lread (int hFile, Object lpBuffer, int uBytes);
  1364.  
  1365.         /** @dll.import("KERNEL32", auto) */
  1366.         public native static int _lwrite (int hFile, int lpBuffer, int uBytes);
  1367.  
  1368.         /** @dll.import("KERNEL32", auto) */
  1369.         public native static int _lwrite (int hFile, Object lpBuffer, int uBytes);
  1370.  
  1371.         /** @dll.import("KERNEL32", auto) */
  1372.         public native static int lstrcat (StringBuffer lpString1, String lpString2);
  1373.  
  1374.         /** @dll.import("KERNEL32", auto) */
  1375.         public native static int lstrcmp (String lpString1, String lpString2);
  1376.  
  1377.         /** @dll.import("KERNEL32", auto) */
  1378.         public native static int lstrcmpi (String lpString1, String lpString2);
  1379.  
  1380.         /** @dll.import("KERNEL32", auto) */
  1381.         public native static int lstrcpy (StringBuffer lpString1, String lpString2);
  1382.  
  1383.         /** @dll.import("KERNEL32", auto) */
  1384.         public native static int lstrcpyn (StringBuffer lpString1, String lpString2, int iMaxLength);
  1385.  
  1386.         /** @dll.import("KERNEL32", auto) */
  1387.         public native static int lstrlen (String lpString);
  1388.  
  1389.  
  1390. }
  1391.