Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[blurymind]

Well here it is: http://vectorlinux.osuosl.org/Uelsk8s/linuxwacom-0.8.0-3-i586-1vl59.tlz

If it works Ill finish up the buildscript and upload it to the repo

thanks.I'll test it right away.

Its too bad you dont have a stylus.

[blurymind]

damn,whats wrong with this driver.How did ubuntu and mandriva team managed to get it right? 

the values on wacdump are frozen
pressure sensitivity still does not work in wine. Thanks for trying...it still works in gimp though,but gimp's not enought for me.I need artrage again. =(

On a relate note,this problem occured with ubuntu too for a while:

https://bugs.launchpad.net/ubuntu/+source/wine/+bug/151448

but they fixed it on gutsy gibbon somehow (works,tested it)

what did they do to their driver?

it seems that again,hardy heron has the same problem with the dead stats in wacdump and the lack of pressure in wine:

http://ubuntuforums.org/showthread.php?t=745102
i'm going to try this patch before i go to sleep

my next best guess is that theres nothing wrong with the driver, only wine guys need to some time to get things updated to the bleeding edge.
I would say uel,its fine for the repo...if you could also add this symlink file :

/etc/udev/rules.d/10-wacom.rules

Code: [Select]

KERNEL=="event*", ATTRS{idVendor}=="056a", NAME="input/%k", SYMLINK+="input/wacom" and somehow add the default lines in xorg.conf (or maybe just the first) , it would make a pretty sweet addition!

[exeterdad]

By the info in the links you just gave, it would appear the driver is fine.  You said it's working with Gimp.  Looks like another case of something not working quite right with wine running a windows app?  I guess you can try to patch your wine as mentioned in the links?

[blurymind]

By the info in the links you just gave, it would appear the driver is fine.  You said it's working with Gimp.  Looks like another case of something not working quite right with wine running a windows app?  I guess you can try to patch your wine as mentioned in the links?

yeah,this is new info for me.Makes me think that wine devs just need to catch up a bit...
but yet wacdump application's behaviour doesnt speak for a healthy driver,and in my case xidump -l states "extended" instead of "unknown"
and xsetpointer -l is a command not found.

i am recompiling wine with the patch applied as we speak.Will let you know asap.

[exeterdad]

Wish I could help you my friend.  But I've never been able to get my hands on a Wacom tablet.  I do want one.  But what you and Uel have been posting about may as well be Martian since I don't know a thing about them.

[blurymind]

YES! SUCESS!

After months this problem was located and fixed.After applying the patch:

patch.file:
http://azure.freehost.pl/patch.file
backup code of the patch (in case the link goes down)

Code: [Select]

*** dlls/winex11.drv/xdnd.c 2008-04-18 17:47:52.000000000 +0200
--- xdnd.c1 2008-04-24 16:11:23.000000000 +0200
***************
*** 21,26 ****
--- 21,28 ----
 
  #include "config.h"
  #include "wine/port.h"
+ #define COBJMACROS
+ #include <initguid.h>
 
  #include <string.h>
  #ifdef HAVE_UNISTD_H
***************
*** 36,41 ****
--- 38,45 ----
 
  #include "x11drv.h"
  #include "shlobj.h"  /* DROPFILES */
+ #include "oleidl.h"
+ #include "objidl.h"
 
  #include "wine/unicode.h"
  #include "wine/debug.h"
***************
*** 57,62 ****
--- 61,70 ----
 
  static LPXDNDDATA XDNDData = NULL;
  static POINT XDNDxy = { 0, 0 };
+ extern IDataObject xdndDataObject;
+ static BOOL XDNDEntered = FALSE;
+ static BOOL XDNDAccepted = FALSE;
+ static DWORD XDNDDropEffect = DROPEFFECT_NONE;
 
  static void X11DRV_XDND_InsertXDNDData(int property, int format, void* data, unsigned int len);
  static int X11DRV_XDND_DeconstructTextURIList(int property, void* data, int len);
***************
*** 69,74 ****
--- 77,86 ----
  static void X11DRV_XDND_FreeDragDropOp(void);
  static unsigned int X11DRV_XDND_UnixToDos(char** lpdest, char* lpsrc, int len);
  static WCHAR* X11DRV_XDND_URIToDOS(char *encodedURI);
