Cleanup.

src/cocoa_window.m

@@ -446,12 +446,10 @@ static int translateKey(unsigned int key)
         window = initWindow;
         trackingArea = nil;
 
-        fileNamesForDrag = (char*)malloc(1024);
+        fileNamesForDrag = malloc(1024);
         fileNamesSize = 1024;
 
         [self updateTrackingAreas];
-        
-        
         [self registerForDraggedTypes:[NSArray arrayWithObjects:
                                        NSFilenamesPboardType, nil]];
     }
@@ -667,55 +665,60 @@ static int translateKey(unsigned int key)
         _glfwInputScroll(window, deltaX, deltaY);
 }
 
-
+- (void)resetCursorRects
-// arturoc: this makes the cursor dissapear when the window is
-// resized or received a drag operation
-/*- (void)resetCursorRects
 {
+    // This makes the cursor dissapear when the window is
+    // resized or received a drag operation
     [self discardCursorRects];
     [self addCursorRect:[self bounds] cursor:_glfw.ns.cursor];
-}*/
+}
 
 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
 {
     if ((NSDragOperationGeneric & [sender draggingSourceOperationMask])
-		== NSDragOperationGeneric) {
+        == NSDragOperationGeneric)
-        
+    {
         [self setNeedsDisplay:YES];
-        
         return NSDragOperationGeneric;
-		
     }
 
     return NSDragOperationNone;
 }
 
