- Wine-Devel - list.winehq.org

Possible printer driver bug
by Jukka Heinonen July 30, 2001

July 30, 2001

Wine compiled from CVS crashes since file "wine/dlls/gdi/driver.c" passes a NULL pointer to function CreateICA. The following patch stops crashing, but since I have no idea how Wine printer drivers work, this patch might be plain wrong. After this patch, Wine no longer crashes, but I haven't been able to test whether printing works or not. Index: wine/dlls/gdi/driver.c =================================================================== RCS file: /home/wine/wine/dlls/gdi/driver.c,v retrieving revision 1.2 diff -u -r1.2 driver.c --- wine/dlls/gdi/driver.c 2001/07/28 00:18:02 1.2 +++ wine/dlls/gdi/driver.c 2001/07/29 14:10:18 @@ -376,7 +376,7 @@ if(!DRIVER_GetDriverName( lpszDevice, buf, sizeof(buf) )) return -1; - if (!(hdc = CreateICA( buf, NULL, lpszPort, NULL ))) return -1; + if (!(hdc = CreateICA( buf, lpszDevice, lpszPort, NULL ))) return -1; if ((dc = DC_GetDCPtr( hdc ))) { -- Jukka Heinonen <http://www.iki.fi/jhei/>

2 1

Hi There
by Robert Laverick July 29, 2001

July 29, 2001

Hi, I'm new to wine and while I've been messing about with it I've not acctualy done anything significant. I'm mostly into Java but picked up some C recently doing some parallel comutational stuff as part of my Final year project as part of my degree. Now I'm officaly Unemployed as apposed to a Student I can give of my time freely. I'd love to get into this, if someone could give me a point at something that needs a good looking at then I'll start there. My biggest motivation is to get to understand this whole thing better and (if I'm luck) get Diablo II running so I don't have to reboot out of linux each time my Girlfriend comes round and demmands to kick my ass. :-) Well thanks in advance and I hope I can prove usefull. Rob PS anyone who want's to be nice enough to offer me a job DO IT NOW PLEASE I'M SKINT!

1 0

Wine Unreal and a strange old problem
by FT Rathore July 29, 2001

July 29, 2001

Hi I have been using wine to play Unreal for a long time, but it would always crash in the start when I play as root or when I have my /dos filsystem mounted rw. It would always blow my mind, but I would fail to catch it. (been happenning for years too). I copied the whole Unreal tree to my ext2 filesystem and tried with different file permissions. I came to reallize that wine will allways crash if the file Unreal.log in Unreal/System is writeable. If I make that file read only, wine works flawlessly and I can do everything including save/load games. I tried to debug it, but the clues were very strange. There is only one message I see before the crash: err:seh:EXC_DefaultHandling Exception frame is not in stack limits => unable to dispatch exception. Besides that there is not much different between the good and the bad traces. I am attaching last 2000 lines of "-debugmsg +all" with this message. Someone might be able to get some sense from the trace. Anything else I sould do? FT

1 0

Re: wnd lock tracing
by Alexandre Julliard July 29, 2001

July 29, 2001

Andreas Mohr <a.mohr(a)mailto.de> writes: > Add a #define DBG_WNDLOCK in order to have reasonable wndlock debugging Please don't add #ifdefs. You should use a debug channel. -- Alexandre Julliard julliard(a)winehq.com

1 0

RE: -DSTRICT warning fixes
by Patrik Stridvall July 29, 2001

July 29, 2001

> Patrik Stridvall <ps(a)leissner.se> writes: > > > Sure Win64 should use 64-bit pointers as handles that is > > without questions, but forcing it on Win32 on 64-bit > > is totally unnessary > > This may be the root of your misunderstanding: there is no such thing > as Win32 on 64-bit platforms. Wine (and Winelib) implement Win32 on > 32-bit platforms, and Win64 on a 64-bit platform. Well, actually Win32 does exist (or rather existed, it has been discontinue by Microsoft) on Alpha. But, never mind, it doesn't matter. The point is somebody has souce code for a Windows application and wishes that it will run on Alpha. He or she doesn't care whether Win32 on 64-bit exists or not he wished to port his application with as little effort as possible. He or she doesn't care what magic Winelib does as long as it works and he has to change the source as little as possible. > If you want to > compile your apps as Win32, you need a 32-bit compiler. Sure thats an idea, but doing that is a little awkard, no 32-bit compiler currently exists for 64-bit platforms AFAIK. While this might work, at least in theory, if you only call the Win32 API, how do you suggest calls to 64-bit Unix libraries should be handled? > Then you use > the same compiler to build Wine as a Win32 library, and everything > works fine. If you use a 64-bit compiler, some types (including > handles) become 64-bit, and you have to deal with it. Since you refuse to make it easier for the porter, sure he or she will have to deal with it, that is pretty obvious isn't it? The question is what can we do to make it easier for the porters. We can almost always say "We don't care, its your problem", so that is not an argument by itself. Sure we can't do the impossible, and some things takes to much effort, but still. > The only possible exception would be running existing Win32 binaries > on ia64. And I'm not even convinced it needs an exception, it's > probably easier to simply build a version of Wine with the 32-bit gcc > than to try to come up with a translation layer. Well, that is a future problem. I don't know exactly how to handle it either, but as you pointed out earlier since we need to convert 32-bit pointers to 64-bit pointers we might as well convert 32-bit handlers to 64-bit handlers the same way. Of course that doesn't mean that being able to compile Winelib with handle as 32-bit integers won't help, but I really can't say whether or not right now.

