Remove $Id$ tags, update URL's, and more

- remove obsolete svn '$Id$' tags from all source files
- update .fl files and generated files accordingly
- replace 'http://www.fltk.org' URL's with 'https://...'
- replace bug report URL 'str.php' with 'bugs.php'
- remove trailing whitespace
- fix other whitespace errors flagged by Git
- add and/or fix missing or wrong standard headers
- convert tabs to spaces in all source files

The only relevant code changes are in the fluid/ folder where
some .fl files and other source files were used to generate
the '$Id' headers and footers.

1 files changed, 583 insertions, 589 deletions

diff --git a/src/Fl_win32.cxx b/src/Fl_win32.cxx
index 4ec2531ff..d234f7afd 100644
--- a/src/Fl_win32.cxx
+++ b/src/Fl_win32.cxx
@@ -1,6 +1,4 @@
 //
-// "$Id$"
-//
 // Windows-specific code for the Fast Light Tool Kit (FLTK).
 //
 // Copyright 1998-2018 by Bill Spitzak and others.
@@ -9,11 +7,11 @@
 // the file "COPYING" which should have been included with this file.  If this
 // file is missing or damaged, see the license at:
 //
-//     http://www.fltk.org/COPYING.php
+//     https://www.fltk.org/COPYING.php
 //
-// Please report all bugs and problems on the following page:
+// Please see the following page on how to report bugs and issues:
 //
-//     http://www.fltk.org/str.php
+//     https://www.fltk.org/bugs.php
 //
 
 // This file contains Windows-specific code for FLTK which is always linked
@@ -81,7 +79,7 @@ void fl_cleanup_dc_list(void);
 #endif
 
 #if !defined(NO_TRACK_MOUSE)
-#  include <commctrl.h>	// TrackMouseEvent
+#  include <commctrl.h> // TrackMouseEvent
 #endif
 
 #if defined(__GNUC__)
@@ -261,7 +259,7 @@ static Fl_Window *track_mouse_win = 0; // current TrackMouseEvent() window
 #endif
 
 #ifndef WHEEL_DELTA
-#  define WHEEL_DELTA 120	// according to MSDN.
+#  define WHEEL_DELTA 120       // according to MSDN.
 #endif
 
 // This is only defined on Vista and upwards...
