/***********************************************************************
* SetDeskWallPaper (USER32.@)
*
* FIXME: is there a unicode version?
*/
BOOL WINAPI SetDeskWallPaper( LPCSTR filename )
{
HBITMAP hbitmap;
HDC hdc;
char buffer[256];
if (filename == (LPSTR)-1)
{
GetProfileStringA( "desktop", "WallPaper", "(None)", buffer, 256 );
filename = buffer;
}
hdc = GetDC( 0 );
hbitmap = DESKTOP_LoadBitmap( hdc, filename );
ReleaseDC( 0, hdc );
if (hbitmapWallPaper) DeleteObject( hbitmapWallPaper );
hbitmapWallPaper = hbitmap;
fTileWallPaper = GetProfileIntA( "desktop", "TileWallPaper", 0 );
if (hbitmap)
{
BITMAP bmp;
GetObjectA( hbitmap, sizeof(bmp), &bmp );
bitmapSize.cx = (bmp.bmWidth != 0) ? bmp.bmWidth : 1;
bitmapSize.cy = (bmp.bmHeight != 0) ? bmp.bmHeight : 1;
}
return TRUE;
}
/***********************************************************************
* init_wallpaper
*/
static void init_wallpaper( const WCHAR *wallpaper )
{
HBITMAP hbitmap = DESKTOP_LoadBitmap( wallpaper );
if (hbitmapWallPaper) DeleteObject( hbitmapWallPaper );
hbitmapWallPaper = hbitmap;
if (hbitmap)
{
BITMAP bmp;
GetObjectA( hbitmap, sizeof(bmp), &bmp );
bitmapSize.cx = (bmp.bmWidth != 0) ? bmp.bmWidth : 1;
bitmapSize.cy = (bmp.bmHeight != 0) ? bmp.bmHeight : 1;
fTileWallPaper = GetProfileIntA( "desktop", "TileWallPaper", 0 );
}
}
/***********************************************************************
* TASK_Create
*
* NOTE: This routine might be called by a Win32 thread. Thus, we need
* to be careful to protect global data structures. We do this
* by entering the Win16Lock while linking the task into the
* global task list.
*/
static TDB *TASK_Create( NE_MODULE *pModule, UINT16 cmdShow, LPCSTR cmdline, BYTE len )
{
HTASK16 hTask;
TDB *pTask;
FARPROC16 proc;
char curdir[MAX_PATH];
HMODULE16 hModule = pModule ? pModule->self : 0;
/* Allocate the task structure */
hTask = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, sizeof(TDB) );
if (!hTask) return NULL;
pTask = TASK_GetPtr( hTask );
FarSetOwner16( hTask, hModule );
/* Fill the task structure */
pTask->hSelf = hTask;
pTask->version = pModule ? pModule->ne_expver : 0x0400;
pTask->hModule = hModule;
pTask->hParent = GetCurrentTask();
pTask->magic = TDB_MAGIC;
pTask->nCmdShow = cmdShow;
GetCurrentDirectoryA( sizeof(curdir), curdir );
GetShortPathNameA( curdir, curdir, sizeof(curdir) );
pTask->curdrive = (curdir[0] - 'A') | 0x80;
lstrcpynA( pTask->curdir, curdir + 2, sizeof(pTask->curdir) );
/* Create the thunks block */
TASK_CreateThunks( hTask, (char *)pTask->thunks - (char *)pTask, 7 );
/* Copy the module name */
if (hModule)
{
char name[sizeof(pTask->module_name)+1];
size_t len;
GetModuleName16( hModule, name, sizeof(name) );
len = strlen(name) + 1;
memcpy(pTask->module_name, name, min(len,sizeof(pTask->module_name)));
pTask->compat_flags = GetProfileIntA( "Compatibility", name, 0 );
}
/* Allocate a selector for the PDB */
pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB16),
hModule, WINE_LDT_FLAGS_DATA );
/* Fill the PDB */
pTask->pdb.int20 = 0x20cd;
pTask->pdb.dispatcher[0] = 0x9a; /* ljmp */
proc = GetProcAddress16( GetModuleHandle16("KERNEL"), "DOS3Call" );
memcpy( &pTask->pdb.dispatcher[1], &proc, sizeof(proc) );
pTask->pdb.savedint22 = 0;
pTask->pdb.savedint23 = 0;
pTask->pdb.savedint24 = 0;
pTask->pdb.fileHandlesPtr =
MAKESEGPTR( GlobalHandleToSel16(pTask->hPDB), FIELD_OFFSET( PDB16, fileHandles ));
pTask->pdb.hFileHandles = 0;
memset( pTask->pdb.fileHandles, 0xff, sizeof(pTask->pdb.fileHandles) );
/* FIXME: should we make a copy of the environment? */
pTask->pdb.environment = SELECTOROF(GetDOSEnvironment16());
pTask->pdb.nbFiles = 20;
/* Fill the command line */
if (!cmdline)
{
cmdline = GetCommandLineA();
/* remove the first word (program name) */
if (*cmdline == '"')
if (!(cmdline = strchr( cmdline+1, '"' ))) cmdline = GetCommandLineA();
while (*cmdline && (*cmdline != ' ') && (*cmdline != '\t')) cmdline++;
while ((*cmdline == ' ') || (*cmdline == '\t')) cmdline++;
len = strlen(cmdline);
}
if (len >= sizeof(pTask->pdb.cmdLine)) len = sizeof(pTask->pdb.cmdLine)-1;
pTask->pdb.cmdLine[0] = len;
memcpy( pTask->pdb.cmdLine + 1, cmdline, len );
/* pTask->pdb.cmdLine[len+1] = 0; */
TRACE("cmdline='%.*s' task=%04x\n", len, cmdline, hTask );
/* Allocate a code segment alias for the TDB */
pTask->hCSAlias = GLOBAL_CreateBlock( GMEM_FIXED, pTask, sizeof(TDB),
pTask->hPDB, WINE_LDT_FLAGS_CODE );
/* Default DTA overwrites command line */
pTask->dta = MAKESEGPTR( pTask->hPDB, FIELD_OFFSET( PDB16, cmdLine ));
/* Create scheduler event for 16-bit tasks */
if ( !(pTask->flags & TDBF_WIN32) )
NtCreateEvent( &pTask->hEvent, EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE );
if (!initial_task) initial_task = hTask;
return pTask;
}
/*****************************************************************
* CreateCaret (USER32.@)
*/
BOOL WINAPI CreateCaret( HWND hwnd, HBITMAP bitmap, INT width, INT height )
{
BOOL ret;
RECT r;
int old_state = 0;
int hidden = 0;
HBITMAP hBmp = 0;
HWND prev = 0;
TRACE("hwnd=%p\n", hwnd);
if (!hwnd) return FALSE;
if (bitmap && (bitmap != (HBITMAP)1))
{
BITMAP bmp;
if (!GetObjectA( bitmap, sizeof(bmp), &bmp )) return FALSE;
width = bmp.bmWidth;
height = bmp.bmHeight;
bmp.bmBits = NULL;
hBmp = CreateBitmapIndirect(&bmp);
if (hBmp)
{
/* copy the bitmap */
LPBYTE buf = HeapAlloc(GetProcessHeap(), 0, bmp.bmWidthBytes * bmp.bmHeight);
GetBitmapBits(bitmap, bmp.bmWidthBytes * bmp.bmHeight, buf);
SetBitmapBits(hBmp, bmp.bmWidthBytes * bmp.bmHeight, buf);
HeapFree(GetProcessHeap(), 0, buf);
}
}
else
{
HDC hdc;
if (!width) width = GetSystemMetrics(SM_CXBORDER);
if (!height) height = GetSystemMetrics(SM_CYBORDER);
/* create the uniform bitmap on the fly */
hdc = GetDC(hwnd);
if (hdc)
{
HDC hMemDC = CreateCompatibleDC(hdc);
if (hMemDC)
{
if ((hBmp = CreateCompatibleBitmap(hMemDC, width, height )))
{
HBITMAP hPrevBmp = SelectObject(hMemDC, hBmp);
SetRect( &r, 0, 0, width, height );
FillRect(hMemDC, &r, ULongToHandle((bitmap ? COLOR_GRAYTEXT : COLOR_WINDOW) + 1));
SelectObject(hMemDC, hPrevBmp);
}
DeleteDC(hMemDC);
}
ReleaseDC(hwnd, hdc);
}
}
if (!hBmp) return FALSE;
SERVER_START_REQ( set_caret_window )
{
req->handle = wine_server_user_handle( hwnd );
req->width = width;
req->height = height;
if ((ret = !wine_server_call_err( req )))
{
prev = wine_server_ptr_handle( reply->previous );
r.left = reply->old_rect.left;
r.top = reply->old_rect.top;
r.right = reply->old_rect.right;
r.bottom = reply->old_rect.bottom;
old_state = reply->old_state;
hidden = reply->old_hide;
}
}
SERVER_END_REQ;
if (!ret) return FALSE;
if (prev && !hidden) /* hide the previous one */
{
/* FIXME: won't work if prev belongs to a different process */
KillSystemTimer( prev, TIMERID );
if (old_state) CARET_DisplayCaret( prev, &r );
}
if (Caret.hBmp) DeleteObject( Caret.hBmp );
Caret.hBmp = hBmp;
Caret.timeout = GetProfileIntA( "windows", "CursorBlinkRate", 500 );
return TRUE;
}
VOID
NetpGetTimeFormat(
LPNET_TIME_FORMAT TimeFormat
)
/*++
Routine Description:
This function obtains the user-specific format for the time and date
strings (short format). The format is returned in a structure
pointed to by the TimeFormat parameter.
MEMORY_USAGE ** IMPORTANT **
NOTE: This function expects any NON-NULL pointers in the TimeFormat
structure to be allocated on the heap. It will attempt to free those
pointers in order to update the format. This function allocates memory
from the heap for the various structure members that are pointers to
strings. It is the caller's responsiblilty to free each of these
pointers.
Arguments:
TimeFormat - A pointer to a structure in which the format information
can be stored.
Return Value:
--*/
{
CHAR czParseString[MAX_TIME_SIZE];
LPSTR pTempString;
INT numChars;
LPSTR AMPMString="";
LPSTR ProfileLoc = "intl";
LPSTR emptyStr = "";
//-----------------------------------------
// Get the Date Format (M/d/yy)
//-----------------------------------------
pTempString = czParseString;
numChars = GetProfileStringA(
ProfileLoc,
"sShortDate",
emptyStr,
czParseString,
MAX_TIME_SIZE);
if (numChars == 0) {
//
// No data, use the default.
//
pTempString = "M/d/yy";
numChars = strlen(pTempString);
}
if (TimeFormat->DateFormat != NULL) {
LocalFree(TimeFormat->DateFormat);
TimeFormat->DateFormat = NULL;
}
TimeFormat->DateFormat = LocalAlloc(LMEM_ZEROINIT, numChars+sizeof(CHAR));
if (TimeFormat->DateFormat != NULL) {
strcpy(TimeFormat->DateFormat, pTempString);
}
//-----------------------------------------
// 12 or 24 hour format?
//-----------------------------------------
TimeFormat->TwelveHour = TRUE;
numChars = GetProfileStringA(
ProfileLoc,
"iTime",
emptyStr,
czParseString,
MAX_TIME_SIZE);
if (numChars > 0) {
if (*czParseString == '1'){
TimeFormat->TwelveHour = FALSE;
}
}
//-----------------------------------------
// Where put AMPM string?
//-----------------------------------------
TimeFormat->TimePrefix = FALSE;
numChars = GetProfileStringA(
ProfileLoc,
"iTimePrefix",
emptyStr,
czParseString,
MAX_TIME_SIZE);
if (numChars > 0) {
if (*czParseString == '1'){
TimeFormat->TimePrefix = TRUE;
}
}
//-----------------------------------------
// Is there a Leading Zero?
//-----------------------------------------
TimeFormat->LeadingZero = FALSE;
if (GetProfileIntA(ProfileLoc,"iTLZero",0) == 1) {
TimeFormat->LeadingZero = TRUE;
}
//-----------------------------------------
// Get the Time Separator character.
//-----------------------------------------
if (TimeFormat->TimeSeparator != NULL) {
LocalFree(TimeFormat->TimeSeparator);
TimeFormat->TimeSeparator == NULL;
}
numChars = GetProfileStringA(
ProfileLoc,
"sTime",
emptyStr,
czParseString,
MAX_TIME_SIZE);
if (numChars == 0) {
//
// No data, use the default.
//
pTempString = ":";
numChars = strlen(pTempString);
}
else {
pTempString = czParseString;
}
TimeFormat->TimeSeparator = LocalAlloc(LMEM_FIXED, numChars + sizeof(CHAR));
if (TimeFormat->TimeSeparator != NULL) {
strcpy(TimeFormat->TimeSeparator, pTempString);
}
//-------------------------------------------------
// Get the AM string.
//-------------------------------------------------
pTempString = czParseString;
numChars = GetProfileStringA(
ProfileLoc,
"s1159",
emptyStr,
czParseString,
MAX_TIME_SIZE);
if (numChars == 0) {
pTempString = emptyStr;
}
if (TimeFormat->AMString != NULL) {
LocalFree(TimeFormat->AMString);
}
TimeFormat->AMString = LocalAlloc(LMEM_FIXED,strlen(pTempString)+sizeof(CHAR));
if (TimeFormat->AMString != NULL) {
strcpy(TimeFormat->AMString,pTempString);
}
//-------------------------------------------------
// Get the PM string.
//-------------------------------------------------
pTempString = czParseString;
numChars = GetProfileStringA(
ProfileLoc,
"s2359",
emptyStr,
czParseString,
MAX_TIME_SIZE);
if (numChars == 0) {
pTempString = emptyStr;
}
if (TimeFormat->PMString != NULL) {
LocalFree(TimeFormat->PMString);
}
TimeFormat->PMString = LocalAlloc(LMEM_FIXED,strlen(pTempString)+sizeof(WCHAR));
if (TimeFormat->PMString != NULL) {
strcpy(TimeFormat->PMString,pTempString);
}
return;
}
