Release 961222
Sun Dec 22 13:30:18 1996 Alexandre Julliard <julliard@lrc.epfl.ch>
* [graphics/metafiledrv/init.c] [graphisc/metafiledrv/mapping.c]
Added mapping functions.
* [if1632/gdi.spec] [objects/*.c] [include/windows.h]
Added a lot of Win32 functions.
* [memory/heap.c]
Added HEAP_strdupAtoW and HEAP_strdupWtoA.
* [misc/lstr.c] [memory/string.c]
Moved OEM<->Ansi conversion to string.c. Fixed a couple of bugs.
* [object/font.c]
Avoid uppercasing font names.
* [windows/hook.c]
Set ds = ss before calling hook procedure.
Sat Dec 21 21:44:17 1996 Alex Korobka <alex@trantor.pharm.sunysb.edu>
* [objects/color.c]
Use colors allocated by other clients.
* [windows/caret.c]
Set default blink time to 500.
* [windows/win.c] [windows/event.c]
Delete X context before XDestroyWindow().
* [windows/keyboard.c]
Fixed GetKeyState() once more.
Fri Dec 20 08:26:33 1996 Eric Youngdale <eric@sub2304.jic.com>
* [debugger/*.c]
Lots of built-in debugger improvements: parse Win32 EXEs debug
information, display local variables, source files and line
numbers, get symbols directly from the Wine executable, etc.
Tue Dec 17 22:39:42 1996 Philippe De Muyter <phdm@info.ucl.ac.be>
* [misc/winsock_async.c]
Extern declaration added for h_errno.
Tue Dec 17 21:29:34 1996 Albrecht Kleine <kleine@ak.sax.de>
* [windows/message.c]
Added two more CBT hook calls: HCBT_CLICKSKIPPED/HCBT_KEYSKIPPED.
diff --git a/ANNOUNCE b/ANNOUNCE
index 835a25a..ba07f17 100644
--- a/ANNOUNCE
+++ b/ANNOUNCE
@@ -1,12 +1,13 @@
-This is release 961215 of Wine, the MS Windows emulator. This is still a
+This is release 961222 of Wine, the MS Windows emulator. This is still a
developer's only release. There are many bugs and many unimplemented API
features. Most applications still do not work correctly.
Patches should be submitted to "julliard@lrc.epfl.ch". Please don't
forget to include a ChangeLog entry.
-WHAT'S NEW with Wine-961215: (see ChangeLog for details)
- - Tons of new Win32 stuff.
+WHAT'S NEW with Wine-961222: (see ChangeLog for details)
+ - Lots of improvements to the built-in debugger
+ - Yet more Win32 stuff.
- Lots of bug fixes.
See the README file in the distribution for installation instructions.
@@ -15,10 +16,10 @@
the release is available at the ftp sites. The sources will be available
from the following locations:
- ftp://sunsite.unc.edu/pub/Linux/ALPHA/wine/development/Wine-961215.tar.gz
- ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/development/Wine-961215.tar.gz
- ftp://ftp.infomagic.com/pub/mirrors/linux/wine/development/Wine-961215.tar.gz
- ftp://aris.com/pub/linux/ALPHA/Wine/development/Wine-961215.tar.gz
+ ftp://sunsite.unc.edu/pub/Linux/ALPHA/wine/development/Wine-961222.tar.gz
+ ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/development/Wine-961222.tar.gz
+ ftp://ftp.infomagic.com/pub/mirrors/linux/wine/development/Wine-961222.tar.gz
+ ftp://aris.com/pub/linux/ALPHA/Wine/development/Wine-961222.tar.gz
It should also be available from any site that mirrors tsx-11 or sunsite.
diff --git a/BUGS b/BUGS
index 0379d01..b4e8b84 100644
--- a/BUGS
+++ b/BUGS
@@ -5,7 +5,7 @@
add new entries and, more importantly, remove those for the
bugs you fixed ;-)
------------------------------------------------------------
-As of Dec 15 1996 -
+As of Dec 22 1996 -
General:
@@ -41,7 +41,6 @@
* AllocCSToDSAlias() shouldn't alloc alias for the same segment multiple
times.
* ScrollWindowEx() is outdated.
- * HCBT_CLICKSKIPPED/HCBT_KEYSKIPPED hook actions are not implemented.
Where to look in source files:
diff --git a/ChangeLog b/ChangeLog
index f94bb28..517be68 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,56 @@
----------------------------------------------------------------------
+Sun Dec 22 13:30:18 1996 Alexandre Julliard <julliard@lrc.epfl.ch>
+
+ * [graphics/metafiledrv/init.c] [graphisc/metafiledrv/mapping.c]
+ Added mapping functions.
+
+ * [if1632/gdi.spec] [objects/*.c] [include/windows.h]
+ Added a lot of Win32 functions.
+
+ * [memory/heap.c]
+ Added HEAP_strdupAtoW and HEAP_strdupWtoA.
+
+ * [misc/lstr.c] [memory/string.c]
+ Moved OEM<->Ansi conversion to string.c. Fixed a couple of bugs.
+
+ * [object/font.c]
+ Avoid uppercasing font names.
+
+ * [windows/hook.c]
+ Set ds = ss before calling hook procedure.
+
+Sat Dec 21 21:44:17 1996 Alex Korobka <alex@trantor.pharm.sunysb.edu>
+
+ * [objects/color.c]
+ Use colors allocated by other clients.
+
+ * [windows/caret.c]
+ Set default blink time to 500.
+
+ * [windows/win.c] [windows/event.c]
+ Delete X context before XDestroyWindow().
+
+ * [windows/keyboard.c]
+ Fixed GetKeyState() once more.
+
+Fri Dec 20 08:26:33 1996 Eric Youngdale <eric@sub2304.jic.com>
+
+ * [debugger/*.c]
+ Lots of built-in debugger improvements: parse Win32 EXEs debug
+ information, display local variables, source files and line
+ numbers, get symbols directly from the Wine executable, etc.
+
+Tue Dec 17 22:39:42 1996 Philippe De Muyter <phdm@info.ucl.ac.be>
+
+ * [misc/winsock_async.c]
+ Extern declaration added for h_errno.
+
+Tue Dec 17 21:29:34 1996 Albrecht Kleine <kleine@ak.sax.de>
+
+ * [windows/message.c]
+ Added two more CBT hook calls: HCBT_CLICKSKIPPED/HCBT_KEYSKIPPED.
+
+----------------------------------------------------------------------
Sun Dec 15 16:18:15 1996 Alexandre Julliard <julliard@lrc.epfl.ch>
* [graphics/x11drv/bitblt.c]
diff --git a/controls/button.c b/controls/button.c
index e53b4c0..b9bbe05 100644
--- a/controls/button.c
+++ b/controls/button.c
@@ -264,7 +264,7 @@
BUTTON_SEND_CTLCOLOR( wndPtr, hDC );
hOldPen = (HPEN32)SelectObject32(hDC, sysColorObjects.hpenWindowFrame);
hOldBrush = (HBRUSH32)SelectObject32(hDC, sysColorObjects.hbrushBtnFace);
- SetBkMode(hDC, TRANSPARENT);
+ SetBkMode32(hDC, TRANSPARENT);
Rectangle32(hDC, rc.left, rc.top, rc.right, rc.bottom);
if (action == ODA_DRAWENTIRE)
{
@@ -339,7 +339,7 @@
{
static int Pattern[] = {0xAA,0x55,0xAA,0x55,0xAA,0x55,0xAA,0x55};
HBITMAP16 hbm = CreateBitmap(8, 8, 1, 1, Pattern);
- HDC32 hdcMem = CreateCompatibleDC(hDC);
+ HDC32 hdcMem = CreateCompatibleDC32(hDC);
HBITMAP16 hbmMem;
HBRUSH16 hBr;
RECT32 rect,rc2;
@@ -359,7 +359,7 @@
PatBlt32( hdcMem,0,0,rect.right,rect.bottom,0xFA0089);
DeleteObject32( SelectObject32( hdcMem,hBr) );
BitBlt32(hDC,rect.left,rect.top,rect.right,rect.bottom,hdcMem,0,0,0x990000);
- DeleteDC( hdcMem);
+ DeleteDC32( hdcMem);
DeleteObject32( hbmMem );
}
diff --git a/controls/desktop.c b/controls/desktop.c
index b7458b9..8fcde45 100644
--- a/controls/desktop.c
+++ b/controls/desktop.c
@@ -61,9 +61,9 @@
HeapFree( SystemHeap, 0, buffer );
return 0;
}
- hbitmap = CreateDIBitmap( hdc, &bitmapInfo->bmiHeader, CBM_INIT,
- buffer + fileHeader->bfOffBits,
- bitmapInfo, DIB_RGB_COLORS );
+ hbitmap = CreateDIBitmap32( hdc, &bitmapInfo->bmiHeader, CBM_INIT,
+ buffer + fileHeader->bfOffBits,
+ bitmapInfo, DIB_RGB_COLORS );
HeapFree( SystemHeap, 0, buffer );
return hbitmap;
}
diff --git a/controls/edit.c b/controls/edit.c
index 54aecd4..3cb1372 100644
--- a/controls/edit.c
+++ b/controls/edit.c
@@ -1313,8 +1313,8 @@
if (!count)
return 0;
- BkColor = GetBkColor(hdc);
- TextColor = GetTextColor(hdc);
+ BkColor = GetBkColor32(hdc);
+ TextColor = GetTextColor32(hdc);
if (rev) {
SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
diff --git a/controls/menu.c b/controls/menu.c
index fd5bb8a..8e8583d 100644
--- a/controls/menu.c
+++ b/controls/menu.c
@@ -28,7 +28,6 @@
#include "message.h"
#include "graphics.h"
#include "resource.h"
-#include "string32.h"
#include "stddebug.h"
#include "debug.h"
@@ -585,7 +584,7 @@
if (lpitem->item_flags & MF_HILITE)
FillRect16( hdc, &rect, sysColorObjects.hbrushHighlight );
else FillRect16( hdc, &rect, sysColorObjects.hbrushMenu );
- SetBkMode( hdc, TRANSPARENT );
+ SetBkMode32( hdc, TRANSPARENT );
/* Draw the separator bar (if any) */
@@ -2250,9 +2249,9 @@
if (IS_STRING_ITEM(flags) && str)
{
- LPSTR newstr = STRING32_DupUniToAnsi( str );
+ LPSTR newstr = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
ret = InsertMenu32A( hMenu, pos, flags, id, newstr );
- free( newstr );
+ HeapFree( GetProcessHeap(), 0, newstr );
return ret;
}
else return InsertMenu32A( hMenu, pos, flags, id, (LPCSTR)str );
@@ -2386,9 +2385,9 @@
if (IS_STRING_ITEM(flags) && str)
{
- LPSTR newstr = STRING32_DupUniToAnsi( str );
+ LPSTR newstr = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
ret = ModifyMenu32A( hMenu, pos, flags, id, newstr );
- free( newstr );
+ HeapFree( GetProcessHeap(), 0, newstr );
return ret;
}
else return ModifyMenu32A( hMenu, pos, flags, id, (LPCSTR)str );
diff --git a/controls/oldlbox.c b/controls/oldlbox.c
index d7a7547..c1577ce 100644
--- a/controls/oldlbox.c
+++ b/controls/oldlbox.c
@@ -200,7 +200,7 @@
int OldBkMode;
DWORD dwOldTextColor = 0;
- OldBkMode = SetBkMode(hdc, TRANSPARENT);
+ OldBkMode = SetBkMode32(hdc, TRANSPARENT);
if (itemState != 0) {
dwOldTextColor = SetTextColor(hdc, 0x00FFFFFFL);
@@ -220,7 +220,7 @@
SetTextColor(hdc, dwOldTextColor);
}
- SetBkMode(hdc, OldBkMode);
+ SetBkMode32(hdc, OldBkMode);
}
else DrawFocusRect16(hdc, rect);
}
diff --git a/controls/scroll.c b/controls/scroll.c
index 0ffa3b4..ea04e38 100644
--- a/controls/scroll.c
+++ b/controls/scroll.c
@@ -311,11 +311,11 @@
RECT32 *rect, INT32 arrowSize, BOOL32 vertical,
BOOL32 top_pressed, BOOL32 bottom_pressed )
{
- HDC32 hdcMem = CreateCompatibleDC( hdc );
+ HDC32 hdcMem = CreateCompatibleDC32( hdc );
HBITMAP32 hbmpPrev = SelectObject32( hdcMem, vertical ?
TOP_ARROW(infoPtr->flags, top_pressed)
: LEFT_ARROW(infoPtr->flags, top_pressed));
- SetStretchBltMode( hdc, STRETCH_DELETESCANS );
+ SetStretchBltMode32( hdc, STRETCH_DELETESCANS );
StretchBlt32( hdc, rect->left, rect->top,
vertical ? rect->right-rect->left : arrowSize+1,
vertical ? arrowSize+1 : rect->bottom-rect->top,
@@ -339,7 +339,7 @@
SYSMETRICS_CXVSCROLL + 1, SYSMETRICS_CYHSCROLL + 1,
SRCCOPY );
SelectObject32( hdcMem, hbmpPrev );
- DeleteDC( hdcMem );
+ DeleteDC32( hdcMem );
}
diff --git a/controls/status.c b/controls/status.c
index 971651a..ccb188b 100644
--- a/controls/status.c
+++ b/controls/status.c
@@ -70,14 +70,14 @@
/* now draw text */
if ((style != SBT_OWNERDRAW) && text) {
SelectObject32(hdc, sysColorObjects.hpenWindowText);
- oldbkmode = SetBkMode(hdc, TRANSPARENT);
+ oldbkmode = SetBkMode32(hdc, TRANSPARENT);
rt = r;
rt.left += 3;
DrawText32A(hdc, text, lstrlen32A(text),
&rt, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
if (oldbkmode != TRANSPARENT)
- SetBkMode(hdc, oldbkmode);
+ SetBkMode32(hdc, oldbkmode);
}
}
diff --git a/debugger/Makefile.in b/debugger/Makefile.in
index a01ca75..6a3634c 100644
--- a/debugger/Makefile.in
+++ b/debugger/Makefile.in
@@ -12,7 +12,9 @@
hash.c \
info.c \
memory.c \
+ msc.c \
registers.c \
+ stabs.c \
stack.c
GEN_C_SRCS = \
diff --git a/debugger/break.c b/debugger/break.c
index 7375a75..8c727b4 100644
--- a/debugger/break.c
+++ b/debugger/break.c
@@ -205,7 +205,8 @@
breakpoints[num].enabled = TRUE;
breakpoints[num].in_use = TRUE;
fprintf( stderr, "Breakpoint %d at ", num );
- DEBUG_PrintAddress( &breakpoints[num].addr, breakpoints[num].addrlen );
+ DEBUG_PrintAddress( &breakpoints[num].addr, breakpoints[num].addrlen,
+ TRUE );
fprintf( stderr, "\n" );
}
@@ -258,7 +259,8 @@
if (breakpoints[i].in_use)
{
fprintf( stderr, "%d: %c ", i, breakpoints[i].enabled ? 'y' : 'n');
- DEBUG_PrintAddress( &breakpoints[i].addr, breakpoints[i].addrlen );
+ DEBUG_PrintAddress( &breakpoints[i].addr, breakpoints[i].addrlen,
+ TRUE);
fprintf( stderr, "\n" );
}
}
@@ -290,7 +292,7 @@
{
fprintf( stderr, "Stopped on breakpoint %d at ", bpnum );
DEBUG_PrintAddress( &breakpoints[bpnum].addr,
- breakpoints[bpnum].addrlen );
+ breakpoints[bpnum].addrlen, TRUE );
fprintf( stderr, "\n" );
return FALSE;
}
diff --git a/debugger/db_disasm.c b/debugger/db_disasm.c
index ea068b7..cb230c6 100644
--- a/debugger/db_disasm.c
+++ b/debugger/db_disasm.c
@@ -1010,7 +1010,7 @@
case LONG:
{
DBG_ADDR address = { 0, addr };
- DEBUG_PrintAddress( &address, db_disasm_16 ? 16 : 32 );
+ DEBUG_PrintAddress( &address, db_disasm_16 ? 16 : 32, TRUE );
}
break;
}
@@ -1457,7 +1457,8 @@
short_addr ? 2 : 4, FALSE );
get_value_inc( address.seg, addr, /* segment */
2, FALSE );
- DEBUG_PrintAddress( &address, short_addr ? 16 : 32 );
+ DEBUG_PrintAddress( &address, short_addr ? 16 : 32,
+ TRUE );
}
break;
}
diff --git a/debugger/dbg.y b/debugger/dbg.y
index fa505b7..a7ab4f7 100644
--- a/debugger/dbg.y
+++ b/debugger/dbg.y
@@ -18,6 +18,7 @@
extern FILE * yyin;
unsigned int dbg_mode = 0;
+int curr_frame = 0;
static enum exec_mode dbg_exec_mode = EXEC_CONT;
@@ -37,11 +38,13 @@
int integer;
}
-%token tCONT tSTEP tLIST tNEXT tQUIT tHELP tBACKTRACE tINFO tWALK
+%token tCONT tSTEP tLIST tNEXT tQUIT tHELP tBACKTRACE tINFO tWALK tUP tDOWN
%token tENABLE tDISABLE tBREAK tDELETE tSET tMODE tPRINT tEXAM tDEFINE tABORT
-%token tCLASS tMODULE tSTACK tSEGMENTS tREGS tWND tQUEUE
+%token tCLASS tMODULE tSTACK tSEGMENTS tREGS tWND tQUEUE tLOCAL
%token tNO_SYMBOL tEOL
%token tSYMBOLFILE
+%token tFRAME
+
%token <string> tIDENTIFIER
%token <integer> tNUM tFORMAT
@@ -87,12 +90,17 @@
| tLIST addr tEOL { DEBUG_List( &$2, 15 ); }
| tABORT tEOL { kill(getpid(), SIGABRT); }
| tSYMBOLFILE tIDENTIFIER tEOL { DEBUG_ReadSymbolTable( $2 ); }
- | tDEFINE tIDENTIFIER addr tEOL { DEBUG_AddSymbol( $2, &$3 ); }
+ | tDEFINE tIDENTIFIER addr tEOL { DEBUG_AddSymbol( $2, &$3, NULL ); }
| tMODE tNUM tEOL { mode_command($2); }
| tENABLE tNUM tEOL { DEBUG_EnableBreakpoint( $2, TRUE ); }
| tDISABLE tNUM tEOL { DEBUG_EnableBreakpoint( $2, FALSE ); }
| tDELETE tBREAK tNUM tEOL { DEBUG_DelBreakpoint( $3 ); }
| tBACKTRACE tEOL { DEBUG_BackTrace(); }
+ | tUP tEOL { DEBUG_SetFrame( curr_frame + 1 ); }
+ | tUP tNUM tEOL { DEBUG_SetFrame( curr_frame + $2 ); }
+ | tDOWN tEOL { DEBUG_SetFrame( curr_frame - 1 ); }
+ | tDOWN tNUM tEOL { DEBUG_SetFrame( curr_frame - $2 ); }
+ | tFRAME expr tEOL { DEBUG_SetFrame( $2 ); }
| set_command
| x_command
| print_command
@@ -122,6 +130,10 @@
break_command:
tBREAK '*' addr tEOL { DEBUG_AddBreakpoint( &$3 ); }
| tBREAK symbol tEOL { DEBUG_AddBreakpoint( &$2 ); }
+ | tBREAK symbol '+' expr tEOL { DBG_ADDR addr = $2;
+ addr.off += $4;
+ DEBUG_AddBreakpoint( &addr );
+ }
| tBREAK tEOL { DBG_ADDR addr = { CS_reg(DEBUG_context),
EIP_reg(DEBUG_context) };
DEBUG_AddBreakpoint( &addr );
@@ -137,6 +149,7 @@
| tINFO tSEGMENTS tEOL { LDT_Print( 0, -1 ); }
| tINFO tSTACK tEOL { DEBUG_InfoStack(); }
| tINFO tWND expr tEOL { WIN_DumpWindow( $3 ); }
+ | tINFO tLOCAL tEOL { DEBUG_InfoLocals(); }
walk_command:
tWALK tCLASS tEOL { CLASS_WalkClasses(); }
@@ -145,12 +158,19 @@
| tWALK tWND tEOL { WIN_WalkWindows( 0, 0 ); }
| tWALK tWND tNUM tEOL { WIN_WalkWindows( $3, 0 ); }
-symbol: tIDENTIFIER { if (!DEBUG_GetSymbolValue( $1, &$$ ))
- {
- fprintf( stderr, "Symbol %s not found\n", $1 );
- YYERROR;
- }
- }
+symbol:
+ tIDENTIFIER { if (!DEBUG_GetSymbolValue( $1, -1, &$$ ))
+ {
+ fprintf( stderr, "Symbol %s not found\n", $1 );
+ YYERROR;
+ }
+ }
+ | tIDENTIFIER ':' tNUM { if (!DEBUG_GetSymbolValue( $1, $3, &$$ ))
+ {
+ fprintf( stderr, "No code at %s:%d\n", $1, $3 );
+ YYERROR;
+ }
+ }
addr:
expr { $$.seg = 0xffffffff; $$.off = $1; }
@@ -159,6 +179,8 @@
segaddr:
expr ':' expr { $$.seg = $1; $$.off = $3; }
| symbol { $$ = $1; }
+ | symbol '+' expr { $$ = $1; $$.off += $3; }
+ | symbol '-' expr { $$ = $1; $$.off -= $3; }
expr:
tNUM { $$ = $1; }
@@ -258,9 +280,29 @@
if (!loaded_symbols)
{
loaded_symbols++;
- PROFILE_GetWineIniString( "wine", "SymbolTableFile", "wine.sym",
- SymbolTableFile, sizeof(SymbolTableFile) );
- DEBUG_ReadSymbolTable( SymbolTableFile );
+ /*
+ * In some cases we can read the stabs information directly
+ * from the executable. If this is the case, we don't need
+ * to bother with trying to read a symbol file, as the stabs
+ * also have line number and local variable information.
+ * As long as gcc is used for the compiler, stabs will
+ * be the default. On SVr4, DWARF could be used, but we
+ * don't grok that yet, and in this case we fall back to using
+ * the wine.sym file.
+ */
+ if( DEBUG_ReadExecutableDbgInfo() == FALSE )
+ {
+ PROFILE_GetWineIniString( "wine", "SymbolTableFile", "wine.sym",
+ SymbolTableFile, sizeof(SymbolTableFile));
+ DEBUG_ReadSymbolTable( SymbolTableFile );
+ }
+
+ /*
+ * Read COFF, MSC, etc debug information that we noted when we
+ * started up the executable.
+ */
+ DEBUG_ProcessDeferredDebug();
+
DEBUG_LoadEntryPoints();
}
@@ -298,7 +340,8 @@
}
/* Show where we crashed */
- DEBUG_PrintAddress( &addr, dbg_mode );
+ curr_frame = 0;
+ DEBUG_PrintAddress( &addr, dbg_mode, TRUE );
fprintf(stderr,": ");
if (DBG_CHECK_READ_PTR( &addr, 1 ))
{
diff --git a/debugger/debug.l b/debugger/debug.l
index 7b8d278..93e0929 100644
--- a/debugger/debug.l
+++ b/debugger/debug.l
@@ -86,6 +86,10 @@
$fs { yylval.reg = REG_FS; return tREG; }
$gs { yylval.reg = REG_GS; return tREG; }
+up { return tUP; }
+down|dow|do { return tDOWN; }
+frame|fram|fra|fr { return tFRAME; }
+locals|local|loca|loc { return tLOCAL; }
info|inf|in { return tINFO; }
show|sho|sh { return tINFO; }
list|lis|li|l { return tLIST; }
diff --git a/debugger/hash.c b/debugger/hash.c
index 82609e7..bfbdafa 100644
--- a/debugger/hash.c
+++ b/debugger/hash.c
@@ -16,13 +16,6 @@
#include "toolhelp.h"
#include "xmalloc.h"
-struct name_hash
-{
- struct name_hash * next;
- char * name;
- DBG_ADDR addr;
-};
-
#define NR_NAME_HASH 128
static struct name_hash * name_hash_table[NR_NAME_HASH];
@@ -44,7 +37,8 @@
*
* Add a symbol to the table.
*/
-void DEBUG_AddSymbol( const char * name, const DBG_ADDR *addr )
+struct name_hash *
+DEBUG_AddSymbol( const char * name, const DBG_ADDR *addr, const char * source )
{
struct name_hash * new;
int hash;
@@ -52,12 +46,32 @@
new = (struct name_hash *) xmalloc(sizeof(struct name_hash));
new->addr = *addr;
new->name = xstrdup(name);
+
+ if( source != NULL )
+ {
+ new->sourcefile = xstrdup(source);
+ }
+ else
+ {
+ new->sourcefile = NULL;
+ }
+
+ new->n_lines = 0;
+ new->lines_alloc = 0;
+ new->linetab = NULL;
+
+ new->n_locals = 0;
+ new->locals_alloc = 0;
+ new->local_vars = NULL;
+
new->next = NULL;
hash = name_hash(name);
/* Now insert into the hash table */
new->next = name_hash_table[hash];
name_hash_table[hash] = new;
+
+ return new;
}
@@ -66,9 +80,11 @@
*
* Get the address of a named symbol.
*/
-BOOL32 DEBUG_GetSymbolValue( const char * name, DBG_ADDR *addr )
+BOOL32 DEBUG_GetSymbolValue( const char * name, const int lineno,
+ DBG_ADDR *addr )
{
char buffer[256];
+ int i;
struct name_hash *nh;
for(nh = name_hash_table[name_hash(name)]; nh; nh = nh->next)
@@ -82,8 +98,45 @@
if (!strcmp(nh->name, buffer)) break;
}
- if (!nh) return FALSE;
- *addr = nh->addr;
+ /*
+ * If we don't have anything here, then try and see if this
+ * is a local symbol to the current stack frame. No matter
+ * what, we have nothing more to do, so we let that function
+ * decide what we ultimately return.
+ */
+ if (!nh) return DEBUG_GetStackSymbolValue(name, addr);
+
+
+ if( lineno == -1 )
+ {
+ *addr = nh->addr;
+ }
+ else
+ {
+ /*
+ * Search for the specific line number. If we don't find it,
+ * then return FALSE.
+ */
+ if( nh->linetab == NULL )
+ {
+ return FALSE;
+ }
+
+ for(i=0; i < nh->n_lines; i++ )
+ {
+ if( nh->linetab[i].line_number == lineno )
+ {
+ *addr = nh->linetab[i].pc_offset;
+ return TRUE;
+ }
+ }
+
+ /*
+ * This specific line number not found.
+ */
+ return FALSE;
+ }
+
return TRUE;
}
@@ -120,14 +173,26 @@
* DEBUG_FindNearestSymbol
*
* Find the symbol nearest to a given address.
+ * If ebp is specified as non-zero, it means we should dump the argument
+ * list into the string we return as well.
*/
-const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr )
+const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr, int flag,
+ struct name_hash ** rtn,
+ unsigned int ebp)
{
- static char name_buffer[256];
+ static char name_buffer[MAX_PATH + 256];
+ static char arglist[1024];
+ static char argtmp[256];
struct name_hash * nearest = NULL;
struct name_hash * nh;
unsigned int nearest_address = 0;
+ unsigned int * ptr;
+ int lineno;
+ char * lineinfo, *sourcefile;
int i;
+ char linebuff[16];
+
+ *rtn = NULL;
for(i=0; i<NR_NAME_HASH; i++)
{
@@ -142,11 +207,95 @@
}
if (!nearest) return NULL;
- if (addr->off == nearest->addr.off)
- sprintf( name_buffer, "%s", nearest->name );
+ *rtn = nearest;
+ lineinfo = "";
+ lineno = -1;
+
+ memset(arglist, '\0', sizeof(arglist));
+ if( ebp != 0 )
+ {
+ for(i=0; i < nearest->n_locals; i++ )
+ {
+ /*
+ * If this is a register (offset == 0) or a local
+ * variable, we don't want to know about it.
+ */
+ if( nearest->local_vars[i].offset <= 0 )
+ {
+ continue;
+ }
+
+ ptr = (unsigned int *) (ebp + nearest->local_vars[i].offset);
+ if( arglist[0] == '\0' )
+ {
+ arglist[0] = '(';
+ }
+ else
+ {
+ strcat(arglist, ", ");
+ }
+
+ sprintf(argtmp, "%s=0x%x", nearest->local_vars[i].name,
+ *ptr);
+ strcat(arglist, argtmp);
+ }
+ if( arglist[0] == '(' )
+ {
+ strcat(arglist, ")");
+ }
+ }
+
+ if( (nearest->sourcefile != NULL) && (flag == TRUE)
+ && (addr->off - nearest->addr.off < 0x100000) )
+ {
+
+ /*
+ * Try and find the nearest line number to the current offset.
+ */
+ if( nearest->linetab != NULL )
+ {
+ /*
+ * FIXME - this is an inefficient linear search. A binary
+ * search would be better if this gets to be a performance
+ * bottleneck.
+ */
+ for(i=0; i < nearest->n_lines; i++)
+ {
+ if( addr->off < nearest->linetab[i].pc_offset.off )
+ {
+ break;
+ }
+ lineno = nearest->linetab[i].line_number;
+ }
+ }
+
+ if( lineno != -1 )
+ {
+ sprintf(linebuff, ":%d", lineno);
+ lineinfo = linebuff;
+ }
+
+ /* Remove the path from the file name */
+ sourcefile = strrchr( nearest->sourcefile, '/' );
+ if (!sourcefile) sourcefile = nearest->sourcefile;
+ else sourcefile++;
+
+ if (addr->off == nearest->addr.off)
+ sprintf( name_buffer, "%s%s [%s%s]", nearest->name,
+ arglist, sourcefile, lineinfo);
+ else
+ sprintf( name_buffer, "%s+0x%lx%s [%s%s]", nearest->name,
+ addr->off - nearest->addr.off,
+ arglist, sourcefile, lineinfo );
+ }
else
- sprintf( name_buffer, "%s+0x%lx", nearest->name,
- addr->off - nearest->addr.off );
+ {
+ if (addr->off == nearest->addr.off)
+ sprintf( name_buffer, "%s%s", nearest->name, arglist);
+ else
+ sprintf( name_buffer, "%s+0x%lx%s", nearest->name,
+ addr->off - nearest->addr.off, arglist);
+ }
return name_buffer;
}
@@ -194,7 +343,7 @@
if (!(*cpnt) || *cpnt == '\n') continue;
nargs = sscanf(buffer, "%lx %c %s", &addr.off, &type, name);
- DEBUG_AddSymbol( name, &addr );
+ DEBUG_AddSymbol( name, &addr, NULL );
}
fclose(symbolfile);
}
@@ -234,7 +383,7 @@
{
addr.seg = HIWORD(address);
addr.off = LOWORD(address);
- DEBUG_AddSymbol( buffer, &addr );
+ DEBUG_AddSymbol( buffer, &addr, NULL );
}
}
@@ -252,8 +401,59 @@
{
addr.seg = HIWORD(address);
addr.off = LOWORD(address);
- DEBUG_AddSymbol( buffer, &addr );
+ DEBUG_AddSymbol( buffer, &addr, NULL);
}
}
}
}
+
+void
+DEBUG_AddLineNumber( struct name_hash * func, int line_num,
+ unsigned long offset )
+{
+ if( func == NULL )
+ {
+ return;
+ }
+
+ if( func->n_lines + 1 >= func->lines_alloc )
+ {
+ func->lines_alloc += 32;
+ func->linetab = realloc(func->linetab,
+ func->lines_alloc * sizeof(WineLineNo));
+ }
+
+ func->linetab[func->n_lines].line_number = line_num;
+ func->linetab[func->n_lines].pc_offset.seg = func->addr.seg;
+ func->linetab[func->n_lines].pc_offset.off = func->addr.off + offset;
+ func->n_lines++;
+}
+
+
+void
+DEBUG_AddLocal( struct name_hash * func, int regno,
+ int offset,
+ int pc_start,
+ int pc_end,
+ char * name)
+{
+ if( func == NULL )
+ {
+ return;
+ }
+
+ if( func->n_locals + 1 >= func->locals_alloc )
+ {
+ func->locals_alloc += 32;
+ func->local_vars = realloc(func->local_vars,
+ func->locals_alloc * sizeof(WineLocals));
+ }
+
+ func->local_vars[func->n_locals].regno = regno;
+ func->local_vars[func->n_locals].offset = offset;
+ func->local_vars[func->n_locals].pc_start = pc_start;
+ func->local_vars[func->n_locals].pc_end = pc_end;
+ func->local_vars[func->n_locals].name = xstrdup(name);
+ func->n_locals++;
+}
+
diff --git a/debugger/info.c b/debugger/info.c
index 57d8d27..2abc981 100644
--- a/debugger/info.c
+++ b/debugger/info.c
@@ -76,14 +76,38 @@
*
* Print an 16- or 32-bit address, with the nearest symbol if any.
*/
-void DEBUG_PrintAddress( const DBG_ADDR *addr, int addrlen )
+struct name_hash *
+DEBUG_PrintAddress( const DBG_ADDR *addr, int addrlen, int flag )
{
- const char *name = DEBUG_FindNearestSymbol( addr );
+ struct name_hash * nh;
+ const char *name = DEBUG_FindNearestSymbol( addr, flag, &nh, 0 );
if (addr->seg) fprintf( stderr, "0x%04lx:", addr->seg );
if (addrlen == 16) fprintf( stderr, "0x%04lx", addr->off );
else fprintf( stderr, "0x%08lx", addr->off );
if (name) fprintf( stderr, " (%s)", name );
+ return nh;
+}
+/***********************************************************************
+ * DEBUG_PrintAddressAndArgs
+ *
+ * Print an 16- or 32-bit address, with the nearest symbol if any.
+ * Similar to DEBUG_PrintAddress, but we print the arguments to
+ * each function (if known). This is useful in a backtrace.
+ */
+struct name_hash *
+DEBUG_PrintAddressAndArgs( const DBG_ADDR *addr, int addrlen,
+ unsigned int ebp, int flag )
+{
+ struct name_hash * nh;
+ const char *name = DEBUG_FindNearestSymbol( addr, flag, &nh, ebp );
+
+ if (addr->seg) fprintf( stderr, "0x%04lx:", addr->seg );
+ if (addrlen == 16) fprintf( stderr, "0x%04lx", addr->off );
+ else fprintf( stderr, "0x%08lx", addr->off );
+ if (name) fprintf( stderr, " (%s)", name );
+
+ return nh;
}
@@ -100,19 +124,20 @@
"The commands accepted by the Wine debugger are a small subset",
"of the commands that gdb would accept.",
"The commands currently are:",
-" break [*<addr>] delete break bpnum",
-" disable bpnum enable bpnum",
-" help quit",
-" bt cont",
-" step next",
-" x <addr> print <expr>",
-" set <reg> = <expr> set *<addr> = <expr>",
-" symbolfile <filename> define <identifier> <addr>",
-" list <addr>\n",
+" break [*<addr>] delete break bpnum",
+" disable bpnum enable bpnum",
+" help quit",
+" bt cont",
+" step next",
+" x <addr> print <expr>",
+" set <reg> = <expr> set *<addr> = <expr>",
+" symbolfile <filename> define <identifier> <addr>",
+" up down\n",
+" list <addr> frame <n>\n",
"Wine-specific commands:",
-" mode [16,32] walk [wnd,class,queue] <handle>",
-" info [reg,stack,break,segments] info [wnd, queue] <handle>\n",
+" mode [16,32] walk [wnd,class,queue] <handle>",
+" info [reg,stack,break,segments,locals] info [wnd, queue] <handle>\n",
"The 'x' command accepts repeat counts and formats (including 'i') in the",
"same way that gdb does.\n",
@@ -144,7 +169,7 @@
DBG_FIX_ADDR_SEG( addr, CS_reg(DEBUG_context) );
while (count-- > 0)
{
- DEBUG_PrintAddress( addr, dbg_mode );
+ DEBUG_PrintAddress( addr, dbg_mode, FALSE );
fprintf( stderr, ": " );
if (!DBG_CHECK_READ_PTR( addr, 1 )) return;
DEBUG_Disasm( addr );
diff --git a/debugger/memory.c b/debugger/memory.c
index a51e915..ee826b4 100644
--- a/debugger/memory.c
+++ b/debugger/memory.c
@@ -153,7 +153,7 @@
if (format != 'i' && count > 1)
{
- DEBUG_PrintAddress( &addr, dbg_mode );
+ DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
fprintf(stderr,": ");
}
@@ -176,7 +176,7 @@
case 'i':
while (count--)
{
- DEBUG_PrintAddress( &addr, dbg_mode );
+ DEBUG_PrintAddress( &addr, dbg_mode, TRUE );
fprintf(stderr,": ");
if (!DBG_CHECK_READ_PTR( &addr, 1 )) return;
DEBUG_Disasm( &addr );
@@ -193,7 +193,7 @@
if ((i % 8) == 7)
{
fprintf(stderr,"\n");
- DEBUG_PrintAddress( &addr, dbg_mode );
+ DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
fprintf(stderr,": ");
}
}
@@ -210,7 +210,7 @@
if ((i % 8) == 7)
{
fprintf(stderr,"\n");
- DEBUG_PrintAddress( &addr, dbg_mode );
+ DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
fprintf(stderr,": ");
}
}
@@ -227,7 +227,7 @@
if ((i % 8) == 7)
{
fprintf(stderr,"\n");
- DEBUG_PrintAddress( &addr, dbg_mode );
+ DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
fprintf(stderr,": ");
}
}
@@ -248,7 +248,7 @@
if ((i % 32) == 31)
{
fprintf(stderr,"\n");
- DEBUG_PrintAddress( &addr, dbg_mode );
+ DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
fprintf(stderr,": ");
}
}
@@ -264,7 +264,7 @@
if ((i % 16) == 15)
{
fprintf(stderr,"\n");
- DEBUG_PrintAddress( &addr, dbg_mode );
+ DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
fprintf(stderr,": ");
}
}
diff --git a/debugger/msc.c b/debugger/msc.c
new file mode 100644
index 0000000..dc29ca9
--- /dev/null
+++ b/debugger/msc.c
@@ -0,0 +1,413 @@
+/*
+ * File msc.c - read VC++ debug information from COFF and eventually
+ * from PDB files.
+ *
+ * Copyright (C) 1996, Eric Youngdale.
+ *
+ * Note - this handles reading debug information for 32 bit applications
+ * that run under Windows-NT for example. I doubt that this would work well
+ * for 16 bit applications, but I don't think it really matters since the
+ * file format is different, and we should never get in here in such cases.
+ */
+
+#include <stdio.h>
+
+
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <limits.h>
+#include <strings.h>
+#include <unistd.h>
+#include <malloc.h>
+
+#include "win.h"
+#include "pe_image.h"
+#include "debugger.h"
+#include "peexe.h"
+#include "xmalloc.h"
+
+/*
+ * For the type CODEVIEW debug directory entries, the debug directory
+ * points to a structure like this. The cv_name field is the name
+ * of an external .PDB file.
+ */
+struct CodeViewDebug
+{
+ char cv_nbtype[8];
+ unsigned int cv_timestamp;
+ char cv_unknown[4];
+ char cv_name[1];
+};
+
+struct MiscDebug {
+ unsigned int DataType;
+ unsigned int Length;
+ char Unicode;
+ char Reserved[3];
+ char Data[1];
+};
+
+/*
+ * This is the header that the COFF variety of debug header points to.
+ */
+struct CoffDebug {
+ unsigned int N_Sym;
+ unsigned int SymbolOffset;
+ unsigned int N_Linenum;
+ unsigned int LinenumberOffset;
+ unsigned int Unused[4];
+};
+
+struct CoffLinenum {
+ unsigned int VirtualAddr;
+ unsigned int Linenum;
+};
+
+struct CoffFiles {
+ unsigned int startaddr;
+ unsigned int endaddr;
+ char * filename;
+};
+
+
+struct CoffSymbol {
+ union {
+ char ShortName[8];
+ struct {
+ unsigned int NotLong;
+ unsigned int StrTaboff;
+ } Name;
+ } N;
+ unsigned int Value;
+ short SectionNumber;
+ short Type;
+ char StorageClass;
+ unsigned char NumberOfAuxSymbols;
+};
+
+struct CoffAuxSection{
+ unsigned int Length;
+ unsigned short NumberOfRelocations;
+ unsigned short NumberOfLinenumbers;
+ unsigned int CheckSum;
+ short Number;
+ char Selection;
+} Section;
+
+struct deferred_debug_info
+{
+ struct deferred_debug_info * next;
+ char * load_addr;
+ char * dbg_info;
+ int dbg_size;
+ struct PE_Debug_dir * dbgdir;
+ struct pe_data * pe;
+};
+
+struct deferred_debug_info * dbglist = NULL;
+
+/*
+ * A simple macro that tells us whether a given COFF symbol is a
+ * function or not.
+ */
+#define N_TMASK 0x0030
+#define IMAGE_SYM_DTYPE_FUNCTION 2
+#define N_BTSHFT 4
+#define ISFCN(x) (((x) & N_TMASK) == (IMAGE_SYM_DTYPE_FUNCTION << N_BTSHFT))
+
+
+/*
+ * This is what we are looking for in the COFF symbols.
+ */
+#define IMAGE_SYM_CLASS_EXTERNAL 0x2
+#define IMAGE_SYM_CLASS_STATIC 0x3
+#define IMAGE_SYM_CLASS_FILE 0x67
+
+/*
+ * In this function, we keep track of deferred debugging information
+ * that we may need later if we were to need to use the internal debugger.
+ * We don't fully process it here for performance reasons.
+ */
+int
+DEBUG_RegisterDebugInfo(int fd, struct pe_data * pe,
+ int load_addr, u_long v_addr, u_long size)
+{
+ int rtn = FALSE;
+ struct PE_Debug_dir * dbgptr;
+ struct deferred_debug_info * deefer;
+
+ dbgptr = (struct PE_Debug_dir *) (load_addr + v_addr);
+ for(; size > 0; size -= sizeof(*dbgptr), dbgptr++ )
+ {
+ switch(dbgptr->type)
+ {
+ case IMAGE_DEBUG_TYPE_COFF:
+ case IMAGE_DEBUG_TYPE_CODEVIEW:
+ case IMAGE_DEBUG_TYPE_MISC:
+ /*
+ * This is usually an indirection to a .DBG file.
+ * This is similar to (but a slightly older format) from the
+ * PDB file.
+ *
+ * First check to see if the image was 'stripped'. If so, it
+ * means that this entry points to a .DBG file. Otherwise,
+ * it just points to itself, and we can ignore this.
+ */
+ if( (dbgptr->type == IMAGE_DEBUG_TYPE_MISC)
+ && (pe->pe_header->coff.Characteristics & IMAGE_FILE_DEBUG_STRIPPED) == 0 )
+ {
+ break;
+ }
+
+ deefer = (struct deferred_debug_info *) xmalloc(sizeof(*deefer));
+ deefer->pe = pe;
+
+ deefer->dbg_info = NULL;
+ deefer->dbg_size = 0;
+
+ /*
+ * Read the important bits. What we do after this depends
+ * upon the type, but this is always enough so we are able
+ * to proceed if we know what we need to do next.
+ */
+ deefer->dbg_size = dbgptr->dbgsize;
+ deefer->dbg_info = (char *) xmalloc(dbgptr->dbgsize);
+ lseek(fd, dbgptr->dbgoff, SEEK_SET);
+ read(fd, deefer->dbg_info, deefer->dbg_size);
+
+ deefer->load_addr = (char *) load_addr;
+ deefer->dbgdir = dbgptr;
+ deefer->next = dbglist;
+ dbglist = deefer;
+ break;
+ default:
+ }
+ }
+
+ return (rtn);
+
+}
+
+/*
+ * Process COFF debugging information embedded in a Win32 application.
+ *
+ * FIXME - we need to process the source file information and the line
+ * numbers.
+ */
+static
+int
+DEBUG_ProcessCoff(struct deferred_debug_info * deefer)
+{
+ struct CoffAuxSection * aux;
+ struct CoffDebug * coff;
+ struct CoffSymbol * coff_sym;
+ struct CoffSymbol * coff_symbol;
+ struct CoffLinenum * coff_linetab;
+ char * coff_strtab;
+ int i;
+ DBG_ADDR new_addr;
+ int rtn = FALSE;
+ int naux;
+ char namebuff[9];
+ char * nampnt;
+ int nfiles = 0;
+ int nfiles_alloc = 0;
+ struct CoffFiles * coff_files = NULL;
+ struct CoffFiles * curr_file = NULL;
+ char * this_file;
+ int j;
+
+ coff = (struct CoffDebug *) deefer->dbg_info;
+
+ coff_symbol = (struct CoffSymbol *) ((unsigned int) coff + coff->SymbolOffset);
+ coff_linetab = (struct CoffLinenum *) ((unsigned int) coff + coff->LinenumberOffset);
+ coff_strtab = (char *) ((unsigned int) coff_symbol + 18*coff->N_Sym);
+
+ for(i=0; i < coff->N_Sym; i++ )
+ {
+ /*
+ * We do this because some compilers (i.e. gcc) incorrectly
+ * pad the structure up to a 4 byte boundary. The structure
+ * is really only 18 bytes long, so we have to manually make sure
+ * we get it right.
+ *
+ * FIXME - there must be a way to have autoconf figure out the
+ * correct compiler option for this. If it is always gcc, that
+ * makes life simpler, but I don't want to force this.
+ */
+ coff_sym = (struct CoffSymbol *) ((unsigned int) coff_symbol + 18*i);
+ naux = coff_sym->NumberOfAuxSymbols;
+
+ if( coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE )
+ {
+ if( nfiles + 1 >= nfiles_alloc )
+ {
+ nfiles_alloc += 10;
+ coff_files = (struct CoffFiles *) realloc( coff_files,
+ nfiles_alloc * sizeof(struct CoffFiles));
+ }
+ curr_file = coff_files + nfiles;
+ nfiles++;
+ curr_file->startaddr = 0xffffffff;
+ curr_file->endaddr = 0;
+ curr_file->filename = ((char *) coff_sym) + 18;
+ }
+
+ /*
+ * This guy marks the size and location of the text section
+ * for the current file. We need to keep track of this so
+ * we can figure out what file the different global functions
+ * go with.
+ */
+ if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
+ && (naux != 0)
+ && (coff_sym->SectionNumber == 1) )
+ {
+ aux = (struct CoffAuxSection *) ((unsigned int) coff_sym + 18);
+ if( curr_file->startaddr > coff_sym->Value )
+ {
+ curr_file->startaddr = coff_sym->Value;
+ }
+
+ if( curr_file->startaddr > coff_sym->Value )
+ {
+ curr_file->startaddr = coff_sym->Value;
+ }
+
+ if( curr_file->endaddr < coff_sym->Value + aux->Length )
+ {
+ curr_file->endaddr = coff_sym->Value + aux->Length;
+ }
+
+ }
+
+ if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
+ && (naux == 0)
+ && (coff_sym->SectionNumber == 1) )
+ {
+ /*
+ * This is a normal static function when naux == 0.
+ * Just register it. The current file is the correct
+ * one in this instance.
+ */
+ if( coff_sym->N.Name.NotLong )
+ {
+ memcpy(namebuff, coff_sym->N.ShortName, 8);
+ namebuff[8] = '\0';
+ nampnt = &namebuff[0];
+ }
+ else
+ {
+ nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
+ }
+
+ new_addr.seg = 0;
+ new_addr.off = (int) (deefer->load_addr + coff_sym->Value);
+ DEBUG_AddSymbol( nampnt, &new_addr, curr_file->filename );
+ }
+
+ if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
+ && ISFCN(coff_sym->Type)
+ && (coff_sym->SectionNumber > 0) )
+ {
+ if( coff_sym->N.Name.NotLong )
+ {
+ memcpy(namebuff, coff_sym->N.ShortName, 8);
+ namebuff[8] = '\0';
+ nampnt = &namebuff[0];
+ }
+ else
+ {
+ nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
+ }
+
+ new_addr.seg = 0;
+ new_addr.off = (int) (deefer->load_addr + coff_sym->Value);
+
+#if 0
+ fprintf(stderr, "%d: %x %s\n", i, new_addr.off, nampnt);
+#endif
+
+ /*
+ * Now we need to figure out which file this guy belongs to.
+ */
+ this_file = NULL;
+ for(j=0; j < nfiles; j++)
+ {
+ if( coff_files[j].startaddr <= coff_sym->Value
+ && coff_files[j].endaddr > coff_sym->Value )
+ {
+ this_file = coff_files[j].filename;
+ break;
+ }
+ }
+ DEBUG_AddSymbol( nampnt, &new_addr, this_file );
+ }
+
+ /*
+ * For now, skip past the aux entries.
+ */
+ i += naux;
+
+ }
+
+ rtn = TRUE;
+
+ if( coff_files != NULL )
+ {
+ free(coff_files);
+ }
+
+ return (rtn);
+
+}
+
+int
+DEBUG_ProcessDeferredDebug()
+{
+ struct deferred_debug_info * deefer;
+ struct CodeViewDebug * cvd;
+ struct MiscDebug * misc;
+
+ for(deefer = dbglist; deefer; deefer = deefer->next)
+ {
+ switch(deefer->dbgdir->type)
+ {
+ case IMAGE_DEBUG_TYPE_COFF:
+ /*
+ * Standard COFF debug information that VC++ adds when you
+ * use /debugtype:both with the linker.
+ */
+#if 0
+ fprintf(stderr, "Processing COFF symbols...\n");
+#endif
+ DEBUG_ProcessCoff(deefer);
+ break;
+ case IMAGE_DEBUG_TYPE_CODEVIEW:
+ /*
+ * This is a pointer to a PDB file of some sort.
+ */
+ cvd = (struct CodeViewDebug *) deefer->dbg_info;
+#if 0
+ fprintf(stderr, "Processing PDB file %s\n", cvd->cv_name);
+#endif
+ break;
+ case IMAGE_DEBUG_TYPE_MISC:
+ /*
+ * A pointer to a .DBG file of some sort.
+ */
+ misc = (struct MiscDebug *) deefer->dbg_info;
+#if 0
+ fprintf(stderr, "Processing DBG file %s\n", misc->Data);
+#endif
+ break;
+ default:
+ /*
+ * We should never get here...
+ */
+ break;
+ }
+ }
+ return TRUE;
+}
diff --git a/debugger/registers.c b/debugger/registers.c
index 4545d78..3fc5422 100644
--- a/debugger/registers.c
+++ b/debugger/registers.c
@@ -46,14 +46,14 @@
case REG_FS: FS_reg(DEBUG_context) = val; break;
#else
case REG_FS:
- fprintf( stderr, "Register %fs not supported on this system\n" );
+ fprintf( stderr, "Register %%fs not supported on this system\n" );
break;
#endif
#ifdef GS_reg
case REG_GS: GS_reg(DEBUG_context) = val; break;
#else
case REG_GS:
- fprintf( stderr, "Register %gs not supported on this system\n" );
+ fprintf( stderr, "Register %%gs not supported on this system\n" );
break;
#endif
}
@@ -97,14 +97,14 @@
case REG_FS: return FS_reg(DEBUG_context);
#else
case REG_FS:
- fprintf( stderr, "Register %fs not supported on this system\n" );
+ fprintf( stderr, "Register %%fs not supported on this system\n" );
return 0;
#endif
#ifdef GS_reg
case REG_GS: return GS_reg(DEBUG_context);
#else
case REG_GS:
- fprintf( stderr, "Register %gs not supported on this system\n" );
+ fprintf( stderr, "Register %%gs not supported on this system\n" );
return 0;
#endif
}
diff --git a/debugger/stabs.c b/debugger/stabs.c
new file mode 100644
index 0000000..2c238be
--- /dev/null
+++ b/debugger/stabs.c
@@ -0,0 +1,375 @@
+/*
+ * File stabs.c - read stabs information from the wine executable itself.
+ *
+ * Copyright (C) 1996, Eric Youngdale.
+ */
+
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <limits.h>
+#include <stdio.h>
+#include <strings.h>
+#include <unistd.h>
+
+#include "win.h"
+#include "debugger.h"
+
+#ifdef __ELF__
+#include <elf.h>
+#endif
+
+#define N_UNDF 0x00
+#define N_GSYM 0x20
+#define N_FUN 0x24
+#define N_STSYM 0x26
+#define N_LCSYM 0x28
+#define N_MAIN 0x2a
+#define N_ROSYM 0x2c
+#define N_OPT 0x3c
+#define N_RSYM 0x40
+#define N_SLINE 0x44
+#define N_SO 0x64
+#define N_LSYM 0x80
+#define N_BINCL 0x82
+#define N_SOL 0x84
+#define N_PSYM 0xa0
+#define N_EINCL 0xa2
+#define N_LBRAC 0xc0
+#define N_RBRAC 0xe0
+
+
+/*
+ * Set so that we know the main executable name and path.
+ */
+char * DEBUG_argv0;
+
+struct stab_nlist {
+ union {
+ char *n_name;
+ struct stab_nlist *n_next;
+ long n_strx;
+ } n_un;
+ unsigned char n_type;
+ char n_other;
+ short n_desc;
+ unsigned long n_value;
+};
+
+#ifdef __ELF__
+
+int
+DEBUG_ParseStabs(char * addr, Elf32_Shdr * stabsect, Elf32_Shdr * stabstr)
+{
+ int i;
+ int ignore = FALSE;
+ int nstab;
+ struct stab_nlist * stab_ptr;
+ char * strs;
+ char * ptr;
+ char * xptr;
+ char currpath[PATH_MAX];
+ char symname[4096];
+ char * subpath = NULL;
+ DBG_ADDR new_addr;
+ struct name_hash * curr_func = NULL;
+ int strtabinc;
+
+ nstab = stabsect->sh_size / sizeof(struct stab_nlist);
+ stab_ptr = (struct stab_nlist *) (addr + stabsect->sh_offset);
+ strs = (char *) (addr + stabstr->sh_offset);
+
+ memset(currpath, 0, sizeof(currpath));
+
+ strtabinc = 0;
+ for(i=0; i < nstab; i++, stab_ptr++ )
+ {
+ ptr = strs + (unsigned int) stab_ptr->n_un.n_name;
+ switch(stab_ptr->n_type)
+ {
+ case N_GSYM:
+ /*
+ * These are useless. They have no value, and you have to
+ * read the normal symbol table to get the address. Thus we
+ * ignore them, and when we process the normal symbol table
+ * we should do the right thing.
+ */
+ case N_RBRAC:
+ case N_LBRAC:
+ /*
+ * We need to keep track of these so we get symbol scoping
+ * right for local variables. For now, we just ignore them.
+ * The hooks are already there for dealing with this however,
+ * so all we need to do is to keep count of the nesting level,
+ * and find the RBRAC for each matching LBRAC.
+ */
+ break;
+ case N_LCSYM:
+ case N_STSYM:
+ /*
+ * These are static symbols and BSS symbols.
+ */
+ new_addr.seg = 0;
+ new_addr.off = stab_ptr->n_value;
+
+ strcpy(symname, ptr);
+ xptr = strchr(symname, ':');
+ if( xptr != NULL )
+ {
+ *xptr = '\0';
+ }
+ DEBUG_AddSymbol( symname, &new_addr, currpath );
+ break;
+ case N_PSYM:
+ /*
+ * These are function parameters.
+ */
+ if( (curr_func != NULL)
+ && (stab_ptr->n_value != 0) )
+ {
+ strcpy(symname, ptr);
+ xptr = strchr(symname, ':');
+ if( xptr != NULL )
+ {
+ *xptr = '\0';
+ }
+ DEBUG_AddLocal(curr_func, 0,
+ stab_ptr->n_value, 0, 0, symname);
+ }
+ break;
+ case N_RSYM:
+ if( curr_func != NULL )
+ {
+ strcpy(symname, ptr);
+ xptr = strchr(symname, ':');
+ if( xptr != NULL )
+ {
+ *xptr = '\0';
+ }
+ DEBUG_AddLocal(curr_func, stab_ptr->n_value, 0, 0, 0, symname);
+ }
+ break;
+ case N_LSYM:
+ if( (curr_func != NULL)
+ && (stab_ptr->n_value != 0) )
+ {
+ strcpy(symname, ptr);
+ xptr = strchr(symname, ':');
+ if( xptr != NULL )
+ {
+ *xptr = '\0';
+ }
+ DEBUG_AddLocal(curr_func, 0,
+ stab_ptr->n_value, 0, 0, symname);
+ }
+ break;
+ case N_SLINE:
+ /*
+ * This is a line number. These are always relative to the start
+ * of the function (N_FUN), and this makes the lookup easier.
+ */
+ if( curr_func != NULL )
+ {
+ DEBUG_AddLineNumber(curr_func, stab_ptr->n_desc,
+ stab_ptr->n_value);
+ }
+ break;
+ case N_FUN:
+ /*
+ * For now, just declare the various functions. Later
+ * on, we will add the line number information and the
+ * local symbols.
+ */
+ if( !ignore )
+ {
+ new_addr.seg = 0;
+ new_addr.off = stab_ptr->n_value;
+ /*
+ * Copy the string to a temp buffer so we
+ * can kill everything after the ':'. We do
+ * it this way because otherwise we end up dirtying
+ * all of the pages related to the stabs, and that
+ * sucks up swap space like crazy.
+ */
+ strcpy(symname, ptr);
+ xptr = strchr(symname, ':');
+ if( xptr != NULL )
+ {
+ *xptr = '\0';
+ }
+ curr_func = DEBUG_AddSymbol( symname, &new_addr, currpath );
+ }
+ else
+ {
+ /*
+ * Don't add line number information for this function
+ * any more.
+ */
+ curr_func = NULL;
+ }
+ break;
+ case N_SO:
+ /*
+ * This indicates a new source file. Append the records
+ * together, to build the correct path name.
+ */
+ if( *ptr == '\0' )
+ {
+ /*
+ * Nuke old path.
+ */
+ currpath[0] = '\0';
+ curr_func = NULL;
+ }
+ else
+ {
+ strcat(currpath, ptr);
+ subpath = ptr;
+ }
+ break;
+ case N_SOL:
+ /*
+ * This indicates we are including stuff from an include file.
+ * If this is the main source, enable the debug stuff, otherwise
+ * ignore it.
+ */
+ if( subpath == NULL || strcmp(ptr, subpath) == 0 )
+ {
+ ignore = FALSE;
+ }
+ else
+ {
+ ignore = TRUE;
+ curr_func = NULL;
+ }
+ break;
+ case N_UNDF:
+ strs += strtabinc;
+ strtabinc = stab_ptr->n_value;
+ curr_func = NULL;
+ break;
+ case N_OPT:
+ /*
+ * Ignore this. We don't care what it points to.
+ */
+ break;
+ case N_BINCL:
+ case N_EINCL:
+ case N_MAIN:
+ /*
+ * Always ignore these. GCC doesn't even generate them.
+ */
+ break;
+ default:
+ break;
+ }
+#if 0
+ fprintf(stderr, "%d %x %s\n", stab_ptr->n_type,
+ (unsigned int) stab_ptr->n_value,
+ strs + (unsigned int) stab_ptr->n_un.n_name);
+#endif
+ }
+ return TRUE;
+}
+
+int
+DEBUG_ReadExecutableDbgInfo(void)
+{
+ int rtn = FALSE;
+ char * exe_name;
+ struct stat statbuf;
+ int fd = -1;
+ int status;
+ char * addr = (char *) 0xffffffff;
+ Elf32_Ehdr * ehptr;
+ Elf32_Shdr * spnt;
+ char * shstrtab;
+ int nsect;
+ int i;
+ int stabsect;
+ int stabstrsect;
+
+ exe_name = DEBUG_argv0;
+
+ /*
+ * Make sure we can stat and open this file.
+ */
+ if( exe_name == NULL )
+ {
+ goto leave;
+ }
+
+ status = stat(exe_name, &statbuf);
+ if( status == -1 )
+ {
+ goto leave;
+ }
+
+ /*
+ * Now open the file, so that we can mmap() it.
+ */
+ fd = open(exe_name, O_RDONLY);
+ if( fd == -1 )
+ {
+ goto leave;
+ }
+
+
+ /*
+ * Now mmap() the file.
+ */
+ addr = mmap(0, statbuf.st_size, PROT_READ,
+ MAP_PRIVATE, fd, 0);
+
+ /*
+ * Next, we need to find a few of the internal ELF headers within
+ * this thing. We need the main executable header, and the section
+ * table.
+ */
+ ehptr = (Elf32_Ehdr *) addr;
+ spnt = (Elf32_Shdr *) (addr + ehptr->e_shoff);
+ nsect = ehptr->e_shnum;
+ shstrtab = (addr + spnt[ehptr->e_shstrndx].sh_offset);
+
+ stabsect = stabstrsect = -1;
+
+ for(i=0; i < nsect; i++)
+ {
+ if( strcmp(shstrtab + spnt[i].sh_name, ".stab") == 0 )
+ {
+ stabsect = i;
+ }
+
+ if( strcmp(shstrtab + spnt[i].sh_name, ".stabstr") == 0 )
+ {
+ stabstrsect = i;
+ }
+ }
+
+ if( stabsect == -1 || stabstrsect == -1 )
+ {
+ goto leave;
+ }
+
+ /*
+ * OK, now just parse all of the stabs.
+ */
+ rtn = DEBUG_ParseStabs(addr, spnt + stabsect, spnt + stabstrsect);
+
+leave:
+
+ if( addr != (char *) 0xffffffff )
+ {
+ munmap(addr, statbuf.st_size);
+ }
+
+ if( fd != -1 )
+ {
+ close(fd);
+ }
+
+ return (rtn);
+
+}
+
+#endif /* __ELF__ */
diff --git a/debugger/stack.c b/debugger/stack.c
index bbf9033..9ac2ea2 100644
--- a/debugger/stack.c
+++ b/debugger/stack.c
@@ -2,13 +2,35 @@
* Debugger stack handling
*
* Copyright 1995 Alexandre Julliard
+ * Copyright 1996 Eric Youngdale
*/
#include <stdio.h>
+#include <malloc.h>
+#include "xmalloc.h"
#include "windows.h"
#include "debugger.h"
+/*
+ * We keep this info for each frame, so that we can
+ * find local variable information correctly.
+ */
+struct bt_info
+{
+ unsigned int eip;
+ unsigned int ebp;
+ struct name_hash * frame;
+};
+
+static int nframe;
+static struct bt_info * frames = NULL;
+int curr_frame;
+static char * reg_name[] =
+{
+ "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"
+};
+
typedef struct
{
WORD bp;
@@ -66,19 +88,45 @@
if (SS_reg(DEBUG_context) == WINE_DATA_SELECTOR) /* 32-bit mode */
{
addr.seg = 0;
- fprintf(stderr,"%d ",frameno++);
- addr.off = EIP_reg(DEBUG_context);
- DEBUG_PrintAddress( &addr, 32 );
- fprintf( stderr, "\n" );
addr.off = EBP_reg(DEBUG_context);
+ nframe = 1;
while (addr.off)
{
FRAME32 *frame = (FRAME32 *)addr.off;
if (!DBG_CHECK_READ_PTR( &addr, sizeof(FRAME32) )) return;
if (!frame->ip) break;
- fprintf(stderr,"%d ",frameno++);
+ addr.off = frame->bp;
+ nframe++;
+ }
+ if( frames != NULL )
+ {
+ free(frames);
+ }
+
+ frames = (struct bt_info *) xmalloc(nframe
+ * sizeof(struct bt_info) );
+ fprintf(stderr,"%s%d ",(curr_frame == 0 ? "=>" : " "), frameno++);
+ addr.off = EIP_reg(DEBUG_context);
+ frames[0].eip = addr.off;
+ frames[0].frame = DEBUG_PrintAddress( &addr, 32, TRUE );
+ fprintf( stderr, "\n" );
+ addr.off = EBP_reg(DEBUG_context);
+
+ frames[0].ebp = addr.off;
+
+ while (addr.off)
+ {
+ FRAME32 *frame = (FRAME32 *)addr.off;
+ if (!DBG_CHECK_READ_PTR( &addr, sizeof(FRAME32) )) return;
+ if (!frame->ip) break;
+ fprintf(stderr,"%s%d ", (frameno == curr_frame ? "=>" : " "),
+ frameno);
addr.off = frame->ip;
- DEBUG_PrintAddress( &addr, 32 );
+ frames[frameno].eip = addr.off;
+ frames[frameno].ebp = frame->bp;
+ frames[frameno].frame = DEBUG_PrintAddressAndArgs( &addr, 32,
+ frame->bp, TRUE );
+ frameno++;
fprintf( stderr, "\n" );
addr.off = frame->bp;
}
@@ -94,7 +142,7 @@
fprintf( stderr,"%d ", frameno++ );
addr.seg = cs;
addr.off = IP_reg(DEBUG_context);
- DEBUG_PrintAddress( &addr, 16 );
+ DEBUG_PrintAddress( &addr, 16, TRUE );
fprintf( stderr, "\n" );
addr.seg = ss;
addr.off = BP_reg(DEBUG_context) & ~1;
@@ -107,7 +155,7 @@
fprintf( stderr,"%d ", frameno++ );
addr.seg = cs;
addr.off = frame->ip;
- DEBUG_PrintAddress( &addr, 16 );
+ DEBUG_PrintAddress( &addr, 16, TRUE );
fprintf( stderr, "\n" );
addr.seg = ss;
addr.off = frame->bp & ~1;
@@ -115,3 +163,166 @@
}
fprintf( stderr, "\n" );
}
+
+/***********************************************************************
+ * DEBUG_GetSymbolValue
+ *
+ * Get the address of a named symbol from the current stack frame.
+ */
+BOOL32 DEBUG_GetStackSymbolValue( const char * name, DBG_ADDR *addr )
+{
+ struct name_hash * curr_func;
+ int i;
+
+ /*
+ * If we don't have a valid backtrace, then just return.
+ */
+ if( frames == NULL )
+ {
+ return FALSE;
+ }
+
+ curr_func = frames[curr_frame].frame;
+
+ /*
+ * If we don't know what the current function is, then we also have
+ * nothing to report here.
+ */
+ if( curr_func == NULL )
+ {
+ return FALSE;
+ }
+
+ for(i=0; i < curr_func->n_locals; i++ )
+ {
+ /*
+ * Test the range of validity of the local variable. This
+ * comes up with RBRAC/LBRAC stabs in particular.
+ */
+ if( (curr_func->local_vars[i].pc_start != 0)
+ && ((frames[curr_frame].eip - curr_func->addr.off)
+ < curr_func->local_vars[i].pc_start) )
+ {
+ continue;
+ }
+
+ if( (curr_func->local_vars[i].pc_end != 0)
+ && ((frames[curr_frame].eip - curr_func->addr.off)
+ > curr_func->local_vars[i].pc_end) )
+ {
+ continue;
+ }
+
+ if( strcmp(name, curr_func->local_vars[i].name) == 0 )
+ {
+ /*
+ * OK, we found it. Now figure out what to do with this.
+ */
+ if( curr_func->local_vars[i].regno != 0 )
+ {
+ /*
+ * Register variable. We don't know how to treat
+ * this yet.
+ */
+ return FALSE;
+ }
+
+ addr->seg = 0;
+ addr->off = frames[curr_frame].ebp + curr_func->local_vars[i].offset;
+
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+int
+DEBUG_SetFrame(int newframe)
+{
+ int rtn = FALSE;
+ /*
+ * Nothing for now. Add support later.
+ */
+
+ curr_frame = newframe;
+ if( curr_frame < 0 )
+ {
+ curr_frame = 0;
+ }
+
+ if( curr_frame >= nframe )
+ {
+ curr_frame = nframe - 1;
+ }
+
+ rtn = TRUE;
+ return (rtn);
+}
+
+int
+DEBUG_InfoLocals()
+{
+ struct name_hash * curr_func;
+ int i;
+ int rtn = FALSE;
+ unsigned int * ptr;
+
+ /*
+ * If we don't have a valid backtrace, then just return.
+ */
+ if( frames == NULL )
+ {
+ return FALSE;
+ }
+
+ curr_func = frames[curr_frame].frame;
+
+ /*
+ * If we don't know what the current function is, then we also have
+ * nothing to report here.
+ */
+ if( curr_func == NULL )
+ {
+ return FALSE;
+ }
+
+ for(i=0; i < curr_func->n_locals; i++ )
+ {
+ /*
+ * Test the range of validity of the local variable. This
+ * comes up with RBRAC/LBRAC stabs in particular.
+ */
+ if( (curr_func->local_vars[i].pc_start != 0)
+ && ((frames[curr_frame].eip - curr_func->addr.off)
+ < curr_func->local_vars[i].pc_start) )
+ {
+ continue;
+ }
+
+ if( (curr_func->local_vars[i].pc_end != 0)
+ && ((frames[curr_frame].eip - curr_func->addr.off)
+ > curr_func->local_vars[i].pc_end) )
+ {
+ continue;
+ }
+
+ if( curr_func->local_vars[i].offset == 0 )
+ {
+ fprintf(stderr, "%s:%s optimized into register $%s \n",
+ curr_func->name, curr_func->local_vars[i].name,
+ reg_name[curr_func->local_vars[i].regno]);
+ }
+ else
+ {
+ ptr = (unsigned int *) (frames[curr_frame].ebp
+ + curr_func->local_vars[i].offset);
+ fprintf(stderr, "%s:%s == 0x%8.8x\n",
+ curr_func->name, curr_func->local_vars[i].name,
+ *ptr);
+ }
+ }
+
+ rtn = TRUE;
+
+ return (rtn);
+}
diff --git a/files/dos_fs.c b/files/dos_fs.c
index 237139e..6ce5881 100644
--- a/files/dos_fs.c
+++ b/files/dos_fs.c
@@ -21,11 +21,11 @@
#include "dos_fs.h"
#include "drive.h"
#include "file.h"
+#include "heap.h"
#include "msdos.h"
#include "stddebug.h"
#include "debug.h"
#include "xmalloc.h"
-#include "string32.h"
/* Chars we don't want to see in DOS file names */
#define INVALID_DOS_CHARS "*?<>|\"+=,;[] \345"
@@ -877,9 +877,9 @@
*/
DWORD GetShortPathName32W( LPCWSTR longpath, LPWSTR shortpath, DWORD shortlen )
{
- LPSTR longpatha = STRING32_DupUniToAnsi( longpath );
+ LPSTR longpatha = HEAP_strdupWtoA( GetProcessHeap(), 0, longpath );
LPCSTR dostruename = DOSFS_GetDosTrueName( longpatha, TRUE );
- free( longpatha );
+ HeapFree( GetProcessHeap(), 0, longpatha );
lstrcpynAtoW( shortpath, dostruename, shortlen );
return strlen(dostruename);
}
diff --git a/files/drive.c b/files/drive.c
index 74b3672..522518c 100644
--- a/files/drive.c
+++ b/files/drive.c
@@ -28,11 +28,11 @@
#include "dos_fs.h"
#include "drive.h"
#include "file.h"
+#include "heap.h"
#include "msdos.h"
#include "options.h"
#include "task.h"
#include "xmalloc.h"
-#include "string32.h"
#include "stddebug.h"
#include "debug.h"
@@ -529,7 +529,7 @@
/***********************************************************************
- * GetDiskFreeSpaceA (KERNEL32.206)
+ * GetDiskFreeSpace32A (KERNEL32.206)
*/
BOOL32 GetDiskFreeSpace32A( LPCSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
@@ -562,7 +562,7 @@
/***********************************************************************
- * GetDiskFreeSpaceW (KERNEL32.207)
+ * GetDiskFreeSpace32W (KERNEL32.207)
*/
BOOL32 GetDiskFreeSpace32W( LPCWSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
@@ -571,10 +571,10 @@
LPSTR xroot;
BOOL ret;
- xroot = STRING32_DupUniToAnsi(root);
+ xroot = HEAP_strdupWtoA( GetProcessHeap(), 0, root);
ret = GetDiskFreeSpace32A( xroot,cluster_sectors, sector_bytes,
free_clusters, total_clusters );
- free( xroot );
+ HeapFree( GetProcessHeap(), 0, xroot );
return ret;
}
@@ -625,11 +625,9 @@
*/
UINT32 GetDriveType32W( LPCWSTR root )
{
- LPSTR xpath=STRING32_DupUniToAnsi(root);
- UINT32 ret;
-
- ret = GetDriveType32A(xpath);
- free(xpath);
+ LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, root );
+ UINT32 ret = GetDriveType32A( xpath );
+ HeapFree( GetProcessHeap(), 0, xpath );
return ret;
}
@@ -669,12 +667,10 @@
*/
UINT32 GetCurrentDirectory32W( UINT32 buflen, LPWSTR buf )
{
- LPSTR xpath=(char*)xmalloc(buflen+1);
- UINT32 ret;
-
- ret = GetCurrentDirectory32A(buflen,xpath);
- STRING32_AnsiToUni(buf,xpath);
- free(xpath);
+ LPSTR xpath = HeapAlloc( GetProcessHeap(), 0, buflen+1 );
+ UINT32 ret = GetCurrentDirectory32A( buflen, xpath );
+ lstrcpyAtoW( buf, xpath );
+ HeapFree( GetProcessHeap(), 0, xpath );
return ret;
}
@@ -715,10 +711,9 @@
*/
BOOL32 SetCurrentDirectory32W( LPCWSTR dirW)
{
- LPSTR dir = STRING32_DupUniToAnsi(dirW);
- BOOL32 res = SetCurrentDirectory32A(dir);
-
- free(dir);
+ LPSTR dir = HEAP_strdupWtoA( GetProcessHeap(), 0, dirW );
+ BOOL32 res = SetCurrentDirectory32A( dir );
+ HeapFree( GetProcessHeap(), 0, dir );
return res;
}
@@ -831,19 +826,19 @@
DWORD *serial, DWORD *filename_len,
DWORD *flags, LPWSTR fsname, DWORD fsname_len)
{
- LPSTR xroot = root?STRING32_DupUniToAnsi(root):NULL;
- LPSTR xvolname = label?(char*)xmalloc( label_len ):NULL;
- LPSTR xfsname = fsname?(char*)xmalloc( fsname_len ):NULL;
+ LPSTR xroot = HEAP_strdupWtoA( GetProcessHeap(), 0, root );
+ LPSTR xvolname = label ? HeapAlloc(GetProcessHeap(),0,label_len) : NULL;
+ LPSTR xfsname = fsname ? HeapAlloc(GetProcessHeap(),0,fsname_len) : NULL;
BOOL32 ret = GetVolumeInformation32A( xroot, xvolname, label_len, serial,
filename_len, flags, xfsname,
fsname_len );
if (ret)
{
- if (label) STRING32_AnsiToUni( label, xvolname );
- if (fsname) STRING32_AnsiToUni( fsname, xfsname );
+ if (label) lstrcpyAtoW( label, xvolname );
+ if (fsname) lstrcpyAtoW( fsname, xfsname );
}
- if (xroot) free(xroot);
- if (xvolname) free(xvolname);
- if (xfsname) free(xfsname);
+ HeapFree( GetProcessHeap(), 0, xroot );
+ HeapFree( GetProcessHeap(), 0, xvolname );
+ HeapFree( GetProcessHeap(), 0, xfsname );
return ret;
}
diff --git a/files/file.c b/files/file.c
index fa3177e..5f41ecf 100644
--- a/files/file.c
+++ b/files/file.c
@@ -23,11 +23,11 @@
#include "dos_fs.h"
#include "drive.h"
#include "global.h"
+#include "heap.h"
#include "msdos.h"
#include "options.h"
#include "ldt.h"
#include "task.h"
-#include "string32.h"
#include "stddebug.h"
#include "debug.h"
#include "xmalloc.h"
@@ -630,12 +630,12 @@
UINT32 ret;
if (!path) return 0;
- patha = STRING32_DupUniToAnsi(path);
- prefixa = STRING32_DupUniToAnsi(prefix);
- ret = GetTempFileName32A( patha, prefixa, unique, buffera );
- STRING32_AnsiToUni( buffer, buffera );
- free(patha);
- free(prefixa);
+ patha = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
+ prefixa = HEAP_strdupWtoA( GetProcessHeap(), 0, prefix );
+ ret = GetTempFileName32A( patha, prefixa, unique, buffera );
+ lstrcpyAtoW( buffer, buffera );
+ HeapFree( GetProcessHeap(), 0, patha );
+ HeapFree( GetProcessHeap(), 0, prefixa );
return ret;
}
@@ -921,29 +921,27 @@
/***********************************************************************
* SearchPath32W (KERNEL32.448)
*/
-DWORD SearchPath32W(
- LPCWSTR path,LPCWSTR fn,LPCWSTR ext,DWORD buflen,LPWSTR buf,
- LPWSTR *lastpart
-) {
- LPSTR pathA = path?STRING32_DupUniToAnsi(path):NULL;
- LPSTR fnA = STRING32_DupUniToAnsi(fn);
- LPSTR extA = ext?STRING32_DupUniToAnsi(fn):NULL;
+DWORD SearchPath32W( LPCWSTR path, LPCWSTR fn, LPCWSTR ext, DWORD buflen,
+ LPWSTR buf, LPWSTR *lastpart )
+{
+ LPSTR pathA = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
+ LPSTR fnA = HEAP_strdupWtoA( GetProcessHeap(), 0, fn );
+ LPSTR extA = HEAP_strdupWtoA( GetProcessHeap(), 0, ext );
LPSTR lastpartA;
- LPSTR bufA = (char*)xmalloc(buflen+1);
+ LPSTR bufA = HeapAlloc( GetProcessHeap(), 0, buflen + 1 );
DWORD ret;
- ret=SearchPath32A(pathA,fnA,extA,buflen,bufA,&lastpartA);
- lstrcpynAtoW(buf,bufA,buflen);
- if (lastpart) {
- if (lastpartA)
- *lastpart = buf+(lastpartA-bufA);
- else
- *lastpart = NULL;
+ ret = SearchPath32A(pathA,fnA,extA,buflen,bufA,&lastpartA);
+ lstrcpyAtoW( buf, bufA );
+ if (lastpart)
+ {
+ if (lastpartA) *lastpart = buf+(lastpartA-bufA);
+ else *lastpart = NULL;
}
- free(bufA);
- free(fnA);
- if (pathA) free(pathA);
- if (extA) free(extA);
+ HeapFree( GetProcessHeap(), 0, bufA );
+ HeapFree( GetProcessHeap(), 0, fnA );
+ HeapFree( GetProcessHeap(), 0, pathA );
+ HeapFree( GetProcessHeap(), 0, extA );
return ret;
}
@@ -1282,9 +1280,9 @@
*/
BOOL32 DeleteFile32W( LPCWSTR path )
{
- LPSTR xpath = STRING32_DupUniToAnsi(path);
+ LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
BOOL32 ret = RemoveDirectory32A( xpath );
- free(xpath);
+ HeapFree( GetProcessHeap(), 0, xpath );
return ret;
}
@@ -1328,9 +1326,9 @@
*/
BOOL32 CreateDirectory32W( LPCWSTR path, LPSECURITY_ATTRIBUTES lpsecattribs )
{
- LPSTR xpath = STRING32_DupUniToAnsi(path);
- BOOL32 ret = CreateDirectory32A(xpath,lpsecattribs);
- free(xpath);
+ LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
+ BOOL32 ret = CreateDirectory32A( xpath, lpsecattribs );
+ HeapFree( GetProcessHeap(), 0, xpath );
return ret;
}
@@ -1391,9 +1389,9 @@
*/
BOOL32 RemoveDirectory32W( LPCWSTR path )
{
- LPSTR xpath = STRING32_DupUniToAnsi(path);
+ LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
BOOL32 ret = RemoveDirectory32A( xpath );
- free(xpath);
+ HeapFree( GetProcessHeap(), 0, xpath );
return ret;
}
diff --git a/files/profile.c b/files/profile.c
index 8b6bf27..2f08849 100644
--- a/files/profile.c
+++ b/files/profile.c
@@ -13,8 +13,8 @@
#include "windows.h"
#include "dos_fs.h"
+#include "heap.h"
#include "xmalloc.h"
-#include "string32.h"
#include "stddebug.h"
#include "debug.h"
@@ -649,7 +649,7 @@
*/
UINT32 GetProfileInt32W( LPCWSTR section, LPCWSTR entry, INT32 def_val )
{
- if (!wininiW) wininiW = STRING32_DupAnsiToUni("win.ini");
+ if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini" );
return GetPrivateProfileInt32W( section, entry, def_val, wininiW );
}
@@ -679,7 +679,7 @@
INT32 GetProfileString32W( LPCWSTR section,LPCWSTR entry,LPCWSTR def_val,
LPWSTR buffer, INT32 len )
{
- if (!wininiW) wininiW = STRING32_DupAnsiToUni("win.ini");
+ if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini" );
return GetPrivateProfileString32W( section, entry, def_val,
buffer, len, wininiW );
}
@@ -706,7 +706,7 @@
*/
BOOL32 WriteProfileString32W( LPCWSTR section, LPCWSTR entry, LPCWSTR string )
{
- if (!wininiW) wininiW = STRING32_DupAnsiToUni("win.ini");
+ if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini" );
return WritePrivateProfileString32W( section, entry, string, wininiW );
}
@@ -749,15 +749,13 @@
UINT32 GetPrivateProfileInt32W( LPCWSTR section, LPCWSTR entry, INT32 def_val,
LPCWSTR filename )
{
- LPSTR sectionA=section?STRING32_DupUniToAnsi(section):NULL;
- LPSTR entryA=entry?STRING32_DupUniToAnsi(entry):NULL;
- LPSTR filenameA=filename?STRING32_DupUniToAnsi(filename):NULL;
- UINT32 res;
-
- res=GetPrivateProfileInt32A(sectionA,entryA,def_val,filenameA);
- if (sectionA) free(sectionA);
- if (filenameA) free(filenameA);
- if (entryA) free(entryA);
+ LPSTR sectionA = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
+ LPSTR entryA = HEAP_strdupWtoA( GetProcessHeap(), 0, entry );
+ LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
+ UINT32 res = GetPrivateProfileInt32A(sectionA, entryA, def_val, filenameA);
+ HeapFree( GetProcessHeap(), 0, sectionA );
+ HeapFree( GetProcessHeap(), 0, filenameA );
+ HeapFree( GetProcessHeap(), 0, entryA );
return res;
}
@@ -785,24 +783,23 @@
/***********************************************************************
* GetPrivateProfileString32W (KERNEL32.256)
*/
-INT32 GetPrivateProfileString32W( LPCWSTR section,LPCWSTR entry,LPCWSTR def_val,
- LPWSTR buffer,INT32 len,LPCWSTR filename )
+INT32 GetPrivateProfileString32W( LPCWSTR section, LPCWSTR entry,
+ LPCWSTR def_val, LPWSTR buffer,
+ INT32 len, LPCWSTR filename )
{
- LPSTR sectionA = section?STRING32_DupUniToAnsi(section):NULL;
- LPSTR entryA = entry?STRING32_DupUniToAnsi(entry):NULL;
- LPSTR filenameA = filename?STRING32_DupUniToAnsi(filename):NULL;
- LPSTR def_valA = def_val?STRING32_DupUniToAnsi(def_val):NULL;
- LPSTR bufferA = xmalloc(len);
- INT32 ret;
-
- ret=GetPrivateProfileString32A(sectionA,entryA,def_valA,bufferA,len,filenameA);
- if (sectionA) free(sectionA);
- if (entryA) free(entryA);
- if (filenameA) free(filenameA);
- if (def_valA) free(def_valA);
-
+ LPSTR sectionA = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
+ LPSTR entryA = HEAP_strdupWtoA( GetProcessHeap(), 0, entry );
+ LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
+ LPSTR def_valA = HEAP_strdupWtoA( GetProcessHeap(), 0, def_val );
+ LPSTR bufferA = HeapAlloc( GetProcessHeap(), 0, len );
+ INT32 ret = GetPrivateProfileString32A( sectionA, entryA, def_valA,
+ bufferA, len, filenameA );
lstrcpynAtoW( buffer, bufferA, len );
- free(bufferA);
+ HeapFree( GetProcessHeap(), 0, sectionA );
+ HeapFree( GetProcessHeap(), 0, entryA );
+ HeapFree( GetProcessHeap(), 0, filenameA );
+ HeapFree( GetProcessHeap(), 0, def_valA );
+ HeapFree( GetProcessHeap(), 0, bufferA);
return ret;
}
@@ -831,21 +828,19 @@
/***********************************************************************
* WritePrivateProfileString32W (KERNEL32.583)
*/
-BOOL32 WritePrivateProfileString32W(LPCWSTR section,LPCWSTR entry,LPCWSTR string,
- LPCWSTR filename )
+BOOL32 WritePrivateProfileString32W( LPCWSTR section, LPCWSTR entry,
+ LPCWSTR string, LPCWSTR filename )
{
- LPSTR sectionA = section?STRING32_DupUniToAnsi(section):NULL;
- LPSTR entryA = entry?STRING32_DupUniToAnsi(entry):NULL;
- LPSTR stringA = string?STRING32_DupUniToAnsi(string):NULL;
- LPSTR filenameA = filename?STRING32_DupUniToAnsi(filename):NULL;
- BOOL32 res;
-
- res = WritePrivateProfileString32A(sectionA,entryA,stringA,filenameA);
-
- if (sectionA) free(sectionA);
- if (entryA) free(entryA);
- if (stringA) free(stringA);
- if (filenameA) free(filenameA);
+ LPSTR sectionA = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
+ LPSTR entryA = HEAP_strdupWtoA( GetProcessHeap(), 0, entry );
+ LPSTR stringA = HEAP_strdupWtoA( GetProcessHeap(), 0, string );
+ LPSTR filenameA = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
+ BOOL32 res = WritePrivateProfileString32A( sectionA, entryA,
+ stringA, filenameA );
+ HeapFree( GetProcessHeap(), 0, sectionA );
+ HeapFree( GetProcessHeap(), 0, entryA );
+ HeapFree( GetProcessHeap(), 0, stringA );
+ HeapFree( GetProcessHeap(), 0, filenameA );
return res;
}
diff --git a/graphics/Makefile.in b/graphics/Makefile.in
index 0db59ed..5339596 100644
--- a/graphics/Makefile.in
+++ b/graphics/Makefile.in
@@ -8,6 +8,7 @@
C_SRCS = \
bitblt.c \
driver.c \
+ mapping.c \
wing.c
all: $(MODULE).o
diff --git a/graphics/bitblt.c b/graphics/bitblt.c
index 2acda69..eda13f4 100644
--- a/graphics/bitblt.c
+++ b/graphics/bitblt.c
@@ -4,7 +4,7 @@
* Copyright 1993, 1994 Alexandre Julliard
*/
-#include "gdi.h"
+#include "dc.h"
#include "stddebug.h"
#include "debug.h"
@@ -15,7 +15,7 @@
BOOL16 PatBlt16( HDC16 hdc, INT16 left, INT16 top,
INT16 width, INT16 height, DWORD rop)
{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+ DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pPatBlt) return FALSE;
dprintf_bitblt( stddeb, "PatBlt16: %04x %d,%d %dx%d %06lx\n",
@@ -30,7 +30,7 @@
BOOL32 PatBlt32( HDC32 hdc, INT32 left, INT32 top,
INT32 width, INT32 height, DWORD rop)
{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+ DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pPatBlt) return FALSE;
dprintf_bitblt( stddeb, "PatBlt32: %04x %d,%d %dx%d %06lx\n",
@@ -47,9 +47,9 @@
{
DC *dcDst, *dcSrc;
- if (!(dcDst = (DC *)GDI_GetObjPtr( hdcDst, DC_MAGIC ))) return FALSE;
+ if (!(dcDst = DC_GetDCPtr( hdcDst ))) return FALSE;
if (!dcDst->funcs->pBitBlt) return FALSE;
- dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
+ dcSrc = DC_GetDCPtr( hdcSrc );
dprintf_bitblt(stddeb,
"BitBlt16: hdcSrc=%04x %d,%d %d bpp -> hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
@@ -68,9 +68,9 @@
{
DC *dcDst, *dcSrc;
- if (!(dcDst = (DC *)GDI_GetObjPtr( hdcDst, DC_MAGIC ))) return FALSE;
+ if (!(dcDst = DC_GetDCPtr( hdcDst ))) return FALSE;
if (!dcDst->funcs->pBitBlt) return FALSE;
- dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
+ dcSrc = DC_GetDCPtr( hdcSrc );
dprintf_bitblt(stddeb,
"BitBlt32: hdcSrc=%04x %d,%d %d bpp -> hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
@@ -91,9 +91,10 @@
{
DC *dcDst, *dcSrc;
- if (!(dcDst = (DC *) GDI_GetObjPtr( hdcDst, DC_MAGIC ))) return FALSE;
+ if (!(dcDst = DC_GetDCPtr( hdcDst ))) return FALSE;
if (!dcDst->funcs->pStretchBlt) return FALSE;
- dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
+ dcSrc = DC_GetDCPtr( hdcSrc );
+
dprintf_bitblt(stddeb,
"StretchBlt16: %04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
@@ -115,9 +116,10 @@
{
DC *dcDst, *dcSrc;
- if (!(dcDst = (DC *) GDI_GetObjPtr( hdcDst, DC_MAGIC ))) return FALSE;
+ if (!(dcDst = DC_GetDCPtr( hdcDst ))) return FALSE;
if (!dcDst->funcs->pStretchBlt) return FALSE;
- dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
+ dcSrc = DC_GetDCPtr( hdcSrc );
+
dprintf_bitblt(stddeb,
"StretchBlt32: %04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
diff --git a/graphics/mapping.c b/graphics/mapping.c
new file mode 100644
index 0000000..e70c1e5
--- /dev/null
+++ b/graphics/mapping.c
@@ -0,0 +1,568 @@
+/*
+ * GDI mapping mode functions
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+#include <math.h>
+#include "dc.h"
+#include "stddebug.h"
+#include "debug.h"
+
+
+/***********************************************************************
+ * MAPPING_FixIsotropic
+ *
+ * Fix viewport extensions for isotropic mode.
+ */
+void MAPPING_FixIsotropic( DC * dc )
+{
+ double xdim = (double)dc->vportExtX * dc->w.devCaps->horzSize /
+ (dc->w.devCaps->horzRes * dc->wndExtX);
+ double ydim = (double)dc->vportExtY * dc->w.devCaps->vertSize /
+ (dc->w.devCaps->vertRes * dc->wndExtY);
+ if (xdim > ydim)
+ {
+ dc->vportExtX = dc->vportExtX * fabs( ydim / xdim );
+ if (!dc->vportExtX) dc->vportExtX = 1;
+ }
+ else
+ {
+ dc->vportExtY = dc->vportExtY * fabs( xdim / ydim );
+ if (!dc->vportExtY) dc->vportExtY = 1;
+ }
+}
+
+
+/***********************************************************************
+ * DPtoLP16 (GDI.67)
+ */
+BOOL16 DPtoLP16( HDC16 hdc, LPPOINT16 points, INT16 count )
+{
+ DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+ if (!dc) return FALSE;
+
+ while (count--)
+ {
+ points->x = XDPTOLP( dc, points->x );
+ points->y = YDPTOLP( dc, points->y );
+ points++;
+ }
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * DPtoLP32 (GDI32.65)
+ */
+BOOL32 DPtoLP32( HDC32 hdc, LPPOINT32 points, INT32 count )
+{
+ DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+ if (!dc) return FALSE;
+
+ while (count--)
+ {
+ points->x = XDPTOLP( dc, points->x );
+ points->y = YDPTOLP( dc, points->y );
+ points++;
+ }
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * LPtoDP16 (GDI.99)
+ */
+BOOL16 LPtoDP16( HDC16 hdc, LPPOINT16 points, INT16 count )
+{
+ DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+ if (!dc) return FALSE;
+
+ while (count--)
+ {
+ points->x = XLPTODP( dc, points->x );
+ points->y = YLPTODP( dc, points->y );
+ points++;
+ }
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * LPtoDP32 (GDI32.247)
+ */
+BOOL32 LPtoDP32( HDC32 hdc, LPPOINT32 points, INT32 count )
+{
+ DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+ if (!dc) return FALSE;
+
+ while (count--)
+ {
+ points->x = XLPTODP( dc, points->x );
+ points->y = YLPTODP( dc, points->y );
+ points++;
+ }
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * SetMapMode16 (GDI.3)
+ */
+INT16 SetMapMode16( HDC16 hdc, INT16 mode )
+{
+ return SetMapMode32( hdc, mode );
+}
+
+
+/***********************************************************************
+ * SetMapMode32 (GDI32.321)
+ */
+INT32 SetMapMode32( HDC32 hdc, INT32 mode )
+{
+ INT32 prevMode;
+ DC * dc = DC_GetDCPtr( hdc );
+ if (!dc) return 0;
+ if (dc->funcs->pSetMapMode) return dc->funcs->pSetMapMode( dc, mode );
+
+ dprintf_gdi(stddeb, "SetMapMode: %04x %d\n", hdc, mode );
+
+ prevMode = dc->w.MapMode;
+ switch(mode)
+ {
+ case MM_TEXT:
+ dc->wndOrgX = dc->wndOrgY = 0;
+ dc->vportOrgX = dc->vportOrgY = 0;
+ dc->wndExtX = 1;
+ dc->wndExtY = 1;
+ dc->vportExtX = 1;
+ dc->vportExtY = 1;
+ break;
+
+ case MM_LOMETRIC:
+ case MM_ISOTROPIC:
+ dc->wndOrgX = dc->wndOrgY = 0;
+ dc->vportOrgX = dc->vportOrgY = 0;
+ dc->wndExtX = dc->w.devCaps->horzSize;
+ dc->wndExtY = dc->w.devCaps->vertSize;
+ dc->vportExtX = dc->w.devCaps->horzRes / 10;
+ dc->vportExtY = dc->w.devCaps->vertRes / -10;
+ break;
+
+ case MM_HIMETRIC:
+ dc->wndOrgX = dc->wndOrgY = 0;
+ dc->vportOrgX = dc->vportOrgY = 0;
+ dc->wndExtX = dc->w.devCaps->horzSize * 10;
+ dc->wndExtY = dc->w.devCaps->vertSize * 10;
+ dc->vportExtX = dc->w.devCaps->horzRes / 10;
+ dc->vportExtY = dc->w.devCaps->vertRes / -10;
+ break;
+
+ case MM_LOENGLISH:
+ dc->wndOrgX = dc->wndOrgY = 0;
+ dc->vportOrgX = dc->vportOrgY = 0;
+ dc->wndExtX = dc->w.devCaps->horzSize;
+ dc->wndExtY = dc->w.devCaps->vertSize;
+ dc->vportExtX = 254L * dc->w.devCaps->horzRes / 1000;
+ dc->vportExtY = -254L * dc->w.devCaps->vertRes / 1000;
+ break;
+
+ case MM_HIENGLISH:
+ dc->wndOrgX = dc->wndOrgY = 0;
+ dc->vportOrgX = dc->vportOrgY = 0;
+ dc->wndExtX = dc->w.devCaps->horzSize * 10;
+ dc->wndExtY = dc->w.devCaps->vertSize * 10;
+ dc->vportExtX = 254L * dc->w.devCaps->horzRes / 1000;
+ dc->vportExtY = -254L * dc->w.devCaps->vertRes / 1000;
+ break;
+
+ case MM_TWIPS:
+ dc->wndOrgX = dc->wndOrgY = 0;
+ dc->vportOrgX = dc->vportOrgY = 0;
+ dc->wndExtX = 144L * dc->w.devCaps->horzSize / 10;
+ dc->wndExtY = 144L * dc->w.devCaps->vertSize / 10;
+ dc->vportExtX = 254L * dc->w.devCaps->horzRes / 1000;
+ dc->vportExtY = -254L * dc->w.devCaps->vertRes / 1000;
+ break;
+
+ case MM_ANISOTROPIC:
+ break;
+
+ default:
+ return prevMode;
+ }
+ dc->w.MapMode = mode;
+ return prevMode;
+}
+
+
+/***********************************************************************
+ * SetViewportExt (GDI.14)
+ */
+DWORD SetViewportExt( HDC16 hdc, INT16 x, INT16 y )
+{
+ SIZE32 size;
+ if (!SetViewportExtEx32( hdc, x, y, &size )) return 0;
+ return MAKELONG( size.cx, size.cy );
+}
+
+
+/***********************************************************************
+ * SetViewportExtEx16 (GDI.479)
+ */
+BOOL16 SetViewportExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
+{
+ SIZE32 size32;
+ BOOL16 ret = SetViewportExtEx32( hdc, x, y, &size32 );
+ if (size) CONV_SIZE32TO16( &size32, size );
+ return ret;
+}
+
+
+/***********************************************************************
+ * SetViewportExtEx32 (GDI32.340)
+ */
+BOOL32 SetViewportExtEx32( HDC32 hdc, INT32 x, INT32 y, LPSIZE32 size )
+{
+ DC * dc = DC_GetDCPtr( hdc );
+ if (!dc) return FALSE;
+ if (dc->funcs->pSetViewportExt)
+ return dc->funcs->pSetViewportExt( dc, x, y );
+ if (size)
+ {
+ size->cx = dc->vportExtX;
+ size->cy = dc->vportExtY;
+ }
+ if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
+ return TRUE;
+ if (!x || !y) return FALSE;
+ dc->vportExtX = x;
+ dc->vportExtY = y;
+ if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * SetViewportOrg (GDI.13)
+ */
+DWORD SetViewportOrg( HDC16 hdc, INT16 x, INT16 y )
+{
+ POINT32 pt;
+ if (!SetViewportOrgEx32( hdc, x, y, &pt )) return 0;
+ return MAKELONG( pt.x, pt.y );
+}
+
+
+/***********************************************************************
+ * SetViewportOrgEx16 (GDI.480)
+ */
+BOOL16 SetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
+{
+ POINT32 pt32;
+ BOOL16 ret = SetViewportOrgEx32( hdc, x, y, &pt32 );
+ if (pt) CONV_POINT32TO16( &pt32, pt );
+ return ret;
+}
+
+
+/***********************************************************************
+ * SetViewportOrgEx32 (GDI32.341)
+ */
+BOOL32 SetViewportOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
+{
+ DC * dc = DC_GetDCPtr( hdc );
+ if (!dc) return FALSE;
+ if (dc->funcs->pSetViewportOrg)
+ return dc->funcs->pSetViewportOrg( dc, x, y );
+ if (pt)
+ {
+ pt->x = dc->vportOrgX;
+ pt->y = dc->vportOrgY;
+ }
+ dc->vportOrgX = x;
+ dc->vportOrgY = y;
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * SetWindowExt (GDI.12)
+ */
+DWORD SetWindowExt( HDC16 hdc, INT16 x, INT16 y )
+{
+ SIZE32 size;
+ if (!SetWindowExtEx32( hdc, x, y, &size )) return 0;
+ return MAKELONG( size.cx, size.cy );
+}
+
+
+/***********************************************************************
+ * SetWindowExtEx16 (GDI.481)
+ */
+BOOL16 SetWindowExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
+{
+ SIZE32 size32;
+ BOOL16 ret = SetWindowExtEx32( hdc, x, y, &size32 );
+ if (size) CONV_SIZE32TO16( &size32, size );
+ return ret;
+}
+
+
+/***********************************************************************
+ * SetWindowExtEx32 (GDI32.344)
+ */
+BOOL32 SetWindowExtEx32( HDC32 hdc, INT32 x, INT32 y, LPSIZE32 size )
+{
+ DC * dc = DC_GetDCPtr( hdc );
+ if (!dc) return FALSE;
+ if (dc->funcs->pSetWindowExt) return dc->funcs->pSetWindowExt( dc, x, y );
+ if (size)
+ {
+ size->cx = dc->wndExtX;
+ size->cy = dc->wndExtY;
+ }
+ if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
+ return TRUE;
+ if (!x || !y) return FALSE;
+ dc->wndExtX = x;
+ dc->wndExtY = y;
+ if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * SetWindowOrg (GDI.11)
+ */
+DWORD SetWindowOrg( HDC16 hdc, INT16 x, INT16 y )
+{
+ POINT32 pt;
+ if (!SetWindowOrgEx32( hdc, x, y, &pt )) return 0;
+ return MAKELONG( pt.x, pt.y );
+}
+
+
+/***********************************************************************
+ * SetWindowOrgEx16 (GDI.482)
+ */
+BOOL16 SetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
+{
+ POINT32 pt32;
+ BOOL16 ret = SetWindowOrgEx32( hdc, x, y, &pt32 );
+ if (pt) CONV_POINT32TO16( &pt32, pt );
+ return ret;
+}
+
+
+/***********************************************************************
+ * SetWindowOrgEx32 (GDI32.345)
+ */
+BOOL32 SetWindowOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
+{
+ DC * dc = DC_GetDCPtr( hdc );
+ if (!dc) return FALSE;
+ if (dc->funcs->pSetWindowOrg) return dc->funcs->pSetWindowOrg( dc, x, y );
+ if (pt)
+ {
+ pt->x = dc->wndOrgX;
+ pt->y = dc->wndOrgY;
+ }
+ dc->wndOrgX = x;
+ dc->wndOrgY = y;
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * OffsetViewportOrg (GDI.17)
+ */
+DWORD OffsetViewportOrg( HDC16 hdc, INT16 x, INT16 y )
+{
+ POINT32 pt;
+ if (!OffsetViewportOrgEx32( hdc, x, y, &pt )) return 0;
+ return MAKELONG( pt.x, pt.y );
+}
+
+
+/***********************************************************************
+ * OffsetViewportOrgEx16 (GDI.476)
+ */
+BOOL16 OffsetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
+{
+ POINT32 pt32;
+ BOOL16 ret = OffsetViewportOrgEx32( hdc, x, y, &pt32 );
+ if (pt) CONV_POINT32TO16( &pt32, pt );
+ return ret;
+}
+
+
+/***********************************************************************
+ * OffsetViewportOrgEx32 (GDI32.257)
+ */
+BOOL32 OffsetViewportOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
+{
+ DC * dc = DC_GetDCPtr( hdc );
+ if (!dc) return FALSE;
+ if (dc->funcs->pOffsetViewportOrg)
+ return dc->funcs->pOffsetViewportOrg( dc, x, y );
+ if (pt)
+ {
+ pt->x = dc->vportOrgX;
+ pt->y = dc->vportOrgY;
+ }
+ dc->vportOrgX += x;
+ dc->vportOrgY += y;
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * OffsetWindowOrg (GDI.15)
+ */
+DWORD OffsetWindowOrg( HDC16 hdc, INT16 x, INT16 y )
+{
+ POINT32 pt;
+ if (!OffsetWindowOrgEx32( hdc, x, y, &pt )) return 0;
+ return MAKELONG( pt.x, pt.y );
+}
+
+
+/***********************************************************************
+ * OffsetWindowOrgEx16 (GDI.477)
+ */
+BOOL16 OffsetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
+{
+ POINT32 pt32;
+ BOOL16 ret = OffsetWindowOrgEx32( hdc, x, y, &pt32 );
+ if (pt) CONV_POINT32TO16( &pt32, pt );
+ return ret;
+}
+
+
+/***********************************************************************
+ * OffsetWindowOrgEx32 (GDI32.258)
+ */
+BOOL32 OffsetWindowOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
+{
+ DC * dc = DC_GetDCPtr( hdc );
+ if (!dc) return FALSE;
+ if (dc->funcs->pOffsetWindowOrg)
+ return dc->funcs->pOffsetWindowOrg( dc, x, y );
+ if (pt)
+ {
+ pt->x = dc->wndOrgX;
+ pt->y = dc->wndOrgY;
+ }
+ dc->wndOrgX += x;
+ dc->wndOrgY += y;
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * ScaleViewportExt (GDI.18)
+ */
+DWORD ScaleViewportExt( HDC16 hdc, INT16 xNum, INT16 xDenom,
+ INT16 yNum, INT16 yDenom )
+{
+ SIZE32 size;
+ if (!ScaleViewportExtEx32( hdc, xNum, xDenom, yNum, yDenom, &size ))
+ return FALSE;
+ return MAKELONG( size.cx, size.cy );
+}
+
+
+/***********************************************************************
+ * ScaleViewportExtEx16 (GDI.484)
+ */
+BOOL16 ScaleViewportExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
+ INT16 yNum, INT16 yDenom, LPSIZE16 size )
+{
+ SIZE32 size32;
+ BOOL16 ret = ScaleViewportExtEx32( hdc, xNum, xDenom, yNum, yDenom,
+ &size32 );
+ if (size) CONV_SIZE32TO16( &size32, size );
+ return ret;
+}
+
+
+/***********************************************************************
+ * ScaleViewportExtEx32 (GDI32.293)
+ */
+BOOL32 ScaleViewportExtEx32( HDC32 hdc, INT32 xNum, INT32 xDenom,
+ INT32 yNum, INT32 yDenom, LPSIZE32 size )
+{
+ DC * dc = DC_GetDCPtr( hdc );
+ if (!dc) return FALSE;
+ if (dc->funcs->pScaleViewportExt)
+ return dc->funcs->pScaleViewportExt( dc, xNum, xDenom, yNum, yDenom );
+ if (size)
+ {
+ size->cx = dc->vportExtX;
+ size->cy = dc->vportExtY;
+ }
+ if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
+ return TRUE;
+ if (!xNum || !xDenom || !xNum || !yDenom) return FALSE;
+ dc->vportExtX = (dc->vportExtX * xNum) / xDenom;
+ dc->vportExtY = (dc->vportExtY * yNum) / yDenom;
+ if (dc->vportExtX == 0) dc->vportExtX = 1;
+ if (dc->vportExtY == 0) dc->vportExtY = 1;
+ if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * ScaleWindowExt (GDI.16)
+ */
+DWORD ScaleWindowExt( HDC16 hdc, INT16 xNum, INT16 xDenom,
+ INT16 yNum, INT16 yDenom )
+{
+ SIZE32 size;
+ if (!ScaleWindowExtEx32( hdc, xNum, xDenom, yNum, yDenom, &size ))
+ return FALSE;
+ return MAKELONG( size.cx, size.cy );
+}
+
+
+/***********************************************************************
+ * ScaleWindowExtEx16 (GDI.485)
+ */
+BOOL16 ScaleWindowExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
+ INT16 yNum, INT16 yDenom, LPSIZE16 size )
+{
+ SIZE32 size32;
+ BOOL16 ret = ScaleWindowExtEx32( hdc, xNum, xDenom, yNum, yDenom,
+ &size32 );
+ if (size) CONV_SIZE32TO16( &size32, size );
+ return ret;
+}
+
+
+/***********************************************************************
+ * ScaleWindowExtEx32 (GDI32.294)
+ */
+BOOL32 ScaleWindowExtEx32( HDC32 hdc, INT32 xNum, INT32 xDenom,
+ INT32 yNum, INT32 yDenom, LPSIZE32 size )
+{
+ DC * dc = DC_GetDCPtr( hdc );
+ if (!dc) return FALSE;
+ if (dc->funcs->pScaleWindowExt)
+ return dc->funcs->pScaleWindowExt( dc, xNum, xDenom, yNum, yDenom );
+ if (size)
+ {
+ size->cx = dc->wndExtX;
+ size->cy = dc->wndExtY;
+ }
+ if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
+ return TRUE;
+ if (!xNum || !xDenom || !xNum || !yDenom) return FALSE;
+ dc->wndExtX = (dc->wndExtX * xNum) / xDenom;
+ dc->wndExtY = (dc->wndExtY * yNum) / yDenom;
+ if (dc->wndExtX == 0) dc->wndExtX = 1;
+ if (dc->wndExtY == 0) dc->wndExtY = 1;
+ if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
+ return TRUE;
+}
diff --git a/graphics/metafiledrv/Makefile.in b/graphics/metafiledrv/Makefile.in
index 02de44e..1b0a161 100644
--- a/graphics/metafiledrv/Makefile.in
+++ b/graphics/metafiledrv/Makefile.in
@@ -7,7 +7,8 @@
C_SRCS = \
bitblt.c \
- init.c
+ init.c \
+ mapping.c
all: $(MODULE).o
diff --git a/graphics/metafiledrv/init.c b/graphics/metafiledrv/init.c
index e8ad11d..f1d3454 100644
--- a/graphics/metafiledrv/init.c
+++ b/graphics/metafiledrv/init.c
@@ -39,8 +39,8 @@
NULL, /* pLineTo */
NULL, /* pMoveToEx */
NULL, /* pOffsetClipRgn */
- NULL, /* pOffsetViewportOrgEx */
- NULL, /* pOffsetWindowOrgEx */
+ MFDRV_OffsetViewportOrg, /* pOffsetViewportOrg */
+ MFDRV_OffsetWindowOrg, /* pOffsetWindowOrg */
NULL, /* pPaintRgn */
MFDRV_PatBlt, /* pPatBlt */
NULL, /* pPie */
@@ -52,8 +52,8 @@
NULL, /* pRestoreDC */
NULL, /* pRoundRect */
NULL, /* pSaveDC */
- NULL, /* pScaleViewportExtEx */
- NULL, /* pScaleWindowExtEx */
+ MFDRV_ScaleViewportExt, /* pScaleViewportExt */
+ MFDRV_ScaleWindowExt, /* pScaleWindowExt */
NULL, /* pSelectClipRgn */
NULL, /* pSelectObject */
NULL, /* pSelectPalette */
@@ -61,7 +61,7 @@
NULL, /* pSetBkMode */
NULL, /* pSetDeviceClipping */
NULL, /* pSetDIBitsToDevice */
- NULL, /* pSetMapMode */
+ MFDRV_SetMapMode, /* pSetMapMode */
NULL, /* pSetMapperFlags */
NULL, /* pSetPixel */
NULL, /* pSetPolyFillMode */
@@ -72,10 +72,10 @@
NULL, /* pSetTextCharacterExtra */
NULL, /* pSetTextColor */
NULL, /* pSetTextJustification */
- NULL, /* pSetViewportExtEx */
- NULL, /* pSetViewportOrgEx */
- NULL, /* pSetWindowExtEx */
- NULL, /* pSetWindowOrgEx */
+ MFDRV_SetViewportExt, /* pSetViewportExt */
+ MFDRV_SetViewportOrg, /* pSetViewportOrg */
+ MFDRV_SetWindowExt, /* pSetWindowExt */
+ MFDRV_SetWindowOrg, /* pSetWindowOrg */
MFDRV_StretchBlt, /* pStretchBlt */
NULL, /* pStretchDIBits */
NULL /* pTextOut */
@@ -156,13 +156,13 @@
physDev->mh->mtType = METAFILE_DISK;
if ((hFile = _lcreat( filename, 0 )) == HFILE_ERROR)
{
- DeleteDC( dc->hSelf );
+ DeleteDC32( dc->hSelf );
return 0;
}
if (_lwrite32( hFile, (LPSTR)physDev->mh,
sizeof(*physDev->mh)) == HFILE_ERROR)
{
- DeleteDC( dc->hSelf );
+ DeleteDC32( dc->hSelf );
return 0;
}
physDev->mh->mtNoParameters = hFile; /* store file descriptor here */
@@ -197,7 +197,7 @@
if (!MF_MetaParam0(dc, META_EOF))
{
- DeleteDC( hdc );
+ DeleteDC32( hdc );
return 0;
}
@@ -207,13 +207,13 @@
physDev->mh->mtNoParameters = 0;
if (_llseek(hFile, 0L, 0) == HFILE_ERROR)
{
- DeleteDC( hdc );
+ DeleteDC32( hdc );
return 0;
}
if (_lwrite32( hFile, (LPSTR)physDev->mh,
sizeof(*physDev->mh)) == HFILE_ERROR)
{
- DeleteDC( hdc );
+ DeleteDC32( hdc );
return 0;
}
_lclose(hFile);
@@ -225,7 +225,7 @@
physDev->mh->mtSize * sizeof(WORD),
GetCurrentPDB(), FALSE, FALSE, FALSE, NULL );
physDev->mh = NULL; /* So it won't be deleted */
- DeleteDC( hdc );
+ DeleteDC32( hdc );
return hmf;
}
diff --git a/graphics/metafiledrv/mapping.c b/graphics/metafiledrv/mapping.c
new file mode 100644
index 0000000..4e396d1
--- /dev/null
+++ b/graphics/metafiledrv/mapping.c
@@ -0,0 +1,102 @@
+/*
+ * Metafile GDI mapping mode functions
+ *
+ * Copyright 1996 Alexandre Julliard
+ */
+
+#include "gdi.h"
+#include "metafile.h"
+#include "metafiledrv.h"
+
+
+/***********************************************************************
+ * MFDRV_SetMapMode
+ */
+INT32 MFDRV_SetMapMode( DC *dc, INT32 mode )
+{
+ INT32 prevMode = dc->w.MapMode;
+ MF_MetaParam1( dc, META_SETMAPMODE, mode );
+ return prevMode;
+}
+
+
+/***********************************************************************
+ * MFDRV_SetViewportExt
+ */
+BOOL32 MFDRV_SetViewportExt( DC *dc, INT32 x, INT32 y )
+{
+ MF_MetaParam2( dc, META_SETVIEWPORTEXT, x, y );
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * MFDRV_SetViewportOrg
+ */
+BOOL32 MFDRV_SetViewportOrg( DC *dc, INT32 x, INT32 y )
+{
+ MF_MetaParam2( dc, META_SETVIEWPORTORG, x, y );
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * MFDRV_SetWindowExt
+ */
+BOOL32 MFDRV_SetWindowExt( DC *dc, INT32 x, INT32 y )
+{
+ MF_MetaParam2( dc, META_SETWINDOWEXT, x, y );
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * MFDRV_SetWindowOrg
+ */
+BOOL32 MFDRV_SetWindowOrg( DC *dc, INT32 x, INT32 y )
+{
+ MF_MetaParam2( dc, META_SETWINDOWORG, x, y );
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * MFDRV_OffsetViewportOrg
+ */
+BOOL32 MFDRV_OffsetViewportOrg( DC *dc, INT32 x, INT32 y )
+{
+ MF_MetaParam2( dc, META_OFFSETVIEWPORTORG, x, y );
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * MFDRV_OffsetWindowOrg
+ */
+BOOL32 MFDRV_OffsetWindowOrg( DC *dc, INT32 x, INT32 y )
+{
+ MF_MetaParam2( dc, META_OFFSETWINDOWORG, x, y );
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * MFDRV_ScaleViewportExt
+ */
+BOOL32 MFDRV_ScaleViewportExt( DC *dc, INT32 xNum, INT32 xDenom,
+ INT32 yNum, INT32 yDenom )
+{
+ MF_MetaParam4( dc, META_SCALEVIEWPORTEXT, xNum, xDenom, yNum, yDenom );
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * MFDRV_ScaleWindowExt
+ */
+BOOL32 MFDRV_ScaleWindowExt( DC *dc, INT32 xNum, INT32 xDenom,
+ INT32 yNum, INT32 yDenom )
+{
+ MF_MetaParam4( dc, META_SCALEWINDOWEXT, xNum, xDenom, yNum, yDenom );
+ return TRUE;
+}
diff --git a/graphics/win16drv/init.c b/graphics/win16drv/init.c
index 10ab2b6..8d05cda 100644
--- a/graphics/win16drv/init.c
+++ b/graphics/win16drv/init.c
@@ -61,8 +61,8 @@
NULL, /* pLineTo */
NULL, /* pMoveToEx */
NULL, /* pOffsetClipRgn */
- NULL, /* pOffsetViewportOrgEx */
- NULL, /* pOffsetWindowOrgEx */
+ NULL, /* pOffsetViewportOrg (optional) */
+ NULL, /* pOffsetWindowOrg (optional) */
NULL, /* pPaintRgn */
NULL, /* pPatBlt */
NULL, /* pPie */
@@ -74,8 +74,8 @@
NULL, /* pRestoreDC */
NULL, /* pRoundRect */
NULL, /* pSaveDC */
- NULL, /* pScaleViewportExtEx */
- NULL, /* pScaleWindowExtEx */
+ NULL, /* pScaleViewportExt (optional) */
+ NULL, /* pScaleWindowExt (optional) */
NULL, /* pSelectClipRgn */
NULL, /* pSelectObject */
NULL, /* pSelectPalette */
@@ -83,7 +83,7 @@
NULL, /* pSetBkMode */
NULL, /* pSetDeviceClipping */
NULL, /* pSetDIBitsToDevice */
- NULL, /* pSetMapMode */
+ NULL, /* pSetMapMode (optional) */
NULL, /* pSetMapperFlags */
NULL, /* pSetPixel */
NULL, /* pSetPolyFillMode */
@@ -94,10 +94,10 @@
NULL, /* pSetTextCharacterExtra */
NULL, /* pSetTextColor */
NULL, /* pSetTextJustification */
- NULL, /* pSetViewportExtEx */
- NULL, /* pSetViewportOrgEx */
- NULL, /* pSetWindowExtEx */
- NULL, /* pSetWindowOrgEx */
+ NULL, /* pSetViewportExt (optional) */
+ NULL, /* pSetViewportOrg (optional) */
+ NULL, /* pSetWindowExt (optional) */
+ NULL, /* pSetWindowOrg (optional) */
NULL, /* pStretchBlt */
NULL, /* pStretchDIBits */
NULL /* pTextOut */
diff --git a/graphics/wing.c b/graphics/wing.c
index 697b5b9..0ed174f 100644
--- a/graphics/wing.c
+++ b/graphics/wing.c
@@ -67,7 +67,7 @@
__initWinG();
if( __WinGOK > 0 )
- return CreateCompatibleDC(NULL);
+ return CreateCompatibleDC16(NULL);
return (HDC16)NULL;
}
@@ -278,8 +278,8 @@
ySrc = dcSrc->w.DCOrgY + YLPTODP( dcSrc, ySrc );
xDest = dcDst->w.DCOrgX + XLPTODP( dcDst, xDest );
yDest = dcDst->w.DCOrgY + YLPTODP( dcDst, yDest );
- widDest = widDest * dcDst->w.VportExtX / dcDst->w.WndExtX;
- heiDest = heiDest * dcDst->w.VportExtY / dcDst->w.WndExtY;
+ widDest = widDest * dcDst->vportExtX / dcDst->wndExtX;
+ heiDest = heiDest * dcDst->vportExtY / dcDst->wndExtY;
XSetFunction( display, dcDst->u.x.gc, GXcopy );
XCopyArea( display, dcSrc->u.x.drawable,
diff --git a/graphics/x11drv/bitblt.c b/graphics/x11drv/bitblt.c
index 2b0fe3e..c4b4f8c 100644
--- a/graphics/x11drv/bitblt.c
+++ b/graphics/x11drv/bitblt.c
@@ -1114,14 +1114,14 @@
xDst = dcDst->w.DCOrgX + XLPTODP( dcDst, xDst );
yDst = dcDst->w.DCOrgY + YLPTODP( dcDst, yDst );
- widthDst = widthDst * dcDst->w.VportExtX / dcDst->w.WndExtX;
- heightDst = heightDst * dcDst->w.VportExtY / dcDst->w.WndExtY;
+ widthDst = widthDst * dcDst->vportExtX / dcDst->wndExtX;
+ heightDst = heightDst * dcDst->vportExtY / dcDst->wndExtY;
dprintf_bitblt( stddeb, " vportdst=%d,%d-%d,%d wnddst=%d,%d-%d,%d\n",
- dcDst->w.VportOrgX, dcDst->w.VportOrgY,
- dcDst->w.VportExtX, dcDst->w.VportExtY,
- dcDst->w.WndOrgX, dcDst->w.WndOrgY,
- dcDst->w.WndExtX, dcDst->w.WndExtY );
+ dcDst->vportOrgX, dcDst->vportOrgY,
+ dcDst->vportExtX, dcDst->vportExtY,
+ dcDst->wndOrgX, dcDst->wndOrgY,
+ dcDst->wndExtX, dcDst->wndExtY );
dprintf_bitblt( stddeb, " rectdst=%d,%d-%d,%d orgdst=%d,%d\n",
xDst, yDst, widthDst, heightDst,
dcDst->w.DCOrgX, dcDst->w.DCOrgY );
@@ -1130,14 +1130,14 @@
{
xSrc = dcSrc->w.DCOrgX + XLPTODP( dcSrc, xSrc );
ySrc = dcSrc->w.DCOrgY + YLPTODP( dcSrc, ySrc );
- widthSrc = widthSrc * dcSrc->w.VportExtX / dcSrc->w.WndExtX;
- heightSrc = heightSrc * dcSrc->w.VportExtY / dcSrc->w.WndExtY;
+ widthSrc = widthSrc * dcSrc->vportExtX / dcSrc->wndExtX;
+ heightSrc = heightSrc * dcSrc->vportExtY / dcSrc->wndExtY;
fStretch = (widthSrc != widthDst) || (heightSrc != heightDst);
dprintf_bitblt( stddeb," vportsrc=%d,%d-%d,%d wndsrc=%d,%d-%d,%d\n",
- dcSrc->w.VportOrgX, dcSrc->w.VportOrgY,
- dcSrc->w.VportExtX, dcSrc->w.VportExtY,
- dcSrc->w.WndOrgX, dcSrc->w.WndOrgY,
- dcSrc->w.WndExtX, dcSrc->w.WndExtY );
+ dcSrc->vportOrgX, dcSrc->vportOrgY,
+ dcSrc->vportExtX, dcSrc->vportExtY,
+ dcSrc->wndOrgX, dcSrc->wndOrgY,
+ dcSrc->wndExtX, dcSrc->wndExtY );
dprintf_bitblt( stddeb, " rectsrc=%d,%d-%d,%d orgsrc=%d,%d\n",
xSrc, ySrc, widthSrc, heightSrc,
dcSrc->w.DCOrgX, dcSrc->w.DCOrgY );
diff --git a/graphics/x11drv/font.c b/graphics/x11drv/font.c
index 532d68c..6faebae 100644
--- a/graphics/x11drv/font.c
+++ b/graphics/x11drv/font.c
@@ -20,8 +20,8 @@
XTextExtents( dc->u.x.font.fstruct, str, count, &dir,
&ascent, &descent, &info );
size->cx = abs((info.width + dc->w.breakRem + count * dc->w.charExtra)
- * dc->w.WndExtX / dc->w.VportExtX);
+ * dc->wndExtX / dc->vportExtX);
size->cy = abs((dc->u.x.font.fstruct->ascent+dc->u.x.font.fstruct->descent)
- * dc->w.WndExtY / dc->w.VportExtY);
+ * dc->wndExtY / dc->vportExtY);
return TRUE;
}
diff --git a/graphics/x11drv/init.c b/graphics/x11drv/init.c
index e56b3d9..5ceb736 100644
--- a/graphics/x11drv/init.c
+++ b/graphics/x11drv/init.c
@@ -39,8 +39,8 @@
NULL, /* pLineTo */
NULL, /* pMoveToEx */
NULL, /* pOffsetClipRgn */
- NULL, /* pOffsetViewportOrgEx */
- NULL, /* pOffsetWindowOrgEx */
+ NULL, /* pOffsetViewportOrg (optional) */
+ NULL, /* pOffsetWindowOrg (optional) */
NULL, /* pPaintRgn */
X11DRV_PatBlt, /* pPatBlt */
NULL, /* pPie */
@@ -52,8 +52,8 @@
NULL, /* pRestoreDC */
NULL, /* pRoundRect */
NULL, /* pSaveDC */
- NULL, /* pScaleViewportExtEx */
- NULL, /* pScaleWindowExtEx */
+ NULL, /* pScaleViewportExt (optional) */
+ NULL, /* pScaleWindowExt (optional) */
NULL, /* pSelectClipRgn */
NULL, /* pSelectObject */
NULL, /* pSelectPalette */
@@ -61,7 +61,7 @@
NULL, /* pSetBkMode */
X11DRV_SetDeviceClipping, /* pSetDeviceClipping */
NULL, /* pSetDIBitsToDevice */
- NULL, /* pSetMapMode */
+ NULL, /* pSetMapMode (optional) */
NULL, /* pSetMapperFlags */
NULL, /* pSetPixel */
NULL, /* pSetPolyFillMode */
@@ -72,10 +72,10 @@
NULL, /* pSetTextCharacterExtra */
NULL, /* pSetTextColor */
NULL, /* pSetTextJustification */
- NULL, /* pSetViewportExtEx */
- NULL, /* pSetViewportOrgEx */
- NULL, /* pSetWindowExtEx */
- NULL, /* pSetWindowOrgEx */
+ NULL, /* pSetViewportExt (optional) */
+ NULL, /* pSetViewportOrg (optional) */
+ NULL, /* pSetWindowExt (optional) */
+ NULL, /* pSetWindowOrg (optional) */
X11DRV_StretchBlt, /* pStretchBlt */
NULL, /* pStretchDIBits */
NULL /* pTextOut */
diff --git a/if1632/gdi.spec b/if1632/gdi.spec
index 9e97789..4d2846b 100644
--- a/if1632/gdi.spec
+++ b/if1632/gdi.spec
@@ -3,15 +3,15 @@
heap 65488 # 65536 - 16 (instance data) - 32 (stock objects)
1 pascal SetBkColor(word long) SetBkColor
-2 pascal16 SetBkMode(word word) SetBkMode
-3 pascal16 SetMapMode(word word) SetMapMode
-4 pascal16 SetROP2(word word) SetROP2
-5 pascal16 SetRelAbs(word word) SetRelAbs
-6 pascal16 SetPolyFillMode(word word) SetPolyFillMode
-7 pascal16 SetStretchBltMode(word word) SetStretchBltMode
-8 pascal16 SetTextCharacterExtra(word s_word) SetTextCharacterExtra
+2 pascal16 SetBkMode(word word) SetBkMode16
+3 pascal16 SetMapMode(word word) SetMapMode16
+4 pascal16 SetROP2(word word) SetROP216
+5 pascal16 SetRelAbs(word word) SetRelAbs16
+6 pascal16 SetPolyFillMode(word word) SetPolyFillMode16
+7 pascal16 SetStretchBltMode(word word) SetStretchBltMode16
+8 pascal16 SetTextCharacterExtra(word s_word) SetTextCharacterExtra16
9 pascal SetTextColor(word long) SetTextColor
-10 pascal16 SetTextJustification(word s_word s_word) SetTextJustification
+10 pascal16 SetTextJustification(word s_word s_word) SetTextJustification16
11 pascal SetWindowOrg(word s_word s_word) SetWindowOrg
12 pascal SetWindowExt(word s_word s_word) SetWindowExt
13 pascal SetViewportOrg(word s_word s_word) SetViewportOrg
@@ -34,7 +34,7 @@
28 pascal16 RoundRect(word s_word s_word s_word s_word s_word s_word)
RoundRect16
29 pascal16 PatBlt(word s_word s_word s_word s_word long) PatBlt16
-30 pascal16 SaveDC(word) SaveDC
+30 pascal16 SaveDC(word) SaveDC16
31 pascal SetPixel(word s_word s_word long) SetPixel16
32 pascal16 OffsetClipRgn(word s_word s_word) OffsetClipRgn16
33 pascal16 TextOut(word s_word s_word ptr word) TextOut16
@@ -45,7 +45,7 @@
36 pascal16 Polygon (word ptr word) Polygon16
37 pascal16 Polyline (word ptr word) Polyline16
38 pascal Escape(word word word segptr segptr) Escape
-39 pascal16 RestoreDC(word s_word) RestoreDC
+39 pascal16 RestoreDC(word s_word) RestoreDC16
40 pascal16 FillRgn(word word word) FillRgn16
41 pascal16 FrameRgn(word word word word word) FrameRgn16
42 pascal16 InvertRgn(word word) InvertRgn16
@@ -58,7 +58,7 @@
49 pascal16 CreateBitmapIndirect(ptr) CreateBitmapIndirect16
50 pascal16 CreateBrushIndirect(ptr) CreateBrushIndirect16
51 pascal16 CreateCompatibleBitmap(word word word) CreateCompatibleBitmap
-52 pascal16 CreateCompatibleDC(word) CreateCompatibleDC
+52 pascal16 CreateCompatibleDC(word) CreateCompatibleDC16
53 pascal16 CreateDC(ptr ptr ptr ptr) CreateDC16
54 pascal16 CreateEllipticRgn(s_word s_word s_word s_word) CreateEllipticRgn16
55 pascal16 CreateEllipticRgnIndirect(ptr) CreateEllipticRgnIndirect16
@@ -74,36 +74,36 @@
65 pascal16 CreateRectRgnIndirect(ptr) CreateRectRgnIndirect16
66 pascal16 CreateSolidBrush(long) CreateSolidBrush16
67 pascal16 DPtoLP(word ptr s_word) DPtoLP16
-68 pascal16 DeleteDC(word) DeleteDC
+68 pascal16 DeleteDC(word) DeleteDC16
69 pascal16 DeleteObject(word) DeleteObject16
70 pascal16 EnumFonts(word ptr segptr long) THUNK_EnumFonts16
71 pascal16 EnumObjects(word word segptr long) THUNK_EnumObjects16
72 pascal16 EqualRgn(word word) EqualRgn16
73 pascal16 ExcludeVisRect(word s_word s_word s_word s_word) ExcludeVisRect
74 pascal GetBitmapBits(word long ptr) GetBitmapBits
-75 pascal GetBkColor(word) GetBkColor
-76 pascal16 GetBkMode(word) GetBkMode
+75 pascal GetBkColor(word) GetBkColor16
+76 pascal16 GetBkMode(word) GetBkMode16
77 pascal16 GetClipBox(word ptr) GetClipBox16
-78 pascal GetCurrentPosition(word) GetCurrentPosition
-79 pascal GetDCOrg(word) GetDCOrg
+78 pascal GetCurrentPosition(word) GetCurrentPosition
+79 pascal GetDCOrg(word) GetDCOrg
80 pascal16 GetDeviceCaps(word s_word) GetDeviceCaps
-81 pascal16 GetMapMode(word) GetMapMode
+81 pascal16 GetMapMode(word) GetMapMode16
82 pascal16 GetObject(word s_word ptr) GetObject16
83 pascal GetPixel(word s_word s_word) GetPixel16
-84 pascal16 GetPolyFillMode(word) GetPolyFillMode
-85 pascal16 GetROP2(word) GetROP2
-86 pascal16 GetRelAbs(word) GetRelAbs
+84 pascal16 GetPolyFillMode(word) GetPolyFillMode16
+85 pascal16 GetROP2(word) GetROP216
+86 pascal16 GetRelAbs(word) GetRelAbs16
87 pascal16 GetStockObject(word) GetStockObject16
-88 pascal16 GetStretchBltMode(word) GetStretchBltMode
-89 pascal16 GetTextCharacterExtra(word) GetTextCharacterExtra
-90 pascal GetTextColor(word) GetTextColor
-91 pascal GetTextExtent(word ptr s_word) GetTextExtent
+88 pascal16 GetStretchBltMode(word) GetStretchBltMode16
+89 pascal16 GetTextCharacterExtra(word) GetTextCharacterExtra16
+90 pascal GetTextColor(word) GetTextColor16
+91 pascal GetTextExtent(word ptr s_word) GetTextExtent
92 pascal16 GetTextFace(word s_word ptr) GetTextFace16
93 pascal16 GetTextMetrics(word ptr) GetTextMetrics16
-94 pascal GetViewportExt(word) GetViewportExt
-95 pascal GetViewportOrg(word) GetViewportOrg
-96 pascal GetWindowExt(word) GetWindowExt
-97 pascal GetWindowOrg(word) GetWindowOrg
+94 pascal GetViewportExt(word) GetViewportExt
+95 pascal GetViewportOrg(word) GetViewportOrg
+96 pascal GetWindowExt(word) GetWindowExt
+97 pascal GetWindowOrg(word) GetWindowOrg
98 pascal16 IntersectVisRect(word s_word s_word s_word s_word)
IntersectVisRect
99 pascal16 LPtoDP(word ptr s_word) LPtoDP16
@@ -136,7 +136,7 @@
149 pascal GetBrushOrg(word) GetBrushOrg
150 pascal16 UnrealizeObject(word) UnrealizeObject16
151 pascal16 CopyMetaFile(word ptr) CopyMetaFile
-153 pascal16 CreateIC(ptr ptr ptr ptr) CreateIC
+153 pascal16 CreateIC(ptr ptr ptr ptr) CreateIC16
154 pascal GetNearestColor(word long) GetNearestColor
155 stub QueryAbort
156 pascal16 CreateDiscardableBitmap(word word word) CreateDiscardableBitmap
@@ -216,7 +216,7 @@
304 stub ENGINESETFONTCONTEXT
305 stub ENGINEGETGLYPHBMP
306 stub ENGINEMAKEFONTDIR
-307 pascal16 GetCharABCWidths(word word word ptr) GetCharABCWidths
+307 pascal16 GetCharABCWidths(word word word ptr) GetCharABCWidths16
308 stub GetOutLineTextMetrics
309 pascal GetGlyphOutLine(word word word ptr long ptr ptr) GetGlyphOutLine
310 pascal16 CreateScalableFontResource(word ptr ptr ptr) CreateScalableFontResource
@@ -229,12 +229,12 @@
317 stub EngineGetGlyphBmpExt
330 pascal16 EnumFontFamilies(word ptr segptr long) THUNK_EnumFontFamilies16
332 pascal16 GetKerningPairs(word word ptr) GetKerningPairs
-345 pascal16 GetTextAlign(word) GetTextAlign
-346 pascal16 SetTextAlign(word word) SetTextAlign
+345 pascal16 GetTextAlign(word) GetTextAlign16
+346 pascal16 SetTextAlign(word word) SetTextAlign16
348 pascal16 Chord(word s_word s_word s_word s_word s_word s_word
s_word s_word) Chord16
349 pascal SetMapperFlags(word long) SetMapperFlags
-350 pascal16 GetCharWidth(word word word ptr) GetCharWidth
+350 pascal16 GetCharWidth(word word word ptr) GetCharWidth16
351 pascal16 ExtTextOut(word s_word s_word word ptr ptr word ptr) ExtTextOut16
352 stub GetPhysicalFontHandle
353 stub GetAspectRatioFilter
@@ -255,7 +255,7 @@
374 pascal16 GetSystemPaletteUse(word) GetSystemPaletteUse
375 pascal16 GetSystemPaletteEntries(word word word ptr)
GetSystemPaletteEntries
-376 pascal16 ResetDC(word ptr) ResetDC
+376 pascal16 ResetDC(word ptr) ResetDC16
377 stub STARTDOC
378 stub ENDDOC
379 stub STARTPAGE
@@ -274,11 +274,11 @@
412 pascal16 IsDCCurrentPalette(word) IsDCCurrentPalette
439 pascal16 StretchDIBits (word s_word s_word s_word s_word s_word s_word
s_word s_word ptr ptr word long) StretchDIBits16
-440 pascal16 SetDIBits(word word word word ptr ptr word) SetDIBits
-441 pascal16 GetDIBits(word word word word ptr ptr word) GetDIBits
-442 pascal16 CreateDIBitmap(word ptr long ptr ptr word) CreateDIBitmap
-443 pascal16 SetDIBitsToDevice(word s_word s_word word word word word
- word word ptr ptr word) SetDIBitsToDevice
+440 pascal16 SetDIBits(word word word word ptr ptr word) SetDIBits16
+441 pascal16 GetDIBits(word word word word ptr ptr word) GetDIBits16
+442 pascal16 CreateDIBitmap(word ptr long ptr ptr word) CreateDIBitmap16
+443 pascal16 SetDIBitsToDevice(word s_word s_word s_word s_word s_word s_word
+ word word ptr ptr word) SetDIBitsToDevice16
444 pascal16 CreateRoundRectRgn(s_word s_word s_word s_word s_word s_word)
CreateRoundRectRgn16
445 pascal16 CreateDIBPatternBrush(word word) CreateDIBPatternBrush16
diff --git a/if1632/gdi32.spec b/if1632/gdi32.spec
index 7e41277..08f90e6 100644
--- a/if1632/gdi32.spec
+++ b/if1632/gdi32.spec
@@ -33,13 +33,13 @@
0028 stub CreateColorSpaceA
0029 stub CreateColorSpaceW
0030 stdcall CreateCompatibleBitmap(long long long) CreateCompatibleBitmap
-0031 stdcall CreateCompatibleDC(long) CreateCompatibleDC
+0031 stdcall CreateCompatibleDC(long) CreateCompatibleDC32
0032 stdcall CreateDCA(ptr ptr ptr ptr) CreateDC32A
0033 stdcall CreateDCW(ptr ptr ptr ptr) CreateDC32W
0034 stdcall CreateDIBPatternBrush(long long) CreateDIBPatternBrush32
0035 stub CreateDIBPatternBrushPt
0036 stub CreateDIBSection
-0037 stdcall CreateDIBitmap(long ptr long ptr ptr long) CreateDIBitmap
+0037 stdcall CreateDIBitmap(long ptr long ptr ptr long) CreateDIBitmap32
0038 stdcall CreateDiscardableBitmap(long long long) CreateDiscardableBitmap
0039 stdcall CreateEllipticRgn(long long long long) CreateEllipticRgn32
0040 stdcall CreateEllipticRgnIndirect(ptr) CreateEllipticRgnIndirect32
@@ -53,8 +53,8 @@
long long long long long ptr) CreateFont32W
0047 stub CreateHalftonePalette
0048 stdcall CreateHatchBrush(long long) CreateHatchBrush32
-0049 stdcall CreateICA(ptr ptr ptr ptr) CreateIC
-0050 stub CreateICW
+0049 stdcall CreateICA(ptr ptr ptr ptr) CreateIC32A
+0050 stdcall CreateICW(ptr ptr ptr ptr) CreateIC32W
0051 stub CreateMetaFileA
0052 stub CreateMetaFileW
0053 stdcall CreatePalette(ptr) CreatePalette
@@ -72,7 +72,7 @@
0064 stdcall CreateSolidBrush(long) CreateSolidBrush32
0065 stdcall DPtoLP(long ptr long) DPtoLP32
0066 stub DeleteColorSpace
-0067 stdcall DeleteDC(long) DeleteDC
+0067 stdcall DeleteDC(long) DeleteDC32
0068 stub DeleteEnhMetaFile
0069 stub DeleteMetaFile
0070 stdcall DeleteObject(long) DeleteObject32
@@ -150,20 +150,20 @@
0142 stub GetAspectRatioFilterEx
0143 stdcall GetBitmapBits(long long ptr) GetBitmapBits
0144 stdcall GetBitmapDimensionEx(long ptr) GetBitmapDimensionEx32
-0145 stdcall GetBkColor(long) GetBkColor
-0146 stub GetBkMode
+0145 stdcall GetBkColor(long) GetBkColor32
+0146 stdcall GetBkMode(long) GetBkMode32
0147 stub GetBoundsRect
0148 stdcall GetBrushOrgEx(long ptr) GetBrushOrgEx32
-0149 stub GetCharABCWidthsA
+0149 stdcall GetCharABCWidthsA(long long long ptr) GetCharABCWidths32A
0150 stub GetCharABCWidthsFloatA
0151 stub GetCharABCWidthsFloatW
-0152 stub GetCharABCWidthsW
-0153 stdcall GetCharWidth32A(long long long long) GetCharWidth
-0154 stub GetCharWidth32W
-0155 stdcall GetCharWidthA(long long long long) GetCharWidth
+0152 stdcall GetCharABCWidthsW(long long long ptr) GetCharABCWidths32W
+0153 stdcall GetCharWidth32A(long long long long) GetCharWidth32A
+0154 stdcall GetCharWidth32W(long long long long) GetCharWidth32W
+0155 stdcall GetCharWidthA(long long long long) GetCharWidth32A
0156 stub GetCharWidthFloatA
0157 stub GetCharWidthFloatW
-0158 stub GetCharWidthW
+0158 stdcall GetCharWidthW(long long long long) GetCharWidth32W
0159 stub GetCharWidthWOW
0160 stub GetCharacterPlacementA
0161 stub GetCharacterPlacementW
@@ -175,7 +175,7 @@
0167 stdcall GetCurrentPositionEx(long ptr) GetCurrentPositionEx32
0168 stdcall GetDCOrgEx(long ptr) GetDCOrgEx
0169 stub GetDIBColorTable
-0170 stub GetDIBits
+0170 stdcall GetDIBits(long long long long ptr ptr long) GetDIBits32
0171 stdcall GetDeviceCaps(long long) GetDeviceCaps
0172 stub GetDeviceGammaRamp
0173 stub GetETM
@@ -201,7 +201,7 @@
0193 stub GetKerningPairsW
0194 stub GetLogColorSpaceA
0195 stub GetLogColorSpaceW
-0196 stub GetMapMode
+0196 stdcall GetMapMode(long) GetMapMode32
0197 stub GetMetaFileA
0198 stub GetMetaFileBitsEx
0199 stub GetMetaFileW
@@ -218,21 +218,21 @@
0210 stub GetPath
0211 stdcall GetPixel(long long long) GetPixel32
0212 stub GetPixelFormat
-0213 stub GetPolyFillMode
-0214 stub GetROP2
+0213 stdcall GetPolyFillMode(long) GetPolyFillMode32
+0214 stdcall GetROP2(long) GetROP232
0215 stub GetRandomRgn
0216 stub GetRasterizerCaps
0217 stub GetRegionData
-0218 stub GetRelAbs
+0218 stdcall GetRelAbs(long) GetRelAbs32
0219 stdcall GetRgnBox(long ptr) GetRgnBox32
0220 stdcall GetStockObject(long) GetStockObject32
-0221 stub GetStretchBltMode
+0221 stdcall GetStretchBltMode(long) GetStretchBltMode32
0222 stdcall GetSystemPaletteEntries(long long long ptr) GetSystemPaletteEntries
0223 stub GetSystemPaletteUse
-0224 stub GetTextAlign
-0225 stub GetTextCharacterExtra
+0224 stdcall GetTextAlign(long) GetTextAlign32
+0225 stdcall GetTextCharacterExtra(long) GetTextCharacterExtra32
0226 stub GetTextCharset
-0227 stdcall GetTextColor(long) GetTextColor
+0227 stdcall GetTextColor(long) GetTextColor32
0228 stdcall GetTextExtentExPointA(long ptr long long ptr ptr ptr) GetTextExtentExPoint32A
0229 stdcall GetTextExtentExPointW(long ptr long long ptr ptr ptr) GetTextExtentExPoint32W
0230 stdcall GetTextExtentPoint32A(long ptr long ptr) GetTextExtentPoint32A
@@ -292,12 +292,12 @@
0284 stub RemoveFontResourceA
0285 stub RemoveFontResourceTracking
0286 stub RemoveFontResourceW
-0287 stub ResetDCA
-0288 stub ResetDCW
+0287 stdcall ResetDCA(long ptr) ResetDC32A
+0288 stdcall ResetDCW(long ptr) ResetDC32W
0289 stub ResizePalette
-0290 stdcall RestoreDC(long long) RestoreDC
+0290 stdcall RestoreDC(long long) RestoreDC32
0291 stdcall RoundRect(long long long long long long long) RoundRect32
-0292 stdcall SaveDC(long) SaveDC
+0292 stdcall SaveDC(long) SaveDC32
0293 stdcall ScaleViewportExtEx(long long long long long ptr) ScaleViewportExtEx32
0294 stdcall ScaleWindowExtEx(long long long long long ptr) ScaleWindowExtEx32
0295 stub SelectBrushLocal
@@ -311,15 +311,15 @@
0303 stdcall SetBitmapBits(long long ptr) SetBitmapBits
0304 stdcall SetBitmapDimensionEx(long long long ptr) SetBitmapDimensionEx32
0305 stdcall SetBkColor(long long) SetBkColor
-0306 stdcall SetBkMode(long long) SetBkMode
+0306 stdcall SetBkMode(long long) SetBkMode32
0307 stub SetBoundsRect
0308 stdcall SetBrushOrgEx(long long long ptr) SetBrushOrgEx
0309 stub SetColorAdjustment
0310 stub SetColorSpace
0311 stub SetDIBColorTable
-0312 stdcall SetDIBits(long long long long ptr ptr long) SetDIBits
+0312 stdcall SetDIBits(long long long long ptr ptr long) SetDIBits32
0313 stdcall SetDIBitsToDevice(long long long long long long long long long
- ptr ptr long) SetDIBitsToDevice
+ ptr ptr long) SetDIBitsToDevice32
0314 stub SetDeviceGammaRamp
0315 stub SetEnhMetaFileBits
0316 stub SetFontEnumeration
@@ -327,7 +327,7 @@
0318 stub SetICMMode
0319 stub SetICMProfileA
0320 stub SetICMProfileW
-0321 stdcall SetMapMode(long long) SetMapMode
+0321 stdcall SetMapMode(long long) SetMapMode32
0322 stdcall SetMapperFlags(long long) SetMapperFlags
0323 stub SetMetaFileBitsEx
0324 stub SetMetaRgn
@@ -336,16 +336,16 @@
0327 stdcall SetPixel(long long long long) SetPixel32
0328 stub SetPixelFormat
0329 stub SetPixelV
-0330 stub SetPolyFillMode
-0331 stdcall SetROP2(long long) SetROP2
+0330 stdcall SetPolyFillMode(long long) SetPolyFillMode32
+0331 stdcall SetROP2(long long) SetROP232
0332 stdcall SetRectRgn(long long long long long) SetRectRgn
-0333 stub SetRelAbs
-0334 stdcall SetStretchBltMode(long long) SetStretchBltMode
+0333 stdcall SetRelAbs(long long) SetRelAbs32
+0334 stdcall SetStretchBltMode(long long) SetStretchBltMode32
0335 stub SetSystemPaletteUse
-0336 stdcall SetTextAlign(long long) SetTextAlign
-0337 stub SetTextCharacterExtra
+0336 stdcall SetTextAlign(long long) SetTextAlign32
+0337 stdcall SetTextCharacterExtra(long long) SetTextCharacterExtra32
0338 stdcall SetTextColor(long long) SetTextColor
-0339 stub SetTextJustification
+0339 stdcall SetTextJustification(long long long) SetTextJustification32
0340 stdcall SetViewportExtEx(long long long ptr) SetViewportExtEx32
0341 stdcall SetViewportOrgEx(long long long ptr) SetViewportOrgEx32
0342 stub SetVirtualResolution
diff --git a/if1632/keyboard.spec b/if1632/keyboard.spec
index d88895c..ae04afa 100644
--- a/if1632/keyboard.spec
+++ b/if1632/keyboard.spec
@@ -5,8 +5,8 @@
#2 pascal Enable
#3 pascal Disable
4 pascal16 ToAscii(word word ptr ptr word) ToAscii
-5 pascal16 AnsiToOem(ptr ptr) AnsiToOem
-6 pascal16 OemToAnsi(ptr ptr) OemToAnsi
+5 pascal16 AnsiToOem(ptr ptr) AnsiToOem16
+6 pascal16 OemToAnsi(ptr ptr) OemToAnsi16
7 return SetSpeed 2 65535
#100 pascal ScreenSwitchEnable
#126 pascal GetTableSeg
@@ -17,8 +17,8 @@
131 pascal16 MapVirtualKey(word word) MapVirtualKey
132 pascal16 GetKbCodePage() GetKbCodePage
133 pascal16 GetKeyNameText(long ptr word) GetKeyNameText16
-134 pascal16 AnsiToOemBuff(ptr ptr word) AnsiToOemBuff
-135 pascal16 OemToAnsiBuff(ptr ptr word) OemToAnsiBuff
+134 pascal16 AnsiToOemBuff(ptr ptr word) AnsiToOemBuff16
+135 pascal16 OemToAnsiBuff(ptr ptr word) OemToAnsiBuff16
#136 pascal EnableKbSysReq
#137 pascal GetBiosKeyProc
diff --git a/include/color.h b/include/color.h
index cd42b82..8eada96 100644
--- a/include/color.h
+++ b/include/color.h
@@ -14,6 +14,7 @@
#define PC_SYS_MAPPED 0x10 /* logical palentry is a direct alias for system palentry */
extern HPALETTE16 COLOR_Init(void);
+extern void COLOR_Cleanup(void);
extern COLORREF COLOR_ToLogical(int pixel);
extern int COLOR_ToPhysical( DC *dc, COLORREF color );
extern int COLOR_SetMapping( PALETTEOBJ* pal, BOOL32 mapOnly );
diff --git a/include/debugger.h b/include/debugger.h
index ebdefc4..306cb18 100644
--- a/include/debugger.h
+++ b/include/debugger.h
@@ -10,6 +10,8 @@
#include "ldt.h"
#include "registers.h"
+#include "pe_image.h"
+
#define STEP_FLAG 0x100 /* single step flag */
typedef struct
@@ -18,6 +20,45 @@
DWORD off;
} DBG_ADDR;
+struct wine_lines {
+ unsigned long line_number;
+ DBG_ADDR pc_offset;
+};
+
+typedef struct wine_lines WineLineNo;
+
+/*
+ * This structure holds information about stack variables, function
+ * parameters, and register variables, which are all local to this
+ * function.
+ */
+struct wine_locals {
+ unsigned int regno:8; /* For register symbols */
+ unsigned int offset:24; /* offset from esp/ebp to symbol */
+ unsigned int pc_start; /* For RBRAC/LBRAC */
+ unsigned int pc_end; /* For RBRAC/LBRAC */
+ char * name; /* Name of symbol */
+};
+
+typedef struct wine_locals WineLocals;
+
+struct name_hash
+{
+ struct name_hash * next;
+ char * name;
+ char * sourcefile;
+
+ int n_locals;
+ int locals_alloc;
+ WineLocals * local_vars;
+
+ int n_lines;
+ int lines_alloc;
+ WineLineNo * linetab;
+
+ DBG_ADDR addr;
+};
+
#define DBG_FIX_ADDR_SEG(addr,default) \
{ if ((addr)->seg == 0xffffffff) (addr)->seg = (default); \
if (((addr)->seg == WINE_CODE_SELECTOR) || \
@@ -30,13 +71,13 @@
#define DBG_CHECK_READ_PTR(addr,len) \
(!DEBUG_IsBadReadPtr((addr),(len)) || \
(fprintf(stderr,"*** Invalid address "), \
- DEBUG_PrintAddress((addr),dbg_mode), \
+ DEBUG_PrintAddress((addr),dbg_mode, FALSE), \
fprintf(stderr,"\n"),0))
#define DBG_CHECK_WRITE_PTR(addr,len) \
(!DEBUG_IsBadWritePtr((addr),(len)) || \
(fprintf(stderr,"*** Invalid address "), \
- DEBUG_PrintAddress(addr,dbg_mode), \
+ DEBUG_PrintAddress(addr,dbg_mode, FALSE), \
fprintf(stderr,"\n"),0))
#ifdef REG_SP /* Some Sun includes define this */
@@ -79,18 +120,36 @@
extern void DEBUG_Disasm( DBG_ADDR *addr );
/* debugger/hash.c */
-extern void DEBUG_AddSymbol( const char *name, const DBG_ADDR *addr );
-extern BOOL32 DEBUG_GetSymbolValue( const char * name, DBG_ADDR *addr );
+extern struct name_hash * DEBUG_AddSymbol( const char *name,
+ const DBG_ADDR *addr,
+ const char * sourcefile);
+extern BOOL32 DEBUG_GetSymbolValue( const char * name, const int lineno,
+ DBG_ADDR *addr );
extern BOOL32 DEBUG_SetSymbolValue( const char * name, const DBG_ADDR *addr );
-extern const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr );
+extern const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr, int flag,
+ struct name_hash ** rtn,
+ unsigned int ebp);
extern void DEBUG_ReadSymbolTable( const char * filename );
extern void DEBUG_LoadEntryPoints(void);
+extern void DEBUG_AddLineNumber( struct name_hash * func, int line_num,
+ unsigned long offset );
+extern void DEBUG_AddLocal( struct name_hash * func, int regno,
+ int offset,
+ int pc_start,
+ int pc_end,
+ char * name);
+
/* debugger/info.c */
extern void DEBUG_Print( const DBG_ADDR *addr, int count, char format );
-extern void DEBUG_PrintAddress( const DBG_ADDR *addr, int addrlen );
+extern struct name_hash * DEBUG_PrintAddress( const DBG_ADDR *addr,
+ int addrlen, int flag );
extern void DEBUG_Help(void);
extern void DEBUG_List( DBG_ADDR *addr, int count );
+extern struct name_hash * DEBUG_PrintAddressAndArgs( const DBG_ADDR *addr,
+ int addrlen,
+ unsigned int ebp,
+ int flag );
/* debugger/memory.c */
extern BOOL32 DEBUG_IsBadReadPtr( const DBG_ADDR *address, int size );
@@ -108,6 +167,17 @@
/* debugger/stack.c */
extern void DEBUG_InfoStack(void);
extern void DEBUG_BackTrace(void);
+extern BOOL32 DEBUG_GetStackSymbolValue( const char * name, DBG_ADDR *addr );
+extern int DEBUG_InfoLocals(void);
+extern int DEBUG_SetFrame(int newframe);
+
+ /* debugger/stabs.c */
+extern int DEBUG_ReadExecutableDbgInfo(void);
+
+ /* debugger/msc.c */
+extern int DEBUG_RegisterDebugInfo(int, struct pe_data *pe,
+ int, unsigned long, unsigned long);
+extern int DEBUG_ProcessDeferredDebug(void);
/* debugger/dbg.y */
extern void DEBUG_EnterDebugger(void);
diff --git a/include/except.h b/include/except.h
index 582a695..0fbd40e 100644
--- a/include/except.h
+++ b/include/except.h
@@ -216,7 +216,4 @@
DWORD UnhandledExceptionFilter(PEXCEPTION_POINTERS epointers);
-__PTOP_EXCFILTER SetUnhandledExceptionFilter(
- LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter);
-
#endif /* __WINE_EXCEPT_H */
diff --git a/include/gdi.h b/include/gdi.h
index 066bd02..b00988e 100644
--- a/include/gdi.h
+++ b/include/gdi.h
@@ -107,19 +107,11 @@
BYTE bitsPerPixel;
- WORD MapMode;
- short DCOrgX; /* DC origin */
- short DCOrgY;
- short CursPosX; /* Current position */
- short CursPosY;
- short WndOrgX;
- short WndOrgY;
- short WndExtX;
- short WndExtY;
- short VportOrgX;
- short VportOrgY;
- short VportExtX;
- short VportExtY;
+ INT32 MapMode;
+ INT32 DCOrgX; /* DC origin */
+ INT32 DCOrgY;
+ INT32 CursPosX; /* Current position */
+ INT32 CursPosY;
} WIN_DC_INFO;
typedef X11DRV_PDEVICE X_DC_INFO; /* Temporary */
@@ -130,10 +122,19 @@
HDC32 hSelf; /* Handle to this DC */
const struct tagDC_FUNCS *funcs; /* DC function table */
void *physDev; /* Physical device (driver-specific) */
- WORD saveLevel;
+ INT32 saveLevel;
DWORD dwHookData;
FARPROC16 hookProc;
+ INT32 wndOrgX; /* Window origin */
+ INT32 wndOrgY;
+ INT32 wndExtX; /* Window extent */
+ INT32 wndExtY;
+ INT32 vportOrgX; /* Viewport origin */
+ INT32 vportOrgY;
+ INT32 vportExtX; /* Viewport extent */
+ INT32 vportExtY;
+
WIN_DC_INFO w;
union
{
@@ -168,8 +169,8 @@
BOOL32 (*pLineTo)(DC*,INT32,INT32);
BOOL32 (*pMoveToEx)(DC*,INT32,INT32,LPPOINT32);
INT32 (*pOffsetClipRgn)(DC*,INT32,INT32);
- BOOL32 (*pOffsetViewportOrgEx)(DC*,INT32,INT32,LPPOINT32);
- BOOL32 (*pOffsetWindowOrgEx)(DC*,INT32,INT32,LPPOINT32);
+ BOOL32 (*pOffsetViewportOrg)(DC*,INT32,INT32);
+ BOOL32 (*pOffsetWindowOrg)(DC*,INT32,INT32);
BOOL32 (*pPaintRgn)(DC*,HRGN32);
BOOL32 (*pPatBlt)(DC*,INT32,INT32,INT32,INT32,DWORD);
BOOL32 (*pPie)(DC*,INT32,INT32,INT32,INT32,INT32,INT32,INT32,INT32);
@@ -181,8 +182,8 @@
BOOL32 (*pRestoreDC)(DC*,INT32);
BOOL32 (*pRoundRect)(DC*,INT32,INT32,INT32,INT32,INT32,INT32);
INT32 (*pSaveDC)(DC*);
- BOOL32 (*pScaleViewportExtEx)(DC*,INT32,INT32,INT32,INT32,LPSIZE32);
- BOOL32 (*pScaleWindowExtEx)(DC*,INT32,INT32,INT32,INT32,LPSIZE32);
+ BOOL32 (*pScaleViewportExt)(DC*,INT32,INT32,INT32,INT32);
+ BOOL32 (*pScaleWindowExt)(DC*,INT32,INT32,INT32,INT32);
INT32 (*pSelectClipRgn)(DC*,HRGN32);
HANDLE32 (*pSelectObject)(DC*,HANDLE32);
HPALETTE32 (*pSelectPalette)(DC*,HPALETTE32,BOOL32);
@@ -190,7 +191,7 @@
WORD (*pSetBkMode)(DC*,WORD);
VOID (*pSetDeviceClipping)(DC*);
INT32 (*pSetDIBitsToDevice)(DC*,INT32,INT32,DWORD,DWORD,INT32,INT32,UINT32,UINT32,LPCVOID,const BITMAPINFO*,UINT32);
- WORD (*pSetMapMode)(DC*,WORD);
+ INT32 (*pSetMapMode)(DC*,INT32);
DWORD (*pSetMapperFlags)(DC*,DWORD);
COLORREF (*pSetPixel)(DC*,INT32,INT32,COLORREF);
WORD (*pSetPolyFillMode)(DC*,WORD);
@@ -201,10 +202,10 @@
INT32 (*pSetTextCharacterExtra)(DC*,INT32);
DWORD (*pSetTextColor)(DC*,DWORD);
INT32 (*pSetTextJustification)(DC*,INT32,INT32);
- BOOL32 (*pSetViewportExtEx)(DC*,INT32,INT32,LPSIZE32);
- BOOL32 (*pSetViewportOrgEx)(DC*,INT32,INT32,LPPOINT32);
- BOOL32 (*pSetWindowExtEx)(DC*,INT32,INT32,LPSIZE32);
- BOOL32 (*pSetWindowOrgEx)(DC*,INT32,INT32,LPPOINT32);
+ BOOL32 (*pSetViewportExt)(DC*,INT32,INT32);
+ BOOL32 (*pSetViewportOrg)(DC*,INT32,INT32);
+ BOOL32 (*pSetWindowExt)(DC*,INT32,INT32);
+ BOOL32 (*pSetWindowOrg)(DC*,INT32,INT32);
BOOL32 (*pStretchBlt)(DC*,INT32,INT32,INT32,INT32,DC*,INT32,INT32,INT32,INT32,DWORD);
INT32 (*pStretchDIBits)(DC*,INT32,INT32,INT32,INT32,INT32,INT32,INT32,INT32,LPSTR,LPBITMAPINFO,WORD,DWORD);
BOOL32 (*pTextOut)(DC*,INT32,INT32,LPCSTR,INT32);
@@ -259,13 +260,13 @@
/* Device <-> logical coords conversion */
#define XDPTOLP(dc,x) \
-(((x)-(dc)->w.VportOrgX) * (dc)->w.WndExtX / (dc)->w.VportExtX+(dc)->w.WndOrgX)
+ (((x)-(dc)->vportOrgX) * (dc)->wndExtX / (dc)->vportExtX+(dc)->wndOrgX)
#define YDPTOLP(dc,y) \
-(((y)-(dc)->w.VportOrgY) * (dc)->w.WndExtY / (dc)->w.VportExtY+(dc)->w.WndOrgY)
+ (((y)-(dc)->vportOrgY) * (dc)->wndExtY / (dc)->vportExtY+(dc)->wndOrgY)
#define XLPTODP(dc,x) \
-(((x)-(dc)->w.WndOrgX) * (dc)->w.VportExtX / (dc)->w.WndExtX+(dc)->w.VportOrgX)
+ (((x)-(dc)->wndOrgX) * (dc)->vportExtX / (dc)->wndExtX+(dc)->vportOrgX)
#define YLPTODP(dc,y) \
-(((y)-(dc)->w.WndOrgY) * (dc)->w.VportExtY / (dc)->w.WndExtY+(dc)->w.VportOrgY)
+ (((y)-(dc)->wndOrgY) * (dc)->vportExtY / (dc)->wndExtY+(dc)->vportOrgY)
/* GDI local heap */
diff --git a/include/heap.h b/include/heap.h
index e262c09..5cdfdeb 100644
--- a/include/heap.h
+++ b/include/heap.h
@@ -17,6 +17,8 @@
extern SEGPTR HEAP_GetSegptr( HANDLE32 heap, DWORD flags, LPCVOID ptr );
extern LPSTR HEAP_strdupA( HANDLE32 heap, DWORD flags, LPCSTR str );
extern LPWSTR HEAP_strdupW( HANDLE32 heap, DWORD flags, LPCWSTR str );
+extern LPWSTR HEAP_strdupAtoW( HANDLE32 heap, DWORD flags, LPCSTR str );
+extern LPSTR HEAP_strdupWtoA( HANDLE32 heap, DWORD flags, LPCWSTR str );
/* SEGPTR helper macros */
@@ -26,6 +28,8 @@
((type *)HeapAlloc( SegptrHeap, 0, sizeof(type) ))
#define SEGPTR_STRDUP(str) \
(HIWORD(str) ? HEAP_strdupA( SegptrHeap, 0, (str) ) : (LPSTR)(str))
+#define SEGPTR_STRDUP_WtoA(str) \
+ (HIWORD(str) ? HEAP_strdupWtoA( SegptrHeap, 0, (str) ) : (LPSTR)(str))
#define SEGPTR_GET(ptr) \
(HIWORD(ptr) ? HEAP_GetSegptr( SegptrHeap, 0, (ptr) ) : (SEGPTR)(ptr))
#define SEGPTR_FREE(ptr) \
diff --git a/include/message.h b/include/message.h
index 622059a..f51efd2 100644
--- a/include/message.h
+++ b/include/message.h
@@ -31,6 +31,7 @@
extern void EVENT_Synchronize(void);
extern void EVENT_ProcessEvent( XEvent *event );
extern void EVENT_RegisterWindow( WND *pWnd );
+extern void EVENT_DestroyWindow( WND *pWnd );
extern void EVENT_DummyMotionNotify(void);
#endif /* __WINE_MESSAGE_H */
diff --git a/include/metafiledrv.h b/include/metafiledrv.h
index 14b2da5..91027a8 100644
--- a/include/metafiledrv.h
+++ b/include/metafiledrv.h
@@ -32,5 +32,16 @@
INT32 widthDst, INT32 heightDst,
struct tagDC *dcSrc, INT32 xSrc, INT32 ySrc,
INT32 widthSrc, INT32 heightSrc, DWORD rop );
+extern INT32 MFDRV_SetMapMode( struct tagDC *dc, INT32 mode );
+extern BOOL32 MFDRV_SetViewportExt( struct tagDC *dc, INT32 x, INT32 y );
+extern BOOL32 MFDRV_SetViewportOrg( struct tagDC *dc, INT32 x, INT32 y );
+extern BOOL32 MFDRV_SetWindowExt( struct tagDC *dc, INT32 x, INT32 y );
+extern BOOL32 MFDRV_SetWindowOrg( struct tagDC *dc, INT32 x, INT32 y );
+extern BOOL32 MFDRV_OffsetViewportOrg( struct tagDC *dc, INT32 x, INT32 y );
+extern BOOL32 MFDRV_OffsetWindowOrg( struct tagDC *dc, INT32 x, INT32 y );
+extern BOOL32 MFDRV_ScaleViewportExt( struct tagDC *dc, INT32 xNum,
+ INT32 xDenom, INT32 yNum, INT32 yDenom );
+extern BOOL32 MFDRV_ScaleWindowExt( struct tagDC *dc, INT32 xNum, INT32 xDenom,
+ INT32 yNum, INT32 yDenom );
#endif /* __WINE_METAFILEDRV_H */
diff --git a/include/peexe.h b/include/peexe.h
index ff85a08..a7d5474 100644
--- a/include/peexe.h
+++ b/include/peexe.h
@@ -220,6 +220,32 @@
short Relocations[1];
};
+/*
+ * The IMAGE_FILE_DEBUG_DIRECTORY data directory points to an array of
+ * these structures.
+ */
+struct PE_Debug_dir
+{
+ u_long flags;
+ u_long timestamp;
+ u_short major;
+ u_short minor;
+ u_long type;
+ u_long dbgsize;
+ u_long dbgptr;
+ u_long dbgoff;
+};
+
+/*
+ * The type field above can take these (plus a few other
+ * irrelevant) values.
+ */
+#define IMAGE_DEBUG_TYPE_UNKNOWN 0
+#define IMAGE_DEBUG_TYPE_COFF 1
+#define IMAGE_DEBUG_TYPE_CODEVIEW 2
+#define IMAGE_DEBUG_TYPE_FPO 3
+#define IMAGE_DEBUG_TYPE_MISC 4
+
#define IMAGE_REL_BASED_ABSOLUTE 0
#define IMAGE_REL_BASED_HIGH 1
#define IMAGE_REL_BASED_LOW 2
diff --git a/include/string32.h b/include/string32.h
index 7791411..f8f234d 100644
--- a/include/string32.h
+++ b/include/string32.h
@@ -10,8 +10,6 @@
#include "wintypes.h"
-void STRING32_UniToAnsi(LPSTR dest,LPCWSTR src);
-void STRING32_AnsiToUni(LPWSTR dest,LPCSTR src);
LPSTR STRING32_DupUniToAnsi(LPCWSTR src);
LPWSTR STRING32_DupAnsiToUni(LPCSTR src);
LPWSTR STRING32_strdupW(LPCWSTR);
diff --git a/include/windows.h b/include/windows.h
index 1bac570..be336a8 100644
--- a/include/windows.h
+++ b/include/windows.h
@@ -4211,14 +4211,17 @@
WORD FreeSelector(WORD);
HANDLE16 GetAtomHandle(ATOM);
DWORD GetBitmapDimension(HBITMAP16);
+DWORD GetBrushOrg(HDC16);
HANDLE16 GetCodeHandle(FARPROC16);
INT16 GetCommError(INT16,LPCOMSTAT);
UINT16 GetCommEventMask(INT16,UINT16);
VOID GetCodeInfo(FARPROC16,LPVOID);
HANDLE16 GetCurrentPDB(void);
+DWORD GetCurrentPosition(HDC16);
HTASK16 GetCurrentTask(void);
DWORD GetDCHook(HDC16,FARPROC16*);
DWORD GetDCOrg(HDC16);
+HDC16 GetDCState(HDC16);
HWND16 GetDesktopHwnd(void);
HMODULE16 GetExePtr(HANDLE16);
WORD GetExeVersion(void);
@@ -4230,6 +4233,11 @@
DWORD GetSelectorLimit(WORD);
HINSTANCE16 GetTaskDS(void);
HQUEUE16 GetTaskQueue(HTASK16);
+DWORD GetTextExtent(HDC16,LPCSTR,INT16);
+DWORD GetViewportExt(HDC16);
+DWORD GetViewportOrg(HDC16);
+DWORD GetWindowExt(HDC16);
+DWORD GetWindowOrg(HDC16);
DWORD GlobalDOSAlloc(DWORD);
WORD GlobalDOSFree(WORD);
void GlobalFreeAll(HGLOBAL16);
@@ -4239,6 +4247,7 @@
WORD GlobalPageLock(HGLOBAL16);
WORD GlobalPageUnlock(HGLOBAL16);
INT16 InitApp(HINSTANCE16);
+HRGN16 InquireVisRgn(HDC16);
INT16 IntersectVisRect(HDC16,INT16,INT16,INT16,INT16);
BOOL16 IsGDIObject(HGDIOBJ16);
BOOL16 IsSharedSelector(HANDLE16);
@@ -4266,6 +4275,8 @@
DWORD SetBrushOrg(HDC16,INT16,INT16);
UINT16* SetCommEventMask(INT16,UINT16);
BOOL16 SetDCHook(HDC16,FARPROC16,DWORD);
+DWORD SetDCOrg(HDC16,INT16,INT16);
+VOID SetDCState(HDC16,HDC16);
BOOL16 SetDeskPattern(void);
VOID SetPriority(HTASK16,INT16);
WORD SetSelectorBase(WORD,DWORD);
@@ -4444,8 +4455,6 @@
BOOL16 SetCaretBlinkTime(UINT32);
BOOL16 SetCaretPos(INT32,INT32);
WORD SetClassWord(HWND32,INT32,WORD);
-INT16 SetDIBits(HDC32,HBITMAP32,UINT32,UINT32,LPCVOID,const BITMAPINFO*,UINT32);
-INT16 SetDIBitsToDevice(HDC32,INT32,INT32,DWORD,DWORD,INT32,INT32,UINT32,UINT32,LPCVOID,const BITMAPINFO*,UINT32);
VOID SetLastError(DWORD);
VOID SetLastErrorEx(DWORD,DWORD);
VOID SetRectRgn(HRGN32,INT32,INT32,INT32,INT32);
@@ -4474,6 +4483,14 @@
HGLOBAL16 AllocResource16(HINSTANCE16,HRSRC16,DWORD);
HGLOBAL32 AllocResource32(HINSTANCE32,HRSRC32,DWORD);
#define AllocResource WINELIB_NAME(AllocResource)
+INT16 AnsiToOem16(LPCSTR,LPSTR);
+#define AnsiToOem32A CharToOem32A
+#define AnsiToOem32W CharToOem32W
+#define AnsiToOem WINELIB_NAME_AW(AnsiToOem)
+VOID AnsiToOemBuff16(LPCSTR,LPSTR,UINT16);
+#define AnsiToOemBuff32A CharToOemBuff32A
+#define AnsiToOemBuff32W CharToOemBuff32W
+#define AnsiToOemBuff WINELIB_NAME_AW(AnsiToOemBuff)
BOOL16 AppendMenu16(HMENU16,UINT16,UINT16,SEGPTR);
BOOL32 AppendMenu32A(HMENU32,UINT32,UINT32,LPCSTR);
BOOL32 AppendMenu32W(HMENU32,UINT32,UINT32,LPCWSTR);
@@ -4529,10 +4546,10 @@
DWORD CharUpperBuff32A(LPSTR,DWORD);
DWORD CharUpperBuff32W(LPWSTR,DWORD);
#define CharUpperBuff WINELIB_NAME_AW(CharUpperBuff)
-BOOL32 CharToOem32A(LPSTR,LPSTR);
+BOOL32 CharToOem32A(LPCSTR,LPSTR);
BOOL32 CharToOem32W(LPCWSTR,LPSTR);
#define CharToOem WINELIB_NAME_AW(CharToOem)
-BOOL32 CharToOemBuff32A(LPSTR,LPSTR,DWORD);
+BOOL32 CharToOemBuff32A(LPCSTR,LPSTR,DWORD);
BOOL32 CharToOemBuff32W(LPCWSTR,LPSTR,DWORD);
#define CharToOemBuff WINELIB_NAME_AW(CharToOemBuff)
HWND16 ChildWindowFromPoint16(HWND16,POINT16);
@@ -4575,6 +4592,9 @@
HBRUSH16 CreateBrushIndirect16(const LOGBRUSH16*);
HBRUSH32 CreateBrushIndirect32(const LOGBRUSH32*);
#define CreateBrushIndirect WINELIB_NAME(CreateBrushIndirect)
+HDC16 CreateCompatibleDC16(HDC16);
+HDC32 CreateCompatibleDC32(HDC32);
+#define CreateCompatibleDC WINELIB_NAME(CreateCompatibleDC)
HDC16 CreateDC16(LPCSTR,LPCSTR,LPCSTR,const DEVMODE16*);
HDC32 CreateDC32A(LPCSTR,LPCSTR,LPCSTR,const DEVMODE32A*);
HDC32 CreateDC32W(LPCWSTR,LPCWSTR,LPCWSTR,const DEVMODE32W*);
@@ -4599,6 +4619,11 @@
HWND32 CreateDialogParam32A(HINSTANCE32,LPCSTR,HWND32,DLGPROC32,LPARAM);
HWND32 CreateDialogParam32W(HINSTANCE32,LPCWSTR,HWND32,DLGPROC32,LPARAM);
#define CreateDialogParam WINELIB_NAME_AW(CreateDialogParam)
+HBITMAP16 CreateDIBitmap16(HDC16,const BITMAPINFOHEADER*,DWORD,LPCVOID,
+ const BITMAPINFO*,UINT16);
+HBITMAP32 CreateDIBitmap32(HDC32,const BITMAPINFOHEADER*,DWORD,LPCVOID,
+ const BITMAPINFO*,UINT32);
+#define CreateDIBitmap WINELIB_NAME(CreateDIBitmap)
HBRUSH16 CreateDIBPatternBrush16(HGLOBAL16,UINT16);
HBRUSH32 CreateDIBPatternBrush32(HGLOBAL32,UINT32);
#define CreateDIBPatternBrush WINELIB_NAME(CreateDIBPatternBrush)
@@ -4626,6 +4651,10 @@
HBRUSH16 CreateHatchBrush16(INT16,COLORREF);
HBRUSH32 CreateHatchBrush32(INT32,COLORREF);
#define CreateHatchBrush WINELIB_NAME(CreateHatchBrush)
+HDC16 CreateIC16(LPCSTR,LPCSTR,LPCSTR,const DEVMODE16*);
+HDC32 CreateIC32A(LPCSTR,LPCSTR,LPCSTR,const DEVMODE32A*);
+HDC32 CreateIC32W(LPCWSTR,LPCWSTR,LPCWSTR,const DEVMODE32W*);
+#define CreateIC WINELIB_NAME_AW(CreateIC)
HDC16 CreateMetaFile16(LPCSTR);
HDC32 CreateMetaFile32A(LPCSTR);
HDC32 CreateMetaFile32W(LPCWSTR);
@@ -4691,6 +4720,9 @@
LRESULT DefWindowProc32A(HWND32,UINT32,WPARAM32,LPARAM);
LRESULT DefWindowProc32W(HWND32,UINT32,WPARAM32,LPARAM);
#define DefWindowProc WINELIB_NAME_AW(DefWindowProc)
+BOOL16 DeleteDC16(HDC16);
+BOOL32 DeleteDC32(HDC32);
+#define DeleteDC WINELIB_NAME(DeleteDC)
BOOL16 DeleteFile16(LPCSTR);
BOOL32 DeleteFile32A(LPCSTR);
BOOL32 DeleteFile32W(LPCWSTR);
@@ -4863,6 +4895,12 @@
BOOL16 GetBrushOrgEx16(HDC16,LPPOINT16);
BOOL32 GetBrushOrgEx32(HDC32,LPPOINT32);
#define GetBrushOrgEx WINELIB_NAME(GetBrushOrgEx)
+COLORREF GetBkColor16(HDC16);
+COLORREF GetBkColor32(HDC32);
+#define GetBkColor WINELIB_NAME(GetBkColor)
+INT16 GetBkMode16(HDC16);
+INT32 GetBkMode32(HDC32);
+#define GetBkMode WINELIB_NAME(GetBkMode)
HWND16 GetCapture16(void);
HWND32 GetCapture32(void);
#define GetCapture WINELIB_NAME(GetCapture)
@@ -4872,6 +4910,14 @@
VOID GetCaretPos16(LPPOINT16);
BOOL32 GetCaretPos32(LPPOINT32);
#define GetCaretPos WINELIB_NAME(GetCaretPos)
+BOOL16 GetCharABCWidths16(HDC16,UINT16,UINT16,LPABC16);
+BOOL32 GetCharABCWidths32A(HDC32,UINT32,UINT32,LPABC32);
+BOOL32 GetCharABCWidths32W(HDC32,UINT32,UINT32,LPABC32);
+#define GetCharABCWidths WINELIB_NAME_AW(GetCharABCWidths)
+BOOL16 GetCharWidth16(HDC16,UINT16,UINT16,LPINT16);
+BOOL32 GetCharWidth32A(HDC32,UINT32,UINT32,LPINT32);
+BOOL32 GetCharWidth32W(HDC32,UINT32,UINT32,LPINT32);
+#define GetCharWidth WINELIB_NAME_AW(GetCharWidth)
BOOL16 GetClassInfo16(HINSTANCE16,SEGPTR,WNDCLASS16 *);
BOOL32 GetClassInfo32A(HINSTANCE32,LPCSTR,WNDCLASS32A *);
BOOL32 GetClassInfo32W(HINSTANCE32,LPCWSTR,WNDCLASS32W *);
@@ -4922,6 +4968,9 @@
HWND16 GetDesktopWindow16(void);
HWND32 GetDesktopWindow32(void);
#define GetDesktopWindow WINELIB_NAME(GetDesktopWindow)
+INT16 GetDIBits16(HDC16,HBITMAP16,UINT16,UINT16,LPSTR,LPBITMAPINFO,UINT16);
+INT32 GetDIBits32(HDC32,HBITMAP32,UINT32,UINT32,LPSTR,LPBITMAPINFO,UINT32);
+#define GetDIBits WINELIB_NAME(GetDIBits)
BOOL16 GetDiskFreeSpace16(LPCSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
BOOL32 GetDiskFreeSpace32A(LPCSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
BOOL32 GetDiskFreeSpace32W(LPCWSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
@@ -4963,6 +5012,9 @@
UINT32 GetLogicalDriveStrings32A(UINT32,LPSTR);
UINT32 GetLogicalDriveStrings32W(UINT32,LPWSTR);
#define GetLogicalDriveStrings WINELIB_NAME_AW(GetLogicalDriveStrings)
+INT16 GetMapMode16(HDC16);
+INT32 GetMapMode32(HDC32);
+#define GetMapMode WINELIB_NAME(GetMapMode)
INT16 GetModuleFileName16(HINSTANCE16,LPSTR,INT16);
DWORD GetModuleFileName32A(HMODULE32,LPSTR,DWORD);
DWORD GetModuleFileName32W(HMODULE32,LPWSTR,DWORD);
@@ -4983,6 +5035,9 @@
COLORREF GetPixel16(HDC16,INT16,INT16);
COLORREF GetPixel32(HDC32,INT32,INT32);
#define GetPixel WINELIB_NAME(GetPixel)
+INT16 GetPolyFillMode16(HDC16);
+INT32 GetPolyFillMode32(HDC32);
+#define GetPolyFillMode WINELIB_NAME(GetPolyFillMode)
UINT16 GetPrivateProfileInt16(LPCSTR,LPCSTR,INT16,LPCSTR);
UINT32 GetPrivateProfileInt32A(LPCSTR,LPCSTR,INT32,LPCSTR);
UINT32 GetPrivateProfileInt32W(LPCWSTR,LPCWSTR,INT32,LPCWSTR);
@@ -5006,9 +5061,15 @@
HANDLE32 GetProp32A(HWND32,LPCSTR);
HANDLE32 GetProp32W(HWND32,LPCWSTR);
#define GetProp WINELIB_NAME_AW(GetProp)
+INT16 GetRelAbs16(HDC16);
+INT32 GetRelAbs32(HDC32);
+#define GetRelAbs WINELIB_NAME(GetRelAbs)
INT16 GetRgnBox16(HRGN16,LPRECT16);
INT32 GetRgnBox32(HRGN32,LPRECT32);
#define GetRgnBox WINELIB_NAME(GetRgnBox)
+INT16 GetROP216(HDC16);
+INT32 GetROP232(HDC32);
+#define GetROP2 WINELIB_NAME(GetROP2)
BOOL16 GetScrollInfo16(HWND16,INT16,LPSCROLLINFO);
BOOL32 GetScrollInfo32(HWND32,INT32,LPSCROLLINFO);
#define GetScrollInfo WINELIB_NAME(GetScrollInfo)
@@ -5021,6 +5082,9 @@
HGDIOBJ16 GetStockObject16(INT16);
HGDIOBJ32 GetStockObject32(INT32);
#define GetStockObject WINELIB_NAME(GetStockObject)
+INT16 GetStretchBltMode16(HDC16);
+INT32 GetStretchBltMode32(HDC32);
+#define GetStretchBltMode WINELIB_NAME(GetStretchBltMode)
HBRUSH16 GetSysColorBrush16(INT16);
HBRUSH32 GetSysColorBrush32(INT32);
#define GetSysColorBrush WINELIB_NAME(GetSysColorBrush)
@@ -5038,6 +5102,15 @@
UINT32 GetTempPath32A(UINT32,LPSTR);
UINT32 GetTempPath32W(UINT32,LPWSTR);
#define GetTempPath WINELIB_NAME_AW(GetTempPath)
+UINT16 GetTextAlign16(HDC16);
+UINT32 GetTextAlign32(HDC32);
+#define GetTextAlign WINELIB_NAME(GetTextAlign)
+INT16 GetTextCharacterExtra16(HDC16);
+INT32 GetTextCharacterExtra32(HDC32);
+#define GetTextCharacterExtra WINELIB_NAME(GetTextCharacterExtra)
+COLORREF GetTextColor16(HDC16);
+COLORREF GetTextColor32(HDC32);
+#define GetTextColor WINELIB_NAME(GetTextColor)
BOOL16 GetTextExtentPoint16(HDC16,LPCSTR,INT16,LPSIZE16);
BOOL32 GetTextExtentPoint32A(HDC32,LPCSTR,INT32,LPSIZE32);
BOOL32 GetTextExtentPoint32W(HDC32,LPCWSTR,INT32,LPSIZE32);
@@ -5314,10 +5387,18 @@
INT16 MulDiv16(INT16,INT16,INT16);
INT32 MulDiv32(INT32,INT32,INT32);
#define MulDiv WINELIB_NAME(MulDiv)
-BOOL32 OemToChar32A(LPSTR,LPSTR);
+INT16 OemToAnsi16(LPCSTR,LPSTR);
+#define OemToAnsi32A OemToChar32A
+#define OemToAnsi32W OemToChar32W
+#define OemToAnsi WINELIB_NAME_AW(OemToAnsi)
+VOID OemToAnsiBuff16(LPCSTR,LPSTR,UINT16);
+#define OemToAnsiBuff32A OemToCharBuff32A
+#define OemToAnsiBuff32W OemToCharBuff32W
+#define OemToAnsiBuff WINELIB_NAME_AW(OemToAnsiBuff)
+BOOL32 OemToChar32A(LPCSTR,LPSTR);
BOOL32 OemToChar32W(LPCSTR,LPWSTR);
#define OemToChar WINELIB_NAME_AW(OemToChar)
-BOOL32 OemToCharBuff32A(LPSTR,LPSTR,DWORD);
+BOOL32 OemToCharBuff32A(LPCSTR,LPSTR,DWORD);
BOOL32 OemToCharBuff32W(LPCSTR,LPWSTR,DWORD);
#define OemToCharBuff WINELIB_NAME_AW(OemToCharBuff)
INT16 OffsetClipRgn16(HDC16,INT16,INT16);
@@ -5451,9 +5532,19 @@
BOOL32 RemoveDirectory32A(LPCSTR);
BOOL32 RemoveDirectory32W(LPCWSTR);
#define RemoveDirectory WINELIB_NAME_AW(RemoveDirectory)
+HDC16 ResetDC16(HDC16,const DEVMODE16 *);
+HDC32 ResetDC32A(HDC32,const DEVMODE32A *);
+HDC32 ResetDC32W(HDC32,const DEVMODE32W *);
+#define ResetDC WINELIB_NAME_AW(ResetDC)
+BOOL16 RestoreDC16(HDC16,INT16);
+BOOL32 RestoreDC32(HDC32,INT32);
+#define RestoreDC WINELIB_NAME(RestoreDC)
BOOL16 RoundRect16(HDC16,INT16,INT16,INT16,INT16,INT16,INT16);
BOOL32 RoundRect32(HDC32,INT32,INT32,INT32,INT32,INT32,INT32);
#define RoundRect WINELIB_NAME(RoundRect)
+INT16 SaveDC16(HDC16);
+INT32 SaveDC32(HDC32);
+#define SaveDC WINELIB_NAME(SaveDC)
BOOL16 ScaleViewportExtEx16(HDC16,INT16,INT16,INT16,INT16,LPSIZE16);
BOOL32 ScaleViewportExtEx32(HDC32,INT32,INT32,INT32,INT32,LPSIZE32);
#define ScaleViewportExtEx WINELIB_NAME(ScaleViewportExtEx)
@@ -5493,6 +5584,9 @@
BOOL16 SetBitmapDimensionEx16(HBITMAP16,INT16,INT16,LPSIZE16);
BOOL32 SetBitmapDimensionEx32(HBITMAP32,INT32,INT32,LPSIZE32);
#define SetBitmapDimensionEx WINELIB_NAME(SetBitmapDimensionEx)
+INT16 SetBkMode16(HDC16,INT16);
+INT32 SetBkMode32(HDC32,INT32);
+#define SetBkMode WINELIB_NAME(SetBkMode)
HWND16 SetCapture16(HWND16);
HWND32 SetCapture32(HWND32);
#define SetCapture WINELIB_NAME(SetCapture)
@@ -5509,6 +5603,14 @@
BOOL16 SetDeskWallPaper16(LPCSTR);
BOOL32 SetDeskWallPaper32(LPCSTR);
#define SetDeskWallPaper WINELIB_NAME(SetDeskWallPaper)
+INT16 SetDIBits16(HDC16,HBITMAP16,UINT16,UINT16,LPCVOID,const BITMAPINFO*,UINT16);
+INT32 SetDIBits32(HDC32,HBITMAP32,UINT32,UINT32,LPCVOID,const BITMAPINFO*,UINT32);
+#define SetDIBits WINELIB_NAME(SetDIBits)
+INT16 SetDIBitsToDevice16(HDC16,INT16,INT16,INT16,INT16,INT16,INT16,
+ UINT16,UINT16,LPCVOID,const BITMAPINFO*,UINT16);
+INT32 SetDIBitsToDevice32(HDC32,INT32,INT32,DWORD,DWORD,INT32,INT32,
+ UINT32,UINT32,LPCVOID,const BITMAPINFO*,UINT32);
+#define SetDIBitsToDevice WINELIB_NAME(SetDIBitsToDevice)
void SetDlgItemInt16(HWND16,INT16,UINT16,BOOL16);
void SetDlgItemInt32(HWND32,INT32,UINT32,BOOL32);
#define SetDlgItemInt WINELIB_NAME(SetDlgItemInt)
@@ -5532,9 +5634,15 @@
void SetInternalWindowPos16(HWND16,UINT16,LPRECT16,LPPOINT16);
void SetInternalWindowPos32(HWND32,UINT32,LPRECT32,LPPOINT32);
#define SetInternalWindowPos WINELIB_NAME(SetInternalWindowPos)
+INT16 SetMapMode16(HDC16,INT16);
+INT32 SetMapMode32(HDC32,INT32);
+#define SetMapMode WINELIB_NAME(SetMapMode)
COLORREF SetPixel16(HDC16,INT16,INT16,COLORREF);
COLORREF SetPixel32(HDC32,INT32,INT32,COLORREF);
#define SetPixel WINELIB_NAME(SetPixel)
+INT16 SetPolyFillMode16(HDC16,INT16);
+INT32 SetPolyFillMode32(HDC32,INT32);
+#define SetPolyFillMode WINELIB_NAME(SetPolyFillMode)
BOOL16 SetProp16(HWND16,LPCSTR,HANDLE16);
BOOL32 SetProp32A(HWND32,LPCSTR,HANDLE32);
BOOL32 SetProp32W(HWND32,LPCWSTR,HANDLE32);
@@ -5545,6 +5653,12 @@
void SetRectEmpty16(LPRECT16);
void SetRectEmpty32(LPRECT32);
#define SetRectEmpty WINELIB_NAME(SetRectEmpty)
+INT16 SetRelAbs16(HDC16,INT16);
+INT32 SetRelAbs32(HDC32,INT32);
+#define SetRelAbs WINELIB_NAME(SetRelAbs)
+INT16 SetROP216(HDC16,INT16);
+INT32 SetROP232(HDC32,INT32);
+#define SetROP2 WINELIB_NAME(SetROP2)
INT16 SetScrollInfo16(HWND16,INT16,const SCROLLINFO*,BOOL16);
INT32 SetScrollInfo32(HWND32,INT32,const SCROLLINFO*,BOOL32);
#define SetScrollInfo WINELIB_NAME(SetScrollInfo)
@@ -5554,12 +5668,24 @@
void SetScrollRange16(HWND16,INT16,INT16,INT16,BOOL16);
BOOL32 SetScrollRange32(HWND32,INT32,INT32,INT32,BOOL32);
#define SetScrollRange WINELIB_NAME(SetScrollRange)
+INT16 SetStretchBltMode16(HDC16,INT16);
+INT32 SetStretchBltMode32(HDC32,INT32);
+#define SetStretchBltMode WINELIB_NAME(SetStretchBltMode)
HWND16 SetSysModalWindow16(HWND16);
#define SetSysModalWindow32(hwnd) ((HWND32)0)
#define SetSysModalWindow WINELIB_NAME(SetSysModalWindow)
UINT16 SetSystemTimer16(HWND16,UINT16,UINT16,TIMERPROC16);
UINT32 SetSystemTimer32(HWND32,UINT32,UINT32,TIMERPROC32);
#define SetSystemTimer WINELIB_NAME(SetSystemTimer)
+UINT16 SetTextAlign16(HDC16,UINT16);
+UINT32 SetTextAlign32(HDC32,UINT32);
+#define SetTextAlign WINELIB_NAME(SetTextAlign)
+INT16 SetTextCharacterExtra16(HDC16,INT16);
+INT32 SetTextCharacterExtra32(HDC32,INT32);
+#define SetTextCharacterExtra WINELIB_NAME(SetTextCharacterExtra)
+INT16 SetTextJustification16(HDC16,INT16,INT16);
+BOOL32 SetTextJustification32(HDC32,INT32,INT32);
+#define SetTextJustification WINELIB_NAME(SetTextJustification)
UINT16 SetTimer16(HWND16,UINT16,UINT16,TIMERPROC16);
UINT32 SetTimer32(HWND32,UINT32,UINT32,TIMERPROC32);
#define SetTimer WINELIB_NAME(SetTimer)
@@ -5734,6 +5860,8 @@
INT32 lstrncmp32W(LPCWSTR,LPCWSTR,INT32);
INT32 lstrncmpi32A(LPCSTR,LPCSTR,INT32);
INT32 lstrncmpi32W(LPCWSTR,LPCWSTR,INT32);
+LPWSTR lstrcpyAtoW(LPWSTR,LPCSTR);
+LPSTR lstrcpyWtoA(LPSTR,LPCWSTR);
LPWSTR lstrcpynAtoW(LPWSTR,LPCSTR,INT32);
LPSTR lstrcpynWtoA(LPSTR,LPCWSTR,INT32);
@@ -5772,8 +5900,6 @@
UINT AnsiLowerBuff(LPSTR,UINT);
SEGPTR AnsiNext(SEGPTR);
SEGPTR AnsiPrev(SEGPTR,SEGPTR);
-INT AnsiToOem(LPCSTR,LPSTR);
-void AnsiToOemBuff(LPCSTR,LPSTR,UINT);
UINT AnsiUpperBuff(LPSTR,UINT);
BOOL AnyPopup(void);
UINT ArrangeIconicWindows(HWND);
@@ -5790,18 +5916,14 @@
HMETAFILE16 CopyMetaFile(HMETAFILE16,LPCSTR);
INT CountClipboardFormats(void);
INT CountVoiceNotes(INT);
-HDC16 CreateCompatibleDC(HDC16);
HCURSOR16 CreateCursor(HINSTANCE16,INT,INT,INT,INT,const BYTE*,const BYTE*);
HGLOBAL16 CreateCursorIconIndirect(HINSTANCE16,CURSORICONINFO*,const BYTE*,const BYTE*);
-HBITMAP16 CreateDIBitmap(HDC16,BITMAPINFOHEADER*,DWORD,LPVOID,BITMAPINFO*,UINT);
-HDC16 CreateIC(LPCSTR,LPCSTR,LPCSTR,const DEVMODE16*);
HICON16 CreateIcon(HINSTANCE16,INT,INT,BYTE,BYTE,const BYTE*,const BYTE*);
HMENU16 CreateMenu(void);
HPALETTE16 CreatePalette(const LOGPALETTE*);
HMENU16 CreatePopupMenu(void);
HDWP16 DeferWindowPos(HDWP16,HWND,HWND,INT,INT,INT,INT,UINT);
ATOM DeleteAtom(ATOM);
-BOOL DeleteDC(HDC16);
BOOL DeleteMenu(HMENU16,UINT,UINT);
BOOL DestroyCursor(HCURSOR16);
BOOL DestroyIcon(HICON16);
@@ -5834,21 +5956,13 @@
DWORD GetAspectRatioFilter(HDC16);
int GetAsyncKeyState(int);
WORD GetAtomName(ATOM,LPSTR,short);
-COLORREF GetBkColor(HDC16);
-WORD GetBkMode(HDC16);
-DWORD GetBrushOrg(HDC16);
-BOOL GetCharABCWidths(HDC16,UINT,UINT,LPABC16);
-BOOL GetCharWidth(HDC16,WORD,WORD,LPINT16);
HANDLE16 GetClipboardData(WORD);
int GetClipboardFormatName(WORD,LPSTR,short);
HWND GetClipboardOwner(void);
HWND GetClipboardViewer(void);
HBRUSH16 GetControlBrush(HWND,HDC16,WORD);
-DWORD GetCurrentPosition(HDC16);
DWORD GetCurrentTime(void);
HCURSOR16 GetCursor(void);
-HDC16 GetDCState(HDC16);
-int GetDIBits(HDC16,HBITMAP16,WORD,WORD,LPSTR,LPBITMAPINFO,WORD);
SEGPTR GetDOSEnvironment(void);
int GetDeviceCaps(HDC16,WORD);
DWORD GetDialogBaseUnits(void);
@@ -5865,7 +5979,6 @@
void GetKeyboardState(BYTE*);
int GetKeyboardType(int);
HWND GetLastActivePopup(HWND);
-WORD GetMapMode(HDC16);
HMENU16 GetMenu(HWND);
DWORD GetMenuCheckMarkDimensions(void);
INT GetMenuItemCount(HMENU16);
@@ -5885,13 +5998,9 @@
HWND GetNextWindow(HWND,WORD);
HWND GetOpenClipboardWindow(void);
WORD GetPaletteEntries(HPALETTE16,WORD,WORD,LPPALETTEENTRY);
-WORD GetPolyFillMode(HDC16);
int GetPriorityClipboardFormat(WORD*,short);
DWORD GetQueueStatus(UINT);
BOOL GetRasterizerCaps(LPRASTERIZER_STATUS,UINT);
-WORD GetROP2(HDC16);
-WORD GetRelAbs(HDC16);
-WORD GetStretchBltMode(HDC16);
HMENU16 GetSubMenu(HMENU16,short);
HMENU16 GetSystemMenu(HWND,BOOL);
int GetSystemMetrics(WORD);
@@ -5899,20 +6008,12 @@
WORD GetSystemPaletteUse(HDC16);
DWORD GetTabbedTextExtent(HDC16,LPSTR,int,int,LPINT16);
BYTE GetTempDrive(BYTE);
-WORD GetTextAlign(HDC16);
-short GetTextCharacterExtra(HDC16);
-COLORREF GetTextColor(HDC16);
-DWORD GetTextExtent(HDC16,LPCSTR,short);
LPINT16 GetThresholdEvent(void);
int GetThresholdStatus(void);
HWND GetTopWindow(HWND);
-DWORD GetViewportExt(HDC16);
-DWORD GetViewportOrg(HDC16);
BOOL GetWinDebugInfo(LPWINDEBUGINFO,UINT);
LONG GetWinFlags(void);
HWND GetWindow(HWND,WORD);
-DWORD GetWindowExt(HDC16);
-DWORD GetWindowOrg(HDC16);
ATOM GlobalDeleteAtom(ATOM);
void GlobalFix(HGLOBAL16);
BOOL16 GlobalUnWire(HGLOBAL16);
@@ -5922,7 +6023,6 @@
BOOL HiliteMenuItem(HWND,HMENU16,UINT,UINT);
BOOL InSendMessage(void);
WORD InitAtomTable(WORD);
-HRGN32 InquireVisRgn(HDC16);
void InvalidateRgn(HWND32,HRGN32,BOOL32);
BOOL IsChild(HWND,HWND);
BOOL IsClipboardFormatAvailable(WORD);
@@ -5941,8 +6041,6 @@
void MessageBeep(WORD);
BOOL MoveWindow(HWND,short,short,short,short,BOOL);
DWORD OemKeyScan(WORD);
-BOOL OemToAnsi(LPCSTR,LPSTR);
-void OemToAnsiBuff(LPCSTR,LPSTR,INT);
BOOL OpenClipboard(HWND);
BOOL OpenIcon(HWND);
int OpenSound(void);
@@ -5963,14 +6061,10 @@
BOOL RemoveFontResource(LPSTR);
BOOL RemoveMenu(HMENU16,UINT,UINT);
void ReplyMessage(LRESULT);
-HDC16 ResetDC(HDC16,LPVOID);
BOOL ResizePalette(HPALETTE16,UINT);
-BOOL RestoreDC(HDC16,short);
-int SaveDC(HDC16);
void ScrollChildren(HWND,UINT,WPARAM16,LPARAM);
HPALETTE16 SelectPalette(HDC16,HPALETTE16,BOOL);
HWND SetActiveWindow(HWND);
-WORD SetBkMode(HDC16,WORD);
HANDLE16 SetClipboardData(WORD,HANDLE16);
HWND SetClipboardViewer(HWND);
void SetConvertHook(BOOL);
@@ -5978,13 +6072,11 @@
BOOL32 SetCurrentDirectory(LPCSTR);
HCURSOR16 SetCursor(HCURSOR16);
void SetCursorPos(short,short);
-void SetDCState(HDC16,HDC16);
void SetDoubleClickTime(WORD);
int SetEnvironment(LPCSTR,LPCSTR,WORD);
UINT SetErrorMode(UINT);
WORD SetHookFlags(HDC16,WORD);
void SetKeyboardState(BYTE*);
-WORD SetMapMode(HDC16,WORD);
DWORD SetMapperFlags(HDC16,DWORD);
BOOL SetMenu(HWND,HMENU16);
BOOL SetMenuItemBitmaps(HMENU16,UINT,UINT,HBITMAP16,HBITMAP16);
@@ -5992,18 +6084,11 @@
HMETAFILE16 SetMetaFileBits(HGLOBAL16);
WORD SetPaletteEntries(HPALETTE16,WORD,WORD,LPPALETTEENTRY);
HWND SetParent(HWND,HWND);
-WORD SetPolyFillMode(HDC16,WORD);
-WORD SetROP2(HDC16,WORD);
-WORD SetRelAbs(HDC16,WORD);
FARPROC16 SetResourceHandler(HINSTANCE16,LPSTR,FARPROC16);
int SetSoundNoise(int,int);
-WORD SetStretchBltMode(HDC16,WORD);
LONG SetSwapAreaSize(WORD);
void SetSysColors(int,LPINT16,COLORREF*);
WORD SetSystemPaletteUse(HDC16,WORD);
-WORD SetTextAlign(HDC16,WORD);
-short SetTextCharacterExtra(HDC16,short);
-short SetTextJustification(HDC16,short,short);
int SetVoiceAccent(int,int,int,int,int);
int SetVoiceEnvelope(int,int,int);
int SetVoiceNote(int,int,int,int);
diff --git a/library/libres.c b/library/libres.c
index 521f7c2..ebe155d 100644
--- a/library/libres.c
+++ b/library/libres.c
@@ -7,9 +7,9 @@
#include <stdio.h>
#include <stdlib.h>
#include "libres.h"
+#include "heap.h"
#include "windows.h"
#include "xmalloc.h"
-#include "string32.h"
typedef struct RLE
{
@@ -86,16 +86,15 @@
int nameid=0,typeid;
ResListE* ResBlock;
const struct resource* const * Res;
- LPSTR nameA, typeA;
if(HIWORD(name))
{
if(*name=='#')
{
- nameA = STRING32_DupUniToAnsi(name);
- nameid=atoi(nameA+1);
- free(nameA);
- name=NULL;
+ LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
+ nameid = atoi(nameA+1);
+ HeapFree( GetProcessHeap(), 0, nameA );
+ name=NULL;
}
}
else
@@ -107,9 +106,9 @@
{
if(*type=='#')
{
- typeA = STRING32_DupUniToAnsi(type);
- typeid=atoi(typeA+1);
- free(typeA);
+ LPSTR typeA = HEAP_strdupWtoA( GetProcessHeap(), 0, type );
+ typeid=atoi(typeA+1);
+ HeapFree( GetProcessHeap(), 0, typeA );
}
else
{
diff --git a/loader/main.c b/loader/main.c
index 3bd649e..b14f691 100644
--- a/loader/main.c
+++ b/loader/main.c
@@ -166,10 +166,17 @@
int main(int argc, char *argv[] )
{
extern BOOL32 MAIN_WineInit( int *argc, char *argv[] );
+ extern char * DEBUG_argv0;
int i;
HINSTANCE16 handle;
+ /*
+ * Save this so that the internal debugger can get a hold of it if
+ * it needs to.
+ */
+ DEBUG_argv0 = argv[0];
+
if (!MAIN_WineInit( &argc, argv )) return 1;
if (!MAIN_Init()) return 1;
diff --git a/loader/pe_image.c b/loader/pe_image.c
index a99e627..b8c321e 100644
--- a/loader/pe_image.c
+++ b/loader/pe_image.c
@@ -114,7 +114,7 @@
daddr.off=load_addr+*functions;
function++;
}
- DEBUG_AddSymbol(buffer,&daddr);
+ DEBUG_AddSymbol(buffer,&daddr, NULL);
}
}
@@ -525,7 +525,11 @@
if(pe->pe_header->opt_coff.DataDirectory
[IMAGE_FILE_DEBUG_DIRECTORY].Size)
- dprintf_win32(stdnimp,"Debug directory ignored\n");
+ {
+ DEBUG_RegisterDebugInfo(fd, pe, load_addr,
+ pe->pe_header->opt_coff.DataDirectory[IMAGE_FILE_DEBUG_DIRECTORY].Virtual_address,
+ pe->pe_header->opt_coff.DataDirectory[IMAGE_FILE_DEBUG_DIRECTORY].Size);
+ }
if(pe->pe_header->opt_coff.DataDirectory
[IMAGE_FILE_DESCRIPTION_STRING].Size)
@@ -556,15 +560,16 @@
pe->pe_seg[i].Name
);
daddr.off=load_addr+pe->pe_seg[i].Virtual_Address;
- DEBUG_AddSymbol(buffer,&daddr);
+ DEBUG_AddSymbol(buffer,&daddr, NULL);
}
/* add entry point */
sprintf(buffer,"%s.EntryPoint",((char*)load_addr)+pe->pe_export->Name);
daddr.off=load_addr+pe->pe_header->opt_coff.AddressOfEntryPoint;
- DEBUG_AddSymbol(buffer,&daddr);
+ DEBUG_AddSymbol(buffer,&daddr, NULL);
/* add start of DLL */
daddr.off=load_addr;
- DEBUG_AddSymbol(((char*)load_addr)+pe->pe_export->Name,&daddr);
+ DEBUG_AddSymbol(((char*)load_addr)+pe->pe_export->Name,&daddr,
+ NULL);
}
return pe;
}
diff --git a/loader/pe_resource.c b/loader/pe_resource.c
index c5a6c69..74b74bc 100644
--- a/loader/pe_resource.c
+++ b/loader/pe_resource.c
@@ -17,6 +17,7 @@
#include "windows.h"
#include "pe_image.h"
#include "module.h"
+#include "heap.h"
#include "handle32.h"
#include "libres.h"
#include "resource32.h"
@@ -24,7 +25,6 @@
#include "neexe.h"
#include "accel.h"
#include "xmalloc.h"
-#include "string32.h"
#include "stddebug.h"
#include "debug.h"
@@ -102,13 +102,13 @@
PIMAGE_RESOURCE_DIRECTORY ret;
if (HIWORD((DWORD)name))
- xname = STRING32_DupAnsiToUni(name);
+ xname = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
else
xname = (LPWSTR)name;
ret=GetResDirEntryW(resdirptr,xname,root);
if (HIWORD((DWORD)name))
- free(xname);
+ HeapFree( GetProcessHeap(), 0, xname );
return ret;
}
diff --git a/loader/resource.c b/loader/resource.c
index 200406f..3ae6821 100644
--- a/loader/resource.c
+++ b/loader/resource.c
@@ -16,6 +16,7 @@
#include "windows.h"
#include "gdi.h"
#include "global.h"
+#include "heap.h"
#include "neexe.h"
#include "accel.h"
#include "module.h"
@@ -23,8 +24,6 @@
#include "stddebug.h"
#include "debug.h"
#include "libres.h"
-#include "string32.h"
-#include "xmalloc.h"
#define PrintId(name) \
if (HIWORD((DWORD)name)) \
@@ -85,13 +84,17 @@
LPWSTR xname,xtype;
HANDLE32 ret;
- if (HIWORD((DWORD)name)) xname = STRING32_DupAnsiToUni(name);
- else xname = (LPWSTR)name;
- if (HIWORD((DWORD)type)) xtype = STRING32_DupAnsiToUni(type);
- else xtype = (LPWSTR)type;
- ret = FindResourceEx32W(hModule,xname,xtype,lang);
- if (HIWORD((DWORD)name)) free(xname);
- if (HIWORD((DWORD)type)) free(xtype);
+ if (HIWORD((DWORD)name))
+ xname = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
+ else
+ xname = (LPWSTR)name;
+ if (HIWORD((DWORD)type))
+ xtype = HEAP_strdupAtoW( GetProcessHeap(), 0, type);
+ else
+ xtype = (LPWSTR)type;
+ ret = FindResourceEx32W( hModule, xname, xtype, lang );
+ if (HIWORD((DWORD)name)) HeapFree( GetProcessHeap(), 0, xname );
+ if (HIWORD((DWORD)type)) HeapFree( GetProcessHeap(), 0, xtype );
return ret;
}
@@ -494,12 +497,11 @@
LPWSTR uni;
HACCEL32 result;
if (HIWORD(lpTableName))
- uni=STRING32_DupAnsiToUni(lpTableName);
+ uni = HEAP_strdupAtoW( GetProcessHeap(), 0, lpTableName );
else
- uni=(LPWSTR)lpTableName;
- result=LoadAccelerators32W(instance,uni);
- if (HIWORD(uni))
- free(uni);
+ uni = (LPWSTR)lpTableName;
+ result = LoadAccelerators32W(instance,uni);
+ if (HIWORD(uni)) HeapFree( GetProcessHeap(), 0, uni);
return result;
}
@@ -607,13 +609,15 @@
INT32
LoadString32A(HINSTANCE32 instance,UINT32 resource_id,LPSTR buffer,int buflen)
{
- LPWSTR buffer2 = buffer?(LPWSTR)xmalloc(buflen*2):NULL;
- INT32 retval = LoadString32W(instance,resource_id,buffer2,buflen);
+ INT32 retval;
+ LPWSTR buffer2 = NULL;
+ if (buffer) buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen * 2 );
+ retval = LoadString32W(instance,resource_id,buffer2,buflen);
- if (!retval) return 0;
- if (buffer) {
- STRING32_UniToAnsi(buffer,buffer2);
- free(buffer2);
+ if (buffer)
+ {
+ lstrcpynWtoA( buffer, buffer2, buflen );
+ HeapFree( GetProcessHeap(), 0, buffer2 );
}
return retval;
}
@@ -712,16 +716,17 @@
/**********************************************************************
* LoadMessage32W (internal)
*/
-INT32
-LoadMessage32W(
- HINSTANCE32 instance,UINT32 id,WORD lang,LPWSTR buffer,int buflen
-) {
- LPSTR buffer2 = buffer?(LPSTR)xmalloc(buflen):NULL;
- INT32 retval = LoadMessage32A(instance,id,lang,buffer2,buflen);
-
- if (buffer) {
- STRING32_AnsiToUni(buffer,buffer2);
- free(buffer2);
+INT32 LoadMessage32W( HINSTANCE32 instance, UINT32 id, WORD lang,
+ LPWSTR buffer, int buflen )
+{
+ INT32 retval;
+ LPSTR buffer2 = NULL;
+ if (buffer) buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen );
+ retval = LoadMessage32A(instance,id,lang,buffer2,buflen);
+ if (buffer)
+ {
+ lstrcpynAtoW( buffer, buffer2, buflen );
+ HeapFree( GetProcessHeap(), 0, buffer2 );
}
return retval;
}
diff --git a/loader/signal.c b/loader/signal.c
index a693c7d..9d11530 100644
--- a/loader/signal.c
+++ b/loader/signal.c
@@ -97,17 +97,8 @@
*
* wait4 terminated child processes
*/
-#ifdef linux
-static void SIGNAL_child(int signal, SIGCONTEXT context_struct)
+static void SIGNAL_child(void)
{
- SIGCONTEXT *context = &context_struct;
-#elif defined(__svr4__) || defined(_SCO_DS)
-static void SIGNAL_child(int signal, void *siginfo, SIGCONTEXT *context)
-{
-#else
-static void SIGNAL_child(int signal, int code, SIGCONTEXT *context)
-{
-#endif
wait4( 0, NULL, WNOHANG, NULL);
}
diff --git a/memory/heap.c b/memory/heap.c
index 4e3d1ec..6924de4 100644
--- a/memory/heap.c
+++ b/memory/heap.c
@@ -1225,3 +1225,39 @@
lstrcpy32W( p, str );
return p;
}
+
+
+/***********************************************************************
+ * HEAP_strdupAtoW
+ */
+LPWSTR HEAP_strdupAtoW( HANDLE32 heap, DWORD flags, LPCSTR str )
+{
+ LPWSTR ret;
+
+ if (!str) return NULL;
+ if (!(ret = HeapAlloc( heap, flags, (lstrlen32A(str)+1) * sizeof(WCHAR) )))
+ {
+ fprintf( stderr, "Virtual memory exhausted.\n" );
+ exit(1);
+ }
+ lstrcpyAtoW( ret, str );
+ return ret;
+}
+
+
+/***********************************************************************
+ * HEAP_strdupWtoA
+ */
+LPSTR HEAP_strdupWtoA( HANDLE32 heap, DWORD flags, LPCWSTR str )
+{
+ LPSTR ret;
+
+ if (!str) return NULL;
+ if (!(ret = HeapAlloc( heap, flags, lstrlen32W(str) + 1 )))
+ {
+ fprintf( stderr, "Virtual memory exhausted.\n" );
+ exit(1);
+ }
+ lstrcpyWtoA( ret, str );
+ return ret;
+}
diff --git a/memory/string.c b/memory/string.c
index c4b9ad5..fd8d9ea 100644
--- a/memory/string.c
+++ b/memory/string.c
@@ -10,6 +10,45 @@
#include "windows.h"
#include "ldt.h"
+static const BYTE STRING_Oem2Ansi[256] =
+"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\244"
+"\020\021\022\023\266\247\026\027\030\031\032\033\034\035\036\037"
+"\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
+"\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
+"\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
+"\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
+"\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
+"\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
+"\307\374\351\342\344\340\345\347\352\353\350\357\356\354\304\305"
+"\311\346\306\364\366\362\373\371\377\326\334\242\243\245\120\203"
+"\341\355\363\372\361\321\252\272\277\137\254\275\274\241\253\273"
+"\137\137\137\246\246\246\246\053\053\246\246\053\053\053\053\053"
+"\053\055\055\053\055\053\246\246\053\053\055\055\246\055\053\055"
+"\055\055\055\053\053\053\053\053\053\053\053\137\137\246\137\137"
+"\137\337\137\266\137\137\265\137\137\137\137\137\137\137\137\137"
+"\137\261\137\137\137\137\367\137\260\225\267\137\156\262\137\137";
+
+static const BYTE STRING_Ansi2Oem[256] =
+"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"
+"\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+"\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
+"\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
+"\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
+"\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
+"\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
+"\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
+"\200\201\054\237\054\137\375\374\210\045\123\074\117\215\216\217"
+"\220\140\047\042\042\371\055\137\230\231\163\076\157\235\236\131"
+"\040\255\233\234\017\235\335\025\042\143\246\256\252\055\162\137"
+"\370\361\375\063\047\346\024\372\054\061\247\257\254\253\137\250"
+"\101\101\101\101\216\217\222\200\105\220\105\105\111\111\111\111"
+"\104\245\117\117\117\117\231\170\117\125\125\125\232\131\137\341"
+"\205\240\203\141\204\206\221\207\212\202\210\211\215\241\214\213"
+"\144\244\225\242\223\157\224\366\157\227\243\226\201\171\137\230";
+
+#define OEM_TO_ANSI(ch) (STRING_Oem2Ansi[(unsigned char)(ch)])
+#define ANSI_TO_OEM(ch) (STRING_Ansi2Oem[(unsigned char)(ch)])
+
/***********************************************************************
* hmemcpy (KERNEL.348)
@@ -316,6 +355,28 @@
/***********************************************************************
+ * lstrcpyAtoW (Not a Windows API)
+ */
+LPWSTR lstrcpyAtoW( LPWSTR dst, LPCSTR src )
+{
+ register LPWSTR p = dst;
+ while ((*p++ = (WCHAR)(unsigned char)*src++));
+ return dst;
+}
+
+
+/***********************************************************************
+ * lstrcpyWtoA (Not a Windows API)
+ */
+LPSTR lstrcpyWtoA( LPSTR dst, LPCWSTR src )
+{
+ register LPSTR p = dst;
+ while ((*p++ = (CHAR)*src++));
+ return dst;
+}
+
+
+/***********************************************************************
* lstrcpynAtoW (Not a Windows API)
*/
LPWSTR lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT32 n )
@@ -364,3 +425,122 @@
{
memset( ptr, 0, len );
}
+
+
+/***********************************************************************
+ * AnsiToOem16 (KEYBOARD.5)
+ */
+INT16 AnsiToOem16( LPCSTR s, LPSTR d )
+{
+ CharToOem32A( s, d );
+ return -1;
+}
+
+
+/***********************************************************************
+ * OemToAnsi16 (KEYBOARD.6)
+ */
+INT16 OemToAnsi16( LPCSTR s, LPSTR d )
+{
+ OemToChar32A( s, d );
+ return -1;
+}
+
+
+/***********************************************************************
+ * AnsiToOemBuff16 (KEYBOARD.134)
+ */
+void AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
+{
+ CharToOemBuff32A( s, d, len ? len : 65536 );
+}
+
+
+/***********************************************************************
+ * OemToAnsiBuff16 (KEYBOARD.135)
+ */
+void OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
+{
+ OemToCharBuff32A( s, d, len ? len : 65536 );
+}
+
+
+/***********************************************************************
+ * CharToOem32A (USER32.36)
+ */
+BOOL32 CharToOem32A( LPCSTR s, LPSTR d )
+{
+ if (!s || !d) return TRUE;
+ while ((*d++ = ANSI_TO_OEM(*s++)));
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * CharToOemBuff32A (USER32.37)
+ */
+BOOL32 CharToOemBuff32A( LPCSTR s, LPSTR d, DWORD len )
+{
+ while (len--) *d++ = ANSI_TO_OEM(*s++);
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * CharToOemBuff32W (USER32.38)
+ */
+BOOL32 CharToOemBuff32W( LPCWSTR s, LPSTR d, DWORD len )
+{
+ while (len--) *d++ = ANSI_TO_OEM(*s++);
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * CharToOem32W (USER32.39)
+ */
+BOOL32 CharToOem32W( LPCWSTR s, LPSTR d )
+{
+ while ((*d++ = ANSI_TO_OEM(*s++)));
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * OemToChar32A (USER32.401)
+ */
+BOOL32 OemToChar32A( LPCSTR s, LPSTR d )
+{
+ while ((*d++ = OEM_TO_ANSI(*s++)));
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * OemToCharBuff32A (USER32.402)
+ */
+BOOL32 OemToCharBuff32A( LPCSTR s, LPSTR d, DWORD len )
+{
+ while (len--) *d++ = OEM_TO_ANSI(*s++);
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * OemToCharBuff32W (USER32.403)
+ */
+BOOL32 OemToCharBuff32W( LPCSTR s, LPWSTR d, DWORD len )
+{
+ while (len--) *d++ = (WCHAR)OEM_TO_ANSI(*s++);
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * OemToChar32W (USER32.404)
+ */
+BOOL32 OemToChar32W( LPCSTR s, LPWSTR d )
+{
+ while ((*d++ = (WCHAR)OEM_TO_ANSI(*s++)));
+ return TRUE;
+}
diff --git a/misc/clipboard.c b/misc/clipboard.c
index 47304e3..e3d5a61 100644
--- a/misc/clipboard.c
+++ b/misc/clipboard.c
@@ -17,12 +17,12 @@
#include <X11/Xatom.h>
#include "windows.h"
#include "win.h"
+#include "heap.h"
#include "message.h"
#include "clipboard.h"
#include "xmalloc.h"
#include "stddebug.h"
#include "debug.h"
-#include "string32.h"
#define CF_REGFORMATBASE 0xC000
@@ -391,9 +391,9 @@
if( lpstrT )
{
if( lpSource->wFormatID == CF_TEXT )
- AnsiToOemBuff(lpstrS, lpstrT, size);
+ CharToOemBuff32A(lpstrS, lpstrT, size);
else
- OemToAnsiBuff(lpstrS, lpstrT, size);
+ OemToCharBuff32A(lpstrS, lpstrT, size);
dprintf_clipboard(stddeb,"\tgot %s\n", lpstrT);
return TRUE;
}
@@ -585,11 +585,9 @@
*/
UINT32 RegisterClipboardFormat32W( LPCWSTR formatName )
{
- LPSTR aFormat;
- UINT32 ret;
- aFormat = STRING32_DupUniToAnsi(formatName);
- ret = RegisterClipboardFormat32A(aFormat);
- free(aFormat);
+ LPSTR aFormat = HEAP_strdupWtoA( GetProcessHeap(), 0, formatName );
+ UINT32 ret = RegisterClipboardFormat32A( aFormat );
+ HeapFree( GetProcessHeap(), 0, aFormat );
return ret;
}
diff --git a/misc/comm.c b/misc/comm.c
index 613957b..ea2735d 100644
--- a/misc/comm.c
+++ b/misc/comm.c
@@ -21,11 +21,11 @@
#include "windows.h"
#include "comm.h"
+#include "heap.h"
#include "options.h"
#include "stddebug.h"
#include "debug.h"
#include "handle32.h"
-#include "string32.h"
int commerror = 0, eventmask = 0;
@@ -363,9 +363,9 @@
BOOL32 ret;
dprintf_comm(stddeb,"BuildCommDCBAndTimeouts32W(%p,%p,%p)\n",devid,lpdcb,lptimeouts);
- devidA = STRING32_DupUniToAnsi(devid);
+ devidA = HEAP_strdupWtoA( GetProcessHeap(), 0, devid );
ret=BuildCommDCBAndTimeouts32A(devidA,lpdcb,lptimeouts);
- free(devidA);
+ HeapFree( GetProcessHeap(), 0, devidA );
return ret;
}
diff --git a/misc/commdlg.c b/misc/commdlg.c
index 7e06077..42845d5 100644
--- a/misc/commdlg.c
+++ b/misc/commdlg.c
@@ -213,7 +213,7 @@
HBRUSH32 hBrush;
HBITMAP16 hBitmap, hPrevBitmap;
BITMAP16 bm;
- HDC16 hMemDC;
+ HDC32 hMemDC;
if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst1)
{
@@ -253,12 +253,12 @@
GetObject16( hBitmap, sizeof(bm), &bm );
TextOut16(lpdis->hDC, lpdis->rcItem.left + bm.bmWidth,
lpdis->rcItem.top, str, strlen(str));
- hMemDC = CreateCompatibleDC(lpdis->hDC);
+ hMemDC = CreateCompatibleDC32(lpdis->hDC);
hPrevBitmap = SelectObject32(hMemDC, hBitmap);
BitBlt32(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
SelectObject32(hMemDC, hPrevBitmap);
- DeleteDC(hMemDC);
+ DeleteDC32(hMemDC);
if (lpdis->itemState != 0) InvertRect16(lpdis->hDC, &lpdis->rcItem);
SEGPTR_FREE(str);
return TRUE;
@@ -282,12 +282,12 @@
GetObject16( hBitmap, sizeof(bm), &bm );
TextOut16(lpdis->hDC, lpdis->rcItem.left + bm.bmWidth,
lpdis->rcItem.top, str, strlen(str));
- hMemDC = CreateCompatibleDC(lpdis->hDC);
+ hMemDC = CreateCompatibleDC32(lpdis->hDC);
hPrevBitmap = SelectObject32(hMemDC, hBitmap);
BitBlt32( lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY );
SelectObject32(hMemDC, hPrevBitmap);
- DeleteDC(hMemDC);
+ DeleteDC32(hMemDC);
if (lpdis->itemState != 0) InvertRect16(lpdis->hDC, &lpdis->rcItem);
SEGPTR_FREE(str);
return TRUE;
@@ -1595,7 +1595,7 @@
GetClientRect16(hwnd,&client);
hdc=GetDC32(hwnd);
- lpp->hdcMem = CreateCompatibleDC(hdc);
+ lpp->hdcMem = CreateCompatibleDC32(hdc);
lpp->hbmMem = CreateCompatibleBitmap(hdc,client.right,client.bottom);
SelectObject32(lpp->hdcMem,lpp->hbmMem);
@@ -2153,7 +2153,7 @@
case WM_INITDIALOG:
return CC_WMInitDialog(hDlg,wParam,lParam);
case WM_NCDESTROY:
- DeleteDC(lpp->hdcMem);
+ DeleteDC32(lpp->hdcMem);
DeleteObject32(lpp->hbmMem);
free(lpp);
SetWindowLong32A(hDlg, DWL_USER, 0L); /* we don't need it anymore */
@@ -2579,12 +2579,12 @@
/* FIXME: draw bitmap if truetype usage */
if (nFontType&TRUETYPE_FONTTYPE)
{
- hMemDC = CreateCompatibleDC(lpdi->hDC);
+ hMemDC = CreateCompatibleDC32(lpdi->hDC);
hBitmap = SelectObject32(hMemDC, hBitmapTT);
BitBlt32(lpdi->hDC, lpdi->rcItem.left, lpdi->rcItem.top,
bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
SelectObject32(hMemDC, hBitmap);
- DeleteDC(hMemDC);
+ DeleteDC32(hMemDC);
}
#endif
break;
diff --git a/misc/crtdll.c b/misc/crtdll.c
index 5a35026..0d83094 100644
--- a/misc/crtdll.c
+++ b/misc/crtdll.c
@@ -22,7 +22,6 @@
#include "xmalloc.h"
#include "heap.h"
#include "crtdll.h"
-#include "string32.h"
UINT32 CRTDLL_argc_dll; /* CRTDLL.23 */
LPSTR *CRTDLL_argv_dll; /* CRTDLL.24 */
diff --git a/misc/lstr.c b/misc/lstr.c
index ece2f03..82d68b0 100644
--- a/misc/lstr.c
+++ b/misc/lstr.c
@@ -23,42 +23,6 @@
#define ToLower(c) tolower(c)
-static const BYTE Oem2Ansi[256] =
-"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\244"
-"\020\021\022\023\266\247\026\027\030\031\032\033\034\035\036\037"
-"\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
-"\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
-"\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
-"\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
-"\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
-"\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
-"\307\374\351\342\344\340\345\347\352\353\350\357\356\354\304\305"
-"\311\346\306\364\366\362\373\371\377\326\334\242\243\245\120\203"
-"\341\355\363\372\361\321\252\272\277\137\254\275\274\241\253\273"
-"\137\137\137\246\246\246\246\053\053\246\246\053\053\053\053\053"
-"\053\055\055\053\055\053\246\246\053\053\055\055\246\055\053\055"
-"\055\055\055\053\053\053\053\053\053\053\053\137\137\246\137\137"
-"\137\337\137\266\137\137\265\137\137\137\137\137\137\137\137\137"
-"\137\261\137\137\137\137\367\137\260\225\267\137\156\262\137\137";
-
-static const BYTE Ansi2Oem[256] =
-"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"
-"\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
-"\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
-"\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
-"\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
-"\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
-"\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
-"\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
-"\200\201\054\237\054\137\375\374\210\045\123\074\117\215\216\217"
-"\220\140\047\042\042\371\055\137\230\231\163\076\157\235\236\131"
-"\040\255\233\234\017\235\335\025\042\143\246\256\252\055\162\137"
-"\370\361\375\063\047\346\024\372\054\061\247\257\254\253\137\250"
-"\101\101\101\101\216\217\222\200\105\220\105\105\111\111\111\111"
-"\104\245\117\117\117\117\231\170\117\125\125\125\232\131\137\341"
-"\205\240\203\141\204\206\221\207\212\202\210\211\215\241\214\213"
-"\144\244\225\242\223\157\224\366\157\227\243\226\201\171\137\230";
-
/* Funny to divide them between user and kernel. */
/* IsCharAlpha USER 433 */
@@ -203,45 +167,6 @@
}
-/* AnsiToOem Keyboard.5 */
-INT AnsiToOem(LPCSTR lpAnsiStr, LPSTR lpOemStr)
-{
- dprintf_keyboard(stddeb, "AnsiToOem: %s\n", lpAnsiStr);
- while(*lpAnsiStr){
- *lpOemStr++=Ansi2Oem[(unsigned char)(*lpAnsiStr++)];
- }
- *lpOemStr = 0;
- return -1;
-}
-
-/* OemToAnsi Keyboard.6 */
-BOOL OemToAnsi(LPCSTR lpOemStr, LPSTR lpAnsiStr)
-{
- dprintf_keyboard(stddeb, "OemToAnsi: %s\n", lpOemStr);
- while(*lpOemStr){
- *lpAnsiStr++=Oem2Ansi[(unsigned char)(*lpOemStr++)];
- }
- *lpAnsiStr = 0;
- return -1;
-}
-
-/* AnsiToOemBuff Keyboard.134 */
-void AnsiToOemBuff(LPCSTR lpAnsiStr, LPSTR lpOemStr, UINT nLength)
-{
- int i;
- for(i=0;i<nLength;i++)
- lpOemStr[i]=Ansi2Oem[(unsigned char)(lpAnsiStr[i])];
-}
-
-/* OemToAnsi Keyboard.135 */
-void OemToAnsiBuff(LPCSTR lpOemStr, LPSTR lpAnsiStr, INT nLength)
-{
- int i;
- for(i=0;i<nLength;i++)
- lpAnsiStr[i]=Oem2Ansi[(unsigned char)(lpOemStr[i])];
-}
-
-
/***********************************************************************
* OutputDebugString (KERNEL.115)
*/
@@ -518,7 +443,7 @@
}
/***********************************************************************
- * IsCharAlphaW (USER32.334)
+ * IsCharLower32A (USER32.334)
* FIXME: handle current locale
*/
BOOL32 IsCharLower32A(CHAR x)
@@ -527,7 +452,7 @@
}
/***********************************************************************
- * IsCharAlphaW (USER32.335)
+ * IsCharLower32W (USER32.335)
* FIXME: handle current locale
*/
BOOL32 IsCharLower32W(WCHAR x)
@@ -536,7 +461,7 @@
}
/***********************************************************************
- * IsCharAlphaW (USER32.336)
+ * IsCharUpper32A (USER32.336)
* FIXME: handle current locale
*/
BOOL32 IsCharUpper32A(CHAR x)
@@ -545,7 +470,7 @@
}
/***********************************************************************
- * IsCharAlphaW (USER32.337)
+ * IsCharUpper32W (USER32.337)
* FIXME: handle current locale
*/
BOOL32 IsCharUpper32W(WCHAR x)
@@ -554,86 +479,6 @@
}
/***********************************************************************
- * CharToOemA (USER32.36)
- */
-BOOL32 CharToOem32A(LPSTR s,LPSTR d)
-{
- if (!s || !d)
- return TRUE;
- AnsiToOem(s,d);
- return TRUE;
-}
-
-/***********************************************************************
- * CharToOemBuffA (USER32.37)
- */
-BOOL32 CharToOemBuff32A(LPSTR s,LPSTR d,DWORD len)
-{
- AnsiToOemBuff(s,d,len);
- return TRUE;
-}
-
-/***********************************************************************
- * CharToOemBuffW (USER32.38)
- */
-BOOL32 CharToOemBuff32W(LPCWSTR s,LPSTR d,DWORD len)
-{
- LPSTR x=STRING32_DupUniToAnsi(s);
- AnsiToOemBuff(x,d,len);
- return TRUE;
-}
-
-/***********************************************************************
- * CharToOemW (USER32.39)
- */
-BOOL32 CharToOem32W(LPCWSTR s,LPSTR d)
-{
- LPSTR x=STRING32_DupUniToAnsi(s);
- AnsiToOem(x,d);
- return TRUE;
-}
-
-/***********************************************************************
- * OemToCharA (USER32.401)
- */
-BOOL32 OemToChar32A(LPSTR s,LPSTR d)
-{
- OemToAnsi(s,d);
- return TRUE;
-}
-
-/***********************************************************************
- * OemToCharBuffA (USER32.402)
- */
-BOOL32 OemToCharBuff32A(LPSTR s,LPSTR d,DWORD len)
-{
- OemToAnsiBuff(s,d,len);
- return TRUE;
-}
-
-/***********************************************************************
- * OemToCharBuffW (USER32.403)
- */
-BOOL32 OemToCharBuff32W(LPCSTR s,LPWSTR d,DWORD len)
-{
- LPSTR x=(char*)xmalloc(strlen(s));
- OemToAnsiBuff((LPSTR)s,x,len);
- STRING32_AnsiToUni(d,x);
- return TRUE;
-}
-
-/***********************************************************************
- * OemToCharW (USER32.404)
- */
-BOOL32 OemToChar32W(LPCSTR s,LPWSTR d)
-{
- LPSTR x=(char*)xmalloc(strlen(s));
- OemToAnsi((LPSTR)s,x);
- STRING32_AnsiToUni(d,x);
- return TRUE;
-}
-
-/***********************************************************************
* FormatMessageA (KERNEL32.138) Library Version
* FIXME: missing wrap,FROM_SYSTEM message-loading,
*/
diff --git a/misc/lzexpand.c b/misc/lzexpand.c
index 1c47990..a48fa0d 100644
--- a/misc/lzexpand.c
+++ b/misc/lzexpand.c
@@ -16,16 +16,13 @@
#include <sys/stat.h>
#include "windows.h"
#include "file.h"
+#include "heap.h"
#include "ldt.h"
#include "lzexpand.h"
#include "stddebug.h"
#include "debug.h"
#include "xmalloc.h"
-#include "string32.h"
-#define strdupW2A(x) STRING32_DupUniToAnsi(x)
-#define strdupA2W(x) STRING32_DupAnsiToUni(x)
-#define strcpyAW(a,b) STRING32_AnsiToUni(a,b)
/* The readahead length of the decompressor. Reading single bytes
* using _lread() would be SLOW.
@@ -265,13 +262,12 @@
char *xin,*xout;
INT32 ret;
- xout = malloc(lstrlen32W(in)+3);
- xin = strdupW2A(in);
+ xout = HeapAlloc( GetProcessHeap(), 0, lstrlen32W(in)+3 );
+ xin = HEAP_strdupWtoA( GetProcessHeap(), 0, in );
ret = GetExpandedName16(xin,xout);
- if (ret>0)
- strcpyAW(out,xout);
- free(xin);
- free(xout);
+ if (ret>0) lstrcpyAtoW(out,xout);
+ HeapFree( GetProcessHeap(), 0, xin );
+ HeapFree( GetProcessHeap(), 0, xout );
return ret;
}
@@ -530,14 +526,14 @@
LPWSTR yfn;
HFILE ret;
- xfn = strdupW2A(fn);
+ xfn = HEAP_strdupWtoA( GetProcessHeap(), 0, fn);
ret = LZOpenFile16(xfn,ofs,mode);
- free(xfn);
+ HeapFree( GetProcessHeap(), 0, xfn );
if (ret!=HFILE_ERROR) {
/* ofs->szPathName is an array with the OFSTRUCT */
- yfn = strdupA2W(ofs->szPathName);
+ yfn = HEAP_strdupAtoW( GetProcessHeap(), 0, ofs->szPathName );
memcpy(ofs->szPathName,yfn,lstrlen32W(yfn)*2+2);
- free(yfn);
+ HeapFree( GetProcessHeap(), 0, yfn );
}
return ret;
}
diff --git a/misc/main.c b/misc/main.c
index dfda8c5..754950e 100644
--- a/misc/main.c
+++ b/misc/main.c
@@ -18,17 +18,18 @@
#include <X11/Xutil.h>
#include <X11/Xlocale.h>
#include <X11/cursorfont.h>
+#include "heap.h"
#include "message.h"
#include "module.h"
#include "msdos.h"
#include "windows.h"
+#include "color.h"
#include "winsock.h"
#include "options.h"
#include "desktop.h"
#include "registers.h"
#include "shell.h"
#include "winbase.h"
-#include "string32.h"
#define DEBUG_DEFINE_VARIABLES
#include "stddebug.h"
#include "debug.h"
@@ -602,6 +603,7 @@
static void called_at_exit(void)
{
MAIN_RestoreSetup();
+ COLOR_Cleanup();
WINSOCK_Shutdown();
}
@@ -764,7 +766,7 @@
v->dwMinorVersion = v1.dwMinorVersion;
v->dwBuildNumber = v1.dwBuildNumber;
v->dwPlatformId = v1.dwPlatformId;
- STRING32_AnsiToUni(v->szCSDVersion, v1.szCSDVersion);
+ lstrcpyAtoW( v->szCSDVersion, v1.szCSDVersion );
return TRUE;
}
@@ -889,12 +891,11 @@
*/
BOOL32 SetEnvironmentVariable32W( LPCWSTR lpName, LPCWSTR lpValue )
{
- LPSTR lpNameA = STRING32_DupUniToAnsi(lpName);
- LPSTR lpValueA = lpValue?STRING32_DupUniToAnsi(lpValue):NULL;
+ LPSTR lpNameA = HEAP_strdupWtoA( GetProcessHeap(), 0, lpName );
+ LPSTR lpValueA = HEAP_strdupWtoA( GetProcessHeap(), 0, lpValue );
BOOL32 ret = SetEnvironmentVariable32A(lpNameA,lpValueA);
-
- free (lpNameA);
- if (lpValue) free (lpValueA);
+ HeapFree( GetProcessHeap(), 0, lpNameA );
+ HeapFree( GetProcessHeap(), 0, lpValueA );
return ret;
}
@@ -936,13 +937,15 @@
*/
DWORD GetEnvironmentVariable32W( LPWSTR nameW, LPWSTR valW, DWORD size )
{
- LPSTR name = nameW?STRING32_DupUniToAnsi(nameW):NULL;
- LPSTR val = valW?(LPSTR)xmalloc(size*2):NULL;
- DWORD res = GetEnvironment(name,val,size);
-
- if (name) free(name);
- if (val) lstrcpynAtoW(valW,val,size);
- if (val) free(val);
+ LPSTR name = HEAP_strdupWtoA( GetProcessHeap(), 0, nameW );
+ LPSTR val = valW ? HeapAlloc( GetProcessHeap(), 0, size ) : NULL;
+ DWORD res = GetEnvironment( name, val, size );
+ HeapFree( GetProcessHeap(), 0, name );
+ if (val)
+ {
+ lstrcpyAtoW( valW, val );
+ HeapFree( GetProcessHeap(), 0, val );
+ }
return res;
}
diff --git a/misc/ole2nls.c b/misc/ole2nls.c
index 8669f50..a6b1e8b 100644
--- a/misc/ole2nls.c
+++ b/misc/ole2nls.c
@@ -7,12 +7,12 @@
#include <string.h>
#include <malloc.h>
#include "windows.h"
+#include "heap.h"
#include "ole.h"
#include "options.h"
#include "winnls.h"
#include "stddebug.h"
#include "debug.h"
-#include "string32.h"
/* Locale name to id map. used by EnumSystemLocales, GetLocalInfoA
* MUST contain all #defines from winnls.h
@@ -1278,22 +1278,22 @@
/***********************************************************************
* EnumSystemLocales32W (KERNEL32.93)
*/
-BOOL32
-EnumSystemLocales32W(LOCALE_ENUMPROC32W lpfnLocaleEnum,DWORD flags) {
- WCHAR *cp;
+BOOL32 EnumSystemLocales32W( LOCALE_ENUMPROC32W lpfnLocaleEnum, DWORD flags )
+{
int i;
BOOL32 ret;
dprintf_win32(stddeb,"EnumSystemLocales32W(%p,%08lx)\n",
- lpfnLocaleEnum,flags
- );
+ lpfnLocaleEnum,flags );
i=0;
- while (locale_name2id[i].name!=NULL) {
- cp=(LPWSTR)STRING32_DupAnsiToUni(locale_name2id[i].name);
- ret=lpfnLocaleEnum(cp);
- free(cp);
- if (!ret) break;
- i++;
+ while (locale_name2id[i].name!=NULL)
+ {
+ LPWSTR cp = HEAP_strdupAtoW( GetProcessHeap(), 0,
+ locale_name2id[i].name );
+ ret = lpfnLocaleEnum(cp);
+ HeapFree( GetProcessHeap(), 0, cp );
+ if (!ret) break;
+ i++;
}
return TRUE;
}
diff --git a/misc/registry.c b/misc/registry.c
index e208349..ece9fb0 100644
--- a/misc/registry.c
+++ b/misc/registry.c
@@ -20,6 +20,7 @@
#include "win.h"
#include "winerror.h"
#include "file.h"
+#include "heap.h"
#include "dos_fs.h"
#include "string32.h"
#include "stddebug.h"
@@ -82,11 +83,8 @@
#define UNICONVMASK ((1<<REG_SZ)|(1<<REG_MULTI_SZ)|(1<<REG_EXPAND_SZ))
#define strdupA2W(x) STRING32_DupAnsiToUni(x)
-#define strdupW2A(x) STRING32_DupUniToAnsi(x)
#define strdupW(x) STRING32_strdupW(x)
-#define strcmpniW(a,b) STRING32_lstrcmpniW(a,b)
#define strchrW(a,c) STRING32_lstrchrW(a,c)
-#define strcpyWA(a,b) STRING32_UniToAnsi(a,b)
static struct openhandle {
LPKEYSTRUCT lpkey;
@@ -159,8 +157,8 @@
return "<NULL>";
if (sub!=0 && sub!=1)
return "<W2C:bad sub>";
- if (unicodedebug[sub]) free(unicodedebug[sub]);
- unicodedebug[sub] = strdupW2A(x);
+ if (unicodedebug[sub]) HeapFree( SystemHeap, 0, unicodedebug[sub] );
+ unicodedebug[sub] = HEAP_strdupWtoA( SystemHeap, 0, x );
return unicodedebug[sub];
}
@@ -1429,7 +1427,7 @@
struct _w31_dirent *dir;
struct _w31_keyent *key;
struct _w31_valent *val;
- LPKEYSTRUCT xlpkey;
+ LPKEYSTRUCT xlpkey = NULL;
LPWSTR name,value;
static char tail[400];
@@ -2132,7 +2130,7 @@
if (buf) {
if (UNICONVMASK & (1<<(type))) {
/* convert UNICODE to ASCII */
- strcpyWA(lpbData,(LPWSTR)buf);
+ lstrcpyWtoA(lpbData,(LPWSTR)buf);
*lpcbData = myxlen/2;
} else {
if (myxlen>*lpcbData)
@@ -2536,10 +2534,10 @@
ft
);
if (ret==ERROR_SUCCESS) {
- strcpyWA(lpszName,lpszNameW);
+ lstrcpyWtoA(lpszName,lpszNameW);
*lpcchName=strlen(lpszName);
if (lpszClassW) {
- strcpyWA(lpszClass,lpszClassW);
+ lstrcpyWtoA(lpszClass,lpszClassW);
*lpcchClass=strlen(lpszClass);
}
}
@@ -2677,10 +2675,10 @@
);
if (ret==ERROR_SUCCESS) {
- strcpyWA(lpszValue,lpszValueW);
+ lstrcpyWtoA(lpszValue,lpszValueW);
if (lpbData) {
if ((1<<*lpdwType) & UNICONVMASK) {
- strcpyWA(lpbData,(LPWSTR)lpbDataW);
+ lstrcpyWtoA(lpbData,(LPWSTR)lpbDataW);
} else {
if (lpcbDataW > *lpcbData)
ret = ERROR_MORE_DATA;
@@ -3009,7 +3007,7 @@
ft
);
if (ret==ERROR_SUCCESS)
- strcpyWA(lpszClass,lpszClassW);
+ lstrcpyWtoA(lpszClass,lpszClassW);
if (lpcchClass)
*lpcchClass/=2;
if (lpcchMaxSubkey)
diff --git a/misc/shell.c b/misc/shell.c
index 263b9d8..486e733 100644
--- a/misc/shell.c
+++ b/misc/shell.c
@@ -9,6 +9,7 @@
#include "windows.h"
#include "file.h"
#include "shell.h"
+#include "heap.h"
#include "module.h"
#include "neexe.h"
#include "resource.h"
@@ -771,7 +772,7 @@
LPSTR lpstr = str;
LPSTR lpbstr = lpBuffer;
- AnsiToOem(str,str);
+ CharToOem32A(str,str);
dprintf_reg(stddeb,"DoEnvSubst: accept %s", str);
@@ -824,7 +825,7 @@
dprintf_reg(stddeb," return %s\n", str);
- OemToAnsi(str,str);
+ OemToChar32A(str,str);
free(lpBuffer);
/* Return str length in the LOWORD
@@ -873,7 +874,8 @@
LPWSTR *argv,s,t;
int i;
- cmdline = (LPWSTR)STRING32_strdupW(cmdline); /* to get writeable copy */
+ /* to get writeable copy */
+ cmdline = HEAP_strdupW( GetProcessHeap(), 0, cmdline);
s=cmdline;i=0;
while (*s) {
/* space */
@@ -886,13 +888,13 @@
}
s++;
}
- argv=(LPWSTR*)xmalloc(sizeof(LPWSTR)*(i+1));
+ argv=(LPWSTR*)HeapAlloc( GetProcessHeap(), 0, sizeof(LPWSTR)*(i+1) );
s=t=cmdline;
i=0;
while (*s) {
if (*s==0x0020) {
*s=0;
- argv[i++]=(LPWSTR)STRING32_strdupW(t);
+ argv[i++]=HEAP_strdupW( GetProcessHeap(), 0, t );
*s=0x0020;
while (*s && *s==0x0020)
s++;
@@ -905,8 +907,8 @@
s++;
}
if (*t)
- argv[i++]=(LPWSTR)STRING32_strdupW(t);
- free(cmdline);
+ argv[i++]=(LPWSTR)HEAP_strdupW( GetProcessHeap(), 0, t );
+ HeapFree( GetProcessHeap(), 0, cmdline );
argv[i]=NULL;
*numargs=i;
return argv;
diff --git a/misc/ver.c b/misc/ver.c
index 3ee1fcd..84740c8 100644
--- a/misc/ver.c
+++ b/misc/ver.c
@@ -11,6 +11,7 @@
#include "windows.h"
#include "win.h"
#include "winerror.h"
+#include "heap.h"
#include "ver.h"
#include "lzexpand.h"
#include "module.h"
@@ -19,15 +20,11 @@
#include "debug.h"
#include "xmalloc.h"
#include "winreg.h"
-#include "string32.h"
#define LZREAD(what) \
if (sizeof(*what)!=LZRead32(lzfd,what,sizeof(*what))) return 0;
#define LZTELL(lzfd) LZSeek(lzfd, 0, SEEK_CUR);
-#define strdupW2A(x) STRING32_DupUniToAnsi(x)
-#define strdupA2W(x) STRING32_DupAnsiToUni(x)
-
int
read_ne_header(HFILE lzfd,struct ne_header_s *nehd) {
struct mz_header_s mzh;
@@ -348,15 +345,12 @@
}
/* GetFileVersionInfoSize32W [VERSION.2] */
-DWORD
-GetFileVersionInfoSize32W(LPCWSTR filename,LPDWORD handle) {
- LPSTR xfn;
- DWORD ret;
-
- xfn = strdupW2A(filename);
- ret=GetFileVersionInfoSize16(xfn,handle);
- free(xfn);
- return ret;
+DWORD GetFileVersionInfoSize32W( LPCWSTR filename, LPDWORD handle )
+{
+ LPSTR xfn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
+ DWORD ret = GetFileVersionInfoSize16( xfn, handle );
+ HeapFree( GetProcessHeap(), 0, xfn );
+ return ret;
}
/* GetFileVersionInfo [VER.7] */
@@ -377,15 +371,13 @@
}
/* GetFileVersionInfoW [VERSION.3] */
-DWORD
-GetFileVersionInfo32W(LPCWSTR filename,DWORD handle,DWORD datasize,LPVOID data){
- DWORD ret;
- LPSTR fn;
-
- fn = strdupW2A(filename);
- ret = GetFileVersionInfo16(fn,handle,datasize,data);
- free(fn);
- return ret;
+DWORD GetFileVersionInfo32W( LPCWSTR filename, DWORD handle, DWORD datasize,
+ LPVOID data)
+{
+ LPSTR fn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
+ DWORD ret = GetFileVersionInfo16( fn, handle, datasize, data );
+ HeapFree( GetProcessHeap(), 0, fn );
+ return ret;
}
/* VerFindFile [VER.8] */
@@ -428,16 +420,21 @@
LPSTR wfn,wwd,wad,wdd,wcd;
DWORD ret;
- wfn = strdupW2A(filename);
- wwd = strdupW2A(windir);
- wad = strdupW2A(appdir);
- wcd = (LPSTR)malloc(*pcurdirlen);
- wdd = (LPSTR)malloc(*pdestdirlen);
- ret=VerFindFile16(flags,wfn,wwd,wad,wcd,&curdirlen,wdd,&destdirlen);
- STRING32_AnsiToUni(curdir,wcd);
- STRING32_AnsiToUni(destdir,wdd);
+ wfn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
+ wwd = HEAP_strdupWtoA( GetProcessHeap(), 0, windir );
+ wad = HEAP_strdupWtoA( GetProcessHeap(), 0, appdir );
+ wcd = HeapAlloc( GetProcessHeap(), 0, *pcurdirlen );
+ wdd = HeapAlloc( GetProcessHeap(), 0, *pdestdirlen );
+ ret = VerFindFile16(flags,wfn,wwd,wad,wcd,&curdirlen,wdd,&destdirlen);
+ lstrcpynAtoW(curdir,wcd,*pcurdirlen);
+ lstrcpynAtoW(destdir,wdd,*pdestdirlen);
*pcurdirlen = strlen(wcd);
*pdestdirlen = strlen(wdd);
+ HeapFree( GetProcessHeap(), 0, wfn );
+ HeapFree( GetProcessHeap(), 0, wwd );
+ HeapFree( GetProcessHeap(), 0, wad );
+ HeapFree( GetProcessHeap(), 0, wcd );
+ HeapFree( GetProcessHeap(), 0, wdd );
return ret;
}
@@ -473,23 +470,23 @@
DWORD
VerInstallFile32W(
UINT32 flags,LPCWSTR srcfilename,LPCWSTR destfilename,LPCWSTR srcdir,
- LPCWSTR destdir,LPWSTR tmpfile,UINT32 *tmpfilelen
-) {
- LPSTR wsrcf,wsrcd,wdestf,wdestd,wtmpf;
- DWORD ret;
+ LPCWSTR destdir,LPWSTR tmpfile,UINT32 *tmpfilelen )
+{
+ LPSTR wsrcf,wsrcd,wdestf,wdestd,wtmpf;
+ DWORD ret;
- wsrcf = strdupW2A(srcfilename);
- wsrcd = strdupW2A(srcdir);
- wdestf = strdupW2A(destfilename);
- wdestd = strdupW2A(destdir);
- wtmpf = strdupW2A(tmpfile);
- ret=VerInstallFile32A(flags,wsrcf,wdestf,wsrcd,wdestd,wtmpf,tmpfilelen);
- free(wsrcf);
- free(wsrcd);
- free(wdestf);
- free(wdestd);
- free(wtmpf);
- return ret;
+ wsrcf = HEAP_strdupWtoA( GetProcessHeap(), 0, srcfilename );
+ wsrcd = HEAP_strdupWtoA( GetProcessHeap(), 0, srcdir );
+ wdestf = HEAP_strdupWtoA( GetProcessHeap(), 0, destfilename );
+ wdestd = HEAP_strdupWtoA( GetProcessHeap(), 0, destdir );
+ wtmpf = HEAP_strdupWtoA( GetProcessHeap(), 0, tmpfile );
+ ret = VerInstallFile32A(flags,wsrcf,wdestf,wsrcd,wdestd,wtmpf,tmpfilelen);
+ HeapFree( GetProcessHeap(), 0, wsrcf );
+ HeapFree( GetProcessHeap(), 0, wsrcd );
+ HeapFree( GetProcessHeap(), 0, wdestf );
+ HeapFree( GetProcessHeap(), 0, wdestd );
+ HeapFree( GetProcessHeap(), 0, wtmpf );
+ return ret;
}
/* FIXME: This table should, of course, be language dependend */
@@ -580,32 +577,25 @@
DWORD
VerLanguageName32W(UINT32 langid,LPWSTR langname,UINT32 langnamelen) {
int i;
- char *buf;
- LPWSTR keyname,result;
+ char buffer[80];
+ LPWSTR keyname;
/* First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
* from the registry.
*/
- buf=(char*)malloc(strlen("\\System\\CurrentControlSet\\control\\Nls\\Locale\\")+9);
- sprintf(buf,"\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",langid);
- keyname=strdupA2W(buf);free(buf);
+ sprintf(buffer,"\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",langid);
+ keyname = HEAP_strdupAtoW( GetProcessHeap(), 0, buffer );
if (ERROR_SUCCESS==RegQueryValue32W(HKEY_LOCAL_MACHINE,keyname,langname,(LPDWORD)&langnamelen)) {
- free(keyname);
+ HeapFree( GetProcessHeap(), 0, keyname );
return langnamelen;
}
- free(keyname);
+ HeapFree( GetProcessHeap(), 0, keyname );
/* if that fails, use the interal table */
for (i=0;languages[i].langid!=0;i++)
if (langid==languages[i].langid)
break;
- result=strdupA2W(languages[i].langname);
- i=lstrlen32W(result)*sizeof(WCHAR);
- if (i>langnamelen)
- i=langnamelen;
- memcpy(langname,result,i);
- langname[langnamelen-1]='\0';
- free(result);
- return strlen(languages[i].langname); /* same as strlenW(result); */
+ lstrcpyAtoW( langname, languages[i].langname );
+ return strlen(languages[i].langname); /* same as strlenW(langname); */
}
/* FIXME: UNICODE? */
@@ -729,13 +719,13 @@
struct db *db;
char *s,*sb;
- sb=strdupW2A(subblock);
+ sb = HEAP_strdupWtoA( GetProcessHeap(), 0, subblock );
s=(char*)xmalloc(strlen("VS_VERSION_INFO\\")+strlen(sb)+1);
strcpy(s,"VS_VERSION_INFO\\");strcat(s,sb);
b=_find_data(block,s);
if (b==NULL) {
*buflen=0;
- free(sb);
+ HeapFree( GetProcessHeap(), 0, sb );
return 0;
}
db=(struct db*)b;
@@ -744,7 +734,7 @@
b = b+4+((strlen(db->name)+4)&~3);
*buffer = b;
dprintf_ver(stddeb," -> %s=%s\n",sb,b);
- free(sb);
+ HeapFree( GetProcessHeap(), 0, sb );
return 1;
}
/* 20 GETFILEVERSIONINFORAW */
diff --git a/misc/winsock_async.c b/misc/winsock_async.c
index c97588b..607b9cf 100644
--- a/misc/winsock_async.c
+++ b/misc/winsock_async.c
@@ -15,6 +15,8 @@
#include <sys/wait.h>
#include <errno.h>
+extern int h_errno;
+
#include "windows.h"
#include "winsock.h"
#include "debug.h"
diff --git a/objects/bitmap.c b/objects/bitmap.c
index 0c535f5..791848d 100644
--- a/objects/bitmap.c
+++ b/objects/bitmap.c
@@ -13,7 +13,6 @@
#include "dc.h"
#include "bitmap.h"
#include "heap.h"
-#include "string32.h"
#include "stddebug.h"
#include "debug.h"
@@ -88,6 +87,9 @@
BITMAPOBJ * bmpObjPtr;
HBITMAP16 hbitmap;
+ planes = (BYTE)planes;
+ bpp = (BYTE)bpp;
+
dprintf_gdi( stddeb, "CreateBitmap: %dx%d, %d colors\n",
width, height, 1 << (planes*bpp) );
@@ -294,7 +296,7 @@
*/
HBITMAP16 LoadBitmap16( HINSTANCE16 instance, SEGPTR name )
{
- HBITMAP16 hbitmap = 0;
+ HBITMAP32 hbitmap = 0;
HDC32 hdc;
HRSRC16 hRsrc;
HGLOBAL16 handle;
@@ -323,8 +325,8 @@
if ((hdc = GetDC32(0)) != 0)
{
char *bits = (char *)info + DIB_BitmapInfoSize( info, DIB_RGB_COLORS );
- hbitmap = CreateDIBitmap( hdc, &info->bmiHeader, CBM_INIT,
- bits, info, DIB_RGB_COLORS );
+ hbitmap = CreateDIBitmap32( hdc, &info->bmiHeader, CBM_INIT,
+ bits, info, DIB_RGB_COLORS );
ReleaseDC32( 0, hdc );
}
FreeResource16( handle );
@@ -356,8 +358,8 @@
if ((hdc = GetDC32(0)) != 0)
{
char *bits = (char *)info + DIB_BitmapInfoSize( info, DIB_RGB_COLORS );
- hbitmap = CreateDIBitmap( hdc, &info->bmiHeader, CBM_INIT,
- bits, info, DIB_RGB_COLORS );
+ hbitmap = CreateDIBitmap32( hdc, &info->bmiHeader, CBM_INIT,
+ bits, info, DIB_RGB_COLORS );
ReleaseDC32( 0, hdc );
}
return hbitmap;
@@ -370,12 +372,12 @@
HBITMAP32 LoadBitmap32A( HINSTANCE32 instance, LPCSTR name )
{
HBITMAP32 res;
- if (!HIWORD(name)) res = LoadBitmap32W(instance,(LPWSTR)name);
+ if (!HIWORD(name)) res = LoadBitmap32W( instance, (LPWSTR)name );
else
{
- LPWSTR uni = STRING32_DupAnsiToUni(name);
- res = LoadBitmap32W(instance,uni);
- free(uni);
+ LPWSTR uni = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
+ res = LoadBitmap32W( instance, uni );
+ HeapFree( GetProcessHeap(), 0, uni );
}
return res;
}
diff --git a/objects/brush.c b/objects/brush.c
index ecb71cc..5480b85 100644
--- a/objects/brush.c
+++ b/objects/brush.c
@@ -536,9 +536,10 @@
if ((bmpInfo = (BITMAPINFO *) GlobalLock16( (HGLOBAL16)brush->logbrush.lbHatch )))
{
int size = DIB_BitmapInfoSize( bmpInfo, brush->logbrush.lbColor );
- hBitmap = CreateDIBitmap( dc->hSelf, &bmpInfo->bmiHeader, CBM_INIT,
- ((char *)bmpInfo) + size, bmpInfo,
- (WORD) brush->logbrush.lbColor );
+ hBitmap = CreateDIBitmap32( dc->hSelf, &bmpInfo->bmiHeader,
+ CBM_INIT, ((char *)bmpInfo) + size,
+ bmpInfo,
+ (WORD)brush->logbrush.lbColor );
BRUSH_SelectPatternBrush( dc, hBitmap );
DeleteObject16( hBitmap );
GlobalUnlock16( (HGLOBAL16)brush->logbrush.lbHatch );
diff --git a/objects/clipping.c b/objects/clipping.c
index 787991b..7ca30a9 100644
--- a/objects/clipping.c
+++ b/objects/clipping.c
@@ -418,6 +418,7 @@
return ret;
}
+
/***********************************************************************
* GetClipRgn32 (GDI32.163)
*/
diff --git a/objects/color.c b/objects/color.c
index bc1615f..8aaed5c 100644
--- a/objects/color.c
+++ b/objects/color.c
@@ -23,14 +23,15 @@
*
*
* Windows needs contiguous color space ( from 0 to n ) but
- * it is possible only with private colormap. Otherwise we
- * have to map DC palette indices to real pixel values.
- * With private colormap it boils down to identity mapping. The
- * other special case is when we have fixed color visual with
- * screendepth > 8 - we abandon mapping altogether (pixel
- * values can be calculated without X server assistance).
+ * it is possible only with the private colormap. Otherwise we
+ * have to map DC palette indices to real pixel values. With
+ * private colormaps it boils down to the identity mapping. The
+ * other special case is when we have a fixed color visual with
+ * the screendepth > 8 - we abandon palette mappings altogether
+ * because pixel values can be calculated without X server
+ * assistance.
*
- * For info about general Windows palette management read
+ * For some info about general Windows palette management read
* http://198.105.232.5/MSDN/LIBRARY/TECHNOTE/CH3.HTM
*/
@@ -66,6 +67,7 @@
static PALETTEENTRY* COLOR_sysPal = NULL; /* current system palette */
static int COLOR_gapStart = 256;
static int COLOR_gapEnd = -1;
+static int COLOR_gapFilled = 0;
/* First free dynamic color cell, 0 = full palette, -1 = fixed palette */
static int COLOR_firstFree = 0;
@@ -156,6 +158,15 @@
COLOR_freeList[j] = 0;
}
+BOOL32 COLOR_CheckSysColor(COLORREF c)
+{
+ int i;
+ for( i = 0; i < NB_RESERVED_COLORS; i++ )
+ if( c == (*(COLORREF*)(__sysPalTemplate + i) & 0x00ffffff) )
+ return 0;
+ return 1;
+}
+
void COLOR_FillDefaultColors(void)
{
/* initialize unused entries to what Windows uses as a color
@@ -177,8 +188,9 @@
idx = COLOR_firstFree;
- for (blue = NB_COLORCUBE_START_INDEX; blue < 256 && idx; blue += inc_b )
- for (green = NB_COLORCUBE_START_INDEX; green < 256 && idx; green += inc_g )
+ if( idx != -1 )
+ for (blue = NB_COLORCUBE_START_INDEX; blue < 256 && idx; blue += inc_b )
+ for (green = NB_COLORCUBE_START_INDEX; green < 256 && idx; green += inc_g )
for (red = NB_COLORCUBE_START_INDEX; red < 256 && idx; red += inc_r )
{
/* weird but true */
@@ -212,23 +224,40 @@
idx = COLOR_freeList[idx];
}
- /* fill the rest with gray for now - only needed for
- * sparse palette (in seamless mode)
- */
+ /* try to fill some entries in the "gap" with
+ * what's already in the colormap - they will be
+ * mappable to but not changeable. */
- for ( i = COLOR_gapStart; i <= COLOR_gapEnd; i++ )
+ if( COLOR_gapStart < COLOR_gapEnd && COLOR_PixelToPalette )
{
- *(COLORREF*)(COLOR_sysPal + i) = 0x00c0c0c0;
- if( COLOR_PaletteToPixel )
- COLOR_PaletteToPixel[i] = COLOR_PaletteToPixel[7];
+ XColor xc;
+ int r, g, b;
+
+ for ( i = 0, idx = COLOR_gapStart; i < 256 && idx <= COLOR_gapEnd; i++ )
+ if( COLOR_PixelToPalette[i] == 0 )
+ {
+ xc.pixel = i;
+
+ XQueryColor(display, cSpace.colorMap, &xc);
+ r = xc.red>>8; g = xc.green>>8; b = xc.blue>>8;
+
+ if( xc.pixel < 256 && COLOR_CheckSysColor(RGB(r, g, b)) &&
+ XAllocColor(display, cSpace.colorMap, &xc) )
+ {
+ COLOR_PixelToPalette[xc.pixel] = idx;
+ COLOR_PaletteToPixel[idx] = xc.pixel;
+ *(COLORREF*)(COLOR_sysPal + idx) = RGB(r, g, b);
+ COLOR_sysPal[idx++].peFlags |= PC_SYS_USED;
+ }
+ }
+ COLOR_gapFilled = idx - COLOR_gapStart;
}
}
/***********************************************************************
* COLOR_BuildPrivateMap/COLOR_BuildSharedMap
*
- * Executed only one time so we don't care about sloppiness,
- * the rest have to be very tight though...
+ * Allocate colorcells and initialize mapping tables.
*/
static BOOL COLOR_BuildPrivateMap(CSPACE* cs)
{
@@ -265,7 +294,7 @@
color.pixel = i;
XStoreColor(display, cs->colorMap, &color);
- /* Set EGA mapping if color in the first or last eight */
+ /* Set EGA mapping if color is from the first or last eight */
if (i < 8)
COLOR_mapEGAPixel[i] = color.pixel;
@@ -287,8 +316,10 @@
unsigned long sysPixel[NB_RESERVED_COLORS];
unsigned long* pixDynMapping = NULL;
unsigned long plane_masks[1];
- int i, j;
+ int i, j, warn = 0;
int color_ini_max = 256;
+ int diff, r, g, b, max = 256, bp = 0, wp = 1;
+ int step = 1;
/* read "AllocSystemColors" from wine.conf */
@@ -309,10 +340,46 @@
color.flags = DoRed | DoGreen | DoBlue;
if (!XAllocColor( display, cSpace.colorMap, &color ))
- {
- fprintf(stderr, "Warning: Not enough free colors for system palette.\n" );
- color.pixel = color.red = color.green = color.blue = 0;
- }
+ {
+ XColor best, c;
+
+ if( !warn++ )
+ {
+ dprintf_palette(stddeb, "Not enough colors for the full system palette.\n");
+
+ bp = BlackPixel(display, DefaultScreen(display));
+ wp = WhitePixel(display, DefaultScreen(display));
+
+ max = (0xffffffff)>>(32 - screenDepth);
+ if( max > 256 )
+ {
+ step = max/256;
+ max = 256;
+ }
+ }
+
+ /* reinit color (XAllocColor() may change it)
+ * and map to the best shared colorcell */
+
+ color.red = __sysPalTemplate[i].peRed * 65535 / 255;
+ color.green = __sysPalTemplate[i].peGreen * 65535 / 255;
+ color.blue = __sysPalTemplate[i].peBlue * 65535 / 255;
+
+ best.pixel = best.red = best.green = best.blue = 0;
+ for( c.pixel = 0, diff = 0x7fffffff; c.pixel < max; c.pixel += step )
+ {
+ XQueryColor(display, cSpace.colorMap, &c);
+ r = (c.red - color.red)>>8;
+ g = (c.green - color.green)>>8;
+ b = (c.blue - color.blue)>>8;
+ r = r*r + g*g + b*b;
+ if( r < diff ) { best = c; diff = r; }
+ }
+
+ if( XAllocColor(display, cSpace.colorMap, &best) )
+ color.pixel = best.pixel;
+ else color.pixel = (i < NB_RESERVED_COLORS/2)? bp : wp;
+ }
sysPixel[i] = color.pixel;
@@ -327,6 +394,8 @@
COLOR_mapEGAPixel[i - (NB_RESERVED_COLORS-16)] = color.pixel;
}
+ /* now allocate changeable set */
+
if( !(cSpace.flags & COLOR_FIXED) )
{
int c_min = 0, c_max = cs->size, c_val;
@@ -389,12 +458,8 @@
dprintf_palette(stddeb,"Shared system palette uses %i colors.\n", cs->size);
- /* Set gap to account for pixel shortage. It has to be right in the center
- * of the system palette because otherwise raster ops get screwed.
- * ( if we have 100 color palette and application does invert for pixel 1
- * it gets pixel 254 - far beyond our pathetic palette unless these 100
- * colors are mapped with the gap in the middle )
- */
+ /* set gap to account for pixel shortage. It has to be right in the center
+ * of the system palette because otherwise raster ops get screwed. */
if( cs->size >= 256 )
{ COLOR_gapStart = 256; COLOR_gapEnd = -1; }
@@ -407,7 +472,7 @@
COLOR_sysPal = (PALETTEENTRY*)xmalloc(sizeof(PALETTEENTRY)*256);
- /* Setup system palette entry <-> pixel mappings and fill in 20 fixed entries */
+ /* setup system palette entry <-> pixel mappings and fill in 20 fixed entries */
if( screenDepth <= 8 )
{
@@ -448,7 +513,7 @@
dprintf_palette(stddeb,"\tindex %i -> pixel %i\n", i, COLOR_PaletteToPixel[i]);
if( COLOR_PixelToPalette )
- COLOR_PixelToPalette[COLOR_PaletteToPixel[i]] = i;
+ COLOR_PixelToPalette[COLOR_PaletteToPixel[i]] = i;
}
if( pixDynMapping ) free(pixDynMapping);
@@ -459,7 +524,7 @@
/***********************************************************************
* COLOR_InitPalette
*
- * Create the system palette and initialize mapping tables.
+ * Create the system palette.
*/
static HPALETTE16 COLOR_InitPalette(void)
{
@@ -482,10 +547,9 @@
/* Build free list */
if( COLOR_firstFree != -1 )
- {
COLOR_FormatSystemPalette();
- COLOR_FillDefaultColors();
- }
+
+ COLOR_FillDefaultColors();
/* create default palette (20 system colors) */
@@ -517,7 +581,7 @@
*
* Calculate conversion parameters for direct mapped visuals
*/
-void COLOR_Computeshifts(unsigned long maskbits, int *shift, int *max)
+static void COLOR_Computeshifts(unsigned long maskbits, int *shift, int *max)
{
int i;
@@ -597,6 +661,18 @@
return COLOR_InitPalette();
}
+/***********************************************************************
+ * COLOR_Cleanup
+ *
+ * Free external colors we grabbed in the FillDefaultPalette()
+ */
+void COLOR_Cleanup(void)
+{
+ if( COLOR_gapFilled )
+ XFreeColors(display, cSpace.colorMap,
+ (unsigned long*)(COLOR_PaletteToPixel + COLOR_gapStart),
+ COLOR_gapFilled, 0);
+}
/***********************************************************************
* COLOR_IsSolid
@@ -736,25 +812,25 @@
/* check for hicolor visuals first */
if ( cSpace.flags & COLOR_FIXED && !COLOR_Graymax )
- {
+ {
color.red = (pixel >> COLOR_Redshift) & COLOR_Redmax;
color.green = (pixel >> COLOR_Greenshift) & COLOR_Greenmax;
color.blue = (pixel >> COLOR_Blueshift) & COLOR_Bluemax;
- }
- else if ((screenDepth <= 8) && (pixel < 256) &&
- !(cSpace.flags & (COLOR_VIRTUAL | COLOR_FIXED)) )
- return ( *(COLORREF*)(COLOR_sysPal +
- ((COLOR_PixelToPalette)?COLOR_PixelToPalette[pixel]:pixel)) ) & 0x00ffffff;
- else
- {
- color.pixel = pixel;
- XQueryColor(display, cSpace.colorMap, &color);
- return RGB(color.red >> 8, color.green >> 8, color.blue >> 8);
- }
+ return RGB((color.red * 255)/COLOR_Redmax,
+ (color.green * 255)/COLOR_Greenmax,
+ (color.blue * 255)/COLOR_Bluemax);
+ }
- return RGB((color.red * 255)/COLOR_Redmax,
- (color.green * 255)/COLOR_Greenmax,
- (color.blue * 255)/COLOR_Bluemax);
+ /* check if we can bypass X */
+
+ if ((screenDepth <= 8) && (pixel < 256) &&
+ !(cSpace.flags & (COLOR_VIRTUAL | COLOR_FIXED)) )
+ return ( *(COLORREF*)(COLOR_sysPal +
+ ((COLOR_PixelToPalette)?COLOR_PixelToPalette[pixel]:pixel)) ) & 0x00ffffff;
+
+ color.pixel = pixel;
+ XQueryColor(display, cSpace.colorMap, &color);
+ return RGB(color.red >> 8, color.green >> 8, color.blue >> 8);
}
diff --git a/objects/cursoricon.c b/objects/cursoricon.c
index df7be52..0ee8657 100644
--- a/objects/cursoricon.c
+++ b/objects/cursoricon.c
@@ -236,7 +236,7 @@
HGLOBAL16 CURSORICON_LoadHandler( HGLOBAL16 handle, HINSTANCE16 hInstance,
BOOL fCursor )
{
- HBITMAP16 hAndBits, hXorBits;
+ HBITMAP32 hAndBits, hXorBits;
HDC32 hdc;
int size, sizeAnd, sizeXor;
POINT16 hotspot = { 0 ,0 };
@@ -292,8 +292,8 @@
return 0;
}
- hXorBits = CreateDIBitmap( hdc, &pInfo->bmiHeader, CBM_INIT,
- (char*)bmi + size, pInfo, DIB_RGB_COLORS );
+ hXorBits = CreateDIBitmap32( hdc, &pInfo->bmiHeader, CBM_INIT,
+ (char*)bmi + size, pInfo, DIB_RGB_COLORS );
/* Fix the bitmap header to load the monochrome mask */
@@ -322,8 +322,8 @@
/* Create the AND bitmap */
- hAndBits = CreateDIBitmap( hdc, &pInfo->bmiHeader, CBM_INIT,
- bits, pInfo, DIB_RGB_COLORS );
+ hAndBits = CreateDIBitmap32( hdc, &pInfo->bmiHeader, CBM_INIT,
+ bits, pInfo, DIB_RGB_COLORS );
ReleaseDC32( 0, hdc );
/* Now create the CURSORICONINFO structure */
@@ -664,12 +664,12 @@
BOOL DrawIcon( HDC16 hdc, INT x, INT y, HICON16 hIcon )
{
CURSORICONINFO *ptr;
- HDC16 hMemDC;
+ HDC32 hMemDC;
HBITMAP16 hXorBits, hAndBits;
COLORREF oldFg, oldBg;
if (!(ptr = (CURSORICONINFO *)GlobalLock16( hIcon ))) return FALSE;
- if (!(hMemDC = CreateCompatibleDC( hdc ))) return FALSE;
+ if (!(hMemDC = CreateCompatibleDC32( hdc ))) return FALSE;
hAndBits = CreateBitmap( ptr->nWidth, ptr->nHeight, 1, 1, (char *)(ptr+1));
hXorBits = CreateBitmap( ptr->nWidth, ptr->nHeight, ptr->bPlanes,
ptr->bBitsPerPixel, (char *)(ptr + 1)
@@ -685,7 +685,7 @@
BitBlt32(hdc, x, y, ptr->nWidth, ptr->nHeight, hMemDC, 0, 0,SRCINVERT);
SelectObject32( hMemDC, hBitTemp );
}
- DeleteDC( hMemDC );
+ DeleteDC32( hMemDC );
if (hXorBits) DeleteObject32( hXorBits );
if (hAndBits) DeleteObject32( hAndBits );
GlobalUnlock16( hIcon );
diff --git a/objects/dc.c b/objects/dc.c
index 0d05d11..cfe93a1 100644
--- a/objects/dc.c
+++ b/objects/dc.c
@@ -5,17 +5,18 @@
*
*/
+#define NO_TRANSITION_TYPES /* This file is Win32-clean */
#include <stdlib.h>
#include <string.h>
#include "gdi.h"
#include "bitmap.h"
+#include "heap.h"
#include "metafile.h"
#include "stddebug.h"
#include "color.h"
#include "debug.h"
#include "font.h"
#include "xmalloc.h"
-#include "string32.h"
extern void CLIPPING_UpdateGCRegion( DC * dc ); /* objects/clipping.c */
@@ -56,15 +57,7 @@
0, /* DCOrgX */
0, /* DCOrgY */
0, /* CursPosX */
- 0, /* CursPosY */
- 0, /* WndOrgX */
- 0, /* WndOrgY */
- 1, /* WndExtX */
- 1, /* WndExtY */
- 0, /* VportOrgX */
- 0, /* VportOrgY */
- 1, /* VportExtX */
- 1 /* VportExtY */
+ 0 /* CursPosY */
};
/* ROP code to GC function conversion */
@@ -158,6 +151,14 @@
dc->saveLevel = 0;
dc->dwHookData = 0L;
dc->hookProc = NULL;
+ dc->wndOrgX = 0;
+ dc->wndOrgY = 0;
+ dc->wndExtX = 1;
+ dc->wndExtY = 1;
+ dc->vportOrgX = 0;
+ dc->vportOrgY = 0;
+ dc->vportExtX = 1;
+ dc->vportExtY = 1;
memcpy( &dc->w, &DC_defaultValues, sizeof(DC_defaultValues) );
return dc;
@@ -379,11 +380,49 @@
dprintf_dc(stddeb, "GetDCState(%04x): returning %04x\n", hdc, handle );
memset( &newdc->u.x, 0, sizeof(newdc->u.x) );
- memcpy( &newdc->w, &dc->w, sizeof(dc->w) );
+ newdc->w.flags = dc->w.flags | DC_SAVED;
+ newdc->w.devCaps = dc->w.devCaps;
+ newdc->w.hPen = dc->w.hPen;
+ newdc->w.hBrush = dc->w.hBrush;
+ newdc->w.hFont = dc->w.hFont;
+ newdc->w.hBitmap = dc->w.hBitmap;
+ newdc->w.hFirstBitmap = dc->w.hFirstBitmap;
+ newdc->w.hDevice = dc->w.hDevice;
+ newdc->w.hPalette = dc->w.hPalette;
+ newdc->w.bitsPerPixel = dc->w.bitsPerPixel;
+ newdc->w.ROPmode = dc->w.ROPmode;
+ newdc->w.polyFillMode = dc->w.polyFillMode;
+ newdc->w.stretchBltMode = dc->w.stretchBltMode;
+ newdc->w.relAbsMode = dc->w.relAbsMode;
+ newdc->w.backgroundMode = dc->w.backgroundMode;
+ newdc->w.backgroundColor = dc->w.backgroundColor;
+ newdc->w.textColor = dc->w.textColor;
+ newdc->w.backgroundPixel = dc->w.backgroundPixel;
+ newdc->w.textPixel = dc->w.textPixel;
+ newdc->w.brushOrgX = dc->w.brushOrgX;
+ newdc->w.brushOrgY = dc->w.brushOrgY;
+ newdc->w.textAlign = dc->w.textAlign;
+ newdc->w.charExtra = dc->w.charExtra;
+ newdc->w.breakTotalExtra = dc->w.breakTotalExtra;
+ newdc->w.breakCount = dc->w.breakCount;
+ newdc->w.breakExtra = dc->w.breakExtra;
+ newdc->w.breakRem = dc->w.breakRem;
+ newdc->w.MapMode = dc->w.MapMode;
+ newdc->w.DCOrgX = dc->w.DCOrgX;
+ newdc->w.DCOrgY = dc->w.DCOrgY;
+ newdc->w.CursPosX = dc->w.CursPosX;
+ newdc->w.CursPosY = dc->w.CursPosY;
+ newdc->wndOrgX = dc->wndOrgX;
+ newdc->wndOrgY = dc->wndOrgY;
+ newdc->wndExtX = dc->wndExtX;
+ newdc->wndExtY = dc->wndExtY;
+ newdc->vportOrgX = dc->vportOrgX;
+ newdc->vportOrgY = dc->vportOrgY;
+ newdc->vportExtX = dc->vportExtX;
+ newdc->vportExtY = dc->vportExtY;
newdc->hSelf = (HDC32)handle;
newdc->saveLevel = 0;
- newdc->w.flags |= DC_SAVED;
newdc->w.hGCClipRgn = 0;
newdc->w.hVisRgn = CreateRectRgn32( 0, 0, 0, 0 );
@@ -435,14 +474,15 @@
dc->w.DCOrgY = dcs->w.DCOrgY;
dc->w.CursPosX = dcs->w.CursPosX;
dc->w.CursPosY = dcs->w.CursPosY;
- dc->w.WndOrgX = dcs->w.WndOrgX;
- dc->w.WndOrgY = dcs->w.WndOrgY;
- dc->w.WndExtX = dcs->w.WndExtX;
- dc->w.WndExtY = dcs->w.WndExtY;
- dc->w.VportOrgX = dcs->w.VportOrgX;
- dc->w.VportOrgY = dcs->w.VportOrgY;
- dc->w.VportExtX = dcs->w.VportExtX;
- dc->w.VportExtY = dcs->w.VportExtY;
+
+ dc->wndOrgX = dcs->wndOrgX;
+ dc->wndOrgY = dcs->wndOrgY;
+ dc->wndExtX = dcs->wndExtX;
+ dc->wndExtY = dcs->wndExtY;
+ dc->vportOrgX = dcs->vportOrgX;
+ dc->vportOrgY = dcs->vportOrgY;
+ dc->vportExtX = dcs->vportExtX;
+ dc->vportExtY = dcs->vportExtY;
if (!(dc->w.flags & DC_MEMORY)) dc->w.bitsPerPixel = dcs->w.bitsPerPixel;
CombineRgn32( dc->w.hVisRgn, dcs->w.hVisRgn, 0, RGN_COPY );
@@ -456,11 +496,20 @@
/***********************************************************************
- * SaveDC (GDI.30)
+ * SaveDC16 (GDI.30)
*/
-int SaveDC( HDC16 hdc )
+INT16 SaveDC16( HDC16 hdc )
{
- HDC16 hdcs;
+ return (INT16)SaveDC32( hdc );
+}
+
+
+/***********************************************************************
+ * SaveDC32 (GDI32.292)
+ */
+INT32 SaveDC32( HDC32 hdc )
+{
+ HDC32 hdcs;
DC * dc, * dcs;
dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
@@ -481,9 +530,18 @@
/***********************************************************************
- * RestoreDC (GDI.39)
+ * RestoreDC16 (GDI.39)
*/
-BOOL RestoreDC( HDC16 hdc, short level )
+BOOL16 RestoreDC16( HDC16 hdc, INT16 level )
+{
+ return RestoreDC32( hdc, level );
+}
+
+
+/***********************************************************************
+ * RestoreDC32 (GDI32.290)
+ */
+BOOL32 RestoreDC32( HDC32 hdc, INT32 level )
{
DC * dc, * dcs;
@@ -498,15 +556,15 @@
return TRUE;
}
if (level == -1) level = dc->saveLevel;
- if ((level < 1) || (level > (short)dc->saveLevel)) return FALSE;
+ if ((level < 1) || (level > dc->saveLevel)) return FALSE;
- while ((short)dc->saveLevel >= level)
+ while (dc->saveLevel >= level)
{
HDC16 hdcs = dc->header.hNext;
if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC ))) return FALSE;
dc->header.hNext = dcs->header.hNext;
- if ((short)--dc->saveLevel < level) SetDCState( hdc, hdcs );
- DeleteDC( hdcs );
+ if (--dc->saveLevel < level) SetDCState( hdc, hdcs );
+ DeleteDC32( hdcs );
}
return TRUE;
}
@@ -557,24 +615,23 @@
HDC32 CreateDC32W( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
const DEVMODE32W *initData )
{
- LPSTR driverA = driver?STRING32_DupUniToAnsi(driver):NULL;
- LPSTR deviceA = device?STRING32_DupUniToAnsi(device):NULL;
- LPSTR outputA = output?STRING32_DupUniToAnsi(output):NULL;
- HDC32 res;
-
- res = CreateDC16( driverA, deviceA, outputA, (const DEVMODE16 *)initData );
- if (driverA) free(driverA);
- if (deviceA) free(deviceA);
- if (outputA) free(outputA);
+ LPSTR driverA = HEAP_strdupWtoA( GetProcessHeap(), 0, driver );
+ LPSTR deviceA = HEAP_strdupWtoA( GetProcessHeap(), 0, device );
+ LPSTR outputA = HEAP_strdupWtoA( GetProcessHeap(), 0, output );
+ HDC32 res = CreateDC16( driverA, deviceA, outputA,
+ (const DEVMODE16 *)initData /*FIXME*/ );
+ HeapFree( GetProcessHeap(), 0, driverA );
+ HeapFree( GetProcessHeap(), 0, deviceA );
+ HeapFree( GetProcessHeap(), 0, outputA );
return res;
}
/***********************************************************************
- * CreateIC (GDI.153)
+ * CreateIC16 (GDI.153)
*/
-HDC16 CreateIC( LPCSTR driver, LPCSTR device, LPCSTR output,
- const DEVMODE16* initData )
+HDC16 CreateIC16( LPCSTR driver, LPCSTR device, LPCSTR output,
+ const DEVMODE16* initData )
{
/* Nothing special yet for ICs */
return CreateDC16( driver, device, output, initData );
@@ -582,12 +639,43 @@
/***********************************************************************
- * CreateCompatibleDC (GDI.52)
+ * CreateIC32A (GDI32.49)
*/
-HDC16 CreateCompatibleDC( HDC16 hdc )
+HDC32 CreateIC32A( LPCSTR driver, LPCSTR device, LPCSTR output,
+ const DEVMODE32A* initData )
+{
+ /* Nothing special yet for ICs */
+ return CreateDC32A( driver, device, output, initData );
+}
+
+
+/***********************************************************************
+ * CreateIC32W (GDI32.50)
+ */
+HDC32 CreateIC32W( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
+ const DEVMODE32W* initData )
+{
+ /* Nothing special yet for ICs */
+ return CreateDC32W( driver, device, output, initData );
+}
+
+
+/***********************************************************************
+ * CreateCompatibleDC16 (GDI.52)
+ */
+HDC16 CreateCompatibleDC16( HDC16 hdc )
+{
+ return (HDC16)CreateCompatibleDC32( hdc );
+}
+
+
+/***********************************************************************
+ * CreateCompatibleDC32 (GDI32.31)
+ */
+HDC32 CreateCompatibleDC32( HDC32 hdc )
{
DC *dc, *origDC;
- HBITMAP16 hbitmap;
+ HBITMAP32 hbitmap;
const DC_FUNCTIONS *funcs;
if ((origDC = (DC *)GDI_GetObjPtr( hdc, DC_MAGIC ))) funcs = origDC->funcs;
@@ -613,7 +701,7 @@
if (dc->funcs->pCreateDC &&
!dc->funcs->pCreateDC( dc, NULL, NULL, NULL, NULL ))
{
- dprintf_dc( stddeb, "CreateDC: creation aborted by device\n" );
+ dprintf_dc(stddeb, "CreateCompatibleDC: creation aborted by device\n");
DeleteObject32( hbitmap );
GDI_HEAP_FREE( dc->hSelf );
return 0;
@@ -625,9 +713,18 @@
/***********************************************************************
- * DeleteDC (GDI.68)
+ * DeleteDC16 (GDI.68)
*/
-BOOL DeleteDC( HDC16 hdc )
+BOOL16 DeleteDC16( HDC16 hdc )
+{
+ return DeleteDC32( hdc );
+}
+
+
+/***********************************************************************
+ * DeleteDC32 (GDI32.67)
+ */
+BOOL32 DeleteDC32( HDC32 hdc )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return FALSE;
@@ -641,7 +738,7 @@
if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC ))) break;
dc->header.hNext = dcs->header.hNext;
dc->saveLevel--;
- DeleteDC( hdcs );
+ DeleteDC32( hdcs );
}
if (!(dc->w.flags & DC_SAVED))
@@ -662,11 +759,31 @@
/***********************************************************************
- * ResetDC (GDI.376)
+ * ResetDC16 (GDI.376)
*/
-HDC16 ResetDC( HDC16 hdc, /* DEVMODE */ void *devmode )
+HDC16 ResetDC16( HDC16 hdc, const DEVMODE16 *devmode )
{
- fprintf( stderr, "ResetDC: empty stub!\n" );
+ fprintf( stderr, "ResetDC16: empty stub!\n" );
+ return hdc;
+}
+
+
+/***********************************************************************
+ * ResetDC32A (GDI32.287)
+ */
+HDC32 ResetDC32A( HDC32 hdc, const DEVMODE32A *devmode )
+{
+ fprintf( stderr, "ResetDC32A: empty stub!\n" );
+ return hdc;
+}
+
+
+/***********************************************************************
+ * ResetDC32W (GDI32.288)
+ */
+HDC32 ResetDC32W( HDC32 hdc, const DEVMODE32W *devmode )
+{
+ fprintf( stderr, "ResetDC32A: empty stub!\n" );
return hdc;
}
@@ -732,11 +849,20 @@
/***********************************************************************
- * SetTextAlign (GDI.346)
+ * SetTextAlign16 (GDI.346)
*/
-WORD SetTextAlign( HDC16 hdc, WORD textAlign )
+UINT16 SetTextAlign16( HDC16 hdc, UINT16 textAlign )
{
- WORD prevAlign;
+ return SetTextAlign32( hdc, textAlign );
+}
+
+
+/***********************************************************************
+ * SetTextAlign32 (GDI32.336)
+ */
+UINT32 SetTextAlign32( HDC32 hdc, UINT32 textAlign )
+{
+ UINT32 prevAlign;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
{
@@ -753,7 +879,7 @@
/***********************************************************************
* GetDCOrgEx (GDI32.168)
*/
-BOOL32 GetDCOrgEx(HDC32 hDC, LPPOINT32 lpp)
+BOOL32 GetDCOrgEx( HDC32 hDC, LPPOINT32 lpp )
{
DC * dc = (DC *) GDI_GetObjPtr( hDC, DC_MAGIC );
if (!dc || !lpp) return FALSE;
@@ -762,7 +888,7 @@
{
Window root;
int w, h, border, depth;
-
+ /* FIXME: this is not correct for managed windows */
XGetGeometry( display, dc->u.x.drawable, &root,
&lpp->x, &lpp->y, &w, &h, &border, &depth );
}
@@ -787,7 +913,7 @@
/***********************************************************************
* SetDCOrg (GDI.117)
*/
-DWORD SetDCOrg( HDC16 hdc, short x, short y )
+DWORD SetDCOrg( HDC16 hdc, INT16 x, INT16 y )
{
DWORD prevOrg;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
diff --git a/objects/dcvalues.c b/objects/dcvalues.c
index b497558..b90b484 100644
--- a/objects/dcvalues.c
+++ b/objects/dcvalues.c
@@ -5,16 +5,25 @@
*
*/
+#define NO_TRANSITION_TYPES /* This file is Win32-clean */
#include "gdi.h"
#include "metafile.h"
-#define DC_GET_VAL( func_type, func_name, dc_field ) \
+#define DC_GET_VAL_16( func_type, func_name, dc_field ) \
func_type func_name( HDC16 hdc ) \
{ \
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
if (!dc) return 0; \
- return dc->w.dc_field; \
+ return dc->dc_field; \
+}
+
+#define DC_GET_VAL_32( func_type, func_name, dc_field ) \
+func_type func_name( HDC32 hdc ) \
+{ \
+ DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
+ if (!dc) return 0; \
+ return dc->dc_field; \
}
#define DC_GET_X_Y( func_type, func_name, ret_x, ret_y ) \
@@ -22,7 +31,7 @@
{ \
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
if (!dc) return 0; \
- return MAKELONG( dc->w.ret_x, dc->w.ret_y ); \
+ return MAKELONG( dc->ret_x, dc->ret_y ); \
}
#define DC_GET_VAL_EX( func_name, ret_x, ret_y ) \
@@ -30,8 +39,8 @@
{ \
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
if (!dc) return FALSE; \
- pt->x = dc->w.ret_x; \
- pt->y = dc->w.ret_y; \
+ pt->x = dc->ret_x; \
+ pt->y = dc->ret_y; \
return TRUE; \
} \
\
@@ -39,15 +48,15 @@
{ \
DC * dc = (DC *) GDI_GetObjPtr( (HDC16)hdc, DC_MAGIC ); \
if (!dc) return FALSE; \
- pt->x = dc->w.ret_x; \
- pt->y = dc->w.ret_y; \
+ pt->x = dc->ret_x; \
+ pt->y = dc->ret_y; \
return TRUE; \
}
-#define DC_SET_MODE( func_name, dc_field, min_val, max_val, meta_func ) \
-WORD func_name( HDC16 hdc, WORD mode ) \
+#define DC_SET_MODE_16( func_name, dc_field, min_val, max_val, meta_func ) \
+INT16 func_name( HDC16 hdc, INT16 mode ) \
{ \
- WORD prevMode; \
+ INT16 prevMode; \
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
if ((mode < min_val) || (mode > max_val)) return 0; \
if (!dc) { \
@@ -56,47 +65,85 @@
MF_MetaParam1(dc, meta_func, mode); \
return 1; \
} \
- prevMode = dc->w.dc_field; \
- dc->w.dc_field = mode; \
+ prevMode = dc->dc_field; \
+ dc->dc_field = mode; \
+ return prevMode; \
+}
+
+#define DC_SET_MODE_32( func_name, dc_field, min_val, max_val, meta_func ) \
+INT32 func_name( HDC32 hdc, INT32 mode ) \
+{ \
+ INT32 prevMode; \
+ DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
+ if ((mode < min_val) || (mode > max_val)) return 0; \
+ if (!dc) { \
+ dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC); \
+ if (!dc) return 0; \
+ MF_MetaParam1(dc, meta_func, mode); \
+ return 1; \
+ } \
+ prevMode = dc->dc_field; \
+ dc->dc_field = mode; \
return prevMode; \
}
-DC_SET_MODE( SetBkMode, backgroundMode, TRANSPARENT, OPAQUE,
- META_SETBKMODE ) /* GDI.2 */
-DC_SET_MODE( SetROP2, ROPmode, R2_BLACK, R2_WHITE, META_SETROP2 ) /* GDI.4 */
-DC_SET_MODE( SetRelAbs, relAbsMode, ABSOLUTE, RELATIVE,
- META_SETRELABS ) /* GDI.5 */
-DC_SET_MODE( SetPolyFillMode, polyFillMode, ALTERNATE, WINDING,
- META_SETPOLYFILLMODE ) /* GDI.6 */
-DC_SET_MODE( SetStretchBltMode, stretchBltMode,
- BLACKONWHITE, COLORONCOLOR, META_SETSTRETCHBLTMODE ) /* GDI.7 */
-DC_GET_VAL( COLORREF, GetBkColor, backgroundColor ) /* GDI.75 */
-DC_GET_VAL( WORD, GetBkMode, backgroundMode ) /* GDI.76 */
-DC_GET_X_Y( DWORD, GetCurrentPosition, CursPosX, CursPosY ) /* GDI.78 */
-DC_GET_VAL( WORD, GetMapMode, MapMode ) /* GDI.81 */
-DC_GET_VAL( WORD, GetPolyFillMode, polyFillMode ) /* GDI.84 */
-DC_GET_VAL( WORD, GetROP2, ROPmode ) /* GDI.85 */
-DC_GET_VAL( WORD, GetRelAbs, relAbsMode ) /* GDI.86 */
-DC_GET_VAL( WORD, GetStretchBltMode, stretchBltMode ) /* GDI.88 */
-DC_GET_VAL( COLORREF, GetTextColor, textColor ) /* GDI.90 */
-DC_GET_X_Y( DWORD, GetViewportExt, VportExtX, VportExtY ) /* GDI.94 */
-DC_GET_X_Y( DWORD, GetViewportOrg, VportOrgX, VportOrgY ) /* GDI.95 */
-DC_GET_X_Y( DWORD, GetWindowExt, WndExtX, WndExtY ) /* GDI.96 */
-DC_GET_X_Y( DWORD, GetWindowOrg, WndOrgX, WndOrgY ) /* GDI.97 */
-DC_GET_VAL( HRGN32, InquireVisRgn, hVisRgn ) /* GDI.131 */
-DC_GET_X_Y( DWORD, GetBrushOrg, brushOrgX, brushOrgY ) /* GDI.149 */
-DC_GET_VAL( WORD, GetTextAlign, textAlign ) /* GDI.345 */
-DC_GET_VAL( HFONT16, GetCurLogFont, hFont ) /* GDI.411 */
-DC_GET_VAL_EX( GetBrushOrgEx, brushOrgX, brushOrgY ) /* GDI.469 */
-DC_GET_VAL_EX( GetCurrentPositionEx, CursPosX, CursPosY ) /* GDI.470 */
-DC_GET_VAL_EX( GetViewportExtEx, VportExtX, VportExtY ) /* GDI.472 */
-DC_GET_VAL_EX( GetViewportOrgEx, VportOrgX, VportOrgY ) /* GDI.473 */
-DC_GET_VAL_EX( GetWindowExtEx, WndExtX, WndExtY ) /* GDI.474 */
-DC_GET_VAL_EX( GetWindowOrgEx, WndOrgX, WndOrgY ) /* GDI.475 */
+DC_SET_MODE_16( SetBkMode16, w.backgroundMode, TRANSPARENT, /* GDI.2 */
+ OPAQUE, META_SETBKMODE )
+DC_SET_MODE_32( SetBkMode32, w.backgroundMode, TRANSPARENT, /* GDI32.306 */
+ OPAQUE, META_SETBKMODE )
+DC_SET_MODE_16( SetROP216, w.ROPmode, R2_BLACK, R2_WHITE, /* GDI.4 */
+ META_SETROP2 )
+DC_SET_MODE_32( SetROP232, w.ROPmode, R2_BLACK, R2_WHITE, /* GDI32.331 */
+ META_SETROP2 )
+DC_SET_MODE_16( SetRelAbs16, w.relAbsMode, ABSOLUTE, RELATIVE, /* GDI.5 */
+ META_SETRELABS )
+DC_SET_MODE_32( SetRelAbs32, w.relAbsMode, ABSOLUTE, RELATIVE, /* GDI32.333 */
+ META_SETRELABS )
+DC_SET_MODE_16( SetPolyFillMode16, w.polyFillMode, /* GDI.6 */
+ ALTERNATE, WINDING, META_SETPOLYFILLMODE )
+DC_SET_MODE_32( SetPolyFillMode32, w.polyFillMode, /* GDI32.330 */
+ ALTERNATE, WINDING, META_SETPOLYFILLMODE )
+DC_SET_MODE_16( SetStretchBltMode16, w.stretchBltMode, /* GDI.7 */
+ BLACKONWHITE, COLORONCOLOR, META_SETSTRETCHBLTMODE )
+DC_SET_MODE_32( SetStretchBltMode32, w.stretchBltMode, /* GDI32.334 */
+ BLACKONWHITE, COLORONCOLOR, META_SETSTRETCHBLTMODE )
+DC_GET_VAL_16( COLORREF, GetBkColor16, w.backgroundColor ) /* GDI.75 */
+DC_GET_VAL_32( COLORREF, GetBkColor32, w.backgroundColor ) /* GDI32.145 */
+DC_GET_VAL_16( INT16, GetBkMode16, w.backgroundMode ) /* GDI.76 */
+DC_GET_VAL_32( INT32, GetBkMode32, w.backgroundMode ) /* GDI32.146 */
+DC_GET_X_Y( DWORD, GetCurrentPosition, w.CursPosX, w.CursPosY ) /* GDI.78 */
+DC_GET_VAL_16( INT16, GetMapMode16, w.MapMode ) /* GDI.81 */
+DC_GET_VAL_32( INT32, GetMapMode32, w.MapMode ) /* GDI32.196 */
+DC_GET_VAL_16( INT16, GetPolyFillMode16, w.polyFillMode ) /* GDI.84 */
+DC_GET_VAL_32( INT32, GetPolyFillMode32, w.polyFillMode ) /* GDI32.213 */
+DC_GET_VAL_16( INT16, GetROP216, w.ROPmode ) /* GDI.85 */
+DC_GET_VAL_32( INT32, GetROP232, w.ROPmode ) /* GDI32.214 */
+DC_GET_VAL_16( INT16, GetRelAbs16, w.relAbsMode ) /* GDI.86 */
+DC_GET_VAL_32( INT32, GetRelAbs32, w.relAbsMode ) /* GDI32.218 */
+DC_GET_VAL_16( INT16, GetStretchBltMode16, w.stretchBltMode ) /* GDI.88 */
+DC_GET_VAL_32( INT32, GetStretchBltMode32, w.stretchBltMode ) /* GDI32.221 */
+DC_GET_VAL_16( COLORREF, GetTextColor16, w.textColor ) /* GDI.90 */
+DC_GET_VAL_32( COLORREF, GetTextColor32, w.textColor ) /* GDI32.227 */
+DC_GET_X_Y( DWORD, GetViewportExt, vportExtX, vportExtY ) /* GDI.94 */
+DC_GET_X_Y( DWORD, GetViewportOrg, vportOrgX, vportOrgY ) /* GDI.95 */
+DC_GET_X_Y( DWORD, GetWindowExt, wndExtX, wndExtY ) /* GDI.96 */
+DC_GET_X_Y( DWORD, GetWindowOrg, wndOrgX, wndOrgY ) /* GDI.97 */
+DC_GET_VAL_16( HRGN16, InquireVisRgn, w.hVisRgn ) /* GDI.131 */
+DC_GET_X_Y( DWORD, GetBrushOrg, w.brushOrgX, w.brushOrgY ) /* GDI.149 */
+DC_GET_VAL_16( UINT16, GetTextAlign16, w.textAlign ) /* GDI.345 */
+DC_GET_VAL_32( UINT32, GetTextAlign32, w.textAlign ) /* GDI32.224 */
+DC_GET_VAL_16( HFONT16, GetCurLogFont, w.hFont ) /* GDI.411 */
+DC_GET_VAL_EX( GetBrushOrgEx, w.brushOrgX, w.brushOrgY )/* GDI.469 GDI32.148 */
+DC_GET_VAL_EX( GetCurrentPositionEx, w.CursPosX, /* GDI.470 GDI32.167 */
+ w.CursPosY )
+DC_GET_VAL_EX( GetViewportExtEx, vportExtX, vportExtY ) /* GDI.472 GDI32.239 */
+DC_GET_VAL_EX( GetViewportOrgEx, vportOrgX, vportOrgY ) /* GDI.473 GDI32.240 */
+DC_GET_VAL_EX( GetWindowExtEx, wndExtX, wndExtY ) /* GDI.474 GDI32.242 */
+DC_GET_VAL_EX( GetWindowOrgEx, wndOrgX, wndOrgY ) /* GDI.475 GDI32.243 */
/* this one is wrong - Windows returns region that
is relative to the device and not to the DC origin */
-DC_GET_VAL( HRGN16, GetClipRgn16, hClipRgn ) /* GDI.173 */
+DC_GET_VAL_16( HRGN16, GetClipRgn16, w.hClipRgn ) /* GDI.173 */
diff --git a/objects/dib.c b/objects/dib.c
index 7f37367..66f8d8f 100644
--- a/objects/dib.c
+++ b/objects/dib.c
@@ -4,6 +4,7 @@
* Copyright 1993,1994 Alexandre Julliard
*/
+#define NO_TRANSITION_TYPES /* This file is Win32-clean */
#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>
@@ -134,7 +135,7 @@
BITMAPINFO *info )
{
int i, colors;
- BOOL isInfo;
+ BOOL32 isInfo;
WORD *colorPtr;
int *colorMapping;
@@ -196,10 +197,10 @@
*
* SetDIBits for a 1-bit deep DIB.
*/
-static void DIB_SetImageBits_1( WORD lines, BYTE *bits, WORD width,
+static void DIB_SetImageBits_1( DWORD lines, BYTE *bits, DWORD width,
int *colors, XImage *bmpImage )
{
- WORD i, x;
+ DWORD i, x;
BYTE pad, pix;
if (!(width & 31)) pad = 0;
@@ -240,10 +241,10 @@
*
* SetDIBits for a 4-bit deep DIB.
*/
-static void DIB_SetImageBits_4( WORD lines, BYTE *bits, WORD width,
+static void DIB_SetImageBits_4( DWORD lines, BYTE *bits, DWORD width,
int *colors, XImage *bmpImage )
{
- WORD i, x;
+ DWORD i, x;
BYTE pad;
if (!(width & 7)) pad = 0;
@@ -274,14 +275,14 @@
*
* SetDIBits for a 4-bit deep compressed DIB.
*/
-static void DIB_SetImageBits_RLE4( WORD lines, BYTE *bits, WORD width,
+static void DIB_SetImageBits_RLE4( DWORD lines, BYTE *bits, DWORD width,
int *colors, XImage *bmpImage )
{
int x = 0, c, length;
BYTE *begin = bits;
lines--;
- while ((short)lines >= 0)
+ while ((int)lines >= 0)
{
length = *bits++;
if (length) { /* encoded */
@@ -334,10 +335,10 @@
*
* SetDIBits for an 8-bit deep DIB.
*/
-static void DIB_SetImageBits_8( WORD lines, BYTE *bits, WORD width,
+static void DIB_SetImageBits_8( DWORD lines, BYTE *bits, DWORD width,
int *colors, XImage *bmpImage )
{
- WORD x;
+ DWORD x;
BYTE pad = (4 - (width & 3)) & 3;
while (lines--)
@@ -379,11 +380,8 @@
RleDelta = 2 /* Delta */
};
-static void DIB_SetImageBits_RLE8(WORD lines,
- BYTE *bits,
- WORD width,
- int *colors,
- XImage *bmpImage)
+static void DIB_SetImageBits_RLE8( DWORD lines, BYTE *bits, DWORD width,
+ int *colors, XImage *bmpImage )
{
int x; /* X-positon on each line. Increases. */
int line; /* Line #. Starts at lines-1, decreases */
@@ -535,10 +533,10 @@
*
* SetDIBits for a 24-bit deep DIB.
*/
-static void DIB_SetImageBits_24( WORD lines, BYTE *bits, WORD width,
+static void DIB_SetImageBits_24( DWORD lines, BYTE *bits, DWORD width,
DC *dc, XImage *bmpImage )
{
- WORD x;
+ DWORD x;
BYTE pad = (4 - ((width*3) & 3)) & 3;
/* "bits" order is reversed for some reason */
@@ -560,7 +558,7 @@
* Transfer the bits to an X image.
* Helper function for SetDIBits() and SetDIBitsToDevice().
*/
-static int DIB_SetImageBits( DC *dc, WORD lines, WORD depth, LPSTR bits,
+static int DIB_SetImageBits( DC *dc, DWORD lines, WORD depth, LPSTR bits,
DWORD infoWidth, WORD infoBpp,
BITMAPINFO *info, WORD coloruse,
Drawable drawable, GC gc, int xSrc, int ySrc,
@@ -643,24 +641,36 @@
HBITMAP32 hBitmap, hOldBitmap;
HDC32 hdcMem;
- hBitmap = CreateDIBitmap( hdc, &info->bmiHeader, CBM_INIT,
- bits, info, wUsage );
- hdcMem = CreateCompatibleDC( hdc );
+ hBitmap = CreateDIBitmap32( hdc, &info->bmiHeader, CBM_INIT,
+ bits, info, wUsage );
+ hdcMem = CreateCompatibleDC32( hdc );
hOldBitmap = SelectObject32( hdcMem, hBitmap );
StretchBlt32( hdc, xDst, yDst, widthDst, heightDst,
hdcMem, xSrc, ySrc, widthSrc, heightSrc, dwRop );
SelectObject32( hdcMem, hOldBitmap );
- DeleteDC( hdcMem );
+ DeleteDC32( hdcMem );
DeleteObject32( hBitmap );
return heightSrc;
}
/***********************************************************************
- * SetDIBits (GDI.440) (GDI32.312)
+ * SetDIBits16 (GDI.440)
*/
-INT16 SetDIBits( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan, UINT32 lines,
- LPCVOID bits, const BITMAPINFO *info, UINT32 coloruse )
+INT16 SetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan,
+ UINT16 lines, LPCVOID bits, const BITMAPINFO *info,
+ UINT16 coloruse )
+{
+ return SetDIBits32( hdc, hbitmap, startscan, lines, bits, info, coloruse );
+}
+
+
+/***********************************************************************
+ * SetDIBits32 (GDI32.312)
+ */
+INT32 SetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan,
+ UINT32 lines, LPCVOID bits, const BITMAPINFO *info,
+ UINT32 coloruse )
{
DC * dc;
BITMAPOBJ * bmp;
@@ -692,12 +702,25 @@
/***********************************************************************
- * SetDIBitsToDevice (GDI.443) (GDI32.313)
+ * SetDIBitsToDevice16 (GDI.443)
*/
-INT16 SetDIBitsToDevice( HDC32 hdc, INT32 xDest, INT32 yDest, DWORD cx,
- DWORD cy, INT32 xSrc, INT32 ySrc, UINT32 startscan,
- UINT32 lines, LPCVOID bits, const BITMAPINFO *info,
- UINT32 coloruse )
+INT16 SetDIBitsToDevice16( HDC16 hdc, INT16 xDest, INT16 yDest, INT16 cx,
+ INT16 cy, INT16 xSrc, INT16 ySrc, UINT16 startscan,
+ UINT16 lines, LPCVOID bits, const BITMAPINFO *info,
+ UINT16 coloruse )
+{
+ return SetDIBitsToDevice32( hdc, xDest, yDest, cx, cy, xSrc, ySrc,
+ startscan, lines, bits, info, coloruse );
+}
+
+
+/***********************************************************************
+ * SetDIBitsToDevice32 (GDI32.313)
+ */
+INT32 SetDIBitsToDevice32( HDC32 hdc, INT32 xDest, INT32 yDest, DWORD cx,
+ DWORD cy, INT32 xSrc, INT32 ySrc, UINT32 startscan,
+ UINT32 lines, LPCVOID bits, const BITMAPINFO *info,
+ UINT32 coloruse )
{
DC * dc;
DWORD width, height;
@@ -737,10 +760,22 @@
/***********************************************************************
- * GetDIBits (GDI.441)
+ * GetDIBits16 (GDI.441)
*/
-int GetDIBits( HDC16 hdc, HBITMAP16 hbitmap, WORD startscan, WORD lines,
- LPSTR bits, BITMAPINFO * info, WORD coloruse )
+INT16 GetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan,
+ UINT16 lines, LPSTR bits, BITMAPINFO * info,
+ UINT16 coloruse )
+{
+ return GetDIBits32( hdc, hbitmap, startscan, lines, bits, info, coloruse );
+}
+
+
+/***********************************************************************
+ * GetDIBits32 (GDI32.170)
+ */
+INT32 GetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan,
+ UINT32 lines, LPSTR bits, BITMAPINFO * info,
+ UINT32 coloruse )
{
DC * dc;
BITMAPOBJ * bmp;
@@ -805,13 +840,25 @@
/***********************************************************************
- * CreateDIBitmap (GDI.442)
+ * CreateDIBitmap16 (GDI.442)
*/
-HBITMAP16 CreateDIBitmap( HDC16 hdc, BITMAPINFOHEADER * header, DWORD init,
- LPVOID bits, BITMAPINFO * data, UINT coloruse )
+HBITMAP16 CreateDIBitmap16( HDC16 hdc, const BITMAPINFOHEADER * header,
+ DWORD init, LPCVOID bits, const BITMAPINFO * data,
+ UINT16 coloruse )
{
- HBITMAP16 handle;
- BOOL fColor;
+ return CreateDIBitmap32( hdc, header, init, bits, data, coloruse );
+}
+
+
+/***********************************************************************
+ * CreateDIBitmap32 (GDI32.37)
+ */
+HBITMAP32 CreateDIBitmap32( HDC32 hdc, const BITMAPINFOHEADER *header,
+ DWORD init, LPCVOID bits, const BITMAPINFO *data,
+ UINT32 coloruse )
+{
+ HBITMAP32 handle;
+ BOOL32 fColor;
DWORD width, height;
WORD bpp;
@@ -866,6 +913,6 @@
if (!handle) return 0;
if (init == CBM_INIT)
- SetDIBits( hdc, handle, 0, height, bits, data, coloruse );
+ SetDIBits32( hdc, handle, 0, height, bits, data, coloruse );
return handle;
}
diff --git a/objects/font.c b/objects/font.c
index 40f12a2..cc54c0b 100644
--- a/objects/font.c
+++ b/objects/font.c
@@ -14,9 +14,9 @@
#include <string.h>
#include <X11/Xatom.h>
#include "font.h"
+#include "heap.h"
#include "metafile.h"
#include "options.h"
-#include "string32.h"
#include "xmalloc.h"
#include "stddebug.h"
#include "debug.h"
@@ -133,7 +133,7 @@
int i;
for (i = 1; i < FontSize; i ++)
- if( !strcmp( winFaceName, FontNames[i].window ) ) {
+ if( !lstrcmpi32A( winFaceName, FontNames[i].window ) ) {
dprintf_font(stddeb, "---- Mapped %s to %s\n", winFaceName, FontNames[i].x11 );
return FontNames[i].x11;
}
@@ -163,7 +163,7 @@
if (font->lfHeight == -1)
height = 0;
else
- height = font->lfHeight * dc->w.VportExtX / dc->w.WndExtX;
+ height = font->lfHeight * dc->vportExtX / dc->wndExtX;
if (height == 0) height = 120; /* Default height = 12 */
else if (height < 0)
{
@@ -180,7 +180,7 @@
height = (height-2) * -10;
}
else height *= 10;
- width = 10 * (font->lfWidth * dc->w.VportExtY / dc->w.WndExtY);
+ width = 10 * (font->lfWidth * dc->vportExtY / dc->wndExtY);
if (width < 0) {
dprintf_font( stddeb, "FONT_MatchFont: negative width %d(%d)\n",
width, font->lfWidth );
@@ -279,8 +279,8 @@
dprintf_font(stddeb," Found '%s'\n", *names );
if (!*font->lfFaceName)
ParseFontParms(*names, 2, font->lfFaceName , LF_FACESIZE-1);
- /* we need a font name for function GetTextFace() even if there isn't one ;-) */
- AnsiUpper(font->lfFaceName);
+ /* we need a font name for function GetTextFace() even if there isn't one ;-) */
+ /*AnsiUpper(font->lfFaceName);*/
fontStruct = XLoadQueryFont( display, *names );
XFreeFontNames( names );
@@ -289,6 +289,98 @@
/***********************************************************************
+ * FONT_LOGFONT32AToLOGFONT16
+ */
+static void FONT_LOGFONT32AToLOGFONT16( const LOGFONT32A *font,
+ LPLOGFONT16 font16 )
+{
+ font16->lfHeight = (INT16)font->lfHeight;
+ font16->lfWidth = (INT16)font->lfWidth;
+ font16->lfEscapement = (INT16)font->lfEscapement;
+ font16->lfOrientation = (INT16)font->lfOrientation;
+ font16->lfWeight = (INT16)font->lfWeight;
+ font16->lfItalic = font->lfItalic;
+ font16->lfUnderline = font->lfUnderline;
+ font16->lfStrikeOut = font->lfStrikeOut;
+ font16->lfCharSet = font->lfCharSet;
+ font16->lfOutPrecision = font->lfOutPrecision;
+ font16->lfClipPrecision = font->lfClipPrecision;
+ font16->lfQuality = font->lfQuality;
+ font16->lfPitchAndFamily = font->lfPitchAndFamily;
+ lstrcpyn32A( font16->lfFaceName, font->lfFaceName, LF_FACESIZE );
+}
+
+
+/***********************************************************************
+ * FONT_LOGFONT32WToLOGFONT16
+ */
+static void FONT_LOGFONT32WToLOGFONT16( const LOGFONT32W *font,
+ LPLOGFONT16 font16 )
+{
+ font16->lfHeight = (INT16)font->lfHeight;
+ font16->lfWidth = (INT16)font->lfWidth;
+ font16->lfEscapement = (INT16)font->lfEscapement;
+ font16->lfOrientation = (INT16)font->lfOrientation;
+ font16->lfWeight = (INT16)font->lfWeight;
+ font16->lfItalic = font->lfItalic;
+ font16->lfUnderline = font->lfUnderline;
+ font16->lfStrikeOut = font->lfStrikeOut;
+ font16->lfCharSet = font->lfCharSet;
+ font16->lfOutPrecision = font->lfOutPrecision;
+ font16->lfClipPrecision = font->lfClipPrecision;
+ font16->lfQuality = font->lfQuality;
+ font16->lfPitchAndFamily = font->lfPitchAndFamily;
+ lstrcpynWtoA( font16->lfFaceName, font->lfFaceName, LF_FACESIZE );
+}
+
+
+/***********************************************************************
+ * FONT_LOGFONT16ToLOGFONT32A
+ */
+static void FONT_LOGFONT16ToLOGFONT32A( LPLOGFONT16 font,
+ LPLOGFONT32A font32A )
+{
+ font32A->lfHeight = (INT32)font->lfHeight;
+ font32A->lfWidth = (INT32)font->lfWidth;
+ font32A->lfEscapement = (INT32)font->lfEscapement;
+ font32A->lfOrientation = (INT32)font->lfOrientation;
+ font32A->lfWeight = (INT32)font->lfWeight;
+ font32A->lfItalic = font->lfItalic;
+ font32A->lfUnderline = font->lfUnderline;
+ font32A->lfStrikeOut = font->lfStrikeOut;
+ font32A->lfCharSet = font->lfCharSet;
+ font32A->lfOutPrecision = font->lfOutPrecision;
+ font32A->lfClipPrecision = font->lfClipPrecision;
+ font32A->lfQuality = font->lfQuality;
+ font32A->lfPitchAndFamily = font->lfPitchAndFamily;
+ lstrcpyn32A( font32A->lfFaceName, font->lfFaceName, LF_FACESIZE );
+}
+
+
+/***********************************************************************
+ * FONT_LOGFONT16ToLOGFONT32W
+ */
+static void FONT_LOGFONT16ToLOGFONT32W( LPLOGFONT16 font,
+ LPLOGFONT32W font32W )
+{
+ font32W->lfHeight = (INT32)font->lfHeight;
+ font32W->lfWidth = (INT32)font->lfWidth;
+ font32W->lfEscapement = (INT32)font->lfEscapement;
+ font32W->lfOrientation = (INT32)font->lfOrientation;
+ font32W->lfWeight = (INT32)font->lfWeight;
+ font32W->lfItalic = font->lfItalic;
+ font32W->lfUnderline = font->lfUnderline;
+ font32W->lfStrikeOut = font->lfStrikeOut;
+ font32W->lfCharSet = font->lfCharSet;
+ font32W->lfOutPrecision = font->lfOutPrecision;
+ font32W->lfClipPrecision = font->lfClipPrecision;
+ font32W->lfQuality = font->lfQuality;
+ font32W->lfPitchAndFamily = font->lfPitchAndFamily;
+ lstrcpynAtoW( font32W->lfFaceName, font->lfFaceName, LF_FACESIZE );
+}
+
+
+/***********************************************************************
* FONT_GetMetrics
*/
void FONT_GetMetrics( LOGFONT16 * logfont, XFontStruct * xfont,
@@ -356,78 +448,6 @@
return (DWORD)-1; /* failure */
}
-void
-FONT_LOGFONT32AToLOGFONT16(const LOGFONT32A *font,LPLOGFONT16 font16) {
- font16->lfHeight = (INT16)font->lfHeight;
- font16->lfWidth = (INT16)font->lfWidth;
- font16->lfEscapement = (INT16)font->lfEscapement;
- font16->lfOrientation = (INT16)font->lfOrientation;
- font16->lfWeight = (INT16)font->lfWeight;
- font16->lfItalic = font->lfItalic;
- font16->lfUnderline = font->lfUnderline;
- font16->lfStrikeOut = font->lfStrikeOut;
- font16->lfCharSet = font->lfCharSet;
- font16->lfOutPrecision = font->lfOutPrecision;
- font16->lfClipPrecision = font->lfClipPrecision;
- font16->lfQuality = font->lfQuality;
- font16->lfPitchAndFamily = font->lfPitchAndFamily;
- lstrcpyn32A( font16->lfFaceName, font->lfFaceName, LF_FACESIZE );
-}
-
-void
-FONT_LOGFONT32WToLOGFONT16(const LOGFONT32W *font,LPLOGFONT16 font16) {
- font16->lfHeight = (INT16)font->lfHeight;
- font16->lfWidth = (INT16)font->lfWidth;
- font16->lfEscapement = (INT16)font->lfEscapement;
- font16->lfOrientation = (INT16)font->lfOrientation;
- font16->lfWeight = (INT16)font->lfWeight;
- font16->lfItalic = font->lfItalic;
- font16->lfUnderline = font->lfUnderline;
- font16->lfStrikeOut = font->lfStrikeOut;
- font16->lfCharSet = font->lfCharSet;
- font16->lfOutPrecision = font->lfOutPrecision;
- font16->lfClipPrecision = font->lfClipPrecision;
- font16->lfQuality = font->lfQuality;
- font16->lfPitchAndFamily = font->lfPitchAndFamily;
- lstrcpynWtoA( font16->lfFaceName, font->lfFaceName, LF_FACESIZE );
-}
-
-void
-FONT_LOGFONT16ToLOGFONT32A(LPLOGFONT16 font,LPLOGFONT32A font32A) {
- font32A->lfHeight = (INT32)font->lfHeight;
- font32A->lfWidth = (INT32)font->lfWidth;
- font32A->lfEscapement = (INT32)font->lfEscapement;
- font32A->lfOrientation = (INT32)font->lfOrientation;
- font32A->lfWeight = (INT32)font->lfWeight;
- font32A->lfItalic = font->lfItalic;
- font32A->lfUnderline = font->lfUnderline;
- font32A->lfStrikeOut = font->lfStrikeOut;
- font32A->lfCharSet = font->lfCharSet;
- font32A->lfOutPrecision = font->lfOutPrecision;
- font32A->lfClipPrecision = font->lfClipPrecision;
- font32A->lfQuality = font->lfQuality;
- font32A->lfPitchAndFamily = font->lfPitchAndFamily;
- lstrcpyn32A( font32A->lfFaceName, font->lfFaceName, LF_FACESIZE );
-}
-
-void
-FONT_LOGFONT16ToLOGFONT32W(LPLOGFONT16 font,LPLOGFONT32W font32W) {
- font32W->lfHeight = (INT32)font->lfHeight;
- font32W->lfWidth = (INT32)font->lfWidth;
- font32W->lfEscapement = (INT32)font->lfEscapement;
- font32W->lfOrientation = (INT32)font->lfOrientation;
- font32W->lfWeight = (INT32)font->lfWeight;
- font32W->lfItalic = font->lfItalic;
- font32W->lfUnderline = font->lfUnderline;
- font32W->lfStrikeOut = font->lfStrikeOut;
- font32W->lfCharSet = font->lfCharSet;
- font32W->lfOutPrecision = font->lfOutPrecision;
- font32W->lfClipPrecision = font->lfClipPrecision;
- font32W->lfQuality = font->lfQuality;
- font32W->lfPitchAndFamily = font->lfPitchAndFamily;
- lstrcpynAtoW( font32W->lfFaceName, font->lfFaceName, LF_FACESIZE );
-}
-
/***********************************************************************
* CreateScalableFontResource (GDI.310)
@@ -535,12 +555,12 @@
DWORD clippres, DWORD quality, DWORD pitch,
LPCWSTR name )
{
- LPSTR namea = name ? STRING32_DupUniToAnsi(name) : NULL;
+ LPSTR namea = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
HFONT32 ret = (HFONT32)CreateFont16( height, width, esc, orient, weight,
italic, underline, strikeout, charset,
outpres, clippres, quality, pitch,
namea );
- free(namea);
+ HeapFree( GetProcessHeap(), 0, namea );
return ret;
}
@@ -748,41 +768,71 @@
/***********************************************************************
- * GetTextCharacterExtra (GDI.89)
+ * GetTextCharacterExtra16 (GDI.89)
*/
-short GetTextCharacterExtra( HDC16 hdc )
+INT16 GetTextCharacterExtra16( HDC16 hdc )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
- return abs( (dc->w.charExtra * dc->w.WndExtX + dc->w.VportExtX / 2)
- / dc->w.VportExtX );
+ return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
+ / dc->vportExtX );
}
/***********************************************************************
- * SetTextCharacterExtra (GDI.8)
+ * GetTextCharacterExtra32 (GDI32.225)
*/
-short SetTextCharacterExtra( HDC16 hdc, short extra )
+INT32 GetTextCharacterExtra32( HDC32 hdc )
{
- short prev;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
- extra = (extra * dc->w.VportExtX + dc->w.WndExtX / 2) / dc->w.WndExtX;
+ return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
+ / dc->vportExtX );
+}
+
+
+/***********************************************************************
+ * SetTextCharacterExtra16 (GDI.8)
+ */
+INT16 SetTextCharacterExtra16( HDC16 hdc, INT16 extra )
+{
+ return (INT16)SetTextCharacterExtra32( hdc, extra );
+}
+
+
+/***********************************************************************
+ * SetTextCharacterExtra32 (GDI32.337)
+ */
+INT32 SetTextCharacterExtra32( HDC32 hdc, INT32 extra )
+{
+ INT32 prev;
+ DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+ if (!dc) return 0;
+ extra = (extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX;
prev = dc->w.charExtra;
dc->w.charExtra = abs(extra);
- return (prev * dc->w.WndExtX + dc->w.VportExtX / 2) / dc->w.VportExtX;
+ return (prev * dc->wndExtX + dc->vportExtX / 2) / dc->vportExtX;
}
/***********************************************************************
- * SetTextJustification (GDI.10)
+ * SetTextJustification16 (GDI.10)
*/
-short SetTextJustification( HDC16 hdc, short extra, short breaks )
+INT16 SetTextJustification16( HDC16 hdc, INT16 extra, INT16 breaks )
+{
+ return SetTextJustification32( hdc, extra, breaks );
+}
+
+
+/***********************************************************************
+ * SetTextJustification32 (GDI32.339)
+ */
+BOOL32 SetTextJustification32( HDC32 hdc, INT32 extra, INT32 breaks )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
- extra = abs((extra * dc->w.VportExtX + dc->w.WndExtX / 2) / dc->w.WndExtX);
+ extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
if (!extra) breaks = 0;
dc->w.breakTotalExtra = extra;
dc->w.breakCount = breaks;
@@ -799,6 +849,7 @@
return 1;
}
+
/***********************************************************************
* GetTextFace16 (GDI.92)
*/
@@ -827,11 +878,10 @@
*/
INT32 GetTextFace32W( HDC32 hdc, INT32 count, LPWSTR name )
{
- LPSTR nameA = (LPSTR)xmalloc(count);
+ LPSTR nameA = HeapAlloc( GetProcessHeap(), 0, count );
INT32 res = GetTextFace32A(hdc,count,nameA);
-
- lstrcpynAtoW(name,nameA,count);
- free(nameA);
+ lstrcpyAtoW( name, nameA );
+ HeapFree( GetProcessHeap(), 0, nameA );
return res;
}
@@ -839,7 +889,7 @@
/***********************************************************************
* GetTextExtent (GDI.91)
*/
-DWORD GetTextExtent( HDC16 hdc, LPCSTR str, short count )
+DWORD GetTextExtent( HDC16 hdc, LPCSTR str, INT16 count )
{
SIZE16 size;
if (!GetTextExtentPoint16( hdc, str, count, &size )) return 0;
@@ -892,9 +942,9 @@
BOOL32 GetTextExtentPoint32W( HDC32 hdc, LPCWSTR str, INT32 count,
LPSIZE32 size )
{
- char *p = STRING32_DupUniToAnsi( str );
+ LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
BOOL32 ret = GetTextExtentPoint32A( hdc, p, count, size );
- free( p );
+ HeapFree( GetProcessHeap(), 0, p );
return ret;
}
@@ -967,10 +1017,10 @@
INT32 maxExt, LPINT32 lpnFit, LPINT32 alpDx,
LPSIZE32 size )
{
- char *p = STRING32_DupUniToAnsi( str );
+ LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
BOOL32 ret = GetTextExtentExPoint32A( hdc, p, count, maxExt,
lpnFit, alpDx, size);
- free( p );
+ HeapFree( GetProcessHeap(), 0, p );
return ret;
}
@@ -984,18 +1034,18 @@
memcpy( metrics, &dc->u.x.font.metrics, sizeof(*metrics) );
metrics->tmAscent = abs( metrics->tmAscent
- * dc->w.WndExtY / dc->w.VportExtY );
+ * dc->wndExtY / dc->vportExtY );
metrics->tmDescent = abs( metrics->tmDescent
- * dc->w.WndExtY / dc->w.VportExtY );
+ * dc->wndExtY / dc->vportExtY );
metrics->tmHeight = metrics->tmAscent + metrics->tmDescent;
metrics->tmInternalLeading = abs( metrics->tmInternalLeading
- * dc->w.WndExtY / dc->w.VportExtY );
+ * dc->wndExtY / dc->vportExtY );
metrics->tmExternalLeading = abs( metrics->tmExternalLeading
- * dc->w.WndExtY / dc->w.VportExtY );
+ * dc->wndExtY / dc->vportExtY );
metrics->tmMaxCharWidth = abs( metrics->tmMaxCharWidth
- * dc->w.WndExtX / dc->w.VportExtX );
+ * dc->wndExtX / dc->vportExtX );
metrics->tmAveCharWidth = abs( metrics->tmAveCharWidth
- * dc->w.WndExtX / dc->w.VportExtX );
+ * dc->wndExtX / dc->vportExtX );
dprintf_font(stdnimp,"text metrics:\n
InternalLeading = %i
@@ -1117,26 +1167,50 @@
/***********************************************************************
- * GetCharABCWidths (GDI.307)
+ * GetCharABCWidths16 (GDI.307)
*/
-BOOL GetCharABCWidths(HDC16 hdc, UINT wFirstChar, UINT wLastChar, LPABC16 lpABC)
+BOOL16 GetCharABCWidths16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
+ LPABC16 abc )
{
+ ABC32 abc32;
+ if (!GetCharABCWidths32A( hdc, firstChar, lastChar, &abc32 )) return FALSE;
+ abc->abcA = abc32.abcA;
+ abc->abcB = abc32.abcB;
+ abc->abcC = abc32.abcC;
+ return TRUE;
+}
+
+/***********************************************************************
+ * GetCharABCWidths32A (GDI32.149)
+ */
+BOOL32 GetCharABCWidths32A( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
+ LPABC32 abc )
+{
/* No TrueType fonts in Wine so far */
-
- fprintf(stdnimp,"STUB: GetCharABCWidths(%04x,%04x,%04x,%08x)\n",
- hdc,wFirstChar,wLastChar,(unsigned)lpABC);
-
+ fprintf( stdnimp, "STUB: GetCharABCWidths(%04x,%04x,%04x,%p)\n",
+ hdc, firstChar, lastChar, abc );
return FALSE;
}
/***********************************************************************
- * GetCharWidth (GDI.350)
+ * GetCharABCWidths32W (GDI32.152)
*/
-BOOL GetCharWidth(HDC16 hdc, WORD wFirstChar, WORD wLastChar, LPINT16 lpBuffer)
+BOOL32 GetCharABCWidths32W( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
+ LPABC32 abc )
{
- int i, j;
+ return GetCharABCWidths32A( hdc, firstChar, lastChar, abc );
+}
+
+
+/***********************************************************************
+ * GetCharWidth16 (GDI.350)
+ */
+BOOL16 GetCharWidth16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
+ LPINT16 buffer )
+{
+ int i, width;
XFontStruct *xfont;
XCharStruct *cs, *def;
@@ -1147,25 +1221,68 @@
/* fixed font? */
if (xfont->per_char == NULL)
{
- for (i = wFirstChar, j = 0; i <= wLastChar; i++, j++)
- *(lpBuffer + j) = xfont->max_bounds.width;
+ for (i = firstChar; i <= lastChar; i++)
+ *buffer++ = xfont->max_bounds.width;
return TRUE;
}
CI_GET_DEFAULT_INFO(xfont, def);
- for (i = wFirstChar, j = 0; i <= wLastChar; i++, j++)
+ for (i = firstChar; i <= lastChar; i++)
{
- CI_GET_CHAR_INFO(xfont, i, def, cs);
- *(lpBuffer + j) = cs ? cs->width : xfont->max_bounds.width;
- if (*(lpBuffer + j) < 0)
- *(lpBuffer + j) = 0;
+ CI_GET_CHAR_INFO( xfont, i, def, cs );
+ width = cs ? cs->width : xfont->max_bounds.width;
+ *buffer++ = MAX( width, 0 );
}
return TRUE;
}
/***********************************************************************
+ * GetCharWidth32A (GDI32.155)
+ */
+BOOL32 GetCharWidth32A( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
+ LPINT32 buffer )
+{
+ int i, width;
+ XFontStruct *xfont;
+ XCharStruct *cs, *def;
+
+ DC *dc = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
+ if (!dc) return FALSE;
+ xfont = dc->u.x.font.fstruct;
+
+ /* fixed font? */
+ if (xfont->per_char == NULL)
+ {
+ for (i = firstChar; i <= lastChar; i++)
+ *buffer++ = xfont->max_bounds.width;
+ return TRUE;
+ }
+
+ CI_GET_DEFAULT_INFO(xfont, def);
+
+ for (i = firstChar; i <= lastChar; i++)
+ {
+ CI_GET_CHAR_INFO( xfont, i, def, cs );
+ width = cs ? cs->width : xfont->max_bounds.width;
+ *buffer++ = MAX( width, 0 );
+ }
+ return TRUE;
+}
+
+
+/***********************************************************************
+ * GetCharWidth32W (GDI32.158)
+ */
+BOOL32 GetCharWidth32W( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
+ LPINT32 buffer )
+{
+ return GetCharWidth32A( hdc, firstChar, lastChar, buffer );
+}
+
+
+/***********************************************************************
* AddFontResource (GDI.119)
*/
INT AddFontResource( LPCSTR str )
@@ -1217,8 +1334,8 @@
static int logfcmp(const void *a,const void *b)
{
- return strcmp( (*(LPLOGFONT16 *)a)->lfFaceName,
- (*(LPLOGFONT16 *)b)->lfFaceName );
+ return lstrcmpi32A( (*(LPLOGFONT16 *)a)->lfFaceName,
+ (*(LPLOGFONT16 *)b)->lfFaceName );
}
void InitFontsList(void)
@@ -1256,11 +1373,7 @@
dprintf_font(stddeb,"InitFontsList // names[%d]='%s' \n", i, names[i]);
ParseFontParms(names[i], 2, str, sizeof(str));
-#if 0
- /* not necessary because new function FONT_ChkX11Family() */
- if (strcmp(str, "fixed") == 0) strcat(str, "sys");
-#endif
- AnsiUpper(str);
+/* AnsiUpper(str);*/
strcpy(lpNewFont->lfFaceName, str);
ParseFontParms(names[i], 8, str, sizeof(str));
lpNewFont->lfHeight = atoi(str) / 10;
@@ -1423,7 +1536,7 @@
}
lpOldName = NULL;
strcpy(FaceName,lpLF->lfFaceName);
- AnsiUpper(lpLF->lfFaceName);
+/* AnsiUpper(lpLF->lfFaceName);*/
if (lpLogFontList[0] == NULL) InitFontsList();
for(i = 0; lpLogFontList[i] != NULL; i++) {
@@ -1434,11 +1547,15 @@
/* lfPitchAndFamily only of importance in Hebrew and Arabic versions. */
/* lfFaceName */
- if (FaceName[0]) {
- if (strcmp(FaceName,lpLogFontList[i]->lfFaceName))
+ if (FaceName[0])
+ {
+ if (lstrcmpi32A(FaceName,lpLogFontList[i]->lfFaceName))
continue;
- } else {
- if ((lpOldName!=NULL)&&!strcmp(lpOldName,lpLogFontList[i]->lfFaceName))
+ }
+ else
+ {
+ if ((lpOldName!=NULL) &&
+ !lstrcmpi32A(lpOldName,lpLogFontList[i]->lfFaceName))
continue;
lpOldName=lpLogFontList[i]->lfFaceName;
}
@@ -1500,7 +1617,7 @@
}
lpOldName = NULL;
strcpy(FaceName,lpLF->lfFaceName);
- AnsiUpper(lpLF->lfFaceName);
+/* AnsiUpper(lpLF->lfFaceName);*/
if (lpLogFontList[0] == NULL) InitFontsList();
for(i = 0; lpLogFontList[i] != NULL; i++) {
@@ -1512,10 +1629,11 @@
/* lfPitchAndFamily only of importance in Hebrew and Arabic versions. */
/* lfFaceName */
if (FaceName[0]) {
- if (strcmp(FaceName,lpLogFontList[i]->lfFaceName))
+ if (lstrcmpi32A(FaceName,lpLogFontList[i]->lfFaceName))
continue;
} else {
- if ((lpOldName!=NULL)&&!strcmp(lpOldName,lpLogFontList[i]->lfFaceName))
+ if ((lpOldName!=NULL) &&
+ !lstrcmpi32A(lpOldName,lpLogFontList[i]->lfFaceName))
continue;
lpOldName=lpLogFontList[i]->lfFaceName;
}
@@ -1557,19 +1675,15 @@
LPSTR lpOldName;
int nRet = 0;
int i;
- LPSTR lpszFamily=STRING32_DupUniToAnsi(lpLF->lfFaceName);
+ LPSTR lpszFamily;
dprintf_font(stddeb,"EnumFontFamiliesEx32W(%04x, %p, %08lx, %08lx, %08lx)\n",
hDC, lpLF, (DWORD)lpEnumFunc, lpData,reserved);
- if (lpEnumFunc == 0) {
- free(lpszFamily);
- return 0;
- }
+ if (lpEnumFunc == 0) return 0;
hLog = GDI_HEAP_ALLOC( sizeof(ENUMLOGFONTEX32W) );
lpEnumLogFont = (LPENUMLOGFONTEX32W) GDI_HEAP_LIN_ADDR(hLog);
if (lpEnumLogFont == NULL) {
fprintf(stderr,"EnumFontFamilies32W // can't alloc LOGFONT struct !\n");
- free(lpszFamily);
return 0;
}
hMet = GDI_HEAP_ALLOC( sizeof(NEWTEXTMETRICEX32W) );
@@ -1577,10 +1691,10 @@
if (lptm == NULL) {
GDI_HEAP_FREE(hLog);
fprintf(stderr,"EnumFontFamilies32W // can't alloc TEXTMETRIC struct !\n");
- free(lpszFamily);
return 0;
}
lpOldName = NULL;
+ lpszFamily = HEAP_strdupWtoA( GetProcessHeap(), 0, lpLF->lfFaceName );
AnsiUpper(lpszFamily);
if (lpLogFontList[0] == NULL) InitFontsList();
for(i = 0; lpLogFontList[i] != NULL; i++) {
@@ -1592,18 +1706,19 @@
/* lfPitchAndFamily only of importance in Hebrew and Arabic versions. */
/* lfFaceName */
if (lpszFamily[0]) {
- if (strcmp(lpszFamily,lpLogFontList[i]->lfFaceName))
+ if (lstrcmpi32A(lpszFamily,lpLogFontList[i]->lfFaceName))
continue;
} else {
- if ((lpOldName!=NULL)&&!strcmp(lpOldName,lpLogFontList[i]->lfFaceName))
+ if ((lpOldName!=NULL) &&
+ !lstrcmpi32A(lpOldName,lpLogFontList[i]->lfFaceName))
continue;
lpOldName=lpLogFontList[i]->lfFaceName;
}
FONT_LOGFONT16ToLOGFONT32W(lpLogFontList[i],&(lpEnumLogFont->elfLogFont));
- lstrcpynAtoW(lpEnumLogFont->elfFullName,"",1);
- lstrcpynAtoW(lpEnumLogFont->elfStyle,"",1);
- lstrcpynAtoW(lpEnumLogFont->elfScript,"",1);
+ lpEnumLogFont->elfFullName[0] = 0;
+ lpEnumLogFont->elfStyle[0] = 0;
+ lpEnumLogFont->elfScript[0] = 0;
hFont = CreateFontIndirect32W((LPLOGFONT32W)lpEnumLogFont);
hOldFont = SelectObject32(hDC, hFont);
GetTextMetrics32W(hDC, (LPTEXTMETRIC32W)lptm);
@@ -1619,7 +1734,7 @@
}
GDI_HEAP_FREE(hMet);
GDI_HEAP_FREE(hLog);
- free(lpszFamily);
+ HeapFree( GetProcessHeap(), 0, lpszFamily );
return nRet;
}
diff --git a/objects/metafile.c b/objects/metafile.c
index d1891bb..a912ce8 100644
--- a/objects/metafile.c
+++ b/objects/metafile.c
@@ -205,7 +205,7 @@
if (!MF_MetaParam0(dc, META_EOF))
{
- DeleteDC( hdc );
+ DeleteDC32( hdc );
return 0;
}
@@ -215,12 +215,12 @@
mh->mtNoParameters = 0;
if (_llseek(hFile, 0L, 0) == -1)
{
- DeleteDC( hdc );
+ DeleteDC32( hdc );
return 0;
}
if (_lwrite32(hFile, (char *)mh, MFHEADERSIZE) == -1)
{
- DeleteDC( hdc );
+ DeleteDC32( hdc );
return 0;
}
_lclose(hFile);
@@ -229,7 +229,7 @@
hmf = physDev->hMetafile;
GlobalUnlock16( hmf );
physDev->hMetafile = 0; /* So it won't be deleted */
- DeleteDC( hdc );
+ DeleteDC32( hdc );
return hmf;
}
@@ -409,27 +409,27 @@
break;
case META_SETBKMODE:
- SetBkMode(hdc, *(mr->rdParam));
+ SetBkMode16(hdc, *(mr->rdParam));
break;
case META_SETMAPMODE:
- SetMapMode(hdc, *(mr->rdParam));
+ SetMapMode16(hdc, *(mr->rdParam));
break;
case META_SETROP2:
- SetROP2(hdc, *(mr->rdParam));
+ SetROP216(hdc, *(mr->rdParam));
break;
case META_SETRELABS:
- SetRelAbs(hdc, *(mr->rdParam));
+ SetRelAbs16(hdc, *(mr->rdParam));
break;
case META_SETPOLYFILLMODE:
- SetPolyFillMode(hdc, *(mr->rdParam));
+ SetPolyFillMode16(hdc, *(mr->rdParam));
break;
case META_SETSTRETCHBLTMODE:
- SetStretchBltMode(hdc, *(mr->rdParam));
+ SetStretchBltMode16(hdc, *(mr->rdParam));
break;
case META_SETTEXTCOLOR:
@@ -528,7 +528,7 @@
break;
case META_SAVEDC:
- SaveDC(hdc);
+ SaveDC32(hdc);
break;
case META_SETPIXEL:
@@ -561,7 +561,7 @@
break;
case META_RESTOREDC:
- RestoreDC(hdc, *(mr->rdParam));
+ RestoreDC32(hdc, *(mr->rdParam));
break;
case META_SELECTOBJECT:
@@ -622,7 +622,7 @@
break;
case META_SETTEXTALIGN:
- SetTextAlign(hdc, *(mr->rdParam));
+ SetTextAlign16(hdc, *(mr->rdParam));
break;
case META_SELECTPALETTE:
@@ -698,7 +698,7 @@
case META_STRETCHBLT:
{
- HDC16 hdcSrc=CreateCompatibleDC(hdc);
+ HDC16 hdcSrc=CreateCompatibleDC16(hdc);
HBITMAP16 hbitmap=CreateBitmap(mr->rdParam[10], /*Width */
mr->rdParam[11], /*Height*/
mr->rdParam[13], /*Planes*/
@@ -710,13 +710,13 @@
hdcSrc,mr->rdParam[5],mr->rdParam[4],
mr->rdParam[3],mr->rdParam[2],
MAKELONG(mr->rdParam[0],mr->rdParam[1]));
- DeleteDC(hdcSrc);
+ DeleteDC32(hdcSrc);
}
break;
case META_BITBLT: /* <-- not yet debugged */
{
- HDC16 hdcSrc=CreateCompatibleDC(hdc);
+ HDC16 hdcSrc=CreateCompatibleDC16(hdc);
HBITMAP16 hbitmap=CreateBitmap(mr->rdParam[7]/*Width */,mr->rdParam[8]/*Height*/,
mr->rdParam[10]/*Planes*/,mr->rdParam[11]/*BitsPixel*/,
(LPSTR)&mr->rdParam[12]/*bits*/);
@@ -725,7 +725,7 @@
mr->rdParam[4],mr->rdParam[3],
hdcSrc, mr->rdParam[2],mr->rdParam[1],
MAKELONG(0,mr->rdParam[0]));
- DeleteDC(hdcSrc);
+ DeleteDC32(hdcSrc);
}
break;
diff --git a/objects/pen.c b/objects/pen.c
index 83f70c7..9bb51ee 100644
--- a/objects/pen.c
+++ b/objects/pen.c
@@ -123,8 +123,7 @@
dc->w.hPen = hpen;
dc->u.x.pen.style = pen->logpen.lopnStyle;
- dc->u.x.pen.width = pen->logpen.lopnWidth.x * dc->w.VportExtX
- / dc->w.WndExtX;
+ dc->u.x.pen.width = pen->logpen.lopnWidth.x * dc->vportExtX / dc->wndExtX;
if (dc->u.x.pen.width < 0) dc->u.x.pen.width = -dc->u.x.pen.width;
if (dc->u.x.pen.width == 1) dc->u.x.pen.width = 0; /* Faster */
dc->u.x.pen.pixel = COLOR_ToPhysical( dc, pen->logpen.lopnColor );
diff --git a/objects/text.c b/objects/text.c
index 13659b2..e5977c4 100644
--- a/objects/text.c
+++ b/objects/text.c
@@ -11,8 +11,8 @@
#include "dc.h"
#include "gdi.h"
#include "callback.h"
+#include "heap.h"
#include "metafile.h"
-#include "string32.h"
#include "stddebug.h"
/* #define DEBUG_TEXT */
#include "debug.h"
@@ -257,7 +257,7 @@
rect, line, len, NULL )) return 0;
if (prefix_offset != -1)
{
- HPEN32 hpen = CreatePen32( PS_SOLID, 1, GetTextColor(hdc) );
+ HPEN32 hpen = CreatePen32( PS_SOLID, 1, GetTextColor32(hdc) );
HPEN32 oldPen = SelectObject32( hdc, hpen );
MoveTo(hdc, x + prefix_x, y + tm.tmAscent + 1 );
LineTo32(hdc, x + prefix_end, y + tm.tmAscent + 1 );
@@ -312,9 +312,9 @@
INT32 DrawText32W( HDC32 hdc, LPCWSTR str, INT32 count,
LPRECT32 rect, UINT32 flags )
{
- char *p = STRING32_DupUniToAnsi( str );
+ LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
INT32 ret = DrawText32A( hdc, p, count, rect, flags );
- free(p);
+ HeapFree( GetProcessHeap(), 0, p );
return ret;
}
@@ -589,9 +589,9 @@
const RECT32 *lprect, LPCWSTR str, UINT32 count,
const INT32 *lpDx )
{
- char *p = STRING32_DupUniToAnsi( str );
+ LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
INT32 ret = ExtTextOut32A( hdc, x, y, flags, lprect, p, count, lpDx );
- free(p);
+ HeapFree( GetProcessHeap(), 0, p );
return ret;
}
@@ -634,7 +634,7 @@
if (!cch) cch = lstrlen16( (LPCSTR)PTR_SEG_TO_LIN(lParam) );
if (gsprc) return gsprc( hdc, lParam, cch );
- current_color = GetTextColor( hdc );
+ current_color = GetTextColor32( hdc );
SetTextColor( hdc, GetSysColor(COLOR_GRAYTEXT) );
ret = TextOut16( hdc, x, y, (LPCSTR)PTR_SEG_TO_LIN(lParam), cch );
SetTextColor( hdc, current_color );
@@ -691,7 +691,7 @@
RECT16 r;
SetRect16( &r, x, y, tabPos, y+HIWORD(extent) );
ExtTextOut16( hdc, x, y,
- GetBkMode(hdc) == OPAQUE ? ETO_OPAQUE : 0,
+ GetBkMode32(hdc) == OPAQUE ? ETO_OPAQUE : 0,
&r, lpstr, i, NULL );
}
x = tabPos;
diff --git a/win32/advapi.c b/win32/advapi.c
index c43ef5b..6ac2101 100644
--- a/win32/advapi.c
+++ b/win32/advapi.c
@@ -49,7 +49,7 @@
BOOL32
OpenProcessToken(HANDLE32 process,DWORD desiredaccess,HANDLE32 *thandle)
{
- fprintf(stdnimp,"OpenProcessToken(%08lx,%08lx,%p),stub!\n",
+ fprintf(stdnimp,"OpenProcessToken(%08x,%08lx,%p),stub!\n",
process,desiredaccess,thandle
);
return TRUE;
diff --git a/win32/code_page.c b/win32/code_page.c
index f181ad3..da1d7e0 100644
--- a/win32/code_page.c
+++ b/win32/code_page.c
@@ -9,9 +9,9 @@
#include "windows.h"
#include "winerror.h"
#include "winnls.h"
+#include "heap.h"
#include "stddebug.h"
#include "debug.h"
-#include "string32.h"
/***********************************************************************
@@ -102,14 +102,14 @@
* EnumSystemCodePages32W (KERNEL32.93)
*/
BOOL32
-EnumSystemCodePages32W(CODEPAGE_ENUMPROC32W lpfnCodePageEnum,DWORD flags) {
- WCHAR *cp;
- dprintf_win32(stddeb,"EnumSystemCodePages32W(%p,%08lx)\n",
- lpfnCodePageEnum,flags
- );
+EnumSystemCodePages32W( CODEPAGE_ENUMPROC32W lpfnCodePageEnum, DWORD flags)
+{
+ WCHAR *cp;
+ dprintf_win32(stddeb,"EnumSystemCodePages32W(%p,%08lx)\n",
+ lpfnCodePageEnum,flags );
- cp=STRING32_DupAnsiToUni("437");
- lpfnCodePageEnum(cp);
- free(cp);
- return TRUE;
+ cp = HEAP_strdupAtoW( GetProcessHeap(), 0, "437" );
+ lpfnCodePageEnum(cp);
+ HeapFree( GetProcessHeap(), 0, cp );
+ return TRUE;
}
diff --git a/win32/console.c b/win32/console.c
index 8fb2f66..558b433 100644
--- a/win32/console.c
+++ b/win32/console.c
@@ -9,7 +9,7 @@
#include "windows.h"
#include "winerror.h"
#include "wincon.h"
-#include "string32.h"
+#include "heap.h"
#include "xmalloc.h"
#include "stddebug.h"
#include "debug.h"
@@ -93,7 +93,7 @@
*/
BOOL32 SetConsoleMode(HANDLE32 hcon,DWORD mode)
{
- fprintf(stdnimp,"SetConsoleMode(%08lx,%08lx)\n",hcon,mode);
+ fprintf(stdnimp,"SetConsoleMode(%08x,%08lx)\n",hcon,mode);
return TRUE;
}
@@ -189,20 +189,21 @@
}
/***********************************************************************
- * SetConsoleTitleA (KERNEL32.476)
+ * SetConsoleTitle32A (KERNEL32.476)
*/
BOOL32 SetConsoleTitle32A(LPCSTR title)
{
fprintf(stderr,"SetConsoleTitle(%s)\n",title);
return TRUE;
}
+
/***********************************************************************
- * SetConsoleTitleW (KERNEL32.477)
+ * SetConsoleTitle32W (KERNEL32.477)
*/
-BOOL32 SetConsoleTitle32W(LPCWSTR title)
+BOOL32 SetConsoleTitle32W( LPCWSTR title )
{
- LPSTR titleA = STRING32_DupUniToAnsi(title);
+ LPSTR titleA = HEAP_strdupWtoA( GetProcessHeap(), 0, title );
fprintf(stderr,"SetConsoleTitle(%s)\n",titleA);
- free(titleA);
+ HeapFree( GetProcessHeap(), 0, titleA );
return TRUE;
}
diff --git a/win32/cursoricon32.c b/win32/cursoricon32.c
index 14a34bd..40a3251 100644
--- a/win32/cursoricon32.c
+++ b/win32/cursoricon32.c
@@ -32,11 +32,11 @@
#include "win.h"
#include "bitmap.h"
#include "struct32.h"
-#include "string32.h"
+#include "heap.h"
+#include "task.h"
#include "stddebug.h"
#include "debug.h"
#include "xmalloc.h"
-#include "task.h"
/* This dictionary could might eventually become a macro for better reuse */
struct MAP_DWORD_DWORD{
@@ -328,8 +328,8 @@
return 0;
}
- hXorBits = CreateDIBitmap( hdc, &pInfo->bmiHeader, CBM_INIT,
- (char*)bmi + size, pInfo, DIB_RGB_COLORS );
+ hXorBits = CreateDIBitmap32( hdc, &pInfo->bmiHeader, CBM_INIT,
+ (char*)bmi + size, pInfo, DIB_RGB_COLORS );
/* Fix the bitmap header to load the monochrome mask */
@@ -358,8 +358,8 @@
/* Create the AND bitmap */
- hAndBits = CreateDIBitmap( hdc, &pInfo->bmiHeader, CBM_INIT,
- bits, pInfo, DIB_RGB_COLORS );
+ hAndBits = CreateDIBitmap32( hdc, &pInfo->bmiHeader, CBM_INIT,
+ bits, pInfo, DIB_RGB_COLORS );
ReleaseDC32( 0, hdc );
/* Now create the CURSORICONINFO structure */
@@ -418,19 +418,19 @@
WORD resid;
if(HIWORD(name))
{
- LPSTR ansi;
- ansi=STRING32_DupUniToAnsi(name);
+ LPSTR ansi = HEAP_strdupWtoA(GetProcessHeap(),0,name);
if(ansi[0]=='#') /*Check for '#xxx' name */
{
- resid=atoi(ansi+1);
- free(ansi);
- }else{
- free(ansi);
- return 0;
+ resid = atoi(ansi+1);
+ HeapFree( GetProcessHeap(), 0, ansi );
+ }
+ else
+ {
+ HeapFree( GetProcessHeap(), 0, ansi );
+ return 0;
}
}
- else
- resid=(WORD)(int)name;
+ else resid = LOWORD(name);
return OBM_LoadCursorIcon(resid, fCursor);
}
@@ -474,10 +474,11 @@
HCURSOR32 res=0;
if(!HIWORD(name))
return LoadCursor32W(hInstance,(LPCWSTR)name);
- else {
- LPWSTR uni = STRING32_DupAnsiToUni(name);
- res = LoadCursor32W(hInstance, uni);
- free(uni);
+ else
+ {
+ LPWSTR uni = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
+ res = LoadCursor32W(hInstance, uni);
+ HeapFree( GetProcessHeap(), 0, uni);
}
return res;
}
@@ -501,10 +502,11 @@
HICON32 res=0;
if(!HIWORD(name))
return LoadIcon32W(hInstance, (LPCWSTR)name);
- else {
- LPWSTR uni = STRING32_DupAnsiToUni(name);
- res = LoadIcon32W(hInstance, uni);
- free(uni);
+ else
+ {
+ LPWSTR uni = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
+ res = LoadIcon32W( hInstance, uni );
+ HeapFree( GetProcessHeap(), 0, uni );
}
return res;
}
diff --git a/win32/file.c b/win32/file.c
index bb74b48..7b9ec58 100644
--- a/win32/file.c
+++ b/win32/file.c
@@ -17,8 +17,8 @@
#include "winbase.h"
#include "winerror.h"
#include "file.h"
+#include "heap.h"
#include "handle32.h"
-#include "string32.h"
#include "dos_fs.h"
#include "xmalloc.h"
#include "stddebug.h"
@@ -50,7 +50,6 @@
HANDLE32 CreateFileMapping32A(HANDLE32 h,LPSECURITY_ATTRIBUTES ats,
DWORD pot, DWORD sh, DWORD hlow, LPCSTR lpName )
{
- HFILE hfile;
FILEMAP_OBJECT *filemap_obj;
dprintf_win32(stddeb,"CreateFileMapping32A(%08x,%p,%ld,%ld,%ld,%s)\n",
@@ -82,11 +81,9 @@
HANDLE32 CreateFileMapping32W(HANDLE32 h,LPSECURITY_ATTRIBUTES ats,
DWORD pot, DWORD sh, DWORD hlow, LPCWSTR lpName)
{
- HANDLE32 res;
- LPSTR aname = STRING32_DupUniToAnsi(lpName);
-
- res = CreateFileMapping32A(h,ats,pot,sh,hlow,aname);
- free(aname);
+ LPSTR aname = HEAP_strdupWtoA( GetProcessHeap(), 0, lpName );
+ HANDLE32 res = CreateFileMapping32A(h,ats,pot,sh,hlow,aname);
+ HeapFree( GetProcessHeap(), 0, aname );
return res;
}
@@ -338,11 +335,10 @@
LPSECURITY_ATTRIBUTES security, DWORD creation,
DWORD attributes, HANDLE32 template)
{
- HFILE res;
- LPSTR afn = STRING32_DupUniToAnsi(filename);
-
- res = CreateFile32A(afn,access,sharing,security,creation,attributes,template);
- free(afn);
+ LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
+ HFILE res = CreateFile32A( afn, access, sharing, security, creation,
+ attributes, template );
+ HeapFree( GetProcessHeap(), 0, afn );
return res;
}
@@ -445,12 +441,10 @@
*/
DWORD GetFileAttributes32W(LPCWSTR lpFileName)
{
- LPSTR afn = STRING32_DupUniToAnsi(lpFileName);
- DWORD res;
-
- res = GetFileAttributes32A(afn);
- free(afn);
- return res;
+ LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName );
+ DWORD res = GetFileAttributes32A( afn );
+ HeapFree( GetProcessHeap(), 0, afn );
+ return res;
}
@@ -486,12 +480,10 @@
*/
BOOL32 SetFileAttributes32W(LPCWSTR lpFileName, DWORD attributes)
{
- LPSTR afn = STRING32_DupUniToAnsi(lpFileName);
- BOOL32 res;
-
- res = SetFileAttributes32A(afn,attributes);
- free(afn);
- return res;
+ LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName );
+ BOOL32 res = SetFileAttributes32A( afn, attributes );
+ HeapFree( GetProcessHeap(), 0, afn );
+ return res;
}
/**************************************************************************
@@ -549,14 +541,12 @@
*/
BOOL32 MoveFile32W(LPCWSTR fn1,LPCWSTR fn2)
{
- LPSTR afn1 = STRING32_DupUniToAnsi(fn1);
- LPSTR afn2 = STRING32_DupUniToAnsi(fn2);
- BOOL32 res;
-
- res = MoveFile32A(afn1,afn2);
- free(afn1);
- free(afn2);
- return res;
+ LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
+ LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
+ BOOL32 res = MoveFile32A( afn1, afn2 );
+ HeapFree( GetProcessHeap(), 0, afn1 );
+ HeapFree( GetProcessHeap(), 0, afn2 );
+ return res;
}
VOID SetFileApisToOEM()
@@ -581,7 +571,7 @@
OFSTRUCT of;
HFILE hf1,hf2;
char buffer[2048];
- int res,lastread,curlen;
+ int lastread,curlen;
fprintf(stddeb,"CopyFile: %s -> %s\n",sourcefn,destfn);
hf1 = OpenFile(sourcefn,&of,OF_READ);
@@ -600,16 +590,14 @@
while ((lastread=_lread16(hf1,buffer,sizeof(buffer)))>0) {
curlen=0;
while (curlen<lastread) {
- int res;
-
- res=_lwrite16(hf2,buffer+curlen,lastread-curlen);
+ int res = _lwrite16(hf2,buffer+curlen,lastread-curlen);
if (res<=0) break;
curlen+=res;
}
}
_lclose(hf1);
_lclose(hf2);
- return res>0;
+ return curlen > 0;
}
BOOL32
diff --git a/win32/findfile.c b/win32/findfile.c
index 0c6618a..799e5e1 100644
--- a/win32/findfile.c
+++ b/win32/findfile.c
@@ -11,7 +11,6 @@
#include "winerror.h"
#include "dos_fs.h"
#include "heap.h"
-#include "string32.h"
#include "drive.h"
#include "stddebug.h"
#include "debug.h"
@@ -173,8 +172,8 @@
adata.nFileSizeLow = data->nFileSizeLow;
adata.dwReserved0 = data->dwReserved0;
adata.dwReserved1 = data->dwReserved1;
- STRING32_UniToAnsi(adata.cFileName,data->cFileName);
- STRING32_UniToAnsi(adata.cAlternateFileName,data->cAlternateFileName);
+ lstrcpyWtoA(adata.cFileName,data->cFileName);
+ lstrcpyWtoA(adata.cAlternateFileName,data->cAlternateFileName);
res=FindNextFile32A(handle,&adata);
if (res) {
data->dwFileAttributes = adata.dwFileAttributes;
@@ -185,8 +184,8 @@
data->nFileSizeLow = adata.nFileSizeLow;
data->dwReserved0 = adata.dwReserved0;
data->dwReserved1 = adata.dwReserved1;
- STRING32_AnsiToUni(data->cFileName,adata.cFileName);
- STRING32_AnsiToUni(data->cAlternateFileName,adata.cAlternateFileName);
+ lstrcpyAtoW(data->cFileName,adata.cFileName);
+ lstrcpyAtoW(data->cAlternateFileName,adata.cAlternateFileName);
}
return res;
}
@@ -282,11 +281,10 @@
HANDLE32 FindFirstFile32W(LPCWSTR filename,LPWIN32_FIND_DATA32W data)
{
WIN32_FIND_DATA32A adata;
- LPSTR afn = STRING32_DupUniToAnsi(filename);
- HANDLE32 res;
-
- res=FindFirstFile32A(afn,&adata);
- if (res) {
+ LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
+ HANDLE32 res = FindFirstFile32A(afn,&adata);
+ if (res)
+ {
data->dwFileAttributes = adata.dwFileAttributes;
data->ftCreationTime = adata.ftCreationTime;
data->ftLastAccessTime = adata.ftLastAccessTime;
@@ -295,10 +293,10 @@
data->nFileSizeLow = adata.nFileSizeLow;
data->dwReserved0 = adata.dwReserved0;
data->dwReserved1 = adata.dwReserved1;
- STRING32_AnsiToUni(data->cFileName,adata.cFileName);
- STRING32_AnsiToUni(data->cAlternateFileName,adata.cAlternateFileName);
+ lstrcpyAtoW(data->cFileName,adata.cFileName);
+ lstrcpyAtoW(data->cAlternateFileName,adata.cAlternateFileName);
}
- free(afn);
+ HeapFree( GetProcessHeap(), 0, afn );
return res;
}
diff --git a/win32/init.c b/win32/init.c
index b61ac47..3eb9ed3 100644
--- a/win32/init.c
+++ b/win32/init.c
@@ -11,12 +11,10 @@
#include "winerror.h"
#include "handle32.h"
#include "except.h"
+#include "heap.h"
#include "task.h"
#include "stddebug.h"
-#include "string32.h"
-#define DEBUG_WIN32
#include "debug.h"
-#include "string32.h"
#include "xmalloc.h"
/* The global error value
@@ -28,9 +26,9 @@
*/
BOOL CloseHandle(KERNEL_OBJECT *handle)
{
- if (handle<0x1000) /* FIXME: hack */
- return CloseFileHandle(handle);
- if (handle==0xFFFFFFFF)
+ if ((int)handle<0x1000) /* FIXME: hack */
+ return CloseFileHandle((int)handle);
+ if ((int)handle==0xFFFFFFFF)
return FALSE;
switch(handle->magic)
{
@@ -74,13 +72,11 @@
HMODULE32 WIN32_GetModuleHandleW(LPCWSTR module)
{
- HMODULE32 hModule;
- LPSTR modulea;
- if(module==NULL) return WIN32_GetModuleHandleA(NULL);
- modulea=STRING32_DupUniToAnsi(module);
- hModule = WIN32_GetModuleHandleA(modulea);
- free(modulea);
- return hModule;
+ HMODULE32 hModule;
+ LPSTR modulea = HEAP_strdupWtoA( GetProcessHeap(), 0, module );
+ hModule = WIN32_GetModuleHandleA( modulea );
+ HeapFree( GetProcessHeap(), 0, modulea );
+ return hModule;
}
@@ -107,9 +103,9 @@
VOID GetStartupInfo32W(LPSTARTUPINFO32W lpStartupInfo)
{
lpStartupInfo->cb = sizeof(STARTUPINFO32W);
- lpStartupInfo->lpReserved = STRING32_DupAnsiToUni("<Reserved>");
- lpStartupInfo->lpDesktop = STRING32_DupAnsiToUni("Desktop");
- lpStartupInfo->lpTitle = STRING32_DupAnsiToUni("Title");
+ lpStartupInfo->lpReserved = HEAP_strdupAtoW(GetProcessHeap(),0,"<Reserved>");
+ lpStartupInfo->lpDesktop = HEAP_strdupAtoW(GetProcessHeap(), 0, "Desktop");
+ lpStartupInfo->lpTitle = HEAP_strdupAtoW(GetProcessHeap(), 0, "Title");
lpStartupInfo->cbReserved2 = 0;
lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
@@ -130,8 +126,8 @@
si->u.x.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL;
si->dwPageSize = 4096; /* 4K */
- si->lpMinimumApplicationAddress = 0x40000000;
- si->lpMaximumApplicationAddress = 0x80000000;
+ si->lpMinimumApplicationAddress = (void *)0x40000000;
+ si->lpMaximumApplicationAddress = (void *)0x80000000;
si->dwActiveProcessorMask = 1;
si->dwNumberOfProcessors = 1;
#ifdef WINELIB
diff --git a/win32/newfns.c b/win32/newfns.c
index cab11b9..c7fb4c1 100644
--- a/win32/newfns.c
+++ b/win32/newfns.c
@@ -36,7 +36,7 @@
DWORD
GetWindowThreadProcessId(HWND32 hwnd,LPDWORD processid) {
- fprintf(stdnimp,"GetWindowThreadProcessId(%04lx,%p),stub\n",hwnd,processid);
+ fprintf(stdnimp,"GetWindowThreadProcessId(%04x,%p),stub\n",hwnd,processid);
return 0;
}
diff --git a/win32/process.c b/win32/process.c
index 50a0283..2b6f501 100644
--- a/win32/process.c
+++ b/win32/process.c
@@ -9,6 +9,7 @@
#include <unistd.h>
#include "windows.h"
#include "winerror.h"
+#include "heap.h"
#include "handle32.h"
#include "task.h"
#include "stddebug.h"
@@ -124,13 +125,10 @@
*/
HINSTANCE32 LoadLibrary32W(LPCWSTR libnameW)
{
- LPSTR libnameA = STRING32_DupUniToAnsi(libnameW);
- HINSTANCE32 ret;
-
- ret = LoadLibrary32A(libnameA);
- free(libnameA);
- return ret;
-
+ LPSTR libnameA = HEAP_strdupWtoA( GetProcessHeap(), 0, libnameW );
+ HINSTANCE32 ret = LoadLibrary32A( libnameA );
+ HeapFree( GetProcessHeap(), 0, libnameA );
+ return ret;
}
/***********************************************************************
diff --git a/win32/string32.c b/win32/string32.c
index 011b445..f4a317b 100644
--- a/win32/string32.c
+++ b/win32/string32.c
@@ -15,47 +15,17 @@
#include "string32.h"
#include "xmalloc.h"
-void STRING32_UniToAnsi(LPSTR dest,LPCWSTR src)
-{
- static int have_warned=0;
- while(*src)
- {
- if(*src>255 && !have_warned)
- {
- fprintf(stderr,"Cannot deal with non-ANSI characters\n");
- have_warned=1;
- }
- *dest++=*src++;
- }
- /* copy the terminator */
- *dest = *src;
-}
-
-/* FIXME: we need to use unsigned char here, for if
- * we got chars with the 7th bit set, we will get
- * negative integers -> wrong unicode values
- */
-void
-STRING32_AnsiToUni(LPWSTR dest,LPCSTR src) {
- unsigned char *usrc;
-
- usrc=(unsigned char*)src;
- while(*usrc)
- *dest++=*usrc++;
- *dest = *usrc;
-}
-
LPSTR STRING32_DupUniToAnsi(LPCWSTR src)
{
LPSTR dest=xmalloc(lstrlen32W(src)+1);
- STRING32_UniToAnsi(dest,src);
+ lstrcpyWtoA(dest,src);
return dest;
}
LPWSTR STRING32_DupAnsiToUni(LPCSTR src)
{
LPWSTR dest=xmalloc(2*strlen(src)+2);
- STRING32_AnsiToUni(dest,src);
+ lstrcpyAtoW(dest,src);
return dest;
}
diff --git a/win32/user32.c b/win32/user32.c
index 3880aeb..89c1a40 100644
--- a/win32/user32.c
+++ b/win32/user32.c
@@ -16,7 +16,6 @@
#include "xmalloc.h"
#include "handle32.h"
#include "struct32.h"
-#include "string32.h"
#include "win.h"
#include "debug.h"
#include "stddebug.h"
diff --git a/windows/Makefile.in b/windows/Makefile.in
index 5b3343f..5cfa021 100644
--- a/windows/Makefile.in
+++ b/windows/Makefile.in
@@ -17,7 +17,6 @@
graphics.c \
hook.c \
keyboard.c \
- mapping.c \
mdi.c \
message.c \
msgbox.c \
diff --git a/windows/caret.c b/windows/caret.c
index 055bb1b..ca11b7e 100644
--- a/windows/caret.c
+++ b/windows/caret.c
@@ -33,7 +33,7 @@
CARET_TOGGLE,
} DISPLAY_CARET;
-static CARET Caret;
+static CARET Caret = { 0, 0, FALSE, 0, 0, 2, 12, 0, 500, 0 };
/*****************************************************************
@@ -150,7 +150,7 @@
Caret.x = 0;
Caret.y = 0;
- Caret.timeout = GetProfileInt32A( "windows", "CursorBlinkRate", 750 );
+ Caret.timeout = GetProfileInt32A( "windows", "CursorBlinkRate", 500 );
return TRUE;
}
@@ -268,7 +268,6 @@
*/
UINT32 GetCaretBlinkTime32(void)
{
- if (!Caret.hwnd) return 0;
return Caret.timeout;
}
diff --git a/windows/class.c b/windows/class.c
index d5c3f64..d04e707 100644
--- a/windows/class.c
+++ b/windows/class.c
@@ -13,7 +13,6 @@
#include "dce.h"
#include "atom.h"
#include "ldt.h"
-#include "string32.h"
#include "toolhelp.h"
#include "winproc.h"
#include "stddebug.h"
@@ -92,9 +91,7 @@
if (!classPtr->menuNameA && classPtr->menuNameW)
{
/* We need to copy the Unicode string */
- if ((classPtr->menuNameA = SEGPTR_ALLOC(
- lstrlen32W(classPtr->menuNameW) + 1 )))
- STRING32_UniToAnsi( classPtr->menuNameA, classPtr->menuNameW );
+ classPtr->menuNameA = SEGPTR_STRDUP_WtoA( classPtr->menuNameW );
}
return classPtr->menuNameA;
}
@@ -112,9 +109,8 @@
if (!HIWORD(classPtr->menuNameA))
return (LPWSTR)classPtr->menuNameA;
/* Now we need to copy the ASCII string */
- if ((classPtr->menuNameW = HeapAlloc( SystemHeap, 0,
- (strlen(classPtr->menuNameA)+1)*sizeof(WCHAR) )))
- STRING32_AnsiToUni( classPtr->menuNameW, classPtr->menuNameA );
+ classPtr->menuNameW = HEAP_strdupAtoW( SystemHeap, 0,
+ classPtr->menuNameA );
}
return classPtr->menuNameW;
}
diff --git a/windows/dce.c b/windows/dce.c
index 98bbe81..56889ce 100644
--- a/windows/dce.c
+++ b/windows/dce.c
@@ -85,7 +85,7 @@
SetDCHook(dce->hDC, NULL, 0L);
- DeleteDC( dce->hDC );
+ DeleteDC32( dce->hDC );
if( dce->hClipRgn && !(dce->DCXflags & DCX_KEEPCLIPRGN) )
DeleteObject32(dce->hClipRgn);
HeapFree( SystemHeap, 0, dce );
diff --git a/windows/defwnd.c b/windows/defwnd.c
index 8b0da40..b666cca 100644
--- a/windows/defwnd.c
+++ b/windows/defwnd.c
@@ -12,7 +12,6 @@
#include "heap.h"
#include "nonclient.h"
#include "winpos.h"
-#include "string32.h"
#include "syscolor.h"
#include "sysmetrics.h"
#include "stddebug.h"
@@ -481,9 +480,9 @@
if (cs->lpszName)
{
WND *wndPtr = WIN_FindWndPtr( hwnd );
- LPSTR str = STRING32_DupUniToAnsi( cs->lpszName );
+ LPSTR str = HEAP_strdupWtoA(GetProcessHeap(), 0, cs->lpszName);
DEFWND_SetText( wndPtr, str );
- free( str );
+ HeapFree( GetProcessHeap(), 0, str );
}
result = 1;
}
@@ -491,18 +490,18 @@
case WM_GETTEXT:
{
- LPSTR str = malloc( wParam );
+ LPSTR str = HeapAlloc( GetProcessHeap(), 0, wParam );
result = DefWindowProc32A( hwnd, msg, wParam, (LPARAM)str );
- STRING32_AnsiToUni( (LPWSTR)lParam, str );
- free( str );
+ lstrcpynAtoW( (LPWSTR)lParam, str, wParam );
+ HeapFree( GetProcessHeap(), 0, str );
}
break;
case WM_SETTEXT:
{
- LPSTR str = STRING32_DupUniToAnsi( (LPWSTR)lParam );
+ LPSTR str = HEAP_strdupWtoA( GetProcessHeap(), 0, (LPWSTR)lParam );
result = DefWindowProc32A( hwnd, msg, wParam, (LPARAM)str );
- free( str );
+ HeapFree( GetProcessHeap(), 0, str );
}
break;
diff --git a/windows/dialog.c b/windows/dialog.c
index 864495f..bd03f44 100644
--- a/windows/dialog.c
+++ b/windows/dialog.c
@@ -14,7 +14,6 @@
#include "heap.h"
#include "win.h"
#include "ldt.h"
-#include "string32.h"
#include "user.h"
#include "winproc.h"
#include "message.h"
@@ -73,7 +72,7 @@
if (!(hdc = CreateDC16( "DISPLAY", NULL, NULL, NULL ))) return FALSE;
GetTextMetrics16( hdc, &tm );
- DeleteDC( hdc );
+ DeleteDC32( hdc );
xBaseUnit = tm.tmAveCharWidth;
yBaseUnit = tm.tmHeight;
@@ -174,12 +173,12 @@
{
switch(GET_WORD(p+1))
{
- case 0x80: STRING32_AnsiToUni( buffer, "BUTTON" ); break;
- case 0x81: STRING32_AnsiToUni( buffer, "EDIT" ); break;
- case 0x82: STRING32_AnsiToUni( buffer, "STATIC" ); break;
- case 0x83: STRING32_AnsiToUni( buffer, "LISTBOX" ); break;
- case 0x84: STRING32_AnsiToUni( buffer, "SCROLLBAR" ); break;
- case 0x85: STRING32_AnsiToUni( buffer, "COMBOBOX" ); break;
+ case 0x80: lstrcpyAtoW( buffer, "Button" ); break;
+ case 0x81: lstrcpyAtoW( buffer, "Edit" ); break;
+ case 0x82: lstrcpyAtoW( buffer, "Static" ); break;
+ case 0x83: lstrcpyAtoW( buffer, "ListBox" ); break;
+ case 0x84: lstrcpyAtoW( buffer, "ScrollBar" ); break;
+ case 0x85: lstrcpyAtoW( buffer, "ComboBox" ); break;
default: buffer[0] = '\0'; break;
}
info->className = (LPCSTR)buffer;
@@ -653,9 +652,9 @@
{
if (HIWORD(name))
{
- LPWSTR str = STRING32_DupAnsiToUni( name );
+ LPWSTR str = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
HWND32 hwnd = CreateDialogParam32W( hInst, str, owner, dlgProc, param);
- free( str );
+ HeapFree( GetProcessHeap(), 0, str );
return hwnd;
}
return CreateDialogParam32W( hInst, (LPCWSTR)name, owner, dlgProc, param );
@@ -1599,10 +1598,9 @@
UINT32 attrib )
{
INT32 ret;
- LPSTR specA = NULL;
- if (spec) specA = STRING32_DupUniToAnsi(spec);
+ LPSTR specA = HEAP_strdupWtoA( GetProcessHeap(), 0, spec );
ret = DIALOG_DlgDirList( hDlg, specA, idLBox, idStatic, attrib, FALSE );
- if (specA) free( specA );
+ HeapFree( GetProcessHeap(), 0, specA );
return ret;
}
@@ -1634,9 +1632,8 @@
INT32 idStatic, UINT32 attrib )
{
INT32 ret;
- LPSTR specA = NULL;
- if (spec) specA = STRING32_DupUniToAnsi(spec);
+ LPSTR specA = HEAP_strdupWtoA( GetProcessHeap(), 0, spec );
ret = DIALOG_DlgDirList( hDlg, specA, idCBox, idStatic, attrib, FALSE );
- if (specA) free( specA );
+ HeapFree( GetProcessHeap(), 0, specA );
return ret;
}
diff --git a/windows/event.c b/windows/event.c
index 1143c44..d01c38b 100644
--- a/windows/event.c
+++ b/windows/event.c
@@ -313,6 +313,17 @@
XSaveContext( display, pWnd->window, winContext, (char *)pWnd );
}
+/***********************************************************************
+ * EVENT_DestroyWindow
+ */
+void EVENT_DestroyWindow( WND *pWnd )
+{
+ XEvent xe;
+
+ XDeleteContext( display, pWnd->window, winContext );
+ XDestroyWindow( display, pWnd->window );
+ while( XCheckWindowEvent(display, pWnd->window, NoEventMask, &xe) );
+}
/***********************************************************************
* EVENT_WaitXEvent
@@ -391,9 +402,9 @@
{
WND* pWnd;
MESSAGEQUEUE* pQ;
-
- if( XFindContext( display, ((XAnyEvent *)&event)->window, winContext, (char **)&pWnd)
- || event.type == NoExpose )
+
+ if (XFindContext( display, ((XAnyEvent *)&event)->window, winContext,
+ (char **)&pWnd ) || (event.type == NoExpose))
continue;
/* check for the "safe" hardware events */
@@ -613,7 +624,8 @@
keylp.lp1.count = 1;
keylp.lp1.code = LOBYTE(event->keycode) - 8;
keylp.lp1.extended = (extended ? 1 : 0);
- keylp.lp1.win_internal = 0;
+ keylp.lp1.win_internal = 0; /* this has something to do with dialogs,
+ * don't remember where I read it - AK */
keylp.lp1.context = ( (event->state & Mod1Mask) ||
(InputKeyStateTable[VK_MENU] & 0x80)) ? 1 : 0;
keylp.lp1.previous = (KeyDown ? 0 : 1);
diff --git a/windows/graphics.c b/windows/graphics.c
index 9aedf97..caf865e 100644
--- a/windows/graphics.c
+++ b/windows/graphics.c
@@ -425,8 +425,8 @@
top = YLPTODP( dc, top );
right = XLPTODP( dc, right );
bottom = YLPTODP( dc, bottom );
- ell_width = abs( ell_width * dc->w.VportExtX / dc->w.WndExtX );
- ell_height = abs( ell_height * dc->w.VportExtY / dc->w.WndExtY );
+ ell_width = abs( ell_width * dc->vportExtX / dc->wndExtX );
+ ell_height = abs( ell_height * dc->vportExtY / dc->wndExtY );
/* Fix the coordinates */
@@ -819,10 +819,10 @@
BOOL32 InvertRgn32( HDC32 hdc, HRGN32 hrgn )
{
HBRUSH32 prevBrush = SelectObject32( hdc, GetStockObject32(BLACK_BRUSH) );
- WORD prevROP = SetROP2( hdc, R2_NOT );
+ INT32 prevROP = SetROP232( hdc, R2_NOT );
BOOL32 retval = PaintRgn32( hdc, hrgn );
SelectObject32( hdc, prevBrush );
- SetROP2( hdc, prevROP );
+ SetROP232( hdc, prevROP );
return retval;
}
@@ -856,8 +856,8 @@
bottom = YLPTODP( dc, rc->bottom );
hOldPen = SelectObject32( hdc, sysColorObjects.hpenWindowText );
- oldDrawMode = SetROP2(hdc, R2_XORPEN);
- oldBkMode = SetBkMode(hdc, TRANSPARENT);
+ oldDrawMode = SetROP232(hdc, R2_XORPEN);
+ oldBkMode = SetBkMode32(hdc, TRANSPARENT);
/* Hack: make sure the XORPEN operation has an effect */
dc->u.x.pen.pixel = (1 << screenDepth) - 1;
@@ -867,8 +867,8 @@
dc->w.DCOrgX + left, dc->w.DCOrgY + top,
right-left-1, bottom-top-1 );
- SetBkMode(hdc, oldBkMode);
- SetROP2(hdc, oldDrawMode);
+ SetBkMode32(hdc, oldBkMode);
+ SetROP232(hdc, oldDrawMode);
SelectObject32(hdc, hOldPen);
}
diff --git a/windows/hook.c b/windows/hook.c
index a64db7c..f5dd48a 100644
--- a/windows/hook.c
+++ b/windows/hook.c
@@ -18,10 +18,10 @@
#include "windows.h"
#include "hook.h"
#include "queue.h"
+#include "stackframe.h"
#include "user.h"
#include "heap.h"
#include "struct32.h"
-#include "string32.h"
#include "stddebug.h"
#include "debug.h"
@@ -237,14 +237,14 @@
(LPCREATESTRUCT32A)lpcbtcw32->lpcs );
if (HIWORD(lpcs16->lpszName))
- lpcbtcw32->lpcs->lpszName =
- STRING32_DupAnsiToUni( PTR_SEG_TO_LIN(lpcs16->lpszName) );
+ lpcbtcw32->lpcs->lpszName = HEAP_strdupAtoW( SystemHeap, 0,
+ PTR_SEG_TO_LIN(lpcs16->lpszName) );
else
lpcbtcw32->lpcs->lpszName = (LPWSTR)lpcs16->lpszName;
if (HIWORD(lpcs16->lpszClass))
- lpcbtcw32->lpcs->lpszClass =
- STRING32_DupAnsiToUni( PTR_SEG_TO_LIN(lpcs16->lpszClass) );
+ lpcbtcw32->lpcs->lpszClass = HEAP_strdupAtoW( SystemHeap, 0,
+ PTR_SEG_TO_LIN(lpcs16->lpszClass) );
else
lpcbtcw32->lpcs->lpszClass = (LPWSTR)lpcs16->lpszClass;
@@ -346,9 +346,9 @@
{
LPCBT_CREATEWND32W lpcbtcw32 = (LPCBT_CREATEWND32W)lParam;
if (HIWORD(lpcbtcw32->lpcs->lpszName))
- free( (LPWSTR)lpcbtcw32->lpcs->lpszName );
+ HeapFree( SystemHeap, 0, (LPWSTR)lpcbtcw32->lpcs->lpszName );
if (HIWORD(lpcbtcw32->lpcs->lpszClass))
- free( (LPWSTR)lpcbtcw32->lpcs->lpszClass );
+ HeapFree( SystemHeap, 0, (LPWSTR)lpcbtcw32->lpcs->lpszClass );
HeapFree( SystemHeap, 0, lpcbtcw32->lpcs );
HeapFree( SystemHeap, 0, lpcbtcw32 );
}
@@ -525,6 +525,7 @@
{
if (id == WH_CBT && code == HCBT_CREATEWND)
{
+ LPSTR name, cls;
LPCBT_CREATEWND32W lpcbtcw32 = (LPCBT_CREATEWND32W)*plParam;
LPCBT_CREATEWND16 lpcbtcw16 = SEGPTR_NEW( CBT_CREATEWND16 );
LPCREATESTRUCT16 lpcs16 = SEGPTR_NEW( CREATESTRUCT16 );
@@ -533,24 +534,10 @@
STRUCT32_CREATESTRUCT32Ato16( (LPCREATESTRUCT32A)lpcbtcw32->lpcs,
lpcs16 );
- if (HIWORD(lpcbtcw32->lpcs->lpszName))
- {
- LPSTR str = SEGPTR_ALLOC( lstrlen32W(lpcbtcw32->lpcs->lpszName) );
- STRING32_UniToAnsi( str, lpcbtcw32->lpcs->lpszName );
- lpcs16->lpszName = SEGPTR_GET( str );
- }
- else
- lpcs16->lpszName = (SEGPTR)lpcbtcw32->lpcs->lpszName;
-
- if (HIWORD(lpcbtcw32->lpcs->lpszClass))
- {
- LPSTR str = SEGPTR_ALLOC( lstrlen32W(lpcbtcw32->lpcs->lpszClass) );
- STRING32_UniToAnsi( str, lpcbtcw32->lpcs->lpszClass );
- lpcs16->lpszClass = SEGPTR_GET( str );
- }
- else
- lpcs16->lpszClass = (SEGPTR)lpcbtcw32->lpcs->lpszClass;
-
+ name = SEGPTR_STRDUP_WtoA( lpcbtcw32->lpcs->lpszName );
+ cls = SEGPTR_STRDUP_WtoA( lpcbtcw32->lpcs->lpszClass );
+ lpcs16->lpszName = SEGPTR_GET( name );
+ lpcs16->lpszClass = SEGPTR_GET( cls );
lpcbtcw16->hwndInsertAfter = lpcbtcw32->hwndInsertAfter;
*plParam = (LPARAM)SEGPTR_GET( lpcbtcw16 );
@@ -670,16 +657,16 @@
if (HIWORD(lpcbtcwA->lpcs->lpszName))
{
- lpcbtcwW->lpcs->lpszName =
- STRING32_DupAnsiToUni( lpcbtcwA->lpcs->lpszName );
+ lpcbtcwW->lpcs->lpszName = HEAP_strdupAtoW( SystemHeap, 0,
+ lpcbtcwA->lpcs->lpszName );
}
else
lpcbtcwW->lpcs->lpszName = (LPWSTR)lpcbtcwA->lpcs->lpszName;
if (HIWORD(lpcbtcwA->lpcs->lpszClass))
{
- lpcbtcwW->lpcs->lpszClass =
- STRING32_DupAnsiToUni( lpcbtcwA->lpcs->lpszClass);
+ lpcbtcwW->lpcs->lpszClass = HEAP_strdupAtoW( SystemHeap, 0,
+ lpcbtcwA->lpcs->lpszClass );
}
else
lpcbtcwW->lpcs->lpszClass = (LPCWSTR)lpcbtcwA->lpcs->lpszClass;
@@ -699,9 +686,9 @@
{
LPCBT_CREATEWND32W lpcbtcwW = (LPCBT_CREATEWND32W)lParam;
if (HIWORD(lpcbtcwW->lpcs->lpszName))
- free( (LPWSTR)lpcbtcwW->lpcs->lpszName );
+ HeapFree( SystemHeap, 0, (LPWSTR)lpcbtcwW->lpcs->lpszName );
if (HIWORD(lpcbtcwW->lpcs->lpszClass))
- free( (LPWSTR)lpcbtcwW->lpcs->lpszClass );
+ HeapFree( SystemHeap, 0, (LPWSTR)lpcbtcwW->lpcs->lpszClass );
HeapFree( SystemHeap, 0, lpcbtcwW->lpcs );
HeapFree( SystemHeap, 0, lpcbtcwW );
}
@@ -726,14 +713,14 @@
*lpcbtcwA->lpcs = *(LPCREATESTRUCT32A)lpcbtcwW->lpcs;
if (HIWORD(lpcbtcwW->lpcs->lpszName))
- lpcbtcwA->lpcs->lpszName =
- STRING32_DupUniToAnsi( lpcbtcwW->lpcs->lpszName );
+ lpcbtcwA->lpcs->lpszName = HEAP_strdupWtoA( SystemHeap, 0,
+ lpcbtcwW->lpcs->lpszName );
else
lpcbtcwA->lpcs->lpszName = (LPSTR)lpcbtcwW->lpcs->lpszName;
if (HIWORD(lpcbtcwW->lpcs->lpszClass))
- lpcbtcwA->lpcs->lpszClass =
- STRING32_DupUniToAnsi( lpcbtcwW->lpcs->lpszClass);
+ lpcbtcwA->lpcs->lpszClass = HEAP_strdupWtoA( SystemHeap, 0,
+ lpcbtcwW->lpcs->lpszClass );
else
lpcbtcwA->lpcs->lpszClass = (LPSTR)lpcbtcwW->lpcs->lpszClass;
}
@@ -752,9 +739,9 @@
{
LPCBT_CREATEWND32A lpcbtcwA = (LPCBT_CREATEWND32A)lParam;
if (HIWORD(lpcbtcwA->lpcs->lpszName))
- free( (LPSTR)lpcbtcwA->lpcs->lpszName );
+ HeapFree( SystemHeap, 0, (LPSTR)lpcbtcwA->lpcs->lpszName );
if (HIWORD(lpcbtcwA->lpcs->lpszClass))
- free( (LPSTR)lpcbtcwA->lpcs->lpszClass );
+ HeapFree( SystemHeap, 0, (LPSTR)lpcbtcwA->lpcs->lpszClass );
HeapFree( SystemHeap, 0, lpcbtcwA->lpcs );
HeapFree( SystemHeap, 0, lpcbtcwA );
}
@@ -947,6 +934,7 @@
HANDLE16 prevHook;
HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook);
LRESULT ret;
+ WORD old_ds;
WPARAM32 wParamOrig = wParam;
LPARAM lParamOrig = lParam;
@@ -969,7 +957,11 @@
dprintf_hook( stddeb, "Calling hook %04x: %d %08x %08lx\n",
hook, code, wParam, lParam );
+ /* Set DS = SS to call hook procedure */
+ old_ds = CURRENT_DS;
+ CURRENT_DS = IF1632_Saved16_ss;
ret = data->proc(code, wParam, lParam);
+ CURRENT_DS = old_ds;
dprintf_hook( stddeb, "Ret hook %04x = %08lx\n", hook, ret );
diff --git a/windows/keyboard.c b/windows/keyboard.c
index 0342cb9..d4dcc7f 100644
--- a/windows/keyboard.c
+++ b/windows/keyboard.c
@@ -29,16 +29,12 @@
{
INT retval;
- if (keycode >= 'a' && keycode <= 'z')
- keycode += 'A' - 'a';
- switch(keycode) {
- case VK_LBUTTON:
- retval = MouseButtonsStates[0];
- case VK_MBUTTON:
- retval = MouseButtonsStates[1];
- case VK_RBUTTON:
- retval = MouseButtonsStates[2];
- default:
+ if( keycode >= VK_LBUTTON && keycode <= VK_RBUTTON )
+ retval = MouseButtonsStates[keycode - VK_LBUTTON];
+ else
+ {
+ if (keycode >= 'a' && keycode <= 'z')
+ keycode += 'A' - 'a';
retval = ( (INT)(QueueKeyStateTable[keycode] & 0x80) << 8 ) |
(INT)(QueueKeyStateTable[keycode] & 0x01);
}
diff --git a/windows/mapping.c b/windows/mapping.c
deleted file mode 100644
index ed8a1bb..0000000
--- a/windows/mapping.c
+++ /dev/null
@@ -1,666 +0,0 @@
-/*
- * GDI mapping mode functions
- *
- * Copyright 1993 Alexandre Julliard
- */
-
-#include <math.h>
-#include "gdi.h"
-#include "metafile.h"
-#include "stddebug.h"
-/* #define DEBUG_GDI */
-#include "debug.h"
-
-
-/***********************************************************************
- * MAPPING_FixIsotropic
- *
- * Fix viewport extensions for isotropic mode.
- */
-void MAPPING_FixIsotropic( DC * dc )
-{
- double xdim = (double)dc->w.VportExtX * dc->w.devCaps->horzSize /
- (dc->w.devCaps->horzRes * dc->w.WndExtX);
- double ydim = (double)dc->w.VportExtY * dc->w.devCaps->vertSize /
- (dc->w.devCaps->vertRes * dc->w.WndExtY);
- if (xdim > ydim)
- {
- dc->w.VportExtX = dc->w.VportExtX * fabs( ydim / xdim );
- if (!dc->w.VportExtX) dc->w.VportExtX = 1;
- }
- else
- {
- dc->w.VportExtY = dc->w.VportExtY * fabs( xdim / ydim );
- if (!dc->w.VportExtY) dc->w.VportExtY = 1;
- }
-}
-
-
-/***********************************************************************
- * DPtoLP16 (GDI.67)
- */
-BOOL16 DPtoLP16( HDC16 hdc, LPPOINT16 points, INT16 count )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
-
- while (count--)
- {
- points->x = XDPTOLP( dc, points->x );
- points->y = YDPTOLP( dc, points->y );
- points++;
- }
- return TRUE;
-}
-
-
-/***********************************************************************
- * DPtoLP32 (GDI32.65)
- */
-BOOL32 DPtoLP32( HDC32 hdc, LPPOINT32 points, INT32 count )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
-
- while (count--)
- {
- points->x = XDPTOLP( dc, points->x );
- points->y = YDPTOLP( dc, points->y );
- points++;
- }
- return TRUE;
-}
-
-
-/***********************************************************************
- * LPtoDP16 (GDI.99)
- */
-BOOL16 LPtoDP16( HDC16 hdc, LPPOINT16 points, INT16 count )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
-
- while (count--)
- {
- points->x = XLPTODP( dc, points->x );
- points->y = YLPTODP( dc, points->y );
- points++;
- }
- return TRUE;
-}
-
-
-/***********************************************************************
- * LPtoDP32 (GDI32.247)
- */
-BOOL32 LPtoDP32( HDC32 hdc, LPPOINT32 points, INT32 count )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
-
- while (count--)
- {
- points->x = XLPTODP( dc, points->x );
- points->y = YLPTODP( dc, points->y );
- points++;
- }
- return TRUE;
-}
-
-
-/***********************************************************************
- * SetMapMode (GDI.3)
- */
-WORD SetMapMode( HDC16 hdc, WORD mode )
-{
- WORD prevMode;
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc)
- {
- dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
- if (!dc) return 0;
- MF_MetaParam1(dc, META_SETMAPMODE, mode);
- return 1;
- }
-
- dprintf_gdi(stddeb, "SetMapMode: %04x %d\n", hdc, mode );
-
- prevMode = dc->w.MapMode;
- switch(mode)
- {
- case MM_TEXT:
- dc->w.WndOrgX = dc->w.WndOrgY = 0;
- dc->w.VportOrgX = dc->w.VportOrgY = 0;
- dc->w.WndExtX = 1;
- dc->w.WndExtY = 1;
- dc->w.VportExtX = 1;
- dc->w.VportExtY = 1;
- break;
-
- case MM_LOMETRIC:
- case MM_ISOTROPIC:
- dc->w.WndOrgX = dc->w.WndOrgY = 0;
- dc->w.VportOrgX = dc->w.VportOrgY = 0;
- dc->w.WndExtX = dc->w.devCaps->horzSize;
- dc->w.WndExtY = dc->w.devCaps->vertSize;
- dc->w.VportExtX = dc->w.devCaps->horzRes / 10;
- dc->w.VportExtY = dc->w.devCaps->vertRes / -10;
- break;
-
- case MM_HIMETRIC:
- dc->w.WndOrgX = dc->w.WndOrgY = 0;
- dc->w.VportOrgX = dc->w.VportOrgY = 0;
- dc->w.WndExtX = dc->w.devCaps->horzSize * 10;
- dc->w.WndExtY = dc->w.devCaps->vertSize * 10;
- dc->w.VportExtX = dc->w.devCaps->horzRes / 10;
- dc->w.VportExtY = dc->w.devCaps->vertRes / -10;
- break;
-
- case MM_LOENGLISH:
- dc->w.WndOrgX = dc->w.WndOrgY = 0;
- dc->w.VportOrgX = dc->w.VportOrgY = 0;
- dc->w.WndExtX = dc->w.devCaps->horzSize;
- dc->w.WndExtY = dc->w.devCaps->vertSize;
- dc->w.VportExtX = (short)(254L * dc->w.devCaps->horzRes / 1000);
- dc->w.VportExtY = (short)(-254L * dc->w.devCaps->vertRes / 1000);
- break;
-
- case MM_HIENGLISH:
- dc->w.WndOrgX = dc->w.WndOrgY = 0;
- dc->w.VportOrgX = dc->w.VportOrgY = 0;
- dc->w.WndExtX = dc->w.devCaps->horzSize * 10;
- dc->w.WndExtY = dc->w.devCaps->vertSize * 10;
- dc->w.VportExtX = (short)(254L * dc->w.devCaps->horzRes / 1000);
- dc->w.VportExtY = (short)(-254L * dc->w.devCaps->vertRes / 1000);
- break;
-
- case MM_TWIPS:
- dc->w.WndOrgX = dc->w.WndOrgY = 0;
- dc->w.VportOrgX = dc->w.VportOrgY = 0;
- dc->w.WndExtX = (short)(144L * dc->w.devCaps->horzSize / 10);
- dc->w.WndExtY = (short)(144L * dc->w.devCaps->vertSize / 10);
- dc->w.VportExtX = (short)(254L * dc->w.devCaps->horzRes / 1000);
- dc->w.VportExtY = (short)(-254L * dc->w.devCaps->vertRes / 1000);
- break;
-
- case MM_ANISOTROPIC:
- break;
-
- default:
- return prevMode;
- }
- dc->w.MapMode = mode;
- return prevMode;
-}
-
-
-/***********************************************************************
- * SetViewportExt (GDI.14)
- */
-DWORD SetViewportExt( HDC16 hdc, INT16 x, INT16 y )
-{
- SIZE16 size;
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc)
- {
- dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
- if (!dc) return FALSE;
- MF_MetaParam2(dc, META_SETVIEWPORTEXT, x, y);
- return 0;
- }
-
- size.cx = dc->w.VportExtX;
- size.cy = dc->w.VportExtY;
- if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
- return MAKELONG( size.cx, size.cy );
- if (!x || !y) return 0;
- dc->w.VportExtX = x;
- dc->w.VportExtY = y;
- if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
- return MAKELONG( size.cx, size.cy );
-}
-
-
-/***********************************************************************
- * SetViewportExtEx16 (GDI.479)
- */
-BOOL16 SetViewportExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
- if (size)
- {
- size->cx = dc->w.VportExtX;
- size->cy = dc->w.VportExtY;
- }
- if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
- return TRUE;
- if (!x || !y) return FALSE;
- dc->w.VportExtX = x;
- dc->w.VportExtY = y;
- if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
- return TRUE;
-}
-
-
-/***********************************************************************
- * SetViewportExtEx32 (GDI32.340)
- */
-BOOL32 SetViewportExtEx32( HDC32 hdc, INT32 x, INT32 y, LPSIZE32 size )
-{
- SIZE16 size16;
- BOOL16 ret = SetViewportExtEx16( (HDC16)hdc, (INT16)x, (INT16)y, &size16 );
- if (size) CONV_SIZE16TO32( &size16, size );
- return ret;
-}
-
-
-/***********************************************************************
- * SetViewportOrg (GDI.13)
- */
-DWORD SetViewportOrg( HDC16 hdc, INT16 x, INT16 y )
-{
- POINT16 pt;
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc)
- {
- dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
- if (!dc) return FALSE;
- MF_MetaParam2(dc, META_SETVIEWPORTORG, x, y);
- return 0;
- }
-
- pt.x = dc->w.VportOrgX;
- pt.y = dc->w.VportOrgY;
- dc->w.VportOrgX = x;
- dc->w.VportOrgY = y;
- return pt.x | (pt.y << 16);
-}
-
-
-/***********************************************************************
- * SetViewportOrgEx16 (GDI.480)
- */
-BOOL16 SetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
- if (pt)
- {
- pt->x = dc->w.VportOrgX;
- pt->y = dc->w.VportOrgY;
- }
- dc->w.VportOrgX = x;
- dc->w.VportOrgY = y;
- return TRUE;
-}
-
-
-/***********************************************************************
- * SetViewportOrgEx32 (GDI32.341)
- */
-BOOL32 SetViewportOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
-{
- POINT16 pt16;
- BOOL16 ret = SetViewportOrgEx16( (HDC16)hdc, (INT16)x, (INT16)y, &pt16 );
- if (pt) CONV_POINT16TO32( &pt16, pt );
- return ret;
-}
-
-
-/***********************************************************************
- * SetWindowExt (GDI.12)
- */
-DWORD SetWindowExt( HDC16 hdc, INT16 x, INT16 y )
-{
- SIZE16 size;
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc)
- {
- dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
- if (!dc) return FALSE;
- MF_MetaParam2(dc, META_SETWINDOWEXT, x, y);
- return 0;
- }
-
- size.cx = dc->w.WndExtX;
- size.cy = dc->w.WndExtY;
- if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
- return MAKELONG( size.cx, size.cy );
- if (!x || !y) return 0;
- dc->w.WndExtX = x;
- dc->w.WndExtY = y;
- if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
- return MAKELONG( size.cx, size.cy );
-}
-
-
-/***********************************************************************
- * SetWindowExtEx16 (GDI.481)
- */
-BOOL16 SetWindowExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
- if (size)
- {
- size->cx = dc->w.WndExtX;
- size->cy = dc->w.WndExtY;
- }
- if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
- return TRUE;
- if (!x || !y) return FALSE;
- dc->w.WndExtX = x;
- dc->w.WndExtY = y;
- if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
- return TRUE;
-}
-
-
-/***********************************************************************
- * SetWindowExtEx32 (GDI32.344)
- */
-BOOL32 SetWindowExtEx32( HDC32 hdc, INT32 x, INT32 y, LPSIZE32 size )
-{
- SIZE16 size16;
- BOOL16 ret = SetWindowExtEx16( (HDC16)hdc, (INT16)x, (INT16)y, &size16 );
- if (size) CONV_SIZE16TO32( &size16, size );
- return ret;
-}
-
-
-/***********************************************************************
- * SetWindowOrg (GDI.11)
- */
-DWORD SetWindowOrg( HDC16 hdc, INT16 x, INT16 y )
-{
- POINT16 pt;
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc)
- {
- dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
- if (!dc) return FALSE;
- MF_MetaParam2(dc, META_SETWINDOWORG, x, y);
- return 0;
- }
-
- pt.x = dc->w.WndOrgX;
- pt.y = dc->w.WndOrgY;
- dc->w.WndOrgX = x;
- dc->w.WndOrgY = y;
- return MAKELONG( pt.x, pt.y );
-}
-
-
-/***********************************************************************
- * SetWindowOrgEx16 (GDI.482)
- */
-BOOL16 SetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
- if (pt)
- {
- pt->x = dc->w.WndOrgX;
- pt->y = dc->w.WndOrgY;
- }
- dc->w.WndOrgX = x;
- dc->w.WndOrgY = y;
- return TRUE;
-}
-
-
-/***********************************************************************
- * SetWindowOrgEx32 (GDI32.345)
- */
-BOOL32 SetWindowOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
-{
- POINT16 pt16;
- BOOL16 ret = SetWindowOrgEx16( (HDC16)hdc, (INT16)x, (INT16)y, &pt16 );
- if (pt) CONV_POINT16TO32( &pt16, pt );
- return ret;
-}
-
-
-/***********************************************************************
- * OffsetViewportOrg (GDI.17)
- */
-DWORD OffsetViewportOrg( HDC16 hdc, INT16 x, INT16 y )
-{
- POINT16 pt;
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc)
- {
- dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
- if (!dc) return FALSE;
- MF_MetaParam2(dc, META_OFFSETVIEWPORTORG, x, y);
- return 0;
- }
-
- pt.x = dc->w.VportOrgX;
- pt.y = dc->w.VportOrgY;
- dc->w.VportOrgX += x;
- dc->w.VportOrgY += y;
- return pt.x | (pt.y << 16);
-}
-
-
-/***********************************************************************
- * OffsetViewportOrgEx16 (GDI.476)
- */
-BOOL16 OffsetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
- if (pt)
- {
- pt->x = dc->w.VportOrgX;
- pt->y = dc->w.VportOrgY;
- }
- dc->w.VportOrgX += x;
- dc->w.VportOrgY += y;
- return TRUE;
-}
-
-
-/***********************************************************************
- * OffsetViewportOrgEx32 (GDI32.257)
- */
-BOOL32 OffsetViewportOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
-{
- POINT16 pt16;
- BOOL16 ret = OffsetViewportOrgEx16( (HDC16)hdc, (INT16)x, (INT16)y, &pt16);
- if (pt) CONV_POINT16TO32( &pt16, pt );
- return ret;
-}
-
-
-/***********************************************************************
- * OffsetWindowOrg (GDI.15)
- */
-DWORD OffsetWindowOrg( HDC16 hdc, INT16 x, INT16 y )
-{
- POINT16 pt;
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc)
- {
- dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
- if (!dc) return FALSE;
- MF_MetaParam2(dc, META_OFFSETWINDOWORG, x, y);
- return 0;
- }
-
- pt.x = dc->w.WndOrgX;
- pt.y = dc->w.WndOrgY;
- dc->w.WndOrgX += x;
- dc->w.WndOrgY += y;
- return pt.x | (pt.y << 16);
-}
-
-
-/***********************************************************************
- * OffsetWindowOrgEx16 (GDI.477)
- */
-BOOL16 OffsetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
- if (pt)
- {
- pt->x = dc->w.WndOrgX;
- pt->y = dc->w.WndOrgY;
- }
- dc->w.WndOrgX += x;
- dc->w.WndOrgY += y;
- return TRUE;
-}
-
-
-/***********************************************************************
- * OffsetWindowOrgEx32 (GDI32.258)
- */
-BOOL32 OffsetWindowOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
-{
- POINT16 pt16;
- BOOL16 ret = OffsetWindowOrgEx16( (HDC16)hdc, (INT16)x, (INT16)y, &pt16 );
- if (pt) CONV_POINT16TO32( &pt16, pt );
- return ret;
-}
-
-
-/***********************************************************************
- * ScaleViewportExt (GDI.18)
- */
-DWORD ScaleViewportExt( HDC16 hdc, INT16 xNum, INT16 xDenom,
- INT16 yNum, INT16 yDenom )
-{
- SIZE16 size;
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc)
- {
- dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
- if (!dc) return FALSE;
- MF_MetaParam4(dc, META_SCALEVIEWPORTEXT, xNum, xDenom, yNum, yDenom);
- return 0;
- }
-
- size.cx = dc->w.VportExtX;
- size.cy = dc->w.VportExtY;
- if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
- return size.cx | (size.cy << 16);
- if (!xNum || !xDenom || !xNum || !yDenom) return 0;
- dc->w.VportExtX = (dc->w.VportExtX * xNum) / xDenom;
- dc->w.VportExtY = (dc->w.VportExtY * yNum) / yDenom;
- if (dc->w.VportExtX == 0) dc->w.VportExtX = 1;
- if (dc->w.VportExtY == 0) dc->w.VportExtY = 1;
- if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
- return size.cx | (size.cy << 16);
-}
-
-
-/***********************************************************************
- * ScaleViewportExtEx16 (GDI.484)
- */
-BOOL16 ScaleViewportExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
- INT16 yNum, INT16 yDenom, LPSIZE16 size )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
- if (size)
- {
- size->cx = dc->w.VportExtX;
- size->cy = dc->w.VportExtY;
- }
- if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
- return TRUE;
- if (!xNum || !xDenom || !xNum || !yDenom) return FALSE;
- dc->w.VportExtX = (dc->w.VportExtX * xNum) / xDenom;
- dc->w.VportExtY = (dc->w.VportExtY * yNum) / yDenom;
- if (dc->w.VportExtX == 0) dc->w.VportExtX = 1;
- if (dc->w.VportExtY == 0) dc->w.VportExtY = 1;
- if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
- return TRUE;
-}
-
-
-/***********************************************************************
- * ScaleViewportExtEx32 (GDI32.293)
- */
-BOOL32 ScaleViewportExtEx32( HDC32 hdc, INT32 xNum, INT32 xDenom,
- INT32 yNum, INT32 yDenom, LPSIZE32 size )
-{
- SIZE16 size16;
- BOOL16 ret = ScaleViewportExtEx16( (HDC16)hdc, (INT16)xNum, (INT16)xDenom,
- (INT16)yNum, (INT16)yDenom, &size16 );
- if (size) CONV_SIZE16TO32( &size16, size );
- return ret;
-}
-
-
-/***********************************************************************
- * ScaleWindowExt (GDI.16)
- */
-DWORD ScaleWindowExt( HDC16 hdc, INT16 xNum, INT16 xDenom,
- INT16 yNum, INT16 yDenom )
-{
- SIZE16 size;
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc)
- {
- dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
- if (!dc) return FALSE;
- MF_MetaParam4(dc, META_SCALEWINDOWEXT, xNum, xDenom, yNum, yDenom);
- return 0;
- }
-
- size.cx = dc->w.WndExtX;
- size.cy = dc->w.WndExtY;
- if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
- return size.cx | (size.cy << 16);
- if (!xNum || !xDenom || !xNum || !yDenom) return FALSE;
- dc->w.WndExtX = (dc->w.WndExtX * xNum) / xDenom;
- dc->w.WndExtY = (dc->w.WndExtY * yNum) / yDenom;
- if (dc->w.WndExtX == 0) dc->w.WndExtX = 1;
- if (dc->w.WndExtY == 0) dc->w.WndExtY = 1;
- if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
- return size.cx | (size.cy << 16);
-}
-
-
-/***********************************************************************
- * ScaleWindowExtEx16 (GDI.485)
- */
-BOOL16 ScaleWindowExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
- INT16 yNum, INT16 yDenom, LPSIZE16 size )
-{
- DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
- if (!dc) return FALSE;
- if (size)
- {
- size->cx = dc->w.WndExtX;
- size->cy = dc->w.WndExtY;
- }
- if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
- return TRUE;
- if (!xNum || !xDenom || !xNum || !yDenom) return FALSE;
- dc->w.WndExtX = (dc->w.WndExtX * xNum) / xDenom;
- dc->w.WndExtY = (dc->w.WndExtY * yNum) / yDenom;
- if (dc->w.WndExtX == 0) dc->w.WndExtX = 1;
- if (dc->w.WndExtY == 0) dc->w.WndExtY = 1;
- if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
- return TRUE;
-}
-
-
-/***********************************************************************
- * ScaleWindowExtEx32 (GDI32.294)
- */
-BOOL32 ScaleWindowExtEx32( HDC32 hdc, INT32 xNum, INT32 xDenom,
- INT32 yNum, INT32 yDenom, LPSIZE32 size )
-{
- SIZE16 size16;
- BOOL16 ret = ScaleWindowExtEx16( (HDC16)hdc, (INT16)xNum, (INT16)xDenom,
- (INT16)yNum, (INT16)yDenom, &size16 );
- if (size) CONV_SIZE16TO32( &size16, size );
- return ret;
-}
diff --git a/windows/mdi.c b/windows/mdi.c
index 684b3fc..e0b2474 100644
--- a/windows/mdi.c
+++ b/windows/mdi.c
@@ -663,8 +663,8 @@
*/
HBITMAP16 CreateMDIMenuBitmap(void)
{
- HDC16 hDCSrc = CreateCompatibleDC(0);
- HDC16 hDCDest = CreateCompatibleDC(hDCSrc);
+ HDC32 hDCSrc = CreateCompatibleDC32(0);
+ HDC32 hDCDest = CreateCompatibleDC32(hDCSrc);
HBITMAP16 hbClose = LoadBitmap16(0, MAKEINTRESOURCE(OBM_CLOSE) );
HBITMAP16 hbCopy,hb_src,hb_dest;
@@ -680,8 +680,8 @@
DeleteObject32(hbClose);
- DeleteDC(hDCDest);
- DeleteDC(hDCSrc);
+ DeleteDC32(hDCDest);
+ DeleteDC32(hDCSrc);
return hbCopy;
}
diff --git a/windows/message.c b/windows/message.c
index 07e4722..dcfec8d 100644
--- a/windows/message.c
+++ b/windows/message.c
@@ -439,6 +439,35 @@
if (HOOK_IsHooked( WH_JOURNALRECORD ))
MSG_JournalRecordMsg( msg );
QUEUE_RemoveMsg( sysMsgQueue, pos );
+
+ /* call CBT hook _after_ message removed from queue */
+ if (HOOK_IsHooked( WH_CBT ))
+ {
+ if (((msg->message >= WM_MOUSEFIRST) &&
+ (msg->message <= WM_MOUSELAST)) ||
+ ((msg->message >= WM_NCMOUSEFIRST) &&
+ (msg->message <= WM_NCMOUSELAST)))
+ {
+ MOUSEHOOKSTRUCT16 *hook = SEGPTR_NEW(MOUSEHOOKSTRUCT16);
+ if (hook)
+ {
+ hook->pt = msg->pt;
+ hook->hwnd = msg->hwnd;
+ hook->wHitTestCode = (INT16)SendMessage16( msg->hwnd,
+ WM_NCHITTEST, 0,
+ MAKELONG( msg->pt.x, msg->pt.y ) );
+ hook->dwExtraInfo = 0;
+ HOOK_CallHooks16( WH_CBT, HCBT_CLICKSKIPPED ,msg->message,
+ (LPARAM)SEGPTR_GET(hook) );
+ SEGPTR_FREE(hook);
+ }
+ }
+ else
+ if ((msg->message >= WM_KEYFIRST) &&
+ (msg->message <= WM_KEYLAST))
+ HOOK_CallHooks16( WH_CBT, HCBT_KEYSKIPPED,
+ msg->wParam, msg->lParam );
+ }
}
return TRUE;
}
diff --git a/windows/msgbox.c b/windows/msgbox.c
index 6cfb59f..9708381 100644
--- a/windows/msgbox.c
+++ b/windows/msgbox.c
@@ -9,11 +9,11 @@
#include <malloc.h>
#include "windows.h"
#include "dlgs.h"
+#include "heap.h"
#include "module.h"
#include "win.h"
#include "resource.h"
#include "task.h"
-#include "string32.h"
typedef struct {
LPCSTR title;
@@ -213,8 +213,8 @@
MSGBOX mbox;
int ret;
- mbox.title = title?STRING32_DupUniToAnsi(title):NULL;
- mbox.text = text?STRING32_DupUniToAnsi(text):NULL;
+ mbox.title = HEAP_strdupWtoA( GetProcessHeap(), 0, title );
+ mbox.text = HEAP_strdupWtoA( GetProcessHeap(), 0, text );
mbox.type = type;
fprintf(stderr,"MessageBox(%s,%s)\n",mbox.text,mbox.title);
@@ -225,8 +225,8 @@
MODULE_GetWndProcEntry16("SystemMessageBoxProc"),
(LONG)&mbox );
SYSRES_FreeResource( handle );
- if (title) free(mbox.title);
- if (text) free(mbox.text);
+ HeapFree( GetProcessHeap(), 0, mbox.title );
+ HeapFree( GetProcessHeap(), 0, mbox.text );
return ret;
}
diff --git a/windows/nonclient.c b/windows/nonclient.c
index 423cb4f..4c6a2d5 100644
--- a/windows/nonclient.c
+++ b/windows/nonclient.c
@@ -436,20 +436,20 @@
void NC_DrawSysButton( HWND hwnd, HDC16 hdc, BOOL down )
{
RECT16 rect;
- HDC16 hdcMem;
- HBITMAP16 hbitmap;
+ HDC32 hdcMem;
+ HBITMAP32 hbitmap;
WND *wndPtr = WIN_FindWndPtr( hwnd );
if( !(wndPtr->flags & WIN_MANAGED) )
{
NC_GetInsideRect( hwnd, &rect );
- hdcMem = CreateCompatibleDC( hdc );
+ hdcMem = CreateCompatibleDC32( hdc );
hbitmap = SelectObject32( hdcMem, hbitmapClose );
BitBlt32(hdc, rect.left, rect.top, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
hdcMem, (wndPtr->dwStyle & WS_CHILD) ? SYSMETRICS_CXSIZE : 0, 0,
down ? NOTSRCCOPY : SRCCOPY );
SelectObject32( hdcMem, hbitmap );
- DeleteDC( hdcMem );
+ DeleteDC32( hdcMem );
}
}
@@ -649,7 +649,7 @@
{
if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
- SetBkMode( hdc, TRANSPARENT );
+ SetBkMode32( hdc, TRANSPARENT );
DrawText16( hdc, buffer, -1, &r,
DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
}
diff --git a/windows/property.c b/windows/property.c
index 876bd58..0762558 100644
--- a/windows/property.c
+++ b/windows/property.c
@@ -5,11 +5,9 @@
*/
#define NO_TRANSITION_TYPES /* This file is Win32-clean */
-#include <stdlib.h>
#include <string.h>
#include "win.h"
#include "heap.h"
-#include "string32.h"
#include "stddebug.h"
#include "debug.h"
@@ -83,9 +81,9 @@
HANDLE32 ret;
if (!HIWORD(str)) return GetProp32A( hwnd, (LPCSTR)(UINT32)LOWORD(str) );
- strA = STRING32_DupUniToAnsi( str );
+ strA = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
ret = GetProp32A( hwnd, strA );
- free( strA );
+ HeapFree( GetProcessHeap(), 0, strA );
return ret;
}
@@ -141,9 +139,9 @@
if (!HIWORD(str))
return SetProp32A( hwnd, (LPCSTR)(UINT32)LOWORD(str), handle );
- strA = STRING32_DupUniToAnsi( str );
+ strA = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
ret = SetProp32A( hwnd, strA, handle );
- free( strA );
+ HeapFree( GetProcessHeap(), 0, strA );
return ret;
}
@@ -205,9 +203,9 @@
if (!HIWORD(str))
return RemoveProp32A( hwnd, (LPCSTR)(UINT32)LOWORD(str) );
- strA = STRING32_DupUniToAnsi( str );
+ strA = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
ret = RemoveProp32A( hwnd, strA );
- free( strA );
+ HeapFree( GetProcessHeap(), 0, strA );
return ret;
}
@@ -324,9 +322,9 @@
prop->handle, prop->string );
if (HIWORD(prop->string))
{
- LPWSTR str = STRING32_DupAnsiToUni( prop->string );
+ LPWSTR str = HEAP_strdupAtoW( GetProcessHeap(), 0, prop->string );
ret = func( hwnd, str, prop->handle, lParam );
- free( str );
+ HeapFree( GetProcessHeap(), 0, str );
}
else
ret = func( hwnd, (LPCWSTR)(UINT32)LOWORD( prop->string ),
diff --git a/windows/win.c b/windows/win.c
index 05f52b8..aae3d6d 100644
--- a/windows/win.c
+++ b/windows/win.c
@@ -22,7 +22,6 @@
#include "menu.h"
#include "message.h"
#include "nonclient.h"
-#include "string32.h"
#include "queue.h"
#include "winpos.h"
#include "color.h"
@@ -363,7 +362,7 @@
if (!(wndPtr->dwStyle & WS_CHILD))
if (wndPtr->wIDmenu) DestroyMenu( (HMENU16)wndPtr->wIDmenu );
if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
- if (wndPtr->window) XDestroyWindow( display, wndPtr->window );
+ if (wndPtr->window) EVENT_DestroyWindow( wndPtr );
if (wndPtr->class->style & CS_OWNDC) DCE_FreeDCE( wndPtr->dce );
WINPROC_FreeProc( wndPtr->winproc );
@@ -919,9 +918,9 @@
{
if (HIWORD(className))
{
- LPSTR cn = STRING32_DupUniToAnsi(className);
+ LPSTR cn = HEAP_strdupWtoA( GetProcessHeap(), 0, className );
fprintf( stderr, "CreateWindowEx32W: bad class name '%s'\n",cn);
- free(cn);
+ HeapFree( GetProcessHeap(), 0, cn );
}
else
fprintf( stderr, "CreateWindowEx32W: bad class name %p\n", className );
@@ -1221,9 +1220,9 @@
/* with this name exists either. */
if (!(atom = GlobalFindAtom32W( className ))) return 0;
}
- buffer = title ? STRING32_DupUniToAnsi( title ) : NULL;
+ buffer = HEAP_strdupWtoA( GetProcessHeap(), 0, title );
hwnd = WIN_FindWindow( 0, 0, atom, buffer );
- if (buffer) free( buffer );
+ HeapFree( GetProcessHeap(), 0, buffer );
return hwnd;
}
diff --git a/windows/winproc.c b/windows/winproc.c
index 2fa5f5d..6cbe823 100644
--- a/windows/winproc.c
+++ b/windows/winproc.c
@@ -12,7 +12,6 @@
#include "ldt.h"
#include "registers.h"
#include "stackframe.h"
-#include "string32.h"
#include "struct32.h"
#include "win.h"
#include "winproc.h"
@@ -360,7 +359,7 @@
}
return 1;
case WM_SETTEXT:
- *plparam = (LPARAM)STRING32_DupAnsiToUni( (LPCSTR)*plparam );
+ *plparam = (LPARAM)HEAP_strdupAtoW( SystemHeap, 0, (LPCSTR)*plparam );
return (*plparam ? 1 : -1);
case WM_NCCREATE:
case WM_CREATE:
@@ -370,9 +369,11 @@
if (!cs) return -1;
*cs = *(CREATESTRUCT32W *)*plparam;
if (HIWORD(cs->lpszName))
- cs->lpszName = STRING32_DupAnsiToUni( (LPCSTR)cs->lpszName );
+ cs->lpszName = HEAP_strdupAtoW( SystemHeap, 0,
+ (LPCSTR)cs->lpszName );
if (HIWORD(cs->lpszClass))
- cs->lpszClass = STRING32_DupAnsiToUni( (LPCSTR)cs->lpszClass );
+ cs->lpszClass = HEAP_strdupAtoW( SystemHeap, 0,
+ (LPCSTR)cs->lpszClass );
*plparam = (LPARAM)cs;
}
return 1;
@@ -383,9 +384,11 @@
if (!cs) return -1;
*cs = *(MDICREATESTRUCT32W *)*plparam;
if (HIWORD(cs->szClass))
- cs->szClass = STRING32_DupAnsiToUni( (LPCSTR)cs->szClass );
+ cs->szClass = HEAP_strdupAtoW( SystemHeap, 0,
+ (LPCSTR)cs->szClass );
if (HIWORD(cs->szTitle))
- cs->szTitle = STRING32_DupAnsiToUni( (LPCSTR)cs->szTitle );
+ cs->szTitle = HEAP_strdupAtoW( SystemHeap, 0,
+ (LPCSTR)cs->szTitle );
*plparam = (LPARAM)cs;
}
return 1;
@@ -421,22 +424,26 @@
}
break;
case WM_SETTEXT:
- free( (void *)lParam );
+ HeapFree( SystemHeap, 0, (void *)lParam );
break;
case WM_NCCREATE:
case WM_CREATE:
{
CREATESTRUCT32W *cs = (CREATESTRUCT32W *)lParam;
- if (HIWORD(cs->lpszName)) free( (LPVOID)cs->lpszName );
- if (HIWORD(cs->lpszClass)) free( (LPVOID)cs->lpszClass );
+ if (HIWORD(cs->lpszName))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->lpszName );
+ if (HIWORD(cs->lpszClass))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->lpszClass );
HeapFree( SystemHeap, 0, cs );
}
break;
case WM_MDICREATE:
{
MDICREATESTRUCT32W *cs = (MDICREATESTRUCT32W *)lParam;
- if (HIWORD(cs->szTitle)) free( (LPVOID)cs->szTitle );
- if (HIWORD(cs->szClass)) free( (LPVOID)cs->szClass );
+ if (HIWORD(cs->szTitle))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->szTitle );
+ if (HIWORD(cs->szClass))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->szClass );
HeapFree( SystemHeap, 0, cs );
}
break;
@@ -464,7 +471,7 @@
}
return 1;
case WM_SETTEXT:
- *plparam = (LPARAM)STRING32_DupUniToAnsi( (LPCWSTR)*plparam );
+ *plparam = (LPARAM)HEAP_strdupWtoA( SystemHeap, 0, (LPCWSTR)*plparam );
return (*plparam ? 1 : -1);
case WM_NCCREATE:
case WM_CREATE:
@@ -474,9 +481,11 @@
if (!cs) return -1;
*cs = *(CREATESTRUCT32A *)*plparam;
if (HIWORD(cs->lpszName))
- cs->lpszName = STRING32_DupUniToAnsi( (LPCWSTR)cs->lpszName );
+ cs->lpszName = HEAP_strdupWtoA( SystemHeap, 0,
+ (LPCWSTR)cs->lpszName );
if (HIWORD(cs->lpszClass))
- cs->lpszClass = STRING32_DupUniToAnsi( (LPCWSTR)cs->lpszClass);
+ cs->lpszClass = HEAP_strdupWtoA( SystemHeap, 0,
+ (LPCWSTR)cs->lpszClass);
*plparam = (LPARAM)cs;
}
return 1;
@@ -487,9 +496,11 @@
if (!cs) return -1;
*cs = *(MDICREATESTRUCT32A *)*plparam;
if (HIWORD(cs->szTitle))
- cs->szTitle = STRING32_DupUniToAnsi( (LPCWSTR)cs->szTitle );
+ cs->szTitle = HEAP_strdupWtoA( SystemHeap, 0,
+ (LPCWSTR)cs->szTitle );
if (HIWORD(cs->szClass))
- cs->szClass = STRING32_DupUniToAnsi( (LPCWSTR)cs->szClass );
+ cs->szClass = HEAP_strdupWtoA( SystemHeap, 0,
+ (LPCWSTR)cs->szClass );
*plparam = (LPARAM)cs;
}
return 1;
@@ -525,22 +536,26 @@
}
break;
case WM_SETTEXT:
- free( (void *)lParam );
+ HeapFree( SystemHeap, 0, (void *)lParam );
break;
case WM_NCCREATE:
case WM_CREATE:
{
CREATESTRUCT32A *cs = (CREATESTRUCT32A *)lParam;
- if (HIWORD(cs->lpszName)) free( (LPVOID)cs->lpszName );
- if (HIWORD(cs->lpszClass)) free( (LPVOID)cs->lpszClass );
+ if (HIWORD(cs->lpszName))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->lpszName );
+ if (HIWORD(cs->lpszClass))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->lpszClass );
HeapFree( SystemHeap, 0, cs );
}
break;
case WM_MDICREATE:
{
MDICREATESTRUCT32A *cs = (MDICREATESTRUCT32A *)lParam;
- if (HIWORD(cs->szTitle)) free( (LPVOID)cs->szTitle );
- if (HIWORD(cs->szClass)) free( (LPVOID)cs->szClass );
+ if (HIWORD(cs->szTitle))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->szTitle );
+ if (HIWORD(cs->szClass))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->szClass );
HeapFree( SystemHeap, 0, cs );
}
break;
@@ -868,9 +883,11 @@
cs->lpszName = (LPCWSTR)PTR_SEG_TO_LIN(cs16->lpszName);
cs->lpszClass = (LPCWSTR)PTR_SEG_TO_LIN(cs16->lpszClass);
if (HIWORD(cs->lpszName))
- cs->lpszName = STRING32_DupAnsiToUni( (LPCSTR)cs->lpszName );
+ cs->lpszName = HEAP_strdupAtoW( SystemHeap, 0,
+ (LPCSTR)cs->lpszName );
if (HIWORD(cs->lpszClass))
- cs->lpszClass = STRING32_DupAnsiToUni( (LPCSTR)cs->lpszClass );
+ cs->lpszClass = HEAP_strdupAtoW( SystemHeap, 0,
+ (LPCSTR)cs->lpszClass );
*(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
*plparam = (LPARAM)cs;
}
@@ -887,9 +904,11 @@
cs->szTitle = (LPCWSTR)PTR_SEG_TO_LIN(cs16->szTitle);
cs->szClass = (LPCWSTR)PTR_SEG_TO_LIN(cs16->szClass);
if (HIWORD(cs->szTitle))
- cs->szTitle = STRING32_DupAnsiToUni( (LPCSTR)cs->szTitle );
+ cs->szTitle = HEAP_strdupAtoW( SystemHeap, 0,
+ (LPCSTR)cs->szTitle );
if (HIWORD(cs->szClass))
- cs->szClass = STRING32_DupAnsiToUni( (LPCSTR)cs->szClass );
+ cs->szClass = HEAP_strdupAtoW( SystemHeap, 0,
+ (LPCSTR)cs->szClass );
*(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
*plparam = (LPARAM)cs;
}
@@ -921,8 +940,10 @@
lParam = *(LPARAM *)(cs + 1);
STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCT32A *)cs,
(CREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam) );
- if (HIWORD(cs->lpszName)) free( (LPVOID)cs->lpszName );
- if (HIWORD(cs->lpszClass)) free( (LPVOID)cs->lpszClass );
+ if (HIWORD(cs->lpszName))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->lpszName );
+ if (HIWORD(cs->lpszClass))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->lpszClass );
HeapFree( SystemHeap, 0, cs );
}
break;
@@ -932,8 +953,10 @@
lParam = *(LPARAM *)(cs + 1);
STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCT32A *)cs,
(MDICREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam) );
- if (HIWORD(cs->szTitle)) free( (LPVOID)cs->szTitle );
- if (HIWORD(cs->szClass)) free( (LPVOID)cs->szClass );
+ if (HIWORD(cs->szTitle))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->szTitle );
+ if (HIWORD(cs->szClass))
+ HeapFree( SystemHeap, 0, (LPVOID)cs->szClass );
HeapFree( SystemHeap, 0, cs );
}
break;
@@ -1376,9 +1399,8 @@
case LB_DIR32:
case LB_ADDFILE32:
{
- LPSTR str = SEGPTR_ALLOC( lstrlen32W((LPWSTR)*plparam) + 1 );
+ LPSTR str = SEGPTR_STRDUP_WtoA( (LPWSTR)*plparam );
if (!str) return -1;
- STRING32_UniToAnsi( str, (LPWSTR)*plparam );
*pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING32);
*pwparam16 = (WPARAM16)LOWORD(wParam32);
*plparam = (LPARAM)SEGPTR_GET(str);
@@ -1389,23 +1411,14 @@
{
CREATESTRUCT16 *cs;
CREATESTRUCT32W *cs32 = (CREATESTRUCT32W *)*plparam;
+ LPSTR name, cls;
if (!(cs = SEGPTR_NEW(CREATESTRUCT16))) return -1;
STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCT32A *)cs32, cs );
- if (HIWORD(cs32->lpszName))
- {
- LPSTR name = SEGPTR_ALLOC( lstrlen32W(cs32->lpszName) + 1 );
- STRING32_UniToAnsi( name, cs32->lpszName );
- cs->lpszName = SEGPTR_GET(name);
- }
- else cs->lpszName = (SEGPTR)cs32->lpszName;
- if (HIWORD(cs32->lpszClass))
- {
- LPSTR name = SEGPTR_ALLOC( lstrlen32W(cs32->lpszClass) + 1 );
- STRING32_UniToAnsi( name, cs32->lpszClass );
- cs->lpszClass = SEGPTR_GET(name);
- }
- else cs->lpszClass = (SEGPTR)cs32->lpszClass;
+ name = SEGPTR_STRDUP_WtoA( cs32->lpszName );
+ cls = SEGPTR_STRDUP_WtoA( cs32->lpszClass );
+ cs->lpszName = SEGPTR_GET(name);
+ cs->lpszClass = SEGPTR_GET(cls);
*pmsg16 = (UINT16)msg32;
*pwparam16 = (WPARAM16)LOWORD(wParam32);
*plparam = (LPARAM)SEGPTR_GET(cs);
@@ -1415,23 +1428,14 @@
{
MDICREATESTRUCT16 *cs;
MDICREATESTRUCT32W *cs32 = (MDICREATESTRUCT32W *)*plparam;
+ LPSTR name, cls;
if (!(cs = SEGPTR_NEW(MDICREATESTRUCT16))) return -1;
STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCT32A *)cs32, cs );
- if (HIWORD(cs32->szTitle))
- {
- LPSTR name = SEGPTR_ALLOC( lstrlen32W(cs32->szTitle) + 1 );
- STRING32_UniToAnsi( name, cs32->szTitle );
- cs->szTitle = SEGPTR_GET(name);
- }
- else cs->szTitle = (SEGPTR)cs32->szTitle;
- if (HIWORD(cs32->szClass))
- {
- LPSTR name = SEGPTR_ALLOC( lstrlen32W(cs32->szClass) + 1 );
- STRING32_UniToAnsi( name, cs32->szClass );
- cs->szClass = SEGPTR_GET(name);
- }
- else cs->szClass = (SEGPTR)cs32->szClass;
+ name = SEGPTR_STRDUP_WtoA( cs32->szTitle );
+ cls = SEGPTR_STRDUP_WtoA( cs32->szClass );
+ cs->szTitle = SEGPTR_GET(name);
+ cs->szClass = SEGPTR_GET(cls);
*pmsg16 = (UINT16)msg32;
*pwparam16 = (WPARAM16)LOWORD(wParam32);
*plparam = (LPARAM)SEGPTR_GET(cs);
@@ -1439,9 +1443,8 @@
return 1;
case WM_SETTEXT:
{
- LPSTR str = SEGPTR_ALLOC( lstrlen32W((LPWSTR)*plparam) + 1 );
+ LPSTR str = SEGPTR_STRDUP_WtoA( (LPWSTR)*plparam );
if (!str) return -1;
- STRING32_UniToAnsi( str, (LPWSTR)*plparam );
*pmsg16 = (UINT16)msg32;
*pwparam16 = (WPARAM16)LOWORD(wParam32);
*plparam = (LPARAM)SEGPTR_GET(str);
@@ -1467,7 +1470,7 @@
{
LPSTR str = (LPSTR)PTR_SEG_TO_LIN(lParam);
lParam = *((LPARAM *)str - 1);
- STRING32_AnsiToUni( (LPWSTR)lParam, str );
+ lstrcpyAtoW( (LPWSTR)lParam, str );
SEGPTR_FREE( (LPARAM *)str - 1 );
}
break;