@@ -354,7 +352,7 @@ void Fl_WinAPI_System_Driver::remove_fd(int n, int events) {
     if (fd[i].fd == n) {
       short e = fd[i].events & ~events;
       if (!e)
-	continue; // if no events left, delete this fd
+        continue; // if no events left, delete this fd
       fd[i].events = e;
     }
     // move it down in the array if necessary:
@@ -433,22 +431,22 @@ double Fl_WinAPI_Screen_Driver::wait(double time_to_wait) {
     if (get_wsock_mod() && s_wsock_select(maxfd + 1, &fdt[0], &fdt[1], &fdt[2], &t)) {
       // We got something - do the callback!
       for (int i = 0; i < nfds; i++) {
-	SOCKET f = fd[i].fd;
-	short revents = 0;
-	if (fl_wsk_fd_is_set(f, &fdt[0]))
-	  revents |= FL_READ;
-	if (fl_wsk_fd_is_set(f, &fdt[1]))
-	  revents |= FL_WRITE;
-	if (fl_wsk_fd_is_set(f, &fdt[2]))
-	  revents |= FL_EXCEPT;
-	if (fd[i].events & revents)
-	  fd[i].cb(f, fd[i].arg);
+        SOCKET f = fd[i].fd;
+        short revents = 0;
+        if (fl_wsk_fd_is_set(f, &fdt[0]))
+          revents |= FL_READ;
+        if (fl_wsk_fd_is_set(f, &fdt[1]))
+          revents |= FL_WRITE;
+        if (fl_wsk_fd_is_set(f, &fdt[2]))
+          revents |= FL_EXCEPT;
+        if (fd[i].events & revents)
+          fd[i].cb(f, fd[i].arg);
       }
       time_to_wait = 0.0; // just peek for any messages
     } else {
       // we need to check them periodically, so set a short timeout:
       if (time_to_wait > .001)
-	time_to_wait = .001;
+        time_to_wait = .001;
     }
   }
 
@@ -673,15 +671,15 @@ public:
     // Predict size of \r\n conversion buffer
     for (i = in, lencount = inlen; lencount > 0; lencount--) {
       if (*i == '\r' && *(i + 1) == '\n' && lencount >= 2) { // leave \r\n untranslated
-	i += 2;
-	outlen += 2;
-	lencount--;
+        i += 2;
+        outlen += 2;
+        lencount--;
       } else if (*i == '\n') { // \n by itself? leave room to insert \r
-	i++;
-	outlen += 2;
+        i++;
+        outlen += 2;
       } else {
-	++i;
-	++outlen;
+        ++i;
+        ++outlen;
       }
     }
     // Alloc conversion buffer + NULL
@@ -689,14 +687,14 @@ public:
     // Handle \n -> \r\n conversion
     for (i = in, o = out, lencount = inlen; lencount > 0; lencount--) {
       if (*i == '\r' && *(i + 1) == '\n' && lencount >= 2) { // leave \r\n untranslated
-	*o++ = *i++;
-	*o++ = *i++;
-	lencount--;
+        *o++ = *i++;
+        *o++ = *i++;
+        lencount--;
       } else if (*i == '\n') { // \n by itself? insert \r
-	*o++ = '\r';
-	*o++ = *i++;
+        *o++ = '\r';
+        *o++ = *i++;
       } else {
-	*o++ = *i++;
+        *o++ = *i++;
       }
     }
     *o++ = 0;
@@ -886,9 +884,9 @@ void Fl_WinAPI_System_Driver::paste(Fl_Widget &receiver, int clipboard, const ch
         RECT rect = {0, 0, width, height};
         Fl_Image_Surface *surf = new Fl_Image_Surface(width, height, 1);
         Fl_Surface_Device::push_current(surf);
-        fl_color(FL_WHITE);		// draw white background
+        fl_color(FL_WHITE);             // draw white background
         fl_rectf(0, 0, width, height);
-        rect.right *= scaling;		// apply scaling to the metafile draw operation
+        rect.right *= scaling;          // apply scaling to the metafile draw operation
         rect.bottom *= scaling;
         PlayEnhMetaFile((HDC)fl_graphics_driver->gc(), (HENHMETAFILE)h, &rect); // draw metafile to offscreen buffer
         image = surf->image();
@@ -1008,7 +1006,7 @@ void fl_get_codepage() {
 HWND fl_capture;
 
 static int mouse_event(Fl_Window *window, int what, int button,
-		       WPARAM wParam, LPARAM lParam) {
+                       WPARAM wParam, LPARAM lParam) {
   static int px, py, pmx, pmy;
   POINT pt;
   float scale = Fl_Graphics_Driver::default_driver().scale();
@@ -1042,18 +1040,18 @@ static int mouse_event(Fl_Window *window, int what, int button,
   switch (what) {
     case 1: // double-click
       if (Fl::e_is_click) {
-	Fl::e_clicks++;
-	goto J1;
+        Fl::e_clicks++;
+        goto J1;
       }
     case 0: // single-click
       Fl::e_clicks = 0;
     J1:
 #ifdef USE_CAPTURE_MOUSE_WIN
       if (!fl_capture)
-	SetCapture(fl_xid(mouse_window)); // use mouse window
+        SetCapture(fl_xid(mouse_window)); // use mouse window
 #else
       if (!fl_capture)
-	SetCapture(fl_xid(window)); // use main window
+        SetCapture(fl_xid(window)); // use main window
 #endif
       Fl::e_keysym = FL_Button + button;
       Fl::e_is_click = 1;
@@ -1063,7 +1061,7 @@ static int mouse_event(Fl_Window *window, int what, int button,
 
     case 2: // release:
       if (!fl_capture)
-	ReleaseCapture();
+        ReleaseCapture();
       Fl::e_keysym = FL_Button + button;
       return Fl::handle(FL_RELEASE, window);
 
@@ -1071,11 +1069,11 @@ static int mouse_event(Fl_Window *window, int what, int button,
     default: // avoid compiler warning
       // Windows produces extra events even if the mouse does not move, ignore em:
       if (Fl::e_x_root == pmx && Fl::e_y_root == pmy)
-	return 1;
+        return 1;
       pmx = Fl::e_x_root;
       pmy = Fl::e_y_root;
       if (abs(Fl::e_x_root - px) > 5 || abs(Fl::e_y_root - py) > 5)
-	Fl::e_is_click = 0;
+        Fl::e_is_click = 0;
       return Fl::handle(FL_MOVE, window);
   }
 }
@@ -1086,68 +1084,68 @@ static int mouse_event(Fl_Window *window, int what, int button,
 static const struct {
   unsigned short vk, fltk, extended;
 } vktab[] = {
-  {VK_BACK,	FL_BackSpace},
-  {VK_TAB,	FL_Tab},
-  {VK_CLEAR,	FL_KP+'5',	0xff0b/*XK_Clear*/},
-  {VK_RETURN,	FL_Enter,	FL_KP_Enter},
-  {VK_SHIFT,	FL_Shift_L,	FL_Shift_R},
-  {VK_CONTROL,	FL_Control_L,	FL_Control_R},
-  {VK_MENU,	FL_Alt_L,	FL_Alt_R},
-  {VK_PAUSE,	FL_Pause},
-  {VK_CAPITAL,	FL_Caps_Lock},
-  {VK_ESCAPE,	FL_Escape},
-  {VK_SPACE,	' '},
-  {VK_PRIOR,	FL_KP+'9',	FL_Page_Up},
-  {VK_NEXT,	FL_KP+'3',	FL_Page_Down},
-  {VK_END,	FL_KP+'1',	FL_End},
-  {VK_HOME,	FL_KP+'7',	FL_Home},
-  {VK_LEFT,	FL_KP+'4',	FL_Left},
-  {VK_UP,	FL_KP+'8',	FL_Up},
-  {VK_RIGHT,	FL_KP+'6',	FL_Right},
-  {VK_DOWN,	FL_KP+'2',	FL_Down},
-  {VK_SNAPSHOT,	FL_Print},	// does not work on NT
-  {VK_INSERT,	FL_KP+'0',	FL_Insert},
-  {VK_DELETE,	FL_KP+'.',	FL_Delete},
-  {VK_LWIN,	FL_Meta_L},
-  {VK_RWIN,	FL_Meta_R},
-  {VK_APPS,	FL_Menu},
+  {VK_BACK,     FL_BackSpace},
+  {VK_TAB,      FL_Tab},
+  {VK_CLEAR,    FL_KP+'5',      0xff0b/*XK_Clear*/},
+  {VK_RETURN,   FL_Enter,       FL_KP_Enter},
+  {VK_SHIFT,    FL_Shift_L,     FL_Shift_R},
+  {VK_CONTROL,  FL_Control_L,   FL_Control_R},
+  {VK_MENU,     FL_Alt_L,       FL_Alt_R},
+  {VK_PAUSE,    FL_Pause},
+  {VK_CAPITAL,  FL_Caps_Lock},
+  {VK_ESCAPE,   FL_Escape},
+  {VK_SPACE,    ' '},
+  {VK_PRIOR,    FL_KP+'9',      FL_Page_Up},
+  {VK_NEXT,     FL_KP+'3',      FL_Page_Down},
+  {VK_END,      FL_KP+'1',      FL_End},
+  {VK_HOME,     FL_KP+'7',      FL_Home},
+  {VK_LEFT,     FL_KP+'4',      FL_Left},
+  {VK_UP,       FL_KP+'8',      FL_Up},
+  {VK_RIGHT,    FL_KP+'6',      FL_Right},
+  {VK_DOWN,     FL_KP+'2',      FL_Down},
+  {VK_SNAPSHOT, FL_Print},      // does not work on NT
+  {VK_INSERT,   FL_KP+'0',      FL_Insert},
+  {VK_DELETE,   FL_KP+'.',      FL_Delete},
+  {VK_LWIN,     FL_Meta_L},
+  {VK_RWIN,     FL_Meta_R},
+  {VK_APPS,     FL_Menu},
   {VK_SLEEP, FL_Sleep},
-  {VK_MULTIPLY,	FL_KP+'*'},
-  {VK_ADD,	FL_KP+'+'},
-  {VK_SUBTRACT,	FL_KP+'-'},
-  {VK_DECIMAL,	FL_KP+'.'},
-  {VK_DIVIDE,	FL_KP+'/'},
-  {VK_NUMLOCK,	FL_Num_Lock},
-  {VK_SCROLL,	FL_Scroll_Lock},
+  {VK_MULTIPLY, FL_KP+'*'},
+  {VK_ADD,      FL_KP+'+'},
+  {VK_SUBTRACT, FL_KP+'-'},
+  {VK_DECIMAL,  FL_KP+'.'},
+  {VK_DIVIDE,   FL_KP+'/'},
+  {VK_NUMLOCK,  FL_Num_Lock},
+  {VK_SCROLL,   FL_Scroll_Lock},
 #if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0500)
-  {VK_BROWSER_BACK,	FL_Back},
-  {VK_BROWSER_FORWARD,	FL_Forward},
-  {VK_BROWSER_REFRESH,	FL_Refresh},
-  {VK_BROWSER_STOP,	FL_Stop},
-  {VK_BROWSER_SEARCH,	FL_Search},
+  {VK_BROWSER_BACK,     FL_Back},
+  {VK_BROWSER_FORWARD,  FL_Forward},
+  {VK_BROWSER_REFRESH,  FL_Refresh},
+  {VK_BROWSER_STOP,     FL_Stop},
+  {VK_BROWSER_SEARCH,   FL_Search},
   {VK_BROWSER_FAVORITES, FL_Favorites},
-  {VK_BROWSER_HOME,	FL_Home_Page},
-  {VK_VOLUME_MUTE,	FL_Volume_Mute},
-  {VK_VOLUME_DOWN,	FL_Volume_Down},
-  {VK_VOLUME_UP,	FL_Volume_Up},
-  {VK_MEDIA_NEXT_TRACK,	FL_Media_Next},
-  {VK_MEDIA_PREV_TRACK,	FL_Media_Prev},
-  {VK_MEDIA_STOP,	FL_Media_Stop},
-  {VK_MEDIA_PLAY_PAUSE,	FL_Media_Play},
-  {VK_LAUNCH_MAIL,	FL_Mail},
+  {VK_BROWSER_HOME,     FL_Home_Page},
+  {VK_VOLUME_MUTE,      FL_Volume_Mute},
+  {VK_VOLUME_DOWN,      FL_Volume_Down},
+  {VK_VOLUME_UP,        FL_Volume_Up},
+  {VK_MEDIA_NEXT_TRACK, FL_Media_Next},
+  {VK_MEDIA_PREV_TRACK, FL_Media_Prev},
+  {VK_MEDIA_STOP,       FL_Media_Stop},
+  {VK_MEDIA_PLAY_PAUSE, FL_Media_Play},
+  {VK_LAUNCH_MAIL,      FL_Mail},
 #endif
-  {0xba,	';'},
-  {0xbb,	'='},
-  {0xbc,	','},
-  {0xbd,	'-'},
-  {0xbe,	'.'},
-  {0xbf,	'/'},
-  {0xc0,	'`'},
-  {0xdb,	'['},
-  {0xdc,	'\\'},
-  {0xdd,	']'},
-  {0xde,	'\''},
-  {VK_OEM_102,	FL_Iso_Key}
+  {0xba,        ';'},
+  {0xbb,        '='},
+  {0xbc,        ','},
+  {0xbd,        '-'},
+  {0xbe,        '.'},
+  {0xbf,        '/'},
+  {0xc0,        '`'},
+  {0xdb,        '['},
+  {0xdc,        '\\'},
+  {0xdd,        ']'},
+  {0xde,        '\''},
+  {VK_OEM_102,  FL_Iso_Key}
 };
 static int ms2fltk(WPARAM vk, int extended) {
   static unsigned short vklut[256];
@@ -1166,7 +1164,7 @@ static int ms2fltk(WPARAM vk, int extended) {
     }
     for (i = 0; i < 256; i++)
       if (!extendedlut[i])
-	extendedlut[i] = vklut[i];
+        extendedlut[i] = vklut[i];
   }
   return extended ? extendedlut[vk] : vklut[vk];
 }
@@ -1202,434 +1200,434 @@ static LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lPar
     switch (uMsg) {
 
       case WM_DPICHANGED: { // 0x02E0
-	if (is_dpi_aware && !Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.busy) {
-	  RECT r;
+        if (is_dpi_aware && !Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.busy) {
+          RECT r;
           Fl_WinAPI_Screen_Driver *sd = (Fl_WinAPI_Screen_Driver*)Fl::screen_driver();
           int ns = Fl_Window_Driver::driver(window)->screen_num();
           sd->dpi[ns][0] = sd->dpi[ns][1] = HIWORD(wParam);
-	  float f = HIWORD(wParam) / 96.;
-	  GetClientRect(hWnd, &r);
-	  float old_f = float(r.right) / window->w();
-	  Fl::screen_driver()->scale(ns, f);
-	  Fl_Window_Driver::driver(window)->resize_after_scale_change(ns, old_f, f);
-	}
-	return 0;
+          float f = HIWORD(wParam) / 96.;
+          GetClientRect(hWnd, &r);
+          float old_f = float(r.right) / window->w();
+          Fl::screen_driver()->scale(ns, f);
+          Fl_Window_Driver::driver(window)->resize_after_scale_change(ns, old_f, f);
+        }
+        return 0;
       }
 
       case WM_QUIT: // this should not happen?
-	Fl::fatal("WM_QUIT message");
+        Fl::fatal("WM_QUIT message");
 
       case WM_CLOSE: // user clicked close box
-	Fl::handle(FL_CLOSE, window);
-	return 0;
+        Fl::handle(FL_CLOSE, window);
+        return 0;
 
       case WM_SYNCPAINT:
       case WM_NCPAINT:
       case WM_ERASEBKGND:
-	// Andreas Weitl - WM_SYNCPAINT needs to be passed to DefWindowProc
-	// so that Windows can generate the proper paint messages...
-	// Similarly, WM_NCPAINT and WM_ERASEBKGND need this, too...
-	break;
+        // Andreas Weitl - WM_SYNCPAINT needs to be passed to DefWindowProc
+        // so that Windows can generate the proper paint messages...
+        // Similarly, WM_NCPAINT and WM_ERASEBKGND need this, too...
+        break;
 
       case WM_PAINT: {
-	Fl_Region R, R2;
-	Fl_X *i = Fl_X::i(window);
-	Fl_Window_Driver::driver(window)->wait_for_expose_value = 0;
-	char redraw_whole_window = false;
-	if (!i->region && window->damage()) {
-	  // Redraw the whole window...
-	  i->region = CreateRectRgn(0, 0, window->w(), window->h());
-	  redraw_whole_window = true;
-	}
-
-	// We need to merge Windows' damage into FLTK's damage.
-	R = CreateRectRgn(0, 0, 0, 0);
-	int r = GetUpdateRgn(hWnd, R, 0);
-	if (r == NULLREGION && !redraw_whole_window) {
-	  DeleteObject(R);
-	  break;
-	}
-
-	// convert i->region in FLTK units to R2 in drawing units
-	R2 = Fl_GDI_Graphics_Driver::scale_region(i->region, scale, NULL);
-
-	if (R2) {
-	  // Also tell Windows that we are drawing someplace else as well...
-	  CombineRgn(R2, R2, R, RGN_OR);
-	  DeleteObject(R);
-	} else {
-	  R2 = R;
-	}
-	if (window->type() == FL_DOUBLE_WINDOW)
-	  ValidateRgn(hWnd, 0);
-	else {
-	  ValidateRgn(hWnd, R2);
-	}
-
-	// convert R2 in drawing units to i->region in FLTK units
-	i->region = Fl_GDI_Graphics_Driver::scale_region(R2, 1 / scale, NULL);
-
-	window->clear_damage((uchar)(window->damage() | FL_DAMAGE_EXPOSE));
-	// These next two statements should not be here, so that all update
-	// is deferred until Fl::flush() is called during idle.  However Windows
-	// apparently is very unhappy if we don't obey it and draw right now.
-	// Very annoying!
-	fl_GetDC(hWnd); // Make sure we have a DC for this window...
-	fl_save_pen();
-	Fl_Window_Driver::driver(window)->flush();
-	fl_restore_pen();
-	window->clear_damage();
-	return 0;
+        Fl_Region R, R2;
+        Fl_X *i = Fl_X::i(window);
+        Fl_Window_Driver::driver(window)->wait_for_expose_value = 0;
+        char redraw_whole_window = false;
+        if (!i->region && window->damage()) {
+          // Redraw the whole window...
+          i->region = CreateRectRgn(0, 0, window->w(), window->h());
+          redraw_whole_window = true;
+        }
+
+        // We need to merge Windows' damage into FLTK's damage.
+        R = CreateRectRgn(0, 0, 0, 0);
+        int r = GetUpdateRgn(hWnd, R, 0);
+        if (r == NULLREGION && !redraw_whole_window) {
+          DeleteObject(R);
+          break;
+        }
+
+        // convert i->region in FLTK units to R2 in drawing units
+        R2 = Fl_GDI_Graphics_Driver::scale_region(i->region, scale, NULL);
+
+        if (R2) {
+          // Also tell Windows that we are drawing someplace else as well...
+          CombineRgn(R2, R2, R, RGN_OR);
+          DeleteObject(R);
+        } else {
+          R2 = R;
+        }
+        if (window->type() == FL_DOUBLE_WINDOW)
+          ValidateRgn(hWnd, 0);
+        else {
+          ValidateRgn(hWnd, R2);
+        }
+
+        // convert R2 in drawing units to i->region in FLTK units
+        i->region = Fl_GDI_Graphics_Driver::scale_region(R2, 1 / scale, NULL);
+
+        window->clear_damage((uchar)(window->damage() | FL_DAMAGE_EXPOSE));
+        // These next two statements should not be here, so that all update
+        // is deferred until Fl::flush() is called during idle.  However Windows
+        // apparently is very unhappy if we don't obey it and draw right now.
+        // Very annoying!
+        fl_GetDC(hWnd); // Make sure we have a DC for this window...
+        fl_save_pen();
+        Fl_Window_Driver::driver(window)->flush();
+        fl_restore_pen();
+        window->clear_damage();
+        return 0;
       } // case WM_PAINT
 
       case WM_LBUTTONDOWN:
-	mouse_event(window, 0, 1, wParam, lParam);
-	return 0;
+        mouse_event(window, 0, 1, wParam, lParam);
+        return 0;
       case WM_LBUTTONDBLCLK:
-	mouse_event(window, 1, 1, wParam, lParam);
-	return 0;
+        mouse_event(window, 1, 1, wParam, lParam);
+        return 0;
       case WM_LBUTTONUP:
-	mouse_event(window, 2, 1, wParam, lParam);
-	return 0;
+        mouse_event(window, 2, 1, wParam, lParam);
+        return 0;
       case WM_MBUTTONDOWN:
-	mouse_event(window, 0, 2, wParam, lParam);
-	return 0;
+        mouse_event(window, 0, 2, wParam, lParam);
+        return 0;
       case WM_MBUTTONDBLCLK:
-	mouse_event(window, 1, 2, wParam, lParam);
-	return 0;
+        mouse_event(window, 1, 2, wParam, lParam);
+        return 0;
       case WM_MBUTTONUP:
-	mouse_event(window, 2, 2, wParam, lParam);
-	return 0;
+        mouse_event(window, 2, 2, wParam, lParam);
+        return 0;
       case WM_RBUTTONDOWN:
-	mouse_event(window, 0, 3, wParam, lParam);
-	return 0;
+        mouse_event(window, 0, 3, wParam, lParam);
+        return 0;
       case WM_RBUTTONDBLCLK:
-	mouse_event(window, 1, 3, wParam, lParam);
-	return 0;
+        mouse_event(window, 1, 3, wParam, lParam);
+        return 0;
       case WM_RBUTTONUP:
-	mouse_event(window, 2, 3, wParam, lParam);
-	return 0;
+        mouse_event(window, 2, 3, wParam, lParam);
+        return 0;
 
       case WM_MOUSEMOVE:
 #ifdef USE_TRACK_MOUSE
-	if (track_mouse_win != window) {
-	  TRACKMOUSEEVENT tme;
-	  tme.cbSize    = sizeof(TRACKMOUSEEVENT);
-	  tme.dwFlags   = TME_LEAVE;
-	  tme.hwndTrack = hWnd;
-	  _TrackMouseEvent(&tme);
-	  track_mouse_win = window;
-	}
-#endif	// USE_TRACK_MOUSE
-	mouse_event(window, 3, 0, wParam, lParam);
-	return 0;
+        if (track_mouse_win != window) {
+          TRACKMOUSEEVENT tme;
+          tme.cbSize    = sizeof(TRACKMOUSEEVENT);
+          tme.dwFlags   = TME_LEAVE;
+          tme.hwndTrack = hWnd;
+          _TrackMouseEvent(&tme);
+          track_mouse_win = window;
+        }
+#endif  // USE_TRACK_MOUSE
+        mouse_event(window, 3, 0, wParam, lParam);
+        return 0;
 
       case WM_MOUSELEAVE:
-	if (track_mouse_win == window) { // we left the top level window !
-	  Fl_Window *tw = window;
-	  while (tw->parent()) // find top level window
-	    tw = tw->window();
-	  Fl::belowmouse(0);
-	  Fl::handle(FL_LEAVE, tw);
-	}
-	track_mouse_win = 0; // force TrackMouseEvent() restart
-	break;
+        if (track_mouse_win == window) { // we left the top level window !
+          Fl_Window *tw = window;
+          while (tw->parent()) // find top level window
+            tw = tw->window();
+          Fl::belowmouse(0);
+          Fl::handle(FL_LEAVE, tw);
+        }
+        track_mouse_win = 0; // force TrackMouseEvent() restart
+        break;
 
       case WM_SETFOCUS:
-	if ((Fl::modal_) && (Fl::modal_ != window)) {
-	  SetFocus(fl_xid(Fl::modal_));
-	  return 0;
-	}
-	Fl::handle(FL_FOCUS, window);
-	break;
+        if ((Fl::modal_) && (Fl::modal_ != window)) {
+          SetFocus(fl_xid(Fl::modal_));
+          return 0;
+        }
+        Fl::handle(FL_FOCUS, window);
+        break;
 
       case WM_KILLFOCUS:
-	Fl::handle(FL_UNFOCUS, window);
-	Fl::flush(); // it never returns to main loop when deactivated...
-	break;
+        Fl::handle(FL_UNFOCUS, window);
+        Fl::flush(); // it never returns to main loop when deactivated...
+        break;
 
       case WM_SHOWWINDOW:
-	if (!window->parent()) {
-	  Fl::handle(wParam ? FL_SHOW : FL_HIDE, window);
-	}
-	break;
+        if (!window->parent()) {
+          Fl::handle(wParam ? FL_SHOW : FL_HIDE, window);
+        }
+        break;
 
       case WM_ACTIVATEAPP:
-	// From eric@vfx.sel.sony.com, we should process WM_ACTIVATEAPP
-	// messages to restore the correct state of the shift/ctrl/alt/lock
-	// keys...  Added control, shift, alt, and meta keys, and changed
-	// to use GetAsyncKeyState and do it when wParam is 1
-	// (that means we have focus...)
-	if (wParam) {
-	  ulong state = 0;
-	  if (GetAsyncKeyState(VK_CAPITAL))
-	    state |= FL_CAPS_LOCK;
-	  if (GetAsyncKeyState(VK_NUMLOCK))
-	    state |= FL_NUM_LOCK;
-	  if (GetAsyncKeyState(VK_SCROLL))
-	    state |= FL_SCROLL_LOCK;
-	  if (GetAsyncKeyState(VK_CONTROL) & ~1)
-	    state |= FL_CTRL;
-	  if (GetAsyncKeyState(VK_SHIFT) & ~1)
-	    state |= FL_SHIFT;
-	  if (GetAsyncKeyState(VK_MENU))
-	    state |= FL_ALT;
-	  if ((GetAsyncKeyState(VK_LWIN) | GetAsyncKeyState(VK_RWIN)) & ~1)
-	    state |= FL_META;
-	  Fl::e_state = state;
-	  return 0;
-	}
-	break;
+        // From eric@vfx.sel.sony.com, we should process WM_ACTIVATEAPP
+        // messages to restore the correct state of the shift/ctrl/alt/lock
+        // keys...  Added control, shift, alt, and meta keys, and changed
+        // to use GetAsyncKeyState and do it when wParam is 1
+        // (that means we have focus...)
+        if (wParam) {
+          ulong state = 0;
+          if (GetAsyncKeyState(VK_CAPITAL))
+            state |= FL_CAPS_LOCK;
+          if (GetAsyncKeyState(VK_NUMLOCK))
+            state |= FL_NUM_LOCK;
+          if (GetAsyncKeyState(VK_SCROLL))
+            state |= FL_SCROLL_LOCK;
+          if (GetAsyncKeyState(VK_CONTROL) & ~1)
+            state |= FL_CTRL;
+          if (GetAsyncKeyState(VK_SHIFT) & ~1)
+            state |= FL_SHIFT;
+          if (GetAsyncKeyState(VK_MENU))
+            state |= FL_ALT;
+          if ((GetAsyncKeyState(VK_LWIN) | GetAsyncKeyState(VK_RWIN)) & ~1)
+            state |= FL_META;
+          Fl::e_state = state;
+          return 0;
+        }
+        break;
 
       case WM_INPUTLANGCHANGE:
-	fl_get_codepage();
-	break;
+        fl_get_codepage();
+        break;
       case WM_IME_COMPOSITION:
-	// if (!fl_is_nt4() && lParam & GCS_RESULTCLAUSE) {
-	//   HIMC himc = ImmGetContext(hWnd);
-	//     wlen = ImmGetCompositionStringW(himc, GCS_RESULTSTR,
-	//				       wbuf, sizeof(wbuf)) / sizeof(short);
-	//     if (wlen < 0) wlen = 0;
-	//	 wbuf[wlen] = 0;
-	//	 ImmReleaseContext(hWnd, himc);
-	//     }
-	break;
+        // if (!fl_is_nt4() && lParam & GCS_RESULTCLAUSE) {
+        //   HIMC himc = ImmGetContext(hWnd);
+        //     wlen = ImmGetCompositionStringW(himc, GCS_RESULTSTR,
+        //                                     wbuf, sizeof(wbuf)) / sizeof(short);
+        //     if (wlen < 0) wlen = 0;
+        //       wbuf[wlen] = 0;
+        //       ImmReleaseContext(hWnd, himc);
+        //     }
+        break;
 
       case WM_KEYDOWN:
       case WM_SYSKEYDOWN:
       case WM_KEYUP:
       case WM_SYSKEYUP:
-	// save the keysym until we figure out the characters:
-	Fl::e_keysym = Fl::e_original_keysym = ms2fltk(wParam, lParam & (1 << 24));
-	// See if TranslateMessage turned it into a WM_*CHAR message:
-	if (PeekMessageW(&fl_msg, hWnd, WM_CHAR, WM_SYSDEADCHAR, PM_REMOVE)) {
-	  uMsg = fl_msg.message;
-	  wParam = fl_msg.wParam;
-	  lParam = fl_msg.lParam;
-	}
-	// FALLTHROUGH ...
+        // save the keysym until we figure out the characters:
+        Fl::e_keysym = Fl::e_original_keysym = ms2fltk(wParam, lParam & (1 << 24));
+        // See if TranslateMessage turned it into a WM_*CHAR message:
+        if (PeekMessageW(&fl_msg, hWnd, WM_CHAR, WM_SYSDEADCHAR, PM_REMOVE)) {
+          uMsg = fl_msg.message;
+          wParam = fl_msg.wParam;
+          lParam = fl_msg.lParam;
+        }
+        // FALLTHROUGH ...
 
       case WM_DEADCHAR:
       case WM_SYSDEADCHAR:
       case WM_CHAR:
       case WM_SYSCHAR: {
-	ulong state = Fl::e_state & 0xff000000; // keep the mouse button state
-	// if GetKeyState is expensive we might want to comment some of these out:
-	if (GetKeyState(VK_SHIFT) & ~1)
-	  state |= FL_SHIFT;
-	if (GetKeyState(VK_CAPITAL))
-	  state |= FL_CAPS_LOCK;
-	if (GetKeyState(VK_CONTROL) & ~1)
-	  state |= FL_CTRL;
-	// Alt gets reported for the Alt-GR switch on non-English keyboards.
-	// so we need to check the event as well to get it right:
-	if ((lParam & (1 << 29)) // same as GetKeyState(VK_MENU)
-	    && uMsg != WM_CHAR)
-	  state |= FL_ALT;
-	if (GetKeyState(VK_NUMLOCK))
-	  state |= FL_NUM_LOCK;
-	if ((GetKeyState(VK_LWIN) | GetKeyState(VK_RWIN)) & ~1) {
-	  // Windows bug?  GetKeyState returns garbage if the user hit the
-	  // meta key to pop up start menu.  Sigh.
-	  if ((GetAsyncKeyState(VK_LWIN) | GetAsyncKeyState(VK_RWIN)) & ~1)
-	    state |= FL_META;
-	}
-	if (GetKeyState(VK_SCROLL))
-	  state |= FL_SCROLL_LOCK;
-	Fl::e_state = state;
-	static char buffer[1024];
-	if (uMsg == WM_CHAR || uMsg == WM_SYSCHAR) {
-	  wchar_t u = (wchar_t)wParam;
-	  Fl::e_length = fl_utf8fromwc(buffer, 1024, &u, 1);
-	  buffer[Fl::e_length] = 0;
-	} else if (Fl::e_keysym >= FL_KP && Fl::e_keysym <= FL_KP_Last) {
-	  if (state & FL_NUM_LOCK) {
-	    // Convert to regular keypress...
-	    buffer[0] = Fl::e_keysym - FL_KP;
-	    Fl::e_length = 1;
-	  } else {
-	    // Convert to special keypress...
-	    buffer[0] = 0;
-	    Fl::e_length = 0;
-	    switch (Fl::e_keysym) {
-	      case FL_KP + '0':
-		Fl::e_keysym = FL_Insert;
-		break;
-	      case FL_KP + '1':
-		Fl::e_keysym = FL_End;
-		break;
-	      case FL_KP + '2':
-		Fl::e_keysym = FL_Down;
-		break;
-	      case FL_KP + '3':
-		Fl::e_keysym = FL_Page_Down;
-		break;
-	      case FL_KP + '4':
-		Fl::e_keysym = FL_Left;
-		break;
-	      case FL_KP + '6':
-		Fl::e_keysym = FL_Right;
-		break;
-	      case FL_KP + '7':
-		Fl::e_keysym = FL_Home;
-		break;
-	      case FL_KP + '8':
-		Fl::e_keysym = FL_Up;
-		break;
-	      case FL_KP + '9':
-		Fl::e_keysym = FL_Page_Up;
-		break;
-	      case FL_KP + '.':
-		Fl::e_keysym = FL_Delete;
-		break;
-	      case FL_KP + '/':
-	      case FL_KP + '*':
-	      case FL_KP + '-':
-	      case FL_KP + '+':
-		buffer[0] = Fl::e_keysym - FL_KP;
-		Fl::e_length = 1;
-		break;
-	    }
-	  }
-	} else if ((lParam & (1 << 31)) == 0) {
+        ulong state = Fl::e_state & 0xff000000; // keep the mouse button state
+        // if GetKeyState is expensive we might want to comment some of these out:
+        if (GetKeyState(VK_SHIFT) & ~1)
+          state |= FL_SHIFT;
+        if (GetKeyState(VK_CAPITAL))
+          state |= FL_CAPS_LOCK;
+        if (GetKeyState(VK_CONTROL) & ~1)
+          state |= FL_CTRL;
+        // Alt gets reported for the Alt-GR switch on non-English keyboards.
+        // so we need to check the event as well to get it right:
+        if ((lParam & (1 << 29)) // same as GetKeyState(VK_MENU)
+            && uMsg != WM_CHAR)
+          state |= FL_ALT;
+        if (GetKeyState(VK_NUMLOCK))
+          state |= FL_NUM_LOCK;
+        if ((GetKeyState(VK_LWIN) | GetKeyState(VK_RWIN)) & ~1) {
+          // Windows bug?  GetKeyState returns garbage if the user hit the
+          // meta key to pop up start menu.  Sigh.
+          if ((GetAsyncKeyState(VK_LWIN) | GetAsyncKeyState(VK_RWIN)) & ~1)
+            state |= FL_META;
+        }
+        if (GetKeyState(VK_SCROLL))
+          state |= FL_SCROLL_LOCK;
+        Fl::e_state = state;
+        static char buffer[1024];
+        if (uMsg == WM_CHAR || uMsg == WM_SYSCHAR) {
+          wchar_t u = (wchar_t)wParam;
+          Fl::e_length = fl_utf8fromwc(buffer, 1024, &u, 1);
+          buffer[Fl::e_length] = 0;
+        } else if (Fl::e_keysym >= FL_KP && Fl::e_keysym <= FL_KP_Last) {
+          if (state & FL_NUM_LOCK) {
+            // Convert to regular keypress...
+            buffer[0] = Fl::e_keysym - FL_KP;
+            Fl::e_length = 1;
+          } else {
+            // Convert to special keypress...
+            buffer[0] = 0;
+            Fl::e_length = 0;
+            switch (Fl::e_keysym) {
+              case FL_KP + '0':
+                Fl::e_keysym = FL_Insert;
+                break;
+              case FL_KP + '1':
+                Fl::e_keysym = FL_End;
+                break;
+              case FL_KP + '2':
+                Fl::e_keysym = FL_Down;
+                break;
+              case FL_KP + '3':
+                Fl::e_keysym = FL_Page_Down;
+                break;
+              case FL_KP + '4':
+                Fl::e_keysym = FL_Left;
+                break;
+              case FL_KP + '6':
+                Fl::e_keysym = FL_Right;
+                break;
+              case FL_KP + '7':
+                Fl::e_keysym = FL_Home;
+                break;
+              case FL_KP + '8':
+                Fl::e_keysym = FL_Up;
+                break;
+              case FL_KP + '9':
+                Fl::e_keysym = FL_Page_Up;
+                break;
+              case FL_KP + '.':
+                Fl::e_keysym = FL_Delete;
+                break;
+              case FL_KP + '/':
+              case FL_KP + '*':
+              case FL_KP + '-':
+              case FL_KP + '+':
+                buffer[0] = Fl::e_keysym - FL_KP;
+                Fl::e_length = 1;
+                break;
+            }
+          }
+        } else if ((lParam & (1 << 31)) == 0) {
 #ifdef FLTK_PREVIEW_DEAD_KEYS
-	  if ((lParam & (1 << 24)) == 0) { // clear if dead key (always?)
-	    wchar_t u = (wchar_t)wParam;
-	    Fl::e_length = fl_utf8fromwc(buffer, 1024, &u, 1);
-	    buffer[Fl::e_length] = 0;
-	  } else { // set if "extended key" (never printable?)
-	    buffer[0] = 0;
-	    Fl::e_length = 0;
-	  }
+          if ((lParam & (1 << 24)) == 0) { // clear if dead key (always?)
+            wchar_t u = (wchar_t)wParam;
+            Fl::e_length = fl_utf8fromwc(buffer, 1024, &u, 1);
+            buffer[Fl::e_length] = 0;
+          } else { // set if "extended key" (never printable?)
+            buffer[0] = 0;
+            Fl::e_length = 0;
+          }
 #else
-	  buffer[0] = 0;
-	  Fl::e_length = 0;
+          buffer[0] = 0;
+          Fl::e_length = 0;
 #endif
-	}
-	Fl::e_text = buffer;
-	if (lParam & (1 << 31)) { // key up events.
-	  if (Fl::handle(FL_KEYUP, window))
-	    return 0;
-	  break;
-	}
-	while (window->parent())
-	  window = window->window();
-	if (Fl::handle(FL_KEYBOARD, window)) {
-	  if (uMsg == WM_DEADCHAR || uMsg == WM_SYSDEADCHAR)
-	    Fl::compose_state = 1;
-	  return 0;
-	}
-	break; // WM_KEYDOWN ... WM_SYSKEYUP, WM_DEADCHAR ... WM_SYSCHAR
+        }
+        Fl::e_text = buffer;
+        if (lParam & (1 << 31)) { // key up events.
+          if (Fl::handle(FL_KEYUP, window))
+            return 0;
+          break;
+        }
+        while (window->parent())
+          window = window->window();
+        if (Fl::handle(FL_KEYBOARD, window)) {
+          if (uMsg == WM_DEADCHAR || uMsg == WM_SYSDEADCHAR)
+            Fl::compose_state = 1;
+          return 0;
+        }
+        break; // WM_KEYDOWN ... WM_SYSKEYUP, WM_DEADCHAR ... WM_SYSCHAR
       } // case WM_DEADCHAR ... WM_SYSCHAR
 
       case WM_MOUSEWHEEL: {
-	static int delta = 0; // running total of all motion
-	delta += (SHORT)(HIWORD(wParam));
-	Fl::e_dx = 0;
-	Fl::e_dy = -delta / WHEEL_DELTA;
-	delta += Fl::e_dy * WHEEL_DELTA;
-	if (Fl::e_dy)
-	  Fl::handle(FL_MOUSEWHEEL, window);
-	return 0;
+        static int delta = 0; // running total of all motion
+        delta += (SHORT)(HIWORD(wParam));
+        Fl::e_dx = 0;
+        Fl::e_dy = -delta / WHEEL_DELTA;
+        delta += Fl::e_dy * WHEEL_DELTA;
+        if (Fl::e_dy)
+          Fl::handle(FL_MOUSEWHEEL, window);
+        return 0;
       }
 
       case WM_MOUSEHWHEEL: {
-	static int delta = 0; // running total of all motion
-	delta += (SHORT)(HIWORD(wParam));
-	Fl::e_dy = 0;
-	Fl::e_dx = delta / WHEEL_DELTA;
-	delta -= Fl::e_dx * WHEEL_DELTA;
-	if (Fl::e_dx)
-	  Fl::handle(FL_MOUSEWHEEL, window);
-	return 0;
+        static int delta = 0; // running total of all motion
+        delta += (SHORT)(HIWORD(wParam));
+        Fl::e_dy = 0;
+        Fl::e_dx = delta / WHEEL_DELTA;
+        delta -= Fl::e_dx * WHEEL_DELTA;
+        if (Fl::e_dx)
+          Fl::handle(FL_MOUSEWHEEL, window);
+        return 0;
       }
 
       case WM_GETMINMAXINFO:
-	Fl_WinAPI_Window_Driver::driver(window)->set_minmax((LPMINMAXINFO)lParam);
-	break;
+        Fl_WinAPI_Window_Driver::driver(window)->set_minmax((LPMINMAXINFO)lParam);
+        break;
 
       case WM_SIZE:
-	if (!window->parent()) {
-	  if (wParam == SIZE_MINIMIZED || wParam == SIZE_MAXHIDE) {
-	    Fl::handle(FL_HIDE, window);
-	  } else {
-	    Fl::handle(FL_SHOW, window);
-	    resize_bug_fix = window;
-	    window->size(ceil(LOWORD(lParam) / scale), ceil(HIWORD(lParam) / scale));
-	    // fprintf(LOG,"WM_SIZE size(%.0f,%.0f) graph(%d,%d) s=%.2f\n",
-	    // 	       ceil(LOWORD(lParam)/scale),ceil(HIWORD(lParam)/scale),
-	    //	       LOWORD(lParam),HIWORD(lParam),scale);
-	  }
-	}
-	break;
+        if (!window->parent()) {
+          if (wParam == SIZE_MINIMIZED || wParam == SIZE_MAXHIDE) {
+            Fl::handle(FL_HIDE, window);
+          } else {
+            Fl::handle(FL_SHOW, window);
+            resize_bug_fix = window;
+            window->size(ceil(LOWORD(lParam) / scale), ceil(HIWORD(lParam) / scale));
+            // fprintf(LOG,"WM_SIZE size(%.0f,%.0f) graph(%d,%d) s=%.2f\n",
+            //         ceil(LOWORD(lParam)/scale),ceil(HIWORD(lParam)/scale),
+            //         LOWORD(lParam),HIWORD(lParam),scale);
+          }
+        }
+        break;
 
       case WM_MOVE: {
-	if (IsIconic(hWnd)) {
-	  break;
-	}
-	resize_bug_fix = window;
-	int nx = LOWORD(lParam);
-	int ny = HIWORD(lParam);
-	if (nx & 0x8000) nx -= 65536;
-	if (ny & 0x8000) ny -= 65536;
-	// fprintf(LOG,"WM_MOVE position(%d,%d) s=%.2f\n",int(nx/scale),int(ny/scale),scale);
-	// detect when window centre changes screen
-	Fl_WinAPI_Screen_Driver *sd = (Fl_WinAPI_Screen_Driver *)Fl::screen_driver();
-	Fl_WinAPI_Window_Driver *wd = Fl_WinAPI_Window_Driver::driver(window);
-	int olds = wd->screen_num();
-	int news = sd->screen_num_unscaled(nx + window->w() * scale / 2, ny + window->h() * scale / 2);
-	if (news == -1)
-	  news = olds;
-	float s = sd->scale(news);
-	// fprintf(LOG,"WM_MOVE olds=%d(%.2f) news=%d(%.2f) busy=%d\n",olds,
-	//	       sd->scale(olds),news, s,
-	//	       Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.busy);
-	// fflush(LOG);
-	if (olds != news) {
-	  if (s != sd->scale(olds) &&
-	      !Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.busy &&
-	      window->user_data() != &Fl_WinAPI_Screen_Driver::transient_scale_display) {
-	    Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.busy = true;
-	    Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.screen = news;
-	    Fl::add_timeout(1, Fl_WinAPI_Window_Driver::resize_after_screen_change, window);
-	  }
-	  else if (!Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.busy)
-	    wd->screen_num(news);
-	}
-	window->position(nx / scale, ny / scale);
-	break;
+        if (IsIconic(hWnd)) {
+          break;
+        }
+        resize_bug_fix = window;
+        int nx = LOWORD(lParam);
+        int ny = HIWORD(lParam);
+        if (nx & 0x8000) nx -= 65536;
+        if (ny & 0x8000) ny -= 65536;
+        // fprintf(LOG,"WM_MOVE position(%d,%d) s=%.2f\n",int(nx/scale),int(ny/scale),scale);
+        // detect when window centre changes screen
+        Fl_WinAPI_Screen_Driver *sd = (Fl_WinAPI_Screen_Driver *)Fl::screen_driver();
+        Fl_WinAPI_Window_Driver *wd = Fl_WinAPI_Window_Driver::driver(window);
+        int olds = wd->screen_num();
+        int news = sd->screen_num_unscaled(nx + window->w() * scale / 2, ny + window->h() * scale / 2);
+        if (news == -1)
+          news = olds;
+        float s = sd->scale(news);
+        // fprintf(LOG,"WM_MOVE olds=%d(%.2f) news=%d(%.2f) busy=%d\n",olds,
+        //             sd->scale(olds),news, s,
+        //             Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.busy);
+        // fflush(LOG);
+        if (olds != news) {
+          if (s != sd->scale(olds) &&
+              !Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.busy &&
+              window->user_data() != &Fl_WinAPI_Screen_Driver::transient_scale_display) {
+            Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.busy = true;
+            Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.screen = news;
+            Fl::add_timeout(1, Fl_WinAPI_Window_Driver::resize_after_screen_change, window);
+          }
+          else if (!Fl_WinAPI_Window_Driver::data_for_resize_window_between_screens_.busy)
+            wd->screen_num(news);
+        }
+        window->position(nx / scale, ny / scale);
+        break;
       } // case WM_MOVE
 
       case WM_SETCURSOR:
-	if (LOWORD(lParam) == HTCLIENT) {
-	  while (window->parent())
-	    window = window->window();
-	  SetCursor(Fl_WinAPI_Window_Driver::driver(window)->cursor);
-	  return 0;
-	}
-	break;
+        if (LOWORD(lParam) == HTCLIENT) {
+          while (window->parent())
+            window = window->window();
+          SetCursor(Fl_WinAPI_Window_Driver::driver(window)->cursor);
+          return 0;
+        }
+        break;
 
 #if USE_COLORMAP
       case WM_QUERYNEWPALETTE:
-	fl_GetDC(hWnd);
-	if (fl_select_palette())
-	  InvalidateRect(hWnd, NULL, FALSE);
-	break;
+        fl_GetDC(hWnd);
+        if (fl_select_palette())
+          InvalidateRect(hWnd, NULL, FALSE);
+        break;
 
       case WM_PALETTECHANGED:
-	if ((HWND)wParam != hWnd && fl_select_palette())
-	  UpdateColors(fl_GetDC(hWnd));
-	break;
+        if ((HWND)wParam != hWnd && fl_select_palette())
+          UpdateColors(fl_GetDC(hWnd));
+        break;
 
       case WM_CREATE:
-	fl_GetDC(hWnd);
-	fl_select_palette();
-	break;
+        fl_GetDC(hWnd);
+        fl_select_palette();
+        break;
 #endif
 
       case WM_DESTROYCLIPBOARD:
-	fl_i_own_selection[1] = 0;
-	return 1;
+        fl_i_own_selection[1] = 0;
+        return 1;
 
       case WM_DISPLAYCHANGE: {// occurs when screen configuration (number, size, position) changes
         Fl::call_screen_init();
@@ -1641,36 +1639,36 @@ static LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lPar
         return 0;
       }
       case WM_CHANGECBCHAIN:
-	if ((hWnd == clipboard_wnd) && (next_clipboard_wnd == (HWND)wParam))
-	  next_clipboard_wnd = (HWND)lParam;
-	else
-	  SendMessage(next_clipboard_wnd, WM_CHANGECBCHAIN, wParam, lParam);
-	return 0;
+        if ((hWnd == clipboard_wnd) && (next_clipboard_wnd == (HWND)wParam))
+          next_clipboard_wnd = (HWND)lParam;
+        else
+          SendMessage(next_clipboard_wnd, WM_CHANGECBCHAIN, wParam, lParam);
+        return 0;
 
       case WM_DRAWCLIPBOARD:
-	// When the clipboard moves between two FLTK windows,
-	// fl_i_own_selection will temporarily be false as we are
-	// processing this message. Hence the need to use fl_find().
-	if (!initial_clipboard && !fl_find(GetClipboardOwner()))
-	  fl_trigger_clipboard_notify(1);
-	initial_clipboard = false;
+        // When the clipboard moves between two FLTK windows,
+        // fl_i_own_selection will temporarily be false as we are
+        // processing this message. Hence the need to use fl_find().
+        if (!initial_clipboard && !fl_find(GetClipboardOwner()))
+          fl_trigger_clipboard_notify(1);
+        initial_clipboard = false;
 
-	if (next_clipboard_wnd)
-	  SendMessage(next_clipboard_wnd, WM_DRAWCLIPBOARD, wParam, lParam);
+        if (next_clipboard_wnd)
+          SendMessage(next_clipboard_wnd, WM_DRAWCLIPBOARD, wParam, lParam);
 
-	return 0;
+        return 0;
 
       default:
-	if (Fl::handle(0, 0))
-	  return 0;
-	break;
+        if (Fl::handle(0, 0))
+          return 0;
+        break;
     } // switch (uMsg)
   } // if (window)
   return DefWindowProcW(hWnd, uMsg, wParam, lParam);
 }
 
 /* Implementation note about the API to get the dimensions of the top/left borders and the title bar
- 
+
  Function fake_X_wm_style() below is used before calling CreateWindowExW() to create
  a window and before calling SetWindowPos(). Both of these Windows functions need the window size
  including borders and title bar. Function fake_X_wm_style() uses AdjustWindowRectExForDpi() or
@@ -1681,7 +1679,7 @@ static LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lPar
     Calculates the required size of the window rectangle, based on the desired size of the client
     rectangle [and the provided DPI]. This window rectangle can then be passed to the CreateWindowEx
     function to create a window with a client area of the desired size.
- 
+
  Conversely, Fl_WinAPI_Window_Driver::border_width_title_bar_height() is used to get
  the true sizes of borders and title bar of a mapped window. The correct API for that is
  DwmGetWindowAttribute().
@@ -1713,10 +1711,10 @@ static int fake_X_wm_style(const Fl_Window *w, int &X, int &Y, int &bt, int &bx,
       // fallback to get the best guess which is always available.
 
       if (!style) {
-	HWND hwnd = fl_xid(w);
-	// request the style flags of this window, as Windows sees them
-	style = GetWindowLong(hwnd, GWL_STYLE);
-	styleEx = GetWindowLong(hwnd, GWL_EXSTYLE);
+        HWND hwnd = fl_xid(w);
+        // request the style flags of this window, as Windows sees them
+        style = GetWindowLong(hwnd, GWL_STYLE);
+        styleEx = GetWindowLong(hwnd, GWL_EXSTYLE);
       }
 
       RECT r;
@@ -1725,7 +1723,7 @@ static int fake_X_wm_style(const Fl_Window *w, int &X, int &Y, int &bt, int &bx,
       r.right = (w->x() + w->w()) * s;
       r.bottom = (w->y() + w->h()) * s;
       // get the decoration rectangle for the desired client rectangle
-      
+
       typedef BOOL(WINAPI* AdjustWindowRectExForDpi_type)(LPRECT, DWORD, BOOL, DWORD, UINT);
       static AdjustWindowRectExForDpi_type fl_AdjustWindowRectExForDpi =
         (AdjustWindowRectExForDpi_type)GetProcAddress(LoadLibrary("User32.DLL"), "AdjustWindowRectExForDpi");
@@ -1737,22 +1735,22 @@ static int fake_X_wm_style(const Fl_Window *w, int &X, int &Y, int &bt, int &bx,
       } else
         ok = AdjustWindowRectEx(&r, style, FALSE, styleEx);
       if (ok) {
-	X = r.left;
-	Y = r.top;
-	W = r.right - r.left;
-	H = r.bottom - r.top;
-	bx = w->x() * s - r.left;
-	by = r.bottom - (w->y() + w->h()) * s; // height of the bottom frame
-	bt = w->y() * s - r.top - by;          // height of top caption bar
-	xoff = bx;
-	yoff = by + bt;
-	dx = W - w->w() * s;
-	dy = H - w->h() * s;
-	if (w_size_range_set && (w_maxw != w_minw || w_maxh != w_minh))
-	  ret = 2;
-	else
-	  ret = 1;
-	fallback = 0;
+        X = r.left;
+        Y = r.top;
+        W = r.right - r.left;
+        H = r.bottom - r.top;
+        bx = w->x() * s - r.left;
+        by = r.bottom - (w->y() + w->h()) * s; // height of the bottom frame
+        bt = w->y() * s - r.top - by;          // height of top caption bar
+        xoff = bx;
+        yoff = by + bt;
+        dx = W - w->w() * s;
+        dy = H - w->h() * s;
+        if (w_size_range_set && (w_maxw != w_minw || w_maxh != w_minh))
+          ret = 2;
+        else
+          ret = 1;
+        fallback = 0;
       }
     }
   }
@@ -1760,17 +1758,17 @@ static int fake_X_wm_style(const Fl_Window *w, int &X, int &Y, int &bt, int &bx,
   if (fallback) {
     if (w->border() && !w->parent()) {
       if (w_size_range_set && (w_maxw != w_minw || w_maxh != w_minh)) {
-	ret = 2;
-	bx = GetSystemMetrics(SM_CXSIZEFRAME);
-	by = GetSystemMetrics(SM_CYSIZEFRAME);
+        ret = 2;
+        bx = GetSystemMetrics(SM_CXSIZEFRAME);
+        by = GetSystemMetrics(SM_CYSIZEFRAME);
       } else {
-	ret = 1;
-	int padding = GetSystemMetrics(SM_CXPADDEDBORDER);
-	NONCLIENTMETRICS ncm;
-	ncm.cbSize = sizeof(NONCLIENTMETRICS);
-	SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
-	bx = GetSystemMetrics(SM_CXFIXEDFRAME) + (padding ? padding + ncm.iBorderWidth : 0);
-	by = GetSystemMetrics(SM_CYFIXEDFRAME) + (padding ? padding + ncm.iBorderWidth : 0);
+        ret = 1;
+        int padding = GetSystemMetrics(SM_CXPADDEDBORDER);
+        NONCLIENTMETRICS ncm;
+        ncm.cbSize = sizeof(NONCLIENTMETRICS);
+        SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
+        bx = GetSystemMetrics(SM_CXFIXEDFRAME) + (padding ? padding + ncm.iBorderWidth : 0);
+        by = GetSystemMetrics(SM_CYFIXEDFRAME) + (padding ? padding + ncm.iBorderWidth : 0);
       }
       bt = GetSystemMetrics(SM_CYCAPTION);
     }
@@ -1860,7 +1858,7 @@ void Fl_WinAPI_Window_Driver::resize(int X, int Y, int W, int H) {
       // with no width or height will never get an exposure event
       Fl_X *i = Fl_X::i(pWindow);
       if (i && W > 0 && H > 0)
-	wait_for_expose_value = 1;
+        wait_for_expose_value = 1;
     }
   } else {
     x(X);
@@ -1927,7 +1925,7 @@ public:
     int i;
     for (i = 0; i < nName; i++) {
       if (strcmp(name[i], n) == 0)
-	return 1;
+        return 1;
     }
     return 0;
   }
@@ -1973,9 +1971,9 @@ Fl_X *Fl_WinAPI_Window_Driver::makeWindow() {
   // convert UTF-8 class_name to wchar_t for RegisterClassExW and CreateWindowExW
 
   fl_utf8toUtf16(class_name,
-		 (unsigned)strlen(class_name),                     // in
-		 (unsigned short *)class_namew,                    // out
-		 (unsigned)sizeof(class_namew) / sizeof(wchar_t)); // max. size
+                 (unsigned)strlen(class_name),                     // in
+                 (unsigned short *)class_namew,                    // out
+                 (unsigned)sizeof(class_namew) / sizeof(wchar_t)); // max. size
 
   if (!class_name_list.has_name(class_name)) {
     WNDCLASSEXW wcw;
@@ -2039,16 +2037,16 @@ Fl_X *Fl_WinAPI_Window_Driver::makeWindow() {
   } else {
     if (!size_range_set()) {
       if (w->resizable()) {
-	Fl_Widget *o = w->resizable();
-	int minw = o->w();
-	if (minw > 100)
-	  minw = 100;
-	int minh = o->h();
-	if (minh > 100)
-	  minh = 100;
-	w->size_range(w->w() - o->w() + minw, w->h() - o->h() + minh, 0, 0);
+        Fl_Widget *o = w->resizable();
+        int minw = o->w();
+        if (minw > 100)
+          minw = 100;
+        int minh = o->h();
+        if (minh > 100)
+          minh = 100;
+        w->size_range(w->w() - o->w() + minw, w->h() - o->h() + minh, 0, 0);
       } else {
-	w->size_range(w->w(), w->h(), w->w(), w->h());
+        w->size_range(w->w(), w->h(), w->w(), w->h());
       }
     }
     styleEx |= WS_EX_WINDOWEDGE | WS_EX_CONTROLPARENT;
@@ -2056,31 +2054,31 @@ Fl_X *Fl_WinAPI_Window_Driver::makeWindow() {
     int wintype = 0;
     if (w->border() && !w->parent()) {
       if (size_range_set() && (maxw() != minw() || maxh() != minh()))
-	wintype = 2;
+        wintype = 2;
       else
-	wintype = 1;
+        wintype = 1;
     }
 
     switch (wintype) {
       // No border (used for menus)
       case 0:
-	style |= WS_POPUP;
-	styleEx |= WS_EX_TOOLWINDOW;
-	break;
+        style |= WS_POPUP;
+        styleEx |= WS_EX_TOOLWINDOW;
+        break;
 
       // Thin border and title bar
       case 1:
-	style |= WS_DLGFRAME | WS_CAPTION;
-	if (!w->modal())
-	  style |= WS_SYSMENU | WS_MINIMIZEBOX;
-	break;
+        style |= WS_DLGFRAME | WS_CAPTION;
+        if (!w->modal())
+          style |= WS_SYSMENU | WS_MINIMIZEBOX;
+        break;
 
       // Thick, resizable border and title bar, with maximize button
       case 2:
-	style |= WS_THICKFRAME | WS_SYSMENU | WS_MAXIMIZEBOX | WS_CAPTION;
-	if (!w->modal())
-	  style |= WS_MINIMIZEBOX;
-	break;
+        style |= WS_THICKFRAME | WS_SYSMENU | WS_MAXIMIZEBOX | WS_CAPTION;
+        if (!w->modal())
+          style |= WS_MINIMIZEBOX;
+        break;
     }
 
     int xwm = xp, ywm = yp, bt, bx, by; // these are in graphical units
@@ -2093,10 +2091,10 @@ Fl_X *Fl_WinAPI_Window_Driver::makeWindow() {
       xp = yp = CW_USEDEFAULT;
     } else {
       if (!Fl::grab()) {
-	xp = xwm;
-	yp = ywm;
-	x(xp / s);
-	y(yp / s);
+        xp = xwm;
+        yp = ywm;
+        x(xp / s);
+        y(yp / s);
       }
       xp -= bx;
       yp -= by + bt;
@@ -2107,10 +2105,10 @@ Fl_X *Fl_WinAPI_Window_Driver::makeWindow() {
       // find some other window to be "transient for":
       Fl_Window *w = Fl_X::first->w;
       while (w->parent())
-	w = w->window();
+        w = w->window();
       parent = fl_xid(w);
       if (!w->visible())
-	showit = 0;
+        showit = 0;
     } else if (Fl::grab())
       parent = fl_xid(Fl::grab());
   }
@@ -2136,13 +2134,13 @@ Fl_X *Fl_WinAPI_Window_Driver::makeWindow() {
     lab[wlen] = 0;
   }
   x->xid = CreateWindowExW(styleEx,
-			   class_namew, lab, style,
-			   xp, yp, wp, hp,
-			   parent,
-			   NULL, // menu
-			   fl_display,
-			   NULL // creation parameters
-			  );
+                           class_namew, lab, style,
+                           xp, yp, wp, hp,
+                           parent,
+                           NULL, // menu
+                           fl_display,
+                           NULL // creation parameters
+                          );
   if (lab)
     free(lab);
 
@@ -2190,7 +2188,7 @@ Fl_X *Fl_WinAPI_Window_Driver::makeWindow() {
   // If we've captured the mouse, we dont want to activate any
   // other windows from the code, or we lose the capture.
   ShowWindow(x->xid, !showit ? SW_SHOWMINNOACTIVE :
-	     (Fl::grab() || (styleEx & WS_EX_TOOLWINDOW)) ? SW_SHOWNOACTIVATE : SW_SHOWNORMAL);
+             (Fl::grab() || (styleEx & WS_EX_TOOLWINDOW)) ? SW_SHOWNOACTIVATE : SW_SHOWNORMAL);
 
   // Register all windows for potential drag'n'drop operations
   RegisterDragDrop(x->xid, flIDropTarget);
@@ -2289,18 +2287,18 @@ static HICON image_to_icon(const Fl_RGB_Image *image, bool is_icon, int hotx, in
   for (int y = 0; y < image->h(); y++) {
     for (int x = 0; x < image->w(); x++) {
       switch (image->d()) {
-	case 1:
-	  *bits = (0xff << 24) | (i[0] << 16) | (i[0] << 8) | i[0];
-	  break;
-	case 2:
-	  *bits = (i[1] << 24) | (i[0] << 16) | (i[0] << 8) | i[0];
-	  break;
-	case 3:
-	  *bits = (0xff << 24) | (i[0] << 16) | (i[1] << 8) | i[2];
-	  break;
-	case 4:
-	  *bits = (i[3] << 24) | (i[0] << 16) | (i[1] << 8) | i[2];
-	  break;
+        case 1:
+          *bits = (0xff << 24) | (i[0] << 16) | (i[0] << 8) | i[0];
+          break;
+        case 2:
+          *bits = (i[1] << 24) | (i[0] << 16) | (i[0] << 8) | i[0];
+          break;
+        case 3:
+          *bits = (0xff << 24) | (i[0] << 16) | (i[1] << 8) | i[2];
+          break;
+        case 4:
+          *bits = (i[3] << 24) | (i[0] << 16) | (i[1] << 8) | i[2];
+          break;
       }
       i += image->d();
       bits++;
@@ -2346,11 +2344,11 @@ static const Fl_RGB_Image *find_best_icon(int ideal_width, const Fl_RGB_Image *i
       best = icons[i];
     else {
       if (best->w() < ideal_width) {
-	if (icons[i]->w() > best->w())
-	  best = icons[i];
+        if (icons[i]->w() > best->w())
+          best = icons[i];
       } else {
-	if ((icons[i]->w() >= ideal_width) && (icons[i]->w() < best->w()))
-	  best = icons[i];
+        if ((icons[i]->w() >= ideal_width) && (icons[i]->w() < best->w()))
+          best = icons[i];
       }
     }
   }
@@ -2450,11 +2448,11 @@ void Fl_WinAPI_Window_Driver::set_icons() {
     const Fl_RGB_Image *best_big, *best_small;
 
     best_big = find_best_icon(GetSystemMetrics(SM_CXICON),
-			      (const Fl_RGB_Image **)icon_->icons,
-			      icon_->count);
+                              (const Fl_RGB_Image **)icon_->icons,
+                              icon_->count);
     best_small = find_best_icon(GetSystemMetrics(SM_CXSMICON),
-				(const Fl_RGB_Image **)icon_->icons,
-				icon_->count);
+                                (const Fl_RGB_Image **)icon_->icons,
+                                icon_->count);
 
     if (best_big != NULL)
       big_icon = image_to_icon(best_big, true, 0, 0);
@@ -2490,52 +2488,52 @@ int Fl_WinAPI_Window_Driver::set_cursor(Fl_Cursor c) {
   else {
     switch (c) {
       case FL_CURSOR_ARROW:
-	n = IDC_ARROW;
-	break;
+        n = IDC_ARROW;
+        break;
       case FL_CURSOR_CROSS:
-	n = IDC_CROSS;
-	break;
+        n = IDC_CROSS;
+        break;
       case FL_CURSOR_WAIT:
-	n = IDC_WAIT;
-	break;
+        n = IDC_WAIT;
+        break;
       case FL_CURSOR_INSERT:
-	n = IDC_IBEAM;
-	break;
+        n = IDC_IBEAM;
+        break;
       case FL_CURSOR_HAND:
-	n = IDC_HAND;
-	break;
+        n = IDC_HAND;
+        break;
       case FL_CURSOR_HELP:
-	n = IDC_HELP;
-	break;
+        n = IDC_HELP;
+        break;
       case FL_CURSOR_MOVE:
-	n = IDC_SIZEALL;
-	break;
+        n = IDC_SIZEALL;
+        break;
       case FL_CURSOR_N:
       case FL_CURSOR_S:
       // FIXME: Should probably have fallbacks for these instead
       case FL_CURSOR_NS:
-	n = IDC_SIZENS;
-	break;
+        n = IDC_SIZENS;
+        break;
       case FL_CURSOR_NE:
       case FL_CURSOR_SW:
       // FIXME: Dito.
       case FL_CURSOR_NESW:
-	n = IDC_SIZENESW;
-	break;
+        n = IDC_SIZENESW;
+        break;
       case FL_CURSOR_E:
       case FL_CURSOR_W:
       // FIXME: Dito.
       case FL_CURSOR_WE:
-	n = IDC_SIZEWE;
-	break;
+        n = IDC_SIZEWE;
+        break;
       case FL_CURSOR_SE:
       case FL_CURSOR_NW:
       // FIXME: Dito.
       case FL_CURSOR_NWSE:
-	n = IDC_SIZENWSE;
-	break;
+        n = IDC_SIZENWSE;
+        break;
       default:
-	return 0;
+        return 0;
     }
 
     new_cursor = LoadCursor(NULL, n);
@@ -2702,9 +2700,9 @@ void fl_release_dc(HWND w, HDC dc) {
       RestoreDC(dc, t->saved_dc);
       ReleaseDC(w, dc);
       if (!prev) {
-	win_DC_list = t->next; // delete first item
+        win_DC_list = t->next; // delete first item
       } else {
-	prev->next = t->next; // one in the middle
+        prev->next = t->next; // one in the middle
       }
       delete (t);
       return;
@@ -2855,7 +2853,3 @@ void preparePrintFront(void) {
 #endif // USE_PRINT_BUTTON
 
 #endif // defined(_WIN32) and !defined(FL_DOXYGEN)
-
-//
-// End of "$Id$".
-//