path: root/hw/xwin/winclipboardwrappers.c

/*
 *Copyright (C) 2003-2004 Harold L Hunt II All Rights Reserved.
 *
 *Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 *"Software"), to deal in the Software without restriction, including
 *without limitation the rights to use, copy, modify, merge, publish,
 *distribute, sublicense, and/or sell copies of the Software, and to
 *permit persons to whom the Software is furnished to do so, subject to
 *the following conditions:
 *
 *The above copyright notice and this permission notice shall be
 *included in all copies or substantial portions of the Software.
 *
 *THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *NONINFRINGEMENT. IN NO EVENT SHALL HAROLD L HUNT II BE LIABLE FOR
 *ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 *CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 *Except as contained in this notice, the name of Harold L Hunt II
 *shall not be used in advertising or otherwise to promote the sale, use
 *or other dealings in this Software without prior written authorization
 *from Harold L Hunt II.
 *
 * Authors:	Harold L Hunt II
 */

#ifdef HAVE_XWIN_CONFIG_H
#include <xwin-config.h>
#endif
#include "win.h"
#include "dixstruct.h"
#include <X11/Xatom.h>


/*
 * Constants
 */

#define CLIP_NUM_SELECTIONS		2
#define CLIP_OWN_PRIMARY		0
#define CLIP_OWN_CLIPBOARD		1


/*
 * Local function prototypes
 */

DISPATCH_PROC(winProcEstablishConnection);
DISPATCH_PROC(winProcQueryTree);
DISPATCH_PROC(winProcSetSelectionOwner);


/*
 * References to external symbols
 */

extern Bool		g_fUnicodeSupport;
extern int		g_iNumScreens;
extern unsigned int	g_uiAuthDataLen;
extern char		*g_pAuthData;
extern Bool		g_fXdmcpEnabled;
extern Bool		g_fClipboardLaunched;
extern Bool		g_fClipboardStarted;
extern Bool		g_fClipboard;
extern Window		g_iClipboardWindow;
extern Atom		g_atomLastOwnedSelection;
extern HWND		g_hwndClipboard;

extern winDispatchProcPtr	winProcEstablishConnectionOrig;
extern winDispatchProcPtr	winProcQueryTreeOrig;
extern winDispatchProcPtr	winProcSetSelectionOwnerOrig;


/*
 * Wrapper for internal QueryTree function.
 * Hides the clipboard client when it is the only client remaining.
 */

int
winProcQueryTree (ClientPtr client)
{
  int			iReturn;

  /*
   * This procedure is only used for initialization.
   * We can unwrap the original procedure at this point
   * so that this function is no longer called until the
   * server resets and the function is wrapped again.
   */
  ProcVector[X_QueryTree] = winProcQueryTreeOrig;

  /*
   * Call original function and bail if it fails.
   * NOTE: We must do this first, since we need XdmcpOpenDisplay
   * to be called before we initialize our clipboard client.
   */
  iReturn = (*winProcQueryTreeOrig) (client);
  if (iReturn != 0)
    {
      ErrorF ("winProcQueryTree - ProcQueryTree failed, bailing.\n");
      return iReturn;
    }

  /* Make errors more obvious */
  winProcQueryTreeOrig = NULL;

  /* Do nothing if clipboard is not enabled */
  if (!g_fClipboard)
    {
      ErrorF ("winProcQueryTree - Clipboard is not enabled, "
	      "returning.\n");
      return iReturn;
    }

  /* If the clipboard client has already been started, abort */
  if (g_fClipboardLaunched)
    {
      ErrorF ("winProcQueryTree - Clipboard client already "
	      "launched, returning.\n");
      return iReturn;
    }

  /* Startup the clipboard client if clipboard mode is being used */
  if (g_fXdmcpEnabled && g_fClipboard)
    {
      /*
       * NOTE: The clipboard client is started here for a reason:
       * 1) Assume you are using XDMCP (e.g. XWin -query %hostname%)
       * 2) If the clipboard client attaches during X Server startup,
       *    then it becomes the "magic client" that causes the X Server
       *    to reset if it exits.
       * 3) XDMCP calls KillAllClients when it starts up.
       * 4) The clipboard client is a client, so it is killed.
       * 5) The clipboard client is the "magic client", so the X Server
       *    resets itself.
       * 6) This repeats ad infinitum.
       * 7) We avoid this by waiting until at least one client (could
       *    be XDM, could be another client) connects, which makes it
       *    almost certain that the clipboard client will not connect
       *    until after XDM when using XDMCP.
       * 8) Unfortunately, there is another problem.
       * 9) XDM walks the list of windows with XQueryTree,
       *    killing any client it finds with a window.
       * 10)Thus, when using XDMCP we wait until the first call
       *    to ProcQueryTree before we startup the clipboard client.
       *    This should prevent XDM from finding the clipboard client,
       *    since it has not yet created a window.
       * 11)Startup when not using XDMCP is handled in
       *    winProcEstablishConnection.
       */
      
      /* Create the clipboard client thread */
      if (!winInitClipboard ())
	{
	  ErrorF ("winProcQueryTree - winClipboardInit "
		  "failed.\n");
	  return iReturn;
	}
      
      ErrorF ("winProcQueryTree - winInitClipboard returned.\n");
    }
  
  /* Flag that clipboard client has been launched */
  g_fClipboardLaunched = TRUE;

  return iReturn;
}


