1038_merged_head.patch - Ryzom - Ryzom Core Development Site

     	// get the number of call to swapBuffer since the driver was created
     	virtual uint64			getSwapBufferCounter() const = 0;
     	virtual bool copyTextToClipboard(const ucstring &text) = 0;
     	virtual bool pasteTextFromClipboard(ucstring &text) = 0;
     	/** Set cull mode
     	  * Useful for mirrors / cube map rendering or when the scene must be rendered upside down
     	  */

     	virtual void		  deleteWaterEnvMap(UWaterEnvMap *map);
     	// @}
     	virtual bool copyTextToClipboard(const ucstring &text);
     	virtual bool pasteTextFromClipboard(ucstring &text);
     	virtual uint64	getSwapBufferCounter();

     	virtual uint64	getSwapBufferCounter() = 0;
     	virtual bool copyTextToClipboard(const ucstring &text) =0;
     	virtual bool pasteTextFromClipboard(ucstring &text) =0;
     public:
     	/**

     	/// From IEventEmitter. This call submitEvents on all the emitters
     	virtual void submitEvents(CEventServer &server, bool allWindows);
     	virtual void emulateMouseRawMode(bool enable);
     	virtual bool copyTextToClipboard(const ucstring &text);
     	virtual bool pasteTextFromClipboard(ucstring &text);
     private:
     	typedef std::vector<std::pair<IEventEmitter *, bool> > TEmitterCont;
     	TEmitterCont	_Emitters;

b/code/nel/src/3d/driver/direct3d/driver_direct3d.cpp Fri Oct 15 21:33:52 2010 +0200
292	292
293	293	_SumTextureMemoryUsed = false;
294	294
295
296	295	_DesktopGammaRampValid = false;
	296	// initialize COM
	297	HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
297	298	}
298	299
299	300	// ***************************************************************************
...	...
3831	3832	}
3832	3833	}
3833	3834	}
3834
	3835	bool CDriverD3D::copyTextToClipboard(const ucstring &text)
	3836	{
	3837	return _EventEmitter.copyTextToClipboard(text);
	3838	}
	3839
	3840	bool CDriverD3D::pasteTextFromClipboard(ucstring &text)
	3841	{
	3842	return _EventEmitter.pasteTextFromClipboard(text);
	3843	}
3835	3844	} // NL3D

     	void deleteIndexBuffer(CIBDrvInfosD3D *ib);
     	// Build 16 bit index buffer for quad
     	bool buildQuadIndexBuffer();
     	virtual bool copyTextToClipboard(const ucstring &text);
     	virtual bool pasteTextFromClipboard(ucstring &text);
     public:
     	#ifdef 	NL_DEBUG
     		std::set<CVBDrvInfosD3D *> _LockedBuffers;

     	_TextureTargetCubeFace = 0;
     	_TextureTargetUpload = false;
     #ifdef NL_OS_WINDOWS
     	// initialize COM
     	HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
     #endif
+    }
     // ***************************************************************************
-...
+    {
+    }
     bool CDriverGL::copyTextToClipboard(const ucstring &text)
+    {
     	return _EventEmitter.copyTextToClipboard(text);
+    }
     bool CDriverGL::pasteTextFromClipboard(ucstring &text)
+    {
     	return _EventEmitter.pasteTextFromClipboard(text);
+    }
     } // NL3D
     // ***************************************************************************

b/code/nel/src/3d/driver/opengl/driver_opengl.h Fri Oct 15 21:33:52 2010 +0200
325	325	{
326	326	return _win;
327	327	}
	328	virtual bool copyTextToClipboard(const ucstring &text);
	329
	330	virtual bool pasteTextFromClipboard(ucstring &text);
328	331
329	332	virtual uint32 getAvailableVertexAGPMemory ();
330	333	virtual uint32 getAvailableVertexVRAMMemory ();

     	// just forwarding to our cocoa adapter
     	NL3D::MAC::emulateMouseRawMode(enable);
+    }
     bool CCocoaEventEmitter::pasteTextFromClipboard(ucstring &text)
+    {
     	return false;
+    }
     bool CCocoaEventEmitter::copyTextToClipboard(const ucstring &text)
+    {
     	return false;
+    }
+    }

     public:
     	virtual void submitEvents(CEventServer & server, bool allWindows);
     	virtual void emulateMouseRawMode(bool enable);
     };
     	/**
+    	 *
     	 */
     	virtual bool copyTextToClipboard(const ucstring &text);
     	/*
+    	 *
     	 */
     	virtual bool pasteTextFromClipboard(ucstring &text);};
