Removing current broken history documentation/src dir.

git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3@6451 ea41ed52-d2ee-0310-a9c1-e6b18d33e121
2026-05-31 22:04:26 +08:00 · 2008-10-17 11:22:35 +00:00
parent 4b5a6d1b23
commit 09cfc1a1ea
148 changed files with 0 additions and 144821 deletions
@@ -1,113 +0,0 @@
 /**
 \page advanced 10 - Advanced FLTK
 This chapter explains advanced programming and design topics
 that will help you to get the most out of FLTK.
 <A NAME="multithreading"> </A> <!-- For old HTML links only ! -->
 \section advanced_multithreading Multithreading
 FLTK supports multithreaded application using a locking mechanism
 based on "pthreads". We do not provide a threading interface as part of
 the library.  However a simple example how threads can be implemented
 for all supported platforms can be found in <tt>test/threads.h</tt>
 and <tt>test/threads.cxx</tt>.
 To use the locking mechanism, FLTK must be compiled with
 <tt>--enable-threads</tt> set during the <tt>configure</tt>
 process. IDE-based versions of FLTK are automatically compiled with
 locking enabled if possible.
 In <TT>main()</TT>, call
 <a href="Fl.html#Fl.lock"><TT>Fl::lock()</TT></A> before
 <A HREF="Fl.html#Fl.run"><TT>Fl::run()</TT></A> or
 <A HREF="Fl.html#Fl.wait"><TT>Fl::wait()</TT></A>
 to start the runtime
 multithreading support for your program. All callbacks and derived
 functions like <tt>handle()</tt> and <tt>draw()</tt> will now be properly
 locked:
 }
 \code
    int main() {
      Fl::lock();
      /* run thread */
      while (Fl::wait() &gt; 0) {
        if (Fl::thread_message()) {
          /* process your data */
        }
      }
    }
 \endcode
 You can now start as many threads as you like. From within
 a thread (other than the main thread) FLTK calls must be wrapped
 with calls to <a href="Fl.html#Fl.lock"><tt>Fl::lock()</tt></a> 
 and <a href="Fl.html#Fl.unlock"><tt>Fl::unlock()</tt></a>:
 \code
    Fl::lock();      // avoid conflicting calls
    ...              // your code here
    Fl::unlock();    // allow other threads to access FLTK again
 \endcode
 You can send messages from child threads to the main thread 
 using <a href="Fl.html#Fl.awake"><tt>Fl::awake(msg)</tt></a>:</p>
 \code
    void *msg;       // "msg" is a pointer to your message
    Fl::awake(msg);  // send "msg" to main thread
 \endcode
 You can also tell the main thread to call a function for you
 as soon as possible by using
 <a href="Fl.html#Fl.awake"><tt>Fl::awake(callback, userdata)</tt></a>:</p>
 \code
    void do_something(void *userdata) {
      // running with the main thread
    }
    // running in another thread
    void *data;       // "data" is a pointer to your user data
    Fl::awake(do_something, data);  // call something in main thread
 \endcode
 FLTK supports multiple platforms, some of them which do not 
 allow any other but the main thread to handle system events and
 open or close windows. The safe thing to do is to adhere to the 
 following rules for threads on all operating systems:
 \li Don't <tt>show()</tt> or <tt>hide()</tt>anything that contains 
    widgets derived from <tt>Fl_Window</tt>, including dialogs, file
    choosers, subwindows or <tt>Fl_GL_Window</tt>s
 \li Don't call <tt>Fl::wait()</tt>, <tt>Fl::flush()</tt> or any 
    related methods that will handle system messages
 \li Don't start or cancel timers
 \li Don't change window decorations or titles
 \li The <tt>make_current()</tt> method may or may not work well for
    regular windows, but should always work for <tt>Fl_GL_Window</tt>s
    to allow for high speed rendering on graphics cards with multiple
    pipelines
 See also: 
 <a href="Fl.html#Fl.awake">void awake(void *message)</A>, 
 <a href="Fl.html#Fl.lock">void lock()</A>, 
 <a href="Fl.html#Fl.thread_message">void *thread_message()</A>,
 <a href="Fl.html#Fl.unlock">void unlock()</A>.
 \htmlonly
 <hr>
 <a class="el" href="index.html">[Index]</a> &nbsp;&nbsp;
 <a class="el" href="fluid.html">[Previous]&nbsp; 9 - Programming with FLUID</a>&nbsp;
 <a class="el" href="unicode.html">[Next]&nbsp; 11 - Unicode and utf-8 Support</a>&nbsp;
 \endhtmlonly
 */