+ static DROPFILES* X11DRV_XDND_BuildDropFiles(char* filename, unsigned int len, POINT pt);
+ static void X11DRV_XDND_DescribeClipboardFormat(int cfFormat, char *buffer, int size);
+ static DWORD X11DRV_XDND_ActionToDROPEFFECT(long action);
+ static long X11DRV_XDND_DROPEFFECTToAction(DWORD effect);
 
  static CRITICAL_SECTION xdnd_cs;
  static CRITICAL_SECTION_DEBUG critsect_debug =
***************
*** 150,163 ****
  {
      XClientMessageEvent e;
      int accept = 0; /* Assume we're not accepting */
!
      XDNDxy.x = event->data.l[2] >> 16;
      XDNDxy.y = event->data.l[2] & 0xFFFF;
 
!     /* FIXME: Notify OLE of DragEnter. Result determines if we accept */
 
      if (GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)
          accept = 1;
 
      TRACE("action req: %ld accept(%d) at x(%d),y(%d)\n",
            event->data.l[4], accept, XDNDxy.x, XDNDxy.y);
--- 162,234 ----
  {
      XClientMessageEvent e;
      int accept = 0; /* Assume we're not accepting */
!     HMODULE ole32;
!     IDropTarget *dropTarget = NULL;
!     DWORD effect;
!     POINTL pointl;
! 
      XDNDxy.x = event->data.l[2] >> 16;
      XDNDxy.y = event->data.l[2] & 0xFFFF;
 
!         pointl.x = XDNDxy.x;
!         pointl.y = XDNDxy.y;
!     
!         effect = X11DRV_XDND_ActionToDROPEFFECT(event->data.l[4]);
!     
!         /* Notify OLE of DragEnter. Result determines if we accept */
!         ole32 = GetModuleHandleA("OLE32.DLL");
!         if (ole32)
!         {
!             IDropTarget *(CDECL *wine_oledd_find_drop_target)(HWND) = (void*)
!                 GetProcAddress(ole32, "wine_oledd_find_drop_target");
!             if (wine_oledd_find_drop_target)
!             {
!             dropTarget = wine_oledd_find_drop_target(hWnd);
!                 if (dropTarget)
!                 {
!                     HRESULT hr;
!                     if (XDNDEntered == FALSE)
!                     {
!                         XDNDEntered = TRUE;
!                         hr = IDropTarget_DragEnter(dropTarget, &xdndDataObject,
!                                                    MK_LBUTTON, pointl, &effect);
!                         if (SUCCEEDED(hr))
!                         {
!                             if (effect != DROPEFFECT_NONE)
!                             {
!                                 XDNDAccepted = TRUE;
!                                 TRACE("the application accepted the drop\n");
!                             }
!                             else
!                                 TRACE("the application refused the drop\n");
!                         }
!                         else
!                             WARN("IDropTarget_DragEnter failed, error 0x%X\n", hr);
!                     }
!                 }
!                 else
!                     TRACE("no drop target\n");
!             }
!             else
!                 WARN("wine_oledd_find_drop_target not found\n");
!         }
!         else
!             WARN("loading ole32 failed\n");
!         if (XDNDAccepted)
!             accept = 1;
 
      if (GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)
          accept = 1;
+     /* If drag accepted notify OLE of DragOver */
+     if (dropTarget && accept)
+     {
+         HRESULT hr = IDropTarget_DragOver(dropTarget, MK_LBUTTON, pointl, &effect);
+         if (SUCCEEDED(hr))
+             XDNDDropEffect = effect;
+         else
+             WARN("IDropTarget_DragOver failed, error 0x%X\n", hr);
+     }
+
 
      TRACE("action req: %ld accept(%d) at x(%d),y(%d)\n",
            event->data.l[4], accept, XDNDxy.x, XDNDxy.y);
***************
*** 176,188 ****
      e.data.l[2] = 0; /* Empty Rect */
      e.data.l[3] = 0; /* Empty Rect */
      if (accept)
!         e.data.l[4] = event->data.l[4];
!     else
          e.data.l[4] = None;
      wine_tsx11_lock();
      XSendEvent(event->display, event->data.l[0], False, NoEventMask, (XEvent*)&e);
      wine_tsx11_unlock();
 
      /* FIXME: if drag accepted notify OLE of DragOver */
  }
 
--- 247,260 ----
      e.data.l[2] = 0; /* Empty Rect */
      e.data.l[3] = 0; /* Empty Rect */
      if (accept)
!         e.data.l[4] = X11DRV_XDND_DROPEFFECTToAction(effect);
! else
          e.data.l[4] = None;
      wine_tsx11_lock();
      XSendEvent(event->display, event->data.l[0], False, NoEventMask, (XEvent*)&e);
      wine_tsx11_unlock();
 
+     XDNDEntered = XDNDAccepted = FALSE;
      /* FIXME: if drag accepted notify OLE of DragOver */
  }
 