+    }
     #endif

     #if defined(NL_OS_UNIX) && !defined(NL_OS_MAC)
     #include <X11/Xlib.h>
     #include <X11/Xatom.h>
     #include <X11/keysym.h>
     #include <GL/gl.h>
     #include <GL/glx.h>
-...
+    {
     	_im = 0;
     	_ic = 0;
     	_SelectionOwned=false;
+    }
     CUnixEventEmitter::~CUnixEventEmitter()
-...
     	_win = win;
     	_driver = driver;
     	XSelectInput (_dpy, _win, KeyPressMask|KeyReleaseMask|ButtonPressMask|ButtonReleaseMask|PointerMotionMask|StructureNotifyMask);
     	XSelectInput (_dpy, _win, KeyPressMask|KeyReleaseMask|ButtonPressMask|ButtonReleaseMask|PointerMotionMask|StructureNotifyMask|ExposureMask);
     	_PrecomputedAtom[0] = XInternAtom(dpy, "CLIPBOARD",False);
     	#define XA_CLIPBOARD _PrecomputedAtom[0]
     	_PrecomputedAtom[1] = XInternAtom(dpy, "UTF8_STRING",False);
     	#define XA_UTF8_STRING _PrecomputedAtom[1]
     	_PrecomputedAtom[2] = XInternAtom(dpy, "TARGETS",False);
     	#define XA_TARGETS _PrecomputedAtom[2]
     	_PrecomputedAtom[3] = XInternAtom(dpy, "ATOM",False);
     	//#define XA_ATOM _PrecomputedAtom[3]
     	_PrecomputedAtom[4] = XInternAtom(dpy, "NeL_SEL",False);
     	#define XA_NEL_SEL _PrecomputedAtom[4]
     	_PrecomputedAtom[5] = XInternAtom(dpy, "TEXT",False);
     	#define XA_TEXT _PrecomputedAtom[5]
     /*
     	TODO: implements all useful events processing
     	EnterWindowMask|LeaveWindowMask|ButtonMotionMask|Button1MotionMask|Button2MotionMask|
     	Button3MotionMask|Button4MotionMask|Button5MotionMask|KeymapStateMask|ExposureMask|
     	Button3MotionMask|Button4MotionMask|Button5MotionMask|KeymapStateMask|
     	SubstructureNotifyMask|VisibilityChangeMask|FocusChangeMask|PropertyChangeMask|
     	ColormapChangeMask|OwnerGrabButtonMask
     */
-...
+    		}
     		break;
+    	}
     	case SelectionRequest:
+    	{
     		XEvent respond;
     		XSelectionRequestEvent *req=&(event.xselectionrequest);
     		respond.xselection.type= SelectionNotify;
     		respond.xselection.display= req->display;
     		respond.xselection.requestor= req->requestor;
     		respond.xselection.selection=req->selection;
     		respond.xselection.target= req->target;
     		respond.xselection.time = req->time;
     		respond.xselection.property = req->property;
     		if (req->property == None)
+    		{
     			respond.xselection.property=req->target;
+    		}
     		if (req->target == XA_TARGETS)
+    		{
     			nlwarning("Client is asking for TARGETS");
     			Atom targets[] = {
     				  XA_TARGETS
     				, XA_TEXT
     				, XA_UTF8_STRING
     			};
     			respond.xselection.property = req->property;
     			XChangeProperty(req->display, req->requestor, req->property, XA_ATOM, 32, PropModeReplace, (unsigned char *)targets, 3 /* number of element */);
+    		}
     		else if (req->target == XInternAtom(_dpy, "TEXT", False) || req->target == XA_STRING )
+    		{
     			nlwarning("client want TEXT");
     			respond.xselection.property=req->property;
     			std::string str=_CopiedString.toString();
     			XChangeProperty(req->display, req->requestor, req->property, XA_STRING, 8, PropModeReplace, (const unsigned char*)str.c_str(), strlen(str.c_str()));
+    		}
     		else if (req->target == XInternAtom(_dpy, "UTF8_STRING", False))
+    		{
     			nlwarning("Client want UTF8 STRING");
     			respond.xselection.property=req->property;
     			std::string str=_CopiedString.toUtf8();
     			XChangeProperty(req->display, req->requestor, respond.xselection.property, XInternAtom(_dpy, "UTF8_STRING", False), 8, PropModeReplace, (const unsigned char*)str.c_str(), strlen((char*)str.c_str()));
+    		}
     		else
+    		{
     			nlwarning("Target doesn't want a string %u",req->target); // Note: Calling XGetAtomName with arbitrary value crash the client, maybe req->target have been sanitized by X11 server
     			respond.xselection.property= None;
+    		}
     		XSendEvent (_dpy, req->requestor,0,0,&respond);
     		break;
+    	}
     	case SelectionClear:
     		nlwarning("SelectionClear:");
     		_SelectionOwned=false;
     		_CopiedString="";
     		break;
     	case FocusIn:
     		// keyboard focus
     		if (_ic) XSetICFocus(_ic);