@@ -1,352 +0,0 @@
 /**
 \page basics	2 - FLTK Basics
 This chapter teaches you the basics of compiling programs
 that use FLTK.
 \section basics_writing Writing Your First FLTK Program
 All programs must include the file <tt><FL/Fl.H></tt>.
 In addition the program must include a header file for each
 FLTK class it uses. Listing 1 shows a simple "Hello,
 World!" program that uses FLTK to display the window.
 \par Listing 1 - "hello.cxx"
 \code
 #include <FL/Fl.H>
 #include <FL/Fl_Window.H>
 #include <FL/Fl_Box.H>
 int main(int argc, char **argv) {
  Fl_Window *window = new Fl_Window(300,180);
  Fl_Box *box = new Fl_Box(20,40,260,100,"Hello, World!");
  box->box(FL_UP_BOX);
  box->labelsize(36);
  box->labelfont(FL_BOLD+FL_ITALIC);
  box->labeltype(FL_SHADOW_LABEL);
  window->end();
  window->show(argc, argv);
  return Fl::run();
 }
 \endcode
 <!-- NEED 2in -->
 After including the required header files, the program then creates a
 window. All following widgets will automatically be children of this window.
 \code
 Fl_Window *window = new Fl_Window(300,180);
 \endcode
 Then we create a box with the "Hello, World!" string in it. FLTK automatically
 adds the new box to <tt>window</tt>, the current grouping widget.
 \code
 Fl_Box *box = new Fl_Box(20,40,260,100,"Hello, World!");
 \endcode
 Next, we set the type of box and the size, font, and style of the label:
 \code
 box->box(FL_UP_BOX);
 box->labelsize(36);
 box->labelfont(FL_BOLD+FL_ITALIC);
 box->labeltype(FL_SHADOW_LABEL);
 \endcode
 We tell FLTK that we will not add any more widgets to <tt>window</tt>.
 \code
 window->end();
 \endcode
 Finally, we show the window and enter the FLTK event loop:
 \code
 window->show(argc, argv);
 return Fl::run();
 \endcode
 The resulting program will display the window in Figure 2-1.
 You can quit the program by closing the window or pressing the
 <KBD>ESC</KBD>ape key.
 \image html hello.C.gif "Figure 2-1: The Hello, World! Window"
 \image latex hello.C.eps "The Hello, World! Window" width=8cm
 \subsection basics_creating Creating the Widgets
 The widgets are created using the C++ <tt>new</tt> operator.  For
 most widgets the arguments to the constructor are:
 \code
 Fl_Widget(x, y, width, height, label)
 \endcode
 The <tt>x</tt> and <tt>y</tt> parameters determine where the
 widget or window is placed on the screen. In FLTK the top left
 corner of the window or screen is the origin (i.e. x = 0, y =
 0) and the units are in pixels.
 The <tt>width</tt> and <tt>height</tt> parameters determine
 the size of the widget or window in pixels. The maximum widget
 size is typically governed by the underlying window system or
 hardware.
 <tt>label</tt> is a pointer to a character string to label
 the widget with or <tt>NULL</tt>. If not specified the label
 defaults to <tt>NULL</tt>. The label string must be in static
 storage such as a string constant because FLTK does not make a
 copy of it - it just uses the pointer.
 \subsection basics_hierarchies Creating Widget hierarchies
 Widgets are commonly ordered into functional groups, which 
 in turn may be grouped again, creating a hierarchy of widgets. 
 FLTK makes it easy to fill groups by automatically adding all widgets 
 that are created between a <tt>myGroup->begin()</tt> and 
 <tt>myGroup->end()</tt>. In this example, <tt>myGroup</tt>  
 would be the <i>current</i> group.
 Newly created groups and their derived widgets implicitly call
 <tt>begin()</tt> in the constructor, effectively adding all 
 subsequently created widgets to itself until <tt>end()</tt> 
 is called.
 Setting the current group to <tt>NULL</tt> will stop automatic
 hierarchies. New widgets can now be added manually using 
 <tt>Fl_Group::add(...)</tt> and <tt>Fl_Group::insert(...)</tt>.
 \subsection basics_getset Get/Set Methods
 <tt>box->box(FL_UP_BOX)</tt> sets the type of box the
 Fl_Box draws, changing it from the default of
 <tt>FL_NO_BOX</tt>, which means  that no box is drawn. In our
 "Hello, World!" example we use <tt>FL_UP_BOX</tt>,
 which means that a raised button border will be drawn around
 the widget. You can learn more about boxtypes in
 <A href="common.html#boxtypes">Chapter 3</A>.
 You could examine the boxtype in by doing
 <tt>box->box()</tt>. FLTK uses method name overloading to make
 short names for get/set methods. A "set" method is always of
 the form "void name(type)", and a "get" method is always
 of the form "type name() const".
 \subsection basics_redrawing Redrawing After Changing Attributes
 Almost all of the set/get pairs are very fast, short inline
 functions and thus very efficient. However, <i>the "set" methods
 do not call <tt>redraw()</tt></i> - you have to call it
 yourself. This greatly reduces code size and execution time. The
 only common exceptions are <tt>value()</tt> which calls
 <tt>redraw()</tt> and <tt>label()</tt> which calls
 <tt>redraw_label()</tt> if necessary.
 \subsection basics_labels Labels
 All widgets support labels.  In the case of window widgets,
 the label is used for the label in the title bar. Our example
 program calls the <tt>labelfont()</tt>,<tt> labelsize</tt>,
 and <tt>labeltype()</tt> methods.
 All widgets support labels.  In the case of window widgets,
 the label  is used for the label in the title bar. Our example
 program calls the
 <A href=Fl_Widget.html#Fl_Widget.labelfont><tt>labelfont</tt></A>,
 <A href=Fl_Widget.html#Fl_Widget.labelsize><tt> labelsize</tt></A>,
 and
 <A href=Fl_Widget.html#Fl_Widget.labeltype><tt>labeltype</tt></A>
 methods.
 The <tt>labelfont</tt> method sets the typeface and style
 that is used for the label, which for this example we are using
 <tt>FL_BOLD</tt> and <tt>FL_ITALIC</tt>. You can also specify
 typefaces directly.
 The <tt>labelsize</tt> method sets the height of the font in pixels.
 The <tt>labeltype</tt>
 method sets the type of label. FLTK supports normal, embossed,
 and shadowed labels internally, and more types can be added as
 desired.
 A complete list of all label options can be found in
 <A href="common.html#labels">Chapter 3</A>.
 \subsection basics_showing Showing the Window
 The <tt>show()</tt> method shows the widget or window. For windows
 you can also provide the command-line arguments to allow users to
 customize the appearance, size, and position of your windows.
 \subsection basics_eventloop The Main Event Loop
 All FLTK applications (and most GUI applications in general)
 are based on a simple event processing model. User actions such
 as mouse movement, button clicks, and keyboard activity generate
 events that are sent to an application. The application may then
 ignore the events or respond to the user, typically by redrawing
 a button in the "down" position, adding the text to an input
 field, and so forth.
 FLTK also supports idle, timer, and file pseudo-events that
 cause a function to be called when they occur. Idle functions
 are called when no user input is present and no timers or files
 need to be handled - in short, when the application is not doing
 anything. Idle callbacks are often used to update a 3D display
 or do other background processing.
 Timer functions are called after a specific amount of time
 has expired. They can be used to pop up a progress dialog after
 a certain amount of time or do other things that need to happen
 at more-or-less regular intervals. FLTK timers are not 100%
 accurate, so they should not be used to measure time intervals,
 for example.
 File functions are called when data is ready to read or
 write, or when an error condition occurs on a file. They are
 most often used to monitor network connections (sockets) for
 data-driven displays.
 FLTK applications must periodically check (Fl::check()) 
 or wait (Fl::wait()) for events or use the Fl::run()
 method to enter a standard event processing loop. Calling
 Fl::run() is equivalent to the following code:
 \code
 while (Fl::wait());
 \endcode
 Fl::run() does not return until all of the windows
 under FLTK control are closed by the user or your program.
 \section basics_standard_compiler Compiling Programs with Standard Compilers
 Under UNIX (and under Microsoft Windows when using the GNU development
 tools) you will probably need to tell the compiler where to find the
 header files. This is usually done using the <tt>-I</tt> option:
 \code
 CC -I/usr/local/include ...
 gcc -I/usr/local/include ...
 \endcode
 The <tt>fltk-config</tt> script included with FLTK can be
 used to get the options that are required by your compiler:
 \code
 CC `fltk-config --cxxflags` ...
 \endcode
 Similarly, when linking your application you will need to tell the
 compiler to use the FLTK library:
 \code
 CC  ... -L/usr/local/lib -lfltk -lXext -lX11 -lm
 gcc ... -L/usr/local/lib -lfltk -lXext -lX11 -lm
 \endcode
 Aside from the "fltk" library, there is also a "fltk_forms"
 library for the XForms compatibility classes, "fltk_gl" for the
 OpenGL and GLUT classes, and "fltk_images" for the image file
 classes, Fl_Help_Dialog widget, and system icon support.
 \note
 The libraries are named "fltk.lib", "fltkgl.lib", "fltkforms.lib",
 and "fltkimages.lib", respectively under Windows.
 As before, the <tt>fltk-config</tt> script included with FLTK can be
 used to get the options that are required by your linker:
 \code
 CC ... `fltk-config --ldflags`
 \endcode
 <!-- NEED 2in -->
 The forms, GL, and images libraries are included with the "--use-foo"
 options, as follows:
 \code
 CC ... `fltk-config --use-forms --ldflags`
 CC ... `fltk-config --use-gl --ldflags`
 CC ... `fltk-config --use-images --ldflags`
 CC ... `fltk-config --use-forms --use-gl --use-images --ldflags`
 \endcode
 Finally, you can use the <tt>fltk-config</tt> script to
 compile a single source file as a FLTK program:
 \code
 fltk-config --compile filename.cpp
 fltk-config --use-forms --compile filename.cpp
 fltk-config --use-gl --compile filename.cpp
 fltk-config --use-images --compile filename.cpp
 fltk-config --use-forms --use-gl --use-images --compile filename.cpp
 \endcode
 Any of these will create an executable named <tt>filename</tt>.
 \section basics_visual_cpp Compiling Programs with Microsoft Visual C++
 In Visual C++ you will need to tell the compiler where to
 find the  FLTK header files.  This can be done by selecting
 "Settings" from the "Project" menu and then changing the 
 "Preprocessor" settings under the "C/C++" tab. You will also 
 need to add the FLTK and WinSock2 (WS2_32.LIB) libraries to 
 the "Link" settings.
 You can build your Microsoft Windows applications as Console or
 WIN32 applications.  If you want to use the standard C <tt>main()</tt>
 function as the entry point, FLTK includes a <tt>WinMain()</tt>
 function that will call your <tt>main()</tt> function for you.
 <I>Note: The Visual C++ 5.0 optimizer is known to cause problems with
 many programs. We only recommend using the "Favor Small Code"
 optimization setting.</I> The Visual C++ 6.0 optimizer seems to be much
 better and can be used with the "optimized for speed" setting.
 \section basics_naming Naming
 All public symbols in FLTK start with the characters 'F' and 'L':
 \li Functions are either <tt>Fl::foo()</tt> or <tt>fl_foo()</tt>.
 \li Class and type names are capitalized: <tt>Fl_Foo</tt>.
 \li <A href="enumerations.html">Constants and enumerations</A>
    are uppercase: <tt>FL_FOO</tt>.
 \li All header files start with <tt><FL/...></tt>.
 <!-- NEED 5in -->
 \section basics_headerfiles Header Files
 The proper way to include FLTK header files is:
 \code
 #include <FL/Fl_xyz.H>
 \endcode
 \note
 Case <I>is</I> significant on many operating systems,
 and the C standard uses the forward slash (/) to
 separate directories. <i>Do not use any of the following
 include lines:</i>
 \code
 #include <FL\Fl_xyz.H>
 #include <fl/fl_xyz.h>
 #include <Fl/fl_xyz.h>
 \endcode
 \htmlonly
 <hr>
 <a class="el" href="index.html">[Index]</a> &nbsp;&nbsp;
 <a class="el" href="intro.html">[Previous]&nbsp; 1 - Introduction to FLTK</a>&nbsp;
 <a class="el" href="common.html">[Next]&nbsp; 3 - Common Widgets and Attributes</a>&nbsp;
 \endhtmlonly
 */