***************
*** 194,207 ****
  void X11DRV_XDND_DropEvent( HWND hWnd, XClientMessageEvent *event )
  {
      XClientMessageEvent e;
!
      TRACE("\n");
 
      /* If we have a HDROP type we send a WM_ACCEPTFILES.*/
      if (GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)
          X11DRV_XDND_SendDropFiles( hWnd );
 
!     /* FIXME: Notify OLE of Drop */
      X11DRV_XDND_FreeDragDropOp();
 
      /* Tell the target we are finished. */
--- 266,317 ----
  void X11DRV_XDND_DropEvent( HWND hWnd, XClientMessageEvent *event )
  {
      XClientMessageEvent e;
!     HMODULE ole32;
!     
      TRACE("\n");
 
      /* If we have a HDROP type we send a WM_ACCEPTFILES.*/
      if (GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)
          X11DRV_XDND_SendDropFiles( hWnd );
 
!
!     /* Notify OLE of Drop */
!     ole32 = GetModuleHandleA("OLE32.DLL");
!     if (ole32)
!     {
!         IDropTarget *(CDECL *wine_oledd_find_drop_target)(HWND) = (void*)
!             GetProcAddress(ole32, "wine_oledd_find_drop_target");
!         if (wine_oledd_find_drop_target)
!         {
!             IDropTarget *dropTarget = wine_oledd_find_drop_target(hWnd);
!             if (dropTarget)
!             {
!                 HRESULT hr;
!                 POINTL pointl;
!                 DWORD effect = XDNDDropEffect;
!
!                 pointl.x = XDNDxy.x;
!                 pointl.y = XDNDxy.y;
!                 hr = IDropTarget_Drop(dropTarget, &xdndDataObject, MK_LBUTTON,
!                                       pointl, &effect);
!                 if (SUCCEEDED(hr))
!                 {
!                     if (effect != DROPEFFECT_NONE)
!                         TRACE("drop succeeded\n");
!                     else
!                         TRACE("the application refused the drop\n");
!                 }
!                 else
!                     WARN("drop failed, error 0x%X\n", hr);
!             }
!             else
!                 TRACE("no drop target\n");
!         }
!         else
!             WARN("wine_oledd_find_drop_target failed\n");
!     }
!     else
!         WARN("failed loading ole32\n");
      X11DRV_XDND_FreeDragDropOp();
 
      /* Tell the target we are finished. */
***************
*** 224,234 ****
   */
  void X11DRV_XDND_LeaveEvent( HWND hWnd, XClientMessageEvent *event )
  {
      TRACE("DND Operation canceled\n");
 
      X11DRV_XDND_FreeDragDropOp();
 
!     /* FIXME: Notify OLE of DragLeave */
  }
 
 
--- 334,370 ----
   */
  void X11DRV_XDND_LeaveEvent( HWND hWnd, XClientMessageEvent *event )
  {
+     HMODULE ole32;
      TRACE("DND Operation canceled\n");
 
      X11DRV_XDND_FreeDragDropOp();
 
!         /* Notify OLE of DragLeave */
!         ole32 = GetModuleHandleA("OLE32.DLL");
!         if (ole32)
!         {
!             IDropTarget *(CDECL *wine_oledd_find_drop_target)(HWND) = (void*)
!                 GetProcAddress(ole32, "wine_oledd_find_drop_target");
!             if (wine_oledd_find_drop_target)
!             {
!                 IDropTarget *dropTarget = wine_oledd_find_drop_target(hWnd);
!                 if (dropTarget)
!                 {
!                     HRESULT hr = IDropTarget_DragLeave(dropTarget);
!                     if (FAILED(hr))
!                         WARN("IDropTarget_DragLeave failed, error 0x%X\n", hr);
!                 }
!                 else
!                     TRACE("drop target not found\n");
!             }
!             else
!                 WARN("wine_oledd_find_drop_target not found\n");       
!         }
!         else
!             WARN("loading ole32 failed\n");
!     
!         XDNDEntered = XDNDAccepted = FALSE;
!     
  }
 
 
***************
*** 248,254 ****
      unsigned long bytesret, icount;
      int entries = 0;
      unsigned char* data = NULL;
!
      TRACE("count(%ld)\n", *count);
 
      X11DRV_XDND_FreeDragDropOp(); /* Clear previously cached data */
--- 384,392 ----
      unsigned long bytesret, icount;
      int entries = 0;
      unsigned char* data = NULL;
!     XDNDDATA *previous = NULL;
!     XDNDDATA *current, *next;
!     BOOL haveHDROP = FALSE;
      TRACE("count(%ld)\n", *count);
 
      X11DRV_XDND_FreeDragDropOp(); /* Clear previously cached data */
***************
*** 291,297 ****
--- 429,493 ----
          XFree(data);
          wine_tsx11_unlock();
      }
+     /* We get the list of formats in descending order of preference, yet the linked
+      * list is a stack so the order is inverted. Reverse the linked list here so
+      * that we get the right order.
+      */
+     current = XDNDData;
+     while (current != NULL)
+     {
+         next = current->next;
+         current->next = previous;
+     previous = current;
+         current = next;
+     }
+     if (previous)
+         XDNDData = previous;
 
+     /* On Windows when there is a CF_HDROP, there is no other CF_ formats.
+      * foobar2000 relies on this (spaces -> %20's without it).
+      */
+     current = XDNDData;
+     while (current != NULL)
+     {
+         if (current->cf_win == CF_HDROP)
+         {
+             haveHDROP = TRUE;
+             break;
+         }
+         current = current->next;
+     }
+     if (haveHDROP)
+     {
+         current = XDNDData;
+         while (current != NULL
+             && current->cf_win != CF_HDROP
+             && current->cf_win < CF_MAX)
+         {
+             next = current->next;
+             HeapFree(GetProcessHeap(), 0, current->data);
+             HeapFree(GetProcessHeap(), 0, current);
+         current = next;
+             --entries;
+         }
+     XDNDData = previous = current;
+         while (current != NULL)
+         {
+             current = current->next;
+             while (current != NULL
+                 && current->cf_win != CF_HDROP
+                 && current->cf_win < CF_MAX)
+             {
+                 next = current->next;
+                 HeapFree(GetProcessHeap(), 0, current->data);
+                 HeapFree(GetProcessHeap(), 0, current);
+                 current = next;
+                 --entries;
+             }
+             previous->next = current;
+             previous = current;
+         }
+     }
      *count = entries;
  }
 
