Added DoConfig (clone, not a decompilation)

Right now only the CMake file builds it

CMakeLists.txt

@@ -360,3 +360,64 @@ if (MSVC)
 		COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/msvc/SDL2/lib/${SDL2_DLL_ARCH}/SDL2.dll" "${BUILD_DIRECTORY}/"
 	)
 endif()
+
+# Now for DoConfig
+
+add_executable(DoConfig "DoConfig/DoConfig.cpp" "DoConfig/icon.rc")
+
+set_target_properties(DoConfig PROPERTIES WIN32_EXECUTABLE YES)	# Disable the console window
+
+# Find FLTK
+if (MSVC)
+	# Use local copy
+	target_include_directories(DoConfig PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/msvc/fltk/include")
+
+	if (CMAKE_CL_64)
+		target_link_libraries(DoConfig "${CMAKE_CURRENT_SOURCE_DIR}/msvc/fltk/lib/x64/fltk.lib")
+	else()
+		target_link_libraries(DoConfig "${CMAKE_CURRENT_SOURCE_DIR}/msvc/fltk/lib/x86/fltk.lib")
+
+		# Since the x86 version was built with MSVC2003, we need to enable backwards compatibility on newer compilers
+		if ((MSVC_VERSION EQUAL 1900) OR (MSVC_VERSION GREATER 1900))
+			target_link_libraries(DoConfig "legacy_stdio_definitions.lib")
+		endif()
+	endif()
+
+	# Shut up those stupid warnings
+	target_compile_definitions(DoConfig PRIVATE _CRT_SECURE_NO_WARNINGS)
+elseif (MSYS)
+	target_link_libraries(DoConfig -static)
+
+	# Do crazy nonsense to link the static version
+	find_package(FLTK REQUIRED)
+	target_include_directories(DoConfig PRIVATE ${FLTK_INCLUDE_DIRS})
+
+	if (NOT FLTK_CONFIG_SCRIPT)
+		find_program(FLTK_CONFIG_SCRIPT fltk-config)
+	endif()
+
+	exec_program(bash ARGS ${FLTK_CONFIG_SCRIPT} --ldstaticflags OUTPUT_VARIABLE FLTK_LDSTATICFLAGS)
+	target_link_libraries(DoConfig ${FLTK_LDSTATICFLAGS})
+else()
+	find_package(FLTK REQUIRED)
+	target_include_directories(DoConfig PRIVATE ${FLTK_INCLUDE_DIRS})
+	target_link_libraries(DoConfig ${FLTK_LIBRARIES})
+endif()
+
+set_target_properties(DoConfig PROPERTIES
+	RUNTIME_OUTPUT_DIRECTORY_RELEASE ${BUILD_DIRECTORY}
+	RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${BUILD_DIRECTORY}
+	RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${BUILD_DIRECTORY}
+	RUNTIME_OUTPUT_DIRECTORY_DEBUG ${BUILD_DIRECTORY}
+)
+
+if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+	if ((${CMAKE_VERSION} VERSION_EQUAL 3.9) OR (${CMAKE_VERSION} VERSION_GREATER 3.9))
+		# Enable link-time optimisation if available
+		include(CheckIPOSupported)
+		check_ipo_supported(RESULT result)
+		if (result)
+			set_target_properties(DoConfig PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE)
+		endif()
+	endif()
+endif()

DoConfig/DoConfig.cpp

@@ -0,0 +1,230 @@
+/* This program is free software. It comes without any warranty, to
+ * the extent permitted by applicable law. You can redistribute it
+ * and/or modify it under the terms of the Do What The F*** You Want
+ * To Public License, Version 2, as published by Sam Hocevar. See
+ * http://sam.zoy.org/wtfpl/COPYING for more details. */
+
+#include <cstdlib>
+#include <iostream>
+#include <fstream>
+#include <cstring>
+#include "FL/Fl.H"
+#include "FL/Fl_Window.H"
+#include "FL/Fl_Radio_Round_Button.H"
+#include "FL/Fl_Choice.H"
+#include "FL/Fl_Check_Button.H"
+
+#define HEADER "DOUKUTSU20041206"
+#define TEXT "Courier New"
+
+struct data{
+	char header[32];
+	char text[64];
+	int move;
+	int attack;
+	int okay;
+	int display;
+	int useJoy;
+	int buttons[8];
+};
+
+class RadioRow{
+	public:
+		RadioRow(char offset);
+		int value();
+		void value(int input);
+	private:
+		Fl_Group *group;
+		Fl_Radio_Round_Button *buttons[6];
+		Fl_Group *label;
+};
+
+RadioRow::RadioRow(char offset){
+	char *temp = new char[2];
+	*(temp) = (char)(49+offset); //Muhahahahahahah!
+	*(temp+1) = '\0';
+	this->group = new Fl_Group(140+offset*30, 150, 30, 180);
+	this->group->label(temp);
+	this->group->align(FL_ALIGN_TOP_LEFT);
+	for(char i=0;i<6;i++){
+		this->buttons[i] = new Fl_Radio_Round_Button(140+offset*30, 150+30*i, 30, 30);
+	}
+	this->group->end();
+}
+
+int RadioRow::value(){
+	char i;
+	for(i=0;i<6;i++){
+		if(this->buttons[i]->value()){
+			return (int)i;
+		}
+	}
+	return 0;
+}
+
+void RadioRow::value(int input){
+	this->buttons[input]->setonly();
+}
+
+Fl_Round_Button *movear;
+Fl_Round_Button *movegt;
+
+Fl_Round_Button *buttonxz;
+Fl_Round_Button *buttonzx;
+
+Fl_Round_Button *okayjump;
+Fl_Round_Button *okayattack;
+
+Fl_Choice *displaychoice;
+Fl_Check_Button *joychoice;
+
+Fl_Group *joystuffcontainer;
+RadioRow *joyRows[8];
+
+void quit(Fl_Widget*, void*){
+	std::exit(0);
+}
+
+void activatejoy(Fl_Widget*, void*){
+	if(joystuffcontainer->active()){
+		joystuffcontainer->deactivate();
+	} else {
+		joystuffcontainer->activate();
+	}
+}
+void read_Config(){
+	std::fstream fd;
+	data config;
+	fd.open("Config.dat", std::ios::in | std::ios::binary);
+	fd.read((char*)&config, 148);
+	if (config.move == 0){
+		movear->setonly();
+	} else {
+		movegt->setonly();
+	}
+	if (config.attack == 0){
+		buttonxz->setonly();
+	} else { 
+		buttonzx->setonly();
+	}
+	if (config.okay == 0){
+		okayjump->setonly();
+	}else{
+		okayattack->setonly();
+	}
+	displaychoice->value(config.display);
+	joychoice->value(config.useJoy);
+	if( !config.useJoy ){
+		joystuffcontainer->deactivate();
+	}
+	for(char i=0;i<8;i++){
+		if(config.buttons[i]<9 && config.buttons[i]>0){
+			joyRows[i]->value(config.buttons[i] -1);
+		}
+	}
+	fd.close();
+}
+
+void write_Config(Fl_Widget*, void*){
+	std::fstream fd;
+	data config;
+	std::memset(config.header, '\0', 32);
+	std::memset(config.text, '\0', 64);
+	std::strcpy(config.header, HEADER);
+	std::strcpy(config.text, TEXT);
+	fd.open("Config.dat", std::ios::out | std::ios::binary);
+	
+	config.move = movegt->value();
+	config.attack = buttonzx->value();
+	config.okay = okayattack->value();
+	
+	config.display = displaychoice->value();
+	config.useJoy = joychoice->value();
+	for(char i =0;i<8;i++){
+		config.buttons[i] = joyRows[i]->value();
+	}
+	fd.write((char*)&config, 148);
+	fd.close();
+	exit(0);
+}
+int main(int argc, char* argv[]){
+	Fl_Window *mainw = new Fl_Window(400, 380, "DoConfigure - Doukutsu Monotagari Settings");
+	
+	Fl_Group *movegroup = new Fl_Group(10, 10, 185, 50);
+		movegroup->box(FL_THIN_DOWN_BOX);
+		movear = new Fl_Radio_Round_Button(10, 10, 185, 20, "Arrows for Movement");
+		movear->setonly();
+		movegt = new Fl_Radio_Round_Button(10, 40, 185, 20, "<>? for Movement");
+	movegroup->end();
+	
+	Fl_Group *buttongroup = new Fl_Group(10, 70, 185, 50);
+		buttongroup->box(FL_THIN_DOWN_BOX);
+		buttonxz = new Fl_Radio_Round_Button(10, 70, 185, 20, "Z=Jump; X=Attack");
+		buttonxz->setonly();
+		buttonzx = new Fl_Radio_Round_Button(10, 100, 185, 20, "X=Jump; Z=Attack");
+	buttongroup->end();
+	
+	Fl_Group *okaygroup = new Fl_Group(205, 10, 185, 50);
+		okaygroup->box(FL_THIN_DOWN_BOX);
+		okayjump = new Fl_Radio_Round_Button(205, 10, 185, 20, "Jump=Okay");
+		okayjump->setonly();
+		okayattack = new Fl_Radio_Round_Button(205, 40, 185, 20, "Attack=Okay");
+	okaygroup->end();
+	
+	displaychoice = new Fl_Choice(205, 70, 185, 20);
+	Fl_Menu_Item screens[] = {
+		{"Fullscreen 16-bit"},
+		{"Windowed 320x240"},
+ 		{"Windowed 640x480"},
+		{"Fullscreen 24-bit"},
+		{"Fullscreen 32-bit"},
+		{0}};
+	displaychoice->menu(screens);
+	joychoice = new Fl_Check_Button(205, 100, 185, 20, "Use Joypad");
+	joychoice->callback(&activatejoy);
+		
+	joystuffcontainer = new Fl_Group(10, 130, 380, 200);
+		joystuffcontainer->box(FL_THIN_DOWN_BOX);
+		for(char i=0;i<8;i++){
+			joyRows[i] = new RadioRow(i);
+		}
+		//There's no Label class alright? I'll switch it as soon as one is introduced.
+		Fl_Group *labeljump = new Fl_Group(10, 150, 10, 20);
+		labeljump->label("Jump:");
+		labeljump->align(FL_ALIGN_RIGHT);
+		labeljump->end();
+		Fl_Group *labelattack = new Fl_Group(10, 180, 10, 20);
+		labelattack->label("Attack:");
+		labelattack->align(FL_ALIGN_RIGHT);
+		labelattack->end();
+		Fl_Group *labelweaponup = new Fl_Group(10, 210, 10, 20);
+		labelweaponup->label("Weapon+:");
+		labelweaponup->align(FL_ALIGN_RIGHT);
+		labelweaponup->end();
+		Fl_Group *labelweapondown = new Fl_Group(10, 240, 10, 20);
+		labelweapondown->label("Weapon-:");
+		labelweapondown->align(FL_ALIGN_RIGHT);
+		labelweapondown->end();
+		Fl_Group *labelitem = new Fl_Group(10, 270, 10, 20);
+		labelitem->label("Items:");
+		labelitem->align(FL_ALIGN_RIGHT);
+		labelitem->end();
+		Fl_Group *labelmap = new Fl_Group(10, 300, 10, 20);
+		labelmap->label("Map:");
+		labelmap->align(FL_ALIGN_RIGHT);
+		labelmap->end();
+		
+	joystuffcontainer->end();
+	
+	Fl_Button *okaybutton = new Fl_Button(10, 340, 185, 30, "Okay");
+	okaybutton->callback(&write_Config);
+	Fl_Button *cancelbutton = new Fl_Button(205, 340, 185, 30, "Cancel");
+	cancelbutton->callback(&quit);
+	
+	mainw->end();
+	mainw->show(argc, argv);
+	
+	read_Config();
+	Fl::option(Fl::OPTION_VISIBLE_FOCUS, false);
+	return Fl::run();
+}

DoConfig/icon.rc

@@ -0,0 +1 @@
+102 ICON "1.ico"

msvc/fltk/include/FL/Fl_Adjuster.H

@@ -0,0 +1,73 @@
+//
+// "$Id$"
+//
+// Adjuster widget header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Adjuster widget . */
+
+// 3-button "slider", made for Nuke
+
+#ifndef Fl_Adjuster_H
+#define Fl_Adjuster_H
+
+#ifndef Fl_Valuator_H
+#include "Fl_Valuator.H"
+#endif
+
+/**
+  The Fl_Adjuster widget was stolen from Prisms, and has proven
+  to be very useful for values that need a large dynamic range.
+  \image html adjuster1.png 
+  \image latex adjuster1.png "Fl_Adjuster" width=4cm
+  <P>When you  press a button and drag to the right the value increases.
+  When you drag  to the left it decreases.  The largest button adjusts by
+  100 *  step(), the next by 10 * step() and that
+  smallest button  by step().  Clicking on the buttons
+  increments by 10 times the  amount dragging by a pixel does. Shift +
+  click decrements by 10 times  the amount.
+*/
+class FL_EXPORT Fl_Adjuster : public Fl_Valuator {
+  int drag;
+  int ix;
+  int soft_;
+protected:
+  void draw();
+  int handle(int);
+  void value_damage();
+public:
+  Fl_Adjuster(int X,int Y,int W,int H,const char *l=0);
+  /**
+    If "soft" is turned on, the user is allowed to drag the value outside
+    the range.  If they drag the value to one of the ends, let go, then
+    grab again and continue to drag, they can get to any value.  Default is
+    one.
+  */
+  void soft(int s) {soft_ = s;}
+  /**
+    If "soft" is turned on, the user is allowed to drag the value outside
+    the range.  If they drag the value to one of the ends, let go, then
+    grab again and continue to drag, they can get to any value.  Default is
+    one.
+  */
+  int soft() const {return soft_;}
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_BMP_Image.H

@@ -0,0 +1,41 @@
+//
+// "$Id$"
+//
+// BMP image header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_BMP_Image widget . */
+
+#ifndef Fl_BMP_Image_H
+#define Fl_BMP_Image_H
+#  include "Fl_Image.H"
+
+/**
+ The Fl_BMP_Image class supports loading, caching,
+ and drawing of Windows Bitmap (BMP) image files. 
+ */
+class FL_EXPORT Fl_BMP_Image : public Fl_RGB_Image {
+
+  public:
+
+  Fl_BMP_Image(const char* filename);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Bitmap.H

@@ -0,0 +1,78 @@
+//
+// "$Id$"
+//
+// Bitmap header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Bitmap widget . */
+
+#ifndef Fl_Bitmap_H
+#define Fl_Bitmap_H
+#  include "Fl_Image.H"
+
+class Fl_Widget;
+struct Fl_Menu_Item;
+
+/**
+  The Fl_Bitmap class supports caching and drawing of mono-color
+  (bitmap) images. Images are drawn using the current color.
+*/
+class FL_EXPORT Fl_Bitmap : public Fl_Image {
+  friend class Fl_Quartz_Graphics_Driver;
+  friend class Fl_GDI_Graphics_Driver;
+  friend class Fl_GDI_Printer_Graphics_Driver;
+  friend class Fl_Xlib_Graphics_Driver;
+public:
+
+  /** pointer to raw bitmap data */
+  const uchar *array;
+  /** Non-zero if array points to bitmap data allocated internally */
+  int alloc_array;
+  
+  private:
+  int start(int XP, int YP, int WP, int HP, int &cx, int &cy, 
+	    int &X, int &Y, int &W, int &H);
+#if defined(__APPLE__) || defined(WIN32)
+  /** for internal use */
+  void *id_;
+#else
+  /** for internal use */
+  unsigned id_;
+#endif // __APPLE__ || WIN32
+
+  public:
+
+  /** The constructors create a new bitmap from the specified bitmap data */
+  Fl_Bitmap(const uchar *bits, int W, int H) :
+    Fl_Image(W,H,0), array(bits), alloc_array(0), id_(0) {data((const char **)&array, 1);}
+  /** The constructors create a new bitmap from the specified bitmap data */
+  Fl_Bitmap(const char *bits, int W, int H) :
+    Fl_Image(W,H,0), array((const uchar *)bits), alloc_array(0), id_(0) {data((const char **)&array, 1);}
+  virtual ~Fl_Bitmap();
+  virtual Fl_Image *copy(int W, int H);
+  Fl_Image *copy() { return copy(w(), h()); }
+  virtual void draw(int X, int Y, int W, int H, int cx=0, int cy=0);
+  void draw(int X, int Y) {draw(X, Y, w(), h(), 0, 0);}
+  virtual void label(Fl_Widget*w);
+  virtual void label(Fl_Menu_Item*m);
+  virtual void uncache();
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Box.H

@@ -0,0 +1,59 @@
+//
+// "$Id$"
+//
+// Box header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Box widget . */
+
+#ifndef Fl_Box_H
+#define Fl_Box_H
+
+#ifndef Fl_Widget_H
+#include "Fl_Widget.H"
+#endif
+
+/**
+  This widget simply draws its box, and possibly its label.  Putting it
+  before some other widgets and making it big enough to surround them
+  will let you draw a frame around them.
+*/
+class FL_EXPORT Fl_Box : public Fl_Widget {
+protected:
+  void draw();
+public:
+  /**
+    - The first constructor sets box() to FL_NO_BOX, which
+    means it is invisible. However such widgets are useful as placeholders
+    or Fl_Group::resizable()
+    values.  To change the box to something visible, use box(n).
+    - The second form of the constructor sets the box to the specified box
+    type.
+    <P>The destructor removes the box.
+  */
+  Fl_Box(int X, int Y, int W, int H, const char *l=0);
+  
+  /**    See Fl_Box::Fl_Box(int x, int y, int w, int h, const char * = 0)   */
+  Fl_Box(Fl_Boxtype b, int X, int Y, int W, int H, const char *l);
+
+  virtual int handle(int);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Browser.H

@@ -0,0 +1,326 @@
+//
+// "$Id$"
+//
+// Browser header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2016 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Browser widget . */
+
+// Forms-compatible browser.  Probably useful for other
+// lists of textual data.  Notice that the line numbers
+// start from 1, and 0 means "no line".
+
+#ifndef Fl_Browser_H
+#define Fl_Browser_H
+
+#include "Fl_Browser_.H"
+#include "Fl_Image.H"
+
+struct FL_BLINE;
+
+/**
+  The Fl_Browser widget displays a scrolling list of text
+  lines, and manages all the storage for the text.  This is not a text
+  editor or spreadsheet!  But it is useful for showing a vertical list of
+  named objects to the user.
+  
+  Each line in the browser is identified by number. <I>The numbers
+  start at one</I> (this is so that zero can be reserved for "no line" in
+  the selective browsers). <I>Unless otherwise noted, the methods do not
+  check to see if the passed line number is in range and legal.  It must
+  always be greater than zero and &lt;= size().</I>
+
+  Each line contains a null-terminated string of text and a void *
+  data pointer.  The text string is displayed, the void *
+  pointer can be used by the callbacks to reference the object the text
+  describes.
+
+  The base class does nothing when the user clicks on it.  The
+  subclasses 
+  Fl_Select_Browser, 
+  Fl_Hold_Browser, and 
+  Fl_Multi_Browser react to user clicks to select lines in
+  the browser and do callbacks.
+
+  The base class
+  Fl_Browser_ provides the scrolling and selection mechanisms of
+  this and all the subclasses, but the dimensions and appearance of each
+  item are determined by the subclass. You can use Fl_Browser_
+  to display information other than text, or text that is dynamically
+  produced from your own data structures. If you find that loading the
+  browser is a lot of work or is inefficient, you may want to make a
+  subclass of Fl_Browser_.
+
+  Some common coding patterns used for working with Fl_Browser:
+  \code
+      // How to loop through all the items in the browser
+      for ( int t=1; t<=browser->size(); t++ ) {       // index 1 based..!
+	  printf("item #%d, label='%s'\n", t, browser->text(t));
+      }
+  \endcode
+
+  Note: If you are <I>subclassing</I> Fl_Browser, it's more efficient
+  to use the protected methods item_first() and item_next(), since
+  Fl_Browser internally uses linked lists to manage the browser's items.
+  For more info, see find_item(int).
+*/
+class FL_EXPORT Fl_Browser : public Fl_Browser_ {
+
+  FL_BLINE *first;		// the array of lines
+  FL_BLINE *last;
+  FL_BLINE *cache;
+  int cacheline;		// line number of cache
+  int lines;                	// Number of lines
+  int full_height_;
+  const int* column_widths_;
+  char format_char_;		// alternative to @-sign
+  char column_char_;		// alternative to tab
+
+protected:
+
+  // required routines for Fl_Browser_ subclass:
+  void* item_first() const ;
+  void* item_next(void* item) const ;
+  void* item_prev(void* item) const ;
+  void* item_last()const ;
+  int item_selected(void* item) const ;
+  void item_select(void* item, int val);
+  int item_height(void* item) const ;
+  int item_width(void* item) const ;
+  void item_draw(void* item, int X, int Y, int W, int H) const ;
+  int full_height() const ;
+  int incr_height() const ;
+  const char *item_text(void *item) const;
+  /** Swap the items \p a and \p b.
+      You must call redraw() to make any changes visible.
+      \param[in] a,b the items to be swapped.
+      \see swap(int,int), item_swap()
+   */
+  void item_swap(void *a, void *b) { swap((FL_BLINE*)a, (FL_BLINE*)b); }
+  /** Return the item at specified \p line.
+      \param[in] line The line of the item to return. (1 based)
+      \returns The item, or NULL if line out of range.
+      \see item_at(), find_line(), lineno()
+   */
+  void *item_at(int line) const { return (void*)find_line(line); }
+
+  FL_BLINE* find_line(int line) const ;
+  FL_BLINE* _remove(int line) ;
+  void insert(int line, FL_BLINE* item);
+  int lineno(void *item) const ;
+  void swap(FL_BLINE *a, FL_BLINE *b);
+
+public:
+
+  void remove(int line);
+  void add(const char* newtext, void* d = 0);
+  void insert(int line, const char* newtext, void* d = 0);
+  void move(int to, int from);
+  int  load(const char* filename);
+  void swap(int a, int b);
+  void clear();
+
+  /**
+    Returns how many lines are in the browser.
+    The last line number is equal to this.
+    Returns 0 if browser is empty.
+  */
+  int size() const { return lines; }
+  void size(int W, int H) { Fl_Widget::size(W, H); }
+
+  /**
+    Gets the default text size (in pixels) for the lines in the browser.
+  */
+  Fl_Fontsize textsize() const { return Fl_Browser_::textsize(); }
+
+  /*
+    Sets the default text size for the lines in the browser to newSize.
+    Defined and documented in Fl_Browser.cxx
+  */
+  void textsize(Fl_Fontsize newSize);
+
+  int topline() const ;
+  /** For internal use only? */
+  enum Fl_Line_Position { TOP, BOTTOM, MIDDLE };
+  void lineposition(int line, Fl_Line_Position pos);
+  /**
+    Scrolls the browser so the top item in the browser
+    is showing the specified \p line.
+    \param[in] line The line to be displayed at the top.
+    \see topline(), middleline(), bottomline(), displayed(), lineposition()
+   */
+  void topline(int line) { lineposition(line, TOP); }
+  /**
+    Scrolls the browser so the bottom item in the browser
+    is showing the specified \p line.
+    \param[in] line The line to be displayed at the bottom.
+    \see topline(), middleline(), bottomline(), displayed(), lineposition()
+   */
+  void bottomline(int line) { lineposition(line, BOTTOM); }
+  /**
+    Scrolls the browser so the middle item in the browser
+    is showing the specified \p line.
+    \param[in] line The line to be displayed in the middle.
+    \see topline(), middleline(), bottomline(), displayed(), lineposition()
+   */
+  void middleline(int line) { lineposition(line, MIDDLE); }
+
+  int select(int line, int val=1);
+  int selected(int line) const ;
+  void show(int line);
+  /** Shows the entire Fl_Browser widget -- opposite of hide(). */
+  void show() { Fl_Widget::show(); }
+  void hide(int line);
+  /** Hides the entire Fl_Browser widget -- opposite of show(). */
+  void hide() { Fl_Widget::hide(); }
+  int visible(int line) const ;
+
+  int value() const ;
+  /**
+    Sets the browser's value(), which selects the specified \p line.
+    This is the same as calling select(line).
+    \see select(), selected(), value(), item_select(), item_selected()
+   */
+  void value(int line) { select(line); }
+  const char* text(int line) const ;
+  void text(int line, const char* newtext);
+  void* data(int line) const ;
+  void data(int line, void* d);
+
+  Fl_Browser(int X, int Y, int W, int H, const char *L = 0);
+  /**
+    The destructor deletes all list items and destroys the browser.
+   */
+  ~Fl_Browser() { clear(); }
+
+  /**
+    Gets the current format code prefix character, which by default is '\@'.
+    A string of formatting codes at the start of each column are stripped off
+    and used to modify how the rest of the line is printed:
+    
+    \li <tt>'\@.'</tt> Print rest of line, don't look for more '\@' signs
+    \li <tt>'\@\@'</tt> Print rest of line starting with '\@'
+    \li <tt>'\@l'</tt> Use a LARGE (24 point) font
+    \li <tt>'\@m'</tt> Use a medium large (18 point) font
+    \li <tt>'\@s'</tt> Use a <SMALL>small</SMALL> (11 point) font
+    \li <tt>'\@b'</tt> Use a <B>bold</B> font (adds FL_BOLD to font)
+    \li <tt>'\@i'</tt> Use an <I>italic</I> font (adds FL_ITALIC to font)
+    \li <tt>'\@f' or '\@t'</tt> Use a fixed-pitch
+    font (sets font to FL_COURIER)
+    \li <tt>'\@c'</tt> Center the line horizontally
+    \li <tt>'\@r'</tt> Right-justify the text
+    \li <tt>'\@B0', '\@B1', ... '\@B255'</tt> Fill the backgound with
+    fl_color(n)
+    \li <tt>'\@C0', '\@C1', ... '\@C255'</tt> Use fl_color(n) to draw the text
+    \li <tt>'\@F0', '\@F1', ...</tt> Use fl_font(n) to draw the text
+    \li <tt>'\@S1', '\@S2', ...</tt> Use point size n to draw the text
+    \li <tt>'\@u' or '\@_'</tt> Underline the text.
+    \li <tt>'\@-'</tt> draw an engraved line through the middle.
+
+    Notice that the '\@.' command can be used to reliably
+    terminate the parsing.  To print a random string in a random color, use 
+    <tt>sprintf("@C%d@.%s", color, string)</tt> and it will work even if the
+    string starts with a digit or has the format character in it.
+  */
+  char format_char() const { return format_char_; }
+  /**
+    Sets the current format code prefix character to \p c.
+    The default prefix is '\@'.  Set the prefix to 0 to disable formatting.
+    \see format_char() for list of '\@' codes
+  */
+  void format_char(char c) { format_char_ = c; }
+  /**
+    Gets the current column separator character.
+    The default is '\\t' (tab).
+    \see column_char(), column_widths()
+  */
+  char column_char() const { return column_char_; }
+  /**
+    Sets the column separator to c.
+    This will only have an effect if you also set column_widths().
+    The default is '\\t' (tab).
+    \see column_char(), column_widths()
+  */
+  void column_char(char c) { column_char_ = c; }
+  /**
+    Gets the current column width array.
+    This array is zero-terminated and specifies the widths in pixels of
+    each column. The text is split at each column_char() and each part is
+    formatted into it's own column.  After the last column any remaining
+    text is formatted into the space between the last column and the
+    right edge of the browser, even if the text contains instances of
+    column_char() .  The default value is a one-element array of just
+    a zero, which means there are no columns.
+
+    Example:
+    \code
+  Fl_Browser *b = new Fl_Browser(..);
+  static int widths[] = { 50, 50, 50, 70, 70, 40, 40, 70, 70, 50, 0 };  // widths for each column
+  b->column_widths(widths); // assign array to widget
+  b->column_char('\t');     // use tab as the column character
+  b->add("USER\tPID\tCPU\tMEM\tVSZ\tRSS\tTTY\tSTAT\tSTART\tTIME\tCOMMAND");
+  b->add("root\t2888\t0.0\t0.0\t1352\t0\ttty3\tSW\tAug15\t0:00\t@b@f/sbin/mingetty tty3");
+  b->add("root\t13115\t0.0\t0.0\t1352\t0\ttty2\tSW\tAug30\t0:00\t@b@f/sbin/mingetty tty2");
+  [..]
+    \endcode
+    \see column_char(), column_widths()
+  */
+  const int* column_widths() const { return column_widths_; }
+  /**
+    Sets the current array to \p arr.  Make sure the last entry is zero.
+    \see column_char(), column_widths()
+  */
+  void column_widths(const int* arr) { column_widths_ = arr; }
+
+  /**
+    Returns non-zero if \p line has been scrolled to a position where it is being displayed.
+    Checks to see if the item's vertical position is within the top and bottom
+    edges of the display window. This does NOT take into account the hide()/show()
+    status of the widget or item.
+    \param[in] line The line to be checked
+    \returns 1 if visible, 0 if not visible.
+    \see topline(), middleline(), bottomline(), displayed(), lineposition()
+  */
+  int displayed(int line) const { return Fl_Browser_::displayed(find_line(line)); }
+
+  /**
+    Make the item at the specified \p line visible().
+    Functionally similar to show(int line).
+    If \p line is out of range, redisplay top or bottom of list as appropriate.
+    \param[in] line The line to be made visible.
+    \see show(int), hide(int), display(), visible(), make_visible()
+  */
+  void make_visible(int line) {
+    if (line < 1) Fl_Browser_::display(find_line(1));
+    else if (line > lines) Fl_Browser_::display(find_line(lines));
+    else Fl_Browser_::display(find_line(line));
+  }
+
+  // icon support
+  void icon(int line, Fl_Image* icon);
+  Fl_Image* icon(int line) const;
+  void remove_icon(int line);
+
+  /** For back compatibility only. */
+  void replace(int a, const char* b) { text(a, b); }
+  void display(int line, int val=1);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Browser_.H

@@ -0,0 +1,388 @@
+//
+// "$Id$"
+//
+// Common browser header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2016 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Browser_ widget . */
+
+// Yes, I know this should be a template...
+
+#ifndef Fl_Browser__H
+#define Fl_Browser__H
+
+#ifndef Fl_Group_H
+#include "Fl_Group.H"
+#endif
+#include "Fl_Scrollbar.H"
+#include <FL/Fl.H>		// Fl::scrollbar_size()
+
+#define FL_NORMAL_BROWSER	0	/**< type() of Fl_Browser */
+#define FL_SELECT_BROWSER	1	/**< type() of FL_Select_Browser */
+#define FL_HOLD_BROWSER		2	/**< type() of Fl_Hold_Browser */
+#define FL_MULTI_BROWSER	3	/**< type() of Fl_Multi_Browser */
+
+#define FL_SORT_ASCENDING	0	/**< sort browser items in ascending alphabetic order. */
+#define FL_SORT_DESCENDING	1	/**< sort in descending order */
+
+/**
+  This is the base class for browsers.  To be useful it must be
+  subclassed and several virtual functions defined.  The Forms-compatible
+  browser and the file chooser's browser are subclassed off of this.
+
+  This has been designed so that the subclass has complete control
+  over the storage of the data, although because next() and 
+  prev() functions are used to index, it works best as a linked list
+  or as a large block of characters in which the line breaks must be
+  searched for.
+
+  A great deal of work has been done so that the "height" of a data
+  object does not need to be determined until it is drawn.  This is
+  useful if actually figuring out the size of an object requires
+  accessing image data or doing stat() on a file or doing some
+  other slow operation.
+
+  Keyboard navigation of browser items
+  ------------------------------------
+  The keyboard navigation of browser items is only possible if
+  visible_focus() is enabled. If disabled, the widget rejects keyboard focus;
+  Tab and Shift-Tab focus navigation will skip the widget.
+
+  In 'Select' and 'Normal' mode, the widget rejects keyboard focus;
+  no navigation keys are supported (other than scrollbar positioning).
+
+  In 'Hold' mode, the widget accepts keyboard focus, and Up/Down arrow
+  keys can navigate the selected item.
+
+  In 'Multi' mode, the widget accepts keyboard focus, and Up/Down arrow
+  keys navigate the focus box; Space toggles the current item's selection,
+  Enter selects only the current item (deselects all others).  If Shift
+  (or Ctrl) is combined with Up/Down arrow keys, the current item's
+  selection state is extended to the next item. In this way one can
+  extend a selection or de-selection.
+*/
+class FL_EXPORT Fl_Browser_ : public Fl_Group {
+  int position_;	// where user wants it scrolled to
+  int real_position_;	// the current vertical scrolling position
+  int hposition_;	// where user wants it panned to
+  int real_hposition_;	// the current horizontal scrolling position
+  int offset_;		// how far down top_ item the real_position is
+  int max_width;	// widest object seen so far
+  uchar has_scrollbar_;	// which scrollbars are enabled
+  Fl_Font textfont_;
+  Fl_Fontsize textsize_;
+  Fl_Color textcolor_;
+  void* top_;		// which item scrolling position is in
+  void* selection_;	// which is selected (except for FL_MULTI_BROWSER)
+  void *redraw1,*redraw2; // minimal update pointers
+  void* max_width_item;	// which item has max_width_
+  int scrollbar_size_;	// size of scrollbar trough
+
+  void update_top();
+
+protected:
+
+  // All of the following must be supplied by the subclass:
+  /**
+    This method must be provided by the subclass 
+    to return the first item in the list.
+    \see item_first(), item_next(), item_last(), item_prev()
+   */
+  virtual void *item_first() const = 0;
+  /**
+    This method must be provided by the subclass
+    to return the item in the list after \p item.
+    \see item_first(), item_next(), item_last(), item_prev()
+   */
+  virtual void *item_next(void *item) const = 0;
+  /**
+    This method must be provided by the subclass
+    to return the item in the list before \p item.
+    \see item_first(), item_next(), item_last(), item_prev()
+   */
+  virtual void *item_prev(void *item) const = 0;
+  /**
+    This method must be provided by the subclass
+    to return the last item in the list.
+    \see item_first(), item_next(), item_last(), item_prev()
+   */
+  virtual void *item_last() const { return 0L; }
+  /** 
+    This method must be provided by the subclass to return 
+    the height of \p item in pixels.
+    Allow for two additional pixels for the list selection box.
+    \param[in] item The item whose height is returned.
+    \returns The height of the specified \p item in pixels.
+    \see item_height(), item_width(), item_quick_height()
+  */
+  virtual int item_height(void *item) const = 0;
+  /**
+    This method must be provided by the subclass to return the width of the
+    \p item in pixels.  Allow for two additional pixels for the list
+    selection box.
+    \param[in] item The item whose width is returned.
+    \returns The width of the item in pixels.
+  */
+  virtual int item_width(void *item) const = 0;
+  virtual int item_quick_height(void *item) const ;
+  /**
+    This method must be provided by the subclass to draw the \p item
+    in the area indicated by \p X, \p Y, \p W, \p H.
+  */
+  virtual void item_draw(void *item,int X,int Y,int W,int H) const = 0;
+  /**
+    This optional method returns a string (label) that may be used for sorting. 
+    \param[in] item The item whose label text is returned.
+    \returns The item's text label. (Can be NULL if blank)
+   */
+  virtual const char *item_text(void *item) const { (void)item; return 0L; }
+  /**
+    This optional method should be provided by the subclass 
+    to efficiently swap browser items \p a and \p b, such as for sorting.
+    \param[in] a,b The two items to be swapped.
+   */
+  virtual void item_swap(void *a,void *b) { (void)a; (void)b; }
+  /**
+    This method must be provided by the subclass 
+    to return the item for the specified \p index. 
+    \param[in] index The \p index of the item to be returned
+    \returns The item at the specified \p index.
+   */
+  virtual void *item_at(int index) const { (void)index; return 0L; }
+  // you don't have to provide these but it may help speed it up:
+  virtual int full_width() const ;	// current width of all items
+  virtual int full_height() const ;	// current height of all items
+  virtual int incr_height() const ;	// average height of an item
+  // These only need to be done by subclass if you want a multi-browser:
+  virtual void item_select(void *item,int val=1);
+  virtual int item_selected(void *item) const ;
+
+  // things the subclass may want to call:
+  /**
+    Returns the item that appears at the top of the list.
+   */
+  void *top() const { return top_; }
+  /**
+    Returns the item currently selected, or NULL if there is no selection.
+    
+    For multiple selection browsers this call returns the currently focused item,
+    even if it is not selected. To find all selected items, call 
+    Fl_Multi_Browser::selected() for every item in question.
+  */
+  void *selection() const { return selection_; }
+  void new_list(); // completely clobber all data, as though list replaced
+  void deleting(void *item); // get rid of any pointers to item
+  void replacing(void *a,void *b); // change a pointers to b
+  void swapping(void *a,void *b); // exchange pointers a and b
+  void inserting(void *a,void *b); // insert b near a
+  int displayed(void *item) const ; // true if this item is visible
+  void redraw_line(void *item); // minimal update, no change in size
+  /**
+    This method will cause the entire list to be redrawn.
+    \see redraw_lines(), redraw_line()
+   */
+  void redraw_lines() { damage(FL_DAMAGE_SCROLL); } // redraw all of them
+  void bbox(int &X,int &Y,int &W,int &H) const;
+  int leftedge() const;	// x position after scrollbar & border
+  void *find_item(int ypos); // item under mouse
+  
+  void draw();
+  Fl_Browser_(int X,int Y,int W,int H,const char *L=0);
+
+public:
+
+  /**
+    Vertical scrollbar. Public, so that it can be accessed directly.
+   */
+  Fl_Scrollbar scrollbar;
+  /**
+    Horizontal scrollbar. Public, so that it can be accessed directly.
+   */
+  Fl_Scrollbar hscrollbar;
+
+  int handle(int event);
+  void resize(int X,int Y,int W,int H);
+
+  int select(void *item,int val=1,int docallbacks=0);
+  int select_only(void *item,int docallbacks=0);
+  int deselect(int docallbacks=0);
+  /**
+    Gets the vertical scroll position of the list as a pixel position \p pos.
+    The position returned is how many pixels of the list are scrolled off the top edge
+    of the screen.  Example: A position of '3' indicates the top 3 pixels of 
+    the list are scrolled off the top edge of the screen.
+    \see position(), hposition()
+  */
+  int position() const { return position_; }
+  void position(int pos); // scroll to here
+  /**
+    Gets the horizontal scroll position of the list as a pixel position \p pos.
+    The position returned is how many pixels of the list are scrolled off the left edge
+    of the screen. Example: A position of '18' indicates the left 18 pixels of
+    the list are scrolled off the left edge of the screen.
+    \see position(), hposition()
+  */
+  int hposition() const { return hposition_; }
+  void hposition(int); // pan to here
+  void display(void *item); // scroll so this item is shown
+
+  /**
+    Values for has_scrollbar().
+   */
+  /** Anonymous enum bit flags for has_scrollbar().
+     -  bit 0: horizontal
+     -  bit 1: vertical
+     -  bit 2: 'always' (to be combined with bits 0 and 1)
+     -  bit 3-31: reserved for future use
+   */
+  enum { // values for has_scrollbar()
+    HORIZONTAL = 1,		///< Only show horizontal scrollbar.
+    VERTICAL = 2,		///< Only show vertical scrollbar.
+    BOTH = 3,			///< Show both scrollbars. (default)
+    ALWAYS_ON = 4,		///< Specified scrollbar(s) should 'always' be shown (to be used with HORIZONTAL/VERTICAL)
+    HORIZONTAL_ALWAYS = 5,	///< Horizontal scrollbar always on.
+    VERTICAL_ALWAYS = 6,	///< Vertical scrollbar always on.
+    BOTH_ALWAYS = 7		///< Both scrollbars always on.
+  };
+  /**
+    Returns the current scrollbar mode, see Fl_Browser_::has_scrollbar(uchar)
+   */
+  uchar has_scrollbar() const { return has_scrollbar_; }
+  /**
+    Sets whether the widget should have scrollbars or not (default Fl_Browser_::BOTH).
+    By default you can scroll in both directions, and the scrollbars
+    disappear if the data will fit in the widget.  
+    has_scrollbar() changes this based on the value of \p mode:
+  
+    - 0 - No scrollbars.
+
+    - Fl_Browser_::HORIZONTAL - Only a horizontal scrollbar.
+
+    - Fl_Browser_::VERTICAL - Only a vertical scrollbar.
+
+    - Fl_Browser_::BOTH - The default is both scrollbars.
+
+    - Fl_Browser_::HORIZONTAL_ALWAYS - Horizontal scrollbar always on,
+      vertical always off.
+
+    - Fl_Browser_::VERTICAL_ALWAYS - Vertical scrollbar always on,
+      horizontal always off.
+
+    - Fl_Browser_::BOTH_ALWAYS - Both always on.
+  */
+  void has_scrollbar(uchar mode) { has_scrollbar_ = mode; }
+
+  /**
+    Gets the default text font for the lines in the browser.
+    \see textfont(), textsize(), textcolor()
+  */
+  Fl_Font textfont() const { return textfont_; }
+  /**
+    Sets the default text font for the lines in the browser to \p font.
+  */
+  void textfont(Fl_Font font) { textfont_ = font; }
+
+  /**
+    Gets the default text size (in pixels) for the lines in the browser.
+  */
+  Fl_Fontsize textsize() const { return textsize_; }
+  /**
+    Sets the default text size (in pixels) for the lines in the browser to \p size.
+  */
+  void textsize(Fl_Fontsize newSize) { textsize_ = newSize; }
+
+  /**
+    Gets the default text color for the lines in the browser.
+  */
+  Fl_Color textcolor() const { return textcolor_; }
+  /**
+    Sets the default text color for the lines in the browser to color \p col.
+  */
+  void textcolor(Fl_Color col) { textcolor_ = col; }
+
+  /**
+    Gets the current size of the scrollbars' troughs, in pixels.
+
+    If this value is zero (default), this widget will use the 
+    Fl::scrollbar_size() value as the scrollbar's width.
+  
+    \returns Scrollbar size in pixels, or 0 if the global Fl::scrollbar_size() is being used.
+    \see Fl::scrollbar_size(int)
+  */
+  int scrollbar_size() const {
+      return(scrollbar_size_);
+  }
+  /**
+    Sets the pixel size of the scrollbars' troughs to \p newSize, in pixels.
+
+    Normally you should not need this method, and should use
+    Fl::scrollbar_size(int) instead to manage the size of ALL 
+    your widgets' scrollbars. This ensures your application 
+    has a consistent UI, is the default behavior, and is normally
+    what you want.
+
+    Only use THIS method if you really need to override the global
+    scrollbar size. The need for this should be rare.
+    
+    Setting \p newSize to the special value of 0 causes the widget to
+    track the global Fl::scrollbar_size(), which is the default.
+    
+    \param[in] newSize Sets the scrollbar size in pixels.\n
+                    If 0 (default), scrollbar size tracks the global Fl::scrollbar_size()
+    \see Fl::scrollbar_size()
+  */
+  void scrollbar_size(int newSize) {
+      scrollbar_size_ = newSize;
+  }   
+  /**
+    This method has been deprecated, existing for backwards compatibility only.
+    Use scrollbar_size() instead.
+    This method always returns the global value Fl::scrollbar_size().
+    \returns Always returns the global value Fl::scrollbar_size().
+    \todo This method should eventually be removed in 1.4+
+  */
+  int scrollbar_width() const {
+      return(Fl::scrollbar_size());
+  }
+  /**
+    This method has been deprecated, existing for backwards compatibility only.
+    Use scrollbar_size(int) instead.
+    This method sets the global Fl::scrollbar_size(), and forces this
+    instance of the widget to use it.
+    \todo This method should eventually be removed in 1.4+
+  */
+  void scrollbar_width(int width) {
+      Fl::scrollbar_size(width);
+      scrollbar_size_ = 0;
+  }
+  /**
+    Moves the vertical scrollbar to the righthand side of the list.
+    For back compatibility.
+  */
+  void scrollbar_right() { scrollbar.align(FL_ALIGN_RIGHT); }
+  /**
+    Moves the vertical scrollbar to the lefthand side of the list.
+    For back compatibility.
+  */
+  void scrollbar_left() { scrollbar.align(FL_ALIGN_LEFT); }
+  void sort(int flags=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Button.H

@@ -0,0 +1,176 @@
+//
+// "$Id$"
+//
+// Button header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2014 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Button widget . */
+
+#ifndef Fl_Button_H
+#define Fl_Button_H
+
+#ifndef Fl_Widget_H
+#include "Fl_Widget.H"
+#endif
+
+// values for type()
+#define FL_NORMAL_BUTTON	0   /**< value() will be set to 1 during the press of the button and
+                                         reverts back to 0 when the button is released */
+#define FL_TOGGLE_BUTTON	1   ///< value() toggles between 0 and 1 at every click of the button
+#define FL_RADIO_BUTTON		(FL_RESERVED_TYPE+2) /**< is set to 1 at button press, and all other
+				         buttons in the same group with <tt>type() == FL_RADIO_BUTTON</tt>
+				         are set to zero.*/
+#define FL_HIDDEN_BUTTON	3   ///< for Forms compatibility
+
+extern FL_EXPORT Fl_Shortcut fl_old_shortcut(const char*);
+
+class Fl_Widget_Tracker;
+
+/**
+  \class Fl_Button
+  \brief Buttons generate callbacks when they are clicked by the user.
+
+  You control exactly when and how by changing the values for type() and
+  when().  Buttons can also generate callbacks in response to \c FL_SHORTCUT
+  events.  The button can either have an explicit shortcut(int s) value or a
+  letter shortcut can be indicated in the label() with an '\&' character
+  before it.  For the label shortcut it does not matter if \e Alt is held
+  down, but if you have an input field in the same window, the user will have
+  to hold down the \e Alt key so that the input field does not eat the event
+  first as an \c FL_KEYBOARD event.
+
+  \todo Refactor the doxygen comments for Fl_Button type() documentation.
+
+  For an Fl_Button object, the type() call returns one of:
+  \li \c FL_NORMAL_BUTTON (0): value() remains unchanged after button press.
+  \li \c FL_TOGGLE_BUTTON: value() is inverted after button press.
+  \li \c FL_RADIO_BUTTON: value() is set to 1 after button press, and all other
+         buttons in the current group with <tt>type() == FL_RADIO_BUTTON</tt>
+	 are set to zero.
+
+  \todo Refactor the doxygen comments for Fl_Button when() documentation.
+
+  For an Fl_Button object, the following when() values are useful, the default
+  being \c FL_WHEN_RELEASE:
+  \li \c 0: The callback is not done, instead changed() is turned on.
+  \li \c FL_WHEN_RELEASE: The callback is done after the user successfully
+         clicks the button, or when a shortcut is typed.
+  \li \c FL_WHEN_CHANGED: The callback is done each time the value() changes
+         (when the user pushes and releases the button, and as the mouse is
+	 dragged around in and out of the button).
+*/
+
+class FL_EXPORT Fl_Button : public Fl_Widget {
+
+  int shortcut_;
+  char value_;
+  char oldval;
+  uchar down_box_;
+
+protected:
+
+  static Fl_Widget_Tracker *key_release_tracker;
+  static void key_release_timeout(void*);
+  void simulate_key_action();
+
+  virtual void draw();
+
+public:
+
+  virtual int handle(int);
+
+  Fl_Button(int X, int Y, int W, int H, const char *L = 0);
+
+  int value(int v);
+
+  /**
+    Returns the current value of the button (0 or 1).
+   */
+  char value() const {return value_;}
+
+  /**
+    Same as \c value(1).
+    \see value(int v)
+   */
+  int set() {return value(1);}
+
+  /**
+    Same as \c value(0).
+    \see value(int v)
+   */
+  int clear() {return value(0);}
+
+  void setonly(); // this should only be called on FL_RADIO_BUTTONs
+
+  /**
+    Returns the current shortcut key for the button.
+    \retval int
+   */
+  int shortcut() const {return shortcut_;}
+
+  /**
+    Sets the shortcut key to \c s.
+    Setting this overrides the use of '\&' in the label().
+    The value is a bitwise OR of a key and a set of shift flags, for example:
+    <tt>FL_ALT | 'a'</tt>, or
+    <tt>FL_ALT | (FL_F + 10)</tt>, or just
+    <tt>'a'</tt>.
+    A value of 0 disables the shortcut.
+
+    The key can be any value returned by Fl::event_key(), but will usually be
+    an ASCII letter.  Use a lower-case letter unless you require the shift key
+    to be held down.
+
+    The shift flags can be any set of values accepted by Fl::event_state().
+    If the bit is on, that shift key must be pushed.  Meta, Alt, Ctrl, and
+    Shift must be off if they are not in the shift flags (zero for the other
+    bits indicates a "don't care" setting).
+    \param[in] s bitwise OR of key and shift flags
+   */
+  void shortcut(int s) {shortcut_ = s;}
+
+  /**
+    Returns the current down box type, which is drawn when value() is non-zero.
+    \retval Fl_Boxtype
+   */
+  Fl_Boxtype down_box() const {return (Fl_Boxtype)down_box_;}
+
+  /**
+    Sets the down box type. The default value of 0 causes FLTK to figure out
+    the correct matching down version of box().
+
+    Some derived classes (e.g. Fl_Round_Button and Fl_Light_Button use
+    down_box() for special purposes. See docs of these classes.
+
+    \param[in] b down box type
+   */
+  void down_box(Fl_Boxtype b) {down_box_ = b;}
+
+  /// (for backwards compatibility)
+  void shortcut(const char *s) {shortcut(fl_old_shortcut(s));}
+
+  /// (for backwards compatibility)
+  Fl_Color down_color() const {return selection_color();}
+
+  /// (for backwards compatibility)
+  void down_color(unsigned c) {selection_color(c);}
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Cairo.H

@@ -0,0 +1,88 @@
+//
+// "$Id$"
+//
+// Main header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+    Handling transparently platform dependent cairo include files 
+*/
+
+#ifndef FL_CAIRO_H
+# define FL_CAIRO_H
+# ifdef FLTK_HAVE_CAIRO
+
+// Cairo is currently supported for the following platforms:
+// Win32, Apple Quartz, X11
+
+# include <FL/Fl_Export.H>
+
+# include <cairo.h>
+
+/** 
+   \addtogroup group_cairo
+   @{
+*/
+
+/** 
+   Contains all the necessary info on the current cairo context.
+   A private internal & unique corresponding object is created to
+   permit cairo context state handling while keeping it opaque.
+   For internal use only.
+   \note Only available when configure has the --enable-cairo option
+*/
+class FL_EXPORT Fl_Cairo_State {
+public:
+  Fl_Cairo_State() : cc_(0), own_cc_(false), autolink_(false), window_(0), gc_(0) {}
+
+    // access attributes
+    cairo_t* cc() const {return cc_;}		 ///< Gets the current cairo context
+    bool autolink() const {return autolink_;}	 ///< Gets the autolink option. See Fl::cairo_autolink_context(bool)
+    /** Sets the current cairo context.
+
+	\p own == \e true (the default) indicates that the cairo context \p c
+	will be deleted by FLTK internally when another cc is set later.
+
+	\p own == \e false indicates cc deletion is handled externally
+	by the user program.
+    */
+    void cc(cairo_t* c, bool own=true)  {
+	if (cc_ && own_cc_) cairo_destroy(cc_);
+	cc_=c;
+	if (!cc_) window_=0;
+	own_cc_=own;
+    }
+    void  autolink(bool b);                     ///< Sets the autolink option, only available with --enable-cairoext
+    void  window(void* w)  {window_=w;}		///< Sets the window \p w to keep track on
+    void* window() const {return window_;}	///< Gets the last window attached to a cc
+    void  gc(void* c)  {gc_=c;}		        ///< Sets the gc \p c to keep track on
+    void* gc() const {return gc_;}		///< Gets the last gc attached to a cc
+
+private:
+    cairo_t * cc_;	 // contains the unique autoupdated cairo context
+    bool own_cc_;	 // indicates whether we must delete the cc, useful for internal cleanup
+    bool autolink_;	 // false by default, prevents the automatic cairo mapping on fltk windows
+			 // for custom cairo implementations.
+    void* window_, *gc_; // for keeping track internally of last win+gc treated
+};
+
+/** @} */
+
+# endif // FLTK_HAVE_CAIRO
+#endif // FL_CAIRO_H
+
+//
+// End of "$Id$" .
+//

msvc/fltk/include/FL/Fl_Cairo_Window.H

@@ -0,0 +1,83 @@
+//
+// "$Id$"
+//
+// Main header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+    Fl_Cairo_Window Handling transparently a fltk window incorporte a cairo draw callback.
+*/
+
+#ifndef FL_CAIRO_WINDOW_H
+# define FL_CAIRO_WINDOW_H
+# ifdef FLTK_HAVE_CAIRO
+
+// Cairo is currently supported for the following platforms:
+// Win32, Apple Quartz, X11
+#  include <FL/Fl.H>
+#  include <FL/Fl_Double_Window.H>
+
+/** 
+   \addtogroup group_cairo
+   @{
+*/
+
+/**
+   This defines a pre-configured cairo fltk window.
+   This class overloads the virtual draw() method for you,
+   so that the only thing you have to do is to provide your cairo code.
+   All cairo context handling is achieved transparently.
+   \note You can alternatively define your custom cairo fltk window,
+   and thus at least override the draw() method to provide custom cairo
+   support. In this case you will probably use Fl::cairo_make_current(Fl_Window*)
+   to attach a context to your window. You should do it only when your window is 
+   the current window. \see Fl_Window::current()
+*/
+class FL_EXPORT Fl_Cairo_Window : public Fl_Double_Window {
+
+public:
+  Fl_Cairo_Window(int w, int h) : Fl_Double_Window(w,h),draw_cb_(0) {}
+
+protected:
+  /** Overloaded to provide cairo callback support */
+  void draw() {
+    Fl_Double_Window::draw();
+    // manual method ? if yes explicitly get a cairo_context here
+    if (!Fl::cairo_autolink_context()) 
+      Fl::cairo_make_current(this); 
+    if (draw_cb_) draw_cb_(this, Fl::cairo_cc());
+  }
+
+public:
+  /** This defines the cairo draw callback prototype that you must further */
+  typedef void (*cairo_draw_cb) (Fl_Cairo_Window* self, cairo_t* def);
+  /** 
+    You must provide a draw callback which will implement your cairo rendering.
+    This method will permit you to set your cairo callback to \p cb.
+  */
+  void set_draw_cb(cairo_draw_cb  cb){draw_cb_=cb;}
+private:
+    cairo_draw_cb draw_cb_;
+};
+
+
+/** @} */
+
+# endif // FLTK_HAVE_CAIRO
+#endif // FL_CAIRO_WINDOW_H
+
+//
+// End of "$Id$" .
+//

msvc/fltk/include/FL/Fl_Chart.H

@@ -0,0 +1,151 @@
+//
+// "$Id$"
+//
+// Forms chart header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Chart widget . */
+
+#ifndef Fl_Chart_H
+#define Fl_Chart_H
+
+#ifndef Fl_Widget_H
+#include "Fl_Widget.H"
+#endif
+
+// values for type()
+#define FL_BAR_CHART		0	/**< type() for Bar Chart variant */
+#define FL_HORBAR_CHART		1	/**< type() for Horizontal Bar Chart variant */
+#define FL_LINE_CHART		2	/**< type() for Line Chart variant */
+#define FL_FILL_CHART		3	/**< type() for Fill Line Chart variant */
+#define FL_SPIKE_CHART		4	/**< type() for Spike Chart variant */
+#define FL_PIE_CHART		5	/**< type() for Pie Chart variant */
+#define FL_SPECIALPIE_CHART	6	/**< type() for Special Pie Chart variant */
+
+#define FL_FILLED_CHART  FL_FILL_CHART	/**< for compatibility */
+
+#define FL_CHART_MAX		128	/**< max entries per chart */
+#define FL_CHART_LABEL_MAX	18	/**< max label length for entry */
+
+/** For internal use only */
+struct FL_CHART_ENTRY {
+   float val;				/**< For internal use only. */
+   unsigned col;			/**< For internal use only. */
+   char str[FL_CHART_LABEL_MAX+1];	/**< For internal use only. */
+};
+
+/**
+  \class Fl_Chart
+  \brief Fl_Chart displays simple charts.
+  It is provided for Forms compatibility.
+
+  \image html charts.png  
+  \image latex charts.png  "Fl_Chart" width=10cm
+  \todo Refactor Fl_Chart::type() information.
+
+  The type of an Fl_Chart object can be set using type(uchar t) to:
+  \li \c FL_BAR_CHART: Each sample value is drawn as a vertical bar.
+  \li \c FL_FILLED_CHART: The chart is filled from the bottom of the graph
+         to the sample values.
+  \li \c FL_HORBAR_CHART: Each sample value is drawn as a horizontal bar.
+  \li \c FL_LINE_CHART: The chart is drawn as a polyline with vertices at
+         each sample value.
+  \li \c FL_PIE_CHART: A pie chart is drawn with each sample value being
+         drawn as a proportionate slice in the circle.
+  \li \c FL_SPECIALPIE_CHART: Like \c FL_PIE_CHART, but the first slice is
+         separated from the pie.
+  \li \c FL_SPIKE_CHART: Each sample value is drawn as a vertical line.
+ */
+class FL_EXPORT Fl_Chart : public Fl_Widget {
+    int numb;
+    int maxnumb;
+    int sizenumb;
+    FL_CHART_ENTRY *entries;
+    double min,max;
+    uchar autosize_;
+    Fl_Font textfont_;
+    Fl_Fontsize textsize_;
+    Fl_Color textcolor_;
+protected:
+    void draw();
+public:
+    Fl_Chart(int X, int Y, int W, int H, const char *L = 0);
+
+    ~Fl_Chart();
+
+    void clear();
+
+    void add(double val, const char *str = 0, unsigned col = 0);
+
+    void insert(int ind, double val, const char *str = 0, unsigned col = 0);
+
+    void replace(int ind, double val, const char *str = 0, unsigned col = 0);
+
+    /**
+      Gets the lower and upper bounds of the chart values.
+      \param[out] a, b are set to lower, upper
+     */
+    void bounds(double *a,double *b) const {*a = min; *b = max;}
+
+    void bounds(double a,double b);
+
+    /**
+      Returns the number of data values in the chart.
+     */
+    int size() const {return numb;}
+
+    void size(int W, int H) { Fl_Widget::size(W, H); }
+
+    /**
+      Gets the maximum number of data values for a chart.
+     */
+    int maxsize() const {return maxnumb;}
+
+    void maxsize(int m);
+
+    /** Gets the chart's text font */
+    Fl_Font textfont() const {return textfont_;}
+    /** Sets the chart's text font to \p s. */
+    void textfont(Fl_Font s) {textfont_ = s;}
+
+    /** Gets the chart's text size */
+    Fl_Fontsize textsize() const {return textsize_;}
+    /** gets the chart's text size to \p s. */
+    void textsize(Fl_Fontsize s) {textsize_ = s;}
+
+    /** Gets the chart's text color */
+    Fl_Color textcolor() const {return textcolor_;}
+    /** gets the chart's text color to \p n. */
+    void textcolor(Fl_Color n) {textcolor_ = n;}
+
+    /**
+      Get whether the chart will automatically adjust the bounds of the chart.
+      \returns non-zero if auto-sizing is enabled and zero if disabled.
+     */
+    uchar autosize() const {return autosize_;}
+
+    /**
+      Set whether the chart will automatically adjust the bounds of the chart.
+      \param[in] n non-zero to enable automatic resizing, zero to disable.
+     */
+    void autosize(uchar n) {autosize_ = n;}
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Check_Browser.H

@@ -0,0 +1,113 @@
+//
+// "$Id$"
+//
+// Fl_Check_Browser header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Check_Browser widget . */
+
+#ifndef Fl_Check_Browser_H
+#define Fl_Check_Browser_H
+
+#include "Fl.H"
+#include "Fl_Browser_.H"
+
+/**
+  The Fl_Check_Browser widget displays a scrolling list of text
+  lines that may be selected and/or checked by the user.
+*/
+class FL_EXPORT Fl_Check_Browser : public Fl_Browser_ {
+  /* required routines for Fl_Browser_ subclass: */
+
+  void *item_first() const;
+  void *item_next(void *) const;
+  void *item_prev(void *) const;
+  int item_height(void *) const;
+  int item_width(void *) const;
+  void item_draw(void *, int, int, int, int) const;
+  void item_select(void *, int);
+  int item_selected(void *) const;
+
+  /* private data */
+
+  public: // IRIX 5.3 C++ compiler doesn't support private structures...
+
+#ifndef FL_DOXYGEN
+  /** For internal use only. */
+  struct cb_item {
+	  cb_item *next;	/**< For internal use only. */
+	  cb_item *prev;	/**< For internal use only. */
+	  char checked;		/**< For internal use only. */
+	  char selected;	/**< For internal use only. */
+	  char *text;		/**< For internal use only. */
+  };
+#endif // !FL_DOXYGEN
+
+  private:
+
+  cb_item *first;
+  cb_item *last;
+  cb_item *cache;
+  int cached_item;
+  int nitems_;
+  int nchecked_;
+  cb_item *find_item(int) const;
+  int lineno(cb_item *) const;
+
+  public:
+
+  Fl_Check_Browser(int x, int y, int w, int h, const char *l = 0);
+   /** The destructor deletes all list items and destroys the browser. */
+  ~Fl_Check_Browser() { clear(); }
+  int add(char *s);               // add an (unchecked) item
+  int add(char *s, int b);        // add an item and set checked
+				  // both return the new nitems()
+  int remove(int item);           // delete an item. Returns nitems()
+
+  // inline const char * methods to avoid breaking binary compatibility...
+   /** See int Fl_Check_Browser::add(char *s) */
+  int add(const char *s) { return add((char *)s); }
+  /** See int Fl_Check_Browser::add(char *s) */
+  int add(const char *s, int b) { return add((char *)s, b); }
+
+  void clear();                   // delete all items
+  /**
+    Returns how many lines are in the browser.  The last line number is equal to
+    this.
+  */
+  int nitems() const { return nitems_; }
+  /**    Returns how many items are currently checked.  */
+  int nchecked() const { return nchecked_; }
+  int checked(int item) const;
+  void checked(int item, int b);
+  /**    Equivalent to Fl_Check_Browser::checked(item, 1).  */
+  void set_checked(int item) { checked(item, 1); }
+  void check_all();
+  void check_none();
+  int value() const;              // currently selected item
+  char *text(int item) const;     // returns pointer to internal buffer
+
+  protected:
+
+  int handle(int);
+};
+
+#endif // Fl_Check_Browser_H
+
+//
+// End of "$Id$".
+//
+

msvc/fltk/include/FL/Fl_Check_Button.H

@@ -0,0 +1,39 @@
+//
+// "$Id$"
+//
+// Check button header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2014 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+#ifndef Fl_Check_Button_H
+#define Fl_Check_Button_H
+
+#include "Fl_Light_Button.H"
+
+/*
+  class: Fl_Check_Button.
+
+  A button with a "checkmark" to show its status.
+*/
+
+class FL_EXPORT Fl_Check_Button : public Fl_Light_Button {
+public:
+  Fl_Check_Button(int X, int Y, int W, int H, const char *L = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Choice.H

@@ -0,0 +1,106 @@
+//
+// "$Id$"
+//
+// Choice header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Choice widget . */
+
+#ifndef Fl_Choice_H
+#define Fl_Choice_H
+
+#include "Fl_Menu_.H"
+
+/**
+  \class Fl_Choice
+  \brief A button that is used to pop up a menu.
+
+  This is a button that, when pushed, pops up a menu (or hierarchy of menus)
+  defined by an array of Fl_Menu_Item objects.
+  Motif calls this an OptionButton.
+
+  The only difference between this and a Fl_Menu_Button is that the name of
+  the most recent chosen menu item is displayed inside the box, while the
+  label is displayed outside the box. However, since the use of this is most
+  often to control a single variable rather than do individual callbacks,
+  some of the Fl_Menu_Button methods are redescribed here in those terms.
+
+  When the user clicks a menu item, value() is set to that item
+  and then:
+
+      - The item's callback is done if one has been set; the
+        Fl_Choice is passed as the Fl_Widget* argument, 
+        along with any userdata configured for the callback.
+
+      - If the item does not have a callback, the Fl_Choice widget's
+        callback is done instead, along with any userdata configured
+        for it.  The callback can determine which item was picked using
+        value(), mvalue(), item_pathname(), etc.
+
+  All three mouse buttons pop up the menu. The Forms behavior of the first
+  two buttons to increment/decrement the choice is not implemented.  This
+  could be added with a subclass, however.
+
+  The menu will also pop up in response to shortcuts indicated by putting
+  a '\&' character in the label().  See Fl_Button::shortcut(int s) for a
+  description of this.
+
+  Typing the shortcut() of any of the items will do exactly the same as when
+  you pick the item with the mouse.  The '\&' character in item names are
+  only looked at when the menu is popped up, however.
+
+  \image html choice.png
+  \image latex choice.png  "Fl_Choice" width=4cm
+  \todo Refactor the doxygen comments for Fl_Choice changed() documentation.
+
+  \li <tt>int Fl_Widget::changed() const</tt>
+      This value is true the user picks a different value. <em>It is turned
+      off by value() and just before doing a callback (the callback can turn
+      it back on if desired).</em>
+  \li <tt>void Fl_Widget::set_changed()</tt>
+      This method sets the changed() flag.
+  \li <tt>void Fl_Widget::clear_changed()</tt>
+      This method clears the changed() flag.
+  \li <tt>Fl_Boxtype Fl_Choice::down_box() const</tt>
+      Gets the current down box, which is used when the menu is popped up.
+      The default down box type is \c FL_DOWN_BOX.
+  \li <tt>void Fl_Choice::down_box(Fl_Boxtype b)</tt>
+      Sets the current down box type to \p b.
+ */
+class FL_EXPORT Fl_Choice : public Fl_Menu_ {
+protected:
+  void draw();
+public:
+  int handle(int);
+
+  Fl_Choice(int X, int Y, int W, int H, const char *L = 0);
+
+  /**
+    Gets the index of the last item chosen by the user.
+    The index is zero initially.
+   */
+  int value() const {return Fl_Menu_::value();}
+
+  int value(int v);
+
+  int value(const Fl_Menu_Item* v);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Clock.H

@@ -0,0 +1,128 @@
+//
+// "$Id$"
+//
+// Clock header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Clock, Fl_Clock_Output widgets . */
+
+#ifndef Fl_Clock_H
+#define Fl_Clock_H
+
+#ifndef Fl_Widget_H
+#include "Fl_Widget.H"
+#endif
+
+// values for type:
+#define FL_SQUARE_CLOCK		0	/**< type() of Square Clock variant */
+#define FL_ROUND_CLOCK		1	/**< type() of Round Clock variant */
+#define FL_ANALOG_CLOCK FL_SQUARE_CLOCK	/**< An analog clock is square */
+#define FL_DIGITAL_CLOCK FL_SQUARE_CLOCK /**< Not yet implemented */
+
+// fabien: Please keep the horizontal formatting of both images in class desc, 
+// don't lose vert. space for nothing!
+
+/**
+  \class Fl_Clock_Output
+  \brief This widget can be used to display a program-supplied time.
+  
+  The time shown on the clock is not updated. To display the current time,
+  use Fl_Clock instead.
+
+  \htmlonly <BR>  <table align=CENTER border=1 cellpadding=5 >  
+  <caption align=bottom>type() FL_SQUARE_CLOCK and FL_ROUND_CLOCK </caption> <TR><TD> \endhtmlonly
+  \image html clock.png  
+  \htmlonly </TD> <TD> \endhtmlonly
+  \image html round_clock.png 
+  \htmlonly </TD> </TR> </table> \endhtmlonly
+  \image latex clock.png "FL_SQUARE_CLOCK type" width=4cm
+  \image latex round_clock.png "FL_ROUND_CLOCK type" width=4cm
+ */
+class FL_EXPORT Fl_Clock_Output : public Fl_Widget {
+  int hour_, minute_, second_;
+  ulong value_;
+  void drawhands(Fl_Color,Fl_Color); // part of draw
+protected:
+  void draw();
+  void draw(int X, int Y, int W, int H);
+public:
+
+  Fl_Clock_Output(int X, int Y, int W, int H, const char *L = 0);
+
+  void value(ulong v);	// set to this Unix time
+  
+  void value(int H, int m, int s);
+
+  /**
+    Returns the displayed time.
+    Returns the time in seconds since the UNIX epoch (January 1, 1970).
+    \see value(ulong)
+   */
+  ulong value() const {return value_;}
+
+  /**
+    Returns the displayed hour (0 to 23).
+    \see value(), minute(), second()
+   */
+  int hour() const {return hour_;}
+
+  /**
+    Returns the displayed minute (0 to 59).
+    \see value(), hour(), second()
+   */
+  int minute() const {return minute_;}
+
+  /**
+    Returns the displayed second (0 to 60, 60=leap second).
+    \see value(), hour(), minute()
+   */
+  int second() const {return second_;}
+};
+
+// a Fl_Clock displays the current time always by using a timeout:
+
+/**
+  \class Fl_Clock
+  \brief This widget provides a round analog clock display.
+
+  Fl_Clock is provided for Forms compatibility. 
+  It installs a 1-second timeout callback using Fl::add_timeout().
+  You can choose the rounded or square type of the clock with type(), see below.
+  \htmlonly <BR>  <table align=CENTER border=1 cellpadding=5 >  
+  <caption align=bottom>type() FL_SQUARE_CLOCK and FL_ROUND_CLOCK </caption> <TR><TD> \endhtmlonly
+  \image html clock.png  
+  \htmlonly </TD> <TD> \endhtmlonly
+  \image html round_clock.png 
+  \htmlonly </TD> </TR> </table> \endhtmlonly
+  \image latex clock.png "FL_SQUARE_CLOCK type" width=4cm  
+  \image latex round_clock.png "FL_ROUND_CLOCK type" width=4cm
+ */
+class FL_EXPORT Fl_Clock : public Fl_Clock_Output {
+public:
+  int handle(int);
+
+  Fl_Clock(int X, int Y, int W, int H,  const char *L = 0);
+  
+  Fl_Clock(uchar t, int X, int Y, int W, int H, const char *L);
+  
+  ~Fl_Clock();
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Color_Chooser.H

@@ -0,0 +1,190 @@
+//
+// "$Id$"
+//
+// Color chooser header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/** \file
+   Fl_Color_Chooser widget . */
+
+// The color chooser object and the color chooser popup.  The popup
+// is just a window containing a single color chooser and some boxes
+// to indicate the current and cancelled color.
+
+#ifndef Fl_Color_Chooser_H
+#define Fl_Color_Chooser_H
+
+#include <FL/Fl_Group.H>
+#include <FL/Fl_Box.H>
+#include <FL/Fl_Return_Button.H>
+#include <FL/Fl_Choice.H>
+#include <FL/Fl_Value_Input.H>
+
+#ifndef FL_DOXYGEN
+
+/** For internal use only */
+class FL_EXPORT Flcc_HueBox : public Fl_Widget {
+  int px, py;
+protected:
+  void draw();
+  int handle_key(int);
+public:
+  int handle(int);
+  Flcc_HueBox(int X, int Y, int W, int H) : Fl_Widget(X,Y,W,H) {
+  px = py = 0;}
+};
+
+/** For internal use only */
+class FL_EXPORT Flcc_ValueBox : public Fl_Widget {
+  int py;
+protected:
+  void draw();
+  int handle_key(int);
+public:
+  int handle(int);
+  Flcc_ValueBox(int X, int Y, int W, int H) : Fl_Widget(X,Y,W,H) {
+  py = 0;}
+};
+
+/** For internal use only */
+class FL_EXPORT Flcc_Value_Input : public Fl_Value_Input {
+public:
+  int format(char*);
+  Flcc_Value_Input(int X, int Y, int W, int H) : Fl_Value_Input(X,Y,W,H) {}
+};
+
+#endif // !FL_DOXYGEN
+
+/** \addtogroup group_comdlg 
+    @{ */
+
+/**
+  \class Fl_Color_Chooser
+  \brief The Fl_Color_Chooser widget provides a standard RGB color chooser.
+
+  \image html fl_color_chooser.jpg
+  \image latex fl_color_chooser.jpg "fl_color_chooser()" width=5cm
+
+  You can place any number of the widgets into a panel of your own design.
+  The diagram shows the widget as part of a color chooser dialog created by
+  the fl_color_chooser() function. The Fl_Color_Chooser widget contains the
+  hue box, value slider, and rgb input fields from the above diagram (it
+  does not have the color chips or the Cancel or OK buttons).
+  The callback is done every time the user changes the rgb value. It is not
+  done if they move the hue control in a way that produces the \e same rgb
+  value, such as when saturation or value is zero.
+
+  The fl_color_chooser() function pops up a window to let the user pick an
+  arbitrary RGB color. They can pick the hue and saturation in the "hue box"
+  on the left (hold down CTRL to just change the saturation), and the
+  brightness using the vertical slider. Or they can type the 8-bit numbers
+  into the RGB Fl_Value_Input fields, or drag the mouse across them to adjust
+  them.  The pull-down menu lets the user set the input fields to show RGB,
+  HSV, or 8-bit RGB (0 to 255).
+
+  fl_color_chooser() returns non-zero if the user picks ok, and updates the
+  RGB values.  If the user picks cancel or closes the window this returns
+  zero and leaves RGB unchanged.
+
+  If you use the color chooser on an 8-bit screen, it will allocate all the
+  available colors, leaving you no space to exactly represent the color the
+  user picks! You can however use fl_rectf() to fill a region with a simulated
+  color using dithering.
+ */
+/** @} */
+class FL_EXPORT Fl_Color_Chooser : public Fl_Group {
+  Flcc_HueBox huebox;
+  Flcc_ValueBox valuebox;
+  Fl_Choice choice;
+  Flcc_Value_Input rvalue;
+  Flcc_Value_Input gvalue;
+  Flcc_Value_Input bvalue;
+  Fl_Box resize_box;
+  double hue_, saturation_, value_;
+  double r_, g_, b_;
+  void set_valuators();
+  static void rgb_cb(Fl_Widget*, void*);
+  static void mode_cb(Fl_Widget*, void*);
+public:
+  
+  /** 
+   Returns which Fl_Color_Chooser variant is currently active 
+   \return color modes are rgb(0), byte(1), hex(2), or hsv(3)   
+   */
+  int mode() {return choice.value();}
+  
+  /** 
+   Set which Fl_Color_Chooser variant is currently active 
+   \param[in] newMode color modes are rgb(0), byte(1), hex(2), or hsv(3)   
+   */
+  void mode(int newMode);
+  
+  /**
+    Returns the current hue.
+    0 <= hue < 6. Zero is red, one is yellow, two is green, etc.
+    <em>This value is convenient for the internal calculations - some other
+    systems consider hue to run from zero to one, or from 0 to 360.</em>
+   */
+  double hue() const {return hue_;}
+
+  /**
+    Returns the saturation.
+    0 <= saturation <= 1.
+   */
+  double saturation() const {return saturation_;}
+
+  /**
+    Returns the value/brightness.
+    0 <= value <= 1.
+   */
+  double value() const {return value_;}
+
+  /**
+    Returns the current red value.
+    0 <= r <= 1.
+   */
+  double r() const {return r_;}
+
+  /**
+    Returns the current green value.
+    0 <= g <= 1.
+   */
+  double g() const {return g_;}
+
+  /**
+    Returns the current blue value.
+    0 <= b <= 1.
+   */
+  double b() const {return b_;}
+
+  int hsv(double H, double S, double V);
+
+  int rgb(double R, double G, double B);
+
+  static void hsv2rgb(double H, double S, double V, double& R, double& G, double& B);
+
+  static void rgb2hsv(double R, double G, double B, double& H, double& S, double& V);
+
+  Fl_Color_Chooser(int X, int Y, int W, int H, const char *L = 0);
+};
+
+FL_EXPORT int fl_color_chooser(const char* name, double& r, double& g, double& b, int m=-1);
+FL_EXPORT int fl_color_chooser(const char* name, uchar& r, uchar& g, uchar& b, int m=-1);
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Copy_Surface.H

@@ -0,0 +1,137 @@
+//
+// "$Id$"
+//
+// Copy-to-clipboard code for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2014 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+#ifndef Fl_Copy_Surface_H
+#define Fl_Copy_Surface_H
+
+#include <FL/Fl_Paged_Device.H>
+#include <FL/Fl_Printer.H>
+#include <FL/x.H>
+
+/** Supports copying of graphical data to the clipboard.
+ 
+ <br> After creation of an Fl_Copy_Surface object, call set_current() on it, and all subsequent graphics requests
+ will be recorded in the clipboard. It's possible to draw widgets (using Fl_Copy_Surface::draw()
+ ) or to use any of the \ref fl_drawings or the \ref fl_attributes.
+ Finally, delete the Fl_Copy_Surface object to load the clipboard with the graphical data.
+ <br> Fl_GL_Window 's can be copied to the clipboard as well. 
+ <br> Usage example:
+ \code
+ Fl_Widget *g = ...; // a widget you want to copy to the clipboard
+ Fl_Copy_Surface *copy_surf = new Fl_Copy_Surface(g->w(), g->h()); // create an Fl_Copy_Surface object
+ copy_surf->set_current(); // direct graphics requests to the clipboard
+ fl_color(FL_WHITE); fl_rectf(0, 0, g->w(), g->h()); // draw a white background
+ copy_surf->draw(g); // draw the g widget in the clipboard
+ delete copy_surf; // after this, the clipboard is loaded
+ Fl_Display_Device::display_device()->set_current();  // direct graphics requests back to the display
+ \endcode
+ Platform details:
+ \li MSWindows: Transparent RGB images copy without transparency.
+ The graphical data are copied to the clipboard as an 'enhanced metafile'.
+ \li Mac OS: The graphical data are copied to the clipboard (a.k.a. pasteboard) in two 'flavors':
+ 1) in vectorial form as PDF data; 2) in bitmap form as a TIFF image. 
+ Applications to which the clipboard content is pasted can use the flavor that suits them best.
+ \li X11: the graphical data are copied to the clipboard as an image in BMP format.
+*/
+class FL_EXPORT Fl_Copy_Surface : public Fl_Surface_Device {
+private:
+  int width;
+  int height;
+  Fl_Paged_Device *helper;
+#ifdef __APPLE__
+  CFMutableDataRef pdfdata;
+  CGContextRef oldgc;
+  CGContextRef gc;
+  void prepare_copy_pdf_and_tiff(int w, int h);
+  void complete_copy_pdf_and_tiff();
+  void init_PDF_context(int w, int h);
+  static size_t MyPutBytes(void* info, const void* buffer, size_t count);
+#elif defined(WIN32)
+  HDC oldgc;
+  HDC gc;
+#else // Xlib
+  Fl_Offscreen xid;
+  Window oldwindow;
+  Fl_Surface_Device *_ss;
+#endif
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  Fl_Copy_Surface(int w, int h);
+  ~Fl_Copy_Surface();
+  void set_current();
+  void draw(Fl_Widget* widget, int delta_x = 0, int delta_y = 0);
+  void draw_decorated_window(Fl_Window* win, int delta_x = 0, int delta_y = 0);
+  /** Returns the pixel width of the copy surface */
+  int w() { return width; }
+  /** Returns the pixel height of the copy surface */
+  int h() { return height; }
+};
+
+#if defined(__APPLE__)
+
+/* Mac class to reimplement Fl_Paged_Device::printable_rect() */
+class FL_EXPORT Fl_Quartz_Surface_ : public Fl_System_Printer {
+protected:
+  int width;
+  int height;
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  Fl_Quartz_Surface_(int w, int h);
+  virtual int printable_rect(int *w, int *h);
+  virtual ~Fl_Quartz_Surface_() {};
+};
+
+#elif defined(WIN32)
+
+/* Win class to implement translate()/untranslate() */
+class FL_EXPORT Fl_GDI_Surface_ : public Fl_Paged_Device {
+  int width;
+  int height;
+  unsigned depth;
+  POINT origins[10];
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  Fl_GDI_Surface_();
+  virtual void translate(int x, int y);
+  virtual void untranslate();
+  virtual ~Fl_GDI_Surface_();
+};
+
+#elif !defined(FL_DOXYGEN)
+
+/* Xlib class to implement translate()/untranslate() */
+class FL_EXPORT Fl_Xlib_Surface_ : public Fl_Paged_Device {
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  Fl_Xlib_Surface_();
+  virtual void translate(int x, int y);
+  virtual void untranslate();
+  virtual ~Fl_Xlib_Surface_();
+};
+
+#endif
+
+#endif // Fl_Copy_Surface_H
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Counter.H

@@ -0,0 +1,115 @@
+//
+// "$Id$"
+//
+// Counter header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Counter widget . */
+
+// A numerical value with up/down step buttons.  From Forms.
+
+#ifndef Fl_Counter_H
+#define Fl_Counter_H
+
+#ifndef Fl_Valuator_H
+#include "Fl_Valuator.H"
+#endif
+
+// values for type():
+#define FL_NORMAL_COUNTER	0	/**< type() for counter with fast buttons */
+#define FL_SIMPLE_COUNTER	1	/**< type() for counter without fast buttons */
+
+/**
+  Controls a single floating point value with button (or keyboard) arrows.
+  Double arrows buttons achieve larger steps than simple arrows.
+  \see Fl_Spinner for value input with vertical step arrows.
+  <P align=center>\image html counter.png</P>
+  \image latex counter.png "Fl_Counter" width=4cm
+
+  \todo Refactor the doxygen comments for Fl_Counter type() documentation.
+
+  The type of an Fl_Counter object can be set using type(uchar t) to:
+  \li \c FL_NORMAL_COUNTER: Displays a counter with 4 arrow buttons.
+  \li \c FL_SIMPLE_COUNTER: Displays a counter with only 2 arrow buttons.
+*/
+class FL_EXPORT Fl_Counter : public Fl_Valuator {
+
+  Fl_Font textfont_;
+  Fl_Fontsize textsize_;
+  Fl_Color textcolor_;
+  double lstep_;
+  uchar mouseobj;
+  static void repeat_callback(void *);
+  int calc_mouseobj();
+  void increment_cb();
+
+protected:
+
+  void draw();
+
+public:
+
+  int handle(int);
+
+  Fl_Counter(int X, int Y, int W, int H, const char* L = 0);
+  ~Fl_Counter();
+
+  /**
+    Sets the increment for the large step buttons.
+    The default value is 1.0.
+    \param[in] a large step increment.
+  */
+  void lstep(double a) {lstep_ = a;}
+
+  /**
+    Sets the increments for the normal and large step buttons.
+    \param[in] a, b normal and large step increments.
+  */
+  void step(double a,double b) {Fl_Valuator::step(a); lstep_ = b;}
+
+  /**
+    Sets the increment for the normal step buttons.
+    \param[in] a normal step increment.
+  */
+  void step(double a) {Fl_Valuator::step(a);}
+
+  /**
+    Returns the increment for normal step buttons.
+   */
+  double step() const {return Fl_Valuator::step();}
+
+  /** Gets the text font */
+  Fl_Font textfont() const {return textfont_;}
+  /** Sets the text font to \p s */
+  void textfont(Fl_Font s) {textfont_ = s;}
+
+  /** Gets the font size */
+  Fl_Fontsize textsize() const {return textsize_;}
+  /** Sets the font size to \p s */
+  void textsize(Fl_Fontsize s) {textsize_ = s;}
+
+  /** Gets the font color */
+  Fl_Color textcolor() const {return textcolor_;}
+  /** Sets the font color to \p s */
+  void textcolor(Fl_Color s) {textcolor_ = s;}
+
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Device.H

@@ -0,0 +1,636 @@
+//
+// "$Id$"
+//
+// Definition of classes Fl_Device, Fl_Graphics_Driver, Fl_Surface_Device, Fl_Display_Device
+// for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 2010-2014 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/** \file Fl_Device.H 
+ \brief declaration of classes Fl_Device, Fl_Graphics_Driver, Fl_Surface_Device, 
+ Fl_Display_Device, Fl_Device_Plugin.
+*/
+
+#ifndef Fl_Device_H
+#define Fl_Device_H
+
+#include <FL/x.H>
+#include <FL/Fl_Plugin.H>
+#include <FL/Fl_Image.H>
+#include <FL/Fl_Bitmap.H>
+#include <FL/Fl_Pixmap.H>
+#include <FL/Fl_RGB_Image.H>
+#include <stdlib.h>
+
+class Fl_Graphics_Driver;
+class Fl_Font_Descriptor;
+/** \brief Points to the driver that currently receives all graphics requests */
+FL_EXPORT extern Fl_Graphics_Driver *fl_graphics_driver;
+
+/**
+ signature of image generation callback function.
+ \param[in]  data  user data passed to function
+ \param[in]  x,y,w position and width of scan line in image
+ \param[out] buf   buffer for generated image data. You must copy \p w
+ pixels from scanline \p y, starting at pixel \p x
+ to this buffer.
+ */
+typedef void (*Fl_Draw_Image_Cb)(void* data,int x,int y,int w,uchar* buf);
+
+// typedef what the x,y fields in a point are:
+#ifdef WIN32
+typedef int COORD_T;
+#  define XPOINT XPoint
+#elif defined(__APPLE__)
+typedef float COORD_T;
+typedef struct { float x; float y; } QPoint;
+#  define XPOINT QPoint
+extern float fl_quartz_line_width_;
+#else
+typedef short COORD_T;
+#  define XPOINT XPoint
+#endif
+
+/**
+ All graphical output devices and all graphics systems.
+ This class supports a rudimentary system of run-time type information.
+ */
+class FL_EXPORT Fl_Device {
+public:
+  /** A string that identifies each subclass of Fl_Device.
+     Function class_name() applied to a device of this class returns this string.
+   */
+  static const char *class_id;
+  /** 
+   Returns the name of the class of this object. 
+   Use of the class_name() function is discouraged because it will be removed from future FLTK versions.
+   
+   The class of an instance of an Fl_Device subclass can be checked with code such as:
+   \code
+   if ( instance->class_name() == Fl_Printer::class_id ) { ... }
+   \endcode
+   */
+  virtual const char *class_name() {return class_id;};
+  /** 
+   Virtual destructor.
+   
+   The destructor of Fl_Device must be virtual to make the destructors of
+   derived classes being called correctly on destruction.
+   */
+  virtual ~Fl_Device() {};
+};
+
+#define FL_REGION_STACK_SIZE 10
+#define FL_MATRIX_STACK_SIZE 32
+/**
+ \brief A virtual class subclassed for each graphics driver FLTK uses.
+ Typically, FLTK applications do not use directly objects from this class. Rather, they perform
+ drawing operations (e.g., fl_rectf()) that operate on the current drawing surface (see Fl_Surface_Device).
+ Drawing operations are functionally presented in \ref drawing and as function lists
+ in the \ref fl_drawings and \ref fl_attributes modules. The \ref fl_graphics_driver global variable
+ gives at any time the graphics driver used by all drawing operations. Its value changes when
+ drawing operations are directed to another drawing surface by Fl_Surface_Device::set_current().
+ 
+ \p The Fl_Graphics_Driver class is of interest if one wants to perform new kinds of drawing operations.
+ An example would be to draw to a PDF file. This would involve creating a new Fl_Graphics_Driver derived 
+ class. This new class should implement all virtual methods of the Fl_Graphics_Driver class
+ to support all FLTK drawing functions.
+  */
+class FL_EXPORT Fl_Graphics_Driver : public Fl_Device {
+public:
+  /** A 2D coordinate transformation matrix
+   */
+  struct matrix {double a, b, c, d, x, y;};
+private:
+  static const matrix m0;
+  Fl_Font font_; // current font
+  Fl_Fontsize size_; // current font size
+  Fl_Color color_; // current color
+  int sptr;
+  static const int matrix_stack_size = FL_MATRIX_STACK_SIZE;
+  matrix stack[FL_MATRIX_STACK_SIZE];
+  matrix m;
+  int n, p_size, gap_;
+  XPOINT *p;
+  int what;
+  int fl_clip_state_number;
+  int rstackptr;
+  static const int region_stack_max = FL_REGION_STACK_SIZE - 1;
+  Fl_Region rstack[FL_REGION_STACK_SIZE];
+#ifdef WIN32
+  int numcount;
+  int counts[20];
+#endif
+  Fl_Font_Descriptor *font_descriptor_;
+  void transformed_vertex0(COORD_T x, COORD_T y);
+  void fixloop();
+  
+protected:
+#ifndef FL_DOXYGEN
+  enum {LINE, LOOP, POLYGON, POINT_};
+  inline int vertex_no() { return n; }
+  inline XPOINT *vertices() {return p;}
+  inline int vertex_kind() {return what;}
+#endif
+/*  ** \brief red color for background and/or mixing if device does not support masking or alpha *
+  uchar bg_r_; 
+  ** \brief green color for background and/or mixing if device does not support masking or alpha *
+  uchar bg_g_; 
+  ** \brief blue color for background and/or mixing if device does not support masking or alpha *
+  uchar bg_b_; */
+  friend class Fl_Pixmap;
+  friend class Fl_Bitmap;
+  friend class Fl_RGB_Image;
+  friend void fl_rect(int x, int y, int w, int h);
+  friend void fl_rectf(int x, int y, int w, int h);
+  friend void fl_line_style(int style, int width, char* dashes);
+  friend void fl_xyline(int x, int y, int x1);
+  friend void fl_xyline(int x, int y, int x1, int y2);
+  friend void fl_xyline(int x, int y, int x1, int y2, int x3);
+  friend void fl_yxline(int x, int y, int y1);
+  friend void fl_yxline(int x, int y, int y1, int x2);
+  friend void fl_yxline(int x, int y, int y1, int x2, int y3);
+  friend void fl_line(int x, int y, int x1, int y1);
+  friend void fl_line(int x, int y, int x1, int y1, int x2, int y2);
+  friend void fl_draw(const char *str, int n, int x, int y);
+#ifdef __APPLE__
+  friend void fl_draw(const char *str, int n, float x, float y);
+#endif
+  friend void fl_draw(int angle, const char *str, int n, int x, int y);
+  friend void fl_rtl_draw(const char *str, int n, int x, int y);
+  friend void fl_font(Fl_Font face, Fl_Fontsize size);
+  friend void fl_color(Fl_Color c);
+  friend void fl_color(uchar r, uchar g, uchar b);
+  friend void fl_point(int x, int y);
+  friend void fl_loop(int x0, int y0, int x1, int y1, int x2, int y2);
+  friend void fl_loop(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3);
+  friend void fl_polygon(int x0, int y0, int x1, int y1, int x2, int y2);
+  friend void fl_polygon(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3);
+  friend void fl_begin_points();
+  friend void fl_begin_line();
+  friend void fl_begin_loop();
+  friend void fl_begin_polygon();
+  friend void fl_vertex(double x, double y);
+  friend void fl_curve(double X0, double Y0, double X1, double Y1, double X2, double Y2, double X3, double Y3);
+  friend void fl_circle(double x, double y, double r);
+  friend void fl_arc(double x, double y, double r, double start, double end);
+  friend void fl_arc(int x, int y, int w, int h, double a1, double a2);
+  friend void fl_pie(int x, int y, int w, int h, double a1, double a2);
+  friend void fl_end_points();
+  friend void fl_end_line();
+  friend void fl_end_loop();
+  friend void fl_end_polygon();
+  friend void fl_transformed_vertex(double xf, double yf);
+  friend void fl_push_clip(int x, int y, int w, int h);
+  friend int fl_clip_box(int x, int y, int w, int h, int &X, int &Y, int &W, int &H);
+  friend int fl_not_clipped(int x, int y, int w, int h);
+  friend void fl_push_no_clip();
+  friend void fl_pop_clip();
+  friend void fl_begin_complex_polygon();
+  friend void fl_gap();
+  friend void fl_end_complex_polygon();
+  friend void fl_push_matrix();
+  friend void fl_pop_matrix();
+  friend void fl_mult_matrix(double a, double b, double c, double d, double x, double y);
+  friend void fl_scale(double x, double y);
+  friend void fl_scale(double x);
+  friend void fl_translate(double x, double y);
+  friend void fl_rotate(double d);
+  friend double fl_transform_x(double x, double y);
+  friend double fl_transform_y(double x, double y);
+  friend double fl_transform_dx(double x, double y);
+  friend double fl_transform_dy(double x, double y);
+  friend Fl_Region fl_clip_region();
+  friend void fl_clip_region(Fl_Region r);
+  friend void fl_restore_clip();
+  
+  friend void fl_draw_image(const uchar* buf, int X,int Y,int W,int H, int D, int L);
+  friend void fl_draw_image_mono(const uchar* buf, int X,int Y,int W,int H, int D, int L);
+  friend void fl_draw_image(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D);
+  friend FL_EXPORT void fl_draw_image_mono(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D);
+  friend FL_EXPORT void gl_start();
+  friend FL_EXPORT void fl_copy_offscreen(int x, int y, int w, int h, Fl_Offscreen pixmap, int srcx, int srcy);
+  matrix *fl_matrix; /**< Points to the current coordinate transformation matrix */
+
+  /** \brief The constructor. */
+  Fl_Graphics_Driver();
+  /** \brief see fl_rect(int x, int y, int w, int h). */
+  virtual void rect(int x, int y, int w, int h);
+  /** \brief see fl_rectf(int x, int y, int w, int h). */
+  virtual void rectf(int x, int y, int w, int h);
+  /** \brief see fl_line_style(int style, int width, char* dashes). */
+  virtual void line_style(int style, int width=0, char* dashes=0);
+  /** \brief see fl_xyline(int x, int y, int x1). */
+  virtual void xyline(int x, int y, int x1);
+  /** \brief see fl_xyline(int x, int y, int x1, int y2). */
+  virtual void xyline(int x, int y, int x1, int y2);
+  /** \brief see fl_xyline(int x, int y, int x1, int y2, int x3). */
+  virtual void xyline(int x, int y, int x1, int y2, int x3);
+  /** \brief see fl_yxline(int x, int y, int y1). */
+  virtual void yxline(int x, int y, int y1);
+  /** \brief see fl_yxline(int x, int y, int y1, int x2). */
+  virtual void yxline(int x, int y, int y1, int x2);
+  /** \brief see fl_yxline(int x, int y, int y1, int x2, int y3). */
+  virtual void yxline(int x, int y, int y1, int x2, int y3);
+  /** \brief see fl_line(int x, int y, int x1, int y1). */
+  virtual void line(int x, int y, int x1, int y1);
+  /** \brief see fl_line(int x, int y, int x1, int y1, int x2, int y2). */
+  virtual void line(int x, int y, int x1, int y1, int x2, int y2);
+  /** \brief see fl_draw(const char *str, int n, int x, int y). */
+  virtual void draw(const char *str, int n, int x, int y) {}
+#ifdef __APPLE__
+  virtual void draw(const char *str, int n, float x, float y) { draw(str, n, (int)(x+0.5), (int)(y+0.5));}
+#endif
+  /** \brief see fl_draw(int angle, const char *str, int n, int x, int y). */
+  virtual void draw(int angle, const char *str, int n, int x, int y) {}
+  /** \brief see fl_rtl_draw(const char *str, int n, int x, int y). */
+  virtual void rtl_draw(const char *str, int n, int x, int y) {};
+  /** \brief see fl_color(Fl_Color c). */
+  virtual void color(Fl_Color c) {color_ = c;}
+  /** \brief see fl_color(uchar r, uchar g, uchar b). */
+  virtual void color(uchar r, uchar g, uchar b) {}
+  /** \brief see fl_point(int x, int y). */
+  virtual void point(int x, int y);
+  /** \brief see fl_loop(int x0, int y0, int x1, int y1, int x2, int y2). */
+  virtual void loop(int x0, int y0, int x1, int y1, int x2, int y2);
+  /** \brief see fl_loop(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3). */
+  virtual void loop(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3);
+  /** \brief see fl_polygon(int x0, int y0, int x1, int y1, int x2, int y2). */
+  virtual void polygon(int x0, int y0, int x1, int y1, int x2, int y2);
+  /** \brief see fl_polygon(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3). */
+  virtual void polygon(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3);
+  /** \brief see fl_begin_points(). */
+  virtual void begin_points();
+  /** \brief see fl_begin_line(). */
+  virtual void begin_line();
+  /** \brief see fl_begin_loop(). */
+  virtual void begin_loop();
+  /** \brief see fl_begin_polygon(). */
+  virtual void begin_polygon();
+  /** \brief see fl_vertex(double x, double y). */
+  virtual void vertex(double x, double y);
+  /** \brief see fl_curve(double X0, double Y0, double X1, double Y1, double X2, double Y2, double X3, double Y3). */
+  virtual void curve(double X0, double Y0, double X1, double Y1, double X2, double Y2, double X3, double Y3);
+  /** \brief see fl_circle(double x, double y, double r). */
+  virtual void circle(double x, double y, double r);
+  /** \brief see fl_arc(double x, double y, double r, double start, double end). */
+  virtual void arc(double x, double y, double r, double start, double end);
+  /** \brief see fl_arc(int x, int y, int w, int h, double a1, double a2). */
+  virtual void arc(int x, int y, int w, int h, double a1, double a2);
+  /** \brief see fl_pie(int x, int y, int w, int h, double a1, double a2). */
+  virtual void pie(int x, int y, int w, int h, double a1, double a2);
+  /** \brief see fl_end_points(). */
+  virtual void end_points();
+  /** \brief see fl_end_line(). */
+  virtual void end_line();
+  /** \brief see fl_end_loop(). */
+  virtual void end_loop();
+  /** \brief see fl_end_polygon(). */
+  virtual void end_polygon();
+  /** \brief see fl_begin_complex_polygon(). */
+  virtual void begin_complex_polygon();
+  /** \brief see fl_gap(). */
+  virtual void gap();
+  /** \brief see fl_end_complex_polygon(). */
+  virtual void end_complex_polygon();
+  /** \brief see fl_transformed_vertex(double xf, double yf). */
+  virtual void transformed_vertex(double xf, double yf);
+  /** \brief see fl_push_clip(int x, int y, int w, int h). */
+  virtual void push_clip(int x, int y, int w, int h);
+  /** \brief see fl_clip_box(int x, int y, int w, int h, int &X, int &Y, int &W, int &H). */
+  virtual int clip_box(int x, int y, int w, int h, int &X, int &Y, int &W, int &H);
+  /** \brief see fl_not_clipped(int x, int y, int w, int h). */
+  virtual int not_clipped(int x, int y, int w, int h);
+  /** \brief see fl_push_no_clip(). */
+  virtual void push_no_clip();
+  /** \brief see fl_pop_clip(). */
+  virtual void pop_clip();
+    
+  /** \brief see fl_push_matrix(). */
+  void push_matrix();
+  /** \brief see fl_pop_matrix(). */
+  void pop_matrix();
+  /** \brief see fl_mult_matrix(double a, double b, double c, double d, double x, double y). */
+  void mult_matrix(double a, double b, double c, double d, double x, double y);
+  /** \brief see fl_scale(double x, double y). */
+  inline void scale(double x, double y) { mult_matrix(x,0,0,y,0,0); }
+  /** \brief see fl_scale(double x). */
+  inline void scale(double x) { mult_matrix(x,0,0,x,0,0); }
+  /** \brief see fl_translate(double x, double y). */
+  inline void translate(double x,double y) { mult_matrix(1,0,0,1,x,y); }
+  /** \brief see fl_rotate(double d). */
+  void rotate(double d);
+  /** \brief see fl_transform_x(double x, double y). */
+  double transform_x(double x, double y);
+  /** \brief see fl_transform_y(double x, double y). */
+  double transform_y(double x, double y);
+  /** \brief see fl_transform_dx(double x, double y). */
+  double transform_dx(double x, double y);
+  /** \brief see fl_transform_dy(double x, double y). */
+  double transform_dy(double x, double y);
+  /** \brief see fl_clip_region(). */
+  Fl_Region clip_region();
+  /** \brief see fl_clip_region(Fl_Region r). */
+  void clip_region(Fl_Region r);
+  /** \brief see fl_restore_clip(). */
+  void restore_clip();
+  
+  // Images
+  /** \brief see fl_draw_image(const uchar* buf, int X,int Y,int W,int H, int D, int L). */
+  virtual   void draw_image(const uchar* buf, int X,int Y,int W,int H, int D=3, int L=0) {}
+  /** \brief see fl_draw_image_mono(const uchar* buf, int X,int Y,int W,int H, int D, int L). */
+  virtual   void draw_image_mono(const uchar* buf, int X,int Y,int W,int H, int D=1, int L=0) {}
+  /** \brief see fl_draw_image(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D). */
+  virtual   void draw_image(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=3) {}
+  /** \brief see fl_draw_image_mono(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D). */
+  virtual   void draw_image_mono(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=1) {}
+  // Image classes
+  /** \brief Draws an Fl_RGB_Image object to the device. 
+   *
+   Specifies a bounding box for the image, with the origin (upper left-hand corner) of 
+   the image offset by the cx and cy arguments.
+   */
+  virtual   void draw(Fl_RGB_Image * rgb,int XP, int YP, int WP, int HP, int cx, int cy) {}
+  /** \brief Draws an Fl_Pixmap object to the device. 
+   *
+   Specifies a bounding box for the image, with the origin (upper left-hand corner) of 
+   the image offset by the cx and cy arguments.
+   */
+  virtual   void draw(Fl_Pixmap * pxm,int XP, int YP, int WP, int HP, int cx, int cy) {}
+  /** \brief Draws an Fl_Bitmap object to the device. 
+   *
+   Specifies a bounding box for the image, with the origin (upper left-hand corner) of 
+   the image offset by the cx and cy arguments.
+   */
+  virtual void draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy) {}
+#if FLTK_ABI_VERSION >= 10301
+  virtual
+#endif
+  void copy_offscreen(int x, int y, int w, int h, Fl_Offscreen pixmap, int srcx, int srcy);
+  
+public:
+  static const char *class_id;
+  virtual const char *class_name() {return class_id;};
+  /** \brief see fl_font(Fl_Font face, Fl_Fontsize size). */
+  virtual void font(Fl_Font face, Fl_Fontsize fsize) {font_ = face; size_ = fsize;}
+  /** \brief see fl_font(void). */
+  Fl_Font font() {return font_; }
+  /** \brief see fl_size(). */
+  Fl_Fontsize size() {return size_; }
+  /** \brief see fl_width(const char *str, int n). */
+  virtual double width(const char *str, int n) {return 0;}
+  /** \brief see fl_width(unsigned int n). */
+  virtual inline double width(unsigned int c) { char ch = (char)c; return width(&ch, 1); }
+  /** \brief see fl_text_extents(const char*, int n, int& dx, int& dy, int& w, int& h). */
+  virtual void text_extents(const char*, int n, int& dx, int& dy, int& w, int& h);
+  /** \brief see fl_height(). */
+  virtual int height() {return size();}
+  /** \brief see fl_descent(). */
+  virtual int descent() {return 0;}
+  /** \brief see fl_color(void). */
+  Fl_Color color() {return color_;}
+  /** Returns a pointer to the current Fl_Font_Descriptor for the graphics driver */
+  inline Fl_Font_Descriptor *font_descriptor() { return font_descriptor_;}
+  /** Sets the current Fl_Font_Descriptor for the graphics driver */
+  inline void font_descriptor(Fl_Font_Descriptor *d) { font_descriptor_ = d;}
+#if FLTK_ABI_VERSION >= 10304 || defined(FL_DOXYGEN)
+  virtual
+#endif
+  int draw_scaled(Fl_Image *img, int X, int Y, int W, int H);
+  /** \brief The destructor */
+  virtual ~Fl_Graphics_Driver() { if (p) free(p); }
+};
+
+#if defined(__APPLE__) || defined(FL_DOXYGEN)
+/**
+ \brief The Mac OS X-specific graphics class.
+ *
+ This class is implemented only on the Mac OS X platform.
+ */
+class FL_EXPORT Fl_Quartz_Graphics_Driver : public Fl_Graphics_Driver {
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  void color(Fl_Color c);
+  void color(uchar r, uchar g, uchar b);
+  void draw(const char* str, int n, int x, int y);
+#ifdef __APPLE__
+  void draw(const char *str, int n, float x, float y);
+#endif
+  void draw(int angle, const char *str, int n, int x, int y);
+  void rtl_draw(const char* str, int n, int x, int y);
+  void font(Fl_Font face, Fl_Fontsize size);
+  void draw(Fl_Pixmap *pxm, int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw(Fl_Bitmap *pxm, int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw(Fl_RGB_Image *img, int XP, int YP, int WP, int HP, int cx, int cy);
+  int draw_scaled(Fl_Image *img, int XP, int YP, int WP, int HP);
+  void draw_image(const uchar* buf, int X,int Y,int W,int H, int D=3, int L=0);
+  void draw_image(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=3);
+  void draw_image_mono(const uchar* buf, int X,int Y,int W,int H, int D=1, int L=0);
+  void draw_image_mono(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=1);
+  double width(const char *str, int n);
+  double width(unsigned int c);
+  void text_extents(const char*, int n, int& dx, int& dy, int& w, int& h);
+  int height();
+  int descent();
+#if ! defined(FL_DOXYGEN)
+  static Fl_Offscreen create_offscreen_with_alpha(int w, int h);
+#endif
+  void copy_offscreen(int x, int y, int w, int h, Fl_Offscreen pixmap, int srcx, int srcy);
+};
+#endif
+#if defined(WIN32) || defined(FL_DOXYGEN)
+/**
+ \brief The MSWindows-specific graphics class.
+ *
+ This class is implemented only on the MSWindows platform.
+ */
+class FL_EXPORT Fl_GDI_Graphics_Driver : public Fl_Graphics_Driver {
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  void color(Fl_Color c);
+  void color(uchar r, uchar g, uchar b);
+  void draw(const char* str, int n, int x, int y);
+  void draw(int angle, const char *str, int n, int x, int y);
+  void rtl_draw(const char* str, int n, int x, int y);
+  void font(Fl_Font face, Fl_Fontsize size);
+  void draw(Fl_Pixmap *pxm, int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw(Fl_Bitmap *pxm, int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw(Fl_RGB_Image *img, int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw_image(const uchar* buf, int X,int Y,int W,int H, int D=3, int L=0);
+  void draw_image(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=3);
+  void draw_image_mono(const uchar* buf, int X,int Y,int W,int H, int D=1, int L=0);
+  void draw_image_mono(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=1);
+  double width(const char *str, int n);
+  double width(unsigned int c);
+  void text_extents(const char*, int n, int& dx, int& dy, int& w, int& h);
+  int height();
+  int descent();
+#if ! defined(FL_DOXYGEN)
+  void copy_offscreen_with_alpha(int x,int y,int w,int h,HBITMAP bitmap,int srcx,int srcy);
+#endif
+  void copy_offscreen(int x, int y, int w, int h, Fl_Offscreen pixmap, int srcx, int srcy);
+};
+
+/**
+ The graphics driver used when printing on MSWindows.
+ *
+ This class is implemented only on the MSWindows platform. It 's extremely similar to Fl_GDI_Graphics_Driver.
+ */
+class FL_EXPORT Fl_GDI_Printer_Graphics_Driver : public Fl_GDI_Graphics_Driver {
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  void draw(Fl_Pixmap *pxm, int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy);
+  int draw_scaled(Fl_Image *img, int XP, int YP, int WP, int HP);
+};
+#endif
+#if !(defined(__APPLE__) || defined(WIN32))
+/**
+ \brief The Xlib-specific graphics class.
+ *
+ This class is implemented only on the Xlib platform.
+ */
+class FL_EXPORT Fl_Xlib_Graphics_Driver : public Fl_Graphics_Driver {
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  void color(Fl_Color c);
+  void color(uchar r, uchar g, uchar b);
+  void draw(const char* str, int n, int x, int y);
+  void draw(int angle, const char *str, int n, int x, int y);
+  void rtl_draw(const char* str, int n, int x, int y);
+  void font(Fl_Font face, Fl_Fontsize size);
+  void draw(Fl_Pixmap *pxm, int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw(Fl_Bitmap *pxm, int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw(Fl_RGB_Image *img, int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw_image(const uchar* buf, int X,int Y,int W,int H, int D=3, int L=0);
+  void draw_image(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=3);
+  void draw_image_mono(const uchar* buf, int X,int Y,int W,int H, int D=1, int L=0);
+  void draw_image_mono(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=1);
+  double width(const char *str, int n);
+  double width(unsigned int c);
+  void text_extents(const char*, int n, int& dx, int& dy, int& w, int& h);
+  int height();
+  int descent();
+  void copy_offscreen(int x, int y, int w, int h, Fl_Offscreen pixmap, int srcx, int srcy);
+#if ! defined(FL_DOXYGEN)
+  void copy_offscreen_with_alpha(int x, int y, int w, int h, Fl_Offscreen pixmap, int srcx, int srcy);
+#endif
+};
+#endif
+
+/**
+ A drawing surface that's susceptible to receive graphical output.
+ Any FLTK application has at any time a current drawing surface to which all drawing requests are directed.
+ The current surface is given by Fl_Surface_Device::surface().
+ When main() begins running, the current drawing surface has been set to the computer's display, 
+ an instance of the Fl_Display_Device class.
+
+ A drawing surface other than the computer's display, is typically used as follows:
+ <ol><li> Create \c surface, an object from a particular Fl_Surface_Device derived class (e.g., Fl_Copy_Surface, Fl_Printer).
+ <li> Memorize what is the current drawing surface with <tt> Fl_Surface_Device *old_current = Fl_Surface_Device::surface();</tt>
+ <li> Call \c surface->set_current(); to redirect all graphics requests to \c surface which becomes the new
+ current drawing surface (not necessary with class Fl_Printer because it is done by Fl_Printer::start_job()).
+ <li> At this point any of the \ref fl_drawings (e.g., fl_rect()) or the \ref fl_attributes or \ref drawing_images functions
+ (e.g., fl_draw_image(), Fl_Image::draw()) operates on the new current drawing surface.
+ Certain drawing surfaces allow additional ways to draw to them (e.g., Fl_Printer::print_widget(), Fl_Image_Surface::draw()).
+ <li> After all drawing requests have been performed, redirect graphics requests back to their previous destination
+ with \c old_current->set_current();.
+ <li> Delete \c surface.
+ </ol>
+ */
+class FL_EXPORT Fl_Surface_Device : public Fl_Device {
+  /** \brief The graphics driver in use by this surface. */
+  Fl_Graphics_Driver *_driver;
+  static Fl_Surface_Device *_surface; // the surface that currently receives graphics output
+  static Fl_Surface_Device *default_surface(); // create surface is none exists yet
+protected:
+  /** \brief Constructor that sets the graphics driver to use for the created surface. */
+  Fl_Surface_Device(Fl_Graphics_Driver *graphics_driver) {_driver = graphics_driver; };
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  virtual void set_current(void);
+  /** \brief Sets the graphics driver of this drawing surface. */
+  inline void driver(Fl_Graphics_Driver *graphics_driver) {_driver = graphics_driver;};
+  /** \brief Returns the graphics driver of this drawing surface. */
+  inline Fl_Graphics_Driver *driver() {return _driver; };
+  /** The current drawing surface.
+   In other words, the Fl_Surface_Device object that currently receives all graphics output */
+  static inline Fl_Surface_Device *surface() {
+    return _surface ? _surface : default_surface();
+  };
+  /** \brief The destructor. */
+  virtual ~Fl_Surface_Device() {}
+};
+
+/**
+ A display to which the computer can draw.
+ When the program begins running, an Fl_Display_Device instance has been created and made the current drawing surface.
+ There is no need to create any other object of this class.
+ */
+class FL_EXPORT Fl_Display_Device : public Fl_Surface_Device {
+  static Fl_Display_Device *_display; // the platform display device
+#ifdef __APPLE__
+  friend class Fl_X;
+  friend class Fl_Graphics_Driver;
+  static bool high_res_window_; //< true when drawing to a window of a retina display (Mac OS X only)
+  static bool high_resolution() {return high_res_window_;}
+#endif
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  Fl_Display_Device(Fl_Graphics_Driver *graphics_driver);
+  static Fl_Display_Device *display_device();
+};
+
+/**
+ This plugin socket allows the integration of new device drivers for special
+ window or screen types. 
+ This class is not intended for use outside the FLTK library.
+ It is currently used to provide an automated printing
+ service and screen capture for OpenGL windows, if linked with fltk_gl.
+ */
+class FL_EXPORT Fl_Device_Plugin : public Fl_Plugin {
+public:
+  /** \brief The constructor */
+  Fl_Device_Plugin(const char *pluginName)
+  : Fl_Plugin(klass(), pluginName) { }
+  /** \brief Returns the class name */
+  virtual const char *klass() { return "fltk:device"; }
+  /** \brief Returns the plugin name */
+  virtual const char *name() = 0;
+  /** \brief Prints a widget 
+   \param w the widget
+   \param x,y offsets where to print relatively to coordinates origin
+   \param height height of the current drawing area
+   */
+  virtual int print(Fl_Widget* w, int x, int y, int height) = 0;
+  /** captures a rectangle of a widget as an image
+   \return The captured pixels as an RGB image
+   */
+#ifdef FL_LIBRARY
+    virtual
+#endif
+  Fl_RGB_Image* rectangle_capture(Fl_Widget *widget, int x, int y, int w, int h) {return NULL;}
+};
+
+#endif // Fl_Device_H
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Dial.H

@@ -0,0 +1,88 @@
+//
+// "$Id$"
+//
+// Dial header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Dial widget . */
+
+#ifndef Fl_Dial_H
+#define Fl_Dial_H
+
+#ifndef Fl_Valuator_H
+#include "Fl_Valuator.H"
+#endif
+
+// values for type():
+#define FL_NORMAL_DIAL	0	/**< type() for dial variant with dot */
+#define FL_LINE_DIAL	1	/**< type() for dial variant with line */
+#define FL_FILL_DIAL	2	/**< type() for dial variant with filled arc */
+
+/**
+  The Fl_Dial widget provides a circular dial to control a
+  single floating point value.
+  <P ALIGN=CENTER>\image html dial.png 
+  \image latex dial.png "Fl_Dial" width=4cm
+  Use type() to set the type of the dial to:
+  <UL>
+  <LI>FL_NORMAL_DIAL - Draws a normal dial with a knob. </LI>
+  <LI>FL_LINE_DIAL - Draws a dial with a line. </LI>
+  <LI>FL_FILL_DIAL - Draws a dial with a filled arc. </LI>
+  </UL>
+
+*/
+class FL_EXPORT Fl_Dial : public Fl_Valuator {
+
+  short a1,a2;
+
+protected:
+
+  // these allow subclasses to put the dial in a smaller area:
+  void draw(int X, int Y, int W, int H);
+  int handle(int event, int X, int Y, int W, int H);
+  void draw();
+
+public:
+
+  int handle(int);
+  /**
+    Creates a new Fl_Dial widget using the given position, size,
+    and label string. The default type is FL_NORMAL_DIAL.
+  */
+  Fl_Dial(int x,int y,int w,int h, const char *l = 0);
+  /** 
+     Sets Or gets the angles used for the minimum and maximum values.  The default
+     values are 45 and 315 (0 degrees is straight down and the angles
+     progress clockwise).  Normally angle1 is less than angle2, but if you
+     reverse them the dial moves counter-clockwise.
+  */
+  short angle1() const {return a1;}
+  /** See short angle1() const */
+  void angle1(short a) {a1 = a;}
+  /** See short angle1() const */
+  short angle2() const {return a2;}
+  /** See short angle1() const */
+  void angle2(short a) {a2 = a;}
+  /** See short angle1() const */
+  void angles(short a, short b) {a1 = a; a2 = b;}
+
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Double_Window.H

@@ -0,0 +1,73 @@
+//
+// "$Id$"
+//
+// Double-buffered window header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Double_Window widget . */
+
+#ifndef Fl_Double_Window_H
+#define Fl_Double_Window_H
+
+#include "Fl_Window.H"
+
+/**
+  The Fl_Double_Window provides a double-buffered window.
+  If possible this will use the X double buffering extension (Xdbe).  If
+  not, it will draw the window data into an off-screen pixmap, and then
+  copy it to the on-screen window.
+  <P>It is highly recommended that you put the following code before the
+  first show() of <I>any</I> window in your program: </P>
+  \code
+  Fl::visual(FL_DOUBLE|FL_INDEX)
+  \endcode
+  This makes sure you can use Xdbe on servers where double buffering
+  does not exist for every visual.
+*/
+class FL_EXPORT Fl_Double_Window : public Fl_Window {
+protected:
+  void flush(int eraseoverlay);
+  /**
+    Force double buffering, even if the OS already buffers windows
+    (overlays need that on MacOS and Windows2000)
+  */
+  char force_doublebuffering_;
+public:
+  void show();
+  void show(int a, char **b) {Fl_Window::show(a,b);}
+  void flush();
+  void resize(int,int,int,int);
+  void hide();
+  ~Fl_Double_Window();
+  
+  /**
+   Creates a new Fl_Double_Window widget using the given
+   position, size, and label (title) string.
+  */
+  Fl_Double_Window(int W, int H, const char *l = 0);
+  
+  /**
+   See  Fl_Double_Window::Fl_Double_Window(int w, int h, const char *label = 0)
+  */
+  Fl_Double_Window(int X, int Y, int W, int H, const char *l = 0);
+
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Export.H

@@ -0,0 +1,42 @@
+/*
+ * "$Id$"
+ *
+ * WIN32 DLL export .
+ *
+ * Copyright 1998-2010 by Bill Spitzak and others.
+ *
+ * This library is free software. Distribution and use rights are outlined in
+ * 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
+ *
+ * Please report all bugs and problems on the following page:
+ *
+ *     http://www.fltk.org/str.php
+ */
+
+#ifndef Fl_Export_H
+#  define Fl_Export_H
+
+/*
+ * The following is only used when building DLLs under WIN32...
+ */
+
+#  if defined(FL_DLL)
+#    ifdef FL_LIBRARY
+#      define FL_EXPORT	__declspec(dllexport)
+#    else
+#      define FL_EXPORT	__declspec(dllimport)
+#    endif /* FL_LIBRARY */
+#  elif __GNUC__ >= 4
+#    define FL_EXPORT __attribute__ ((visibility ("default")))
+#  else
+#    define FL_EXPORT
+#  endif /* FL_DLL */
+
+#endif /* !Fl_Export_H */
+
+/*
+ * End of "$Id$".
+ */

msvc/fltk/include/FL/Fl_File_Browser.H

@@ -0,0 +1,111 @@
+//
+// "$Id$"
+//
+// FileBrowser definitions.
+//
+// Copyright 1999-2010 by Michael Sweet.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_File_Browser widget . */
+
+//
+// Include necessary header files...
+//
+
+#ifndef _Fl_File_Browser_H_
+#  define _Fl_File_Browser_H_
+
+#  include "Fl_Browser.H"
+#  include "Fl_File_Icon.H"
+#  include "filename.H"
+
+
+//
+// Fl_File_Browser class...
+//
+
+/** The Fl_File_Browser widget displays a list of filenames, optionally with file-specific icons. */
+class FL_EXPORT Fl_File_Browser : public Fl_Browser {
+  
+  int		filetype_;
+  const char	*directory_;
+  uchar		iconsize_;
+  const char	*pattern_;
+
+  int		full_height() const;
+  int		item_height(void *) const;
+  int		item_width(void *) const;
+  void		item_draw(void *, int, int, int, int) const;
+  int		incr_height() const { return (item_height(0)); }
+
+public:
+  enum { FILES, DIRECTORIES };
+
+  /**
+    The constructor creates the Fl_File_Browser widget at the specified position and size.
+    The destructor destroys the widget and frees all memory that has been allocated.
+  */
+  Fl_File_Browser(int, int, int, int, const char * = 0);
+
+  /**    Sets or gets the size of the icons. The default size is 20 pixels.  */
+  uchar		iconsize() const { return (iconsize_); };
+  /**    Sets or gets the size of the icons. The default size is 20 pixels.  */
+  void		iconsize(uchar s) { iconsize_ = s; redraw(); };
+
+  /**
+    Sets or gets the filename filter. The pattern matching uses
+    the fl_filename_match()
+    function in FLTK.
+  */
+  void	filter(const char *pattern);
+  /**
+    Sets or gets the filename filter. The pattern matching uses
+    the fl_filename_match()
+    function in FLTK.
+  */
+  const char	*filter() const { return (pattern_); };
+
+  /**
+    Loads the specified directory into the browser. If icons have been
+    loaded then the correct icon is associated with each file in the list.
+    
+    <P>The sort argument specifies a sort function to be used with
+    fl_filename_list().
+  */
+  int		load(const char *directory, Fl_File_Sort_F *sort = fl_numericsort);
+
+  Fl_Fontsize  textsize() const { return Fl_Browser::textsize(); };
+  void		textsize(Fl_Fontsize s) { Fl_Browser::textsize(s); iconsize_ = (uchar)(3 * s / 2); };
+
+  /**
+    Sets or gets the file browser type, FILES or
+    DIRECTORIES. When set to FILES, both
+    files and directories are shown. Otherwise only directories are
+    shown.
+  */
+  int		filetype() const { return (filetype_); };
+  /**
+    Sets or gets the file browser type, FILES or
+    DIRECTORIES. When set to FILES, both
+    files and directories are shown. Otherwise only directories are
+    shown.
+  */
+  void		filetype(int t) { filetype_ = t; };
+};
+
+#endif // !_Fl_File_Browser_H_
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_File_Chooser.H

@@ -0,0 +1,245 @@
+//
+// "$Id$"
+//
+// Fl_File_Chooser dialog for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2015 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+// =======================================================================
+//  DO NOT EDIT FL/Fl_File_Chooser.H and src/Fl_File_Chooser.cxx !!!
+// =======================================================================
+//  Please use fluid to change src/Fl_File_Chooser.fl interactively
+//  and then use fluid to "write code" or edit and use fluid -c .
+// =======================================================================
+//
+
+// generated by Fast Light User Interface Designer (fluid) version 1.0305
+
+#ifndef Fl_File_Chooser_H
+#define Fl_File_Chooser_H
+#include <FL/Fl.H>
+#include <FL/Fl_Double_Window.H>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <FL/Fl_Group.H>
+#include <FL/Fl_Choice.H>
+#include <FL/Fl_Menu_Button.H>
+#include <FL/Fl_Button.H>
+#include <FL/Fl_Preferences.H>
+#include <FL/Fl_Tile.H>
+#include <FL/Fl_File_Browser.H>
+#include <FL/Fl_Box.H>
+#include <FL/Fl_Check_Button.H>
+#include <FL/Fl_File_Input.H>
+#include <FL/Fl_Return_Button.H>
+#include <FL/fl_ask.H>
+
+class FL_EXPORT Fl_File_Chooser {
+public:
+  enum { SINGLE = 0, MULTI = 1, CREATE = 2, DIRECTORY = 4 }; 
+private:
+  static Fl_Preferences *prefs_; 
+  void (*callback_)(Fl_File_Chooser*, void *); 
+  void *data_; 
+  char directory_[FL_PATH_MAX]; 
+  char pattern_[FL_PATH_MAX]; 
+  char preview_text_[2048]; 
+  int type_; 
+  void favoritesButtonCB(); 
+  void favoritesCB(Fl_Widget *w); 
+  void fileListCB(); 
+  void fileNameCB(); 
+  void newdir(); 
+  static void previewCB(Fl_File_Chooser *fc); 
+  void showChoiceCB(); 
+  void update_favorites(); 
+  void update_preview(); 
+public:
+  Fl_File_Chooser(const char *d, const char *p, int t, const char *title);
+private:
+  Fl_Double_Window *window;
+  inline void cb_window_i(Fl_Double_Window*, void*);
+  static void cb_window(Fl_Double_Window*, void*);
+  Fl_Choice *showChoice;
+  inline void cb_showChoice_i(Fl_Choice*, void*);
+  static void cb_showChoice(Fl_Choice*, void*);
+  Fl_Menu_Button *favoritesButton;
+  inline void cb_favoritesButton_i(Fl_Menu_Button*, void*);
+  static void cb_favoritesButton(Fl_Menu_Button*, void*);
+public:
+  Fl_Button *newButton;
+private:
+  inline void cb_newButton_i(Fl_Button*, void*);
+  static void cb_newButton(Fl_Button*, void*);
+  inline void cb__i(Fl_Tile*, void*);
+  static void cb_(Fl_Tile*, void*);
+  Fl_File_Browser *fileList;
+  inline void cb_fileList_i(Fl_File_Browser*, void*);
+  static void cb_fileList(Fl_File_Browser*, void*);
+  Fl_Box *previewBox;
+public:
+  Fl_Check_Button *previewButton;
+private:
+  inline void cb_previewButton_i(Fl_Check_Button*, void*);
+  static void cb_previewButton(Fl_Check_Button*, void*);
+public:
+  Fl_Check_Button *showHiddenButton;
+private:
+  inline void cb_showHiddenButton_i(Fl_Check_Button*, void*);
+  static void cb_showHiddenButton(Fl_Check_Button*, void*);
+  Fl_File_Input *fileName;
+  inline void cb_fileName_i(Fl_File_Input*, void*);
+  static void cb_fileName(Fl_File_Input*, void*);
+  Fl_Return_Button *okButton;
+  inline void cb_okButton_i(Fl_Return_Button*, void*);
+  static void cb_okButton(Fl_Return_Button*, void*);
+  Fl_Button *cancelButton;
+  inline void cb_cancelButton_i(Fl_Button*, void*);
+  static void cb_cancelButton(Fl_Button*, void*);
+  Fl_Double_Window *favWindow;
+  Fl_File_Browser *favList;
+  inline void cb_favList_i(Fl_File_Browser*, void*);
+  static void cb_favList(Fl_File_Browser*, void*);
+  Fl_Button *favUpButton;
+  inline void cb_favUpButton_i(Fl_Button*, void*);
+  static void cb_favUpButton(Fl_Button*, void*);
+  Fl_Button *favDeleteButton;
+  inline void cb_favDeleteButton_i(Fl_Button*, void*);
+  static void cb_favDeleteButton(Fl_Button*, void*);
+  Fl_Button *favDownButton;
+  inline void cb_favDownButton_i(Fl_Button*, void*);
+  static void cb_favDownButton(Fl_Button*, void*);
+  Fl_Button *favCancelButton;
+  inline void cb_favCancelButton_i(Fl_Button*, void*);
+  static void cb_favCancelButton(Fl_Button*, void*);
+  Fl_Return_Button *favOkButton;
+  inline void cb_favOkButton_i(Fl_Return_Button*, void*);
+  static void cb_favOkButton(Fl_Return_Button*, void*);
+public:
+  ~Fl_File_Chooser();
+  void callback(void (*cb)(Fl_File_Chooser *, void *), void *d = 0);
+  void color(Fl_Color c);
+  Fl_Color color();
+  int count(); 
+  void directory(const char *d); 
+  char * directory();
+  void filter(const char *p); 
+  const char * filter();
+  int filter_value();
+  void filter_value(int f);
+  void hide();
+  void iconsize(uchar s);
+  uchar iconsize();
+  void label(const char *l);
+  const char * label();
+  void ok_label(const char *l);
+  const char * ok_label();
+  void preview(int e); 
+  int preview() const { return previewButton->value(); }; 
+private:
+  void showHidden(int e); 
+  void remove_hidden_files(); 
+public:
+  void rescan(); 
+  void rescan_keep_filename(); 
+  void show(); 
+  int shown();
+  void textcolor(Fl_Color c);
+  Fl_Color textcolor();
+  void textfont(Fl_Font f);
+  Fl_Font textfont();
+  void textsize(Fl_Fontsize s);
+  Fl_Fontsize textsize();
+  void type(int t);
+  int type();
+  void * user_data() const;
+  void user_data(void *d);
+  const char *value(int f = 1); 
+  void value(const char *filename); 
+  int visible();
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *add_favorites_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *all_files_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *custom_filter_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *existing_file_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *favorites_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *filename_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *filesystems_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *manage_favorites_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *new_directory_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *new_directory_tooltip; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *preview_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *save_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *show_label; 
+  /**
+   [standard text may be customized at run-time]
+  */
+  static const char *hidden_label; 
+  /**
+   the sort function that is used when loading
+   the contents of a directory.
+  */
+  static Fl_File_Sort_F *sort; 
+private:
+  Fl_Widget* ext_group; 
+public:
+  Fl_Widget* add_extra(Fl_Widget* gr);
+};
+FL_EXPORT char *fl_dir_chooser(const char *message,const char *fname,int relative=0);
+FL_EXPORT char *fl_file_chooser(const char *message,const char *pat,const char *fname,int relative=0);
+FL_EXPORT void fl_file_chooser_callback(void (*cb)(const char*));
+FL_EXPORT void fl_file_chooser_ok_label(const char*l);
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_File_Icon.H

@@ -0,0 +1,159 @@
+//
+// "$Id$"
+//
+// Fl_File_Icon definitions.
+//
+// Copyright 1999-2010 by Michael Sweet.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_File_Icon widget . */
+
+//
+// Include necessary header files...
+//
+
+#ifndef _Fl_Fl_File_Icon_H_
+#  define _Fl_Fl_File_Icon_H_
+
+#  include "Fl.H"
+
+
+//
+// Special color value for the icon color.
+//
+
+#  define FL_ICON_COLOR (Fl_Color)0xffffffff	/**< icon color [background?]*/
+
+
+//
+// Fl_File_Icon class...
+//
+
+/** 
+  The Fl_File_Icon class manages icon images that can be used 
+  as labels in other widgets and as icons in the FileBrowser widget.
+*/
+class FL_EXPORT Fl_File_Icon {			//// Icon data
+
+  static Fl_File_Icon *first_;	// Pointer to first icon/filetype
+  Fl_File_Icon	*next_;		// Pointer to next icon/filetype
+  const char	*pattern_;	// Pattern string
+  int		type_;		// Match only if directory or file?
+  int		num_data_;	// Number of data elements
+  int		alloc_data_;	// Number of allocated elements
+  short		*data_;		// Icon data
+
+  public:
+
+  enum				// File types
+  {
+    ANY,			// Any kind of file
+    PLAIN,			// Only plain files
+    FIFO,			// Only named pipes
+    DEVICE,			// Only character and block devices
+    LINK,			// Only symbolic links
+    DIRECTORY			// Only directories
+  };
+
+  enum				// Data opcodes
+  {
+    END,			// End of primitive/icon
+    COLOR,			// Followed by color value (2 shorts)
+    LINE,			// Start of line
+    CLOSEDLINE,			// Start of closed line
+    POLYGON,			// Start of polygon
+    OUTLINEPOLYGON,		// Followed by outline color (2 shorts)
+    VERTEX			// Followed by scaled X,Y
+  };
+
+  Fl_File_Icon(const char *p, int t, int nd = 0, short *d = 0);
+  ~Fl_File_Icon();
+
+  short		*add(short d);
+
+  /**
+    Adds a color value to the icon array, returning a pointer to it.
+    \param[in] c color value
+  */
+  short		*add_color(Fl_Color c)
+		{ short *d = add((short)COLOR); add((short)(c >> 16)); add((short)c); return (d); }
+
+  /**
+    Adds a vertex value to the icon array, returning a pointer to it.
+    The integer version accepts coordinates from 0 to 10000.
+    The origin (0.0) is in the lower-lefthand corner of the icon.
+    \param[in] x, y vertex coordinates
+  */
+  short		*add_vertex(int x, int y)
+		{ short *d = add((short)VERTEX); add((short)x); add((short)y); return (d); }
+
+  /**
+    Adds a vertex value to the icon array, returning a pointer to it.
+    The floating point version goes from 0.0 to 1.0.
+    The origin (0.0) is in the lower-lefthand corner of the icon.
+    \param[in] x, y vertex coordinates
+  */
+  short		*add_vertex(float x, float y)
+		{ short *d = add((short)VERTEX); add((short)(x * 10000.0));
+		  add((short)(y * 10000.0)); return (d); }
+
+  /** Clears all icon data from the icon.*/
+  void		clear() { num_data_ = 0; }
+
+  void		draw(int x, int y, int w, int h, Fl_Color ic, int active = 1);
+
+  void		label(Fl_Widget *w);
+
+  static void	labeltype(const Fl_Label *o, int x, int y, int w, int h, Fl_Align a);
+  void		load(const char *f);
+  int		load_fti(const char *fti);
+  int		load_image(const char *i);
+
+  /** Returns next file icon object. See Fl_File_Icon::first() */
+  Fl_File_Icon	*next() { return (next_); }
+
+  /** Returns the filename matching pattern for the icon.*/
+  const char	*pattern() { return (pattern_); }
+
+  /**  Returns the number of words of data used by the icon.*/
+  int		size() { return (num_data_); }
+
+  /**
+    Returns the filetype associated with the icon, which can be one of the
+    following:
+  
+    \li Fl_File_Icon::ANY, any kind of file.
+    \li Fl_File_Icon::PLAIN, plain files.
+    \li Fl_File_Icon::FIFO, named pipes.
+    \li Fl_File_Icon::DEVICE, character and block devices.
+    \li Fl_File_Icon::LINK, symbolic links.
+    \li Fl_File_Icon::DIRECTORY, directories.
+  */
+  int		type() { return (type_); }
+
+  /**  Returns the data array for the icon.*/
+  short		*value() { return (data_); }
+
+  static Fl_File_Icon *find(const char *filename, int filetype = ANY);
+
+  /** Returns a pointer to the first icon in the list.*/
+  static Fl_File_Icon *first() { return (first_); }
+  static void	load_system_icons(void);
+};
+
+#endif // !_Fl_Fl_File_Icon_H_
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_File_Input.H

@@ -0,0 +1,97 @@
+//
+// "$Id$"
+//
+// File_Input header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+// Original version Copyright 1998 by Curtis Edwards.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_File_Input widget . */
+
+#ifndef Fl_File_Input_H
+#  define Fl_File_Input_H
+
+#  include <FL/Fl_Input.H>
+
+/**
+  \class Fl_File_Input
+  \brief This widget displays a pathname in a text input field.
+
+  A navigation bar located above the input field allows the user to
+  navigate upward in the directory tree.
+  You may want to handle FL_WHEN_CHANGED events for tracking text changes
+  and also FL_WHEN_RELEASE for button release when changing to parent dir.
+  FL_WHEN_RELEASE callback won't be called if the directory clicked
+  is the same as the current one.
+
+  <P align=CENTER> \image html Fl_File_Input.png </P> 
+  \image latex Fl_File_Input.png "Fl_File_Input"  width=6cm
+
+  \note As all Fl_Input derived objects, Fl_File_Input may call its callback
+  when losing focus (see FL_UNFOCUS) to update its state like its cursor shape.
+  One resulting side effect is that you should call clear_changed() early in your callback
+  to avoid reentrant calls if you plan to show another window or dialog box in the callback.
+*/
+class FL_EXPORT Fl_File_Input : public Fl_Input {
+  
+  Fl_Color	errorcolor_;
+  char		ok_entry_;
+  uchar		down_box_;
+  short		buttons_[200];
+  short		pressed_;
+
+  void		draw_buttons();
+  int		handle_button(int event);
+  void		update_buttons();
+
+public:
+
+  Fl_File_Input(int X, int Y, int W, int H, const char *L=0);
+
+  virtual int handle(int event);
+
+protected:
+  virtual void draw();
+
+public:
+  /** Gets the box type used for the navigation bar. */
+  Fl_Boxtype	down_box() const { return (Fl_Boxtype)down_box_; }
+  /** Sets the box type to use for the navigation bar.  */
+  void		down_box(Fl_Boxtype b) { down_box_ = b; }
+
+  /**
+    Gets the current error color.
+    \todo Better docs for Fl_File_Input::errorcolor() - is it even used?
+  */
+  Fl_Color	errorcolor() const { return errorcolor_; }
+  /** Sets the current error color to \p c */
+  void		errorcolor(Fl_Color c) { errorcolor_ = c; }
+
+  int	value(const char *str);
+  int	value(const char *str, int len);
+
+  /**
+    Returns the current value, which is a pointer to an internal buffer
+    and is valid only until the next event is handled.
+  */
+  const char	*value() { return Fl_Input_::value(); }
+};
+
+#endif // !Fl_File_Input_H
+
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Fill_Dial.H

@@ -0,0 +1,38 @@
+//
+// "$Id$"
+//
+// Filled dial header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Fill_Dial widget . */
+
+#ifndef Fl_Fill_Dial_H
+#define Fl_Fill_Dial_H
+
+#include "Fl_Dial.H"
+
+/** Draws a dial with a filled arc */
+class FL_EXPORT Fl_Fill_Dial : public Fl_Dial {
+public:
+  /** Creates a filled dial, also setting its type to FL_FILL_DIAL. */
+  Fl_Fill_Dial(int X,int Y,int W,int H, const char *L);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Fill_Slider.H

@@ -0,0 +1,37 @@
+//
+// "$Id$"
+//
+// Filled slider header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Fill_Slider widget . */
+
+#ifndef Fl_Fill_Slider_H
+#define Fl_Fill_Slider_H
+
+#include "Fl_Slider.H"
+/** Widget that draws a filled horizontal  slider,  useful as a progress or value meter*/
+class FL_EXPORT Fl_Fill_Slider : public Fl_Slider {
+public:
+  /** Creates the slider from its position,size and optional title. */
+  Fl_Fill_Slider(int X,int Y,int W,int H,const char *L=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Float_Input.H

@@ -0,0 +1,47 @@
+//
+// "$Id$"
+//
+// Floating point input header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Float_Input widget . */
+
+#ifndef Fl_Float_Input_H
+#define Fl_Float_Input_H
+
+#include "Fl_Input.H"
+
+/**
+  The Fl_Float_Input class is a subclass of Fl_Input
+  that only allows the user to type floating point numbers (sign,
+  digits, decimal point, more digits, 'E' or 'e', sign, digits).
+*/
+class FL_EXPORT Fl_Float_Input : public Fl_Input {
+public:
+  /**
+    Creates a new Fl_Float_Input widget using the given position,
+    size, and label string. The default boxtype is FL_DOWN_BOX.
+
+    Inherited destructor destroys the widget and any value associated with it.
+  */
+  Fl_Float_Input(int X,int Y,int W,int H,const char *l = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_FormsBitmap.H

@@ -0,0 +1,47 @@
+//
+// "$Id$"
+//
+// Forms bitmap header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_FormsBitmap widget . */
+
+#ifndef Fl_FormsBitmap_H
+#define Fl_FormsBitmap_H
+
+#include "Fl_Bitmap.H"
+
+/** 
+    Forms compatibility Bitmap Image Widget
+*/
+class FL_EXPORT Fl_FormsBitmap : public Fl_Widget {
+    Fl_Bitmap *b;
+protected:
+    void draw();
+public:
+    Fl_FormsBitmap(Fl_Boxtype, int, int, int, int, const char * = 0);
+    void set(int W, int H, const uchar *bits);
+    /** Sets a new bitmap. */
+    void bitmap(Fl_Bitmap *B) {b = B;}
+    /** Gets a the current associated Fl_Bitmap objects. */
+    Fl_Bitmap *bitmap() const {return b;}
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_FormsPixmap.H

@@ -0,0 +1,54 @@
+//
+// "$Id$"
+//
+// Forms pixmap header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_FormsPixmap widget . */
+
+#ifndef Fl_FormsPixmap_H
+#define Fl_FormsPixmap_H
+
+#include "Fl_Pixmap.H"
+
+/**
+  \class Fl_FormsPixmap
+  \brief Forms pixmap drawing routines
+*/
+class FL_EXPORT Fl_FormsPixmap : public Fl_Widget {
+    Fl_Pixmap *b;
+protected:
+    void draw();
+public:
+    Fl_FormsPixmap(Fl_Boxtype t, int X, int Y, int W, int H, const char *L= 0);
+
+    void set(/*const*/char * const * bits);
+
+    /**
+      Set the internal pixmap pointer to an existing pixmap.
+      \param[in] B existing pixmap
+    */
+    void Pixmap(Fl_Pixmap *B) {b = B;}
+
+    /** Get the internal pixmap pointer. */
+    Fl_Pixmap *Pixmap() const {return b;}
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Free.H

@@ -0,0 +1,80 @@
+//
+// "$Id$"
+//
+// Forms free header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Free widget . */
+
+#ifndef Fl_Free_H
+#define Fl_Free_H
+
+#ifndef Fl_Widget_H
+#include "Fl_Widget.H"
+#endif
+
+#define FL_NORMAL_FREE		1 /**< normal event handling */
+#define FL_SLEEPING_FREE	2 /**< deactivate event handling */
+#define FL_INPUT_FREE		3 /**< accepts FL_FOCUS events */
+#define FL_CONTINUOUS_FREE	4 /**< repeated timeout handling */
+#define FL_ALL_FREE		5 /**< FL_INPUT_FREE and FL_CONTINOUS_FREE */
+
+/** appropriate signature for handle function */
+typedef int (*FL_HANDLEPTR)(Fl_Widget *, int , float, float, char);
+
+/**
+  Emulation of the Forms "free" widget.
+  
+  This emulation allows the free demo to run, and appears to be useful for
+  porting programs written in Forms which use the free widget or make
+  subclasses of the Forms widgets.
+
+  There are five types of free, which determine when the handle function
+  is called:
+  
+  \li \c FL_NORMAL_FREE      normal event handling.
+  \li \c FL_SLEEPING_FREE    deactivates event handling (widget is inactive).
+  \li \c FL_INPUT_FREE       accepts FL_FOCUS events.
+  \li \c FL_CONTINUOUS_FREE  sets a timeout callback 100 times a second and
+                             provides an FL_STEP event. This has obvious
+			     detrimental effects on machine performance.
+  \li \c FL_ALL_FREE         same as FL_INPUT_FREE and FL_CONTINUOUS_FREE.
+ 
+*/
+class FL_EXPORT Fl_Free : public Fl_Widget {
+    FL_HANDLEPTR hfunc;
+    static void step(void *);
+protected:
+    void draw();
+public:
+    int handle(int e);
+  Fl_Free(uchar t,int X,int Y,int W,int H,const char *L,FL_HANDLEPTR hdl);
+  ~Fl_Free();
+};
+
+// old event names for compatibility:
+#define FL_MOUSE	FL_DRAG /**< for backward compatibility */
+#define FL_DRAW		100     /**< for backward compatibility [UNUSED]*/
+#define FL_STEP		101     /**< for backward compatibility */
+#define FL_FREEMEM	102     /**< for backward compatibility [UNUSED]*/
+#define FL_FREEZE	103     /**< for backward compatibility [UNUSED]*/
+#define FL_THAW		104     /**< for backward compatibility [UNUSED]*/
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_GIF_Image.H

@@ -0,0 +1,42 @@
+//
+// "$Id$"
+//
+// GIF image header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_GIF_Image widget . */
+
+#ifndef Fl_GIF_Image_H
+#define Fl_GIF_Image_H
+#  include "Fl_Pixmap.H"
+
+/**
+ The Fl_GIF_Image class supports loading, caching,
+ and drawing of Compuserve GIF<SUP>SM</SUP> images. The class
+ loads the first image and supports transparency.
+ */
+class FL_EXPORT Fl_GIF_Image : public Fl_Pixmap {
+
+  public:
+
+  Fl_GIF_Image(const char* filename);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Gl_Window.H

@@ -0,0 +1,284 @@
+//
+// "$Id$"
+//
+// OpenGL header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2015 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Gl_Window widget . */
+
+#ifndef Fl_Gl_Window_H
+#define Fl_Gl_Window_H
+
+#include "Fl_Window.H"
+
+#ifndef GLContext
+/**
+  Opaque pointer type to hide system specific implementation.
+*/
+typedef void* GLContext; // actually a GLXContext or HGLDC
+#endif
+
+class Fl_Gl_Choice; // structure to hold result of glXChooseVisual
+
+/**
+  The Fl_Gl_Window widget sets things up so OpenGL works.
+  
+  It also keeps an OpenGL "context" for that window, so that changes to the
+  lighting and projection may be reused between redraws. Fl_Gl_Window
+  also flushes the OpenGL streams and swaps buffers after draw() returns.
+
+  OpenGL hardware typically provides some overlay bit planes, which
+  are very useful for drawing UI controls atop your 3D graphics.  If the
+  overlay hardware is not provided, FLTK tries to simulate the overlay.
+  This works pretty well if your graphics are double buffered, but not
+  very well for single-buffered.
+
+  Please note that the FLTK drawing and clipping functions
+  will not work inside an Fl_Gl_Window. All drawing
+  should be done using OpenGL calls exclusively.
+  Even though Fl_Gl_Window is derived from Fl_Group, 
+  it is not useful to add other FLTK Widgets as children,
+  unless those widgets are modified to draw using OpenGL calls.
+*/
+class FL_EXPORT Fl_Gl_Window : public Fl_Window {
+
+  int mode_;
+  const int *alist;
+  Fl_Gl_Choice *g;
+  GLContext context_;
+  char valid_f_;
+  char damage1_; // damage() of back buffer
+  virtual void draw_overlay();
+  void init();
+
+  void *overlay;
+  void make_overlay();
+  friend class _Fl_Gl_Overlay;
+
+  static int can_do(int, const int *);
+  int mode(int, const int *);
+  static int gl_plugin_linkage();
+
+public:
+
+  void show();
+  void show(int a, char **b) {Fl_Window::show(a,b);}
+  void flush();
+  void hide();
+  void resize(int,int,int,int);
+  int handle(int);
+  
+  /**
+    Is turned off when FLTK creates a new context for this window or 
+    when the window resizes, and is turned on \e after draw() is called.
+    You can use this inside your draw() method to avoid unnecessarily
+    initializing the OpenGL context. Just do this:
+    \code
+    void mywindow::draw() {
+     if (!valid()) {
+       glViewport(0,0,pixel_w(),pixel_h());
+       glFrustum(...);
+       ...other initialization...
+     }
+     if (!context_valid()) {
+       ...load textures, etc. ...
+     }
+     ... draw your geometry here ...
+    }
+    \endcode
+    
+    You can turn valid() on by calling valid(1).  You
+    should only do this after fixing the transformation inside a draw()
+    or after make_current().  This is done automatically after 
+    draw() returns.
+  */
+  char valid() const {return valid_f_ & 1;}
+  /**
+    See char Fl_Gl_Window::valid() const 
+  */
+  void valid(char v) {if (v) valid_f_ |= 1; else valid_f_ &= 0xfe;}
+  void invalidate();
+
+  /**
+    Will only be set if the 
+    OpenGL context is created or recreated. It differs from
+    Fl_Gl_Window::valid() which is also set whenever the context
+    changes size.
+  */
+  char context_valid() const {return valid_f_ & 2;}
+  /**
+    See char Fl_Gl_Window::context_valid() const 
+  */
+  void context_valid(char v) {if (v) valid_f_ |= 2; else valid_f_ &= 0xfd;}
+
+  /**  Returns non-zero if the hardware supports the given OpenGL mode. */
+  static int can_do(int m) {return can_do(m,0);}
+  /**  Returns non-zero if the hardware supports the given OpenGL mode.
+   \see Fl_Gl_Window::mode(const int *a) */
+  static int can_do(const int *m) {return can_do(0, m);}
+  /**  Returns non-zero if the hardware supports the current OpenGL mode. */
+  int can_do() {return can_do(mode_,alist);}
+  /** Returns the current OpenGL capabilites of the window.
+   Don't use this if capabilities were set through Fl_Gl_Window::mode(const int *a).
+   */
+  Fl_Mode mode() const {return (Fl_Mode)mode_;}
+  /**
+   Set or change the OpenGL capabilites of the window.  The value can be
+   any of the following OR'd together:
+   
+   - \c FL_RGB - RGB color (not indexed)
+   - \c FL_RGB8 - RGB color with at least 8 bits of each color
+   - \c FL_INDEX - Indexed mode
+   - \c FL_SINGLE - not double buffered
+   - \c FL_DOUBLE - double buffered
+   - \c FL_ACCUM - accumulation buffer
+   - \c FL_ALPHA - alpha channel in color
+   - \c FL_DEPTH - depth buffer
+   - \c FL_STENCIL - stencil buffer
+   - \c FL_MULTISAMPLE - multisample antialiasing
+   - \c FL_OPENGL3 - use OpenGL version 3.0 or more.
+   
+   FL_RGB and FL_SINGLE have a value of zero, so they
+   are "on" unless you give FL_INDEX or FL_DOUBLE.
+   
+   If the desired combination cannot be done, FLTK will try turning off
+   FL_MULTISAMPLE.  If this also fails the show() will call
+   Fl::error() and not show the window.
+   
+   You can change the mode while the window is displayed.  This is most
+   useful for turning double-buffering on and off.  Under X this will
+   cause the old X window to be destroyed and a new one to be created.  If
+   this is a top-level window this will unfortunately also cause the
+   window to blink, raise to the top, and be de-iconized, and the xid()
+   will change, possibly breaking other code.  It is best to make the GL
+   window a child of another window if you wish to do this!
+   
+   mode() must not be called within draw() since it
+   changes the current context.
+   
+   The FL_OPENGL3 flag is required to access OpenGL version 3 or more
+   under the X11 and MacOS platforms; it's optional under Windows.
+   See more details in \ref opengl3.
+   
+   \version the <tt>FL_OPENGL3</tt> flag appeared in version 1.3.4
+   */
+  int mode(int a) {return mode(a,0);}
+  /** Set the OpenGL capabilites of the window using platform-specific data.
+   \param a zero-ending array of platform-specific attributes and attribute values
+   <p><b>Unix/Linux platform</b>: attributes are GLX attributes adequate for the 3rd argument of
+   the <tt>glXChooseVisual()</tt> function (e.g., <tt>GLX_DOUBLEBUFFER</tt>, defined by including <GL/glx.h>).
+   \note What attributes are adequate here is subject to change.
+   The preferred, stable public API is Fl_Gl_Window::mode(int a).
+   <p><b>MSWindows platform</b>: this member function is of no use.
+   <p><b>Mac OS X platform</b>: attributes belong to the <tt>CGLPixelFormatAttribute</tt> enumeration
+   (defined by including <tt><OpenGL/OpenGL.h></tt>, e.g., <tt>kCGLPFADoubleBuffer</tt>)
+   and may be followed by adequate attribute values.
+   */
+  int mode(const int *a) {return mode(0, a);}
+  /** Returns a pointer to the GLContext that this window is using.
+   \see void context(void* v, int destroy_flag) */
+  void* context() const {return context_;}
+  void context(void*, int destroy_flag = 0);
+  void make_current();
+  void swap_buffers();
+  void ortho();
+
+  /**
+    Returns true if the hardware overlay is possible.  If this is false,
+    FLTK will try to simulate the overlay, with significant loss of update
+    speed.  Calling this will cause FLTK to open the display.
+  */
+  int can_do_overlay();
+  /**
+    This method causes draw_overlay() to be called at a later time.
+    Initially the overlay is clear. If you want the window to display
+    something in the overlay when it first appears, you must call this
+    immediately after you show() your window.
+  */
+  void redraw_overlay();
+  void hide_overlay();
+  /**
+    The make_overlay_current() method selects the OpenGL context
+    for the widget's overlay.  It is called automatically prior to the 
+    draw_overlay() method being called and can also be used to
+    implement feedback and/or selection within the handle()
+    method.
+  */
+  void make_overlay_current();
+
+  // Note: Doxygen docs in Fl_Widget.H to avoid redundancy.
+  virtual Fl_Gl_Window* as_gl_window() {return this;}
+  
+  /** The number of pixels per FLTK unit of length for the window.
+   Returns 1, except for a window mapped to
+   an Apple 'retina' display, and if Fl::use_high_res_GL(bool) is set to true,
+   when it returns 2. This method dynamically adjusts its value when the window
+   is moved to/from a retina display. This method is useful, e.g., to convert,
+   in a window's handle() method, the FLTK units returned by Fl::event_x() and
+   Fl::event_y() to the pixel units used by the OpenGL source code.
+   \version 1.3.4
+   */
+#ifdef __APPLE__
+  float pixels_per_unit();
+#else
+  float pixels_per_unit() { return 1; }
+#endif
+  /** Gives the window width in OpenGL pixels.
+   Generally identical with the result of the w() function, but for a window mapped to
+   an Apple 'retina' display, and if Fl::use_high_res_GL(bool) is set to true,
+   pixel_w() returns 2 * w(). This method detects when the window has been moved
+   between low and high resolution displays and automatically adjusts the returned value.
+   \version 1.3.4
+   */
+  int pixel_w() { return int(pixels_per_unit() * w() + 0.5); }
+  /** Gives the window height in OpenGL pixels.
+   Generally identical with the result of the h() function, but for a window mapped to
+   an Apple 'retina' display, and if Fl::use_high_res_GL(bool) is set to true,
+   pixel_h() returns 2 * h(). This method detects when the window has been moved
+   between low and high resolution displays and automatically adjusts the returned value.
+   \version 1.3.4
+   */
+  int pixel_h() { return int(pixels_per_unit() * h() + 0.5); }
+  
+  ~Fl_Gl_Window();
+  /**
+    Creates a new Fl_Gl_Window widget using the given size, and label string. 
+    The default boxtype is FL_NO_BOX. The default mode is FL_RGB|FL_DOUBLE|FL_DEPTH.
+  */
+  Fl_Gl_Window(int W, int H, const char *l=0) : Fl_Window(W,H,l) {init();}
+  /**
+    Creates a new Fl_Gl_Window widget using the given position,
+    size, and label string. The default boxtype is FL_NO_BOX. The
+    default mode is FL_RGB|FL_DOUBLE|FL_DEPTH.
+  */
+
+  Fl_Gl_Window(int X, int Y, int W, int H, const char *l=0)
+    : Fl_Window(X,Y,W,H,l) {init();}
+
+protected:
+  /**
+    Draws the Fl_Gl_Window.
+
+    You \e \b must override the draw() method.
+  */
+  virtual void draw();
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Group.H

@@ -0,0 +1,228 @@
+//
+// "$Id$"
+//
+// Group header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Group, Fl_End classes . */
+
+#ifndef Fl_Group_H
+#define Fl_Group_H
+
+#ifndef Fl_Widget_H
+#include "Fl_Widget.H"
+#endif
+
+/**
+  The Fl_Group class is the FLTK container widget. It maintains
+  an array of child widgets. These children can themselves be any widget
+  including Fl_Group. The most important subclass of Fl_Group
+  is Fl_Window, however groups can also be used to control radio buttons
+  or to enforce resize behavior.
+
+  The tab and arrow keys are used to move the focus between widgets of
+  this group, and to other groups. The only modifier grabbed is shift
+  (for shift-tab), so that ctrl-tab, alt-up, and such are free
+  for the app to use as shortcuts.
+*/
+class FL_EXPORT Fl_Group : public Fl_Widget {
+
+  Fl_Widget** array_;
+  Fl_Widget* savedfocus_;
+  Fl_Widget* resizable_;
+  int children_;
+  int *sizes_; // remembered initial sizes of children
+
+  int navigation(int);
+  static Fl_Group *current_;
+ 
+  // unimplemented copy ctor and assignment operator
+  Fl_Group(const Fl_Group&);
+  Fl_Group& operator=(const Fl_Group&);
+
+protected:
+  void draw();
+  void draw_child(Fl_Widget& widget) const;
+  void draw_children();
+  void draw_outside_label(const Fl_Widget& widget) const ;
+  void update_child(Fl_Widget& widget) const;
+  int  *sizes();
+
+public:
+
+  int handle(int);
+  void begin();
+  void end();
+  static Fl_Group *current();
+  static void current(Fl_Group *g);
+
+  /**
+    Returns how many child widgets the group has.
+  */
+  int children() const {return children_;}
+  /**
+    Returns array()[n].  <i>No range checking is done!</i>
+  */
+  Fl_Widget* child(int n) const {return array()[n];}
+  int find(const Fl_Widget*) const;
+  /**
+    See int Fl_Group::find(const Fl_Widget *w) const 
+  */
+  int find(const Fl_Widget& o) const {return find(&o);}
+  Fl_Widget* const* array() const;
+
+  void resize(int,int,int,int);
+  /**
+    Creates a new Fl_Group widget using the given position, size,
+    and label string. The default boxtype is FL_NO_BOX.
+  */
+  Fl_Group(int,int,int,int, const char * = 0);
+  virtual ~Fl_Group();
+  void add(Fl_Widget&);
+  /**
+    See void Fl_Group::add(Fl_Widget &w) 
+  */
+  void add(Fl_Widget* o) {add(*o);}
+  void insert(Fl_Widget&, int i);
+  /**
+    This does insert(w, find(before)).  This will append the
+    widget if \p before is not in the group.
+  */
+  void insert(Fl_Widget& o, Fl_Widget* before) {insert(o,find(before));}
+  void remove(int index);
+  void remove(Fl_Widget&);
+  /**
+    Removes the widget \p o from the group.
+    \sa void remove(Fl_Widget&)
+  */
+  void remove(Fl_Widget* o) {remove(*o);}
+  void clear();
+
+  /**
+    See void Fl_Group::resizable(Fl_Widget *box) 
+  */
+  void resizable(Fl_Widget& o) {resizable_ = &o;}
+  /**
+    The resizable widget defines the resizing box for the group. When the
+    group is resized it calculates a new size and position for all of its
+    children. Widgets that are horizontally or vertically inside the
+    dimensions of the box are scaled to the new size. Widgets outside the
+    box are moved.
+
+    In these examples the gray area is the resizable:
+
+    \image html resizebox1.png
+
+    <br>
+    
+    \image html resizebox2.png
+    
+    \image latex resizebox1.png "before resize"  width=4cm
+    
+    \image latex resizebox2.png "after resize"   width=4.85cm
+
+    The resizable may be set to the group itself, in which case all the
+    contents are resized. This is the default value for Fl_Group,
+    although NULL is the default for Fl_Window and Fl_Pack.
+
+    If the resizable is NULL then all widgets remain a fixed size
+    and distance from the top-left corner.
+
+    It is possible to achieve any type of resize behavior by using an
+    invisible Fl_Box as the resizable and/or by using a hierarchy
+    of child Fl_Group's.
+  */
+  void resizable(Fl_Widget* o) {resizable_ = o;}
+  /**
+    See void Fl_Group::resizable(Fl_Widget *box) 
+  */
+  Fl_Widget* resizable() const {return resizable_;}
+  /**
+    Adds a widget to the group and makes it the resizable widget.
+  */
+  void add_resizable(Fl_Widget& o) {resizable_ = &o; add(o);}
+  void init_sizes();
+
+  /**
+    Controls whether the group widget clips the drawing of
+    child widgets to its bounding box.
+    
+    Set \p c to 1 if you want to clip the child widgets to the
+    bounding box.
+
+    The default is to not clip (0) the drawing of child widgets.
+  */
+  void clip_children(int c) { if (c) set_flag(CLIP_CHILDREN); else clear_flag(CLIP_CHILDREN); }
+  /**
+    Returns the current clipping mode.
+
+    \return true, if clipping is enabled, false otherwise.
+
+    \see void Fl_Group::clip_children(int c)
+  */
+  unsigned int clip_children() { return (flags() & CLIP_CHILDREN) != 0; }
+
+  // Note: Doxygen docs in Fl_Widget.H to avoid redundancy.
+  virtual Fl_Group* as_group() { return this; }
+
+  // back compatibility functions:
+
+  /**
+    \deprecated This is for backwards compatibility only. You should use
+    \e W->%take_focus() instead.
+    \sa Fl_Widget::take_focus();
+  */
+  void focus(Fl_Widget* W) {W->take_focus();}
+
+  /** This is for forms compatibility only */
+  Fl_Widget* & _ddfdesign_kludge() {return resizable_;}
+
+  /** This is for forms compatibility only */
+  void forms_end();
+};
+
+// dummy class used to end child groups in constructors for complex
+// subclasses of Fl_Group:
+/**
+  This is a dummy class that allows you to end a Fl_Group in a constructor list of a
+  class:
+  \code 
+   class MyClass {
+   Fl_Group group;
+   Fl_Button button_in_group;
+   Fl_End end;
+   Fl_Button button_outside_group;
+   MyClass();
+  };
+  MyClass::MyClass() :
+   group(10,10,100,100),
+   button_in_group(20,20,60,30),
+   end(),
+   button_outside_group(10,120,60,30)
+  {} 
+  \endcode
+*/
+class FL_EXPORT Fl_End {
+public:
+  /** All it does is calling Fl_Group::current()->end() */
+  Fl_End() {Fl_Group::current()->end();}
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Help_Dialog.H

@@ -0,0 +1,90 @@
+//
+// "$Id$"
+//
+// Fl_Help_Dialog dialog for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2015 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+// ========================================================================
+//  DO NOT EDIT FL/Fl_Help_Dialog.H and src/Fl_Help_Dialog.cxx !!!
+// ========================================================================
+//  Please use fluid to change src/Fl_Help_Dialog.fl interactively
+//  and then use fluid to "write code" or edit and use fluid -c .
+// ========================================================================
+//
+
+// generated by Fast Light User Interface Designer (fluid) version 1.0305
+
+#ifndef Fl_Help_Dialog_H
+#define Fl_Help_Dialog_H
+#include <FL/Fl.H>
+#include <FL/Fl_Double_Window.H>
+#include <FL/Fl_Group.H>
+#include <FL/Fl_Button.H>
+#include <FL/Fl_Input.H>
+#include <FL/Fl_Box.H>
+#include <FL/Fl_Help_View.H>
+
+class FL_EXPORT Fl_Help_Dialog {
+  int index_; 
+  int max_; 
+  int line_[100]; // FIXME: we must remove those static numbers
+  char file_[100][FL_PATH_MAX]; // FIXME: we must remove those static numbers
+  int find_pos_; 
+public:
+  Fl_Help_Dialog();
+private:
+  Fl_Double_Window *window_;
+  Fl_Button *back_;
+  inline void cb_back__i(Fl_Button*, void*);
+  static void cb_back_(Fl_Button*, void*);
+  Fl_Button *forward_;
+  inline void cb_forward__i(Fl_Button*, void*);
+  static void cb_forward_(Fl_Button*, void*);
+  Fl_Button *smaller_;
+  inline void cb_smaller__i(Fl_Button*, void*);
+  static void cb_smaller_(Fl_Button*, void*);
+  Fl_Button *larger_;
+  inline void cb_larger__i(Fl_Button*, void*);
+  static void cb_larger_(Fl_Button*, void*);
+  Fl_Input *find_;
+  inline void cb_find__i(Fl_Input*, void*);
+  static void cb_find_(Fl_Input*, void*);
+  Fl_Help_View *view_;
+  inline void cb_view__i(Fl_Help_View*, void*);
+  static void cb_view_(Fl_Help_View*, void*);
+public:
+  ~Fl_Help_Dialog();
+  int h();
+  void hide();
+  void load(const char *f);
+  void position(int xx, int yy);
+  void resize(int xx, int yy, int ww, int hh);
+  void show();
+  void show(int argc, char **argv);
+  void textsize(Fl_Fontsize s);
+  Fl_Fontsize textsize();
+  void topline(const char *n);
+  void topline(int n);
+  void value(const char *f);
+  const char * value() const;
+  int visible();
+  int w();
+  int x();
+  int y();
+};
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Help_View.H

@@ -0,0 +1,399 @@
+//
+// "$Id$"
+//
+// Help Viewer widget definitions.
+//
+// Copyright 1997-2010 by Easy Software Products.
+// Image support by Matthias Melcher, Copyright 2000-2009.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Help_View widget . */
+
+#ifndef Fl_Help_View_H
+#  define Fl_Help_View_H
+
+//
+// Include necessary header files...
+//
+
+#  include <stdio.h>
+#  include "Fl.H"
+#  include "Fl_Group.H"
+#  include "Fl_Scrollbar.H"
+#  include "fl_draw.H"
+#  include "Fl_Shared_Image.H"
+#  include "filename.H"
+
+
+//
+// Fl_Help_Func type - link callback function for files...
+//
+
+
+typedef const char *(Fl_Help_Func)(Fl_Widget *, const char *);
+
+
+//
+// Fl_Help_Block structure...
+//
+
+struct Fl_Help_Block {
+  const char	*start,		// Start of text
+		*end;		// End of text
+  uchar		border;		// Draw border?
+  Fl_Color	bgcolor;	// Background color
+  int		x,		// Indentation/starting X coordinate
+		y,		// Starting Y coordinate
+		w,		// Width
+		h;		// Height
+  int		line[32];	// Left starting position for each line
+};
+
+//
+// Fl_Help_Link structure...
+//
+/** Definition of a link for the html viewer. */
+struct Fl_Help_Link {
+  char		filename[192],	///< Reference filename
+		name[32];	///< Link target (blank if none)
+  int		x,		///< X offset of link text
+		y,		///< Y offset of link text
+		w,		///< Width of link text
+		h;		///< Height of link text
+};
+
+/*
+ * Fl_Help_View font stack opaque implementation
+ */
+
+/** Fl_Help_View font stack element definition. */
+struct FL_EXPORT Fl_Help_Font_Style {
+  Fl_Font      f;  ///< Font
+  Fl_Fontsize  s;  ///< Font Size
+  Fl_Color     c;  ///< Font Color
+  void get(Fl_Font &afont, Fl_Fontsize &asize, Fl_Color &acolor) {afont=f; asize=s; acolor=c;} ///< Gets current font attributes
+  void set(Fl_Font afont, Fl_Fontsize asize, Fl_Color acolor) {f=afont; s=asize; c=acolor;} ///< Sets current font attributes
+  Fl_Help_Font_Style(Fl_Font afont, Fl_Fontsize asize, Fl_Color acolor) {set(afont, asize, acolor);}
+  Fl_Help_Font_Style(){} // For in table use
+};
+
+/** Fl_Help_View font stack definition. */
+const size_t MAX_FL_HELP_FS_ELTS = 100;
+
+struct FL_EXPORT Fl_Help_Font_Stack {
+  /** font stack construction, initialize attributes. */
+  Fl_Help_Font_Stack() {
+    nfonts_ = 0;
+  }
+
+  void init(Fl_Font f, Fl_Fontsize s, Fl_Color c) { 
+    nfonts_ = 0;
+    elts_[nfonts_].set(f, s, c);
+    fl_font(f, s); 
+    fl_color(c);
+  }
+  /** Gets the top (current) element on the stack. */
+  void top(Fl_Font &f, Fl_Fontsize &s, Fl_Color &c) { elts_[nfonts_].get(f, s, c); }
+  /** Pushes the font style triplet on the stack, also calls fl_font() & fl_color() adequately */
+  void push(Fl_Font f, Fl_Fontsize s, Fl_Color c) { 
+    if (nfonts_ <  MAX_FL_HELP_FS_ELTS-1) nfonts_ ++;
+    elts_[nfonts_].set(f, s, c);
+    fl_font(f, s); fl_color(c); 
+  }
+  /** Pops from the stack the font style triplet and calls fl_font() & fl_color() adequately */
+  void pop(Fl_Font &f, Fl_Fontsize &s, Fl_Color &c) { 
+    if (nfonts_ > 0) nfonts_ --;
+    top(f, s, c);
+    fl_font(f, s); fl_color(c);
+  }
+  /** Gets the current count of font style elements in the stack. */
+  size_t count() const {return nfonts_;} // Gets the current number of fonts in the stack
+
+protected:
+  size_t nfonts_;		///< current number of fonts in stack
+  Fl_Help_Font_Style elts_[100]; ///< font elements
+};
+
+/** Fl_Help_Target structure */
+
+struct Fl_Help_Target {
+  char		name[32];	///< Target name
+  int		y;		///< Y offset of target
+};
+
+/**
+  The Fl_Help_View widget displays HTML text. Most HTML 2.0
+  elements are supported, as well as a primitive implementation of tables.
+  GIF, JPEG, and PNG images are displayed inline.
+
+  Supported HTML tags:
+     - A: HREF/NAME
+     - B
+     - BODY: BGCOLOR/TEXT/LINK
+     - BR
+     - CENTER
+     - CODE
+     - DD
+     - DL
+     - DT
+     - EM
+     - FONT: COLOR/SIZE/FACE=(helvetica/arial/sans/times/serif/symbol/courier)
+     - H1/H2/H3/H4/H5/H6
+     - HEAD
+     - HR
+     - I
+     - IMG: SRC/WIDTH/HEIGHT/ALT
+     - KBD
+     - LI
+     - OL
+     - P
+     - PRE
+     - STRONG
+     - TABLE: TH/TD/TR/BORDER/BGCOLOR/COLSPAN/ALIGN=CENTER|RIGHT|LEFT
+     - TITLE
+     - TT
+     - U
+     - UL
+     - VAR
+
+  Supported color names:
+     - black,red,green,yellow,blue,magenta,fuchsia,cyan,aqua,white,gray,grey,lime,maroon,navy,olive,purple,silver,teal.
+
+  Supported urls:
+     - Internal: file:
+     - External: http: ftp: https: ipp: mailto: news:
+
+  Quoted char names:
+     - Aacute aacute Acirc acirc acute AElig aelig Agrave agrave amp Aring aring Atilde atilde Auml auml
+     - brvbar bull
+     - Ccedil ccedil cedil cent copy curren
+     - deg divide
+     - Eacute eacute Ecirc ecirc Egrave egrave ETH eth Euml euml euro
+     - frac12 frac14 frac34
+     - gt
+     - Iacute iacute Icirc icirc iexcl Igrave igrave iquest Iuml iuml
+     - laquo lt
+     - macr micro middot
+     - nbsp not Ntilde ntilde
+     - Oacute oacute Ocirc ocirc Ograve ograve ordf ordm Oslash oslash Otilde otilde Ouml ouml
+     - para permil plusmn pound
+     - quot
+     - raquo reg
+     - sect shy sup1 sup2 sup3 szlig
+     - THORN thorn times trade
+     - Uacute uacute Ucirc ucirc Ugrave ugrave uml Uuml uuml
+     - Yacute yacute
+     - yen Yuml yuml
+
+*/
+class FL_EXPORT Fl_Help_View : public Fl_Group {	// Help viewer widget
+  
+  enum { RIGHT = -1, CENTER, LEFT };	///< Alignments
+
+  char		title_[1024];		///< Title string
+  Fl_Color	defcolor_,		///< Default text color
+		bgcolor_,		///< Background color
+		textcolor_,		///< Text color
+		linkcolor_;		///< Link color
+  Fl_Font       textfont_;		///< Default font for text
+  Fl_Fontsize  textsize_;		///< Default font size
+  const char	*value_;		///< HTML text value
+  Fl_Help_Font_Stack fstack_;		///< font stack management
+  int		nblocks_,		///< Number of blocks/paragraphs
+		ablocks_;		///< Allocated blocks
+  Fl_Help_Block	*blocks_;		///< Blocks
+
+  Fl_Help_Func	*link_;			///< Link transform function
+
+  int		nlinks_,		///< Number of links
+		alinks_;		///< Allocated links
+  Fl_Help_Link	*links_;		///< Links
+
+  int		ntargets_,		///< Number of targets
+		atargets_;		///< Allocated targets
+  Fl_Help_Target *targets_;		///< Targets
+
+  char		directory_[FL_PATH_MAX];///< Directory for current file
+  char		filename_[FL_PATH_MAX];	///< Current filename
+  int		topline_,		///< Top line in document
+		leftline_,		///< Lefthand position
+		size_,			///< Total document length
+		hsize_,			///< Maximum document width
+  		scrollbar_size_;	///< Size for both scrollbars
+  Fl_Scrollbar	scrollbar_,		///< Vertical scrollbar for document
+		hscrollbar_;		///< Horizontal scrollbar
+
+  static int    selection_first;
+  static int    selection_last;
+  static int    selection_push_first;
+  static int    selection_push_last;
+  static int    selection_drag_first;
+  static int    selection_drag_last;
+  static int    selected;
+  static int    draw_mode;
+  static int    mouse_x;
+  static int    mouse_y;
+  static int    current_pos;
+  static Fl_Help_View *current_view;
+  static Fl_Color hv_selection_color;
+  static Fl_Color hv_selection_text_color;
+
+
+  void initfont(Fl_Font &f, Fl_Fontsize &s, Fl_Color &c) { f = textfont_; s = textsize_; c = textcolor_; fstack_.init(f, s, c); }
+  void pushfont(Fl_Font f, Fl_Fontsize s) {fstack_.push(f, s, textcolor_);}
+  void pushfont(Fl_Font f, Fl_Fontsize s, Fl_Color c) {fstack_.push(f, s, c);}
+  void popfont(Fl_Font &f, Fl_Fontsize &s, Fl_Color &c) {fstack_.pop(f, s, c);}
+
+  Fl_Help_Block	*add_block(const char *s, int xx, int yy, int ww, int hh, uchar border = 0);
+  void		add_link(const char *n, int xx, int yy, int ww, int hh);
+  void		add_target(const char *n, int yy);
+  static int	compare_targets(const Fl_Help_Target *t0, const Fl_Help_Target *t1);
+  int		do_align(Fl_Help_Block *block, int line, int xx, int a, int &l);
+#if FLTK_ABI_VERSION >= 10303
+protected:
+#endif
+  void		draw();
+#if FLTK_ABI_VERSION >= 10303
+private:
+#endif
+  void		format();
+  void		format_table(int *table_width, int *columns, const char *table);
+  void		free_data();
+  int		get_align(const char *p, int a);
+  const char	*get_attr(const char *p, const char *n, char *buf, int bufsize);
+  Fl_Color	get_color(const char *n, Fl_Color c);
+  Fl_Shared_Image *get_image(const char *name, int W, int H);
+  int		get_length(const char *l);
+#if FLTK_ABI_VERSION >= 10303
+public:
+#endif
+  int		handle(int);
+#if FLTK_ABI_VERSION >= 10303
+private:
+#endif
+
+  void          hv_draw(const char *t, int x, int y, int entity_extra_length = 0);
+  char          begin_selection();
+  char          extend_selection();
+  void          end_selection(int c=0);
+  void          clear_global_selection();
+  Fl_Help_Link  *find_link(int, int);
+  void          follow_link(Fl_Help_Link*);
+
+public:
+
+  Fl_Help_View(int xx, int yy, int ww, int hh, const char *l = 0);
+  ~Fl_Help_View();
+  /** Returns the current directory for the text in the buffer. */
+  const char	*directory() const { if (directory_[0]) return (directory_);
+  					else return ((const char *)0); }
+  /** Returns the current filename for the text in the buffer. */
+  const char	*filename() const { if (filename_[0]) return (filename_);
+  					else return ((const char *)0); }
+  int		find(const char *s, int p = 0);
+  /**
+    This method assigns a callback function to use when a link is
+    followed or a file is loaded (via Fl_Help_View::load()) that
+    requires a different file or path.
+    
+    The callback function receives a pointer to the Fl_Help_View
+    widget and the URI or full pathname for the file in question.
+    It must return a pathname that can be opened as a local file or NULL:
+    
+    \code
+    const char *fn(Fl_Widget *w, const char *uri);
+    \endcode
+    
+    The link function can be used to retrieve remote or virtual
+    documents, returning a temporary file that contains the actual
+    data. If the link function returns NULL, the value of
+    the Fl_Help_View widget will remain unchanged.
+    
+    If the link callback cannot handle the URI scheme, it should
+    return the uri value unchanged or set the value() of the widget
+    before returning NULL.
+  */
+  void		link(Fl_Help_Func *fn) { link_ = fn; }
+  int		load(const char *f);
+  void		resize(int,int,int,int);
+  /** Gets the size of the help view. */
+  int		size() const { return (size_); }
+  void		size(int W, int H) { Fl_Widget::size(W, H); }
+  /** Sets the default text color. */
+  void		textcolor(Fl_Color c) { if (textcolor_ == defcolor_) textcolor_ = c; defcolor_ = c; }
+  /** Returns the current default text color. */
+  Fl_Color	textcolor() const { return (defcolor_); }
+  /** Sets the default text font. */
+  void		textfont(Fl_Font f) { textfont_ = f; format(); }
+  /** Returns the current default text font. */
+  Fl_Font       textfont() const { return (textfont_); }
+  /** Sets the default text size. */
+  void		textsize(Fl_Fontsize s) { textsize_ = s; format(); }
+  /** Gets the default text size. */
+  Fl_Fontsize  textsize() const { return (textsize_); }
+  /** Returns the current document title, or NULL if there is no title. */
+  const char	*title() { return (title_); }
+  void		topline(const char *n);
+  void		topline(int);
+  /** Returns the current top line in pixels. */
+  int		topline() const { return (topline_); }
+  void		leftline(int);
+  /** Gets the left position in pixels. */
+  int		leftline() const { return (leftline_); }
+  void		value(const char *val);
+  /** Returns the current buffer contents. */
+  const char	*value() const { return (value_); }
+  void          clear_selection();
+  void          select_all();
+  /**
+    Gets the current size of the scrollbars' troughs, in pixels.
+
+    If this value is zero (default), this widget will use the 
+    Fl::scrollbar_size() value as the scrollbar's width.
+  
+    \returns Scrollbar size in pixels, or 0 if the global Fl::scrollbar_size() is being used.
+    \see Fl::scrollbar_size(int)
+  */
+  int scrollbar_size() const {
+      return(scrollbar_size_);
+  }
+  /**
+    Sets the pixel size of the scrollbars' troughs to \p newSize, in pixels.
+
+    Normally you should not need this method, and should use
+    Fl::scrollbar_size(int) instead to manage the size of ALL 
+    your widgets' scrollbars. This ensures your application 
+    has a consistent UI, is the default behavior, and is normally
+    what you want.
+
+    Only use THIS method if you really need to override the global
+    scrollbar size. The need for this should be rare.
+    
+    Setting \p newSize to the special value of 0 causes the widget to
+    track the global Fl::scrollbar_size(), which is the default.
+    
+    \param[in] newSize Sets the scrollbar size in pixels.\n
+                    If 0 (default), scrollbar size tracks the global Fl::scrollbar_size()
+    \see Fl::scrollbar_size()
+  */
+  void scrollbar_size(int newSize) {
+      scrollbar_size_ = newSize;
+  }   
+};
+
+#endif // !Fl_Help_View_H
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Hold_Browser.H

@@ -0,0 +1,51 @@
+//
+// "$Id$"
+//
+// Hold browser header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Hold_Browser widget . */
+
+#ifndef Fl_Hold_Browser_H
+#define Fl_Hold_Browser_H
+
+#include "Fl_Browser.H"
+
+/**
+  The Fl_Hold_Browser is a subclass of Fl_Browser
+  which lets the user select a single item, or no items by clicking on
+  the empty space.  As long as the mouse button is held down the item
+  pointed to by it is highlighted, and this highlighting remains on when
+  the mouse button is released. Normally the callback is done when the
+  user releases the mouse, but you can change this with when().
+  <P>See Fl_Browser for methods to add and remove lines from the browser.
+*/
+class FL_EXPORT Fl_Hold_Browser : public Fl_Browser {
+public:
+  /**
+    Creates a new Fl_Hold_Browser widget using the given
+    position, size, and label string. The default boxtype is FL_DOWN_BOX.
+    The constructor specializes Fl_Browser() by setting the type to FL_HOLD_BROWSER.
+    The destructor destroys the widget and frees all memory that has been allocated.
+ */
+  Fl_Hold_Browser(int X,int Y,int W,int H,const char *L=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Hor_Fill_Slider.H

@@ -0,0 +1,36 @@
+//
+// "$Id$"
+//
+// Horizontal fill slider header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Hor_Fill_Slider widget . */
+
+#ifndef Fl_Hor_Fill_Slider_H
+#define Fl_Hor_Fill_Slider_H
+
+#include "Fl_Slider.H"
+
+class FL_EXPORT Fl_Hor_Fill_Slider : public Fl_Slider {
+public:
+  Fl_Hor_Fill_Slider(int X,int Y,int W,int H,const char *L=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Hor_Nice_Slider.H

@@ -0,0 +1,36 @@
+//
+// "$Id$"
+//
+// Horizontal "nice" slider header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Hor_Nice_Slider widget . */
+
+#ifndef Fl_Hor_Nice_Slider_H
+#define Fl_Hor_Nice_Slider_H
+
+#include "Fl_Slider.H"
+
+class FL_EXPORT Fl_Hor_Nice_Slider : public Fl_Slider {
+public:
+  Fl_Hor_Nice_Slider(int X,int Y,int W,int H,const char *L=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Hor_Slider.H

@@ -0,0 +1,45 @@
+//
+// "$Id$"
+//
+// Horizontal slider header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Hor_Slider widget . */
+
+#ifndef Fl_Hor_Slider_H
+#define Fl_Hor_Slider_H
+
+#include "Fl_Slider.H"
+
+/** Horizontal Slider class.
+
+  \see class Fl_Slider.
+*/
+class FL_EXPORT Fl_Hor_Slider : public Fl_Slider {
+public:
+
+  /**
+    Creates a new Fl_Hor_Slider widget using the given position,
+    size, and label string.
+  */
+  Fl_Hor_Slider(int X,int Y,int W,int H,const char *l=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Hor_Value_Slider.H

@@ -0,0 +1,36 @@
+//
+// "$Id$"
+//
+// Horizontal value slider header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Hor_Value_Slider widget . */
+
+#ifndef Fl_Hor_Value_Slider_H
+#define Fl_Hor_Value_Slider_H
+
+#include "Fl_Value_Slider.H"
+
+class FL_EXPORT Fl_Hor_Value_Slider : public Fl_Value_Slider {
+public:
+  Fl_Hor_Value_Slider(int X,int Y,int W,int H,const char *l=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Image.H

@@ -0,0 +1,262 @@
+//
+// "$Id$"
+//
+// Image header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2016 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/** \file
+   Fl_Image, Fl_RGB_Image classes. */
+
+#ifndef Fl_Image_H
+#  define Fl_Image_H
+
+#  include "Enumerations.H"
+#include <stdlib.h>
+
+class Fl_Widget;
+class Fl_Pixmap;
+struct Fl_Menu_Item;
+struct Fl_Label;
+
+
+/** \enum Fl_RGB_Scaling
+ The scaling algorithm to use for RGB images.
+*/
+enum Fl_RGB_Scaling {
+  FL_RGB_SCALING_NEAREST = 0, ///< default RGB image scaling algorithm
+  FL_RGB_SCALING_BILINEAR     ///< more accurate, but slower RGB image scaling algorithm
+};
+
+
+/**
+ \brief Base class for image caching and drawing.
+ 
+ Fl_Image is the base class used for caching and drawing all kinds of images 
+ in FLTK. This class keeps track of common image data such as the pixels, 
+ colormap, width, height, and depth. Virtual methods are used to provide 
+ type-specific image handling.
+  
+ Since the Fl_Image class does not support image
+ drawing by itself, calling the draw() method results in
+ a box with an X in it being drawn instead.
+*/
+class FL_EXPORT Fl_Image {
+    
+public:
+  static const int ERR_NO_IMAGE    = -1;
+  static const int ERR_FILE_ACCESS = -2;
+  static const int ERR_FORMAT      = -3;
+    
+private:
+  int w_, h_, d_, ld_, count_;
+  const char * const *data_;
+  static Fl_RGB_Scaling RGB_scaling_;
+
+  // Forbid use of copy constructor and assign operator
+  Fl_Image & operator=(const Fl_Image &);
+  Fl_Image(const Fl_Image &);
+
+protected:
+
+  /**
+   Sets the current image width in pixels.
+   */
+  void w(int W) {w_ = W;}
+  /**
+   Sets the current image height in pixels.
+   */
+  void h(int H) {h_ = H;}
+  /**
+   Sets the current image depth.
+   */
+  void d(int D) {d_ = D;}
+  /**
+   Sets the current line data size in bytes.
+
+   Color images may contain extra data that is included after every
+   line of color image data and is normally not present.
+
+   If \p LD is zero, then line data size is assumed to be w() * d() bytes.
+
+   If \p LD is non-zero, then it must be positive and larger than w() * d()
+   to account for the extra data per line.
+   */
+  void ld(int LD) {ld_ = LD;}
+  /** 
+   Sets the current array pointer and count of pointers in the array.
+   */
+  void data(const char * const *p, int c) {data_ = p; count_ = c;}
+  void draw_empty(int X, int Y);
+
+  static void labeltype(const Fl_Label *lo, int lx, int ly, int lw, int lh, Fl_Align la);
+  static void measure(const Fl_Label *lo, int &lw, int &lh);
+
+public:
+
+  /** 
+   Returns the current image width in pixels.
+   */
+  int w() const {return w_;}
+  /**
+   Returns the current image height in pixels.
+   */
+  int h() const {return h_;}
+  /**
+   Returns the current image depth.
+   The return value will be 0 for bitmaps, 1 for
+   pixmaps, and 1 to 4 for color images.</P>
+   */
+  int d() const {return d_;}
+  /**
+   Returns the current line data size in bytes.
+   \see ld(int)
+   */
+  int ld() const {return ld_;}
+  /**
+   The count() method returns the number of data values
+   associated with the image. The value will be 0 for images with
+   no associated data, 1 for bitmap and color images, and greater
+   than 2 for pixmap images.
+   */
+  int count() const {return count_;}
+  /**
+   Returns a pointer to the current image data array.
+   Use the count() method to find the size of the data array.
+   */
+  const char * const *data() const {return data_;}
+  int fail();
+  Fl_Image(int W, int H, int D);
+  virtual ~Fl_Image();
+  virtual Fl_Image *copy(int W, int H);
+  /**
+   The copy() method creates a copy of the specified
+   image. If the width and height are provided, the image is
+   resized to the specified size. The image should be deleted (or in
+   the case of Fl_Shared_Image, released) when you are done
+   with it.
+   */
+  Fl_Image *copy() { return copy(w(), h()); }
+  virtual void color_average(Fl_Color c, float i);
+  /**
+   The inactive() method calls
+   color_average(FL_BACKGROUND_COLOR, 0.33f) to produce
+   an image that appears grayed out.
+
+   An internal copy is made of the original image before
+   changes are applied, to avoid modifying the original image.
+   */
+  void inactive() { color_average(FL_GRAY, .33f); }
+  virtual void desaturate();
+  virtual void label(Fl_Widget*w);
+  virtual void label(Fl_Menu_Item*m);
+  /**
+   Draws the image with a bounding box.
+   Arguments <tt>X,Y,W,H</tt> specify
+   a bounding box for the image, with the origin        
+   (upper-left corner) of the image offset by the \c cx
+   and \c cy arguments.
+   
+   In other words:  <tt>fl_push_clip(X,Y,W,H)</tt> is applied,
+   the image is drawn with its upper-left corner at <tt>X-cx,Y-cy</tt> and its own width and height,
+   <tt>fl_pop_clip</tt><tt>()</tt> is applied.
+   */
+  virtual void draw(int X, int Y, int W, int H, int cx=0, int cy=0); // platform dependent
+  /**
+   Draws the image.
+   This form specifies the upper-lefthand corner of the image.
+   */
+  void draw(int X, int Y) {draw(X, Y, w(), h(), 0, 0);} // platform dependent
+  virtual void uncache();
+
+  // set RGB image scaling method
+  static void RGB_scaling(Fl_RGB_Scaling);
+
+  // get RGB image scaling method
+  static Fl_RGB_Scaling RGB_scaling();
+};
+
+
+/**
+  The Fl_RGB_Image class supports caching and drawing
+  of full-color images with 1 to 4 channels of color information.
+  Images with an even number of channels are assumed to contain
+  alpha information, which is used to blend the image with the
+  contents of the screen.
+
+  Fl_RGB_Image is defined in
+  &lt;FL/Fl_Image.H&gt;, however for compatibility reasons
+  &lt;FL/Fl_RGB_Image.H&gt; should be included.
+*/
+class FL_EXPORT Fl_RGB_Image : public Fl_Image {
+  friend class Fl_Quartz_Graphics_Driver;
+  friend class Fl_GDI_Graphics_Driver;
+  friend class Fl_GDI_Printer_Graphics_Driver;
+  friend class Fl_Xlib_Graphics_Driver;
+  static size_t max_size_;
+public:
+
+  /** Points to the start of the object's data array
+   */
+  const uchar *array;
+  /** If non-zero, the object's data array is delete[]'d when deleting the object.
+   */
+  int alloc_array;
+
+  private:
+
+#if defined(__APPLE__) || defined(WIN32)
+  void *id_; // for internal use
+  void *mask_; // for internal use (mask bitmap)
+#else
+  unsigned id_; // for internal use
+  unsigned mask_; // for internal use (mask bitmap)
+#endif // __APPLE__ || WIN32
+
+public:
+
+  Fl_RGB_Image(const uchar *bits, int W, int H, int D=3, int LD=0);
+  Fl_RGB_Image(const Fl_Pixmap *pxm, Fl_Color bg=FL_GRAY);
+  virtual ~Fl_RGB_Image();
+  virtual Fl_Image *copy(int W, int H);
+  Fl_Image *copy() { return copy(w(), h()); }
+  virtual void color_average(Fl_Color c, float i);
+  virtual void desaturate();
+  virtual void draw(int X, int Y, int W, int H, int cx=0, int cy=0);
+  void draw(int X, int Y) {draw(X, Y, w(), h(), 0, 0);}
+  virtual void label(Fl_Widget*w);
+  virtual void label(Fl_Menu_Item*m);
+  virtual void uncache();
+  /** Sets the maximum allowed image size in bytes when creating an Fl_RGB_Image object.
+   
+   The image size in bytes of an Fl_RGB_Image object is the value of the product w() * h() * d().
+   If this product exceeds size, the created object of a derived class of Fl_RGB_Image 
+   won't be loaded with the image data.
+   This does not apply to direct RGB image creation with 
+   Fl_RGB_Image::Fl_RGB_Image(const uchar *bits, int W, int H, int D, int LD).
+   The default max_size() value is essentially infinite. 
+   */
+  static void max_size(size_t size) { max_size_ = size;}
+  /** Returns the maximum allowed image size in bytes when creating an Fl_RGB_Image object.
+   
+   \sa  void Fl_RGB_Image::max_size(size_t)
+   */
+  static size_t max_size() {return max_size_;}
+};
+
+#endif // !Fl_Image_H
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Image_Surface.H

@@ -0,0 +1,99 @@
+//
+// "$Id$"
+//
+// Draw-to-image code for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2014 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+#ifndef Fl_Image_Surface_H
+#define Fl_Image_Surface_H
+
+#include <FL/Fl_Copy_Surface.H>
+#include <FL/Fl_Image.H>
+#include <FL/Fl_Shared_Image.H>
+
+
+/** Directs all graphics requests to an Fl_Image.
+ 
+ After creation of an Fl_Image_Surface object, call set_current() on it, and all subsequent graphics requests
+ will be recorded in the image. It's possible to draw widgets (using Fl_Image_Surface::draw()) 
+ or to use any of the \ref fl_drawings or the \ref fl_attributes.
+ Finally, call image() on the object to obtain a newly allocated Fl_RGB_Image object.
+ <br> Fl_GL_Window objects can be drawn in the image as well. 
+ 
+ <br> Usage example:
+ \code
+ Fl_Widget *g = ...; // a widget you want to draw in an image
+ Fl_Image_Surface *img_surf = new Fl_Image_Surface(g->w(), g->h()); // create an Fl_Image_Surface object
+ img_surf->set_current(); // direct graphics requests to the image
+ fl_color(FL_WHITE); fl_rectf(0, 0, g->w(), g->h()); // draw a white background
+ img_surf->draw(g); // draw the g widget in the image
+ Fl_RGB_Image* image = img_surf->image(); // get the resulting image
+ delete img_surf; // delete the img_surf object
+ Fl_Display_Device::display_device()->set_current();  // direct graphics requests back to the display
+ \endcode
+*/
+class FL_EXPORT Fl_Image_Surface : public Fl_Surface_Device {
+private:
+  void prepare_(int w, int h, int highres);
+  Fl_Offscreen offscreen;
+  int width;
+  int height;
+  Fl_Paged_Device *helper;
+#ifdef __APPLE__
+#elif defined(WIN32)
+  HDC _sgc; 
+  Window _sw; 
+  Fl_Surface_Device *_ss;
+  int _savedc;
+#else
+  Fl_Surface_Device *previous;
+  Window pre_window;
+  GC gc;
+#endif
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+#if FLTK_ABI_VERSION >= 10304 || defined(FL_DOXYGEN)
+  Fl_Image_Surface(int w, int h, int highres = 0);
+#else
+  Fl_Image_Surface(int w, int h, int highres);
+  Fl_Image_Surface(int w, int h);
+#endif
+  ~Fl_Image_Surface();
+  void set_current();
+  void draw(Fl_Widget*, int delta_x = 0, int delta_y = 0);
+  void draw_decorated_window(Fl_Window* win, int delta_x = 0, int delta_y = 0);
+  Fl_RGB_Image *image();
+  Fl_Shared_Image *highres_image();
+};
+
+#ifdef __APPLE__
+/* Mac class to implement translate()/untranslate() for a flipped bitmap graphics context */
+class FL_EXPORT Fl_Quartz_Flipped_Surface_ : public Fl_Quartz_Surface_ {
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  Fl_Quartz_Flipped_Surface_(int w, int h);
+  void translate(int x, int y);
+  void untranslate();
+  virtual ~Fl_Quartz_Flipped_Surface_() {};
+};
+#endif 
+
+#endif // Fl_Image_Surface_H
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Input.H

@@ -0,0 +1,269 @@
+//
+// "$Id$"
+//
+// Input header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Input widget . */
+
+#ifndef Fl_Input_H
+#define Fl_Input_H
+
+#include "Fl_Input_.H"
+
+/**
+  This is the FLTK text input widget. It displays a single line
+  of text and lets the user edit it. Normally it is drawn with an
+  inset box and a white background. The text may contain any
+  characters, and will correctly display any UTF text, using
+  ^X notation for unprintable control characters. It assumes the
+  font can draw any characters of the used scripts, which is true
+  for standard fonts under MSWindows and Mac OS X.
+  Characters can be input using the keyboard or the character palette/map.
+  Character composition is done using dead keys and/or a compose
+  key as defined by the operating system.
+  <P>
+ <!-- DON'T use the class name in the caption, or doxygen 1.8.x will fail. -->
+  <TABLE WIDTH="90%" BORDER="1" SUMMARY="Fl_Input keyboard and mouse bindings.">
+    <CAPTION ALIGN="TOP">Keyboard and mouse bindings.</CAPTION>
+    <TR><TD NOWRAP="NOWRAP" WIDTH="1%">
+      <B>Mouse button 1</B> 
+    </TD><TD>
+      Moves the cursor to this point. 
+      Drag selects characters. 
+      Double click selects words. 
+      Triple click selects all line.
+      Shift+click extends the selection.
+      When you select text it is automatically copied to the selection buffer.
+    </TD></TR><TR><TD NOWRAP="NOWRAP">
+      <B>Mouse button 2</B> 
+    </TD><TD>
+      Insert the selection buffer at the point clicked.
+      You can also select a region and replace it with the selection buffer
+      by selecting the region with mouse button 2.
+    </TD></TR><TR><TD NOWRAP="NOWRAP">
+      <B>Mouse button 3</B>
+    </TD><TD>
+      Currently acts like button 1.
+    </TD></TR><TR><TD NOWRAP="NOWRAP">
+      <B>Backspace</B>
+    </TD><TD>
+      Deletes one character to the left, or deletes the selected region.
+    </TD></TR><TR><TD NOWRAP="NOWRAP">
+      <B>Delete</B>
+    </TD><TD>
+      Deletes one character to the right, or deletes the selected region.
+      Combine with Shift for equivalent of ^X (copy+cut).
+    </TD></TR><TR><TD NOWRAP="NOWRAP">
+      <B>Enter</b>
+    </TD><TD>
+      May cause the callback, see when().
+  </TD></TR></TABLE>
+
+  <P>
+
+  <TABLE WIDTH="90%" BORDER="1" SUMMARY="Fl_Input platform specific keyboard bindings.">
+    <CAPTION ALIGN="TOP">Platform specific keyboard bindings.</CAPTION>
+  <TR>
+    <TD NOWRAP="NOWRAP" WIDTH="1%"><B> Windows/Linux </B></TD>
+    <TD NOWRAP="NOWRAP" WIDTH="1%"><B> Mac </B></TD>
+    <TD NOWRAP="NOWRAP"           ><B> Function </B></TD>
+
+  </TR><TR>
+    <TD NOWRAP="NOWRAP"><B> ^A </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Command-A </B></TD>
+    <TD>
+      <B>Selects all text in the widget.</B>
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> ^C </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Command-C </B></TD>
+    <TD>
+      <B>Copy the current selection to the clipboard.</B>
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> ^I </B></TD>
+    <TD NOWRAP="NOWRAP"><B> ^I </B></TD>
+    <TD>
+      <B>Insert a tab.</B>
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> ^J </B></TD>
+    <TD NOWRAP="NOWRAP"><B> ^J </B></TD>
+    <TD>
+      <B>Insert a Line Feed.</B> <BR>
+      (Similar to literal 'Enter' character)
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> ^L </B></TD>
+    <TD NOWRAP="NOWRAP"><B> ^L </B></TD>
+    <TD>
+      <B>Insert a Form Feed.</B>
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> ^M </B></TD>
+    <TD NOWRAP="NOWRAP"><B> ^M </B></TD>
+    <TD>
+      <B>Insert a Carriage Return.</B>
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> ^V,<BR>Shift-Insert </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Command-V </B></TD>
+    <TD>
+      <B>Paste the clipboard.</B> <BR>
+      (Macs keyboards don't have "Insert" keys, 
+      but if they did, Shift-Insert would work)
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> ^X,<BR>Shift-Delete </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Command-X,<BR>Shift-Delete </B></TD>
+    <TD>
+      <B>Cut.</B> <BR>
+      Copy the selection to the clipboard and delete it.
+      (If there's no selection, Shift-Delete acts like Delete)
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> ^Z </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Command-Z </B></TD>
+    <TD>
+      <B>Undo.</B> <BR>
+      This is a single-level undo mechanism, but all adjacent 
+      deletions and insertions are concatenated into a single "undo".
+      Often this will undo a lot more than you expected. 
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> Shift-^Z </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Shift-Command-Z </B></TD>
+    <TD>
+      <B>Redo.</B> <BR>
+      Currently same behavior as ^Z. 
+      Reserved for future multilevel undo/redo.
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> Arrow Keys </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Arrow Keys </B></TD>
+    <TD>
+      <B>Standard cursor movement.</B> <BR>
+      Can be combined with Shift to extend selection.
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> Home </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Command-Up,<BR>Command-Left </B></TD>
+    <TD>
+      <B>Move to start of line.</B> <BR>
+      Can be combined with Shift to extend selection.
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> End </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Command-Down,<BR>Command-Right </B></TD>
+    <TD>
+      <B>Move to end of line.</B> <BR>
+      Can be combined with Shift to extend selection.
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B>Ctrl-Home</B></TD>
+    <TD NOWRAP="NOWRAP"><B>Command-Up,<BR>Command-PgUp,<BR>Ctrl-Left</B></TD>
+    <TD>
+      <B>Move to top of document/field.</B> <BR>
+      In single line input, moves to start of line.
+      In multiline input, moves to start of top line.
+      Can be combined with Shift to extend selection.
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> Ctrl-End </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Command-End,<BR>Command-PgDn,<BR>Ctrl-Right</B></TD>
+    <TD>
+      <B>Move to bottom of document/field.</B> <BR>
+      In single line input, moves to end of line.
+      In multiline input, moves to end of last line.
+      Can be combined with Shift to extend selection.
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> Ctrl-Left </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Alt-Left </B></TD>
+    <TD>
+      <B>Word left.</B> <BR>
+      Can be combined with Shift to extend selection.
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> Ctrl-Right </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Alt-Right </B></TD>
+    <TD>
+      <B>Word right.</B> <BR>
+      Can be combined with Shift to extend selection.
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> Ctrl-Backspace </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Alt-Backspace </B></TD>
+    <TD>
+      <B>Delete word left.</B>
+
+  </TD></TR><TR>
+    <TD NOWRAP="NOWRAP"><B> Ctrl-Delete </B></TD>
+    <TD NOWRAP="NOWRAP"><B> Alt-Delete </B></TD>
+    <TD>
+      <B>Delete word right.</B>
+
+  </TD></TR></TABLE>
+  */
+class FL_EXPORT Fl_Input : public Fl_Input_ {
+  int handle_key();
+  int shift_position(int p);
+  int shift_up_down_position(int p);
+  void handle_mouse(int keepmark=0);
+
+  // Private keyboard functions
+  int kf_lines_up(int repeat_num);
+  int kf_lines_down(int repeat_num);
+  int kf_page_up();
+  int kf_page_down();
+  int kf_insert_toggle();
+  int kf_delete_word_right();
+  int kf_delete_word_left();
+  int kf_delete_sol();
+  int kf_delete_eol();
+  int kf_delete_char_right();
+  int kf_delete_char_left();
+  int kf_move_sol();
+  int kf_move_eol();
+  int kf_clear_eol();
+  int kf_move_char_left();
+  int kf_move_char_right();
+  int kf_move_word_left();
+  int kf_move_word_right();
+  int kf_move_up_and_sol();
+  int kf_move_down_and_eol();
+  int kf_top();
+  int kf_bottom();
+  int kf_select_all();
+  int kf_undo();
+  int kf_redo();
+  int kf_copy();
+  int kf_paste();
+  int kf_copy_cut();
+
+protected:
+  void draw();
+public:
+  int handle(int);
+  Fl_Input(int,int,int,int,const char * = 0);
+};
+
+#endif 
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Input_.H

@@ -0,0 +1,499 @@
+//
+// "$Id$"
+//
+// Input base class header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2015 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Input_ widget . */
+
+#ifndef Fl_Input__H
+#define Fl_Input__H
+
+#ifndef Fl_Widget_H
+#include "Fl_Widget.H"
+#endif
+
+#define FL_NORMAL_INPUT		0
+#define FL_FLOAT_INPUT		1
+#define FL_INT_INPUT		2
+#define FL_HIDDEN_INPUT		3
+#define FL_MULTILINE_INPUT	4
+#define FL_SECRET_INPUT		5
+#define FL_INPUT_TYPE		7
+#define FL_INPUT_READONLY	8
+#define FL_NORMAL_OUTPUT	(FL_NORMAL_INPUT | FL_INPUT_READONLY)
+#define FL_MULTILINE_OUTPUT	(FL_MULTILINE_INPUT | FL_INPUT_READONLY)
+#define FL_INPUT_WRAP		16
+#define FL_MULTILINE_INPUT_WRAP	(FL_MULTILINE_INPUT | FL_INPUT_WRAP)
+#define FL_MULTILINE_OUTPUT_WRAP (FL_MULTILINE_INPUT | FL_INPUT_READONLY | FL_INPUT_WRAP)
+
+/**
+  This class provides a low-overhead text input field.
+
+  This is a virtual base class below Fl_Input. It has all
+  the same interfaces, but lacks the handle() and
+  draw() method. You may want to subclass it if you are
+  one of those people who likes to change how the editing keys
+  work. It may also be useful for adding scrollbars
+  to the input field.
+
+  This can act like any of the subclasses of Fl_Input, by
+  setting type() to one of the following values:
+
+  \code
+  #define FL_NORMAL_INPUT	   0
+  #define FL_FLOAT_INPUT	   1
+  #define FL_INT_INPUT		   2
+  #define FL_MULTILINE_INPUT	   4
+  #define FL_SECRET_INPUT	   5
+  #define FL_INPUT_TYPE		   7
+  #define FL_INPUT_READONLY	   8
+  #define FL_NORMAL_OUTPUT	   (FL_NORMAL_INPUT | FL_INPUT_READONLY)
+  #define FL_MULTILINE_OUTPUT	   (FL_MULTILINE_INPUT | FL_INPUT_READONLY)
+  #define FL_INPUT_WRAP		   16
+  #define FL_MULTILINE_INPUT_WRAP  (FL_MULTILINE_INPUT | FL_INPUT_WRAP)
+  #define FL_MULTILINE_OUTPUT_WRAP (FL_MULTILINE_INPUT | FL_INPUT_READONLY | FL_INPUT_WRAP)
+  \endcode
+
+  All variables that represent an index into a text buffer are byte-oriented,
+  not character oriented, counting from 0 (at or before the first character)
+  to size() (at the end of the buffer, after the last byte). Since UTF-8
+  characters can be up to six bytes long, simply incrementing such an index
+  will not reliably advance to the next character in the text buffer.
+
+  Indices and pointers into the text buffer should always point at a 7 bit ASCII
+  character or the beginning of a UTF-8 character sequence. Behavior for false
+  UTF-8 sequences and pointers into the middle of a sequence are undefined.
+
+  \see Fl_Text_Display, Fl_Text_Editor for more powerful text handling widgets
+
+  \internal
+  When porting this widget from ASCII to UTF-8, previously legal pointers into
+  the text of this widget can become illegal by pointing into the middle of
+  a UTF-8 sequence. This is not a big problem for Fl_Input_ because all code
+  in this module is quite tolerant. It could be problematic though when deriving
+  from this class because no feedback for illegal pointers is given. Additionally,
+  a careless "copy" call can put partial UTF-8 sequences into the clipboard.
+
+  None of these issues should be disastrous. Nevertheless, we should
+  discuss how FLTK should handle false UTF-8 sequences and pointers.
+*/
+class FL_EXPORT Fl_Input_ : public Fl_Widget {
+
+  /** \internal Storage for the text field. */
+  const char* value_;
+
+  /** \internal Buffer memory for expanded text. \see expand() */
+  char* buffer;
+
+  /** \internal Size of text in bytes in the \p value_ field. */
+  int size_;
+
+  /** \internal Current size of internal value() buffer in bytes. */
+  int bufsize;
+
+  /** \internal Position of the cursor in the document. */
+  int position_;
+
+  /** \internal Position of the other end of the selected text.
+      If \p position_ equals \p mark_, no text is selected */
+  int mark_;
+
+  /** \internal Behavior of Tab key in multiline input widget. 
+      If enabled (default) Tab causes focus nav, otherwise Tab is inserted 
+      as a character. */
+  int tab_nav_;
+
+  /** \internal Offset to text origin within widget bounds */
+  int xscroll_, yscroll_;
+
+  /** \internal Minimal update pointer. Display requires redraw from here to the end
+      of the buffer. */
+  int mu_p;
+
+  /** \internal Maximum number of (UTF-8) characters a user can input. */
+  int maximum_size_;
+
+  /** \internal Shortcut key that will fetch focus for this widget. */
+  int shortcut_;
+
+  /** \internal This is set if no text but only the cursor needs updating. */
+  uchar erase_cursor_only;
+
+  /** \internal The font used for the entire text. */
+  Fl_Font textfont_;
+
+  /** \internal Height of the font used for the entire text. */
+  Fl_Fontsize textsize_;
+
+  /** \internal color of the entire text */
+  Fl_Color textcolor_;
+
+  /** \internal color of the text cursor */
+  Fl_Color cursor_color_;
+
+  /** \internal Horizontal cursor position in pixels while moving up or down. */
+  static double up_down_pos;
+
+  /** \internal Flag to remember last cursor move. */
+  static int was_up_down;
+
+  /* Convert a given text segment into the text that will be rendered on screen. */
+  const char* expand(const char*, char*) const;
+
+  /* Calculates the width in pixels of part of a text buffer. */
+  double expandpos(const char*, const char*, const char*, int*) const;
+
+  /* Mark a range of characters for update. */
+  void minimal_update(int, int);
+
+  /* Mark a range of characters for update. */
+  void minimal_update(int p);
+
+  /* Copy the value from a possibly static entry into the internal buffer. */
+  void put_in_buffer(int newsize);
+
+  /* Set the current font and font size. */
+  void setfont() const;
+
+protected:
+
+  /* Find the start of a word. */
+  int word_start(int i) const;
+
+  /* Find the end of a word. */
+  int word_end(int i) const;
+
+  /* Find the start of a line. */
+  int line_start(int i) const;
+  
+  /* Find the end of a line. */
+  int line_end(int i) const;
+
+  /* Draw the text in the passed bounding box. */
+  void drawtext(int, int, int, int);
+
+  /* Move the cursor to the column given by up_down_pos. */
+  int up_down_position(int, int keepmark=0);
+
+  /* Handle mouse clicks and mouse moves. */
+  void handle_mouse(int, int, int, int, int keepmark=0);
+
+  /* Handle all kinds of text field related events. */
+  int handletext(int e, int, int, int, int);
+
+  /* Check the when() field and do a callback if indicated. */
+  void maybe_do_callback();
+
+  /** \internal Horizontal offset of text to left edge of widget. */
+  int xscroll() const {return xscroll_;}
+
+  /** \internal Vertical offset of text to top edge of widget. */
+  int yscroll() const {return yscroll_;}
+  void yscroll(int yOffset) { yscroll_ = yOffset; damage(FL_DAMAGE_EXPOSE);}
+
+  /* Return the number of lines displayed on a single page.  */
+  int linesPerPage();
+
+public:
+
+  /* Change the size of the widget. */
+  void resize(int, int, int, int);
+
+  /* Constructor */
+  Fl_Input_(int, int, int, int, const char* = 0);
+
+  /* Destructor */
+  ~Fl_Input_();
+
+  /* Changes the widget text. */
+  int value(const char*);
+
+  /* Changes the widget text. */
+  int value(const char*, int);
+
+  /* Changes the widget text. */
+  int static_value(const char*);
+
+  /* Changes the widget text. */
+  int static_value(const char*, int);
+
+  /**
+      Returns the text displayed in the widget.
+
+      This function returns the current value, which is a pointer
+      to the internal buffer and is valid only until the next event is
+      handled.
+  
+      \return pointer to an internal buffer - do not free() this    
+      \see Fl_Input_::value(const char*)
+  */
+  const char* value() const {return value_;}
+
+  /* Returns the character at index \p i. */
+  Fl_Char index(int i) const;
+
+  /**
+    Returns the number of bytes in value(). 
+  
+    This may be greater than <tt>strlen(value())</tt> if there are 
+    \c nul characters in the text.
+
+    \return number of bytes in the text
+  */
+  int size() const {return size_;}
+
+  /** Sets the width and height of this widget.
+    \param [in] W, H new width and height
+    \see Fl_Widget::size(int, int) */
+  void size(int W, int H) { Fl_Widget::size(W, H); }
+
+  /** Gets the maximum length of the input field in characters.
+    \see maximum_size(int). */
+  int maximum_size() const {return maximum_size_;}
+
+  /** Sets the maximum length of the input field in characters.
+
+    This limits the number of <b>characters</b> that can be inserted
+    in the widget.
+
+    Since FLTK 1.3 this is different than the buffer size, since one
+    character can be more than one byte in UTF-8 encoding. In FLTK 1.1
+    this was the same (one byte = one character).
+  */
+  void maximum_size(int m) {maximum_size_ = m;}
+
+  /** Gets the position of the text cursor.
+    \return the cursor position as an index in the range 0..size()
+    \see position(int, int)
+  */
+  int position() const {return position_;}
+
+  /** Gets the current selection mark. 
+    \return index into the text */
+  int mark() const {return mark_;}
+
+  /* Sets the index for the cursor and mark. */
+  int position(int p, int m);
+
+  /** Sets the cursor position and mark.
+    position(n) is the same as <tt>position(n, n)</tt>.
+    \param p new index for cursor and mark
+    \return 0 if no positions changed
+    \see position(int, int), position(), mark(int)
+  */
+  int position(int p) {return position(p, p);}
+
+  /** Sets the current selection mark. 
+    mark(n) is the same as <tt>position(position(),n)</tt>.
+    \param m new index of the mark 
+    \return 0 if the mark did not change
+    \see position(), position(int, int) */
+  int mark(int m) {return position(position(), m);}
+
+  /* Deletes text from \p b to \p e and inserts the new string \p text. */
+  int replace(int b, int e, const char *text, int ilen=0);
+
+  /**
+    Deletes the current selection.
+
+    This function deletes the currently selected text
+    \e without storing it in the clipboard. To use the clipboard,
+    you may call copy() first or copy_cuts() after
+    this call.
+
+    \return 0 if no data was copied
+  */
+  int cut() {return replace(position(), mark(), 0);}
+
+  /**
+    Deletes the next \p n bytes rounded to characters before or after the cursor.
+
+    This function deletes the currently selected text
+    \e without storing it in the clipboard. To use the clipboard,
+    you may call copy() first or copy_cuts() after
+    this call.
+
+    \param n number of bytes rounded to full characters and clamped to the buffer.
+           A negative number will cut characters to the left of the cursor.
+    \return 0 if no data was copied
+  */
+  int cut(int n) {return replace(position(), position()+n, 0);}
+
+  /**
+    Deletes all characters between index \p a and \p b.
+
+    This function deletes the currently selected text
+    \e without storing it in the clipboard. To use the clipboard,
+    you may call copy() first or copy_cuts() after
+    this call.
+
+    \param a, b range of bytes rounded to full characters and clamped to the buffer
+    \return 0 if no data was copied
+  */
+  int cut(int a, int b) {return replace(a, b, 0);}
+
+  /**
+    Inserts text at the cursor position.
+
+    This function inserts the string in \p t at the cursor
+    position() and moves the new position and mark to
+    the end of the inserted text.
+
+    \param [in] t text that will be inserted
+    \param [in] l length of text, or 0 if the string is terminated by \c nul.
+    \return 0 if no text was inserted
+  */
+  int insert(const char* t, int l=0){return replace(position_, mark_, t, l);}
+
+  /* Put the current selection into the clipboard. */
+  int copy(int clipboard);
+
+  /* Undo previous changes to the text buffer. */
+  int undo();
+
+  /* Copy the yank buffer to the clipboard. */
+  int copy_cuts();
+
+  /** Return the shortcut key associated with this widget.
+    \return shortcut keystroke
+    \see Fl_Button::shortcut() */
+  int shortcut() const {return shortcut_;}
+
+  /** 
+    Sets the shortcut key associated with this widget.
+    Pressing the shortcut key gives text editing focus to this widget.
+    \param [in] s new shortcut keystroke 
+    \see Fl_Button::shortcut() 
+  */
+  void shortcut(int s) {shortcut_ = s;}
+
+  /** Gets the font of the text in the input field.
+    \return the current Fl_Font index */
+  Fl_Font textfont() const {return textfont_;}
+
+  /** Sets the font of the text in the input field.
+    The text font defaults to \c FL_HELVETICA.
+    \param [in] s the new text font */
+  void textfont(Fl_Font s) {textfont_ = s;}
+
+  /** Gets the size of the text in the input field.
+    \return the text height in pixels */
+  Fl_Fontsize textsize() const {return textsize_;}
+
+  /** Sets the size of the text in the input field.
+    The text height defaults to \c FL_NORMAL_SIZE.
+    \param [in] s the new font height in pixel units */
+  void textsize(Fl_Fontsize s) {textsize_ = s;}
+
+  /** Gets the color of the text in the input field.
+    \return the text color
+    \see textcolor(Fl_Color) */
+  Fl_Color textcolor() const {return textcolor_;}
+
+  /** Sets the color of the text in the input field.
+    The text color defaults to \c FL_FOREGROUND_COLOR.
+    \param [in] n new text color
+    \see textcolor() */
+  void textcolor(Fl_Color n) {textcolor_ = n;}
+
+  /** Gets the color of the cursor.  
+    \return the current cursor color */
+  Fl_Color cursor_color() const {return cursor_color_;}
+
+  /** Sets the color of the cursor.  
+    The default color for the cursor is \c FL_BLACK.
+    \param [in] n the new cursor color */
+  void cursor_color(Fl_Color n) {cursor_color_ = n;}
+
+  /** Gets the input field type. 
+    \return the current input type */
+  int input_type() const {return type() & FL_INPUT_TYPE; }
+
+  /** Sets the input field type. 
+    A redraw() is required to reformat the input field.
+    \param [in] t new input type */
+  void input_type(int t) { type((uchar)(t | readonly())); }
+
+  /** Gets the read-only state of the input field.  
+    \return non-zero if this widget is read-only */
+  int readonly() const { return type() & FL_INPUT_READONLY; }
+
+  /** Sets the read-only state of the input field.  
+    \param [in] b if \p b is 0, the text in this widget can be edited by the user */
+  void readonly(int b) { if (b) type((uchar)(type() | FL_INPUT_READONLY));
+                         else type((uchar)(type() & ~FL_INPUT_READONLY)); }
+
+  /**
+    Gets  the word wrapping state of the input field. 
+    Word wrap is only functional with multi-line input fields.
+  */
+  int wrap() const { return type() & FL_INPUT_WRAP; }
+
+  /**
+    Sets the word wrapping state of the input field. 
+    Word wrap is only functional with multi-line input fields.
+  */
+  void wrap(int b) { if (b) type((uchar)(type() | FL_INPUT_WRAP));
+                         else type((uchar)(type() & ~FL_INPUT_WRAP)); }
+
+  /**
+    Sets whether the Tab key does focus navigation, 
+    or inserts tab characters into Fl_Multiline_Input.
+
+    By default this flag is enabled to provide the 'normal' behavior 
+    most users expect; Tab navigates focus to the next widget. 
+    To inserting an actual Tab character, users can use Ctrl-I
+    or copy/paste.
+
+    Disabling this flag gives the old FLTK behavior where Tab
+    inserts a tab character into the text field, in which case
+    only the mouse can be used to navigate to the next field.
+
+    History: This flag was provided for backwards support of FLTK's old 1.1.x
+    behavior where Tab inserts a tab character instead of navigating 
+    focus to the next widget. This behavior was unique to Fl_Multiline_Input. 
+    With the advent of Fl_Text_Editor, this old behavior has been deprecated.
+
+    \param [in] val If \p val is 1, Tab advances focus (default).<BR>
+                    If \p val is 0, Tab inserts a tab character (old FLTK behavior).
+
+    \see tab_nav(), Fl::OPTION_ARROW_FOCUS.
+  */
+  void tab_nav(int val) {
+    tab_nav_ = val;
+  }
+
+  /**
+    Gets whether the Tab key causes focus navigation in multiline input fields or not.
+
+    If enabled (default), hitting Tab causes focus navigation to the next widget.
+
+    If disabled, hitting Tab inserts a tab character into the text field.
+    \returns 1 if Tab advances focus (default), 0 if Tab inserts tab characters.
+
+    \see tab_nav(int), Fl::OPTION_ARROW_FOCUS.
+  */
+  int tab_nav() const {
+    return tab_nav_;
+  }
+};
+
+#endif 
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Input_Choice.H

@@ -0,0 +1,268 @@
+//
+// "$Id$"
+//
+// An input/chooser widget.
+//            ______________  ____
+//           |              || __ |
+//           | input area   || \/ |
+//           |______________||____|
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+// Copyright 2004 by Greg Ercolano.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Input_Choice widget . */
+
+#ifndef Fl_Input_Choice_H
+#define Fl_Input_Choice_H
+
+#include <FL/Fl.H>
+#include <FL/Fl_Group.H>
+#include <FL/Fl_Input.H>
+#include <FL/Fl_Menu_Button.H>
+#include <FL/fl_draw.H>
+#include <string.h>
+
+/**
+  A combination of the input widget and a menu button.
+
+  \image html input_choice.jpg
+  \image latex input_choice.jpg "Fl_Input_Choice widget" width=6cm
+
+  The user can either type into the input area, or use the
+  menu button chooser on the right to choose an item which loads
+  the input area with the selected text.
+
+  The application can directly access both the internal Fl_Input 
+  and Fl_Menu_Button widgets respectively using the input() and menubutton()
+  accessor methods.
+
+  The default behavior is to invoke the Fl_Input_Choice::callback()
+  if the user changes the input field's contents, either by typing,
+  pasting, or clicking a different item in the choice menu.
+  
+  The callback can determine if an item was picked vs. typing
+  into the input field by checking the value of menubutton()->changed(),
+  which will be:
+
+      - 1: the user picked a different item in the choice menu
+      - 0: the user typed or pasted directly into the input field
+
+  Example use:
+  \code
+  #include <stdio.h>
+  #include <FL/Fl.H>
+  #include <FL/Fl_Double_Window.H>
+  #include <FL/Fl_Input_Choice.H>
+  void choice_cb(Fl_Widget *w, void *userdata) {
+    // Show info about the picked item
+    Fl_Input_Choice *choice = (Fl_Input_Choice*)w;
+    const Fl_Menu_Item *item = choice->menubutton()->mvalue();
+    printf("*** Choice Callback:\n");
+    printf("    item label()='%s'\n", item ? item->label() : "(No item)");
+    printf("    item value()=%d\n", choice->menubutton()->value());
+    printf("    input value()='%s'\n", choice->input()->value());
+    printf("    The user %s\n", choice->menubutton()->changed()
+                                    ? "picked a menu item"
+                                    : "typed text");
+  }
+  int main() {
+    Fl_Double_Window win(200,100,"Input Choice");
+    win.begin();
+      Fl_Input_Choice choice(10,10,100,30);
+      choice.callback(choice_cb, 0);
+      choice.add("Red");
+      choice.add("Orange");
+      choice.add("Yellow");
+      //choice.value("Red");    // uncomment to make "Red" default
+    win.end();
+    win.show();
+    return Fl::run();
+  }
+  \endcode
+*/
+class FL_EXPORT Fl_Input_Choice : public Fl_Group {
+  // Private class to handle slightly 'special' behavior of menu button
+  class InputMenuButton : public Fl_Menu_Button {
+    void draw() {
+      draw_box(FL_UP_BOX, color());
+      fl_color(active_r() ? labelcolor() : fl_inactive(labelcolor()));
+      int xc = x()+w()/2, yc=y()+h()/2;
+      fl_polygon(xc-5,yc-3,xc+5,yc-3,xc,yc+3);
+      if (Fl::focus() == this) draw_focus();
+    }
+  public:
+    InputMenuButton(int X,int Y,int W,int H,const char*L=0) : 
+	Fl_Menu_Button(X, Y, W, H, L) { box(FL_UP_BOX); }
+  };
+
+  Fl_Input *inp_;
+  InputMenuButton *menu_;
+
+  // note: this is used by the Fl_Input_Choice ctor defined in Fl_Group.
+  static void menu_cb(Fl_Widget*, void *data) { 
+    Fl_Input_Choice *o=(Fl_Input_Choice *)data;
+    Fl_Widget_Tracker wp(o);
+    const Fl_Menu_Item *item = o->menubutton()->mvalue();
+    if (item && item->flags & (FL_SUBMENU|FL_SUBMENU_POINTER)) return;	// ignore submenus
+    if (!strcmp(o->inp_->value(), o->menu_->text()))
+    {
+      o->Fl_Widget::clear_changed();
+      if (o->when() & FL_WHEN_NOT_CHANGED)
+	o->do_callback();
+    }
+    else
+    {
+      o->inp_->value(o->menu_->text());
+      o->inp_->set_changed();
+      o->Fl_Widget::set_changed();
+      if (o->when() & (FL_WHEN_CHANGED|FL_WHEN_RELEASE))
+	o->do_callback();
+    }
+    
+    if (wp.deleted()) return;
+
+    if (o->callback() != default_callback)
+    {
+      o->Fl_Widget::clear_changed();
+      o->inp_->clear_changed();
+    }
+  }
+
+  // note: this is used by the Fl_Input_Choice ctor defined in Fl_Group.
+  static void inp_cb(Fl_Widget*, void *data) { 
+    Fl_Input_Choice *o=(Fl_Input_Choice *)data;
+    Fl_Widget_Tracker wp(o);
+    if (o->inp_->changed()) {
+      o->Fl_Widget::set_changed();
+      if (o->when() & (FL_WHEN_CHANGED|FL_WHEN_RELEASE))
+	o->do_callback();
+    } else {
+      o->Fl_Widget::clear_changed();
+      if (o->when() & FL_WHEN_NOT_CHANGED)
+	o->do_callback();
+    }
+    
+    if (wp.deleted()) return;
+
+    if (o->callback() != default_callback)
+      o->Fl_Widget::clear_changed();
+  }
+
+  // Custom resize behavior -- input stretches, menu button doesn't
+  inline int inp_x() { return(x() + Fl::box_dx(box())); }
+  inline int inp_y() { return(y() + Fl::box_dy(box())); }
+  inline int inp_w() { return(w() - Fl::box_dw(box()) - 20); }
+  inline int inp_h() { return(h() - Fl::box_dh(box())); }
+
+  inline int menu_x() { return(x() + w() - 20 - Fl::box_dx(box())); }
+  inline int menu_y() { return(y() + Fl::box_dy(box())); }
+  inline int menu_w() { return(20); }
+  inline int menu_h() { return(h() - Fl::box_dh(box())); }
+
+public:
+  /**
+    Creates a new Fl_Input_Choice widget using the given position, size,
+    and label string.
+    Inherited destructor destroys the widget and any values associated with it.
+  */
+  Fl_Input_Choice(int X,int Y,int W,int H,const char*L=0);
+  
+  /** Adds an item to the menu.
+   You can access the more complex Fl_Menu_Button::add() methods 
+   (setting callbacks, userdata, etc), via menubutton(). Example:
+   \code
+   Fl_Input_Choice *choice = new Fl_Input_Choice(100,10,120,25,"Fonts");
+   Fl_Menu_Button *mb = choice->menubutton();             // use Fl_Input_Choice's Fl_Menu_Button
+   mb->add("Helvetica", 0, MyFont_CB,     (void*)mydata); // use Fl_Menu_Button's add() methods
+   mb->add("Courier",   0, MyFont_CB,     (void*)mydata);
+   mb->add("More..",    0, FontDialog_CB, (void*)mydata);
+   \endcode
+   */
+  void add(const char *s) { menu_->add(s);  }
+  /** Returns the combined changed() state of the input and menu button widget. */
+  int changed() const { return inp_->changed() | Fl_Widget::changed(); }
+  /** Clears the changed() state of both input and menu button widgets. */
+  void clear_changed() { 
+    inp_->clear_changed();
+    Fl_Widget::clear_changed();
+  }
+  /** Sets the changed() state of both input and menu button widgets
+   to the specfied value.*/
+  void set_changed() { 
+    inp_->set_changed();
+    // no need to call Fl_Widget::set_changed()
+  }
+  /** Removes all items from the menu. */
+  void clear() { menu_->clear(); }
+  /** Gets the box type of the menu button */
+  Fl_Boxtype down_box() const { return (menu_->down_box()); }
+  /** Sets the box type of the menu button */
+  void down_box(Fl_Boxtype b) { menu_->down_box(b); }
+  /** Gets the Fl_Menu_Item array used for the menu. */
+  const Fl_Menu_Item *menu() { return (menu_->menu()); }
+  /** Sets the Fl_Menu_Item array used for the menu. */
+  void menu(const Fl_Menu_Item *m) { menu_->menu(m); }
+  void resize(int X, int Y, int W, int H) {
+    Fl_Group::resize(X,Y,W,H);
+    inp_->resize(inp_x(), inp_y(), inp_w(), inp_h());
+    menu_->resize(menu_x(), menu_y(), menu_w(), menu_h());
+  }
+  /// Gets the Fl_Input text field's text color.
+  Fl_Color textcolor() const { return (inp_->textcolor());}
+  /// Sets the Fl_Input text field's text color to \p c.
+  void textcolor(Fl_Color c) { inp_->textcolor(c);}
+  /// Gets the Fl_Input text field's font style.
+  Fl_Font textfont() const { return (inp_->textfont());}
+  /// Sets the Fl_Input text field's font style to \p f.
+  void textfont(Fl_Font f) { inp_->textfont(f);}
+  /// Gets the Fl_Input text field's font size
+  Fl_Fontsize textsize() const { return (inp_->textsize()); }
+  /// Sets the Fl_Input text field's font size to \p s.
+  void textsize(Fl_Fontsize s) { inp_->textsize(s); }
+  /// Returns the Fl_Input text field's current contents.
+  const char* value() const { return (inp_->value()); }
+  /** Sets the Fl_Input text field's contents to \p val.
+   Does not affect the menu selection.*/
+  void value(const char *val) { inp_->value(val); }
+  /** Chooses item# \p val in the menu, and sets the Fl_Input text field
+   to that value. Any previous text is cleared.*/
+  void value(int val) {
+    menu_->value(val);
+    inp_->value(menu_->text(val));
+  }
+  /** Returns a pointer to the internal Fl_Menu_Button widget.
+   This can be used to access any of the methods of the menu button, e.g.
+   \code
+   Fl_Input_Choice *choice = new Fl_Input_Choice(100,10,120,25,"Choice:");
+   [..]
+   // Print all the items in the choice menu
+   for ( int t=0; t<choice->menubutton()->size(); t++ ) {
+       const Fl_Menu_Item &item = choice->menubutton()->menu()[t];
+       printf("item %d -- label=%s\n", t, item.label() ? item.label() : "(Null)");
+   }
+   \endcode
+  */
+  Fl_Menu_Button *menubutton() { return menu_; }
+  /** Returns a pointer to the internal Fl_Input widget.
+   This can be used to directly access all of the Fl_Input widget's
+   methods.*/
+  Fl_Input *input() { return inp_; }
+};
+
+#endif // !Fl_Input_Choice_H
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Int_Input.H

@@ -0,0 +1,46 @@
+//
+// "$Id$"
+//
+// Integer input header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Int_Input widget . */
+
+#ifndef Fl_Int_Input_H
+#define Fl_Int_Input_H
+
+#include "Fl_Input.H"
+
+/**
+  The Fl_Int_Input class is a subclass of Fl_Input that only allows
+  the user to type decimal digits (or hex numbers of the form 0xaef).
+*/
+class FL_EXPORT Fl_Int_Input : public Fl_Input {
+public:
+  /**
+    Creates a new Fl_Int_Input widget using the given position,
+    size, and label string. The default boxtype is FL_DOWN_BOX.
+
+    Inherited destructor destroys the widget and any value associated with it.
+  */
+  Fl_Int_Input(int X,int Y,int W,int H,const char *l = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_JPEG_Image.H

@@ -0,0 +1,44 @@
+//
+// "$Id$"
+//
+// JPEG image header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_JPEG_Image class . */
+
+#ifndef Fl_JPEG_Image_H
+#define Fl_JPEG_Image_H
+#  include "Fl_Image.H"
+
+/**
+ The Fl_JPEG_Image class supports loading, caching,
+ and drawing of Joint Photographic Experts Group (JPEG) File
+ Interchange Format (JFIF) images. The class supports grayscale
+ and color (RGB) JPEG image files.
+ */
+class FL_EXPORT Fl_JPEG_Image : public Fl_RGB_Image {
+
+public:
+
+  Fl_JPEG_Image(const char *filename);
+  Fl_JPEG_Image(const char *name, const unsigned char *data);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Light_Button.H

@@ -0,0 +1,50 @@
+//
+// "$Id$"
+//
+// Lighted button header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Light_Button widget . */
+
+#ifndef Fl_Light_Button_H
+#define Fl_Light_Button_H
+
+#include "Fl_Button.H"
+
+/**
+  This subclass displays the "on" state by turning on a light, 
+  rather than drawing pushed in.  The shape of the  "light" 
+  is initially set to FL_DOWN_BOX.  The color of the light when
+  on is controlled with selection_color(), which defaults to FL_YELLOW.
+
+  Buttons generate callbacks when they are clicked by the user.  You
+  control exactly when and how by changing the values for type() and when().
+  <P ALIGN=CENTER>\image html Fl_Light_Button.png</P> 
+  \image latex Fl_Light_Button.png "Fl_Light_Button" width=4cm
+*/
+class FL_EXPORT Fl_Light_Button : public Fl_Button {
+protected:
+    virtual void draw();
+public:
+    virtual int handle(int);
+    Fl_Light_Button(int x,int y,int w,int h,const char *l = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Line_Dial.H

@@ -0,0 +1,36 @@
+//
+// "$Id$"
+//
+// Line dial header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Line_Dial widget . */
+
+#ifndef Fl_Line_Dial_H
+#define Fl_Line_Dial_H
+
+#include "Fl_Dial.H"
+
+class FL_EXPORT Fl_Line_Dial : public Fl_Dial {
+public:
+  Fl_Line_Dial(int X,int Y,int W,int H, const char *L = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Menu.H

@@ -0,0 +1,24 @@
+//
+// "$Id$"
+//
+// Old menu header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+// this include file is for back compatibility only
+#include "Fl_Menu_Item.H"
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Menu_.H

@@ -0,0 +1,188 @@
+//
+// "$Id$"
+//
+// Menu base class header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2016 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Menu_ widget . */
+
+#ifndef Fl_Menu__H
+#define Fl_Menu__H
+
+#ifndef Fl_Widget_H
+#include "Fl_Widget.H"
+#endif
+#include "Fl_Menu_Item.H"
+
+/**
+  Base class of all widgets that have a menu in FLTK.
+
+  Currently FLTK provides you with Fl_Menu_Button, Fl_Menu_Bar, and Fl_Choice.
+
+  The class contains a pointer to an array of structures of type Fl_Menu_Item.
+  The array may either be supplied directly by the user program, or it may
+  be "private": a dynamically allocated array managed by the Fl_Menu_.
+
+  When the user clicks a menu item, value() is set to that item
+  and then:
+
+    - If the Fl_Menu_Item has a callback set, that callback
+      is invoked with any userdata configured for it.
+      (The Fl_Menu_ widget's callback is NOT invoked.)
+
+    - For any Fl_Menu_Items that \b don't have a callback set,
+      the Fl_Menu_ widget's callback is invoked with any userdata
+      configured for it. The callback can determine which item
+      was picked using value(), mvalue(), item_pathname(), etc.
+*/
+class FL_EXPORT Fl_Menu_ : public Fl_Widget {
+
+  Fl_Menu_Item *menu_;
+  const Fl_Menu_Item *value_;
+
+protected:
+
+  uchar alloc;			// flag indicates if menu_ is a dynamic copy (=1) or not (=0)
+  uchar down_box_;
+  Fl_Font textfont_;
+  Fl_Fontsize textsize_;
+  Fl_Color textcolor_;
+
+  int item_pathname_(char *name, int namelen, const Fl_Menu_Item *finditem,
+                     const Fl_Menu_Item *menu=0) const;
+public:
+  Fl_Menu_(int,int,int,int,const char * =0);
+  ~Fl_Menu_();
+
+  int item_pathname(char *name, int namelen, const Fl_Menu_Item *finditem=0) const;
+  const Fl_Menu_Item* picked(const Fl_Menu_Item*);
+  const Fl_Menu_Item* find_item(const char *name);
+  const Fl_Menu_Item* find_item(Fl_Callback*);
+  int find_index(const char *name) const;
+  int find_index(const Fl_Menu_Item *item) const;
+  int find_index(Fl_Callback *cb) const;
+
+  /**
+    Returns the menu item with the entered shortcut (key value).
+
+    This searches the complete menu() for a shortcut that matches the
+    entered key value.  It must be called for a FL_KEYBOARD or FL_SHORTCUT
+    event.
+
+    If a match is found, the menu's callback will be called.
+
+    \return matched Fl_Menu_Item or NULL.
+  */
+  const Fl_Menu_Item* test_shortcut() {return picked(menu()->test_shortcut());}
+  void global();
+
+  /**
+    Returns a pointer to the array of Fl_Menu_Items.  This will either be
+    the value passed to menu(value) or the private copy.
+    \sa size() -- returns the size of the Fl_Menu_Item array.
+
+    \b Example: How to walk the array:
+    \code
+    for ( int t=0; t<menubar->size(); t++ ) {                // walk array of items
+        const Fl_Menu_Item &item = menubar->menu()[t];       // get each item
+        fprintf(stderr, "item #%d -- label=%s, value=%s type=%s\n",
+            t,
+            item.label() ? item.label() : "(Null)",          // menu terminators have NULL labels
+            (item.flags & FL_MENU_VALUE) ? "set" : "clear",  // value of toggle or radio items
+            (item.flags & FL_SUBMENU) ? "Submenu" : "Item"); // see if item is a submenu or actual item
+    }
+    \endcode
+
+  */
+  const Fl_Menu_Item *menu() const {return menu_;}
+  void menu(const Fl_Menu_Item *m);
+  void copy(const Fl_Menu_Item *m, void* user_data = 0);
+  int insert(int index, const char*, int shortcut, Fl_Callback*, void* = 0, int = 0);
+  int  add(const char*, int shortcut, Fl_Callback*, void* = 0, int = 0); // see src/Fl_Menu_add.cxx
+  /** See int Fl_Menu_::add(const char* label, int shortcut, Fl_Callback*, void *user_data=0, int flags=0) */
+  int  add(const char* a, const char* b, Fl_Callback* c, void* d = 0, int e = 0) {
+      return add(a,fl_old_shortcut(b),c,d,e);
+  }
+  /** See int Fl_Menu_::insert(const char* label, int shortcut, Fl_Callback*, void *user_data=0, int flags=0) */
+  int insert(int index, const char* a, const char* b, Fl_Callback* c, void* d = 0, int e = 0) {
+      return insert(index,a,fl_old_shortcut(b),c,d,e);
+  }
+  int  add(const char *);
+  int  size() const ;
+  void size(int W, int H) { Fl_Widget::size(W, H); }
+  void clear();
+  int clear_submenu(int index);
+  void replace(int,const char *);
+  void remove(int);
+  /** Changes the shortcut of item \p i to \p s. */
+  void shortcut(int i, int s) {menu_[i].shortcut(s);}
+  /** Sets the flags of item i.  For a list of the flags, see Fl_Menu_Item.  */
+  void mode(int i,int fl) {menu_[i].flags = fl;}
+  /** Gets the flags of item i.  For a list of the flags, see Fl_Menu_Item.  */
+  int  mode(int i) const {return menu_[i].flags;}
+
+  /** Returns a pointer to the last menu item that was picked.  */
+  const Fl_Menu_Item *mvalue() const {return value_;}
+  /** Returns the index into menu() of the last item chosen by the user.  It is zero initially. */
+  int value() const {return value_ ? (int)(value_-menu_) : -1;}
+  int value(const Fl_Menu_Item*);
+  /**
+    The value is the index into menu() of the last item chosen by
+    the user.  It is zero initially.  You can set it as an integer, or set
+    it with a pointer to a menu item.  The set routines return non-zero if
+    the new value is different than the old one.
+  */
+  int value(int i) {return value(menu_+i);}
+  /** Returns the title of the last item chosen.  */
+  const char *text() const {return value_ ? value_->text : 0;}
+  /** Returns the title of item i.  */
+  const char *text(int i) const {return menu_[i].text;}
+
+  /** Gets the current font of menu item labels.  */
+  Fl_Font textfont() const {return textfont_;}
+  /**  Sets the current font of menu item labels.  */
+  void textfont(Fl_Font c) {textfont_=c;}
+  /**  Gets the font size of menu item labels.  */
+  Fl_Fontsize textsize() const {return textsize_;}
+  /**  Sets the font size of menu item labels.  */
+  void textsize(Fl_Fontsize c) {textsize_=c;}
+  /** Get the current color of menu item labels.  */
+  Fl_Color textcolor() const {return textcolor_;}
+  /** Sets the current color of menu item labels. */
+  void textcolor(Fl_Color c) {textcolor_=c;}
+
+  /**
+    This box type is used to surround the currently-selected items in the
+    menus.  If this is FL_NO_BOX then it acts like
+    FL_THIN_UP_BOX and selection_color() acts like
+    FL_WHITE, for back compatibility.
+  */
+  Fl_Boxtype down_box() const {return (Fl_Boxtype)down_box_;}
+  /**    See Fl_Boxtype Fl_Menu_::down_box() const   */
+  void down_box(Fl_Boxtype b) {down_box_ = b;}
+
+  /** For back compatibility, same as selection_color() */
+  Fl_Color down_color() const {return selection_color();}
+  /** For back compatibility, same as selection_color() */
+  void down_color(unsigned c) {selection_color(c);}
+  void setonly(Fl_Menu_Item* item);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Menu_Bar.H

@@ -0,0 +1,97 @@
+//
+// "$Id$"
+//
+// Menu bar header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2016 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Menu_Bar widget . */
+
+#ifndef Fl_Menu_Bar_H
+#define Fl_Menu_Bar_H
+
+#include "Fl_Menu_.H"
+
+/**
+  This widget provides a standard menubar interface.  Usually you will
+  put this widget along the top edge of your window.  The height of the
+  widget should be 30 for the menu titles to draw correctly with the
+  default font.
+
+  The items on the bar and the menus they bring up are defined by a
+  single Fl_Menu_Item array.
+  Because a Fl_Menu_Item array defines a hierarchy, the
+  top level menu defines the items in the menubar, while the submenus
+  define the pull-down menus. Sub-sub menus and lower pop up to the right
+  of the submenus.
+
+  \image html  menubar.png
+  \image latex  menubar.png " menubar" width=12cm
+
+  If there is an item in the top menu that is not a title of a
+  submenu, then it acts like a "button" in the menubar.  Clicking on it
+  will pick it.
+
+  When the user clicks a menu item, value() is set to that item
+  and then:
+
+    - The item's callback is done if one has been set; the
+      Fl_Menu_Bar is passed as the Fl_Widget* argument,
+      along with any userdata configured for the callback.
+
+    - If the item does not have a callback, the Fl_Menu_Bar's callback
+      is done instead, along with any userdata configured for the callback.
+      The callback can determine which item was picked using
+      value(), mvalue(), item_pathname(), etc.
+
+  Submenus will also pop up in response to shortcuts indicated by
+  putting a '&' character in the name field of the menu item. If you put a
+  '&' character in a top-level "button" then the shortcut picks it.  The
+  '&' character in submenus is ignored until the menu is popped up.
+
+  Typing the shortcut() of any of the menu items will cause
+  callbacks exactly the same as when you pick the item with the mouse.
+*/
+class FL_EXPORT Fl_Menu_Bar : public Fl_Menu_ {
+protected:
+    void draw();
+public:
+    int handle(int);
+  /**
+    Creates a new Fl_Menu_Bar widget using the given position,
+    size, and label string. The default boxtype is FL_UP_BOX.
+
+    The constructor sets menu() to NULL.  See
+    Fl_Menu_ for the methods to set or change the menu.
+
+    labelsize(), labelfont(), and labelcolor()
+    are used to control how the menubar items are drawn.  They are
+    initialized from the Fl_Menu static variables, but you can
+    change them if desired.
+
+    label() is ignored unless you change align() to
+    put it outside the menubar.
+
+    The destructor removes the Fl_Menu_Bar widget and all of its
+    menu items.
+  */
+  Fl_Menu_Bar(int X, int Y, int W, int H, const char *l=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Menu_Button.H

@@ -0,0 +1,85 @@
+//
+// "$Id$"
+//
+// Menu button header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Menu_Button widget . */
+
+#ifndef Fl_Menu_Button_H
+#define Fl_Menu_Button_H
+
+#include "Fl_Menu_.H"
+
+/**
+  This is a button that when pushed pops up a menu (or hierarchy of
+  menus) defined by an array of 
+  Fl_Menu_Item objects.
+  <P ALIGN=CENTER>\image html  menu_button.png</P>
+  \image latex  menu_button.png " menu_button" width=5cm
+  <P>Normally any mouse button will pop up a menu and it is lined up
+  below the button as shown in the picture.  However an Fl_Menu_Button
+  may also control a pop-up menu.  This is done by setting the type().
+  If type() is zero a normal menu button is produced. 
+  If it is nonzero then this is a pop-up menu. The bits in type() indicate 
+  what mouse buttons pop up the menu (see Fl_Menu_Button::popup_buttons). </P>
+  <P>The menu will also pop up in response to shortcuts indicated by
+  putting a '&' character in the label(). </P>
+  <P>Typing the shortcut() of any of the menu items will cause
+  callbacks exactly the same as when you pick the item with the mouse.
+  The '&' character in menu item names are only looked at when the menu is
+  popped up, however. </P>
+
+  When the user clicks a menu item, value() is set to that item
+  and then:
+
+      - The item's callback is done if one has been set; the
+        Fl_Menu_Button is passed as the Fl_Widget* argument, 
+        along with any userdata configured for the callback.
+
+      - If the item does not have a callback, the Fl_Menu_Button's callback
+        is done instead, along with any userdata configured for it.
+        The callback can determine which item was picked using
+        value(), mvalue(), item_pathname(), etc.
+*/
+class FL_EXPORT Fl_Menu_Button : public Fl_Menu_ {
+protected:
+  void draw();
+public:
+  /**
+   \brief indicate what mouse buttons pop up the menu.
+   
+   Values for type() used to indicate what mouse buttons pop up the menu. 
+   Fl_Menu_Button::POPUP3 is usually what you want.
+   */  
+  enum popup_buttons {POPUP1 = 1, /**< pops up with the mouse 1st button. */
+    POPUP2,  /**< pops up with the mouse 2nd button. */
+    POPUP12, /**< pops up with the mouse 1st or 2nd buttons. */
+    POPUP3,   /**< pops up with the mouse 3rd button. */
+    POPUP13,  /**< pops up with the mouse 1st or 3rd buttons. */
+    POPUP23,  /**< pops up with the mouse 2nd or 3rd buttons. */
+    POPUP123 /**< pops up with any mouse button. */
+  };
+  int handle(int);
+  const Fl_Menu_Item* popup();
+  Fl_Menu_Button(int,int,int,int,const char * =0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Menu_Item.H

@@ -0,0 +1,443 @@
+//
+// "$Id$"
+//
+// Menu item header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+#ifndef Fl_Menu_Item_H
+#define Fl_Menu_Item_H
+
+#  include "Fl_Widget.H"
+#  include "Fl_Image.H"
+
+#  if defined(__APPLE__) && defined(check)
+#    undef check
+#  endif
+
+// doxygen needs the following line to enable e.g. ::FL_MENU_TOGGLE to link to the enums
+/// @file
+
+enum { // values for flags:
+  FL_MENU_INACTIVE = 1,		///< Deactivate menu item (gray out)
+  FL_MENU_TOGGLE= 2,		///< Item is a checkbox toggle (shows checkbox for on/off state)
+  FL_MENU_VALUE = 4,		///< The on/off state for checkbox/radio buttons (if set, state is 'on')
+  FL_MENU_RADIO = 8,		///< Item is a radio button (one checkbox of many can be on)
+  FL_MENU_INVISIBLE = 0x10,	///< Item will not show up (shortcut will work)
+  FL_SUBMENU_POINTER = 0x20,	///< Indicates user_data() is a pointer to another menu array
+  FL_SUBMENU = 0x40,		///< This item is a submenu to other items
+  FL_MENU_DIVIDER = 0x80,	///< Creates divider line below this item. Also ends a group of radio buttons.
+  FL_MENU_HORIZONTAL = 0x100	///< ??? -- reserved
+};
+
+extern FL_EXPORT Fl_Shortcut fl_old_shortcut(const char*);
+
+class Fl_Menu_;
+
+/**
+  The Fl_Menu_Item structure defines a single menu item that
+  is used by the Fl_Menu_ class.  
+  \code
+  struct Fl_Menu_Item {
+   const char*   text;     // label()
+   ulong         shortcut_;
+   Fl_Callback*  callback_;
+   void*         user_data_;
+   int           flags;
+   uchar         labeltype_;
+   uchar         labelfont_;
+   uchar         labelsize_;
+   uchar         labelcolor_;
+  };
+  
+  enum { // values for flags:
+   FL_MENU_INACTIVE   = 1,      // Deactivate menu item (gray out)
+   FL_MENU_TOGGLE     = 2,      // Item is a checkbox toggle (shows checkbox for on/off state)
+   FL_MENU_VALUE      = 4,      // The on/off state for checkbox/radio buttons (if set, state is 'on')
+   FL_MENU_RADIO      = 8,      // Item is a radio button (one checkbox of many can be on)
+   FL_MENU_INVISIBLE  = 0x10,   // Item will not show up (shortcut will work)
+   FL_SUBMENU_POINTER = 0x20,   // Indicates user_data() is a pointer to another menu array
+   FL_SUBMENU         = 0x40,   // This item is a submenu to other items
+   FL_MENU_DIVIDER    = 0x80,   // Creates divider line below this item. Also ends a group of radio buttons.
+   FL_MENU_HORIZONTAL = 0x100   // ??? -- reserved
+  };
+  \endcode
+  Typically menu items are statically defined; for example:
+  \code
+  Fl_Menu_Item popup[] = {
+   {"&alpha",    FL_ALT+'a', the_cb, (void*)1},
+   {"&beta",     FL_ALT+'b', the_cb, (void*)2},
+   {"gamma",     FL_ALT+'c', the_cb, (void*)3, FL_MENU_DIVIDER},
+   {"&strange",  0,          strange_cb},
+   {"&charm",    0,          charm_cb},
+   {"&truth",    0,          truth_cb},
+   {"b&eauty",   0,          beauty_cb},
+   {"sub&menu",  0,          0, 0, FL_SUBMENU},
+   {"one"},
+   {"two"},
+   {"three"},
+   {0},
+   {"inactive", FL_ALT+'i', 0, 0, FL_MENU_INACTIVE|FL_MENU_DIVIDER},
+   {"invisible",FL_ALT+'i', 0, 0, FL_MENU_INVISIBLE},
+   {"check",    FL_ALT+'i', 0, 0, FL_MENU_TOGGLE|FL_MENU_VALUE},
+   {"box",      FL_ALT+'i', 0, 0, FL_MENU_TOGGLE},
+   {0}};
+  \endcode
+  produces:
+
+  \image html   menu.png
+  \image latex  menu.png "menu" width=10cm
+
+  A submenu title is identified by the bit FL_SUBMENU in the 
+  flags field, and ends with a label() that is NULL.
+  You can nest menus to any depth.  A pointer to the first item in the
+  submenu can be treated as an Fl_Menu array itself.  It is also
+  possible to make separate submenu arrays with FL_SUBMENU_POINTER flags.
+
+  You should use the method functions to access structure members and
+  not access them directly to avoid compatibility problems with future
+  releases of FLTK.
+*/
+struct FL_EXPORT Fl_Menu_Item {
+  const char *text;	    ///< menu item text, returned by label()
+  int shortcut_;	    ///< menu item shortcut
+  Fl_Callback *callback_;   ///< menu item callback
+  void *user_data_;	    ///< menu item user_data for the menu's callback
+  int flags;		    ///< menu item flags like FL_MENU_TOGGLE, FL_MENU_RADIO
+  uchar labeltype_;	    ///< how the menu item text looks like
+  Fl_Font labelfont_;	    ///< which font for this menu item text
+  Fl_Fontsize labelsize_;   ///< size of menu item text
+  Fl_Color labelcolor_;	    ///< menu item text color
+
+  // advance N items, skipping submenus:
+  const Fl_Menu_Item *next(int=1) const;
+
+  /**
+    Advances a pointer by n items through a menu array, skipping
+    the contents of submenus and invisible items. There are two calls so
+    that you can advance through const and non-const data.
+  */
+  Fl_Menu_Item *next(int i=1) {
+    return (Fl_Menu_Item*)(((const Fl_Menu_Item*)this)->next(i));}
+
+  /** Returns the first menu item, same as next(0). */
+  const Fl_Menu_Item *first() const { return next(0); }
+
+  /** Returns the first menu item, same as next(0). */
+  Fl_Menu_Item *first() { return next(0); }
+
+  // methods on menu items:
+  /**
+    Returns the title of the item.
+    A NULL here indicates the end of the menu (or of a submenu).
+    A '&' in the item will print an underscore under the next letter,
+    and if the menu is popped up that letter will be a "shortcut" to pick
+    that item.  To get a real '&' put two in a row.
+  */
+  const char* label() const {return text;}
+
+  /**    See const char* Fl_Menu_Item::label() const   */
+  void label(const char* a) {text=a;}
+
+  /**    See const char* Fl_Menu_Item::label() const   */
+  void label(Fl_Labeltype a,const char* b) {labeltype_ = a; text = b;}
+
+  /**
+    Returns the menu item's labeltype.
+    A labeltype identifies a routine that draws the label of the
+    widget.  This can be used for special effects such as emboss, or to use
+    the label() pointer as another form of data such as a bitmap.
+    The value FL_NORMAL_LABEL prints the label as text.
+  */
+  Fl_Labeltype labeltype() const {return (Fl_Labeltype)labeltype_;}
+
+  /**
+    Sets the menu item's labeltype.
+    A labeltype identifies a routine that draws the label of the
+    widget.  This can be used for special effects such as emboss, or to use
+    the label() pointer as another form of data such as a bitmap.
+    The value FL_NORMAL_LABEL prints the label as text.
+  */
+  void labeltype(Fl_Labeltype a) {labeltype_ = a;}
+
+  /**
+    Gets the menu item's label color.
+    This color is passed to the labeltype routine, and is typically the
+    color of the label text.  This defaults to FL_BLACK.  If this
+    color is not black fltk will \b not use overlay bitplanes to draw
+    the menu - this is so that images put in the menu draw correctly.
+  */
+  Fl_Color labelcolor() const {return labelcolor_;}
+
+  /**
+    Sets the menu item's label color.
+    \see Fl_Color Fl_Menu_Item::labelcolor() const
+  */
+  void labelcolor(Fl_Color a) {labelcolor_ = a;}
+  /**
+    Gets the menu item's label font.
+    Fonts are identified by small 8-bit indexes into a table. See the
+    enumeration list for predefined fonts. The default value is a
+    Helvetica font. The function Fl::set_font() can define new fonts.
+  */
+  Fl_Font labelfont() const {return labelfont_;}
+
+  /**
+    Sets the menu item's label font.
+    Fonts are identified by small 8-bit indexes into a table. See the
+    enumeration list for predefined fonts. The default value is a
+    Helvetica font.  The function Fl::set_font() can define new fonts.
+  */
+  void labelfont(Fl_Font a) {labelfont_ = a;}
+
+  /** Gets the label font pixel size/height. */
+  Fl_Fontsize labelsize() const {return labelsize_;}
+
+  /** Sets the label font pixel size/height.*/
+  void labelsize(Fl_Fontsize a) {labelsize_ = a;}
+
+  /**
+    Returns the callback function that is set for the menu item.
+    Each item has space for a callback function and an argument for that
+    function. Due to back compatibility, the Fl_Menu_Item itself
+    is not passed to the callback, instead you have to get it by calling
+    ((Fl_Menu_*)w)->mvalue() where w is the widget argument.
+  */
+  Fl_Callback_p callback() const {return callback_;}
+
+  /**
+    Sets the menu item's callback function and userdata() argument.
+    \see Fl_Callback_p Fl_MenuItem::callback() const
+  */
+  void callback(Fl_Callback* c, void* p) {callback_=c; user_data_=p;}
+
+  /**
+    Sets the menu item's callback function.
+    This method does not set the userdata() argument.
+    \see Fl_Callback_p Fl_MenuItem::callback() const
+   */
+  void callback(Fl_Callback* c) {callback_=c;}
+
+  /**
+    Sets the menu item's callback function.
+    This method does not set the userdata() argument.
+    \see Fl_Callback_p Fl_MenuItem::callback() const
+   */
+  void callback(Fl_Callback0*c) {callback_=(Fl_Callback*)c;}
+
+  /**
+    Sets the menu item's callback function and userdata() argument.
+    This method does not set the userdata() argument.
+    The argument \p is cast to void* and stored as the userdata()
+    for the menu item's callback function.
+    \see Fl_Callback_p Fl_MenuItem::callback() const
+   */
+  void callback(Fl_Callback1*c, long p=0) {callback_=(Fl_Callback*)c; user_data_=(void*)(fl_intptr_t)p;}
+
+  /**
+    Gets the user_data() argument that is sent to the callback function.
+  */
+  void* user_data() const {return user_data_;}
+  /**
+    Sets the user_data() argument that is sent to the callback function.
+  */
+  void user_data(void* v) {user_data_ = v;}
+  /**
+    Gets the user_data() argument that is sent to the callback function.
+    For convenience you can also define the callback as taking a long
+    argument.  This method casts the stored userdata() argument to long
+    and returns it as a \e long value.
+  */
+  long argument() const {return (long)(fl_intptr_t)user_data_;}
+  /**
+    Sets the user_data() argument that is sent to the callback function.
+    For convenience you can also define the callback as taking a long
+    argument.  This method casts the given argument \p v to void*
+    and stores it in the menu item's userdata() member.
+    This may not be portable to some machines.
+  */
+  void argument(long v) {user_data_ = (void*)(fl_intptr_t)v;}
+
+  /** Gets what key combination shortcut will trigger the menu item. */
+  int shortcut() const {return shortcut_;}
+
+  /**
+    Sets exactly what key combination will trigger the menu item.  The
+    value is a logical 'or' of a key and a set of shift flags, for instance 
+    FL_ALT+'a' or FL_ALT+FL_F+10 or just 'a'.  A value of
+    zero disables the shortcut.
+
+    The key can be any value returned by Fl::event_key(), but will usually 
+    be an ASCII letter. Use a lower-case letter unless you require the shift 
+    key to be held down.
+
+    The shift flags can be any set of values accepted by Fl::event_state().
+    If the bit is on that shift key must be pushed.  Meta, Alt, Ctrl, 
+    and Shift must be off if they are not in the shift flags (zero for the 
+    other bits indicates a "don't care" setting).
+  */
+  void shortcut(int s) {shortcut_ = s;}
+  /**
+    Returns true if either FL_SUBMENU or FL_SUBMENU_POINTER
+    is on in the flags. FL_SUBMENU indicates an embedded submenu
+    that goes from the next item through the next one with a NULL
+    label(). FL_SUBMENU_POINTER indicates that user_data()
+    is a pointer to another menu array.
+  */
+  int submenu() const {return flags&(FL_SUBMENU|FL_SUBMENU_POINTER);}
+  /**
+    Returns true if a checkbox will be drawn next to this item.
+    This is true if FL_MENU_TOGGLE or FL_MENU_RADIO is set in the flags.
+  */
+  int checkbox() const {return flags&FL_MENU_TOGGLE;}
+  /**
+    Returns true if this item is a radio item.
+    When a radio button is selected all "adjacent" radio buttons are
+    turned off.  A set of radio items is delimited by an item that has
+    radio() false, or by an item with FL_MENU_DIVIDER turned on.
+  */
+  int radio() const {return flags&FL_MENU_RADIO;}
+  /** Returns the current value of the check or radio item.
+      This is zero (0) if the menu item is not checked and
+      non-zero otherwise. You should not rely on a particular value,
+      only zero or non-zero.
+      \note The returned value for a checked menu item as of FLTK 1.3.2
+      is FL_MENU_VALUE (4), but may be 1 in a future version.
+  */
+  int value() const {return flags&FL_MENU_VALUE;}
+  /**
+    Turns the check or radio item "on" for the menu item. Note that this
+    does not turn off any adjacent radio items like set_only() does.
+  */
+  void set() {flags |= FL_MENU_VALUE;}
+
+  /** Turns the check or radio item "off" for the menu item. */
+  void clear() {flags &= ~FL_MENU_VALUE;}
+
+  void setonly();
+
+  /** Gets the visibility of an item. */
+  int visible() const {return !(flags&FL_MENU_INVISIBLE);}
+
+  /** Makes an item visible in the menu. */
+  void show() {flags &= ~FL_MENU_INVISIBLE;}
+
+  /** Hides an item in the menu. */
+  void hide() {flags |= FL_MENU_INVISIBLE;}
+
+  /** Gets whether or not the item can be picked. */
+  int active() const {return !(flags&FL_MENU_INACTIVE);}
+
+  /** Allows a menu item to be picked. */
+  void activate() {flags &= ~FL_MENU_INACTIVE;}
+  /**
+    Prevents a menu item from being picked. Note that this will also cause
+    the menu item to appear grayed-out.
+  */
+  void deactivate() {flags |= FL_MENU_INACTIVE;}
+  /** Returns non 0 if FL_INACTIVE and FL_INVISIBLE are cleared, 0 otherwise. */
+  int activevisible() const {return !(flags & (FL_MENU_INACTIVE|FL_MENU_INVISIBLE));}
+
+  // compatibility for FLUID so it can set the image of a menu item...
+
+  /** compatibility api for FLUID, same as a->label(this) */
+  void image(Fl_Image* a) {a->label(this);}
+
+  /** compatibility api for FLUID, same as a.label(this) */
+  void image(Fl_Image& a) {a.label(this);}
+
+  // used by menubar:
+  int measure(int* h, const Fl_Menu_*) const;
+  void draw(int x, int y, int w, int h, const Fl_Menu_*, int t=0) const;
+
+  // popup menus without using an Fl_Menu_ widget:
+  const Fl_Menu_Item* popup(
+    int X, int Y,
+    const char *title = 0,
+    const Fl_Menu_Item* picked=0,
+    const Fl_Menu_* = 0) const;
+  const Fl_Menu_Item* pulldown(
+    int X, int Y, int W, int H,
+    const Fl_Menu_Item* picked = 0,
+    const Fl_Menu_* = 0,
+    const Fl_Menu_Item* title = 0,
+    int menubar=0) const;
+  const Fl_Menu_Item* test_shortcut() const;
+  const Fl_Menu_Item* find_shortcut(int *ip=0, const bool require_alt = false) const;
+
+  /**
+    Calls the Fl_Menu_Item item's callback, and provides the Fl_Widget argument.
+    The callback is called with the stored user_data() as its second argument.
+    You must first check that callback() is non-zero before calling this.
+  */
+  void do_callback(Fl_Widget* o) const {callback_(o, user_data_);}
+
+  /**
+    Calls the Fl_Menu_Item item's callback, and provides the Fl_Widget argument.
+    This call overrides the callback's second argument with the given value \p arg.
+    You must first check that callback() is non-zero before calling this.
+  */
+  void do_callback(Fl_Widget* o,void* arg) const {callback_(o, arg);}
+
+  /**
+    Calls the Fl_Menu_Item item's callback, and provides the Fl_Widget argument.
+    This call overrides the callback's second argument with the
+    given value \p arg. long \p arg is cast to void* when calling
+    the callback.
+    You must first check that callback() is non-zero before calling this.
+  */
+  void do_callback(Fl_Widget* o,long arg) const {callback_(o, (void*)(fl_intptr_t)arg);}
+
+  // back-compatibility, do not use:
+
+  /** back compatibility only \deprecated. */
+  int checked() const {return flags&FL_MENU_VALUE;}
+
+  /** back compatibility only \deprecated. */
+  void check() {flags |= FL_MENU_VALUE;}
+
+  /** back compatibility only \deprecated. */
+  void uncheck() {flags &= ~FL_MENU_VALUE;}
+
+  int insert(int,const char*,int,Fl_Callback*,void* =0, int =0);
+  int add(const char*, int shortcut, Fl_Callback*, void* =0, int = 0);
+
+  /** See int add(const char*, int shortcut, Fl_Callback*, void*, int) */
+  int add(const char*a, const char* b, Fl_Callback* c,
+	  void* d = 0, int e = 0) {
+    return add(a,fl_old_shortcut(b),c,d,e);}
+
+  int size() const ;
+};
+
+typedef Fl_Menu_Item Fl_Menu; // back compatibility
+
+enum {	// back-compatibility enum:
+  FL_PUP_NONE	= 0,
+  FL_PUP_GREY	= FL_MENU_INACTIVE,
+  FL_PUP_GRAY	= FL_MENU_INACTIVE,
+  FL_MENU_BOX	= FL_MENU_TOGGLE,
+  FL_PUP_BOX	= FL_MENU_TOGGLE,
+  FL_MENU_CHECK	= FL_MENU_VALUE,
+  FL_PUP_CHECK	= FL_MENU_VALUE,
+  FL_PUP_RADIO	= FL_MENU_RADIO,
+  FL_PUP_INVISIBLE = FL_MENU_INVISIBLE,
+  FL_PUP_SUBMENU = FL_SUBMENU_POINTER
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Menu_Window.H

@@ -0,0 +1,57 @@
+//
+// "$Id$"
+//
+// Menu window header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Menu_Window widget . */
+
+#ifndef Fl_Menu_Window_H
+#define Fl_Menu_Window_H
+
+#include "Fl_Single_Window.H"
+
+/**
+  The Fl_Menu_Window widget is a window type used for menus. By
+  default the window is drawn in the hardware overlay planes if they are
+  available so that the menu don't force the rest of the window to
+  redraw.
+*/
+class FL_EXPORT Fl_Menu_Window : public Fl_Single_Window {
+public:
+  void show();
+  void erase();
+  void flush();
+  void hide();
+  /** Tells if hardware overlay mode is set */
+  unsigned int overlay() {return !(flags()&NO_OVERLAY);}
+  /** Tells FLTK to use hardware overlay planes if they are available.  */
+  void set_overlay() {clear_flag(NO_OVERLAY);}
+  /** Tells FLTK to use normal drawing planes instead of overlay planes.
+      This is usually necessary if your menu contains multi-color pixmaps. */
+  void clear_overlay() {set_flag(NO_OVERLAY);}
+  ~Fl_Menu_Window();
+  /** Creates a new Fl_Menu_Window widget using the given size, and label string. */
+  Fl_Menu_Window(int W, int H, const char *l = 0);
+  /** Creates a new Fl_Menu_Window widget using the given position, size, and label string. */
+  Fl_Menu_Window(int X, int Y, int W, int H, const char *l = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Multi_Browser.H

@@ -0,0 +1,54 @@
+//
+// "$Id$"
+//
+// Multi browser header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Multi_Browser widget . */
+
+#ifndef Fl_Multi_Browser_H
+#define Fl_Multi_Browser_H
+
+#include "Fl_Browser.H"
+
+/**
+  The Fl_Multi_Browser class is a subclass of Fl_Browser
+  which lets the user select any set of the lines.  The user interface
+  is Macintosh style: clicking an item turns off all the others and
+  selects that one, dragging selects all the items the mouse moves over,
+  and ctrl + click (Cmd+click on the Mac OS platform) toggles the items.  
+  Shift + click extends the selection until the clicked item.
+  This is different from how forms did it.  
+  Normally the callback is done when the user releases the
+  mouse, but you can change this with when().
+  <P>See Fl_Browser for methods to add and remove lines from the browser.
+*/
+class FL_EXPORT Fl_Multi_Browser : public Fl_Browser {
+public:
+  /**
+      Creates a new Fl_Multi_Browser widget using the given
+    position, size, and label string. The default boxtype is FL_DOWN_BOX.
+    The constructor specializes Fl_Browser() by setting the type to FL_MULTI_BROWSER.
+    The destructor destroys the widget and frees all memory that has been allocated.
+  */
+    Fl_Multi_Browser(int X,int Y,int W,int H,const char *L=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Multi_Label.H

@@ -0,0 +1,78 @@
+//
+// "$Id$"
+//
+// Multi-label header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2015 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+#ifndef Fl_Multi_Label_H
+#define Fl_Multi_Label_H
+
+class Fl_Widget;
+struct Fl_Menu_Item;
+
+/** This struct allows multiple labels to be added to objects that might normally have only one label.
+
+    This struct allows a mixed text and/or graphics label to be applied to an object that
+    would normally only have a single (usually text only) label.
+
+    Most regular FLTK widgets now support the ability to associate both images and text
+    with a label but some special cases, notably the non-widget Fl_Menu_Item objects, do not.
+    Fl_Multi_Label may be used to create menu items that have an icon and text, which would
+    not normally be possible for an Fl_Menu_Item.
+    For example, Fl_Multi_Label is used in the New->Code submenu in fluid, and others.
+
+    Each Fl_Multi_Label holds two elements, labela and labelb; each may hold either a
+    text label (const char*) or an image (Fl_Image*). When displayed, labela is drawn first
+    and labelb is drawn immediately to its right.
+
+    More complex labels might be constructed by setting labelb as another Fl_Multi_Label and
+    thus chaining up a series of label elements.
+
+    When assigning a label element to one of labela or labelb, they should be explicitly cast
+    to (const char*) if they are not of that type already.
+
+    \see Fl_Label and Fl_Labeltype
+ */
+struct FL_EXPORT Fl_Multi_Label {
+  /** Holds the "leftmost" of the two elements in the composite label.
+      Typically this would be assigned either a text string (const char*),
+      a (Fl_Image*) or a (Fl_Multi_Label*). */
+  const char* labela;
+  /** Holds the "rightmost" of the two elements in the composite label.
+      Typically this would be assigned either a text string (const char*),
+      a (Fl_Image*) or a (Fl_Multi_Label*). */
+  const char* labelb;
+  /** Holds the "type" of labela.
+    Typically this is set to FL_NORMAL_LABEL for a text label,
+    _FL_IMAGE_LABEL for an image (based on Fl_image) or _FL_MULTI_LABEL
+    if "chaining" multiple Fl_Multi_Label elements together. */
+  uchar typea;
+  /** Holds the "type" of labelb.
+    Typically this is set to FL_NORMAL_LABEL for a text label,
+    _FL_IMAGE_LABEL for an image (based on Fl_image) or _FL_MULTI_LABEL
+    if "chaining" multiple Fl_Multi_Label elements together. */
+  uchar typeb;
+
+  /** This method is used to associate a Fl_Multi_Label with a Fl_Widget. */
+  void label(Fl_Widget*);
+  /** This method is used to associate a Fl_Multi_Label with a Fl_Menu_Item. */
+  void label(Fl_Menu_Item*);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Multiline_Input.H

@@ -0,0 +1,60 @@
+//
+// "$Id$"
+//
+// Multiline input header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Multiline_Input widget . */ 
+
+#ifndef Fl_Multiline_Input_H
+#define Fl_Multiline_Input_H
+
+#include "Fl_Input.H"
+
+/**
+  This input field displays '\\n' characters as new lines rather than ^J,
+  and accepts the Return, Tab, and up and down arrow keys.  This is for
+  editing multiline text.
+
+  This is far from the nirvana of text editors, and is probably only
+  good for small bits of text, 10 lines at most. Note that this widget
+  does not support scrollbars or per-character color control.
+
+  If you are presenting large amounts of text and need scrollbars
+  or full color control of characters, you probably want Fl_Text_Editor
+  instead.
+
+  In FLTK 1.3.x, the default behavior of the 'Tab' key was changed
+  to support consistent focus navigation. To get the older FLTK 1.1.x
+  behavior, set Fl_Input_::tab_nav() to 0. Newer programs should consider using
+  Fl_Text_Editor.
+*/
+class FL_EXPORT Fl_Multiline_Input : public Fl_Input {
+public:
+  /**
+    Creates a new Fl_Multiline_Input widget using the given
+    position, size, and label string. The default boxtype is FL_DOWN_BOX.
+
+    Inherited destructor destroys the widget and any value associated with it.
+  */
+  Fl_Multiline_Input(int X,int Y,int W,int H,const char *l = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Multiline_Output.H

@@ -0,0 +1,56 @@
+//
+// "$Id$"
+//
+// Multi line output header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Multiline_Output widget . */
+
+#ifndef Fl_Multiline_Output_H
+#define Fl_Multiline_Output_H
+
+#include "Fl_Output.H"
+
+/**
+  This widget is a subclass of Fl_Output that displays multiple
+  lines of text. It also displays tab characters as whitespace to the
+  next column.
+
+  Note that this widget does not support scrollbars, or per-character
+  color control.
+
+  If you are presenting large amounts of read-only text 
+  and need scrollbars, or full color control of characters,
+  then use Fl_Text_Display. If you want to display HTML text,
+  use Fl_Help_View.
+*/
+class FL_EXPORT Fl_Multiline_Output : public Fl_Output {
+public:
+
+  /**
+    Creates a new Fl_Multiline_Output widget using the given position,
+    size, and label string. The default boxtype is FL_DOWN_BOX.
+
+    Inherited destructor destroys the widget and any value associated with it.
+  */
+  Fl_Multiline_Output(int X,int Y,int W,int H,const char *l = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Native_File_Chooser.H

@@ -0,0 +1,348 @@
+//
+// "$Id$"
+//
+// FLTK native OS file chooser widget
+//
+// Copyright 1998-2014 by Bill Spitzak and others.
+// Copyright 2004 Greg Ercolano.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/** \file
+   Fl_Native_File_Chooser widget. */
+
+#ifndef FL_NATIVE_FILE_CHOOSER_H
+#define FL_NATIVE_FILE_CHOOSER_H
+
+// Use Windows' chooser
+#ifdef WIN32
+// #define _WIN32_WINNT	0x0501	// needed for OPENFILENAME's 'FlagsEx'
+#if defined(FL_LIBRARY) || FLTK_ABI_VERSION < 10304
+#  include <windows.h>
+#  include <commdlg.h>		// OPENFILENAMEW, GetOpenFileName()
+#  include <shlobj.h>		// BROWSEINFOW, SHBrowseForFolder()
+typedef OPENFILENAMEW fl_OPENFILENAMEW;
+typedef BROWSEINFOW fl_BROWSEINFOW;
+#else
+typedef void fl_OPENFILENAMEW;
+typedef void fl_BROWSEINFOW;
+#endif
+#endif
+
+// Use Apple's chooser
+#ifdef __APPLE__
+#  define MAXFILTERS	80
+#endif
+
+// All else falls back to FLTK's own chooser
+#if ! defined(__APPLE__) && !defined(WIN32)
+#  include <FL/Fl_File_Chooser.H>
+#else
+#  include <FL/filename.H>	// FL_EXPORT
+#endif
+
+class Fl_FLTK_File_Chooser;
+class Fl_GTK_File_Chooser;
+
+/**
+ This class lets an FLTK application easily and consistently access 
+ the operating system's native file chooser. Some operating systems 
+ have very complex and specific file choosers that many users want 
+ access to specifically, instead of FLTK's default file chooser(s). 
+ 
+ In cases where there is no native file browser, FLTK's own file browser
+ is used instead.
+ 
+ To use this widget, use the following include in your code:
+ \code
+ #include <FL/Fl_Native_File_Chooser.H>
+ \endcode
+ 
+ The following example shows how to pick a single file:
+ \code
+ // Create and post the local native file chooser
+ #include <FL/Fl_Native_File_Chooser.H>
+ [..]
+ Fl_Native_File_Chooser fnfc;
+ fnfc.title("Pick a file");
+ fnfc.type(Fl_Native_File_Chooser::BROWSE_FILE);
+ fnfc.filter("Text\t*.txt\n"
+             "C Files\t*.{cxx,h,c}");
+ fnfc.directory("/var/tmp");           // default directory to use
+ // Show native chooser
+ switch ( fnfc.show() ) {
+   case -1: printf("ERROR: %s\n", fnfc.errmsg());    break;  // ERROR
+   case  1: printf("CANCEL\n");                      break;  // CANCEL
+   default: printf("PICKED: %s\n", fnfc.filename()); break;  // FILE CHOSEN
+ }
+ \endcode
+ 
+ The Fl_Native_File_Chooser widget transmits UTF-8 encoded filenames to its user. It is
+ recommended to open files that may have non-ASCII names with the fl_fopen() or
+ fl_open() utility functions that handle these names in a cross-platform way 
+ (whereas the standard fopen()/open() functions fail on the MSWindows platform 
+ to open files with a non-ASCII name).
+ 
+ <B>Platform Specific Caveats</B>
+ 
+ - Under X windows, and if Fl::OPTION_FNFC_USES_GTK has not been switched off,
+ the widget attempts to use standard GTK file chooser dialogs if they are
+ available at run-time on the platform, and falls back to use FLTK's Fl_File_Chooser if they are not.
+ In the latter case, it's best if you call Fl_File_Icon::load_system_icons()
+ at the start of main(), to enable the nicer looking file browser widgets.
+ Use the static public attributes of class Fl_File_Chooser to localize
+ the browser.
+ - Some operating systems support certain OS specific options; see 
+ Fl_Native_File_Chooser::options() for a list.
+ 
+ \image html Fl_Native_File_Chooser.png "The Fl_Native_File_Chooser on different platforms."
+ \image latex Fl_Native_File_Chooser.png "The Fl_Native_File_Chooser on different platforms" width=14cm
+ 
+ */
+class FL_EXPORT Fl_Native_File_Chooser {
+public:
+  enum Type {
+    BROWSE_FILE = 0,			///< browse files (lets user choose one file)
+    BROWSE_DIRECTORY,			///< browse directories (lets user choose one directory)
+    BROWSE_MULTI_FILE,			///< browse files (lets user choose multiple files)
+    BROWSE_MULTI_DIRECTORY,		///< browse directories (lets user choose multiple directories)
+    BROWSE_SAVE_FILE,			///< browse to save a file
+    BROWSE_SAVE_DIRECTORY		///< browse to save a directory
+  };
+  enum Option {
+    NO_OPTIONS     = 0x0000,		///< no options enabled
+    SAVEAS_CONFIRM = 0x0001,		///< Show native 'Save As' overwrite confirm dialog
+    NEW_FOLDER     = 0x0002,		///< Show 'New Folder' icon (if supported)
+    PREVIEW        = 0x0004,		///< enable preview mode (if supported)
+    USE_FILTER_EXT = 0x0008		///< Chooser filter pilots the output file extension (if supported)
+  };
+  /** Localizable message */
+  static const char *file_exists_message;
+  
+public:
+  Fl_Native_File_Chooser(int val=BROWSE_FILE);
+  ~Fl_Native_File_Chooser();
+  
+  // Public methods
+  void type(int t);
+  int type() const ;
+  void options(int o);
+  int options() const;
+  int count() const;
+  const char *filename() const ;
+  const char *filename(int i) const ;
+  void directory(const char *val) ;
+  const char *directory() const;
+  void title(const char *t);
+  const char* title() const;
+  const char *filter() const ;
+  void filter(const char *f);
+  int filters() const ;
+  void filter_value(int i) ;
+  int filter_value() const ;
+  void preset_file(const char*f) ;
+  const char* preset_file() const;
+  const char *errmsg() const ;
+  int show() ;
+  
+#ifdef WIN32
+private:
+  int  _btype;			// kind-of browser to show()
+  int  _options;		// general options
+#if FLTK_ABI_VERSION >= 10304
+  fl_OPENFILENAMEW *_ofn_ptr;	// GetOpenFileName() & GetSaveFileName() struct
+  fl_BROWSEINFOW   *_binf_ptr;	// SHBrowseForFolder() struct
+  WCHAR            *_wpattern;	// pattern buffer for filter
+#else
+  fl_OPENFILENAMEW _ofn;
+  fl_BROWSEINFOW   _binf;
+#endif
+  char  **_pathnames;		// array of pathnames
+  int     _tpathnames;		// total pathnames
+  char   *_directory;		// default pathname to use
+  char   *_title;		// title for window
+  char   *_filter;		// user-side search filter
+  char   *_parsedfilt;		// filter parsed for Windows dialog
+  int     _nfilters;		// number of filters parse_filter counted
+  char   *_preset_file;		// the file to preselect
+  char   *_errmsg;		// error message
+  
+  // Private methods
+  void errmsg(const char *msg);
+  
+  void clear_pathnames();
+  void set_single_pathname(const char *s);
+  void add_pathname(const char *s);
+  
+  void ClearOFN();
+  void ClearBINF();
+  void Win2Unix(char *s);
+  void Unix2Win(char *s);
+  int showfile();
+  int showdir();
+  
+  void parse_filter(const char *);
+  void clear_filters();
+  void add_filter(const char *, const char *);
+#endif
+
+#ifdef __APPLE__
+private:
+  int             _btype;		// kind-of browser to show()
+  int             _options;		// general options
+  void 	         *_panel;
+  char          **_pathnames;		// array of pathnames
+  int             _tpathnames;	        // total pathnames
+  char           *_directory;		// default pathname to use
+  char           *_title;		// title for window
+  char           *_preset_file;	        // the 'save as' filename
+  
+  char           *_filter;		// user-side search filter, eg:
+  // C Files\t*.[ch]\nText Files\t*.txt"
+  
+  char           *_filt_names;		// filter names (tab delimited)
+  // eg. "C Files\tText Files"
+  
+  char           *_filt_patt[MAXFILTERS];
+  // array of filter patterns, eg:
+  //     _filt_patt[0]="*.{cxx,h}"
+  //     _filt_patt[1]="*.txt"
+  
+  int             _filt_total;		// parse_filter() # of filters loaded
+  int             _filt_value;		// index of the selected filter
+  char           *_errmsg;		// error message
+  
+  // Private methods
+  void errmsg(const char *msg);
+  void clear_pathnames();
+  void set_single_pathname(const char *s);
+  int get_saveas_basename(void);
+  void clear_filters();
+  void add_filter(const char *, const char *);
+  void parse_filter(const char *from);
+  int post();
+  int runmodal();
+#endif
+
+#if ! defined(__APPLE__) && !defined(WIN32)
+private:
+#if FLTK_ABI_VERSION <= 10302
+  int   _btype;			// kind-of browser to show()
+  int   _options;		// general options
+  int   _nfilters;
+  char *_filter;		// user supplied filter
+  char *_parsedfilt;		// parsed filter
+  int   _filtvalue;		// selected filter
+  char *_preset_file;
+  char *_prevvalue;		// Returned filename
+  char *_directory;
+  char *_errmsg;		// error message
+#endif
+  static int have_looked_for_GTK_libs;
+  union {
+    Fl_FLTK_File_Chooser *_x11_file_chooser;
+    Fl_GTK_File_Chooser *_gtk_file_chooser;
+  };
+#endif
+};
+
+#if !defined(__APPLE__) && !defined(WIN32)
+class FL_EXPORT Fl_FLTK_File_Chooser {
+  friend class Fl_Native_File_Chooser;
+protected:
+  int   _btype;			// kind-of browser to show()
+  int   _options;		// general options
+  int   _nfilters;
+  char *_filter;		// user supplied filter
+  char *_parsedfilt;		// parsed filter
+  int   _filtvalue;		// selected filter
+  char *_preset_file;
+  char *_prevvalue;		// Returned filename
+  char *_directory;
+  char *_errmsg;		// error message
+  Fl_FLTK_File_Chooser(int val);
+  virtual ~Fl_FLTK_File_Chooser();
+  void errmsg(const char *msg);
+  int type_fl_file(int);
+  void parse_filter();
+  int exist_dialog();
+  Fl_File_Chooser *_file_chooser;
+  virtual void type(int);
+  int type() const;
+  void options(int);
+  int options() const;
+  virtual int count() const;
+  virtual const char *filename() const;
+  virtual const char *filename(int i) const;
+  void directory(const char *val);
+  const char *directory() const;
+  virtual void title(const char *);
+  virtual const char* title() const;
+  const char *filter() const;
+  void filter(const char *);
+  int filters() const;
+  void filter_value(int i);
+  int filter_value() const;
+  void preset_file(const char*);
+  const char* preset_file() const;
+  const char *errmsg() const;
+  virtual int show();
+};
+
+
+class FL_EXPORT Fl_GTK_File_Chooser : public Fl_FLTK_File_Chooser {
+  friend class Fl_Native_File_Chooser;
+private:
+  typedef struct _GtkWidget GtkWidget;
+  typedef struct _GtkFileFilterInfo GtkFileFilterInfo;
+  struct pair {
+    Fl_GTK_File_Chooser* running; // the running Fl_GTK_File_Chooser
+    const char *filter; // a filter string of the chooser
+    pair(Fl_GTK_File_Chooser* c, const char *f) {
+      running = c; 
+      filter = strdup(f);
+    };
+    ~pair() {
+      free((char*)filter);
+    };
+  };
+  GtkWidget *gtkw_ptr; // used to hold a GtkWidget* without pulling GTK into everything...
+  void *gtkw_slist; // used to hold a GLib GSList...
+  unsigned gtkw_count; // number of files read back - if any
+  mutable char *gtkw_filename; // last name we read back
+  char *gtkw_title; // the title to be applied to the dialog
+  const char *previous_filter;
+  
+  int fl_gtk_chooser_wrapper(); // method that wraps the GTK widget
+  Fl_GTK_File_Chooser(int val);
+  virtual ~Fl_GTK_File_Chooser();
+  static int did_find_GTK_libs;
+  static void probe_for_GTK_libs(void);
+  virtual void type(int);
+  virtual int count() const;
+  virtual const char *filename() const;
+  virtual const char *filename(int i) const;
+  virtual void title(const char *);
+  virtual const char* title() const;
+  virtual int show();
+  void changed_output_type(const char *filter);
+  
+  static int custom_gtk_filter_function(const GtkFileFilterInfo*, Fl_GTK_File_Chooser::pair*);
+  static void free_pair(pair *p);
+};
+#endif // !defined(__APPLE__) && !defined(WIN32)
+
+#endif /*FL_NATIVE_FILE_CHOOSER_H*/
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Nice_Slider.H

@@ -0,0 +1,36 @@
+//
+// "$Id$"
+//
+// "Nice" slider header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Nice_Slider widget . */
+
+#ifndef Fl_Nice_Slider_H
+#define Fl_Nice_Slider_H
+
+#include "Fl_Slider.H"
+
+class FL_EXPORT Fl_Nice_Slider : public Fl_Slider {
+public:
+  Fl_Nice_Slider(int X,int Y,int W,int H,const char *L=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Object.H

@@ -0,0 +1,27 @@
+//
+// "$Id$"
+//
+// Old Fl_Object header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+// This file is provided for back compatibility only.  Please use Fl_Widget
+#ifndef Fl_Object
+#define Fl_Object Fl_Widget
+#endif
+#include "Fl_Widget.H"
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Output.H

@@ -0,0 +1,63 @@
+//
+// "$Id$"
+//
+// Output header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Output widget . */
+
+#ifndef Fl_Output_H
+#define Fl_Output_H
+
+#include "Fl_Input.H"
+/**
+  This widget displays a piece of text.
+  
+  When you set the value() , Fl_Output does a strcpy() to its own storage,
+  which is useful for program-generated values.  The user may select
+  portions of the text using the mouse and paste the contents into other
+  fields or programs.
+
+  <P align=CENTER>\image html text.png</P>
+  \image latex text.png "Fl_Output" width=8cm
+
+  There is a single subclass, Fl_Multiline_Output, which allows you to
+  display multiple lines of text. Fl_Multiline_Output does not provide
+  scroll bars. If a more complete text editing widget is needed, use
+  Fl_Text_Display instead.
+
+  The text may contain any characters except \\0, and will correctly
+  display anything, using ^X notation for unprintable control characters
+  and \\nnn notation for unprintable characters with the high bit set. It
+  assumes the font can draw any characters in the ISO-Latin1 character set.
+*/
+class FL_EXPORT Fl_Output : public Fl_Input {
+public:
+  /**
+    Creates a new Fl_Output widget using the given position,
+    size, and label string. The default boxtype is FL_DOWN_BOX.
+
+    Inherited destructor destroys the widget and any value associated with it.
+  */
+
+    Fl_Output(int X,int Y,int W,int H, const char *l = 0);
+};
+
+#endif 
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Overlay_Window.H

@@ -0,0 +1,81 @@
+//
+// "$Id$"
+//
+// Overlay window header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Overlay_Window class . */
+
+#ifndef Fl_Overlay_Window_H
+#define Fl_Overlay_Window_H
+
+#include "Fl_Double_Window.H"
+
+/**
+  This window provides double buffering and also the ability to draw the
+  "overlay" which is another picture placed on top of the main image. The
+  overlay is designed to be a rapidly-changing but simple graphic such as
+  a mouse selection box. Fl_Overlay_Window uses the overlay
+  planes provided by your graphics hardware if they are available.
+  <P>If no hardware support is found the overlay is simulated by drawing
+  directly into the on-screen copy of the double-buffered window, and
+  "erased" by copying the backbuffer over it again.  This means the
+  overlay will blink if you change the image in the window.
+*/
+class FL_EXPORT Fl_Overlay_Window : public Fl_Double_Window {
+#ifndef FL_DOXYGEN
+  friend class _Fl_Overlay;
+#endif
+protected:
+  /**
+   You must subclass Fl_Overlay_Window and provide this method.
+   It is just like a draw() method, except it draws the overlay.
+   The overlay will have already been "cleared" when this is called.  You
+   can use any of the routines described in &lt;FL/fl_draw.H&gt;.
+   */
+  virtual void draw_overlay() = 0;
+private:
+  Fl_Window *overlay_;
+public:
+  void show();
+  void flush();
+  void hide();
+  void resize(int,int,int,int);
+  ~Fl_Overlay_Window();
+  /** Returns non-zero if there's hardware overlay support */
+  int can_do_overlay();
+  void redraw_overlay();
+protected:
+  /**
+   See Fl_Overlay_Window::Fl_Overlay_Window(int X, int Y, int W, int H, const char *l=0)
+   */
+  Fl_Overlay_Window(int W, int H, const char *l=0);
+  /**
+   Creates a new Fl_Overlay_Window widget using the given
+   position, size, and label (title) string. If the 
+   positions (x,y) are not given, then the window manager
+   will choose them.
+   */
+  Fl_Overlay_Window(int X, int Y, int W, int H, const char *l=0);
+public:
+  void show(int a, char **b) {Fl_Double_Window::show(a,b);}
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_PNG_Image.H

@@ -0,0 +1,46 @@
+//
+// "$Id$"
+//
+// PNG image header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_PNG_Image class . */
+
+#ifndef Fl_PNG_Image_H
+#define Fl_PNG_Image_H
+#  include "Fl_Image.H"
+
+/**
+  The Fl_PNG_Image class supports loading, caching,
+  and drawing of Portable Network Graphics (PNG) image files. The
+  class loads colormapped and full-color images and handles color-
+  and alpha-based transparency.
+*/
+class FL_EXPORT Fl_PNG_Image : public Fl_RGB_Image {
+
+public:
+
+  Fl_PNG_Image(const char* filename);
+  Fl_PNG_Image (const char *name_png, const unsigned char *buffer, int datasize);
+private:
+  void load_png_(const char *name_png, const unsigned char *buffer_png, int datasize);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_PNM_Image.H

@@ -0,0 +1,43 @@
+//
+// "$Id$"
+//
+// PNM image header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_PNM_Image class . */
+
+#ifndef Fl_PNM_Image_H
+#define Fl_PNM_Image_H
+#  include "Fl_Image.H"
+
+/**
+  The Fl_PNM_Image class supports loading, caching,
+  and drawing of Portable Anymap (PNM, PBM, PGM, PPM) image files. The class
+  loads bitmap, grayscale, and full-color images in both ASCII and
+  binary formats.
+*/
+class FL_EXPORT Fl_PNM_Image : public Fl_RGB_Image {
+
+  public:
+
+  Fl_PNM_Image(const char* filename);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Pack.H

@@ -0,0 +1,75 @@
+//
+// "$Id$"
+//
+// Pack header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Pack widget . */
+
+#ifndef Fl_Pack_H
+#define Fl_Pack_H
+
+#include <FL/Fl_Group.H>
+
+/**
+  This widget was designed to add the functionality of compressing and
+  aligning widgets.
+  <P>If type() is Fl_Pack::HORIZONTAL all the children are
+  resized to the height of the Fl_Pack, and are moved next to
+  each other horizontally. If type() is not Fl_Pack::HORIZONTAL
+  then the children are resized to the width and are stacked below each
+  other.  Then the Fl_Pack resizes itself to surround the child
+  widgets.
+  <P>This widget is needed for the Fl_Tabs.
+  In addition you may want to put the Fl_Pack inside an 
+  Fl_Scroll.
+
+  <P>The resizable for Fl_Pack is set to NULL by default.</p>
+  <P>See also: Fl_Group::resizable()
+*/
+class FL_EXPORT Fl_Pack : public Fl_Group {
+  int spacing_;
+
+public:
+  enum { // values for type(int)
+    VERTICAL = 0,
+    HORIZONTAL = 1
+  };
+
+protected:
+  void draw();
+
+public:
+  Fl_Pack(int x,int y,int w ,int h,const char *l = 0);
+  /**
+    Gets the number of extra pixels of blank space that are added
+    between the children.
+  */
+  int spacing() const {return spacing_;}
+  /**
+    Sets the number of extra pixels of blank space that are added
+    between the children.
+  */
+  void spacing(int i) {spacing_ = i;}
+  /** Same as Fl_Group::type() */
+  uchar horizontal() const {return type();}
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Paged_Device.H

@@ -0,0 +1,155 @@
+//
+// "$Id$"
+//
+// Printing support for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 2010-2016 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/** \file Fl_Paged_Device.H 
+ \brief declaration of class Fl_Paged_Device.
+ */
+
+#ifndef Fl_Paged_Device_H
+#define Fl_Paged_Device_H
+
+#include <FL/Fl_Device.H>
+#include <FL/Fl_Window.H>
+
+/** \brief Number of elements in enum Page_Format */
+#define NO_PAGE_FORMATS 30 /* MSVC6 compilation fix */
+
+/**
+ \brief Represents page-structured drawing surfaces.
+ *
+ This class has no public constructor: don't instantiate it; use Fl_Printer 
+ or Fl_PostScript_File_Device instead.
+ */
+class FL_EXPORT Fl_Paged_Device : public Fl_Surface_Device {
+#ifndef __APPLE__
+  friend class Fl_Copy_Surface;
+  friend class Fl_Image_Surface;
+  void draw_decorated_window(Fl_Window *win, int x_offset, int y_offset, Fl_Surface_Device *toset);
+#endif
+public:
+  /**
+   \brief Possible page formats.
+   
+   All paper formats with pre-defined width and height.
+   */
+  enum Page_Format {
+    A0 = 0, /**<  A0 format */
+    A1,
+    A2,
+    A3,
+    A4, /**<  A4 format */
+    A5,
+    A6,
+    A7,
+    A8,
+    A9,
+    B0,
+    B1,
+    B2,
+    B3,
+    B4,
+    B5,
+    B6,
+    B7,
+    B8,
+    B9,
+    B10,
+    C5E,
+    DLE,
+    EXECUTIVE,
+    FOLIO,
+    LEDGER,
+    LEGAL,
+    LETTER, /**<  Letter format */
+    TABLOID,
+    ENVELOPE,
+    MEDIA = 0x1000
+  };
+  /**
+   \brief Possible page layouts.
+   */
+  enum Page_Layout {
+    PORTRAIT = 0,  /**< Portrait orientation */
+    LANDSCAPE = 0x100,   /**< Landscape orientation */
+    REVERSED = 0x200,  /**< Reversed orientation */
+    ORIENTATION = 0x300 /**<  orientation */
+  };
+
+  /** \brief width, height and name of a page format
+ */
+  typedef struct {
+    /** \brief width in points */
+    int width; 
+    /** \brief height in points */
+    int height; 
+    /** \brief format name */
+    const char *name; 
+  } page_format;
+  /** \brief width, height and name of all elements of the enum \ref Page_Format.
+   */
+  static const page_format page_formats[NO_PAGE_FORMATS];  
+private:
+  void traverse(Fl_Widget *widget); // finds subwindows of widget and prints them
+protected:
+  /** \brief horizontal offset to the origin of graphics coordinates */
+  int x_offset;
+  /** \brief vertical offset to the origin of graphics coordinates */
+  int y_offset;
+  /** \brief The constructor */
+  Fl_Paged_Device() : Fl_Surface_Device(NULL), x_offset(0), y_offset(0) {};
+#if FLTK_ABI_VERSION >= 10301
+public:
+  /** \brief The destructor */
+  virtual ~Fl_Paged_Device() {};
+#else
+  /** \brief The destructor */
+  virtual ~Fl_Paged_Device() {};
+public:
+#endif // FLTK_ABI_VERSION
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  virtual int start_job(int pagecount, int *frompage = NULL, int *topage = NULL);
+  virtual int start_page(void);
+  virtual int printable_rect(int *w, int *h);
+  virtual void margins(int *left, int *top, int *right, int *bottom);
+  virtual void origin(int x, int y);
+  virtual void origin(int *x, int *y);
+  virtual void scale(float scale_x, float scale_y = 0.);
+  virtual void rotate(float angle);
+  virtual void translate(int x, int y);
+  virtual void untranslate(void);
+  virtual void print_widget(Fl_Widget* widget, int delta_x = 0, int delta_y = 0);
+  /** Prints a window with its title bar and frame if any.
+   
+   \p x_offset and \p y_offset are optional coordinates of where to position the window top left.
+   Equivalent to print_widget() if \p win is a subwindow or has no border.
+   Use Fl_Window::decorated_w() and Fl_Window::decorated_h() to get the size of the
+   printed window.
+   */
+  void print_window(Fl_Window *win, int x_offset = 0, int y_offset = 0);
+  virtual void print_window_part(Fl_Window *win, int x, int y, int w, int h, int delta_x = 0, int delta_y = 0);
+  virtual int end_page (void);
+  virtual void end_job (void);
+};
+
+#endif // Fl_Paged_Device_H
+
+//
+// End of "$Id$"
+//
+

msvc/fltk/include/FL/Fl_Pixmap.H

@@ -0,0 +1,102 @@
+//
+// "$Id$"
+//
+// Pixmap header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2012 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Pixmap widget . */
+
+#ifndef Fl_Pixmap_H
+#define Fl_Pixmap_H
+#  include "Fl_Image.H"
+#if defined(WIN32)
+#  include "x.H"
+#endif
+
+class Fl_Widget;
+struct Fl_Menu_Item;
+
+// Older C++ compilers don't support the explicit keyword... :(
+#  if defined(__sgi) && !defined(_COMPILER_VERSION)
+#    define explicit
+#  endif // __sgi && !_COMPILER_VERSION
+
+/**
+  The Fl_Pixmap class supports caching and drawing of colormap
+  (pixmap) images, including transparency.
+*/
+class FL_EXPORT Fl_Pixmap : public Fl_Image {
+  friend class Fl_Quartz_Graphics_Driver;
+  friend class Fl_GDI_Graphics_Driver;
+  friend class Fl_GDI_Printer_Graphics_Driver;
+  friend class Fl_Xlib_Graphics_Driver;
+  void copy_data();
+  void delete_data();
+  void set_data(const char * const *p);
+  int prepare(int XP, int YP, int WP, int HP, int &cx, int &cy,
+			 int &X, int &Y, int &W, int &H);
+
+  protected:
+
+  void measure();
+
+  public:
+
+  int alloc_data; // Non-zero if data was allocated
+  
+  private:
+
+#if defined(WIN32)
+#if FLTK_ABI_VERSION < 10301
+  static // a static member is needed for ABI compatibility
+#endif
+  UINT pixmap_bg_color; // RGB color used for pixmap background
+#endif // WIN32
+#if defined(__APPLE__) || defined(WIN32)
+  void *id_; // for internal use
+  void *mask_; // for internal use (mask bitmap)
+#else
+  unsigned id_; // for internal use
+  unsigned mask_; // for internal use (mask bitmap)
+#endif // __APPLE__ || WIN32
+  
+  public:
+
+  /**    The constructors create a new pixmap from the specified XPM data.  */
+  explicit Fl_Pixmap(char * const * D) : Fl_Image(-1,0,1), alloc_data(0), id_(0), mask_(0) {set_data((const char*const*)D); measure();}
+  /**    The constructors create a new pixmap from the specified XPM data.  */
+  explicit Fl_Pixmap(uchar* const * D) : Fl_Image(-1,0,1), alloc_data(0), id_(0), mask_(0) {set_data((const char*const*)D); measure();}
+  /**    The constructors create a new pixmap from the specified XPM data.  */
+  explicit Fl_Pixmap(const char * const * D) : Fl_Image(-1,0,1), alloc_data(0), id_(0), mask_(0) {set_data((const char*const*)D); measure();}
+  /**    The constructors create a new pixmap from the specified XPM data.  */
+  explicit Fl_Pixmap(const uchar* const * D) : Fl_Image(-1,0,1), alloc_data(0), id_(0), mask_(0) {set_data((const char*const*)D); measure();}
+  virtual ~Fl_Pixmap();
+  virtual Fl_Image *copy(int W, int H);
+  Fl_Image *copy() { return copy(w(), h()); }
+  virtual void color_average(Fl_Color c, float i);
+  virtual void desaturate();
+  virtual void draw(int X, int Y, int W, int H, int cx=0, int cy=0);
+  void draw(int X, int Y) {draw(X, Y, w(), h(), 0, 0);}
+  virtual void label(Fl_Widget*w);
+  virtual void label(Fl_Menu_Item*m);
+  virtual void uncache();
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Plugin.H

@@ -0,0 +1,95 @@
+//
+// "$Id: Fl_Plugin.H 6995 2010-01-12 08:48:55Z matt $"
+//
+// A Plugin system for FLTK, implemented in Fl_Preferences.cxx.
+//
+// Copyright 2002-2010 by Matthias Melcher.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Plugin class . */
+
+#ifndef Fl_Plugin_H
+#  define Fl_Plugin_H
+
+#  include "Fl_Preferences.H"
+
+
+/**
+ \brief Fl_Plugin allows link-time and run-time integration of binary modules.
+ 
+ Fl_Plugin and Fl_Plugin_Manager provide a small and simple solution for
+ linking C++ classes at run-time, or optionally linking modules at compile
+ time without the need to change the main application.
+
+ Fl_Plugin_Manager uses static initialisation to create the plugin interface
+ early during startup. Plugins are stored in a temporary database, organized
+ in classes.
+ 
+ Plugins should derive a new class from Fl_Plugin as a base:
+ \code
+ class My_Plugin : public Fl_Plugin {
+ public:
+   My_Plugin() : Fl_Plugin("effects", "blur") { }
+   void do_something(...);
+ };
+ My_Plugin blur_plugin();
+ \endcode
+ 
+ Plugins can be put into modules and either linked before distribution, or loaded
+ from dynamically linkable files. An Fl_Plugin_Manager is used to list and 
+ access all currently loaded plugins.
+ \code
+ Fl_Plugin_Manager mgr("effects");
+ int i, n = mgr.plugins();
+ for (i=0; i<n; i++) {
+   My_Plugin *pin = (My_Plugin*)mgr.plugin(i);
+   pin->do_something();
+ }
+ \endcode
+ */
+class FL_EXPORT Fl_Plugin  {
+  Fl_Preferences::ID id;
+public:
+  Fl_Plugin(const char *klass, const char *name);
+  virtual ~Fl_Plugin();
+};
+
+
+/**
+ \brief Fl_Plugin_Manager manages link-time and run-time plugin binaries.
+ \see Fl_Plugin
+ */
+class FL_EXPORT Fl_Plugin_Manager : public Fl_Preferences {
+public:
+  Fl_Plugin_Manager(const char *klass);
+  ~Fl_Plugin_Manager();
+  
+  /** \brief Return the number of plugins in the klass.
+   */
+  int plugins() { return groups(); }
+  Fl_Plugin *plugin(int index);
+  Fl_Plugin *plugin(const char *name);
+  Fl_Preferences::ID addPlugin(const char *name, Fl_Plugin *plugin);
+  
+  static void removePlugin(Fl_Preferences::ID id);
+  static int load(const char *filename);
+  static int loadAll(const char *filepath, const char *pattern=0);
+};
+
+
+#endif // !Fl_Preferences_H
+
+//
+// End of "$Id: Fl_Preferences.H 6995 2010-01-12 08:48:55Z matt $".
+//

msvc/fltk/include/FL/Fl_Positioner.H

@@ -0,0 +1,94 @@
+//
+// "$Id$"
+//
+// Positioner header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Positioner widget . */
+
+#ifndef Fl_Positioner_H
+#define Fl_Positioner_H
+
+#ifndef Fl_Widget_H
+#include "Fl_Widget.H"
+#endif
+
+/**
+  This class is provided for Forms compatibility.  It provides 2D input.
+  It would be useful if this could be put atop another widget so that the
+  crosshairs are on top, but this is not implemented.  The color of the
+  crosshairs is selection_color().
+  <P ALIGN=CENTER>\image html  positioner.png </P> 
+  \image latex  positioner.png " Fl_Positioner" width=4cm
+*/
+class FL_EXPORT Fl_Positioner : public Fl_Widget {
+
+  double xmin, ymin;
+  double xmax, ymax;
+  double xvalue_, yvalue_;
+  double xstep_, ystep_;
+
+protected:
+
+  // these allow subclasses to put the dial in a smaller area:
+  void draw(int, int, int, int);
+  int handle(int, int, int, int, int);
+  void draw();
+
+public:
+
+  int handle(int);
+  /**
+    Creates a new Fl_Positioner widget using the given position,
+    size, and label string. The default boxtype is FL_NO_BOX.
+  */
+  Fl_Positioner(int x,int y,int w,int h, const char *l=0);
+  /** Gets the X axis coordinate.*/
+  double xvalue() const {return xvalue_;}
+  /** Gets the Y axis coordinate.*/
+  double yvalue() const {return yvalue_;}
+  int xvalue(double);
+  int yvalue(double);
+  int value(double,double);
+  void xbounds(double, double);
+  /** Gets the X axis minimum */
+  double xminimum() const {return xmin;}
+  /** Same as xbounds(a, xmaximum()) */
+  void xminimum(double a) {xbounds(a,xmax);}
+  /** Gets the X axis maximum */
+  double xmaximum() const {return xmax;}
+  /** Same as xbounds(xminimum(), a) */
+  void xmaximum(double a) {xbounds(xmin,a);}
+  void ybounds(double, double);
+  /** Gets the Y axis minimum */
+  double yminimum() const {return ymin;}
+  /** Same as ybounds(a, ymaximum()) */
+  void yminimum(double a) {ybounds(a, ymax);}
+  /** Gets the Y axis maximum */
+  double ymaximum() const {return ymax;}
+  /** Same as ybounds(ymininimum(), a) */
+  void ymaximum(double a) {ybounds(ymin, a);}
+  /** Sets the stepping value for the X axis.*/
+  void xstep(double a) {xstep_ = a;}
+  /** Sets the stepping value for the Y axis.*/
+  void ystep(double a) {ystep_ = a;}
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_PostScript.H

@@ -0,0 +1,264 @@
+//
+// "$Id$"
+//
+// Support for graphics output to PostScript file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 2010-2011 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/** \file Fl_PostScript.H 
+ \brief declaration of classes Fl_PostScript_Graphics_Driver, Fl_PostScript_File_Device.
+ */
+
+#ifndef Fl_PostScript_H
+#define Fl_PostScript_H
+
+#include <FL/Fl_Paged_Device.H>
+#include <FL/fl_draw.H>
+#include <stdarg.h>
+
+/* Signature of Fl_PostScript::close_command() functions passed as parameters. */
+extern "C" {
+  typedef int (Fl_PostScript_Close_Command)(FILE *);
+}
+
+/**
+ \brief PostScript graphical backend.
+ *
+ PostScript text uses vectorial fonts when using the FLTK standard fonts  
+ and the latin alphabet or a few other characters listed in the following table.
+ The latin alphabet means all unicode characters between U+0020 and U+017F, or, in other words, 
+ the ASCII, Latin-1 Supplement and Latin Extended-A charts.
+ <table>
+ <tr> <th>Char</th><th>Codepoint</th><th>Name</th>  <th>Char</th><th>Codepoint</th><th>Name</th> <th>Char</th><th>Codepoint</th><th>Name</th></tr>
+ <tr><td>ƒ</td><td>U+0192</td><td>florin</td><td>‚</td><td>U+201A</td><td>quotesinglbase</td><td>™</td><td>U+2122</td><td>trademark</td></tr>
+ <tr><td>ˆ</td><td>U+02C6</td><td>circumflex</td><td>“</td><td>U+201C</td><td>quotedblleft</td><td>∂</td><td>U+2202</td><td>partialdiff</td></tr>
+ <tr><td>ˇ</td><td>U+02C7</td><td>caron</td><td>”</td><td>U+201D</td><td>quotedblright</td><td>Δ</td><td>U+2206</td><td>Delta</td></tr>
+ <tr><td>˘</td><td>U+02D8</td><td>breve</td><td>„</td><td>U+201E</td><td>quotedblbase</td><td>∑</td><td>U+2211</td><td>summation</td></tr>
+ <tr><td>˙</td><td>U+02D9</td><td>dotaccent</td><td>†</td><td>U+2020</td><td>dagger</td><td>√</td><td>U+221A</td><td>radical</td></tr>
+ <tr><td>˚</td><td>U+02DA</td><td>ring</td><td>‡</td><td>U+2021</td><td>daggerdbl</td><td>∞</td><td>U+221E</td><td>infinity</td></tr>
+ <tr><td>˛</td><td>U+02DB</td><td>ogonek</td><td>•</td><td>U+2022</td><td>bullet</td><td>≠</td><td>U+2260</td><td>notequal</td></tr>
+ <tr><td>˜</td><td>U+02DC</td><td>tilde</td><td>…</td><td>U+2026</td><td>ellipsis</td><td>≤</td><td>U+2264</td><td>lessequal</td></tr>
+ <tr><td>˝</td><td>U+02DD</td><td>hungarumlaut</td><td>‰</td><td>U+2030</td><td>perthousand</td><td>≥</td><td>U+2265</td><td>greaterequal</td></tr>
+ <tr><td>–</td><td>U+2013</td><td>endash</td><td>‹</td><td>U+2039</td><td>guilsinglleft</td><td>◊</td><td>U+25CA</td><td>lozenge</td></tr>
+ <tr><td>—</td><td>U+2014</td><td>emdash</td><td>›</td><td>U+203A</td><td>guilsinglright</td><td>fi</td><td>U+FB01</td><td>fi</td></tr>
+ <tr><td>‘</td><td>U+2018</td><td>quoteleft</td><td>/</td><td>U+2044</td><td>fraction</td><td>fl</td><td>U+FB02</td><td>fl</td></tr>
+ <tr><td>’</td><td>U+2019</td><td>quoteright</td><td>€</td><td>U+20AC</td><td>Euro</td><td></td><td>U+F8FF</td><td>apple (Mac OS only)</td></tr>
+ </table>
+ <br> All other unicode characters or all other fonts (FL_FREE_FONT and above) are output as a bitmap.
+ <br> FLTK standard fonts are output using the corresponding PostScript standard fonts.
+ */
+class FL_EXPORT Fl_PostScript_Graphics_Driver : public Fl_Graphics_Driver {
+private:
+  void transformed_draw_extra(const char* str, int n, double x, double y, int w, bool rtl);
+  void *prepare_rle85();
+  void write_rle85(uchar b, void *data);
+  void close_rle85(void *data);
+  void *prepare85();
+  void write85(void *data, const uchar *p, int len);
+  void close85(void *data);
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  Fl_PostScript_Graphics_Driver();
+#ifndef FL_DOXYGEN
+  enum SHAPE{NONE=0, LINE, LOOP, POLYGON, POINTS};
+  
+class Clip {
+  public:
+    int x, y, w, h;
+    Clip *prev;
+  };
+  Clip * clip_;
+  
+  int lang_level_;
+  int gap_;
+  int pages_;
+  
+  double width_;
+  double height_;
+  
+  int shape_;
+  int linewidth_;// need for clipping, lang level 1-2
+  int linestyle_;//
+  int interpolate_; //interpolation of images
+  unsigned char cr_,cg_,cb_;
+  char  linedash_[256];//should be enough
+  void concat();  // transform ror scalable dradings...
+  void reconcat(); //invert
+  void recover(); //recovers the state after grestore (such as line styles...)
+  void reset();
+  
+  uchar * mask;
+  int mx; // width of mask;
+  int my; // mask lines
+  //Fl_Color bg_;
+  Fl_PostScript_Close_Command* close_cmd_;
+  int page_policy_;
+  int nPages;
+  int orientation_;
+  
+  float scale_x;
+  float scale_y;
+  float angle;
+  int left_margin;
+  int top_margin;
+ 
+  FILE *output;
+  double pw_, ph_;
+  
+  uchar bg_r, bg_g, bg_b;
+  int start_postscript (int pagecount, enum Fl_Paged_Device::Page_Format format, enum Fl_Paged_Device::Page_Layout layout);
+  /*  int alpha_mask(const uchar * data, int w, int h, int D, int LD=0);
+   */
+  void transformed_draw(const char* s, int n, double x, double y); //precise text placing
+  void transformed_draw(const char* s, double x, double y);
+  int alpha_mask(const uchar * data, int w, int h, int D, int LD=0);
+  
+  enum Fl_Paged_Device::Page_Format page_format_;
+  char *ps_filename_;
+ 
+  void page_policy(int p);
+  int page_policy(){return page_policy_;};
+  void close_command(Fl_PostScript_Close_Command* cmd){close_cmd_=cmd;};
+  FILE * file() {return output;};
+  //void orientation (int o);
+  //Fl_PostScript_Graphics_Driver(FILE *o, int lang_level, int pages = 0); // ps (also multi-page) constructor
+  //Fl_PostScript_Graphics_Driver(FILE *o, int lang_level, int x, int y, int w, int h); //eps constructor
+  void interpolate(int i){interpolate_=i;};
+  int interpolate(){return interpolate_;}
+  
+  void page(double pw, double ph, int media = 0);
+  void page(int format);
+#endif // FL_DOXYGEN
+  
+  // implementation of drawing methods
+  void color(Fl_Color c);
+  void color(uchar r, uchar g, uchar b);
+  
+  void push_clip(int x, int y, int w, int h);
+  int clip_box(int x, int y, int w, int h, int &X, int &Y, int &W, int &H);
+  int not_clipped(int x, int y, int w, int h);
+  void push_no_clip();
+  void pop_clip();
+  
+  void line_style(int style, int width=0, char* dashes=0);
+  
+  void rect(int x, int y, int w, int h);
+  void rectf(int x, int y, int w, int h);
+  
+  void xyline(int x, int y, int x1);
+  void xyline(int x, int y, int x1, int y2);
+  void xyline(int x, int y, int x1, int y2, int x3);
+  
+  void yxline(int x, int y, int y1);
+  void yxline(int x, int y, int y1, int x2);
+  void yxline(int x, int y, int y1, int x2, int y3);
+  
+  void line(int x1, int y1, int x2, int y2);
+  void line(int x1, int y1, int x2, int y2, int x3, int y3);  
+  
+  void loop(int x0, int y0, int x1, int y1, int x2, int y2);
+  void loop(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3);
+  void polygon(int x0, int y0, int x1, int y1, int x2, int y2);
+  void polygon(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3);
+  void point(int x, int y);
+  
+  void begin_points();
+  void begin_line();
+  void begin_loop();
+  void begin_polygon();
+  void vertex(double x, double y);
+  void curve(double x, double y, double x1, double y1, double x2, double y2, double x3, double y3);
+  void circle(double x, double y, double r);
+  void arc(double x, double y, double r, double start, double a);
+  void arc(int x, int y, int w, int h, double a1, double a2);
+  void pie(int x, int y, int w, int h, double a1, double a2);
+  void end_points();
+  void end_line();
+  void end_loop();
+  void end_polygon();
+  void begin_complex_polygon(){begin_polygon();};
+  void gap(){gap_=1;};
+  void end_complex_polygon(){end_polygon();};
+  void transformed_vertex(double x, double y);
+    
+  void draw_image(const uchar* d, int x,int y,int w,int h, int delta=3, int ldelta=0);
+  void draw_image_mono(const uchar* d, int x,int y,int w,int h, int delta=1, int ld=0);
+  void draw_image(Fl_Draw_Image_Cb call, void* data, int x,int y, int w, int h, int delta=3);
+  void draw_image_mono(Fl_Draw_Image_Cb call, void* data, int x,int y, int w, int h, int delta=1);
+      
+  void draw(const char* s, int nBytes, int x, int y) {transformed_draw(s,nBytes,x,y); };
+#ifdef __APPLE__
+  void draw(const char* s, int nBytes, float x, float y) {transformed_draw(s,nBytes,x,y); };
+#endif
+  void draw(int angle, const char *str, int n, int x, int y);
+  void rtl_draw(const char* s, int n, int x, int y);
+  void font(int face, int size);
+  double width(const char *, int);
+  double width(unsigned int u);
+  void text_extents(const char *c, int n, int &dx, int &dy, int &w, int &h);
+  int height();
+  int descent();
+  void draw(Fl_Pixmap * pxm,int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw(Fl_Bitmap * bitmap,int XP, int YP, int WP, int HP, int cx, int cy);
+  void draw(Fl_RGB_Image * rgb,int XP, int YP, int WP, int HP, int cx, int cy);
+  int draw_scaled(Fl_Image *img, int XP, int YP, int WP, int HP);
+  int clocale_printf(const char *format, ...);
+  ~Fl_PostScript_Graphics_Driver();
+};
+
+/**
+ To send graphical output to a PostScript file.
+ This class is used exactly as the Fl_Printer class except for the start_job() call,
+ two variants of which are usable and allow to specify what page format and layout are desired.
+ */
+class FL_EXPORT Fl_PostScript_File_Device : public Fl_Paged_Device {
+#ifdef __APPLE__
+  CGContextRef gc;
+#endif
+protected:
+  Fl_PostScript_Graphics_Driver *driver();
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  Fl_PostScript_File_Device();
+  ~Fl_PostScript_File_Device();
+  int start_job(int pagecount, int* from, int* to);
+  int start_job(int pagecount, enum Fl_Paged_Device::Page_Format format = Fl_Paged_Device::A4,
+		enum Fl_Paged_Device::Page_Layout layout = Fl_Paged_Device::PORTRAIT);
+  int start_job(FILE *ps_output, int pagecount, enum Fl_Paged_Device::Page_Format format = Fl_Paged_Device::A4, 
+		enum Fl_Paged_Device::Page_Layout layout = Fl_Paged_Device::PORTRAIT);
+  int start_page (void);
+  int printable_rect(int *w, int *h);
+  void margins(int *left, int *top, int *right, int *bottom);
+  void origin(int *x, int *y);
+  void origin(int x, int y);
+  void scale (float scale_x, float scale_y = 0.);
+  void rotate(float angle);
+  void translate(int x, int y);
+  void untranslate(void);
+  int end_page (void);    
+  void end_job(void);
+#ifdef __APPLE__
+  void set_current() { fl_gc = gc; Fl_Paged_Device::set_current(); }
+#endif
+  
+  static const char *file_chooser_title; 
+};
+
+#endif // Fl_PostScript_H
+
+//
+// End of "$Id$"
+//

msvc/fltk/include/FL/Fl_Preferences.H

@@ -0,0 +1,269 @@
+//
+// "$Id$"
+//
+// Preferences .
+//
+// Copyright 2002-2010 by Matthias Melcher.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Preferences class . */
+
+#ifndef Fl_Preferences_H
+#  define Fl_Preferences_H
+
+#  include <stdio.h>
+#  include "Fl_Export.H" 
+
+/**
+   \brief Fl_Preferences provides methods to store user
+   settings between application starts.
+
+   It is similar to the
+   Registry on WIN32 and Preferences on MacOS, and provides a
+   simple configuration mechanism for UNIX.
+
+   Fl_Preferences uses a hierarchy to store data. It
+   bundles similar data into groups and manages entries into those
+   groups as name/value pairs.
+
+   Preferences are stored in text files that can be edited
+   manually. The file format is easy to read and relatively
+   forgiving. Preferences files are the same on all platforms. User
+   comments in preference files are preserved. Filenames are unique
+   for each application by using a vendor/application naming
+   scheme. The user must provide default values for all entries to
+   ensure proper operation should preferences be corrupted or not
+   yet exist.
+
+   Entries can be of any length. However, the size of each
+   preferences file should be kept small for performance
+   reasons. One application can have multiple preferences files.
+   Extensive binary data however should be stored in separate
+   files: see getUserdataPath().
+
+   \note Starting with FLTK 1.3, preference databases are expected to
+   be in UTF-8 encoding. Previous databases were stored in the
+   current character set or code page which renders them incompatible
+   for text entries using international characters.
+ */
+class FL_EXPORT Fl_Preferences {
+
+public: 
+  /**
+     Define the scope of the preferences.
+   */
+  enum Root { 
+    SYSTEM=0,   ///< Preferences are used system-wide
+    USER        ///< Preferences apply only to the current user
+  };
+  
+  /**
+   Every Fl_Preferences-Group has a uniqe ID.
+   
+   ID's can be retrieved from an Fl_Preferences-Group and can then be used
+   to create more Fl_Preference references to the same data set, as long as the 
+   database remains open.
+   */
+  typedef void *ID;
+  
+  static const char *newUUID();
+
+  Fl_Preferences( Root root, const char *vendor, const char *application );
+  Fl_Preferences( const char *path, const char *vendor, const char *application );
+  Fl_Preferences( Fl_Preferences &parent, const char *group );
+  Fl_Preferences( Fl_Preferences *parent, const char *group );
+  Fl_Preferences( Fl_Preferences &parent, int groupIndex );
+  Fl_Preferences( Fl_Preferences *parent, int groupIndex );
+  Fl_Preferences(const Fl_Preferences&);
+  Fl_Preferences( ID id );
+  virtual ~Fl_Preferences();
+  
+  /** Return an ID that can later be reused to open more references to this dataset.
+   */
+  ID id() { return (ID)node; }
+  
+  /** Remove the group with this ID from a database.
+   */
+  static char remove(ID id_) { return ((Node*)id_)->remove(); }
+
+  /** Return the name of this entry.
+   */
+  const char *name() { return node->name(); }
+  
+  /** Return the full path to this entry.
+   */
+  const char *path() { return node->path(); }
+  
+  int groups();
+  const char *group( int num_group );
+  char groupExists( const char *key );
+  char deleteGroup( const char *group );
+  char deleteAllGroups();
+
+  int entries();
+  const char *entry( int index );
+  char entryExists( const char *key );
+  char deleteEntry( const char *entry );
+  char deleteAllEntries();
+  
+  char clear();
+
+  char set( const char *entry, int value );
+  char set( const char *entry, float value );
+  char set( const char *entry, float value, int precision );
+  char set( const char *entry, double value );
+  char set( const char *entry, double value, int precision );
+  char set( const char *entry, const char *value );
+  char set( const char *entry, const void *value, int size ); 
+  
+  char get( const char *entry, int &value, int defaultValue );
+  char get( const char *entry, float &value,  float defaultValue );
+  char get( const char *entry, double &value, double defaultValue );
+  char get( const char *entry, char *&value,  const char *defaultValue );
+  char get( const char *entry, char *value,   const char *defaultValue, int maxSize );
+  char get( const char *entry, void *&value,  const void *defaultValue, int defaultSize );
+  char get( const char *entry, void *value,   const void *defaultValue, int defaultSize, int maxSize );
+
+  int size( const char *entry );
+
+  char getUserdataPath( char *path, int pathlen );
+
+  void flush();
+
+  // char export( const char *filename, Type fileFormat );
+  // char import( const char *filename );
+  
+  /**
+     'Name' provides a simple method to create numerical or more complex
+     procedural names for entries and groups on the fly.
+     
+     Example: prefs.set(Fl_Preferences::Name("File%d",i),file[i]);.
+    
+     See test/preferences.cxx as a sample for writing arrays into preferences.
+
+     'Name' is actually implemented as a class inside Fl_Preferences. It casts
+     into const char* and gets automatically destroyed after the enclosing call
+     ends.
+   */
+  class FL_EXPORT Name {
+
+    char *data_;
+
+  public: 
+    Name( unsigned int n );
+    Name( const char *format, ... );
+
+    /**
+       Return the Name as a "C" string.
+       \internal
+     */
+    operator const char *() { return data_; }
+    ~Name();
+  };
+
+  /** \internal An entry associates a preference name to its corresponding value */
+  struct Entry {
+    char *name, *value;
+  };
+
+private: 
+  Fl_Preferences() : node(0), rootNode(0) { }
+  Fl_Preferences &operator=(const Fl_Preferences&);
+
+  static char nameBuffer[128];
+  static char uuidBuffer[40];
+  static Fl_Preferences *runtimePrefs;
+
+public:  // older Sun compilers need this (public definition of the following classes)
+  class RootNode;
+  
+  class FL_EXPORT Node {	// a node contains a list to all its entries 
+            			// and all means to manage the tree structure
+    Node *child_, *next_;
+    union { 			// these two are mutually exclusive
+      Node *parent_;   		// top_ bit clear
+      RootNode *root_; 		// top_ bit set
+    };
+    char *path_;
+    Entry *entry_;
+    int nEntry_, NEntry_;
+    unsigned char dirty_:1;
+    unsigned char top_:1;
+    unsigned char indexed_:1;
+    // indexing routines
+    Node **index_;
+    int nIndex_, NIndex_;
+    void createIndex();
+    void updateIndex();
+    void deleteIndex();
+  public:
+    static int lastEntrySet;
+  public:
+    Node( const char *path );
+    ~Node();
+    // node methods
+    int write( FILE *f );
+    const char *name();
+    const char *path() { return path_; }
+    Node *find( const char *path );
+    Node *search( const char *path, int offset=0 );
+    Node *childNode( int ix );
+    Node *addChild( const char *path );
+    void setParent( Node *parent );
+    Node *parent() { return top_?0L:parent_; }
+    void setRoot(RootNode *r) { root_ = r; top_ = 1; }
+    RootNode *findRoot();
+    char remove();
+    char dirty();
+    void deleteAllChildren();
+    // entry methods
+    int nChildren();
+    const char *child( int ix );
+    void set( const char *name, const char *value );
+    void set( const char *line );
+    void add( const char *line );
+    const char *get( const char *name );
+    int getEntry( const char *name );
+    char deleteEntry( const char *name );
+    void deleteAllEntries();
+    int nEntry() { return nEntry_; }
+    Entry &entry(int i) { return entry_[i]; }
+  };
+  friend class Node;
+
+  class FL_EXPORT RootNode {		// the root node manages file paths and basic reading and writing
+    Fl_Preferences *prefs_;
+    char *filename_;
+    char *vendor_, *application_;
+  public:
+    RootNode( Fl_Preferences *, Root root, const char *vendor, const char *application );
+    RootNode( Fl_Preferences *, const char *path, const char *vendor, const char *application );
+    RootNode( Fl_Preferences * );
+    ~RootNode();
+    int read();
+    int write();
+    char getPath( char *path, int pathlen );
+  };
+  friend class RootNode;
+
+protected:
+  Node *node;
+  RootNode *rootNode;
+};
+
+#endif // !Fl_Preferences_H
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Printer.H

@@ -0,0 +1,236 @@
+//
+// "$Id$"
+//
+// Printing support for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 2010-2014 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/** \file Fl_Printer.H 
+ \brief declaration of classes Fl_Printer, Fl_System_Printer and Fl_PostScript_Printer.
+ */
+
+#ifndef Fl_Printer_H
+#define Fl_Printer_H
+
+#include <FL/x.H>
+#include <FL/Fl_Paged_Device.H>
+#include <FL/fl_draw.H>
+#include <FL/Fl_Pixmap.H>
+#include <FL/Fl_RGB_Image.H>
+#include <FL/Fl_Bitmap.H>
+#include <stdio.h>
+#if !(defined(__APPLE__) || defined(WIN32))
+#include <FL/Fl_PostScript.H>
+#elif defined(WIN32)
+#include <commdlg.h>
+#endif
+
+#if defined(__APPLE__) || defined(WIN32) || defined(FL_DOXYGEN)
+/**
+ Print support under MSWindows and Mac OS.
+
+ Class Fl_System_Printer is implemented only on the MSWindows and Mac OS platforms.
+ It has no public constructor.
+ Use Fl_Printer instead that is cross-platform and has the same API.
+ */
+class Fl_System_Printer : public Fl_Paged_Device {
+  friend class Fl_Printer;
+private:
+  /** \brief the printer's graphics context, if there's one, NULL otherwise */
+  void *gc; 
+  void set_current(void);
+#ifdef __APPLE__
+  float scale_x;
+  float scale_y;
+  float angle; // rotation angle in radians
+  PMPrintSession  printSession;
+  PMPageFormat    pageFormat;
+  PMPrintSettings printSettings;
+#elif defined(WIN32)
+  int   abortPrint;
+  PRINTDLG      pd;
+  HDC           hPr;
+  int           prerr;
+  int left_margin;
+  int top_margin;
+  void absolute_printable_rect(int *x, int *y, int *w, int *h);
+#endif
+protected:
+  /** \brief The constructor */
+  Fl_System_Printer(void);
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  int start_job(int pagecount, int *frompage = NULL, int *topage = NULL);
+  int start_page (void);
+  int printable_rect(int *w, int *h);
+  void margins(int *left, int *top, int *right, int *bottom);
+  void origin(int *x, int *y);
+  void origin(int x, int y);
+  void scale (float scale_x, float scale_y = 0.);
+  void rotate(float angle);
+  void translate(int x, int y);
+  void untranslate(void);
+  int end_page (void);
+  void end_job (void);
+#ifdef __APPLE__
+  void print_window_part(Fl_Window *win, int x, int y, int w, int h, int delta_x, int delta_y);
+#endif
+  /** \brief The destructor */
+  ~Fl_System_Printer(void);
+}; // class Fl_System_Printer
+
+#endif
+  
+#if !(defined(__APPLE__) || defined(WIN32) )
+/**
+ Print support under Unix/Linux.
+ 
+ Class Fl_PostScript_Printer is implemented only on the Unix/Linux platform.
+ It has no public constructor.
+ Use Fl_Printer instead that is cross-platform and has the same API.
+ */
+class Fl_PostScript_Printer : public Fl_PostScript_File_Device {
+  friend class Fl_Printer;
+protected:
+  /** The constructor */
+  Fl_PostScript_Printer(void) {};
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  int start_job(int pages, int *firstpage = NULL, int *lastpage = NULL);
+};
+
+#endif
+
+/**
+ * \brief OS-independent print support.
+ *
+ Fl_Printer allows to use all drawing, color, text, image, and clip FLTK functions, and to have them operate
+ on printed page(s). There are two main, non exclusive, ways to use it.
+ <ul><li>Print any widget (standard, custom, Fl_Window, Fl_Gl_Window) as it appears 
+ on screen, with optional translation, scaling and rotation. This is done by calling print_widget(), 
+ print_window() or print_window_part().
+ <li>Use a series of FLTK graphics commands (e.g., font, text, lines, colors, clip, image) to
+ compose a page appropriately shaped for printing. 
+ </ul>
+ In both cases, begin by start_job(), start_page(), printable_rect() and origin() calls
+ and finish by end_page() and end_job() calls.
+ <p>Example of use: print a widget centered in a page
+ \code
+ #include <FL/Fl_Printer.H>
+ #include <FL/fl_draw.H>
+ int width, height;
+ Fl_Widget *widget = ...  // a widget we want printed
+ Fl_Printer *printer = new Fl_Printer();
+ if (printer->start_job(1) == 0) {
+  printer->start_page();
+  printer->printable_rect(&width, &height);
+  fl_color(FL_BLACK);
+  fl_line_style(FL_SOLID, 2);
+  fl_rect(0, 0, width, height);
+  fl_font(FL_COURIER, 12);
+  time_t now; time(&now); fl_draw(ctime(&now), 0, fl_height());
+  printer->origin(width/2, height/2);
+  printer->print_widget(widget, -widget->w()/2, -widget->h()/2);
+  printer->end_page();
+  printer->end_job();
+ }
+ delete printer;
+ \endcode
+ <b>Platform specifics</b>
+ <ul>
+ <li>Unix/Linux platforms:
+ Unless it has been previously changed, the default paper size is A4.
+ To change that, press the "Properties" button of the "Print" dialog window
+ opened by an Fl_Printer::start_job() call. This opens a "Printer Properties" window where it's
+ possible to select the adequate paper size. Finally press the "Save" button therein to assign
+ the chosen paper size to the chosen printer for this and all further print operations.
+ <br>Class Fl_RGB_Image prints but loses its transparency if it has one.
+ See class Fl_PostScript_Graphics_Driver for a description of how UTF-8 strings appear in print.
+ Use the static public attributes of this class to set the print dialog to other languages 
+ than English. For example, the "Printer:" dialog item Fl_Printer::dialog_printer can be set to French with:
+ \code
+ Fl_Printer::dialog_printer = "Imprimante:";
+ \endcode
+ before creation of the Fl_Printer object.
+ Use Fl_PostScript_File_Device::file_chooser_title to customize the title of the file chooser dialog that opens
+ when using the "Print To File" option of the print dialog. 
+ <li>MSWindows platform: Transparent Fl_RGB_Image 's don't print with exact transparency on most printers.
+ Fl_RGB_Image 's don't rotate() well.
+ A workaround is to use the print_window_part() call. 
+ <li>Mac OS X platform: all graphics requests print as on display.
+ </ul>
+ */
+class FL_EXPORT Fl_Printer : public Fl_Paged_Device {
+public:
+  static const char *class_id;
+  const char *class_name() {return class_id;};
+  /** \brief The constructor */
+  Fl_Printer(void);
+  int start_job(int pagecount, int *frompage = NULL, int *topage = NULL);
+  int start_page(void);
+  int printable_rect(int *w, int *h);
+  void margins(int *left, int *top, int *right, int *bottom);
+  void origin(int *x, int *y);
+  void origin(int x, int y);
+  void scale(float scale_x, float scale_y = 0.);
+  void rotate(float angle);
+  void translate(int x, int y);
+  void untranslate(void);
+  int end_page (void);
+  void end_job (void);
+  void print_widget(Fl_Widget* widget, int delta_x=0, int delta_y=0);
+  void print_window_part(Fl_Window *win, int x, int y, int w, int h, int delta_x=0, int delta_y=0);
+  void set_current(void);
+  Fl_Graphics_Driver* driver(void);
+  /** \brief The destructor */
+  ~Fl_Printer(void);
+ 
+  /** \name These attributes are effective under the Xlib platform only.
+   \{
+   */  
+  static const char *dialog_title; 
+  static const char *dialog_printer; 
+  static const char *dialog_range; 
+  static const char *dialog_copies; 
+  static const char *dialog_all; 
+  static const char *dialog_pages;
+  static const char *dialog_from;
+  static const char *dialog_to;
+  static const char *dialog_properties;
+  static const char *dialog_copyNo;
+  static const char *dialog_print_button;
+  static const char *dialog_cancel_button;
+  static const char *dialog_print_to_file;
+  static const char *property_title;
+  static const char *property_pagesize;
+  static const char *property_mode;
+  static const char *property_use;
+  static const char *property_save;
+  static const char *property_cancel;
+  /** \} */ 
+private:
+#if defined(WIN32) || defined(__APPLE__)
+  Fl_System_Printer *printer;
+#else
+  Fl_PostScript_Printer *printer;
+#endif
+};
+
+#endif // Fl_Printer_H
+
+//
+// End of "$Id$"
+//

msvc/fltk/include/FL/Fl_Progress.H

@@ -0,0 +1,72 @@
+//
+// "$Id$"
+//
+// Progress bar widget definitions.
+//
+// Copyright 2000-2010 by Michael Sweet.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Progress widget . */
+
+#ifndef _Fl_Progress_H_
+#  define _Fl_Progress_H_
+
+//
+// Include necessary headers.
+//
+
+#include "Fl_Widget.H"
+
+
+//
+// Progress class...
+//
+/**
+    Displays a progress bar for the user.
+*/
+class FL_EXPORT Fl_Progress : public Fl_Widget {
+  
+  float	value_,
+	minimum_,
+	maximum_;
+
+  protected:
+
+  virtual void draw();
+
+  public:
+
+  Fl_Progress(int x, int y, int w, int h, const char *l = 0);
+
+  /** Sets the maximum value in the progress widget.  */
+  void	maximum(float v) { maximum_ = v; redraw(); }
+  /** Gets the maximum value in the progress widget.  */
+  float	maximum() const { return (maximum_); }
+
+  /** Sets the minimum value in the progress widget.  */
+  void	minimum(float v) { minimum_ = v; redraw(); }
+  /** Gets the minimum value in the progress widget.  */
+  float	minimum() const { return (minimum_); }
+
+  /** Sets the current value in the progress widget.  */
+  void	value(float v) { value_ = v; redraw(); }
+  /** Gets the current value in the progress widget.  */
+  float	value() const { return (value_); }
+};
+
+#endif // !_Fl_Progress_H_
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_RGB_Image.H

@@ -0,0 +1,26 @@
+//
+// "$Id$"
+//
+// RGB Image header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+#ifndef Fl_RGB_Image_H
+# define Fl_RGB_Image_H
+# include "Fl_Image.H"
+#endif // !Fl_RGB_Image_H
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Radio_Button.H

@@ -0,0 +1,36 @@
+//
+// "$Id$"
+//
+// Radio button header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2014 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Radio_Button widget . */
+
+#ifndef Fl_Radio_Button_H
+#define Fl_Radio_Button_H
+
+#include "Fl_Button.H"
+
+class FL_EXPORT Fl_Radio_Button : public Fl_Button {
+public:
+  Fl_Radio_Button(int X,int Y,int W,int H,const char *L=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Radio_Light_Button.H

@@ -0,0 +1,36 @@
+//
+// "$Id$"
+//
+// Radio light button header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2014 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Radio_Light_Button widget . */
+
+#ifndef Fl_Radio_Light_Button_H
+#define Fl_Radio_Light_Button_H
+
+#include "Fl_Light_Button.H"
+
+class FL_EXPORT Fl_Radio_Light_Button : public Fl_Light_Button {
+public:
+  Fl_Radio_Light_Button(int X,int Y,int W,int H,const char *l=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Radio_Round_Button.H

@@ -0,0 +1,36 @@
+//
+// "$Id$"
+//
+// Radio round button header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2014 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Radio_Round_Button widget . */
+
+#ifndef Fl_Radio_Round_Button_H
+#define Fl_Radio_Round_Button_H
+
+#include "Fl_Round_Button.H"
+
+class FL_EXPORT Fl_Radio_Round_Button : public Fl_Round_Button {
+public:
+  Fl_Radio_Round_Button(int X,int Y,int W,int H,const char *L=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Repeat_Button.H

@@ -0,0 +1,54 @@
+//
+// "$Id$"
+//
+// Repeat button header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Repeat_Button widget . */
+
+#ifndef Fl_Repeat_Button_H
+#define Fl_Repeat_Button_H
+#include "Fl.H"
+#include "Fl_Button.H"
+
+/**
+  The Fl_Repeat_Button is a subclass of Fl_Button that
+  generates a callback when it is pressed and then repeatedly generates
+  callbacks as long as it is held down.  The speed of the repeat is fixed
+  and depends on the implementation.
+*/
+class FL_EXPORT Fl_Repeat_Button : public Fl_Button {
+  static void repeat_callback(void *);
+public:
+  int handle(int);
+  /**
+    Creates a new Fl_Repeat_Button widget using the given
+    position, size, and label string. The default boxtype is FL_UP_BOX.
+    Deletes the button.
+  */
+  Fl_Repeat_Button(int X,int Y,int W,int H,const char *l=0);
+
+  void deactivate() {
+    Fl::remove_timeout(repeat_callback,this);
+    Fl_Button::deactivate();
+  }
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Return_Button.H

@@ -0,0 +1,50 @@
+//
+// "$Id$"
+//
+// Return button header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Return_Button widget . */
+
+#ifndef Fl_Return_Button_H
+#define Fl_Return_Button_H
+#include "Fl_Button.H"
+
+/**
+  The Fl_Return_Button is a subclass of Fl_Button that
+  generates a callback when it is pressed or when the user presses the
+  Enter key.  A carriage-return symbol is drawn next to the button label.
+  <P ALIGN=CENTER>\image html Fl_Return_Button.png 
+  \image latex Fl_Return_Button.png "Fl_Return_Button" width=4cm
+*/
+class FL_EXPORT Fl_Return_Button : public Fl_Button {
+protected:
+  void draw();
+public:
+  int handle(int);
+  /**
+    Creates a new Fl_Return_Button widget using the given
+    position, size, and label string. The default boxtype is FL_UP_BOX.
+    <P> The inherited destructor deletes the button.
+  */
+  Fl_Return_Button(int X, int Y, int W, int H,const char *l=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Roller.H

@@ -0,0 +1,47 @@
+//
+// "$Id$"
+//
+// Roller header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Roller widget . */
+
+#ifndef Fl_Roller_H
+#define Fl_Roller_H
+
+#ifndef Fl_Valuator_H
+#include "Fl_Valuator.H"
+#endif
+
+/**
+  The Fl_Roller widget is a "dolly" control commonly used to
+  move 3D objects.
+  <P ALIGN=CENTER>\image html Fl_Roller.png 
+  \image latex Fl_Roller.png "Fl_Roller" width=4cm
+*/
+class FL_EXPORT Fl_Roller : public Fl_Valuator {
+protected:
+  void draw();
+public:
+  int handle(int);
+  Fl_Roller(int X,int Y,int W,int H,const char* L=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Round_Button.H

@@ -0,0 +1,45 @@
+//
+// "$Id$"
+//
+// Round button header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2014 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+#ifndef Fl_Round_Button_H
+#define Fl_Round_Button_H
+
+#include "Fl_Light_Button.H"
+
+/**
+  Buttons generate callbacks when they are clicked by the user.  You
+  control exactly when and how by changing the values for type()
+  and when().
+  <P ALIGN=CENTER>\image html Fl_Round_Button.png</P>
+  \image latex  Fl_Round_Button.png " Fl_Round_Button" width=4cm
+  <P>The Fl_Round_Button subclass display the "on" state by
+  turning on a light, rather than drawing pushed in.  The shape of the
+  "light" is initially set to FL_ROUND_DOWN_BOX.  The color of the light
+  when on is controlled with selection_color(), which defaults to
+  FL_FOREGROUND_COLOR.
+*/
+class FL_EXPORT Fl_Round_Button : public Fl_Light_Button {
+public:
+  Fl_Round_Button(int x,int y,int w,int h,const char *l = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Round_Clock.H

@@ -0,0 +1,38 @@
+//
+// "$Id$"
+//
+// Round clock header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Round_Clock widget . */
+
+#ifndef Fl_Round_Clock_H
+#define Fl_Round_Clock_H
+
+#include "Fl_Clock.H"
+
+/** A clock widget of type FL_ROUND_CLOCK. Has no box. */
+class FL_EXPORT Fl_Round_Clock : public Fl_Clock {
+public:
+  /** Creates the clock widget, setting his type and box. */
+  Fl_Round_Clock(int X,int Y,int W,int H, const char *L = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Scroll.H

@@ -0,0 +1,209 @@
+//
+// "$Id$"
+//
+// Scroll header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2015 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Scroll widget . */
+
+#ifndef Fl_Scroll_H
+#define Fl_Scroll_H
+
+#include "Fl_Group.H"
+#include "Fl_Scrollbar.H"
+
+/**
+  This container widget lets you maneuver around a set of widgets much
+  larger than your window.  If the child widgets are larger than the size
+  of this object then scrollbars will appear so that you can scroll over
+  to them:
+  \image html Fl_Scroll.png
+  \image latex  Fl_Scroll.png "Fl_Scroll" width=4cm
+
+  If all of the child widgets are packed together into a solid
+  rectangle then you want to set box() to FL_NO_BOX or
+  one of the _FRAME types. This will result in the best output.
+  However, if the child widgets are a sparse arrangement you must
+  set box() to a real _BOX type. This can result in some
+  blinking during redrawing, but that can be solved by using a
+  Fl_Double_Window.
+
+  By default you can scroll in both directions, and the scrollbars
+  disappear if the data will fit in the area of the scroll.
+
+  Use Fl_Scroll::type() to change this as follows :
+
+  - 0                            - No scrollbars
+  - Fl_Scroll::HORIZONTAL        - Only a horizontal scrollbar.
+  - Fl_Scroll::VERTICAL          - Only a vertical scrollbar.
+  - Fl_Scroll::BOTH              - The default is both scrollbars.
+  - Fl_Scroll::HORIZONTAL_ALWAYS - Horizontal scrollbar always on, vertical always off.
+  - Fl_Scroll::VERTICAL_ALWAYS   - Vertical scrollbar always on, horizontal always off.
+  - Fl_Scroll::BOTH_ALWAYS       - Both always on.
+
+  Use <B> scrollbar.align(int) ( see void Fl_Widget::align(Fl_Align) ) :</B>
+  to change what side the scrollbars are drawn on.
+
+  If the FL_ALIGN_LEFT bit is on, the vertical scrollbar is on the left.
+  If the FL_ALIGN_TOP bit is on, the horizontal scrollbar is on
+  the top. Note that only the alignment flags in scrollbar are
+  considered. The flags in hscrollbar however are ignored.
+
+  This widget can also be used to pan around a single child widget
+  "canvas".  This child widget should be of your own class, with a
+  draw() method that draws the contents.  The scrolling is done by
+  changing the x() and y() of the widget, so this child
+  must use the x() and y() to position its drawing.
+  To speed up drawing it should test fl_not_clipped(int x,int y,int w,int h)
+  to find out if a particular area of the widget must be drawn.
+
+  Another very useful child is a single Fl_Pack, which is itself a group
+  that packs its children together and changes size to surround them.
+  Filling the Fl_Pack with Fl_Tabs groups (and then putting
+  normal widgets inside those) gives you a very powerful scrolling list
+  of individually-openable panels.
+
+  Fluid lets you create these, but you can only lay out objects that
+  fit inside the Fl_Scroll without scrolling.  Be sure to leave
+  space for the scrollbars, as Fluid won't show these either.
+
+  <I>You cannot use Fl_Window as a child of this since the
+  clipping is not conveyed to it when drawn, and it will draw over the
+  scrollbars and neighboring objects.</I>
+*/
+class FL_EXPORT Fl_Scroll : public Fl_Group {
+
+  int xposition_, yposition_;
+  int oldx, oldy;
+  int scrollbar_size_;
+  static void hscrollbar_cb(Fl_Widget*, void*);
+  static void scrollbar_cb(Fl_Widget*, void*);
+  void fix_scrollbar_order();
+  static void draw_clip(void*,int,int,int,int);
+
+#if FLTK_ABI_VERSION >= 10303
+protected:	// NEW (STR#1895)
+#else
+private:	// OLD
+#endif
+  /**
+    Structure to manage scrollbar and widget interior sizes.
+    This is filled out by recalc_scrollbars() for use in calculations
+    that need to know the visible scroll area size, etc.
+    \note Availability in FLTK_ABI_VERSION 10303 or higher.
+  */
+  typedef struct {
+    /// A local struct to manage a region defined by xywh
+    typedef struct { int x,y,w,h; } Fl_Region_XYWH;
+    /// A local struct to manage a region defined by left/right/top/bottom
+    typedef struct {
+      int l;			///< (l)eft "x" position, aka x1
+      int r;			///< (r)ight "x" position, aka x2
+      int t;			///< (t)op "y" position, aka y1
+      int b;			///< (b)ottom "y" position, aka y2
+    } Fl_Region_LRTB;
+    /// A local struct to manage a scrollbar's xywh region and tab values
+    typedef struct {
+      int x,y,w,h;
+      int pos;			///< scrollbar tab's "position of first line displayed"
+      int size;			///< scrollbar tab's "size of window in lines"
+      int first;		///< scrollbar tab's "number of first line"
+      int total;		///< scrollbar tab's "total number of lines"
+    } Fl_Scrollbar_Data;
+    int scrollsize;		///< the effective scrollbar thickness (local or global)
+    Fl_Region_XYWH innerbox;	///< widget's inner box, excluding scrollbars
+    Fl_Region_XYWH innerchild;	///< widget's inner box, including scrollbars
+    Fl_Region_LRTB child;	///< child bounding box: left/right/top/bottom
+    int hneeded;		///< horizontal scrollbar visibility
+    int vneeded;		///< vertical scrollbar visibility
+    Fl_Scrollbar_Data hscroll;	///< horizontal scrollbar region + values
+    Fl_Scrollbar_Data vscroll;	///< vertical scrollbar region + values
+  } ScrollInfo;
+  void recalc_scrollbars(ScrollInfo &si);
+
+protected:
+
+  void bbox(int&,int&,int&,int&);
+  void draw();
+
+public:
+
+  Fl_Scrollbar scrollbar;
+  Fl_Scrollbar hscrollbar;
+
+  void resize(int X, int Y, int W, int H);
+  int handle(int);
+
+  Fl_Scroll(int X,int Y,int W,int H,const char*l=0);
+
+  enum { // values for type()
+    HORIZONTAL = 1,
+    VERTICAL = 2,
+    BOTH = 3,
+    ALWAYS_ON = 4,
+    HORIZONTAL_ALWAYS = 5,
+    VERTICAL_ALWAYS = 6,
+    BOTH_ALWAYS = 7
+  };
+
+  /**    Gets the current horizontal scrolling position.  */
+  int xposition() const {return xposition_;}
+  /**    Gets the current vertical scrolling position.  */
+  int yposition() const {return yposition_;}
+  void scroll_to(int, int);
+  void clear();
+  /**
+    Gets the current size of the scrollbars' troughs, in pixels.
+
+    If this value is zero (default), this widget will use the
+    Fl::scrollbar_size() value as the scrollbar's width.
+
+    \returns Scrollbar size in pixels, or 0 if the global Fl::scrollbar_size() is being used.
+    \see Fl::scrollbar_size(int)
+  */
+  int scrollbar_size() const {
+      return(scrollbar_size_);
+  }
+  /**
+    Sets the pixel size of the scrollbars' troughs to \p newSize, in pixels.
+
+    Normally you should not need this method, and should use
+    Fl::scrollbar_size(int) instead to manage the size of ALL
+    your widgets' scrollbars. This ensures your application
+    has a consistent UI, is the default behavior, and is normally
+    what you want.
+
+    Only use THIS method if you really need to override the global
+    scrollbar size. The need for this should be rare.
+
+    Setting \p newSize to the special value of 0 causes the widget to
+    track the global Fl::scrollbar_size(), which is the default.
+
+    \param[in] newSize Sets the scrollbar size in pixels.\n
+                    If 0 (default), scrollbar size tracks the global Fl::scrollbar_size()
+    \see Fl::scrollbar_size()
+  */
+  void scrollbar_size(int newSize) {
+      if ( newSize != scrollbar_size_ ) redraw();
+      scrollbar_size_ = newSize;
+  }
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Scrollbar.H

@@ -0,0 +1,111 @@
+//
+// "$Id$"
+//
+// Scroll bar header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Scrollbar widget . */
+
+#ifndef Fl_Scrollbar_H
+#define Fl_Scrollbar_H
+
+#include "Fl_Slider.H"
+
+/**
+  The Fl_Scrollbar widget displays a slider with arrow buttons at
+  the ends of the scrollbar. Clicking on the arrows move up/left and
+  down/right by linesize(). Scrollbars also accept FL_SHORTCUT events:
+  the arrows move by linesize(), and vertical scrollbars take Page
+  Up/Down (they move by the page size minus linesize()) and Home/End
+  (they jump to the top or bottom).
+
+  Scrollbars have step(1) preset (they always return integers). If
+  desired you can set the step() to non-integer values. You will then
+  have to use casts to get at the floating-point versions of value()
+  from Fl_Slider.
+
+  \image html  scrollbar.png 
+  \image latex scrollbar.png "Fl_Scrollbar" width=4cm
+*/
+class FL_EXPORT Fl_Scrollbar : public Fl_Slider {
+
+  int linesize_;
+  int pushed_;
+  static void timeout_cb(void*);
+  void increment_cb();
+protected:
+  void draw();
+
+public:
+
+  Fl_Scrollbar(int X,int Y,int W,int H, const char *L = 0);
+  ~Fl_Scrollbar();
+  int handle(int);
+
+  /**
+    Gets the integer value (position) of the slider in the scrollbar.
+    You can get the floating point value with Fl_Slider::value().
+
+    \see Fl_Scrollbar::value(int p)
+    \see Fl_Scrollbar::value(int pos, int size, int first, int total)
+  */
+  int value() const {return int(Fl_Slider::value());}
+
+  /**
+    Sets the value (position) of the slider in the scrollbar.
+
+    \see Fl_Scrollbar::value()
+    \see Fl_Scrollbar::value(int pos, int size, int first, int total)
+  */
+  int value(int p) {return int(Fl_Slider::value((double)p));}
+
+  /**
+    Sets the position, size and range of the slider in the scrollbar.
+    \param[in] pos   position, first line displayed
+    \param[in] windowSize  number of lines displayed
+    \param[in] first number of first line
+    \param[in] total total number of lines
+
+    You should call this every time your window changes size, your data
+    changes size, or your scroll position changes (even if in response
+    to a callback from this scrollbar).
+    All necessary calls to redraw() are done.
+
+    Calls Fl_Slider::scrollvalue(int pos, int size, int first, int total).
+  */
+  int value(int pos, int windowSize, int first, int total) {
+    return scrollvalue(pos, windowSize, first, total);
+  }
+
+  /**
+    Get the size of step, in lines, that the arror keys move.
+  */
+  int linesize() const {return linesize_;}
+
+  /**
+    This number controls how big the steps are that the arrow keys do.
+    In addition page up/down move by the size last sent to value()
+    minus one linesize().  The default is 16.
+  */
+  void linesize(int i) {linesize_ = i;}
+
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Secret_Input.H

@@ -0,0 +1,51 @@
+//
+// "$Id$"
+//
+// Secret input header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Secret_Input widget . */
+
+#ifndef Fl_Secret_Input_H
+#define Fl_Secret_Input_H
+
+#include "Fl_Input.H"
+
+/**
+  The Fl_Secret_Input class is a subclass of Fl_Input that displays its
+  input as a string of placeholders. Depending on the platform this
+  placeholder is either the asterisk ('*') or the Unicode bullet
+  character (U+2022).
+
+  This subclass is usually used to receive passwords and other "secret" information.
+*/
+class FL_EXPORT Fl_Secret_Input : public Fl_Input {
+public:
+  /**
+    Creates a new Fl_Secret_Input widget using the given
+    position, size, and label string. The default boxtype is FL_DOWN_BOX.
+
+    Inherited destructor destroys the widget and any value associated with it.
+  */
+  Fl_Secret_Input(int X,int Y,int W,int H,const char *l = 0);
+  int handle(int);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Select_Browser.H

@@ -0,0 +1,50 @@
+//
+// "$Id$"
+//
+// Select browser header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Select_Browser widget . */
+
+#ifndef Fl_Select_Browser_H
+#define Fl_Select_Browser_H
+
+#include "Fl_Browser.H"
+
+/**
+  The class is a subclass of Fl_Browser
+  which lets the user select a single item, or no items by clicking on
+  the empty space.  As long as the mouse button is held down on an
+  unselected item it is highlighted. Normally the callback is done when the
+  user presses the mouse, but you can change this with when().
+  <P>See Fl_Browser for  methods to add and remove lines from the browser.
+*/
+class FL_EXPORT Fl_Select_Browser : public Fl_Browser {
+public:
+  /**
+    Creates a new Fl_Select_Browser widget using the given
+    position, size, and label string. The default boxtype is FL_DOWN_BOX.
+    The constructor specializes Fl_Browser() by setting the type to FL_SELECT_BROWSER.
+    The destructor destroys the widget and frees all memory that has been allocated.
+  */
+  Fl_Select_Browser(int X,int Y,int W,int H,const char *L=0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Shared_Image.H

@@ -0,0 +1,144 @@
+//
+// "$Id$"
+//
+// Shared image header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2017 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/** \file
+   Fl_Shared_Image class. */
+
+#ifndef Fl_Shared_Image_H
+#  define Fl_Shared_Image_H
+
+#  include "Fl_Image.H"
+
+
+// Test function for adding new formats
+typedef Fl_Image *(*Fl_Shared_Handler)(const char *name, uchar *header,
+                                       int headerlen);
+
+// Shared images class.
+/**
+  This class supports caching, loading, scaling, and drawing of image files.
+
+  Most applications will also want to link against the fltk_images library
+  and call the fl_register_images() function to support standard image
+  formats such as BMP, GIF, JPEG, and PNG.
+
+  Images can be requested (loaded) with Fl_Shared_Image::get(), find(),
+  and some other methods. All images are cached in an internal list of
+  shared images and should be released when they are no longer needed.
+  A refcount is used to determine if a released image is to be destroyed
+  with delete.
+
+  \see Fl_Shared_Image::get()
+  \see Fl_Shared_Image::find()
+  \see Fl_Shared_Image::release()
+*/
+class FL_EXPORT Fl_Shared_Image : public Fl_Image {
+
+  friend class Fl_JPEG_Image;
+  friend class Fl_PNG_Image;
+
+private:
+  static Fl_RGB_Scaling scaling_algorithm_; // method used to rescale RGB source images
+#if FLTK_ABI_VERSION >= 10304
+  Fl_Image *scaled_image_;
+#endif
+protected:
+
+  static Fl_Shared_Image **images_;	// Shared images
+  static int	num_images_;		// Number of shared images
+  static int	alloc_images_;		// Allocated shared images
+  static Fl_Shared_Handler *handlers_;	// Additional format handlers
+  static int	num_handlers_;		// Number of format handlers
+  static int	alloc_handlers_;	// Allocated format handlers
+
+  const char	*name_;			// Name of image file
+  int		original_;		// Original image?
+  int		refcount_;		// Number of times this image has been used
+  Fl_Image	*image_;		// The image that is shared
+  int		alloc_image_;		// Was the image allocated?
+
+  static int	compare(Fl_Shared_Image **i0, Fl_Shared_Image **i1);
+
+  // Use get() and release() to load/delete images in memory...
+  Fl_Shared_Image();
+  Fl_Shared_Image(const char *n, Fl_Image *img = 0);
+  virtual ~Fl_Shared_Image();
+  void add();
+  void update();
+
+public:
+  /** Returns the filename of the shared image */
+  const char	*name() { return name_; }
+
+  /** Returns the number of references of this shared image.
+    When reference is below 1, the image is deleted.
+  */
+  int		refcount() { return refcount_; }
+
+  /** Returns whether this is an original image.
+    Images loaded from a file or from memory are marked \p original as
+    opposed to images created as a copy of another image with different
+    size (width or height).
+    \note This is useful for debugging (rarely used in user code).
+    \since FLTK 1.4.0
+  */
+  int original() { return original_; }
+
+  void		release();
+  void		reload();
+
+  virtual Fl_Image *copy(int W, int H);
+  Fl_Image *copy() { return copy(w(), h()); }
+  virtual void color_average(Fl_Color c, float i);
+  virtual void desaturate();
+  virtual void draw(int X, int Y, int W, int H, int cx, int cy);
+  void draw(int X, int Y) { draw(X, Y, w(), h(), 0, 0); }
+  void scale(int width, int height, int proportional = 1, int can_expand = 0);
+  virtual void uncache();
+
+  static Fl_Shared_Image *find(const char *name, int W = 0, int H = 0);
+  static Fl_Shared_Image *get(const char *name, int W = 0, int H = 0);
+  static Fl_Shared_Image *get(Fl_RGB_Image *rgb, int own_it = 1);
+  static Fl_Shared_Image **images();
+  static int		num_images();
+  static void		add_handler(Fl_Shared_Handler f);
+  static void		remove_handler(Fl_Shared_Handler f);
+  /** Sets what algorithm is used when resizing a source image.
+   The default algorithm is FL_RGB_SCALING_BILINEAR.
+   Drawing an Fl_Shared_Image is sometimes performed by first resizing the source image
+   and then drawing the resized copy. This occurs, e.g., when drawing to screen under Linux or MSWindows
+   after having called Fl_Shared_Image::scale().
+   This function controls what method is used when the image to be resized is an Fl_RGB_Image.
+   \version 1.3.4 and requires compiling with FLTK_ABI_VERSION = 10304
+   */
+  static void scaling_algorithm(Fl_RGB_Scaling algorithm) {scaling_algorithm_ = algorithm; }
+};
+
+//
+// The following function is provided in the fltk_images library and
+// registers all of the "extra" image file formats that are not part
+// of the core FLTK library...
+//
+
+FL_EXPORT extern void fl_register_images();
+
+#endif // !Fl_Shared_Image_H
+
+//
+// End of "$Id$"
+//

msvc/fltk/include/FL/Fl_Simple_Counter.H

@@ -0,0 +1,40 @@
+//
+// "$Id$"
+//
+// Simple counter header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Simple_Counter widget . */
+
+#ifndef Fl_Simple_Counter_H
+#define Fl_Simple_Counter_H
+
+#include "Fl_Counter.H"
+/** 
+  This widget creates a counter with only 2 arrow buttons 
+  <P align=center>\image html counter.png</P> 
+  \image latex  counter.png "Fl_Simple_Counter" width=4cm
+*/
+class FL_EXPORT Fl_Simple_Counter : public Fl_Counter {
+public:
+  Fl_Simple_Counter(int X,int Y,int W,int H, const char *L = 0);
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Single_Window.H

@@ -0,0 +1,58 @@
+//
+// "$Id$"
+//
+// Single-buffered window header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2015 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Single_Window class . */
+
+#ifndef Fl_Single_Window_H
+#define Fl_Single_Window_H
+
+#include "Fl_Window.H"
+
+/**
+  This is the same as Fl_Window.  However, it is possible that
+  some implementations will provide double-buffered windows by default.
+  This subclass can be used to force single-buffering.  This may be
+  useful for modifying existing programs that use incremental update, or
+  for some types of image data, such as a movie flipbook.
+*/
+class FL_EXPORT Fl_Single_Window : public Fl_Window {
+public:
+  void show();
+  void show(int a, char **b) {Fl_Window::show(a,b);}
+  void flush();
+   /**
+    Creates a new Fl_Single_Window widget using the given
+    size, and label (title) string.
+  */
+  Fl_Single_Window(int W, int H, const char *l=0);
+
+  /**
+    Creates a new Fl_Single_Window widget using the given
+    position, size, and label (title) string.
+  */
+  Fl_Single_Window(int X, int Y, int W, int H, const char *l=0);
+  
+  int make_current();
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Slider.H

@@ -0,0 +1,111 @@
+//
+// "$Id$"
+//
+// Slider header file for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Slider widget . */
+
+#ifndef Fl_Slider_H
+#define Fl_Slider_H
+
+#ifndef Fl_Valuator_H
+#include "Fl_Valuator.H"
+#endif
+
+// values for type(), lowest bit indicate horizontal:
+#define FL_VERT_SLIDER		0
+#define FL_HOR_SLIDER		1
+#define FL_VERT_FILL_SLIDER	2
+#define FL_HOR_FILL_SLIDER	3
+#define FL_VERT_NICE_SLIDER	4
+#define FL_HOR_NICE_SLIDER	5
+
+/**
+  The Fl_Slider widget contains a sliding knob inside a box. It is
+  often used as a scrollbar.  Moving the box all the way to the
+  top/left sets it to the minimum(), and to the bottom/right to the
+  maximum().  The minimum() may be greater than the maximum() to
+  reverse the slider direction.
+
+  Use void Fl_Widget::type(int) to set how the slider is drawn, 
+  which can be one of the following:
+  
+  \li FL_VERTICAL - Draws a vertical slider (this is the default).
+  \li FL_HORIZONTAL - Draws a horizontal slider.
+  \li FL_VERT_FILL_SLIDER - Draws a filled vertical slider,
+      useful as a progress or value meter.
+  \li FL_HOR_FILL_SLIDER - Draws a filled horizontal  slider,
+      useful as a progress or value meter.
+  \li FL_VERT_NICE_SLIDER - Draws a vertical slider with  a nice
+      looking control knob.
+  \li FL_HOR_NICE_SLIDER - Draws a horizontal slider with  a
+      nice looking control knob.
+
+  \image html  slider.png 
+  \image latex slider.png "Fl_Slider" width=4cm
+*/
+class FL_EXPORT Fl_Slider : public Fl_Valuator {
+
+  float slider_size_;
+  uchar slider_;
+  void _Fl_Slider();
+  void draw_bg(int, int, int, int);
+
+protected:
+
+  // these allow subclasses to put the slider in a smaller area:
+  void draw(int, int, int, int);
+  int handle(int, int, int, int, int);
+  void draw();
+
+public:
+
+  int handle(int);
+  Fl_Slider(int X,int Y,int W,int H, const char *L = 0);
+  Fl_Slider(uchar t,int X,int Y,int W,int H, const char *L);
+
+  int scrollvalue(int pos,int size,int first,int total);
+  void bounds(double a, double b);
+
+  /**
+    Get the dimensions of the moving piece of slider.
+  */
+  float slider_size() const {return slider_size_;}
+
+  /**
+    Set the dimensions of the moving piece of slider. This is
+    the fraction of the size of the entire widget. If you set this
+    to 1 then the slider cannot move.  The default value is .08.
+
+    For the "fill" sliders this is the size of the area around the
+    end that causes a drag effect rather than causing the slider to
+    jump to the mouse.
+  */
+  void slider_size(double v);
+
+  /** Gets the slider box type. */
+  Fl_Boxtype slider() const {return (Fl_Boxtype)slider_;}
+
+  /** Sets the slider box type. */
+  void slider(Fl_Boxtype c) {slider_ = c;}
+};
+
+#endif
+
+//
+// End of "$Id$".
+//

msvc/fltk/include/FL/Fl_Spinner.H

@@ -0,0 +1,259 @@
+//
+// "$Id$"
+//
+// Spinner widget for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2010 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// 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
+//
+// Please report all bugs and problems on the following page:
+//
+//     http://www.fltk.org/str.php
+//
+
+/* \file
+   Fl_Spinner widget . */
+
+#ifndef Fl_Spinner_H
+#  define Fl_Spinner_H
+
+//
+// Include necessary headers...
+//
+
+#  include <FL/Enumerations.H>
+#  include <FL/Fl_Group.H>
+#  include <FL/Fl_Input.H>
+#  include <FL/Fl_Repeat_Button.H>
+#  include <stdio.h>
+#  include <stdlib.h>
+
+
+/**
+  This widget is a combination of the input
+  widget and repeat buttons. The user can either type into the
+  input area or use the buttons to change the value.
+
+  \image html Fl_Spinner.png "Fl_Spinner widget"
+  \image latex Fl_Spinner.png "Fl_Spinner widget" width=6cm
+*/
+class FL_EXPORT Fl_Spinner : public Fl_Group {
+ 
+  double	value_;			// Current value
+  double	minimum_;		// Minimum value
+  double	maximum_;		// Maximum value
+  double	step_;			// Amount to add/subtract for up/down
+  const char	*format_;		// Format string
+
+#if FLTK_ABI_VERSION >= 10301
+// NEW
+protected:
+#endif
+  Fl_Input	input_;			// Input field for the value
+  Fl_Repeat_Button
+		up_button_,		// Up button
+		down_button_;		// Down button
+
+private:
+  static void	sb_cb(Fl_Widget *w, Fl_Spinner *sb) {
+		  double v;		// New value
+
+		  if (w == &(sb->input_)) {
+		    // Something changed in the input field...
+		    v = atof(sb->input_.value());
+
+		    if (v < sb->minimum_) {
+		      sb->value_ = sb->minimum_;
+		      sb->update();
+		    } else if (v > sb->maximum_) {
+		      sb->value_ = sb->maximum_;
+		      sb->update();
+		    } else sb->value_ = v;
+		  } else if (w == &(sb->up_button_)) {
+		    // Up button pressed...
+		    v = sb->value_ + sb->step_;
+
+		    if (v > sb->maximum_) sb->value_ = sb->minimum_;
+		    else sb->value_ = v;
+
+		    sb->update();
+		  } else if (w == &(sb->down_button_)) {
+		    // Down button pressed...
+		    v = sb->value_ - sb->step_;
+
+		    if (v < sb->minimum_) sb->value_ = sb->maximum_;
+		    else sb->value_ = v;
+
+		    sb->update();
+		  }
+
+		  sb->set_changed();
+		  sb->do_callback();
+		}
+  void		update() {
+		  char s[255];		// Value string
+
+		  if (format_[0]=='%'&&format_[1]=='.'&&format_[2]=='*') {  // precision argument
+		    // this code block is a simplified version of
+		    // Fl_Valuator::format() and works well (but looks ugly)
+		    int c = 0;
+		    char temp[64], *sp = temp;
+		    sprintf(temp, "%.12f", step_);
+		    while (*sp) sp++;
+		    sp--;
+		    while (sp>temp && *sp=='0') sp--;
+		    while (sp>temp && (*sp>='0' && *sp<='9')) { sp--; c++; }
+		    sprintf(s, format_, c, value_);
+		  } else {
+		    sprintf(s, format_, value_);
+		  }
+		  input_.value(s);
+		}
+
+  public:
+
+		/**
+		  Creates a new Fl_Spinner widget using the given position, size,
+		  and label string.
+		  <P>Inherited destructor Destroys the widget and any value associated with it.
+		*/
+  Fl_Spinner(int X, int Y, int W, int H, const char *L = 0);
+
+  /** Sets or returns the format string for the value. */
+  const char	*format() { return (format_); }
+  /** Sets or returns the format string for the value. */
+  void		format(const char *f) { format_ = f; update(); }
+
+  int		handle(int event) {
+		  switch (event) {
+		    case FL_KEYDOWN :
+		    case FL_SHORTCUT :
+		      if (Fl::event_key() == FL_Up) {
+			up_button_.do_callback();
+			return 1;
+		      } else if (Fl::event_key() == FL_Down) {
+			down_button_.do_callback();
+			return 1;
+		      } else return 0;
+
+		    case FL_FOCUS :
+		      if (input_.take_focus()) return 1;
+		      else return 0;
+		  }
+
+		  return Fl_Group::handle(event);
+		}
+
+  /** Speling mistakes retained for source compatibility \deprecated */
+  double	maxinum() const { return (maximum_); }
+  /** Gets the maximum value of the widget. */
+  double	maximum() const { return (maximum_); }
+  /** Sets the maximum value of the widget. */
+  void		maximum(double m) { maximum_ = m; }
+  /** Speling mistakes retained for source compatibility \deprecated */
+  double	mininum() const { return (minimum_); }
+  /** Gets the minimum value of the widget. */
+  double	minimum() const { return (minimum_); }
+  /** Sets the minimum value of the widget. */
+  void		minimum(double m) { minimum_ = m; }
+  /** Sets the minimum and maximum values for the widget. */
+  void		range(double a, double b) { minimum_ = a; maximum_ = b; }
+  void		resize(int X, int Y, int W, int H) {
+		  Fl_Group::resize(X,Y,W,H);
+
+		  input_.resize(X, Y, W - H / 2 - 2, H);
+		  up_button_.resize(X + W - H / 2 - 2, Y, H / 2 + 2, H / 2);
+		  down_button_.resize(X + W - H / 2 - 2, Y + H - H / 2,
+		                      H / 2 + 2, H / 2);
+		}
+  /**
+    Sets or returns the amount to change the value when the user clicks a button.
+    Before setting step to a non-integer value, the spinner
+    type() should be changed to floating point.
+  */
+  double	step() const { return (step_); }
+  /** See double Fl_Spinner::step() const */
+  void		step(double s) {
+		  step_ = s;
+		  if (step_ != (int)step_) input_.type(FL_FLOAT_INPUT);
+		  else input_.type(FL_INT_INPUT);
+		  update();
+		}
+  /** Gets the color of the text in the input field. */
+  Fl_Color	textcolor() const {
+		  return (input_.textcolor());
+		}
+  /** Sets the color of the text in the input field. */
+  void		textcolor(Fl_Color c) {
+		  input_.textcolor(c);
+		}
+  /** Gets the font of the text in the input field. */
+  Fl_Font       textfont() const {
+		  return (input_.textfont());
+		}
+  /** Sets the font of the text in the input field. */
+  void		textfont(Fl_Font f) {
+		  input_.textfont(f);
+		}
+  /** Gets the size of the text in the input field. */
+  Fl_Fontsize  textsize() const {
+		  return (input_.textsize());
+		}
+  /** Sets the size of the text in the input field. */
+  void		textsize(Fl_Fontsize s) {
+		  input_.textsize(s);
+		}
+  /** Gets the numeric representation in the input field.
+   \see Fl_Spinner::type(uchar)
+  */
+  uchar		type() const { return (input_.type()); }
+  /** Sets the numeric representation in the input field.
+   Valid values are FL_INT_INPUT and FL_FLOAT_INPUT.
+   Also changes the format() template.
+   Setting a new spinner type via a superclass pointer will not work.
+   \note  type is not a virtual function.
+   */
+  void		type(uchar v) {
+		  if (v==FL_FLOAT_INPUT) {
+		    format("%.*f");
+		  } else {
+		    format("%.0f");
+		  }
+		  input_.type(v);
+		}
+  /** Gets the current value of the widget. */
+  double	value() const { return (value_); }
+  /**
+    Sets the current value of the widget.
+    Before setting value to a non-integer value, the spinner
+    type() should be changed to floating point.
+  */
+  void		value(double v) { value_ = v; update(); }
+  /**
+    Change the background color of the spinner widget's input field.
+  */
+  void		color(Fl_Color v) { input_.color(v); }
+  /**
+    Return the background color of the spinner widget's input field.
+  */
+  Fl_Color	color() const { return(input_.color()); }
+  /**
+    Change the selection color of the spinner widget's input field.
+  */
+  void		selection_color(Fl_Color val) { input_.selection_color(val); }
+  /**
+    Return the selection color of the spinner widget's input field.
+  */
+  Fl_Color	selection_color() const { return input_.selection_color(); }
+};
+
+#endif // !Fl_Spinner_H
+
+//
+// End of "$Id$".
+//