@@ -1,462 +0,0 @@
 /**
 \page development I - Developer Information
 This chapter describes FLTK development and documentation.
 \note	documentation with doxygen will be described here.
 <H2>Example</H2>
 \note
 In the following code example(s) "*" will be replaced by "#"
 as a temporary solution.
 \code
 /## \file
   Fl_Clock, Fl_Clock_Output widgets . #/
 /##
  \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.
  \image html clock.gif 
  \image latex clock.eps "" width=10cm 
  \image html round_clock.gif
  \image latex clock.eps "" width=10cm 
  \image html round_clock.eps "" width=10cm #/
  /##
    Returns the displayed time.
    Returns the time in seconds since the UNIX epoch (January 1, 1970).
    \see value(ulong)
   #/
  ulong value() const {return value_;}
 /##
  Set the displayed time.
  Set the time in seconds since the UNIX epoch (January 1, 1970).
  \param[in] v seconds since epoch
  \see value()
 #/
 void Fl_Clock_Output::value(ulong v) {
 [...]
 }
 /##
  Create an Fl_Clock widget using the given position, size, and label string.
  The default boxtype is \c FL_NO_BOX.
  \param[in] X, Y, W, H position and size of the widget
  \param[in] L widget label, default is no label
 #/
 Fl_Clock::Fl_Clock(int X, int Y, int W, int H, const char #L)
  : Fl_Clock_Output(X, Y, W, H, L) {}
 /##
  Create an Fl_Clock widget using the given boxtype, position, size, and
  label string.
  \param[in] t boxtype
  \param[in] X, Y, W, H position and size of the widget
  \param[in] L widget label, default is no label
 #/
 Fl_Clock::Fl_Clock(uchar t, int X, int Y, int W, int H, const char #L)
  : Fl_Clock_Output(X, Y, W, H, L) {
  type(t);
  box(t==FL_ROUND_CLOCK ? FL_NO_BOX : FL_UP_BOX);
 }
 \endcode
 \note
 From Duncan: (will be removed later, just for now as a reminder)
 5. I've just added comments for the fl_color_chooser() functions, and
   in order to keep them and the general Function Reference information
   for them together, I created a new doxygen group, and used \\ingroup
   in the three comment blocks. This creates a new Modules page (which
   may not be what we want) with links to it from the File Members and
   Fl_Color_Chooser.H pages. It needs a bit more experimentation on my
   part unless someone already knows how this should be handled. (Maybe
   we can add it to a functions.dox file that defines a functions group
   and do that for all of the function documentation?)
 \b Update: the trick is not to create duplicate entries in a new group, but
   to move the function information into the doxygen comments for the
   class, and use the navigation links provided. Simply using \\relatesalso
   as the first doxygen command in the function's comment puts it in the
   appropriate place. There is no need to have \\defgroup and \\ingroup as
   well, and indeed they don't work. So, to summarize:
 \code
 Gizmo.H
  /## \class Gizmo
      A gizmo that does everything
    #/
  class Gizmo {
    etc
  };
  extern int popup_gizmo(...);
 Gizmo.cxx:
  /## \relatesalso Gizmo
      Pops up a gizmo dialog with a Gizmo in it
    #/
  int popup_gizmo(...);
 \endcode
 <H3>Example comment:</H3>
 You can use HTML comment statements to embed comments in doxygen comment blocks.
 These comments will not be visible in the generated document.
    The following text is a developer comment.
    <!-- *** This *** is *** invisible *** -->
    This will be visible again.
 \code
    The following text is a developer comment.
    <!-- *** This *** is *** invisible *** -->
    This will be visible again.
 \endcode
 <H3>Different Headlines:</H3>
 \code
    <H1>Headline in big text (H1)</H1>
    <H2>Headline in big text (H2)</H2>
    <H3>Headline in big text (H3)</H3>
    <H4>Headline in big text (H4)</H4>
 \endcode
    <H1>Headline in big text (H1)</H1>
    <H2>Headline in big text (H2)</H2>
    <H3>Headline in big text (H3)</H3>
    <H4>Headline in big text (H4)</H4>
 \section development_non-ascii Non-ASCII characters
 	if you came here from below: back to \ref development_links
 \code
    Doxygen understands many HTML quoting characters like
    &quot;, &uuml;, &ccedil;, &Ccedil;, but not all HTML quoting characters.
 \endcode
 This will appear in the document:
    Doxygen understands many HTML quoting characters like
    &quot;, &uuml;, &ccedil;, &Ccedil;, but not all HTML quoting characters.
 For further informations about quoting see 
    \b http://www.stack.nl/~dimitri/doxygen/htmlcmds.html
 <H3>Example with UTF-8 encoded text</H3>
 \code
    <P>Assuming that the following source code was written on MS Windows, 
    this example will output the correct label on OS X and X11 as well.
    Without the conversion call, the label on OS X would read 
    <tt>Fahrvergn¸gen</tt> with a deformed umlaut u ("cedille",
    html "&cedil;").
    \#code
      btn = new Fl_Button(10, 10, 300, 25);
      btn->copy_label(fl_latin1_to_local("Fahrvergnügen"));
    \#endcode
    \note   If your application uses characters that are not part of both
 	    encodings, or it will be used in areas that commonly use different
 	    code pages, you might consider upgrading to FLTK 2 which supports
 	    UTF-8 encoding. 
    \todo   This is an example todo entry, please ignore !
 \endcode
 This will appear in the document:
    <P>Assuming that the following source code was written on MS Windows, 
    this example will output the correct label on OS X and X11 as well.
    Without the conversion call, the label on OS X would read 
    <tt>Fahrvergn¸gen</tt> with a deformed umlaut u ("cedille",
    html "&cedil;").
    \#code
      btn = new Fl_Button(10, 10, 300, 25);
      btn->copy_label(fl_latin1_to_local("Fahrvergnügen"));
    \#endcode
    \note   If your application uses characters that are not part of both
 	    encodings, or it will be used in areas that commonly use different
 	    code pages, you might consider upgrading to FLTK 2 which supports
 	    UTF-8 encoding. 
    \todo   This is an example todo entry, please ignore !
 \section development_structure Document Structure
  \li	\b \\page	creates a named page
  \li	\b \\section	creates a named section within that page
  \li	\b \\subsection	creates a named subsection within the current section
  \li	\b \\subsubsection creates a named subsubsection within the current subsection
 All these statements take a "name" as their first argument, and a title
 as their second argument. The title can contain spaces.
 The page, section, and subsection titles are formatted in blue color and
 a size like \b "<H1>", \b "<H2>", and \b "<H3>", and \b "<H4>", respectively.
 By <b>FLTK documentation convention</b>, a file like this one with a doxygen
 documentation chapter has the name <b>"<chapter>.dox".</b>
 The \b \\page statement at the top of the page is 
 <b>"\page <chapter> This is the title"</b>.
 Sections within a documentation page must be called \b "<chapter>_<section>",
 where \b "<chapter>" is the name part of the file, and \b "<section>" is a
 unique section name within the page that can be referenced in links. The
 same for subsections and subsubsections.
 These doxygen page and section commands work only in special documentation
 chapters, not within normal source or header documentation blocks. However,
 links \b from normal (e.g. class) documentation \b to documentation sections
 \b do \b work.
 This page has
  \code
 	\page development I - Developer Information
  \endcode
 at its top.
 This section is
  \code
 	\section development_structure Document structure
  \endcode
 The following section is
  \code
 	\section development_links Creating Links
  \endcode
 \section development_links Creating Links
 Links to other documents and external links can be embedded with
  \li	normal HTML links
  \li	HTML links without markup - doxygen creates "http://..."
  	links automatically
  \li	links to other doxygen chapters with the \\ref statments
  \li	links to named sections within the same or other doxygen chapters,
  	if they are defined there with a \\section statement
 \code
    see chapter \ref unicode creates a link to the named chapter unicode
    that has been created with a \subpage statement.
    see <a href="drawing.html#character_encoding">chapter 5</a> creates
    a link to a named html anchor "character_encoding" within the same file.
    For further informations about quoting see
    http://www.stack.nl/~dimitri/doxygen/htmlcmds.html
    Bold link text: you can see the <b>\e old online documentation</b>
    of FLTK 1.3 at \b http://www.fltk.org/doc-1.3/toc.html
    see section \ref development_non-ascii
 \endcode
 appears as:
    see chapter \ref unicode creates a link to the named chapter unicode
    that has been created with a \\subpage statement.
    see <a href="drawing.html#character_encoding">chapter 5</a> creates
    a link to a named html anchor "character_encoding" within the same file.
    For further informations about quoting see
    http://www.stack.nl/~dimitri/doxygen/htmlcmds.html
    Bold link text: you can see the <b>\e old online documentation</b>
    of FLTK 1.3 at \b http://www.fltk.org/doc-1.3/toc.html
    see section \ref development_non-ascii
 \section development_old-links Changing Old Links
 Old HTML links and anchors in text documentation pages should be changed
 as follows:
 \code
 <H2><A name="event_xxx">Fl::event_*() methods</A></H2>
 becomes:
 <A NAME="event_xxx"></A> <!-- For old HTML links only ! -->
 \section events_event_xxx Fl::event_*() methods
 \endcode
 The additional HTML "<A NAME=...>" statement is temporary needed, until
 all links (references) are modified, then:
 \code
 <H2><A name="event_xxx">Fl::event_*() methods</A></H2>
 becomes:
 \section events_event_xxx Fl::event_*() methods
 \endcode
 The "\section" statement can also be a "\subsection" or "\subsubsection"
 statement.
 The references (in this example from index.dox) are changed as follows:
 \code
 \subpage events
    <B>
      <UL>
 	<LI><A HREF="events.html#event_xxx">Fl::event_*() methods</A></LI>
 	<LI><A HREF="events.html#propagation">Event Propagation</A></LI>
      </UL>
    </B>
 becomes:
 \subpage events
    <b>
 	\li \ref events_event_xxx
 	\li \ref events_propagation
    </b>
 \endcode
 \section development_paragraphs Paragraph Layout
 There is no real need to use HTML \<P\> and \</P\> tags within the text
 to tell doxygen to start or stop a paragraph. In most cases, when doxygen
 encounters a blank line or some, but not all, \b \\commands in the text it
 knows that it as reached the start or end of a paragraph. Doxygen also
 offers the \b \\par command for special paragraph handling. It can be used
 to provide a paragraph title and also to indent a paragraph. Unfortunately
 \b \\par won't do what you expect if you want to have doxygen links and
 sometimes html tags don't work either.
  <!-- use verbatim rather than code to avoid links to code reference -->
  \verbatim
    \par Normal Paragraph with title
    This paragraph will have a title, but because there is a blank line
    between the \par and the text, it will have the normal layout.
    \par Indented Paragraph with title
    This paragraph will also have a title, but because there is no blank
    line between the \par and the text, it will be indented.
    \par
    It is also possible to have an indented paragraph without title.
    This is how you indent subsequent paragraphs.
    \par No link to Fl_Widget::draw()
    Note that the paragraph title is treated as plain text.
    Doxygen type links will not work.
    HTML characters and tags may or may not work.
    Fl_Widget::draw() links and &quot;html&quot; tags work<br>
    \par
    Use a single line ending with <br> for complicated paragraph titles.
  \endverbatim
 The above code produces the following paragraphs:
    \par Normal Paragraph with title
    This paragraph will have a title, but because there is a blank line
    between the \\par and the text, it will have the normal layout.
    \par Indented Paragraph with title
    This paragraph will also have a title, but because there is no blank
    line between the \\par and the text, it will be indented.
    \par
    It is also possible to have an indented paragraph without title.
    This is how you indent subsequent paragraphs.
    \par No link to Fl_Widget::draw()
    Note that the paragraph title is treated as plain text.
    Doxygen type links will not work.
    HTML characters and tags may or may not work.
    Fl_Widget::draw() links and &quot;html&quot; tags work<br>
    \par
    Use a single line ending with \<br\> for complicated paragraph titles.
 \section development_html_footer Hack for missing "tiny.gif" file
  \todo
 	*HACK* : include image file for footer. Doxygen does not include
  	the file "tiny.gif" from "html_footer" in its output html dir.
 	Find out, how this can be done, or avoid using an image in
 	the HTML footer.
  \image html tiny.gif
  \image latex tiny.eps "" width=2cm	
 \section development_navigation_test 5 Navigation Proposals
 \htmlonly
 <hr>
 \link migration_1_3 [ Previous ] \endlink
 <b>    [ <a href="index.html">Index</a> ]    </b>
 <b> Next: </b> \ref license
 <hr>
 <b>[ <a href="index.html">Index</a> ]    </b>
 <b>   Previous: </b> \ref migration_1_3
 <b>   Next: </b> \ref license
 <hr>
 <b>[ <a href="index.html">Index</a> ]    </b><br>
 <b>   Previous: </b> \ref migration_1_3 <br>
 <b>   Next: </b> \ref license
 <hr>
 <b>[ <a href="index.html">Index</a> ]    </b>
   Previous:  \ref migration_1_3
   Next:  \ref license
 <hr>
 \link migration_1_3 [ Previous ] \endlink
 <b>    [ <a href="index.html">Top</a> ]    </b>
 \link license [ Next ] \endlink
 <hr>
 <br>
 <br>
 \section development_proposed_nav Proposed (final) Navigation Elements
 See below.
 <hr>
 <a class="el" href="index.html">[Index]</a> &nbsp;&nbsp;
 <a class="el" href="migration_1_3.html">[Previous]</a>&nbsp;
     \ref migration_1_3 &nbsp;&nbsp;
 <a class="el" href="license.html">[Next]</a>&nbsp;
     \ref license
 \endhtmlonly
 */
--- a/Show More
+++ b/Show More