winamp/Src/Wasabi/bfc/platform/linux/linux.cpp

#include <precomp.h>

#include <api/api.h>
  #include <api/linux/api_linux.h>

#include <bfc/ptrlist.h>
#include <bfc/string/string.h>
#include <bfc/critsec.h>
#include <bfc/thread.h>
#include <api/application/ipcs.h>

#ifdef WASABI_COMPILE_WND
Display *Linux::display = NULL;

int linux_atoms_loaded = 0;

Atom winamp_msg;
Atom dnd_enter, dnd_position, dnd_status, dnd_leave, dnd_drop, dnd_finished;
Atom dnd_selection, dnd_wa3drop, dnd_private, dnd_typelist;
Atom dnd_urilist, dnd_textplain, dnd_mozurl;
#endif

#ifndef _NOSTUDIO

#ifdef WASABI_COMPILE_WND
void LoadAtoms() {
  if ( !linux_atoms_loaded ) {
    linux_atoms_loaded = 1;
    winamp_msg = XInternAtom( Linux::getDisplay(), "Winamp3", False );
    dnd_wa3drop = XInternAtom( Linux::getDisplay(), "Winamp3_drop", False );
    dnd_enter = XInternAtom( Linux::getDisplay(), "XdndEnter", True );
    dnd_position = XInternAtom( Linux::getDisplay(), "XdndPosition", True );
    dnd_status = XInternAtom( Linux::getDisplay(), "XdndStatus", True );
    dnd_leave = XInternAtom( Linux::getDisplay(), "XdndLeave", True );
    dnd_drop = XInternAtom( Linux::getDisplay(), "XdndDrop", True );
    dnd_finished = XInternAtom( Linux::getDisplay(), "XdndFinished", True );
    dnd_selection = XInternAtom( Linux::getDisplay(), "XdndSelection", True );
    dnd_private = XInternAtom( Linux::getDisplay(), "XdndActionPrivate", True );
    dnd_typelist = XInternAtom( Linux::getDisplay(), "XdndTypeList", True );
    dnd_urilist = XInternAtom( Linux::getDisplay(), "text/uri-list", True );
    dnd_textplain = XInternAtom( Linux::getDisplay(), "text/plain", True );
    dnd_mozurl = XInternAtom( Linux::getDisplay(), "text/x-moz-url", True );
  }
}
#endif

#endif

void OutputDebugString( const char *s ) {
#ifdef _DEBUG
  fprintf( stderr, "%s", s );
#endif
  char *file = getenv( "WASABI_LOG_FILE" );
  if ( file ) {
    if ( !STRCMP( file, "-" ) ) {
      fprintf( stdout, "%s", s );
    } else {
      FILE *f = fopen( file, "a" );
      if ( f ) {
        fprintf( f, "%s", s );
        fclose( f );
      }
    }
  }
}

DWORD GetTickCount() {
  static int starttime = -1;

  if ( starttime == -1 )
    starttime = time( NULL );

  struct timeb tb;
  ftime( &tb );
  tb.time -= starttime;
  return tb.time * 1000 + tb.millitm;
}
void Sleep( int ms ) {
  if ( ms != 0 ) {
    struct timespec ts = { 0, 0 };
    ts.tv_sec = ms / 1000;
    ts.tv_nsec = (ms % 1000) * 1000000;
    nanosleep( &ts, NULL);
    //    usleep(ms * 1000);
  }
}

#ifndef _NOSTUDIO

#ifdef WASABI_COMPILE_WND

Display *Linux::getDisplay() {
  if ( ! display )
    display = WASABI_API_LINUX->linux_getDisplay();

  return display;
}

XContext Linux::getContext() {
  static XContext context = 0;

  if ( context == 0 )
    context = WASABI_API_LINUX->linux_getContext();

  return context;
}

int Linux::getScreenNum() { return DefaultScreen( getDisplay() ); }

Window Linux::RootWin() {
  return RootWindow( getDisplay(), getScreenNum() );
}
Visual *Linux::DefaultVis() {
  return DefaultVisual( getDisplay(), getScreenNum() );
}

