wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
0187ad47ed
gecko/build/wince/shunt/win32.cpp

1225 lines
32 KiB
C++
Executable File
Raw Blame History

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code, released
* Jan 28, 20.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 2003
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Garrett Arch Bly the, 28-January-2003
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "mozce_internal.h"
#include <mstask.h>
#include "map.h"
extern "C" {
#if 0
}
#endif
#include "kfuncs.h"
#include "wingdi.h"
#include "Windows.h"
#include "locale.h"
#include <winbase.h>
#define MOZCE_NOT_IMPLEMENTED(fname) \
SetLastError(0); \
mozce_printf("-- %s called\n", fname); \
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); \
return 0;
#define MOZCE_NOT_IMPLEMENTED_RV(fname, rv) \
SetLastError(0); \
mozce_printf("-- %s called\n", fname); \
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); \
return rv;
#define wcharcount(array) (sizeof(array) / sizeof(TCHAR))
static int memory_checkpoint_count = 0;
MOZCE_SHUNT_API void mozce_MemoryCheckpoint()
{
#ifdef API_LOGGING
#ifdef WINCE_MEMORY_CHECKPOINTING
MEMORYSTATUS memInfo;
STORE_INFORMATION si;
// Program memory.
memInfo.dwLength = sizeof(memInfo);
GlobalMemoryStatus(&memInfo);
GetStoreInformation(&si);
// OUTPUT: MEM_CHECKPOINT_STRING, counter, Storage Memory Free, RAM TOTAL, RAM FREE, RAM USED
// Can then grep for "MEM, ", put all those lines into one file,
// save the file, and use the resulting text file as
// comma-delimited-text-file input into excel.
// -- wolfe@lobo.us
if (memory_checkpoint_count == 0)
mozce_printf("MEM, counter, Storage Memory Free, RAM TOTAL, RAM FREE, RAM USED\n");
mozce_printf("MEM, %d, %d, %d, %d, %d\n", memory_checkpoint_count, si.dwFreeSize, memInfo.dwTotalPhys, memInfo.dwAvailPhys, memInfo.dwTotalPhys - memInfo.dwAvailPhys);
memory_checkpoint_count++;
#endif
#endif
}
/*this is defined in the WM6 header commdlg.h, but the sdk is missing commdlg.lib*/
MOZCE_SHUNT_API DWORD CommDlgExtendedError()
{
WINCE_LOG_API_CALL("CommDlgExtendedError called\n");
return -1 /*CDERR_DIALOGFAILURE*/;
}
MOZCE_SHUNT_API HBITMAP CreateDIBitmap(HDC inDC, CONST BITMAPINFOHEADER *inBMIH, DWORD inInit, CONST VOID *inBInit, CONST BITMAPINFO *inBMI, UINT inUsage)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API int SetPolyFillMode(HDC inDC, int inPolyFillMode)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API int SetArcDirection(HDC inDC, int inArcDirection)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL Arc(HDC inDC, int inLeftRect, int inTopRect, int inRightRect, int inBottomRect, int inXStartArc, int inYStartArc, int inXEndArc, int inYEndArc)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL Pie(HDC inDC, int inLeftRect, int inTopRect, int inRightRect, int inBottomRect, int inXRadial1, int inYRadial1, int inXRadial2, int inYRadial2)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL LPtoDP(HDC inDC, LPPOINT inoutPoints, int inCount)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL LineDDA(int inXStart, int inYStart, int inXEnd, int inYEnd, LINEDDAPROC inLineFunc, LPARAM inData)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API int ExtSelectClipRgn(HDC inDC, HRGN inRGN, int inMode)
{
WINCE_LOG_API_CALL("ExtSelectClipRgn called\n");
// inModes are defined as:
// RGN_AND = 1
// RGN_OR = 2
// RGN_XOR = 3
// RGN_DIFF = 4
// RGN_COPY = 5
if (inMode == RGN_COPY)
{
return SelectClipRgn(inDC, inRGN);
}
HRGN cRGN = NULL;
int result = GetClipRgn(inDC, cRGN);
// if there is no current clipping region, set it to the
// tightest bounding rectangle that can be drawn around
// the current visible area on the device
if (result != 1)
{
RECT cRect;
GetClipBox(inDC,&cRect);
cRGN = CreateRectRgn(cRect.left,cRect.top,cRect.right,cRect.bottom);
}
// now select the proper region as the current clipping region
result = SelectClipRgn(inDC,cRGN);
if (result == NULLREGION)
{
if (inMode == RGN_DIFF || inMode == RGN_AND)
result = SelectClipRgn(inDC,NULL);
else
result = SelectClipRgn(inDC,inRGN);
DeleteObject(cRGN);
return result;
}
if (result == SIMPLEREGION || result == COMPLEXREGION)
{
if (inMode == RGN_DIFF)
CombineRgn(cRGN, cRGN, inRGN, inMode);
else
CombineRgn(cRGN, inRGN, cRGN, inMode);
result = SelectClipRgn(inDC,cRGN);
DeleteObject(cRGN);
return result;
}
HRGN rgn = CreateRectRgn(0, 0, 32000, 32000);
result = SelectClipRgn(inDC, rgn);
DeleteObject(rgn);
return result;
}
MOZCE_SHUNT_API int FrameRect(HDC inDC, CONST RECT *inRect, HBRUSH inBrush)
{
WINCE_LOG_API_CALL("FrameRect called\n");
HBRUSH oldBrush = (HBRUSH)SelectObject(inDC, inBrush);
RECT myRect = *inRect;
InflateRect(&myRect, 1, 1); // The width and height of
// the border are always one
// logical unit.
// 1 ----> 2
//
// |
// v
//
// 4 ----> 3
MoveToEx(inDC, myRect.left, myRect.top, (LPPOINT) NULL);
// 1 -> 2
LineTo(inDC, myRect.right, myRect.top);
// 2 -> 3
LineTo(inDC, myRect.right, myRect.bottom);
// 3 -> 4
LineTo(inDC, myRect.left, myRect.bottom);
SelectObject(inDC, oldBrush);
return 1;
}
MOZCE_SHUNT_API UINT GetTextCharset(HDC inDC)
{
WINCE_LOG_API_CALL("GetTextCharset called\n");
UINT retval = DEFAULT_CHARSET;
TEXTMETRIC tm;
if(GetTextMetrics(inDC, &tm))
{
retval = tm.tmCharSet;
}
return retval;
}
MOZCE_SHUNT_API UINT GetTextCharsetInfo(HDC inDC, LPFONTSIGNATURE outSig, DWORD inFlags)
{
WINCE_LOG_API_CALL("GetTextCharsetInfo called\n");
// Zero out the FONTSIGNATURE as we do not know how to fill it out properly.
if(NULL != outSig)
{
memset(outSig, 0, sizeof(FONTSIGNATURE));
}
return GetTextCharset(inDC);
}
#define FACENAME_MAX 128
typedef struct __struct_CollectFaces
{
UINT mCount;
LPTSTR mNames[FACENAME_MAX];
}
CollectFaces;
static int CALLBACK collectProc(CONST LOGFONT* inLF, CONST TEXTMETRIC* inTM, DWORD inFontType, LPARAM inParam)
{
int retval = 0;
CollectFaces* collection = (CollectFaces*)inParam;
if(FACENAME_MAX > collection->mCount)
{
retval = 1;
collection->mNames[collection->mCount] = _tcsdup(inLF->lfFaceName);
if(NULL != collection->mNames[collection->mCount])
{
collection->mCount++;
}
}
return retval;
}
MOZCE_SHUNT_API int GetMapMode(HDC inDC)
{
WINCE_LOG_API_CALL("GetMapMode called\n");
int retval = MM_TEXT;
return retval;
}
MOZCE_SHUNT_API LONG RegCreateKey(HKEY inKey, LPCTSTR inSubKey, PHKEY outResult)
{
WINCE_LOG_API_CALL("RegCreateKey called\n");
LONG retval = ERROR_SUCCESS;
DWORD disp = 0;
retval = RegCreateKeyEx(inKey, inSubKey, 0, NULL, 0, 0, NULL, outResult, &disp);
return retval;
}
MOZCE_SHUNT_API BOOL WaitMessage(VOID)
{
WINCE_LOG_API_CALL("WaitMessage called\n");
BOOL retval = TRUE;
HANDLE hThread = GetCurrentThread();
DWORD waitRes = MsgWaitForMultipleObjectsEx(1, &hThread, INFINITE, QS_ALLEVENTS, 0);
if((DWORD)-1 == waitRes)
{
retval = FALSE;
}
return retval;
}
MOZCE_SHUNT_API BOOL FlashWindow(HWND inWnd, BOOL inInvert)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, FALSE);
}
typedef struct ECWWindows
{
LPARAM params;
WNDENUMPROC func;
HWND parent;
} ECWWindows;
static BOOL CALLBACK MyEnumWindowsProc(HWND hwnd, LPARAM lParam)
{
ECWWindows *myParams = (ECWWindows*) lParam;
if (IsChild(myParams->parent, hwnd))
{
return myParams->func(hwnd, myParams->params);
}
return TRUE;
}
MOZCE_SHUNT_API BOOL EnumChildWindows(HWND inParent, WNDENUMPROC inFunc, LPARAM inParam)
{
WINCE_LOG_API_CALL("EnumChildWindows called\n");
ECWWindows myParams;
myParams.params = inParam;
myParams.func = inFunc;
myParams.parent = inParent;
return EnumWindows(MyEnumWindowsProc, (LPARAM) &myParams);
}
MOZCE_SHUNT_API BOOL EnumThreadWindows(DWORD inThreadID, WNDENUMPROC inFunc, LPARAM inParam)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, FALSE);
}
MOZCE_SHUNT_API BOOL IsIconic(HWND inWnd)
{
return false;
}
MOZCE_SHUNT_API BOOL OpenIcon(HWND inWnd)
{
WINCE_LOG_API_CALL("OpenIcon called\n");
return SetActiveWindow(inWnd) ? 1:0;
}
MOZCE_SHUNT_API HHOOK SetWindowsHookEx(int inType, void* inFunc, HINSTANCE inMod, DWORD inThreadId)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, NULL);
}
MOZCE_SHUNT_API BOOL UnhookWindowsHookEx(HHOOK inHook)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, FALSE);
}
MOZCE_SHUNT_API LRESULT CallNextHookEx(HHOOK inHook, int inCode, WPARAM wParam, LPARAM lParam)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, NULL);
}
MOZCE_SHUNT_API BOOL InvertRgn(HDC inDC, HRGN inRGN)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, FALSE);
}
MOZCE_SHUNT_API int GetScrollPos(HWND inWnd, int inBar)
{
WINCE_LOG_API_CALL("GetScrollPos called\n");
int retval = 0;
SCROLLINFO info;
if(GetScrollInfo(inWnd, inBar, &info))
{
return info.nPos;
}
return retval;
}
MOZCE_SHUNT_API BOOL GetScrollRange(HWND inWnd, int inBar, LPINT outMinPos, LPINT outMaxPos)
{
WINCE_LOG_API_CALL("GetScrollRange called\n");
BOOL retval = FALSE;
SCROLLINFO info;
if((retval = GetScrollInfo(inWnd, inBar, &info)))
{
if(NULL != outMinPos)
{
*outMinPos = info.nMin;
}
if(NULL != outMaxPos)
{
*outMaxPos = info.nMax;
}
}
return retval;
}
MOZCE_SHUNT_API HRESULT CoLockObjectExternal(IUnknown* inUnk, BOOL inLock, BOOL inLastUnlockReleases)
{
WINCE_LOG_API_CALL("CoLockObjectExternal called\n");
HRESULT retval = S_OK;
if(NULL != inUnk)
{
if(FALSE == inLock)
{
inUnk->Release();
}
else
{
inUnk->AddRef();
}
}
else
{
retval = E_INVALIDARG;
}
return retval;
}
//LPITEMIDLIST
MOZCE_SHUNT_API void* mozce_SHBrowseForFolder(void* /*LPBROWSEINFOS*/ inBI)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API BOOL SetMenu(HWND inWnd, HMENU inMenu)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, FALSE);
}
MOZCE_SHUNT_API BOOL GetUserName(LPTSTR inBuffer, LPDWORD inoutSize)
{
*inoutSize = 0;
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, FALSE);
}
MOZCE_SHUNT_API DWORD GetShortPathName(LPCSTR inLongPath, LPSTR outShortPath, DWORD inBufferSize)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API DWORD GetShortPathNameW(LPCWSTR inLongPath, LPWSTR outShortPath, DWORD inBufferSize)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API DWORD GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize)
{
char key[256];
int rv =WideCharToMultiByte( CP_ACP, 0, lpName, -1, key, 256, NULL, NULL );
if(rv<0){
return rv;
}
char* val = map_get(key);
if(val){
MultiByteToWideChar( CP_ACP, 0, val, strlen(val)+1, lpBuffer,
nSize );
return ERROR_SUCCESS ;
}else{
return ERROR_ENVVAR_NOT_FOUND;
}
}
MOZCE_SHUNT_API DWORD GetEnvironmentVariable(LPCWSTR lpName, LPCSTR lpBuffer, DWORD nSize)
{
#ifdef UNICODE
return GetEnvironmentVariableW((LPCWSTR)lpName,(LPWSTR)lpBuffer,nSize);
#else
return get(lpName,lpBuffer);
#endif
}
MOZCE_SHUNT_API void GetSystemTimeAsFileTime(LPFILETIME lpSystemTimeAsFileTime)
{
WINCE_LOG_API_CALL("GetSystemTimeAsFileTime called\n");
SYSTEMTIME st;
GetSystemTime(&st);
SystemTimeToFileTime(&st,lpSystemTimeAsFileTime);
}
MOZCE_SHUNT_API DWORD GetLongPathNameW(LPCWSTR lpszShortPath, LPCWSTR lpszLongPath, DWORD cchBuffer)
{
WINCE_LOG_API_CALL("GetLongPathNameW called\n");
return 0;
}
MOZCE_SHUNT_API DWORD GetFullPathName(const char* lpFileName,
DWORD nBufferLength,
const char* lpBuffer,
const char** lpFilePart)
{
WINCE_LOG_API_CALL("GetFullPathName called\n");
DWORD len = strlen(lpFileName);
if (len > nBufferLength)
return len;
strncpy((char*)lpBuffer, lpFileName, len);
((char*)lpBuffer)[len] = '\0';
if(lpFilePart)
{
char* sep = strrchr(lpBuffer, '\\');
if (sep) {
sep++; // pass the seperator
*lpFilePart = sep;
}
else
*lpFilePart = lpBuffer;
}
WINCE_LOG_API_CALL_2("GetFullPathName called %s (%s)\n", lpBuffer, *lpFilePart);
return len;
}
static LONG gGetMessageTime = 0;
MOZCE_SHUNT_API BOOL mozce_GetMessage(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax )
{
SetLastError(0);
WINCE_LOG_API_CALL("mozce_GetMessage called\n");
BOOL b = GetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMin);
if (b)
gGetMessageTime = lpMsg->time;
return b;
}
MOZCE_SHUNT_API BOOL mozce_PeekMessage(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg)
{
SetLastError(0);
WINCE_LOG_API_CALL("mozce_PeekMessageA called\n");
BOOL b = PeekMessageW(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
if (b && wRemoveMsg == PM_REMOVE)
gGetMessageTime = lpMsg->time;
return b;
}
MOZCE_SHUNT_API LONG GetMessageTime(void)
{
SetLastError(0);
WINCE_LOG_API_CALL("GetMessageTime called\n");
return gGetMessageTime;
}
MOZCE_SHUNT_API DWORD ExpandEnvironmentStrings(LPCTSTR lpSrc, LPTSTR lpDst, DWORD nSize)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API DWORD ExpandEnvironmentStringsW(const unsigned short* lpSrc, const unsigned short* lpDst, DWORD nSize)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API BOOL GdiFlush(void)
{
return TRUE;
}
MOZCE_SHUNT_API BOOL GetWindowPlacement(HWND hWnd, WINDOWPLACEMENT *lpwndpl)
{
SetLastError(0);
WINCE_LOG_API_CALL("GetWindowPlacement called\n");
memset(lpwndpl, 0, sizeof(WINDOWPLACEMENT));
// This is wrong when the window is minimized.
lpwndpl->showCmd = SW_SHOWNORMAL;
GetWindowRect(hWnd, &lpwndpl->rcNormalPosition);
return TRUE;
}
MOZCE_SHUNT_API HINSTANCE ShellExecute(HWND hwnd,
LPCSTR lpOperation,
LPCSTR lpFile,
LPCSTR lpParameters,
LPCSTR lpDirectory,
INT nShowCmd)
{
LPTSTR op = a2w_malloc(lpOperation, -1, NULL);
LPTSTR file = a2w_malloc(lpFile, -1, NULL);
LPTSTR parm = a2w_malloc(lpParameters, -1, NULL);
LPTSTR dir = a2w_malloc(lpDirectory, -1, NULL);
SHELLEXECUTEINFO info;
info.cbSize = sizeof(SHELLEXECUTEINFO);
info.fMask = SEE_MASK_NOCLOSEPROCESS;
info.hwnd = hwnd;
info.lpVerb = op;
info.lpFile = file;
info.lpParameters = parm;
info.lpDirectory = dir;
info.nShow = nShowCmd;
BOOL b = ShellExecuteEx(&info);
if (op)
free(op);
if (file)
free(file);
if (parm)
free(parm);
if (dir)
free(dir);
return (HINSTANCE) info.hProcess;
}
MOZCE_SHUNT_API HINSTANCE ShellExecuteW(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd)
{
SetLastError(0);
WINCE_LOG_API_CALL("ShellExecuteW called\n");
SHELLEXECUTEINFO info;
info.cbSize = sizeof(SHELLEXECUTEINFO);
info.fMask = SEE_MASK_NOCLOSEPROCESS;
info.hwnd = hwnd;
info.lpVerb = lpOperation;
info.lpFile = lpFile;
info.lpParameters = lpParameters;
info.lpDirectory = lpDirectory;
info.nShow = nShowCmd;
BOOL b = ShellExecuteEx(&info);
return (HINSTANCE) info.hProcess;
}
struct lconv s_locale_conv =
{
".", /* decimal_point */
",", /* thousands_sep */
"333", /* grouping */
"$", /* int_curr_symbol */
"$", /* currency_symbol */
"", /* mon_decimal_point */
"", /* mon_thousands_sep */
"", /* mon_grouping */
"+", /* positive_sign */
"-", /* negative_sign */
'2', /* int_frac_digits */
'2', /* frac_digits */
1, /* p_cs_precedes */
1, /* p_sep_by_space */
1, /* n_cs_precedes */
1, /* n_sep_by_space */
1, /* p_sign_posn */
1, /* n_sign_posn */
};
MOZCE_SHUNT_API struct lconv * mozce_localeconv(void)
{
WINCE_LOG_API_CALL("mozce_localeconv called\n");
return &s_locale_conv;
}
MOZCE_SHUNT_API BOOL CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, FALSE);
}
MOZCE_SHUNT_API DWORD_PTR SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffinityMask)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API BOOL GetProcessAffinityMask(HANDLE hProcess, PDWORD_PTR lpProcessAffinityMask, PDWORD_PTR lpSystemAffinityMask)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, FALSE);
}
MOZCE_SHUNT_API HANDLE OpenFileMapping(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCTSTR lpName)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API UINT GetDriveType(const char* lpRootPathName)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API BOOL SetHandleInformation(HANDLE hObject, DWORD dwMask, DWORD dwFlags)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API BOOL GetHandleInformation(HANDLE hObject, LPDWORD lpdwFlags)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API BOOL LockFile(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh)
{
OVERLAPPED over = {0};
over.Offset = dwFileOffsetLow;
over.OffsetHigh = dwFileOffsetHigh;
return ::LockFileEx(hFile, 0, 0, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, &over);
}
MOZCE_SHUNT_API BOOL UnlockFile(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh)
{
OVERLAPPED over = {0};
over.Offset = dwFileOffsetLow;
over.OffsetHigh = dwFileOffsetHigh;
return ::UnlockFileEx(hFile, 0, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, &over);
}
MOZCE_SHUNT_API BOOL GetDiskFreeSpaceA(LPCTSTR lpRootPathName, LPDWORD lpSectorsPerCluster,
LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, 0);
}
MOZCE_SHUNT_API BOOL SetWorldTransform(HDC hdc, CONST XFORM *lpXform )
{
return 1;
}
MOZCE_SHUNT_API BOOL GetWorldTransform(HDC hdc, LPXFORM lpXform )
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API int SetGraphicsMode(HDC hdc, int iMode)
{
return 1;
}
MOZCE_SHUNT_API int GetGraphicsMode(HDC hdc)
{
return 1; /*GM_COMPATIBLE*/
}
MOZCE_SHUNT_API HRESULT ScriptFreeCache(SCRIPT_CACHE* psc )
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API DWORD WINAPI GetGlyphIndicesA( HDC hdc,LPCSTR lpstr, int c, LPWORD pgi, DWORD fl)
{
memcpy(pgi,lpstr,c);
return c;
}
MOZCE_SHUNT_API DWORD WINAPI GetGlyphIndicesW( HDC hdc, LPCWSTR lpstr, int c, LPWORD pgi, DWORD fl)
{
for (int i = 0; i < c; i++)
{
char asciiChar = (char) lpstr[i];
pgi[i] = asciiChar;
}
return c;
}
MOZCE_SHUNT_API DWORD GetFontUnicodeRanges(HDC hdc, GLYPHSET *lpgs)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, ERROR_CALL_NOT_IMPLEMENTED);
}
MOZCE_SHUNT_API HRESULT WINAPI ScriptIsComplex(const WCHAR *pwcInChars, int cInChars, DWORD dwFlags)
{
MOZCE_NOT_IMPLEMENTED_RV(__FUNCTION__, ERROR_CALL_NOT_IMPLEMENTED);
}
MOZCE_SHUNT_API BOOL GetTextExtentExPointI( HDC hdc, LPWORD pgiIn, int cgi,int nMaxExtent, LPINT lpnFit, LPINT alpDx, LPSIZE lpSize)
{
return GetTextExtentExPoint(hdc, pgiIn, cgi, nMaxExtent, lpnFit, alpDx, lpSize);
}
MOZCE_SHUNT_API HRESULT WINAPI ScriptGetProperties( const SCRIPT_PROPERTIES ***ppSp, int *piNumScripts)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API HRESULT WINAPI ScriptGetFontProperties(HDC hdc, SCRIPT_CACHE *psc, SCRIPT_FONTPROPERTIES *sfp )
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API HRESULT WINAPI ScriptBreak( const WCHAR *pwcChars, int cChars, const SCRIPT_ANALYSIS *psa, SCRIPT_LOGATTR *psla )
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API HRESULT WINAPI ScriptItemize(const WCHAR *pwcInChars, int cInChars, int cMaxItems, const SCRIPT_CONTROL *psControl,
const SCRIPT_STATE *psState, SCRIPT_ITEM *pItems, int *pcItems )
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL WINAPI GetICMProfile(HDC hDC, LPDWORD lpcbName,LPWSTR lpszFilename)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API DWORD WINAPI GetGuiResources(HANDLE hProcess,DWORD uiFlags)
{
return 1;
}
MOZCE_SHUNT_API BOOL UpdateLayeredWindow(HWND hWnd, HDC hdcDst, POINT *pptDst,
SIZE *psize, HDC hdcSrc, POINT *pptSrc,
COLORREF crKey, BLENDFUNCTION *pblend,
DWORD dwFlags)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API HRESULT WINAPI ScriptRecordDigitSubstitution(LCID Locale, SCRIPT_DIGITSUBSTITUTE *psds)
{
psds->DigitSubstitute =1;
psds->dwReserved =0;
psds->NationalDigitLanguage =9;
psds->TraditionalDigitLanguage =9;
return S_OK;
}
MOZCE_SHUNT_API HWND WINAPI GetTopWindow(HWND hWnd)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL
WINAPI
InitializeCriticalSectionAndSpinCount(
__out LPCRITICAL_SECTION InitializeCriticalSection,
__in DWORD dwSpinCount
)
{
::InitializeCriticalSection(InitializeCriticalSection);
return TRUE;
}
MOZCE_SHUNT_API
DWORD
WINAPI
SetCriticalSectionSpinCount(
__inout LPCRITICAL_SECTION lpCriticalSection,
__in DWORD dwSpinCount
)
{
return 0;
}
MOZCE_SHUNT_API
BOOL
WINAPI
GetSystemTimeAdjustment(
__out PDWORD lpTimeAdjustment,
__out PDWORD lpTimeIncrement,
__out PBOOL lpTimeAdjustmentDisabled
)
{
*lpTimeAdjustmentDisabled = TRUE;
return TRUE;
}
MOZCE_SHUNT_API BOOL WINAPI PolyBezierTo(__in HDC hdc, __in_ecount(cpt) CONST POINT * apt, __in DWORD cpt){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__); }
MOZCE_SHUNT_API BOOL WINAPI CloseFigure(__in HDC hdc){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL WINAPI SelectClipPath(__in HDC hdc, __in int mode){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL WINAPI EndPath(__in HDC hdc){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL WINAPI BeginPath(__in HDC hdc){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL WINAPI ModifyWorldTransform( __in HDC hdc, __in_opt CONST XFORM * lpxf, __in DWORD mode){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL WINAPI WidenPath(__in HDC hdc){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL WINAPI StrokePath(__in HDC hdc){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API HPEN WINAPI ExtCreatePen( __in DWORD iPenStyle,
__in DWORD cWidth,
__in CONST LOGBRUSH *plbrush,
__in DWORD cStyle,
__in_ecount_opt(cStyle) CONST DWORD *pstyle){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL WINAPI SetMiterLimit(__in HDC hdc, __in FLOAT limit, __out_opt PFLOAT old){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL WINAPI FillPath(__in HDC hdc){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API BOOL WINAPI GetICMProfileW( __in HDC hdc,
__inout LPDWORD pBufSize,
__out_ecount_opt(*pBufSize) LPWSTR pszFilename)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
HRESULT WINAPI ScriptShape(
HDC hdc, // In Optional (see under caching)
SCRIPT_CACHE *psc, // InOut Cache handle
const WCHAR *pwcChars, // In Logical unicode run
int cChars, // In Length of unicode run
int cMaxGlyphs, // In Max glyphs to generate
SCRIPT_ANALYSIS *psa, // InOut Result of ScriptItemize (may have fNoGlyphIndex set)
WORD *pwOutGlyphs, // Out Output glyph buffer
WORD *pwLogClust, // Out Logical clusters
SCRIPT_VISATTR *psva, // Out Visual glyph attributes
int *pcGlyphs){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
// Out Count of glyphs generated
HRESULT WINAPI ScriptPlace(
HDC hdc, // In Optional (see under caching)
SCRIPT_CACHE *psc, // InOut Cache handle
const WORD *pwGlyphs, // In Glyph buffer from prior ScriptShape call
int cGlyphs, // In Number of glyphs
const SCRIPT_VISATTR *psva, // In Visual glyph attributes
SCRIPT_ANALYSIS *psa, // InOut Result of ScriptItemize (may have fNoGlyphIndex set)
int *piAdvance, // Out Advance wdiths
GOFFSET *pGoffset, // Out x,y offset for combining glyph
ABC *pABC){
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
// Out Composite ABC for the whole run (Optional)
MOZCE_SHUNT_API int WINAPI SetMapMode(HDC, int)
{
// We only support one Map Mode.
return 1;
}
MOZCE_SHUNT_API DWORD WINAPI GetCharacterPlacementW( __in HDC hdc, __in_ecount(nCount) LPCWSTR lpString, __in int nCount, __in int nMexExtent, __inout LPGCP_RESULTSW lpResults, __in DWORD dwFlags)
{
MOZCE_NOT_IMPLEMENTED(__FUNCTION__);
}
MOZCE_SHUNT_API wchar_t* wgetcwd(wchar_t* dir, size_t size)
{
WINCE_LOG_API_CALL("getcwd called.\n");
int i;
GetModuleFileName(GetModuleHandle (NULL), dir, MAX_PATH);
for (i = _tcslen(dir); i && dir[i] != TEXT('\\'); i--) {}
dir[i + 1] = TCHAR('\0');
return dir;
}
MOZCE_SHUNT_API wchar_t *_wgetcwd(wchar_t *buffer, int maxlen)
{
return wgetcwd(buffer, maxlen);
}
MOZCE_SHUNT_API int _wrmdir(const wchar_t * _Path)
{
return ::RemoveDirectoryW(_Path);
}
MOZCE_SHUNT_API int _wremove(const wchar_t * _Filename)
{
return ::DeleteFileW(_Filename);
}
MOZCE_SHUNT_API int wchmod(const wchar_t * buffer, int inMode)
{
WINCE_LOG_API_CALL("wchmod called\n");
int retval = -1;
if(NULL != buffer)
{
DWORD attribs = 0;
attribs = GetFileAttributesW(buffer);
if(0 != attribs)
{
if(0 != (_S_IWRITE & inMode))
{
attribs |= FILE_ATTRIBUTE_READONLY;
}
else
{
attribs &= ~FILE_ATTRIBUTE_READONLY;
}
BOOL setRes = SetFileAttributesW(buffer, attribs);
if(FALSE != setRes)
{
retval = 0;
}
}
}
return retval;
}
MOZCE_SHUNT_API int _wchmod(const wchar_t * _Filename, int _Mode)
{
return wchmod(_Filename, _Mode);
}
MOZCE_SHUNT_API wchar_t *_wfullpath( wchar_t *absPath, const wchar_t *relPath, size_t maxLength )
{
if(absPath ==NULL){
absPath = (wchar_t*)malloc(maxLength*sizeof(wchar_t));
}
wgetcwd( absPath, maxLength);
size_t len = wcslen(absPath);
if(!(absPath[len-1] == TCHAR('/') || absPath[len-1] == TCHAR('\\'))&& len< maxLength){
absPath[len] = TCHAR('\\');
absPath[++len] = TCHAR('\0');
}
if(len+wcslen(relPath) < maxLength){
return wcscat(absPath,relPath);
}
return NULL;
}
// Copied from msaa.h
MOZCE_SHUNT_API HWND GetAncestor(HWND hwnd, UINT gaFlags)
{
HWND hwndParent;
HWND hwndDesktop;
DWORD dwStyle;
// HERE IS THE FAKE IMPLEMENTATION
if (!IsWindow(hwnd))
return(NULL);
hwndDesktop = GetDesktopWindow();
if (hwnd == hwndDesktop)
return(NULL);
dwStyle = GetWindowLong (hwnd,GWL_STYLE);
switch (gaFlags)
{
case GA_PARENT:
if (dwStyle & WS_CHILD)
hwndParent = GetParent(hwnd);
else
hwndParent = GetWindow (hwnd,GW_OWNER);
if (hwndParent == NULL)
hwndParent = hwnd;
break;
case GA_ROOT:
if (dwStyle & WS_CHILD)
hwndParent = GetParent(hwnd);
else
hwndParent = GetWindow (hwnd,GW_OWNER);
while (hwndParent != hwndDesktop &&
hwndParent != NULL)
{
hwnd = hwndParent;
dwStyle = GetWindowLong(hwnd,GWL_STYLE);
if (dwStyle & WS_CHILD)
hwndParent = GetParent(hwnd);
else
hwndParent = GetWindow (hwnd,GW_OWNER);
}
break;
case GA_ROOTOWNER:
while (hwndParent = GetParent(hwnd))
hwnd = hwndParent;
break;
default:
return NULL;
}
return(hwndParent);
}
MOZCE_SHUNT_API BOOL InitializeAcl(PACL apAcl, DWORD len, DWORD rev)
{
return FALSE;
}
MOZCE_SHUNT_API DWORD SetNamedSecurityInfoW(unsigned short* pObjectName,
SE_OBJECT_TYPE ObjectType,
SECURITY_INFORMATION SecurityInfo,
PSID psidOwner,
PSID psidGroup,
PACL pDacl,
PACL pSacl)
{
return 0;
}
MOZCE_SHUNT_API void FatalAppExitW(UINT uAction, LPCWSTR lpMessageText)
{
if ( ::MessageBoxW(NULL, lpMessageText, L"Runtime Error", MB_OKCANCEL | MB_ICONERROR) == IDCANCEL )
return;
exit(-1);
}
MOZCE_SHUNT_API int clock()
{
return -1;
}
MOZCE_SHUNT_API int GetDIBits(HDC hdc, HBITMAP hbmp, UINT uStartScan, UINT cScanLines,
LPVOID lpvBits, LPBITMAPINFO lpbi, UINT uUsage)
{
#if 0
return GetBitmapBits(hbmp,lpbi->bmiHeader.biSize, lpvBits);
#else
return 0;
#endif
}
#if 0
{
#endif
} /* extern "C" */
Reference in New Issue View Git Blame Copy Permalink