/*
 * Wrapper for internal EstablishConnection function.
 * Initializes internal clients that must not be started until
 * an external client has connected.
 */

int
winProcEstablishConnection (ClientPtr client)
{
  int			iReturn;
  static int		s_iCallCount = 0;
  static unsigned long	s_ulServerGeneration = 0;

  ErrorF ("winProcEstablishConnection - Hello\n");

  /* Do nothing if clipboard is not enabled */
  if (!g_fClipboard)
    {
      ErrorF ("winProcEstablishConnection - Clipboard is not enabled, "
	      "returning.\n");
      
      /* Unwrap the original function, call it, and return */
      InitialVector[2] = winProcEstablishConnectionOrig;
      iReturn = (*winProcEstablishConnectionOrig) (client);
      winProcEstablishConnectionOrig = NULL;
      return iReturn;
    }

  /* Watch for server reset */
  if (s_ulServerGeneration != serverGeneration)
    {
      /* Save new generation number */
      s_ulServerGeneration = serverGeneration;

      /* Reset call count */
      s_iCallCount = 0;
    }

  /* Increment call count */
  ++s_iCallCount;

  /* Wait for second call when Xdmcp is enabled */
  if (g_fXdmcpEnabled
      && !g_fClipboardLaunched
      && s_iCallCount < 4)
    {
      ErrorF ("winProcEstablishConnection - Xdmcp enabled, waiting to "
	      "start clipboard client until fourth call.\n");
      return (*winProcEstablishConnectionOrig) (client);
    }

  /*
   * This procedure is only used for initialization.
   * We can unwrap the original procedure at this point
   * so that this function is no longer called until the
   * server resets and the function is wrapped again.
   */
  InitialVector[2] = winProcEstablishConnectionOrig;

  /*
   * Call original function and bail if it fails.
   * NOTE: We must do this first, since we need XdmcpOpenDisplay
   * to be called before we initialize our clipboard client.
   */
  iReturn = (*winProcEstablishConnectionOrig) (client);
  if (iReturn != 0)
    {
      ErrorF ("winProcEstablishConnection - ProcEstablishConnection "
	      "failed, bailing.\n");
      return iReturn;
    }

  /* Clear original function pointer */
  winProcEstablishConnectionOrig = NULL;

  /* If the clipboard client has already been started, abort */
  if (g_fClipboardLaunched)
    {
      ErrorF ("winProcEstablishConnection - Clipboard client already "
	      "launched, returning.\n");
      return iReturn;
    }

  /* Startup the clipboard client if clipboard mode is being used */
  if (g_fClipboard)
    {
      /*
       * NOTE: The clipboard client is started here for a reason:
       * 1) Assume you are using XDMCP (e.g. XWin -query %hostname%)
       * 2) If the clipboard client attaches during X Server startup,
       *    then it becomes the "magic client" that causes the X Server
       *    to reset if it exits.
       * 3) XDMCP calls KillAllClients when it starts up.
       * 4) The clipboard client is a client, so it is killed.
       * 5) The clipboard client is the "magic client", so the X Server
       *    resets itself.
       * 6) This repeats ad infinitum.
       * 7) We avoid this by waiting until at least one client (could
       *    be XDM, could be another client) connects, which makes it
       *    almost certain that the clipboard client will not connect
       *    until after XDM when using XDMCP.
       * 8) Unfortunately, there is another problem.
       * 9) XDM walks the list of windows with XQueryTree,
       *    killing any client it finds with a window.
       * 10)Thus, when using XDMCP we wait until the second call
       *    to ProcEstablishCeonnection before we startup the clipboard
       *    client.  This should prevent XDM from finding the clipboard
       *    client, since it has not yet created a window.
       */
      
      /* Create the clipboard client thread */
      if (!winInitClipboard ())
	{
	  ErrorF ("winProcEstablishConnection - winClipboardInit "
		  "failed.\n");
	  return iReturn;
	}
      
      ErrorF ("winProcEstablishConnection - winInitClipboard returned.\n");
    }
  
  /* Flag that clipboard client has been launched */
  g_fClipboardLaunched = TRUE;

  return iReturn;
}