void Linux::setCursor( HWND h, int cursor ) {
  Cursor c = XCreateFontCursor( Linux::getDisplay(), cursor );

  if ( cursor == None )
    XUndefineCursor( Linux::getDisplay(), h );
  else
    XDefineCursor( Linux::getDisplay(), h, c );

  XFreeCursor( Linux::getDisplay(), c );
}

int Linux::convertEvent( MSG *m, XEvent *e ) {
  m->hwnd = e->xany.window;

  if ( m->hwnd ) {
    api_window *rw =(api_window *)GetWindowLong( m->hwnd, GWL_USERDATA );
    if ( !rw ) {
      // This is to fix messages for dead windows...
      return 0;
    }
  }

  switch ( e->type ) {
  case ButtonPress:
    switch( e->xbutton.button ) {
    case 1:
      m->message = WM_LBUTTONDOWN;
      m->lParam = (e->xbutton.x & 0xffff) | (e->xbutton.y << 16);
      break;

    case 2:

    case 3:
      m->message = WM_RBUTTONDOWN;
      m->lParam = (e->xbutton.x & 0xffff) | (e->xbutton.y << 16);
      break;

    case 4:
      m->message = WM_MOUSEWHEEL;
      m->wParam = 120 << 16 | 0; // 1 tick, no modifiers
      m->lParam = (e->xbutton.x & 0xffff) | (e->xbutton.y << 16);
      break;

    case 5:
      m->message = WM_MOUSEWHEEL;
      m->wParam = (-120) << 16 | 0; // 1 tick, no modifiers
      m->lParam = (e->xbutton.x & 0xffff) | (e->xbutton.y << 16);
      break;
    }
    break;
  case ButtonRelease:
    switch( e->xbutton.button ) {
    case 1:
      m->message = WM_LBUTTONUP;
      m->lParam = (e->xbutton.x & 0xffff) | (e->xbutton.y << 16);
      break;

    case 2:

    case 3:
      m->message = WM_RBUTTONUP;
      m->lParam = (e->xbutton.x & 0xffff)  | (e->xbutton.y << 16);
      break;
    }
    break;
  case MotionNotify:
    {
      m->message = WM_MOUSEMOVE;
      do {
  // Spin...
      } while( XCheckTypedWindowEvent( Linux::getDisplay(), m->hwnd, MotionNotify, e ) );

      RECT r;
      POINT offset = {0, 0};
      HWND hwnd = m->hwnd;

      GetWindowRect( hwnd, &r );

      m->lParam = ((e->xmotion.x_root - r.left) & 0xffff) |
                 ((e->xmotion.y_root - r.top) << 16);

      if ( ! (e->xmotion.state & ( Button1Mask | Button2Mask | Button3Mask )) )
  PostMessage( m->hwnd, WM_SETCURSOR, m->hwnd, 0 );
    }
    break;

  case KeyPress:
    m->message = WM_KEYDOWN;
    m->wParam = e->xkey.keycode;
    break;

  case KeyRelease:
    m->message = WM_KEYUP;
    m->wParam = e->xkey.keycode;
    break;

  case Expose:
    {
      RECT r;
      m->message = WM_PAINT;
      do {
  r.left = e->xexpose.x;
  r.top = e->xexpose.y;
  r.right = r.left + e->xexpose.width;
  r.bottom = r.top + e->xexpose.height;
  InvalidateRect( m->hwnd, &r, FALSE );
      } while( XCheckTypedWindowEvent( Linux::getDisplay(), m->hwnd, Expose, e ) );
    }
    break;

  case ClientMessage: {
    static int coord = -1;
    static Atom supported = None;
    XClientMessageEvent cme;

    LoadAtoms();

    int message = e->xclient.message_type;
    if ( message == dnd_enter ) {
      if ( e->xclient.data.l[1] & 1 ) {
  Atom actual;
  int format;
  long unsigned int nitems, bytes;
  unsigned char *data = NULL;

  XGetWindowProperty( Linux::getDisplay(), e->xclient.data.l[0],
          dnd_typelist, 0, 65536, True, XA_ATOM,
          &actual, &format, &nitems, &bytes, &data );

  Atom *atomdata = (Atom *)data;

  supported = None;
  for( int i = 0; i < nitems; i++ ) {
    if ( atomdata[i] == dnd_urilist ) {
      supported = dnd_urilist;
    }
  }
  if ( supported == None ) {
    for( int i = 0; i < nitems; i++ ) {
      if ( atomdata[i] == dnd_textplain ) {
        OutputDebugString( "text/plain found\n" );
        supported = dnd_textplain;
      }
    }
  }
  if ( supported == None ) {
    for( int i = 0; i < nitems; i++ ) {
      if ( atomdata[i] == dnd_mozurl ) {
        supported = dnd_mozurl;
      }
    }
  }

  XFree( data );
      } else {
  if ( e->xclient.data.l[2] == dnd_urilist ||
       e->xclient.data.l[3] == dnd_urilist ||
       e->xclient.data.l[4] == dnd_urilist ) {
    supported = dnd_urilist;
  } else if ( e->xclient.data.l[2] == dnd_mozurl ||
        e->xclient.data.l[3] == dnd_mozurl ||
        e->xclient.data.l[4] == dnd_mozurl ) {
    supported = dnd_mozurl;
  }
      }


      // DnD Enter
      return 0;

    } else if ( message == dnd_position ) {
      // DnD Position Notify

      cme.type = ClientMessage;
      cme.message_type = dnd_status;
      cme.format = 32;
      cme.window = e->xclient.data.l[0];
      cme.data.l[0] = e->xclient.window;
      cme.data.l[1] = 1; // Can Accept
      cme.data.l[2] = cme.data.l[3] = 0; // Empty rectangle - give us moves
      cme.data.l[4] = dnd_private; // We're doing our own thing

      if ( coord == -1 && supported != None ) {
  XConvertSelection( Linux::getDisplay(), dnd_selection, supported,
         dnd_wa3drop, cme.window, CurrentTime );
      }

      coord = e->xclient.data.l[2];

      XSendEvent( Linux::getDisplay(), e->xclient.data.l[0], False,
      NoEventMask, (XEvent *)&cme );

      return 0;

    } else if ( message == dnd_leave ) {
      // DnD Leave
      coord = -1;
      supported = None;

      return 0;

    } else if ( message == dnd_drop ) {
      // DnD Drop

      Window win = e->xclient.data.l[0];

      cme.type = ClientMessage;
      cme.message_type = dnd_finished;
      cme.format = 32;
      cme.window = e->xclient.data.l[0];
      cme.data.l[0] = e->xclient.window;
      cme.data.l[1] = cme.data.l[2] = cme.data.l[3] = cme.data.l[4] = 0;

      XSendEvent( Linux::getDisplay(), e->xclient.data.l[0], False,
      NoEventMask, (XEvent *)&cme );

      if ( supported != None ) {
  Atom actual;
  int format;
  long unsigned int nitems, bytes;
  unsigned char *data = NULL;

  XGetWindowProperty( Linux::getDisplay(), cme.window, dnd_wa3drop,
          0, 65536, True, supported, &actual,
          &format, &nitems, &bytes,
          &data );

  OutputDebugString( StringPrintf( "Drop data (%d):\n%s\n", nitems, data ) );

  m->message = WM_DROPFILES;
  m->wParam = coord;
  m->lParam = (LPARAM)data;

  coord = -1;
  supported = None;

      } else {
  coord = -1;
  supported = None;
  return 0;
      }

      break;

    } else if ( message == winamp_msg ) {
      // Internal Message ...

      m->message = e->xclient.data.l[0];
      m->wParam = e->xclient.data.l[1];
      m->lParam = e->xclient.data.l[2];
      break;

    } else {
      return 0;
    }
    break;
  }

  case LeaveNotify:
  case EnterNotify:
    m->message = WM_MOUSEMOVE;
    m->lParam = (e->xcrossing.x & 0xffff) | (e->xcrossing.y << 16);

    if ( ! (e->xcrossing.state & ( Button1Mask | Button2Mask | Button3Mask )) )
      PostMessage( m->hwnd, WM_SETCURSOR, m->hwnd, 0 );
    break;

  case FocusIn:
    m->message = WM_SETFOCUS;
    break;

  case FocusOut:
    m->message = WM_KILLFOCUS;
    break;

  default:
    return 0;
  }

  return 1;
}