***************
*** 655,657 ****
--- 851,1164 ----
      HeapFree(GetProcessHeap(), 0, uri);
      return ret;
  }
+ /**************************************************************************
+  * X11DRV_XDND_DescribeClipboardFormat
+  */
+ static void X11DRV_XDND_DescribeClipboardFormat(int cfFormat, char *buffer, int size)
+ {
+ #define D(x) case x: lstrcpynA(buffer, #x, size); return;
+     switch (cfFormat)
+     {
+         D(CF_TEXT)
+         D(CF_BITMAP)
+         D(CF_METAFILEPICT)
+         D(CF_SYLK)
+         D(CF_DIF)
+         D(CF_TIFF)
+         D(CF_OEMTEXT)
+         D(CF_DIB)
+         D(CF_PALETTE)
+         D(CF_PENDATA)
+     D(CF_RIFF)
+         D(CF_WAVE)
+         D(CF_UNICODETEXT)
+         D(CF_ENHMETAFILE)
+         D(CF_HDROP)
+         D(CF_LOCALE)
+         D(CF_DIBV5)
+     }
+ #undef D
+
+     if (CF_PRIVATEFIRST <= cfFormat && cfFormat <= CF_PRIVATELAST)
+     {
+         GetClipboardFormatNameA(cfFormat, buffer, size);
+         return;
+     }
+
+     if (CF_GDIOBJFIRST <= cfFormat && cfFormat <= CF_GDIOBJLAST)
+     {
+         lstrcpynA(buffer, "some GDI object", size);
+         return;
+     }
+
+     snprintf(buffer, size, "unknown format %d", cfFormat);
+ }
+
+
+ /**************************************************************************
+  * X11DRV_XDND_ActionToDROPEFFECT
+  */
+ static DWORD X11DRV_XDND_ActionToDROPEFFECT(long action)
+ {
+     /* In Windows, nothing but the given effects is allowed.
+      * In X the given action is just a hint, and you can always
+      * XdndActionCopy and XdndActionPrivate, so be more permissive. */
+     if (action == x11drv_atom(XdndActionCopy))
+     return DROPEFFECT_COPY;
+     else if (action == x11drv_atom(XdndActionMove))
+         return DROPEFFECT_MOVE | DROPEFFECT_COPY;
+     else if (action == x11drv_atom(XdndActionLink))
+         return DROPEFFECT_LINK | DROPEFFECT_COPY;
+     else if (action == x11drv_atom(XdndActionAsk))
+         /* FIXME: should we somehow ask the user what to do here? */
+         return DROPEFFECT_COPY | DROPEFFECT_MOVE | DROPEFFECT_LINK;
+     FIXME("unknown action %ld, assuming DROPEFFECT_COPY\n", action);
+     return DROPEFFECT_COPY;
+ }
+
+
+ /**************************************************************************
+  * X11DRV_XDND_DROPEFFECTToAction
+  */
+ static long X11DRV_XDND_DROPEFFECTToAction(DWORD effect)
+ {
+     if (effect == DROPEFFECT_COPY)
+         return x11drv_atom(XdndActionCopy);
+     else if (effect == DROPEFFECT_MOVE)
+         return x11drv_atom(XdndActionMove);
+     else if (effect == DROPEFFECT_LINK)
+         return x11drv_atom(XdndActionLink);
+     FIXME("unknown drop effect %u, assuming XdndActionCopy\n", effect);
+     return x11drv_atom(XdndActionCopy);
+ }
+
+
+ /* The IDataObject singleton we feed to OLE follows */
+
+ static HRESULT WINAPI DATAOBJECT_QueryInterface(IDataObject *dataObject,
+                                                 REFIID riid, void **ppvObject)
+ {
+     TRACE("(%p, %s, %p)\n", dataObject, debugstr_guid(riid), ppvObject);
+     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDataObject))
+     {
+         *ppvObject = dataObject;
+         IDataObject_AddRef(dataObject);
+         return S_OK;
+     }
+     *ppvObject = NULL;
+     return E_NOINTERFACE;
+ }
+
+ static ULONG WINAPI DATAOBJECT_AddRef(IDataObject *dataObject)
+ {
+     TRACE("(%p)\n", dataObject);
+     return 2;
+ }
+
+ static ULONG WINAPI DATAOBJECT_Release(IDataObject *dataObject)
+ {
+     TRACE("(%p)\n", dataObject);
+     return 1;
+ }
+
+ static HRESULT WINAPI DATAOBJECT_GetData(IDataObject *dataObject,
+                                          FORMATETC *formatEtc,
+                                          STGMEDIUM *pMedium)
+ {
+     XDNDDATA *data = XDNDData;
+     HRESULT hr;
+     char buffer[1024];
+
+     TRACE("(%p, %p, %p)\n", dataObject, formatEtc, pMedium);
+     X11DRV_XDND_DescribeClipboardFormat(formatEtc->cfFormat,
+                                         buffer, sizeof(buffer));
+     TRACE("application is looking for %s\n", buffer);
+
+     hr = IDataObject_QueryGetData(dataObject, formatEtc);
+     if (SUCCEEDED(hr))
+     {
+         while (data != NULL)
+         {
+             if (data->cf_win == formatEtc->cfFormat)
+             {
+                 pMedium->tymed = TYMED_HGLOBAL;
+                 pMedium->hGlobal = HeapAlloc(GetProcessHeap(), 0, data->size);
+                 if (pMedium->hGlobal == NULL)
+                     return E_OUTOFMEMORY;
+                 memcpy(pMedium->hGlobal, data->data, data->size);
+                 pMedium->pUnkForRelease = 0;
+                 return S_OK;
+             }
+             data = data->next;
+         }
+     }
+     return hr;
+ }
+
+ static HRESULT WINAPI DATAOBJECT_GetDataHere(IDataObject *dataObject,
+                                              FORMATETC *formatEtc,
+                                              STGMEDIUM *pMedium)
+ {
+     FIXME("(%p, %p, %p): stub\n", dataObject, formatEtc, pMedium);
+     return DATA_E_FORMATETC;
+ }
+
+ static HRESULT WINAPI DATAOBJECT_QueryGetData(IDataObject *dataObject,
+                                               FORMATETC *formatEtc)
+ {
+     XDNDDATA *data = XDNDData;
+     char buffer[1024];
+
+     TRACE("(%p, %p)\n", dataObject, formatEtc);
+     X11DRV_XDND_DescribeClipboardFormat(formatEtc->cfFormat, buffer,
+                                         sizeof(buffer));
+
+     if (formatEtc->tymed != TYMED_HGLOBAL)
+ {
+         FIXME("only HGLOBAL medium types supported right now\n");
+         return E_NOTIMPL;
+     }
+     if (formatEtc->dwAspect != DVASPECT_CONTENT)
+     {
+         FIXME("only the content aspect is supported right now\n");
+         return E_NOTIMPL;
+     }
+
+     while (data != NULL)
+     {
+         if (data->cf_win == formatEtc->cfFormat)
+         {
+             TRACE("application found %s\n", buffer);
+             return S_OK;
+         }
+         data = data->next;
+     }
+     TRACE("application didn't find %s\n", buffer);
+     return DV_E_FORMATETC;
+ }
+
+ static HRESULT WINAPI DATAOBJECT_GetCanonicalFormatEtc(IDataObject *dataObject,
+                                                        FORMATETC *formatEtc,
+                                                        FORMATETC *formatEtcOut)
+ {
+     FIXME("(%p, %p, %p): stub\n", dataObject, formatEtc, formatEtcOut);
+     formatEtcOut->ptd = NULL;
+     return E_NOTIMPL;
+ }
+
+ static HRESULT WINAPI DATAOBJECT_SetData(IDataObject *dataObject,
+                                          FORMATETC *formatEtc,
+                                          STGMEDIUM *pMedium, BOOL fRelease)
+ {
+     FIXME("(%p, %p, %p, %s): stub\n", dataObject, formatEtc,
+         pMedium, fRelease?"TRUE":"FALSE");
+     return E_NOTIMPL;
+ }
+
+ static HRESULT WINAPI DATAOBJECT_EnumFormatEtc(IDataObject *dataObject,
+                                                DWORD dwDirection,
+                                                IEnumFORMATETC *ppEnumFormatEtc)
+ {
+     HMODULE shell32;
+     XDNDDATA *data = XDNDData;
+     int i;
+     DWORD count = 0;
+     FORMATETC *formats;
+     HRESULT hr;
+
+     TRACE("(%u, %p)\n", dwDirection, ppEnumFormatEtc);
+
+     if (dwDirection != DATADIR_GET)
+     {
+         FIXME("only the get direction is implemented\n");
+         return E_NOTIMPL;
+     }
+
+     while (data != NULL)
+     {
+         data = data->next;
+         ++count;
+     }
+
+     formats = HeapAlloc(GetProcessHeap(), 0, count * sizeof(FORMATETC));
+     if (formats)
+     {
+         data = XDNDData;
+         for (i = 0; i < count; ++i)
+         {
+             formats[i].cfFormat = data->cf_win;
+             formats[i].ptd = NULL;
+             formats[i].dwAspect = DVASPECT_CONTENT;
+             formats[i].lindex = -1;
+             formats[i].tymed = TYMED_HGLOBAL;
+             data = data->next;
+         }
+         /* For some strange reason, load-time linking SHELL32.DLL to WINEX11.DRV
+          * causes wine to segfault on startup. So rather use run-time linking.
+          */
+         shell32 = LoadLibraryA("SHELL32.DLL");
+         if (shell32)
+         {
+             HRESULT (WINAPI *SHCreateStdEnumFmtEtc)(DWORD, FORMATETC*, IEnumFORMATETC**) = (void*)
+                 GetProcAddress(shell32, (char*) MAKELONG(74, 0));
+             if (SHCreateStdEnumFmtEtc)
+                 hr = SHCreateStdEnumFmtEtc(count, formats, ppEnumFormatEtc);
+             else
+             {
+                 ERR("symbol lookup of SHCreateStdEnumFmtEtc failed\n");
+                 hr = E_FAIL;
+             }
+         }
+         else
+         {
+             WARN("loading SHELL32.DLL failed\n");
+             hr = E_FAIL;
+         }
+         HeapFree(GetProcessHeap(), 0, formats);
+         return hr;
+     }
+     else
+         return E_OUTOFMEMORY;
+ }
+
+ static HRESULT WINAPI DATAOBJECT_DAdvise(IDataObject *dataObject,
+                                          FORMATETC *formatEtc, DWORD advf,
+                                          IAdviseSink *adviseSink,
+                                          DWORD *pdwConnection)
+ {
+     FIXME("(%p, %p, %u, %p, %p): stub\n", dataObject, formatEtc, advf,
+         adviseSink, pdwConnection);
+     return OLE_E_ADVISENOTSUPPORTED;
+ }
+
+ static HRESULT WINAPI DATAOBJECT_DUnadvise(IDataObject *dataObject,
+                                            DWORD dwConnection)
+ {
+     FIXME("(%p, %u): stub\n", dataObject, dwConnection);
+     return OLE_E_ADVISENOTSUPPORTED;
+ }
+
+ static HRESULT WINAPI DATAOBJECT_EnumDAdvise(IDataObject *dataObject,
+                                              IEnumSTATDATA **pEnumAdvise)
+ {
+     FIXME("(%p, %p): stub\n", dataObject, pEnumAdvise);
+     return OLE_E_ADVISENOTSUPPORTED;
+ }
+
+ static IDataObjectVtbl xdndDataObjectVtbl =
+ {
+     DATAOBJECT_QueryInterface,
+     DATAOBJECT_AddRef,
+     DATAOBJECT_Release,
+     DATAOBJECT_GetData,
+     DATAOBJECT_GetDataHere,
+     DATAOBJECT_QueryGetData,
+     DATAOBJECT_GetCanonicalFormatEtc,
+     DATAOBJECT_SetData,
+     DATAOBJECT_EnumFormatEtc,
+     DATAOBJECT_DAdvise,
+     DATAOBJECT_DUnadvise,
+     DATAOBJECT_EnumDAdvise
+ };
+
+ IDataObject xdndDataObject = { &xdndDataObjectVtbl };