1 0

Re: -DSTRICT warning fixes
by Alexandre Julliard July 29, 2001

July 29, 2001

Patrik Stridvall <ps(a)leissner.se> writes: > Sure Win64 should use 64-bit pointers as handles that is > without questions, but forcing it on Win32 on 64-bit > is totally unnessary This may be the root of your misunderstanding: there is no such thing as Win32 on 64-bit platforms. Wine (and Winelib) implement Win32 on 32-bit platforms, and Win64 on a 64-bit platform. If you want to compile your apps as Win32, you need a 32-bit compiler. Then you use the same compiler to build Wine as a Win32 library, and everything works fine. If you use a 64-bit compiler, some types (including handles) become 64-bit, and you have to deal with it. The only possible exception would be running existing Win32 binaries on ia64. And I'm not even convinced it needs an exception, it's probably easier to simply build a version of Wine with the 32-bit gcc than to try to come up with a translation layer. -- Alexandre Julliard julliard(a)winehq.com

1 0

toolbar fix
by nog July 29, 2001

July 29, 2001

Hi all, Changelog: Nog <nog(a)sdf.lonestar.org> Don't enable the 'hot' state of a toolbar button when it's not enabled. --- dlls/comctl32/toolbar.c Sun Jul 29 09:08:56 2001 +++ dlls/comctl32/toolbar.c Sun Jul 29 11:41:50 2001 @@ -4123,13 +4123,13 @@ if (nHit >= 0) { btnPtr = &infoPtr->buttons[nHit]; - btnPtr->bHot = TRUE; infoPtr->nHotItem = nHit; /* only enabled buttons show hot effect */ if(infoPtr->buttons[nHit].fsState & TBSTATE_ENABLED) { + btnPtr->bHot = TRUE; InvalidateRect(hwnd, &btnPtr->rect, TOOLBAR_HasText(infoPtr, btnPtr)); }

1 0

RFC: Patch for making GrabPointer work
by Jukka Heinonen July 29, 2001

July 29, 2001

After the following patch DXGrab works again. However, this patch has quite a few potential races, so I am not going to submit this to wine-patches. Storing old windows procedure in struct x11drv_win_data would remove the worst race, but unless window procedure update is atomic, it would not remove all races. I'm starting to think that QueueUserAPC used together with OpenThread (which does exist in Windows 2000/Me, but not yet in Wine) is the correct way to fix DXGrab. Index: wine/dlls/x11drv/x11ddraw.c =================================================================== RCS file: /home/wine/wine/dlls/x11drv/x11ddraw.c,v retrieving revision 1.9 diff -u -r1.9 x11ddraw.c --- wine/dlls/x11drv/x11ddraw.c 2001/06/04 21:55:17 1.9 +++ wine/dlls/x11drv/x11ddraw.c 2001/07/29 13:41:52 @@ -45,20 +45,64 @@ } } -static void GrabPointer(HWND hWnd) -{ +static LRESULT WINAPI GrabWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) +{ Display *display = thread_display(); - if (hWnd) { - /* find the X11 window that ddraw uses */ - Window win = X11DRV_get_whole_window(hWnd); - TRACE("WND: %x win: %ld\n", hWnd, win); - if (!win) { - TRACE("host off desktop\n"); - win = root_window; - } - TSXGrabPointer(display, win, True, 0, GrabModeAsync, GrabModeAsync, win, None, CurrentTime); + + if(message != 0x7777) { + ERR("Unrecognized message %d, expect trouble!\n", message); + return 0; } - else TSXUngrabPointer(display, CurrentTime); + + TRACE("hwnd=%d, grab=%d\n", hWnd, wParam); + + if (wParam) + { + /* find the X11 window that ddraw uses */ + Window win = X11DRV_get_whole_window(hWnd); + TRACE("X11 window: %ld\n", win); + if (!win) { + TRACE("host off desktop\n"); + win = root_window; + } + + TSXGrabPointer(display, win, True, 0, GrabModeAsync, GrabModeAsync, win, None, CurrentTime); + TSXSetInputFocus(display, win, RevertToParent, CurrentTime); + } + else + { + TSXUngrabPointer(display, CurrentTime); + } + + return 0; +} + +static void GrabPointer(HWND hWnd, BOOL grab) +{ + WND* pWnd; + WNDPROC pOldProcedure; + + pWnd = WIN_FindWndPtr(hWnd); + if(!pWnd) + return; + + pOldProcedure = pWnd->winproc; + pWnd->winproc = GrabWndProc; + + WIN_ReleaseWndPtr(pWnd); + + SendMessageA(hWnd, 0x7777, grab ? 1 : 0, 0); + + pWnd = WIN_FindWndPtr(hWnd); + if(!pWnd) + return; + + if(pWnd->winproc != GrabWndProc) + ERR("Window procedure has been changed!\n"); + else + pWnd->winproc = pOldProcedure; + + WIN_ReleaseWndPtr(pWnd); } static DWORD PASCAL X11DRV_DDHAL_DestroyDriver(LPDDHAL_DESTROYDRIVERDATA data) @@ -75,7 +119,7 @@ X11DRV_DD_PrimaryGbl = X11DRV_DD_Primary->lpGbl; SetPrimaryDIB(GET_LPDDRAWSURFACE_GBL_MORE(X11DRV_DD_PrimaryGbl)->hKernelSurface); X11DRV_DD_UserClass = GlobalFindAtomA("WINE_DDRAW"); - if (dxgrab) GrabPointer(X11DRV_DD_PrimaryWnd); + if (dxgrab) GrabPointer(X11DRV_DD_PrimaryWnd, TRUE); } data->ddRVal = DD_OK; return DDHAL_DRIVER_NOTHANDLED; @@ -108,12 +152,12 @@ static DWORD PASCAL X11DRV_DDHAL_DestroySurface(LPDDHAL_DESTROYSURFACEDATA data) { if (data->lpDDSurface == X11DRV_DD_Primary) { + if (dxgrab) GrabPointer(X11DRV_DD_PrimaryWnd, FALSE); X11DRV_DD_Primary = NULL; X11DRV_DD_PrimaryWnd = 0; X11DRV_DD_PrimaryGbl = NULL; SetPrimaryDIB(0); X11DRV_DD_UserClass = 0; - if (dxgrab) GrabPointer(0); } data->ddRVal = DD_OK; return DDHAL_DRIVER_HANDLED; -- Jukka Heinonen <http://www.iki.fi/jhei/>

1 0

RE: -DSTRICT warning fixes
by Patrik Stridvall July 29, 2001

July 29, 2001

> Patrik Stridvall <ps(a)leissner.se> writes: > > > Does the Windows API really define exactly what a handle is? > > typedef void* HANDLE seems pretty clear to me. I was refering some documentation that said that application should always expect a handle to be a pointer. But never mind. Documentation and reality is often different things. > > However your suggestion that any Winelib application that > cares whether > > they are 32-bit or 64-bit are broken is a far too strict > IMHO and I see > > no reason to require porters to fix such things. > > An application that assumes that everything is 32-bit is broken, yes. > I don't see why handles are any different than other types; if > anything they should be less of a problem since they are supposed to > be opaque, so their size should not matter for the application. > > Of course most handles will fit in 32-bit, so we will still support > apps that do invalid casts and truncate the handles; but this doesn't > mean it is correct behavior, or that apps that do this should be able > to compile without warnings. OK, since you agree we should accept handles truncated to 32-bit, it still leaves the problem. Should API calls truncate the handles themselves ie take 32-bit integers as arguments or should they not ie take 64-bit pointers as arguments. There is no particular reason to not accept both and make the actual definition of handle be dependent on some define and leave the choice on whether they want warnings or not to the Winelib developers, not leave them without a choice. Actually we might also consider giving them the option to accept 64-bit integers. In short, the Winelib developers should decide what their application wants (warning wise), we shouldn't. > > So therefor I suggest that we should do the following > > TRACE("(%p)", (LPVOID) handle); > > You must be joking. No, I'm not. However reality forced me to change the solution somewhat. See below. > I said I didn't want any typecast, and here you > suggest to have one on every single debugging output. Well, we have (or should have) a debugstr_[aw]n? on every single string in the debugging output, because we have to. We might not like it, but we have it because we must. > Let me repeat it > once more just in case: *NO* *TYPECASTS*. I know that you said that and I have said that I support that whenever possible, which it fortunately is in the normal cases. > The whole point of STRICT and pointer handles is to be able to use > compiler type checks, and this is only possible without typecasts. Agreed, but there is no self value in having no exceptions on a rule. Remember no type cast is a means no a goal. Debugging output is hardly a critical piece of code so if we can gain something from it we should consider making an exception. But never mind, it turns out that we we needn't make a exception either. See below. > Not > to mention that your solution will probably still get a warning like > "converting integer to pointer of different size" on a 64-bit > platform. Ah, thats a good point. Practice often stand in the way of a good theory. :-( Unfurtunately I think you are right, it is more than probable that the compiler will generate such a warning, I if not now so sometime in the future. Casting to a 32-bit integer to 64-bit pointer is almost always bogus, so there is no reason for the compiler not give a warning epecially since you can do a double cast (32-bit integer to 64-bit integer to 64-bit pointer) if you really mean it. Fortunately the problem is solvable #ifdef __alpha__ #ifdef STRICT #define HANDLE2POINTER(handle) (handle) #else #define HANDLE2POINTER(handle) ((void *) (unsigned long) (handle)) #endif #ifdef STRICT #define HANDLE2POINTER(handle) (handle) #else #define HANDLE2POINTER(handle) ((void *) (handle)) #endif #endif TRACE("(%p)", HANDLE2POINTER(handle)); This solves your problem (at least for 32-bit developers) < The whole point of STRICT and pointer handles is to be able to use < compiler type checks, and this is only possible without typecasts. Francois problem < * Ignore gcc's warnings saying '%x format, pointer argument'. Fixing the format < at this stage would only introduce tons of warnings for the developpers not < participating in the switch (i.e. compiling with STRICT off). as well as my problem. Of course we might consider making it a debug output only construct instead Like s/HANDLE2POINTER/debugptr_handle/ and define it in debugtools.h. Non-debugging parts of Wine shouldn't need to use it either since as I said earlier just pass them long or must use an explict cast to a non-void pointer. Ah, wait a minute we will have "converting integer to pointer of different size" on 64-bit platforms for the actual cast to an object. Of course easily solved with a similar #ifdef __alpha__ #define HANDLE2OBJECT(type, handle) ((type *) (unsigned long) (handle)) #else #define HANDLE2OBJECT(type, handle) ((type *) (handle)) #endif but perhaps we should have the HANDLE2POINTER (debugptr_handle) in debugtools.h all the same, nobody else is intrested in a void pointer anyway. Of course, nothing forces us to define handles as the same both internally and externally. At least Alpha AFAIK will be binary compatible all the same, so we might not even need this. Oh well having to always using HANDLE2OBJECT is a small price to pay all the same and makes it possible for us to do adjustments on other 64-bit platforms if need be. And yes, I'm serious. My inital solutions wasn't so good, but thanks to your feedback I have managed to refine it to a much better solution, that I think actually works in reality. And yes, I still consider the 64-bit problem a real problem, you just tries to dismiss the problem by simply saying, that is the Winelib developers problem. Sure we could do that but, remember that Winelib is meant to help developers port application not make it more difficult by trying to enforce unnessary restriction on the code. Sure Win64 should use 64-bit pointers as handles that is without questions, but forcing it on Win32 on 64-bit is totally unnessary, especially since I now finally after your feedback managed to find a solution that solve all your stated problems (remember that no type casts is a means not a goal and actually there will be no type casts on 32-bit (-DSTRICT) either). But perhaps you can see any flaws in this refined solution as well?

1 0

Re: -DSTRICT warning fixes
by Alexandre Julliard July 28, 2001

July 28, 2001

Patrik Stridvall <ps(a)leissner.se> writes: > Does the Windows API really define exactly what a handle is? typedef void* HANDLE seems pretty clear to me. > However your suggestion that any Winelib application that cares whether > they are 32-bit or 64-bit are broken is a far too strict IMHO and I see > no reason to require porters to fix such things. An application that assumes that everything is 32-bit is broken, yes. I don't see why handles are any different than other types; if anything they should be less of a problem since they are supposed to be opaque, so their size should not matter for the application. Of course most handles will fit in 32-bit, so we will still support apps that do invalid casts and truncate the handles; but this doesn't mean it is correct behavior, or that apps that do this should be able to compile without warnings. > So therefor I suggest that we should do the following > TRACE("(%p)", (LPVOID) handle); You must be joking. I said I didn't want any typecast, and here you suggest to have one on every single debugging output. Let me repeat it once more just in case: *NO* *TYPECASTS*. The whole point of STRICT and pointer handles is to be able to use compiler type checks, and this is only possible without typecasts. Not to mention that your solution will probably still get a warning like "converting integer to pointer of different size" on a 64-bit platform. -- Alexandre Julliard julliard(a)winehq.com

1 0