static HWND activeWindow;

HWND GetActiveWindow() {
  return activeWindow;
}

int IntersectRect( RECT *out, const RECT *i1, const RECT *i2 ) {
  return Std::rectIntersect(i1, i2, out);
}

void TranslateMessage( MSG *m ) {
  if ( m->message != WM_CHAR && m->message != WM_KEYDOWN &&
       m->message != WM_KEYUP )
    return;

  int index = !!( Std::keyDown( VK_SHIFT ));

  m->wParam = XKeycodeToKeysym( Linux::getDisplay(), m->wParam, index );
}

void PostMessage( HWND win, UINT msg, WPARAM wParam, LPARAM lParam ) {
  XEvent e;

  LoadAtoms();

  e.type = ClientMessage;
  e.xclient.window = win;
  e.xclient.message_type = winamp_msg;
  e.xclient.format = 32;
  e.xclient.data.l[0] = msg;
  e.xclient.data.l[1] = wParam;
  e.xclient.data.l[2] = lParam;

  XSendEvent( Linux::getDisplay(), win, FALSE, NoEventMask, &e );
}

void PostQuitMessage( int i ) {
  PostMessage( None, WM_QUIT, i, 0 );
}

#endif // wnd

#if defined(WASABI_API_TIMER) | defined(WASABI_API_WND)