-...
     	return true;
+    }
     /**
      * This function copy a selection into propertyName.
      * It is subject to timeout.
+     *
      * @param selection: A Selection Atom
      * @param requestedFormat: Target format Atom
      * @param propertyName: Target property Atom
      * @return true if successfull, false if timeout occured or X11 call failed
      */
     bool CUnixEventEmitter::prepareSelectionContent (Atom selection, Atom requestedFormat, Atom propertyName)
+    {
     	XConvertSelection(_dpy, selection, requestedFormat, propertyName, _win, CurrentTime);
     	XSync (_dpy, False);
     	int i=0;
     	bool gotReply=false;
     	do {
     		XEvent event;
     		usleep(500);
     		gotReply = XCheckTypedWindowEvent(_dpy, _win, SelectionNotify, &event);
     		if (gotReply)
+    		{
     			return true;
+    		}
     		i++;
     	} while (i<20);
     	return false;
+    }
     bool CUnixEventEmitter::copyTextToClipboard(const ucstring &text)
+    {
     	_CopiedString=text;
     	XSetSelectionOwner (_dpy,  XA_CLIPBOARD, _win, CurrentTime);
+    	{
     		Window selectionOwner=XGetSelectionOwner (_dpy, XA_CLIPBOARD);
     		if ( selectionOwner != _win )
+    		{
     			nlwarning("Can't aquire selection");
     			return false;
+    		}
     		_SelectionOwned=true;
     		nlwarning("Owning selection");
     		return true;
+    	}
     	nlwarning("Paste: Can't acquire selection.");
     	return false;
+    }
     bool CUnixEventEmitter::pasteTextFromClipboard(ucstring &text)