*** dlls/ole32/ole2.c 2008-04-18 17:47:52.000000000 +0200
--- ole2.c 2008-04-24 09:24:26.000000000 +0200
***************
*** 1940,1945 ****
--- 1940,1953 ----
    return NULL;
  }
 
+ IDropTarget* wine_oledd_find_drop_target(HWND hwndOfTarget)
+ {
+     DropTargetNode *node = OLEDD_FindDropTarget(hwndOfTarget);
+     if (node)
+         return node->dropTarget;
+     return NULL;
+ }
+
  /***
   * OLEDD_DragTrackerWindowProc()
   *
*** dlls/ole32/ole32.spec 2008-04-18 17:47:52.000000000 +0200
--- ole32.spec 2008-04-24 00:21:38.000000000 +0200
***************
*** 277,279 ****
--- 277,281 ----
  @ stdcall WriteFmtUserTypeStg(ptr long ptr)
  @ stub WriteOleStg
  @ stub WriteStringStream
+ @ cdecl wine_oledd_find_drop_target(long)
+
*** dlls/winex11.drv/wintab.c 2008-04-18 17:47:52.000000000 +0200
--- winetab.c1 2008-04-21 19:51:48.000000000 +0200
417,430c417,420
<     int i;
<     static const char* tablet_stylus_whitelist[] = {
<         "stylus",
<         "wizardpen",
<         NULL
<     };
<
<     for (i=0; tablet_stylus_whitelist[i] != NULL; i++) {
<         if (name && match_token(name, tablet_stylus_whitelist[i]))
<             return TRUE;
<         if (type && match_token(type, tablet_stylus_whitelist[i]))
<             return TRUE;
<     }
<
---
>     if (name && match_token(name, "stylus"))
>         return TRUE;
>     if (type && match_token(type, "stylus"))
>         return TRUE;
526d515
<         LPWTI_CURSORS_INFO cursor;
528c517
<         TRACE("Device %i:  [id %d|name %s|type %s|num_classes %d|use %d]\n",
---
>         TRACE("Device %i:  [id %d|name %s|type %s|num_classes %d|use %s]\n",
530c519,524
<                 devices[loop].num_classes, devices[loop].use );
---
>                 devices[loop].num_classes,
>                 devices[loop].use == IsXKeyboard ? "IsXKeyboard" :
>                     devices[loop].use == IsXPointer ? "IsXPointer" :
>                     devices[loop].use == IsXExtensionDevice ? "IsXExtensionDevice" :
>                     "Unknown"
>                 );
532,538c526,529
<         switch (devices[loop].use)
<         {
<         case IsXExtensionDevice:
< #ifdef IsXExtensionPointer
<         case IsXExtensionPointer:
< #endif
<             TRACE("Is XExtension%s\n", (devices[loop].use == IsXExtensionDevice)? "Device":"Pointer");
---
>         
>             LPWTI_CURSORS_INFO cursor;
>
>             TRACE("Is Extension Device\n");
547c538,539
<                 break;
---
>                 XFree(device_type);
>                 continue;
565c557,558
<                     break;
---
>                     XFree(device_type);
>                     continue;
579c572,573
<                 break;
---
>                 XFree(device_type);
>                 continue;
586a581
>                 XFree(device_type);
588c583
<                 break;
---
>                 continue;
627c622
<                         if (!axis_read_complete && cursor->TYPE == CSR_TYPE_PEN)
---
>                         if (!axis_read_complete && Val->num_axes >= 5 && cursor->TYPE == CSR_TYPE_PEN)
723,724c718
<             break;
<         }
---
>         
726a721
>
on wine 0.9.61 and recompiling it, pressure sensitivity in wine works under vector linux.

I would like to thank uelesk8s for the package of the driver- it works perfect.

wacdump still doesnt work,but i dont need it anyway.Wine works with tablets once again,yaaay...

Hopefully when ubuntu 8 gets to stable these issues will be fixed in the code on next wine/wacom tablet driver.I will keep you updated in this topic with info that i find on the subject.

Thanks to everybody ,you guys made this possible.
Thanks to ubuntu community for the patch

question:
do you want me to make a package of the patched version of wine?
I am going to make a howto set wacom tablet tomorow.

[uelsk8s]

did you try the latest wine to see if the patch has already made it upstream?
Wine is at 1.0RC2 now

[M0E-lnx]

congratulations. Nice to hear you've won the battle at last

[blurymind]

did you try the latest wine to see if the patch has already made it upstream?
Wine is at 1.0RC2 now

yes i did.The patch wasnt applied in wine 1.0rc2

Moe-thanks =) Im really glad im back to vector.I wanna make some new packages to celebrate it.

[M0E-lnx]

did you try the latest wine to see if the patch has already made it upstream?
Wine is at 1.0RC2 now

yes i did.The patch wasnt applied in wine 1.0rc2

Moe-thanks =) Im really glad im back to vector.I wanna make some new packages to celebrate it.

Nice to have you back buddy.
I can't believe we had lost a user because of something this simple

[blurymind]

did you try the latest wine to see if the patch has already made it upstream?
Wine is at 1.0RC2 now

yes i did.The patch wasnt applied in wine 1.0rc2

Moe-thanks =) Im really glad im back to vector.I wanna make some new packages to celebrate it.

Nice to have you back buddy.
I can't believe we had lost a user because of something this simple

hehe thanks. Its something this small that can be that important to a single user to switch temporarily..
If you have tablet and its pressure sensitivity doesnt work, its like having a guitar that lacks half of its strings.I just need to have it on every graphic drawing application that supports it.

Now that i'm here,im starting to feel the difference again.Compared to the bloated distros that had all the "out of the box" use experience, this baby is flying, i have all the development libraries,that were cut out to preserve hd space in other distros, and its easier and faster it seems to do just about anything.

[M-ake]

Congraz blurymind. Can you try this one app for me ? About how well it works with wine && tablet http://sai.detstwo.com/sai/#

"PaintTool SAI English Pack 1.0 Full (1.67 mb)" is the thing u want (:. Lemme tell u, it spanks open canvas IMO as a painting app.

[blurymind]

Congraz blurymind. Can you try this one app for me ? About how well it works with wine && tablet http://sai.detstwo.com/sai/#

"PaintTool SAI English Pack 1.0 Full (1.67 mb)" is the thing u want (:. Lemme tell u, it spanks open canvas IMO as a painting app.

ahahahahahahahahaa 

I've tried it long time ago my friend. In fact,I'm its appDB maintainer there:

http://appdb.winehq.org/objectManager.php?sClass=version&iId=11044
(theodore) the screenshot there is mine..

also,i filed a bug report here:
http://bugs.winehq.org/show_bug.cgi?id=11846

and wine dev heroes have looked into getting pressure sensitivity to work. Post a comment there or vote for sai..It might get the attention of devs to sai more.

the problem with sai is that it has its own tablet driver, Dan Kegel is trying to figure out how that thing works.Other than that its working perfectly fine in wine.I hope they get pressure working in sai soon.I love that app.


here is my patched version of wine:
http://blurymind.googlepages.com/wine-0.9.61-i386-1.tlz
pressure works in artrage and photoshop,but in open canvas its messed with this patch.

[blurymind]

i made the promissed howto here:

http://www.vectorlinux.com/forum2/index.php?topic=6458.0

hope this helps vector's user support/documentation

[M0E-lnx]

i made the promissed howto here:

http://www.vectorlinux.com/forum2/index.php?topic=6458.0

hope this helps vector's user support/documentation

That should probabbly go in the wiki