struct TimerElem {
  HWND win;
  int id;
  int nexttime;
  int delta;
  TIMERPROC tproc;

  TimerElem( HWND _win, int _id, int ms, TIMERPROC _tproc ) {
    win = _win;
    id = _id;
    delta = ms;
    tproc = _tproc;
    nexttime = Std::getTickCount() + delta;
  }
};

int timer_id = 0;
CriticalSection timer_cs;
PtrList<TimerElem> timer_elems;

int SetTimer( HWND win, int id, int ms, TIMERPROC tproc ) {
  KillTimer(win, id);

  if ( win == (HWND)0 ) {
    id = timer_id++;
  }

  TimerElem *te = new TimerElem( win, id, ms, tproc );
  timer_cs.enter();
  timer_elems.addItem( te, PTRLIST_POS_LAST );
  timer_cs.leave();

  return id;
}

void KillTimer( HWND win, int id ) {
  timer_cs.enter();
  for( int i = 0; i < timer_elems.getNumItems(); i++ )
    if ( timer_elems[i]->win == win && timer_elems[i]->id == id ) {
      delete timer_elems[i];
      timer_elems.delByPos( i );
      i--;
    }
  timer_cs.leave();
}

CriticalSection send_cs;
MSG *send_msg;
int sending = 0;
int send_ret;
pthread_t message_thread = (pthread_t)-1;

int _GetMessage( MSG *m, HWND, UINT, UINT, int block=1) {
  MEMSET( m, 0, sizeof( MSG ) );

  message_thread = pthread_self();

#ifdef WASABI_COMPILE_WND
  XEvent e;
#endif // wnd
  int curtime;
  int done = 0;
  int first = 1;
  static wa_msgbuf ipcm;
  static int qid = -1;
  int size;

  if ( qid == -1 ) { qid = WASABI_API_LINUX->linux_getIPCId(); }

  if ( sending ) {
    *m = *send_msg;
    done = 1;
  }

  while( !done && (block || first)) {
    if ( qid != -1 ) {
      if ( (size = msgrcv( qid, &ipcm, IPC_MSGMAX , 0, IPC_NOWAIT )) != -1 ) {
        m->hwnd = None;
        m->message = WM_WA_IPC;
        m->wParam = (WPARAM)&ipcm;
        break;
      }
    }

    curtime = GetTickCount();

    timer_cs.enter();
    for( int i = 0; i < timer_elems.getNumItems(); i++ ) {
      if ( timer_elems[i]->nexttime < curtime ) {
        if (block)
          while( timer_elems[i]->nexttime < curtime )
            timer_elems[i]->nexttime += timer_elems[i]->delta;

        m->hwnd    = timer_elems[i]->win;
        m->message = WM_TIMER;
        m->wParam  = (WPARAM)timer_elems[i]->id;
        m->lParam  = (LPARAM)timer_elems[i]->tproc;

        done = 1;
      }
    }
    timer_cs.leave();

    if ( !done && ! first )
      Sleep( 1 );
    else
      first = 0;

#ifdef WASABI_API_WND
    if ( !done && XPending( Linux::getDisplay() ) ) {
      int n = XEventsQueued( Linux::getDisplay(), QueuedAlready );

      for ( int i = 0; !done && i < n; i++ ) {
        XNextEvent( Linux::getDisplay(), &e );
        if ( Linux::convertEvent( m, &e ) )
          done = 1;
      }
      if ( done )
        break;
    }
#endif // wnd
  }

#ifdef WASABI_API_WND
  activeWindow = m->hwnd;
#endif // wnd

  return m->message != WM_QUIT;
}