/*
 * Wrapper for internal SetSelectionOwner function.
 * Grabs ownership of Windows clipboard when X11 clipboard owner changes.
 */

int
winProcSetSelectionOwner (ClientPtr client)
{
  int			i;
  DrawablePtr		pDrawable;
  WindowPtr		pWindow = None;
  Bool			fOwnedToNotOwned = FALSE;
  static Window		s_iOwners[CLIP_NUM_SELECTIONS] = {None};
  static unsigned long	s_ulServerGeneration = 0;
  REQUEST(xSetSelectionOwnerReq);
  
  REQUEST_SIZE_MATCH(xSetSelectionOwnerReq);

#if 0
  ErrorF ("winProcSetSelectionOwner - Hello.\n");
#endif

  /* Watch for server reset */
  if (s_ulServerGeneration != serverGeneration)
    {
      /* Save new generation number */
      s_ulServerGeneration = serverGeneration;

      /* Initialize static variables */
      for (i = 0; i < CLIP_NUM_SELECTIONS; ++i)
	s_iOwners[i] = None;
    }

  /* Abort if clipboard not completely initialized yet */
  if (!g_fClipboardStarted)
    {
      ErrorF ("winProcSetSelectionOwner - Clipboard not yet started, "
	      "aborting.\n");
      goto winProcSetSelectionOwner_Done;
    }
  
  /* Grab window if we have one */
  if (None != stuff->window)
    {
      /* Grab the Window from the request */
      int rc = dixLookupWindow(&pWindow, stuff->window, client, DixReadAccess);
      if (rc != Success) {
	  ErrorF ("winProcSetSelectionOwner - Found BadWindow, aborting.\n");
	  goto winProcSetSelectionOwner_Done;
      }
    }

  /* Now we either have a valid window or None */

  /* Save selection owners for monitored selections, ignore other selections */
  if (XA_PRIMARY == stuff->selection)
    {
      /* Look for owned -> not owned transition */
      if (None == stuff->window
	  && None != s_iOwners[CLIP_OWN_PRIMARY])
	{
	  fOwnedToNotOwned = TRUE;

#if 0
	  ErrorF ("winProcSetSelectionOwner - PRIMARY - Going from "
		  "owned to not owned.\n");
#endif

	  /* Adjust last owned selection */
	  if (None != s_iOwners[CLIP_OWN_CLIPBOARD])
	    g_atomLastOwnedSelection = MakeAtom ("CLIPBOARD", 9, TRUE);
	  else
	    g_atomLastOwnedSelection = None;
	}
      
      /* Save new selection owner or None */
      s_iOwners[CLIP_OWN_PRIMARY] = stuff->window;

#if 0
      ErrorF ("winProcSetSelectionOwner - PRIMARY - Now owned by: %d\n",
	      stuff->window);
#endif
    }
  else if (MakeAtom ("CLIPBOARD", 9, TRUE) == stuff->selection)
    {
      /* Look for owned -> not owned transition */
      if (None == stuff->window
	  && None != s_iOwners[CLIP_OWN_CLIPBOARD])
	{
	  fOwnedToNotOwned = TRUE;
	  
#if 0
	  ErrorF ("winProcSetSelectionOwner - CLIPBOARD - Going from "
		  "owned to not owned.\n");
#endif

	  /* Adjust last owned selection */
	  if (None != s_iOwners[CLIP_OWN_PRIMARY])
	    g_atomLastOwnedSelection = XA_PRIMARY;
	  else
	    g_atomLastOwnedSelection = None;
	}
      
      /* Save new selection owner or None */
      s_iOwners[CLIP_OWN_CLIPBOARD] = stuff->window;

#if 0
      ErrorF ("winProcSetSelectionOwner - CLIPBOARD - Now owned by: %d\n",
	      stuff->window);
#endif
    }
  else
    goto winProcSetSelectionOwner_Done;

  /*
   * At this point, if one of the selections is still owned by the 
   * clipboard manager then it should be marked as unowned since
   * we will be taking ownership of the Win32 clipboard.
   */
  if (g_iClipboardWindow == s_iOwners[CLIP_OWN_PRIMARY])
    s_iOwners[CLIP_OWN_PRIMARY] = None;
  if (g_iClipboardWindow == s_iOwners[CLIP_OWN_CLIPBOARD])
    s_iOwners[CLIP_OWN_CLIPBOARD] = None;

  /*
   * Handle case when selection is being disowned,
   * WM_DRAWCLIPBOARD did not do the disowning,
   * both monitored selections are no longer owned,
   * an owned to not owned transition was detected,
   * and we currently own the Win32 clipboard.
   */
  if (None == stuff->window
      && (None == s_iOwners[CLIP_OWN_PRIMARY]
	  || g_iClipboardWindow == s_iOwners[CLIP_OWN_PRIMARY])
      && (None == s_iOwners[CLIP_OWN_CLIPBOARD]
	  || g_iClipboardWindow == s_iOwners[CLIP_OWN_CLIPBOARD])
      && fOwnedToNotOwned
      && g_hwndClipboard != NULL
      && g_hwndClipboard == GetClipboardOwner ())
    {
#if 0
      ErrorF ("winProcSetSelectionOwner - We currently own the "
	      "clipboard and neither the PRIMARY nor the CLIPBOARD "
	      "selections are owned, releasing ownership of Win32 "
	      "clipboard.\n");
#endif
      
      /* Release ownership of the Windows clipboard */
      OpenClipboard (NULL);
      EmptyClipboard ();
      CloseClipboard ();

      /* Clear X selection ownership (might still be marked as us owning) */
      s_iOwners[CLIP_OWN_PRIMARY] = None;
      s_iOwners[CLIP_OWN_CLIPBOARD] = None;
      
      goto winProcSetSelectionOwner_Done;
    }

  /* Abort if no window at this point */
  if (None == stuff->window)
    {
#if 0
      ErrorF ("winProcSetSelectionOwner - No window, returning.\n");
#endif
      goto winProcSetSelectionOwner_Done;
    }

  /* Abort if invalid selection */
  if (!ValidAtom (stuff->selection))
    {
      ErrorF ("winProcSetSelectionOwner - Found BadAtom, aborting.\n");
      goto winProcSetSelectionOwner_Done;
    }

  /* Cast Window to Drawable */
  pDrawable = (DrawablePtr) pWindow;
  
  /* Abort if clipboard manager is owning the selection */
  if (pDrawable->id == g_iClipboardWindow)
    {
#if 0
      ErrorF ("winProcSetSelectionOwner - We changed ownership, "
	      "aborting.\n");
#endif
      goto winProcSetSelectionOwner_Done;
    }

  /* Abort if root window is taking ownership */
  if (pDrawable->id == 0)
    {
      ErrorF ("winProcSetSelectionOwner - Root window taking ownership, "
	      "aborting\n");
      goto winProcSetSelectionOwner_Done;
    }

  /* Close clipboard if we have it open already */
  if (GetOpenClipboardWindow () == g_hwndClipboard)
    {
      CloseClipboard ();
    }

  /* Access the Windows clipboard */
  if (!OpenClipboard (g_hwndClipboard))
    {
      ErrorF ("winProcSetSelectionOwner - OpenClipboard () failed: %08x\n",
	      (int) GetLastError ());
      goto winProcSetSelectionOwner_Done;
    }

  /* Take ownership of the Windows clipboard */
  if (!EmptyClipboard ())
    {
      ErrorF ("winProcSetSelectionOwner - EmptyClipboard () failed: %08x\n",
	      (int) GetLastError ());
      goto winProcSetSelectionOwner_Done;
    }

  /* Advertise Unicode if we support it */
  if (g_fUnicodeSupport)
    SetClipboardData (CF_UNICODETEXT, NULL);

  /* Always advertise regular text */
  SetClipboardData (CF_TEXT, NULL);

  /* Save handle to last owned selection */
  g_atomLastOwnedSelection = stuff->selection;

  /* Release the clipboard */
  if (!CloseClipboard ())
    {
      ErrorF ("winProcSetSelectionOwner - CloseClipboard () failed: "
	      "%08x\n",
	      (int) GetLastError ());
      goto winProcSetSelectionOwner_Done;
    }

 winProcSetSelectionOwner_Done:
  return (*winProcSetSelectionOwnerOrig) (client);
}