+    {
     	// check if we own the selection
     	if (_SelectionOwned)
+    	{
     		text=_CopiedString;
     		return true;
+    	}
     	Window selectionOwner=XGetSelectionOwner (_dpy, XA_CLIPBOARD);
     	if (selectionOwner!=None)
+    	{
     		Atom *supportedTargets, type;
     		uint8 *data;
     		int result;
     		unsigned long nitems, bytesLeft;
     		Atom actualType;
     		int  actualFormat;
     		int bestTargetElect=0, bestTarget=0;
     		nlwarning("Selection owner is %u",selectionOwner);
     		// Find supported methods
     		bool bres=prepareSelectionContent(XA_CLIPBOARD, XA_TARGETS, XA_NEL_SEL);
     		if (!bres)
+    		{
     			nlwarning("Paste: Cannot ennumerate TARGETS");
     			return false;
+    		}
     		result=XGetWindowProperty(_dpy, _win, XA_NEL_SEL, 0, XMaxRequestSize(_dpy), False, AnyPropertyType, &actualType, &actualFormat, &nitems, &bytesLeft,(unsigned char**) &supportedTargets);
     		if (result != Success)
+    		{
     			return false;
+    		}
     		if ( bytesLeft>0 )
+    		{
     			nlwarning("Paste: Supported TARGETS list too long."); // We hope we find what we need in the first packet.
+    		}
     		// Elect best type
     		for (unsigned int i=0; i < nitems; i++)
+    		{
     			nldebug(" - Type=%s", XGetAtomName(_dpy, supportedTargets[i]));
     			if (supportedTargets[i] == XA_STRING )
+    			{
     				if (bestTargetElect < 1)
+    				{
     					bestTarget=XA_STRING;
     					bestTargetElect=1;
+    				}
+    			}
     			if (supportedTargets[i] == XA_UTF8_STRING )
+    			{
     				if (bestTargetElect < 2)
+    				{
     					bestTarget=XA_STRING;
     					bestTargetElect=2;
+    				}
+    			}
+    		}
     		XFree(supportedTargets);
     		if (!bestTargetElect)
+    		{
     			nlwarning("Paste buffer is not a text buffer.");
     			return false;
+    		}
     		// Ask for selection lenght && copy to buffer
     		bres=prepareSelectionContent(XA_CLIPBOARD, bestTarget, XA_NEL_SEL);
     		if (!bres)
+    		{
     			nlwarning ("Paste: cannot obtain data. Aborting.");
     			return false;
+    		}
     		XGetWindowProperty(_dpy, _win, XA_NEL_SEL, 0, XMaxRequestSize(_dpy), False, AnyPropertyType, &actualType, &actualFormat, &nitems, &bytesLeft,(unsigned char**) &data);
     		switch (bestTargetElect)
+    		{
     			case 1: // XA_STRING
     				text=(const char*)data;
     				XFree(data);
     				return true;
     			break;
     			case 2:
     				text=ucstring::makeFromUtf8((const char*)data);
     				XFree(data);
     				return true;
     			default:
     				break;
+    		}
     		nlwarning("Paste: buffer is not a text buffer.");
+    	}
     	nlwarning("Paste: error !");
     	return false;
+    }
     } // NLMISC
     #endif // defined(NL_OS_UNIX) && !defined(NL_OS_MAC)

     	 */
     	bool processMessage(XEvent &event, CEventServer *server = NULL);
     	/**
+    	 *
     	 */
             virtual bool copyTextToClipboard(const ucstring &text);
     	/*
+    	 *
     	 */
     	virtual bool pasteTextFromClipboard(ucstring &text);
     private:
     	// Private internal server message
-...
     	};
     	void createIM();
     	bool prepareSelectionContent (Atom selection, Atom requestedFormat, Atom propertyName);
     	Display*				_dpy;
     	Window					_win;
-...
     	bool					_emulateRawMode;
     	NL3D::IDriver*			_driver;
     	CUnixEventServer		_InternalServer;
     	ucstring		_CopiedString;
     	Atom			_PrecomputedAtom[6];
     	bool			_SelectionOwned;
     };

     	return result;
+    }
     bool CDriverUser::copyTextToClipboard(const ucstring &text)
+    {
     	return _Driver->copyTextToClipboard(text);
+    }
     bool CDriverUser::pasteTextFromClipboard(ucstring &text)
+    {
     	return _Driver->pasteTextFromClipboard(text);
+    }
     } // NL3D

     #include "stdmisc.h"
     #include "nel/misc/event_emitter_multi.h"
     #include "nel/misc/system_utils.h"
     namespace NLMISC
+    {
-...
     	return _Emitters[index].first;
+    }
     bool CEventEmitterMulti::copyTextToClipboard(const ucstring &text)
+    {
     	// Naush: wrapped to old API to avoid duplicate code
     	return CSystemUtils::copyTextToClipboard(text);
+    }
     bool CEventEmitterMulti::pasteTextFromClipboard(ucstring &text)
+    {
     	// Naush: wrapped to old API to avoid duplicate code
     	return CSystemUtils::pasteTextFromClipboard(text);
+    }
     } // NLMISC

     	stopParentBlink();
     	// get the selection and copy it
     	if (CSystemUtils::copyTextToClipboard(getSelection()))
     	if (Driver->copyTextToClipboard(getSelection()))
     		nlinfo ("Chat input was copied in the clipboard");
+    }
-...
     	makeTopWindow();
     	ucstring sString;
     	if (CSystemUtils::pasteTextFromClipboard(sString))
     	if (Driver->pasteTextFromClipboard(sString))
+    	{
     		sint length = (sint)sString.length();