int GetMessage( MSG *m, HWND w, UINT f, UINT l) {
  return _GetMessage(m, w, f, l, 1);
}

// on linux, we don't really simply peek when PM_NOREMOVE is used,
// we just don't block, which is the only thing we want to accomplish here
int PeekMessage( MSG *m, HWND w, UINT f, UINT l, UINT remove) {
  if (remove == PM_NOREMOVE) return _GetMessage(m, w, f, l, 0);
  else _GetMessage(m, w, f, l, 1);
}


int DispatchMessage( MSG *m ) {
  if ( m->message == WM_TIMER && m->hwnd == None ) {
    TIMERPROC tproc = (TIMERPROC)m->lParam;
    tproc( m->hwnd, m->message, m->wParam, 0 );
    return 1;
  }

  int ret = 0;

#ifdef WASABI_COMPILE_WND
  api_window *rootwnd = (api_window *)GetWindowLong( m->hwnd, GWL_USERDATA );

  if ( rootwnd ) {
    ret = rootwnd->wndProc( m->hwnd, m->message, m->wParam, m->lParam );
    rootwnd->performBatchProcesses();
  }
#endif // wnd

  if ( sending ) {
    send_ret = ret;
    sending = 0;
  }

  return ret;
}

int SendMessage( HWND win, UINT msg, WPARAM wParam, LPARAM lParam ) {
  MSG m;
  m.hwnd = win;
  m.message = msg;
  m.wParam = wParam;
  m.lParam = lParam;

  int ret;

  if ( pthread_equal( message_thread, pthread_self() ) ) {
    return DispatchMessage( &m );

  } else {
    send_cs.enter();
    sending = 1;
    send_msg = &m;
    while( sending ) { Sleep( 1 ); }
    ret = send_ret;
    send_cs.leave();

    return ret;
  }
}

#endif // timer | wnd

int MulDiv( int m1, int m2, int d ) {
  __asm__ volatile (
        "mov %0, %%eax\n"
        "mov %1, %%ebx\n"
        "mov %2, %%ecx\n"
        "mul %%ebx\n"
        "div %%ecx\n"
        : : "m" (m1), "m" (m2), "m" (d)
        : "%eax", "%ebx", "%ecx", "%edx" );
}

void ExitProcess( int ret ) {
  exit( ret );
}

#ifdef WASABI_COMPILE_WND

void Linux::initContextData( HWND h ) {
  int *data;
  XPointer xp;

  ASSERT( XFindContext( Linux::getDisplay(), h, Linux::getContext(), &xp ));

  data = (int *)MALLOC( GWL_ENUM_SIZE * sizeof( int ) );

  data[GWL_HWND] = h;

  XSaveContext( Linux::getDisplay(), h, Linux::getContext(), (char *)data );
}

void Linux::nukeContextData( HWND h ) {
  int *data;
  XPointer xp;

  if ( XFindContext( Linux::getDisplay(), h, Linux::getContext(), &xp ) )
    return;

  data = (int *)xp;

  ASSERT( data[GWL_HWND] == h );

  if ( data[GWL_INVALIDREGION] ) {
    XDestroyRegion( (HRGN)data[GWL_INVALIDREGION] );
  }

  XDeleteContext( Linux::getDisplay(), h, Linux::getContext() );

  FREE( data );
}

void SetWindowLong( HWND h, contextdata type, LONG value ) {
  XPointer data;

  if ( XFindContext( Linux::getDisplay(), h, Linux::getContext(), &data ) )
    return;

  ASSERT( ((int *)data)[GWL_HWND] == h );

  ((int*)data)[type] = value;
}

