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();