-- (BOOL)prepareForDragOperation:(id <NSDraggingInfo>)sender {
+- (BOOL)prepareForDragOperation:(id <NSDraggingInfo>)sender
+{
     [self setNeedsDisplay:YES];
     return YES;
 }
 
-- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender {
+- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
-	NSPasteboard *zPasteboard = [sender draggingPasteboard];
+{
-	NSArray *files = [zPasteboard propertyListForType:NSFilenamesPboardType];
+    NSPasteboard* pasteboard = [sender draggingPasteboard];
+    NSArray* files = [pasteboard propertyListForType:NSFilenamesPboardType];
 
     // set the first char to 0 so strcat
     // starts to add from the beginning
     fileNamesForDrag[0] = 0;
 
-	int dragX = [sender draggingLocation].x;
+    const int dragX = [sender draggingLocation].x;
-	int dragY = [sender draggingLocation].y;
+    const int dragY = [sender draggingLocation].y;
-	
     int dragSize = 1;
-	if ([files count]) {
+
+    if ([files count])
+    {
         NSEnumerator* filenameEnum = [files objectEnumerator];
         NSString* name;
-		while (name = [filenameEnum nextObject]) {
+
+        while (name = [filenameEnum nextObject])
+        {
             dragSize += [name length] + 1;
-			if (dragSize > fileNamesSize){
+
+            if (dragSize > fileNamesSize)
+            {
                 fileNamesSize *= 2;
                 fileNamesForDrag = realloc(fileNamesForDrag, fileNamesSize);
             }
+
             strcat(fileNamesForDrag, [name UTF8String]);
             strcat(fileNamesForDrag, "\n");
         }
@@ -729,7 +732,8 @@ static int translateKey(unsigned int key)
     return YES;
 }
 
-- (void)concludeDragOperation:(id <NSDraggingInfo>)sender {
+- (void)concludeDragOperation:(id <NSDraggingInfo>)sender
+{
     [self setNeedsDisplay:YES];
 }
 

src/input.c

@@ -211,8 +211,8 @@ void _glfwInputCursorEnter(_GLFWwindow* window, int entered)
         window->callbacks.cursorEnter((GLFWwindow*) window, entered);
 }
 
-void _glfwInputDrop(_GLFWwindow* window, const char* dropString){
+void _glfwInputDrop(_GLFWwindow* window, const char* dropString)
-
+{
     if (window->callbacks.drop)
         window->callbacks.drop((GLFWwindow*) window, dropString);
 }
@@ -403,11 +403,8 @@ GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* handle,
 GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* handle, GLFWdropfun cbfun)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWdropfun previous;
-
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
+    _GLFW_SWAP_POINTERS(window->callbacks.drop, cbfun);
-    previous = window->callbacks.drop;
+    return cbfun;
-    window->callbacks.drop = cbfun;
-    return previous;
 }
+

src/win32_init.c

@@ -215,7 +215,7 @@ int _glfwPlatformInit(void)
     if (!_glfwInitContextAPI())
         return GL_FALSE;
 
-	_glfw.win32.dropString = (char*)malloc(1000);
+    _glfw.win32.dropString = malloc(1000);
 	_glfw.win32.dropStringSize = 1000;
 
     _glfwInitTimer();

src/win32_window.c

@@ -749,30 +749,35 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
             // TODO: Restore vsync if compositing was disabled
             break;
         }
+
         case WM_DROPFILES:
         {
-			TCHAR szName[MAX_PATH];
+            WCHAR szName[MAX_PATH];
             HDROP hDrop = (HDROP) wParam;
             POINT pt;
-			int numFiles = DragQueryFile(hDrop, 0xFFFFFFFF, szName, MAX_PATH);
+            const int numFiles = DragQueryFile(hDrop, 0xffffffff, szName, MAX_PATH);
-			int currentSize = 1;
+            int i, currentSize = 1;
-			int i;
             char* utf8str;
-			DragQueryPoint(hDrop, &pt);
 
             // Move the mouse to the position of the drop
+            DragQueryPoint(hDrop, &pt);
             _glfwInputCursorMotion(window, pt.x, pt.y);
 
             memset(_glfw.win32.dropString, 0, _glfw.win32.dropStringSize);
+
             for (i = 0;  i < numFiles;  i++)
             {
                 DragQueryFile(hDrop, i, szName, MAX_PATH);
-				utf8str = _glfwCreateUTF8FromWideString((const wchar_t*)szName);
+                utf8str = _glfwCreateUTF8FromWideString((const WCHAR*) szName);
                 currentSize += strlen(utf8str);
-				if(_glfw.win32.dropStringSize < currentSize){
+
+                if (_glfw.win32.dropStringSize < currentSize)
+                {
                     _glfw.win32.dropStringSize *= 2;
-					_glfw.win32.dropString = (char*)realloc(_glfw.win32.dropString,_glfw.win32.dropStringSize);
+                    _glfw.win32.dropString = realloc(_glfw.win32.dropString,
+                                                     _glfw.win32.dropStringSize);
                 }
+
                 strcat(_glfw.win32.dropString, utf8str);
                 strcat(_glfw.win32.dropString, "\n");
                 free(utf8str);

src/x11_init.c

@@ -540,8 +540,6 @@ static GLboolean initExtensions(void)
         XInternAtom(_glfw.x11.display, "SAVE_TARGETS", False);
 
     // Find or create drag and drop atoms
-
-	//Atoms for Xdnd
     _glfw.x11.XdndAware = XInternAtom(_glfw.x11.display, "XdndAware", True);
     _glfw.x11.XdndEnter = XInternAtom(_glfw.x11.display, "XdndEnter", True);
     _glfw.x11.XdndPosition = XInternAtom(_glfw.x11.display, "XdndPosition", True);
@@ -552,8 +550,6 @@ static GLboolean initExtensions(void)
     _glfw.x11.XdndFinished = XInternAtom(_glfw.x11.display, "XdndFinished", True);
     _glfw.x11.XdndSelection = XInternAtom(_glfw.x11.display, "XdndSelection", True);
 
-
-
     return GL_TRUE;
 }
 

src/x11_platform.h

@@ -129,6 +129,7 @@ typedef struct _GLFWlibraryX11
 	Atom			XdndLeave;
 	Atom			XdndFinished;
 	Atom			XdndSelection;
+
 	struct {
 		Window      sourceWindow;
 		char*		string;

src/x11_window.c

@@ -306,12 +306,14 @@ static GLboolean createWindow(_GLFWwindow* window,
         XISelectEvents(_glfw.x11.display, window->x11.handle, &eventmask, 1);
     }
 
-    // Enable Xdnd
+    if (_glfw.x11.XdndAware)
-    if(_glfw.x11.XdndAware!=None)
     {
-    	//Announce XDND support
+        // Announce support for XDND version 5 and below
-		Atom version=5;
+
-		XChangeProperty(_glfw.x11.display, window->x11.handle, _glfw.x11.XdndAware, XA_ATOM, 32, PropModeReplace, (unsigned char*)&version, 1);
+        const Atom version = 5;
+        XChangeProperty(_glfw.x11.display, window->x11.handle,
+                        _glfw.x11.XdndAware, XA_ATOM, 32,
+                        PropModeReplace, (unsigned char*) &version, 1);
     }
 
     _glfwPlatformSetWindowTitle(window, wndconfig->title);
@@ -716,10 +718,9 @@ static void processEvent(XEvent *event)
             }
             else if (event->xclient.message_type == _glfw.x11.XdndEnter)
             {
-            	// Xdnd Enter: the drag&drop event has started in the window,
+                // Xdnd Enter: the drag&drop event has started in the window, we
-            	// we could be getting the type and possible conversions here
+                // could be getting the type and possible conversions here but
-            	// but since we use always string conversion we don't need
+                // since we use always string conversion we don't need it
-            	// it
             }
             else if (event->xclient.message_type == _glfw.x11.XdndDrop)
             {
@@ -731,45 +732,43 @@ static void processEvent(XEvent *event)
                                   _glfw.x11.UTF8_STRING,
                                   _glfw.x11.XdndSelection,
                                   window->x11.handle, CurrentTime);
-
             }
             else if (event->xclient.message_type == _glfw.x11.XdndLeave)
             {
-
             }
             else if (event->xclient.message_type == _glfw.x11.XdndPosition)
             {
                 // Xdnd Position: get coordinates of the mouse inside the window
                 // and update the mouse position
-            	int absX = (event->xclient.data.l[2]>>16) & 0xFFFF;
+                const int absX = (event->xclient.data.l[2] >> 16) & 0xFFFF;
-            	int absY = (event->xclient.data.l[2]) & 0xFFFF;
+                const int absY = (event->xclient.data.l[2]) & 0xFFFF;
-            	int x;
+                int x, y;
-            	int y;
 
                 _glfwPlatformGetWindowPos(window, &x, &y);
-
                 _glfwInputCursorMotion(window, absX - x, absY - y);
 
                 // Xdnd: reply with an XDND status message
-				XClientMessageEvent m;
+                XEvent reply;
-				memset(&m, sizeof(m), 0);
+                memset(&reply, sizeof(reply), 0);
-				m.type = ClientMessage;
+
-				m.display = event->xclient.display;
+                reply.type = ClientMessage;
-				m.window = event->xclient.data.l[0];
+                reply.xclient.window = event->xclient.data.l[0];
-				m.message_type = _glfw.x11.XdndStatus;
+                reply.xclient.message_type = _glfw.x11.XdndStatus;
-				m.format=32;
+                reply.xclient.format = 32;
-				m.data.l[0] = window->x11.handle;
+                reply.xclient.data.l[0] = window->x11.handle;
-				m.data.l[1] = 1; // Always accept the dnd with no rectangle
+                reply.xclient.data.l[1] = 1; // Always accept the dnd with no rectangle
-				m.data.l[2] = 0; // Specify an empty rectangle
+                reply.xclient.data.l[2] = 0; // Specify an empty rectangle
-				m.data.l[3] = 0;
+                reply.xclient.data.l[3] = 0;
-				m.data.l[4] = _glfw.x11.XdndActionCopy; // We only accept copying
+                reply.xclient.data.l[4] = _glfw.x11.XdndActionCopy; // We only accept copying
-
+
-				XSendEvent(_glfw.x11.display, event->xclient.data.l[0], False, NoEventMask, (XEvent*)&m);
+                XSendEvent(_glfw.x11.display, window->x11.handle,
+                           False, NoEventMask, &reply);
                 XFlush(_glfw.x11.display);
             }
 
             break;
         }
+
         case SelectionNotify:
         {
             if (event->xselection.property != None)
@@ -777,23 +776,27 @@ static void processEvent(XEvent *event)
                 // Xdnd: got a selection notification from the conversion
                 // we asked for, get the data and finish the d&d event
                 char* data;
+
                 free(_glfw.x11.xdnd.string);
                 _glfw.x11.xdnd.string = NULL;
-				int result = _glfwGetWindowProperty(event->xselection.requestor,
+
+                const int result = _glfwGetWindowProperty(event->xselection.requestor,
                                                           event->xselection.property,
                                                           event->xselection.target,
                                                           (unsigned char**) &data);
 
-				if(result){
+                if (result)
-					// nautilus seems to add a \r at the end of the paths
+                {
+                    // Nautilus seems to add a \r at the end of the paths
                     // remove it so paths can be directly used
                     _glfw.x11.xdnd.string = malloc(strlen(data));
                     char *to = _glfw.x11.xdnd.string;
                     const char *from = data;
                     const char *current = strchr(from, '\r');
+
                     while (current)
                     {
-						int charsToCopy = current - from;
+                        const int charsToCopy = current - from;
                         memcpy(to, from, (size_t) charsToCopy);
                         to += charsToCopy;
 
@@ -801,37 +804,33 @@ static void processEvent(XEvent *event)
                         current = strchr(from, '\r');
                     }
 
-					size_t remaining = strlen(from);
+                    const size_t remaining = strlen(from);
 
                     memcpy(to, from, remaining);
                     to += remaining;
                     *to = 0;
                 }
 
-				XClientMessageEvent m;
+                XEvent reply;
-				memset(&m, sizeof(m), 0);
+                memset(&reply, sizeof(reply), 0);
-				m.type = ClientMessage;
+                reply.type = ClientMessage;
-				m.display = _glfw.x11.display;
+                reply.xclient.window = _glfw.x11.xdnd.sourceWindow;
-				m.window = _glfw.x11.xdnd.sourceWindow;
+                reply.xclient.message_type = _glfw.x11.XdndFinished;
-				m.message_type = _glfw.x11.XdndFinished;
+                reply.xclient.format = 32;
-				m.format=32;
+                reply.xclient.data.l[0] = window->x11.handle;
-				m.data.l[0] = window->x11.handle;
+                reply.xclient.data.l[1] = result;
-				m.data.l[1] = result;
+                reply.xclient.data.l[2] = _glfw.x11.XdndActionCopy; // We only ever copy
-				m.data.l[2] = _glfw.x11.XdndActionCopy; //We only ever copy.
-
-				// Reply that all is well.
-				XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.sourceWindow, False, NoEventMask, (XEvent*)&m);
 
+                // Reply that all is well
+                XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.sourceWindow,
+                           False, NoEventMask, &reply);
                 XSync(_glfw.x11.display, False);
-
                 XFree(data);
 
                 if (result)
-				{
                     _glfwInputDrop(window, _glfw.x11.xdnd.string);
-
-				}
             }
+
             break;
         }