LONG GetWindowLong( HWND h, contextdata type ) {
  XPointer data;

  if ( XFindContext( Linux::getDisplay(), h, Linux::getContext(), &data ) )
    return 0;

  ASSERT( ((int *)data)[GWL_HWND] == h );

  return ((int*)data)[type];
}

void MoveWindowRect( HWND h, int x, int y ) {
  XPointer xp;
  int *data;

  if ( XFindContext( Linux::getDisplay(), h, Linux::getContext(), &xp ) )
    return;

  data = (int *)xp;

  ASSERT( data[GWL_HWND] == h );

  data[GWL_RECT_RIGHT]  -= data[GWL_RECT_LEFT] - x;
  data[GWL_RECT_BOTTOM] -= data[GWL_RECT_TOP] - y;
  data[GWL_RECT_LEFT]   = x;
  data[GWL_RECT_TOP]    = y;
}

void SetWindowRect( HWND h, RECT *r ) {
  int *data;
  XPointer xp;

  if ( XFindContext( Linux::getDisplay(), h, Linux::getContext(), &xp ) )
    return;

  data = (int *)xp;

  ASSERT( data[GWL_HWND] == h );

  data[GWL_RECT_LEFT]   = r->left;
  data[GWL_RECT_TOP]    = r->top;
  data[GWL_RECT_RIGHT]  = r->right;
  data[GWL_RECT_BOTTOM] = r->bottom;
}

int GetWindowRect( HWND h, RECT *r ) {
  int *data;
  XPointer xp;

  if ( XFindContext( Linux::getDisplay(), h, Linux::getContext(), &xp ) )
    return 0;

  data = (int *)xp;

  ASSERT( data[GWL_HWND] == h );

  r->left   = data[GWL_RECT_LEFT];
  r->top    = data[GWL_RECT_TOP];
  r->right  = data[GWL_RECT_RIGHT];
  r->bottom = data[GWL_RECT_BOTTOM];

  POINT offset = { 0, 0};
  while( (h = data[GWL_PARENT]) != Linux::RootWin() ) {
    if ( XFindContext( Linux::getDisplay(), h, Linux::getContext(), &xp ) )
      return 0;

    data = (int *)xp;

    ASSERT( data[GWL_HWND] == h );

    offset.x += data[GWL_RECT_LEFT];
    offset.y += data[GWL_RECT_TOP];
  }
  r->left += offset.x;
  r->top += offset.y;
  r->right += offset.x;
  r->bottom += offset.y;

  return 1;
}

int GetUpdateRect( HWND h, RECT *ret, BOOL ) {
  HRGN invalid = (HRGN)GetWindowLong( h, GWL_INVALIDREGION );
  if ( ! invalid || XEmptyRegion( invalid ) )
    return 0;

  XRectangle xr;
  XClipBox( invalid, &xr );
  ret->left = xr.x;
  ret->top = xr.y;
  ret->right = xr.x + xr.width;
  ret->bottom = xr.y + xr.height;

  return 1;
}

void GetUpdateRgn( HWND h, HRGN r, BOOL ) {
  XSubtractRegion( r, r, r );

  HRGN invalid = (HRGN)GetWindowLong( h, GWL_INVALIDREGION );
  if ( ! invalid ) return;


  XUnionRegion( r, invalid, r );

  XRectangle xr;

  RECT rct;
  GetWindowRect( h, &rct );
  xr.x = 0;
  xr.y = 0;
  xr.width = rct.right - rct.left;
  xr.height = rct.bottom - rct.top;

  HRGN tmp = XCreateRegion();

  XUnionRectWithRegion( &xr, tmp, tmp );
  XIntersectRegion( r, tmp, r );
  XDestroyRegion( tmp );
}

void InvalidateRect( HWND h, const RECT *r, BOOL ) {
  HRGN invalid = (HRGN)GetWindowLong( h, GWL_INVALIDREGION );
  if ( ! invalid ) {
    invalid = XCreateRegion();
    SetWindowLong( h, GWL_INVALIDREGION, (LONG)invalid );
  }

  XRectangle xr;
  if ( r == NULL ) {
    RECT rct;
    GetWindowRect( h, &rct );
    xr.x = 0;
    xr.y = 0;
    xr.width = rct.right - rct.left;
    xr.height = rct.bottom - rct.top;
  } else {
    xr.x = r->left;
    xr.y = r->top;
    xr.width = r->right - r->left;
    xr.height = r->bottom - r->top;
  }

  XUnionRectWithRegion( &xr, invalid, invalid );

  PostMessage( h, WM_PAINT, 0, 0 );
}

void InvalidateRgn( HWND h, HRGN r, BOOL ) {
  HRGN invalid = (HRGN)GetWindowLong( h, GWL_INVALIDREGION );

  if ( ! invalid ) {
    invalid = XCreateRegion();
    SetWindowLong( h, GWL_INVALIDREGION, (LONG)invalid );
  }

  ASSERT( r != invalid );
  XUnionRegion( invalid, r, invalid );

  PostMessage( h, WM_PAINT, 0, 0 );
}

void ValidateRect( HWND h, const RECT *r ) {
  HRGN invalid = (HRGN)GetWindowLong( h, GWL_INVALIDREGION );
  if ( ! invalid ) return;

  XRectangle xr;
  if ( r == NULL ) {
    XDestroyRegion( invalid );
    SetWindowLong( h, GWL_INVALIDREGION, 0 );
    return;
  }

  xr.x = r->left;
  xr.y = r->top;
  xr.width = r->right - r->left;
  xr.height = r->bottom - r->top;

  HRGN tmp = XCreateRegion();
  XUnionRectWithRegion( &xr, tmp, tmp );
  XSubtractRegion( invalid, tmp, invalid );
  XDestroyRegion( tmp );
}

void ValidateRgn( HWND h, HRGN r ) {
  HRGN invalid = (HRGN)GetWindowLong( h, GWL_INVALIDREGION );
  if ( ! invalid ) return;

  ASSERT( r != invalid );
  XSubtractRegion( invalid, r, invalid );
}
#endif // wnd

int SubtractRect( RECT *out, RECT *in1, RECT *in2 ) {
  int ret;
  if ( in1->left >= in2->left && in1->right <= in2->right ) {
    out->left = in1->left; out->right = in1->right;

    if ( in1->top >= in2->top && in2->bottom >= in2->top && in2->bottom <= in2->bottom ) {
      out->top = in1->bottom; out->bottom = in2->bottom;

      ret = 1;
    } else if ( in1->top <= in2->top && in1->bottom >= in2->top && in1->bottom <= in2->bottom ) {
      out->top = in1->top; out->bottom = in2->top;

      ret = 1;
    } else {
      ret = 0;
    }

  } else if ( in1->top >= in2->top && in1->bottom <= in2->bottom ) {
    out->top = in1->top; out->bottom = in1->bottom;

    if ( in1->left >= in2->left && in2->right >= in2->left && in2->right <= in2->right ) {
      out->left = in1->right; out->right = in2->right;

      ret = 1;
    } else if ( in1->left <= in2->left && in1->right >= in2->left && in1->right <= in2->right ) {
      out->left = in1->left; out->right = in2->left;

      ret = 1;
    } else {
      ret = 0;
    }


  } else {
    ret = 0;
  }
  return ret;
}

int EqualRect( RECT *a, RECT *b ) {
  return ( a->top == b->top && a->bottom == b->bottom &&
     a->left == b->left && a->right == b->right );
}

#ifdef WASABI_COMPILE_WND

HWND WindowFromPoint( POINT p ) {
  int x, y;
  Window child;

  XTranslateCoordinates( Linux::getDisplay(), Linux::RootWin(), Linux::RootWin(), p.x, p.y, &x, &y, &child );
  return child;
}
#endif // wnd

void CopyFile( const char *f1, const char *f2, BOOL b ) {
  COPYFILE( f1, f2 );
}

DWORD GetModuleFileName(void *pid, const char *filename, int bufsize) {
  char procbuffer[512];
  sprintf(procbuffer, "/proc/%d/exe", (int)pid);
  return readlink(procbuffer, (char *)filename, bufsize);
}

const char *CharPrev(const char *lpszStart, const char *lpszCurrent) {
  if (lpszCurrent-1 >= lpszStart) return lpszCurrent-1;
  return lpszStart;
}

#endif