Mirrors_UI_SDK/fltk
1
0
Fork 0
mirror of https://github.com/fltk/fltk.git synced 2026-05-26 01:46:58 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Doxygen pdf man: First version added in documentation/fltk.pdf, old doc removed, images, dox files moved to a new src directory.

Browse Source 
git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3@6431 ea41ed52-d2ee-0310-a9c1-e6b18d33e121
This commit is contained in:
Fabien Costantini
2008-10-14 22:12:25 +00:00
parent e08fffdfe0
commit 497afccb07
195 changed files with 272 additions and 22647 deletions
Download Patch File Download Diff File Expand all files Collapse all files
documentation/Doxyfile
+173 -50
View File
@@ -1,4 +1,4 @@
# Doxyfile 1.5.5
# Doxyfile 1.5.7
# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project
@@ -57,8 +57,8 @@ CREATE_SUBDIRS = NO
# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek,
# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages),
# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish,
# Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish,
# and Ukrainian.
# Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, Slovene,
# Spanish, Swedish, and Ukrainian.
OUTPUT_LANGUAGE = English
@@ -155,13 +155,6 @@ QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
# If the DETAILS_AT_TOP tag is set to YES then Doxygen
# will output the detailed description near the top, like JavaDoc.
# If set to NO, the detailed description appears after the member
# documentation.
DETAILS_AT_TOP = NO
# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
# member inherits the documentation from any documented member that it
# re-implements.
@@ -234,6 +227,15 @@ CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
# For Microsoft's IDL there are propget and propput attributes to indicate getter
# and setter methods for a property. Setting this option to YES (the default)
# will make doxygen to replace the get and set methods by a property in the
# documentation. This will only work if the methods are indeed getting or
# setting a simple type. If this is not the case, or you want to show the
# methods anyway, you should set this option to NO.
IDL_PROPERTY_SUPPORT = YES
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
# tag is set to YES, then doxygen will reuse the documentation of the first
# member in the group (if any) for the other members of the group. By default
@@ -259,6 +261,22 @@ SUBGROUPING = YES
TYPEDEF_HIDES_STRUCT = NO
# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
# determine which symbols to keep in memory and which to flush to disk.
# When the cache is full, less often used symbols will be written to disk.
# For small to medium size projects (<1000 input files) the default value is
# probably good enough. For larger projects a too small cache size can cause
# doxygen to be busy swapping symbols to and from disk most of the time
# causing a significant performance penality.
# If the system has enough physical memory increasing the cache will improve the
# performance by keeping more symbols in memory. Note that the value works on
# a logarithmic scale so increasing the size by one will rougly double the
# memory usage. The cache size is given by this formula:
# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
# corresponding to a cache size of 2^16 = 65536 symbols
SYMBOL_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
@@ -443,6 +461,18 @@ SHOW_USED_FILES = YES
SHOW_DIRECTORIES = NO
# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
# This will remove the Files entry from the Quick Index and from the
# Folder Tree View (if specified). The default is YES.
SHOW_FILES = YES
# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
# Namespaces page. This will remove the Namespaces entry from the Quick Index
# and from the Folder Tree View (if specified). The default is YES.
SHOW_NAMESPACES = YES
# The FILE_VERSION_FILTER tag can be used to specify a program or script that
# doxygen should invoke to get the current version for each file (typically from
# the version control system). Doxygen will invoke the program by executing (via
@@ -453,6 +483,15 @@ SHOW_DIRECTORIES = NO
FILE_VERSION_FILTER =
# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by
# doxygen. The layout file controls the global structure of the generated output files
# in an output format independent way. The create the layout file that represents
# doxygen's defaults, run doxygen with the -l option. You can optionally specify a
# file name after the option, if omitted DoxygenLayout.xml will be used as the name
# of the layout file.
LAYOUT_FILE =
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
@@ -513,14 +552,30 @@ WARN_LOGFILE =
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.
INPUT = index.dox preface.dox intro.dox basics.dox common.dox \
drawing.dox editor.dox events.dox subclassing.dox \
opengl.dox fluid.dox advanced.dox unicode.dox \
INPUT = src/index.dox \
src/preface.dox \
src/intro.dox \
src/basics.dox \
src/common.dox \
src/drawing.dox \
src/editor.dox \
src/events.dox \
src/subclassing.dox \
src/opengl.dox \
src/fluid.dox \
src/advanced.dox \
src/unicode.dox \
../FL \
../src \
enumerations.dox glut.dox forms.dox osissues.dox \
migration_1_1.dox migration_1_3.dox development.dox \
license.dox examples.dox
src/enumerations.dox \
src/glut.dox \
src/forms.dox \
src/osissues.dox \
src/migration_1_1.dox \
src/migration_1_3.dox \
src/development.dox \
src/license.dox \
src/examples.dox
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
@@ -553,7 +608,8 @@ RECURSIVE = YES
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
EXCLUDE = ../src/fl_font_win32.cxx ../src/fl_font_mac.cxx
EXCLUDE = ../src/fl_font_win32.cxx \
../src/fl_font_mac.cxx
# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
# directories that are symbolic links (a Unix filesystem feature) are excluded
@@ -604,7 +660,7 @@ EXAMPLE_RECURSIVE = NO
# directories that contain image that are included in the documentation (see
# the \image command).
IMAGE_PATH = .
IMAGE_PATH = ./src
# The INPUT_FILTER tag can be used to specify a program that doxygen should
# invoke to filter for each input file. Doxygen will invoke the filter program
@@ -653,13 +709,13 @@ INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
# If the REFERENCED_BY_RELATION tag is set to YES (the default)
# If the REFERENCED_BY_RELATION tag is set to YES
# then for each documented function all documented
# functions referencing it will be listed.
REFERENCED_BY_RELATION = YES
# If the REFERENCES_RELATION tag is set to YES (the default)
# If the REFERENCES_RELATION tag is set to YES
# then for each documented function all documented entities
# called/used by that function will be listed.
@@ -690,12 +746,6 @@ VERBATIM_HEADERS = YES
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
# of all compounds will be generated. Enable this if the project
# contains a lot of classes, structs, unions or interfaces.
ALPHABETICAL_INDEX = YES
# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
# in which this list will be split (can be a number in the range [1..20])
@@ -759,12 +809,13 @@ HTML_STYLESHEET =
HTML_ALIGN_MEMBERS = YES
# If the GENERATE_HTMLHELP tag is set to YES, additional index files
# will be generated that can be used as input for tools like the
# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
# of the generated HTML documentation.
# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded. For this to work a browser that supports
# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
GENERATE_HTMLHELP = NO
HTML_DYNAMIC_SECTIONS = NO
# If the GENERATE_DOCSET tag is set to YES, additional index files
# will be generated that can be used as input for Apple's Xcode 3
@@ -773,7 +824,8 @@ GENERATE_HTMLHELP = NO
# HTML output directory. Running make will produce the docset in that
# directory and running "make install" will install the docset in
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
# it at startup.
# it at startup.
# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information.
GENERATE_DOCSET = NO
@@ -791,13 +843,12 @@ DOCSET_FEEDNAME = "Doxygen generated docs"
DOCSET_BUNDLE_ID = org.doxygen.Project
# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded. For this to work a browser that supports
# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
# If the GENERATE_HTMLHELP tag is set to YES, additional index files
# will be generated that can be used as input for tools like the
# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
# of the generated HTML documentation.
HTML_DYNAMIC_SECTIONS = NO
GENERATE_HTMLHELP = NO
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
# be used to specify the file name of the resulting .chm file. You
@@ -819,6 +870,12 @@ HHC_LOCATION =
GENERATE_CHI = NO
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
# is used to encode HtmlHelp index (hhk), content (hhc) and project file
# content.
CHM_INDEX_ENCODING =
# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
# controls whether a binary table of contents is generated (YES) or a
# normal table of contents (NO) in the .chm file.
@@ -830,6 +887,38 @@ BINARY_TOC = NO
TOC_EXPAND = NO
# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER
# are set, an additional index file will be generated that can be used as input for
# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated
# HTML documentation.
GENERATE_QHP = NO
# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
# be used to specify the file name of the resulting .qch file.
# The path specified is relative to the HTML output folder.
QCH_FILE =
# The QHP_NAMESPACE tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# <a href="http://doc.trolltech.com/qthelpproject.html#namespace">Qt Help Project / Namespace</a>.
QHP_NAMESPACE = org.doxygen.Project
# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# <a href="http://doc.trolltech.com/qthelpproject.html#virtual-folders">Qt Help Project / Virtual Folders</a>.
QHP_VIRTUAL_FOLDER = doc
# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
# be used to specify the location of Qt's qhelpgenerator.
# If non-empty doxygen will try to run qhelpgenerator on the generated
# .qhp file .
QHG_LOCATION =
# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
# top of each HTML page. The value NO (the default) enables the index and
# the value YES disables it.
@@ -841,12 +930,20 @@ DISABLE_INDEX = NO
ENUM_VALUES_PER_LINE = 4
# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
# generated containing a tree-like index structure (just like the one that
# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
# structure should be generated to display hierarchical information.
# If the tag value is set to FRAME, a side panel will be generated
# containing a tree-like index structure (just like the one that
# is generated for HTML Help). For this to work a browser that supports
# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,
# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are
# probably better off using the HTML help feature.
# probably better off using the HTML help feature. Other possible values
# for this tag are: HIERARCHIES, which will generate the Groups, Directories,
# and Class Hierarchy pages using a tree view instead of an ordered list;
# ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which
# disables this behavior completely. For backwards compatibility with previous
# releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE
# respectively.
GENERATE_TREEVIEW = NO
@@ -856,6 +953,14 @@ GENERATE_TREEVIEW = NO
TREEVIEW_WIDTH = 250
# Use this tag to change the font size of Latex formulas included
# as images in the HTML documentation. The default is 10. Note that
# when you change the font size after a successful doxygen run you need
# to manually remove any form_*.png images from the HTML output directory
# to force them to be regenerated.
FORMULA_FONTSIZE = 10
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
@@ -924,7 +1029,7 @@ USE_PDFLATEX = YES
# running if errors occur, instead of asking the user for help.
# This option is also used when generating formulas in HTML.
LATEX_BATCHMODE = NO
LATEX_BATCHMODE = YES
# If LATEX_HIDE_INDICES is set to YES then doxygen will not
# include the index chapters (such as File Index, Compound Index, etc.)
@@ -1132,9 +1237,9 @@ INCLUDE_FILE_PATTERNS =
# instead of the = operator.
PREDEFINED = FL_DOXYGEN \
HAVE_CAIRO \
HAVE_GL \
HAVE_GL_OVERLAY \
HAVE_CAIRO \
HAVE_GL \
HAVE_GL_OVERLAY \
FL_EXPORT:=
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
@@ -1230,6 +1335,24 @@ HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = NO
# By default doxygen will write a font called FreeSans.ttf to the output
# directory and reference it in all dot files that doxygen generates. This
# font does not include all possible unicode characters however, so when you need
# these (or just want a differently looking font) you can specify the font name
# using DOT_FONTNAME. You need need to make sure dot is able to find the font,
# which can be done by putting it in a standard location or by setting the
# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
# containing the font.
DOT_FONTNAME = FreeSans
# By default doxygen will tell dot to use the output directory to look for the
# FreeSans.ttf font (which doxygen will put there itself). If you specify a
# different font using DOT_FONTNAME you can set the path where dot
# can find it using this tag.
DOT_FONTPATH =
# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect inheritance relations. Setting this tag to YES will force the
@@ -1319,7 +1442,7 @@ DOT_PATH =
DOTFILE_DIRS =
# The MAX_DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
# nodes that will be shown in the graph. If the number of nodes in a graph
# becomes larger than this value, doxygen will truncate the graph, which is
# visualized by representing a node as a red box. Note that doxygen if the
@@ -1340,10 +1463,10 @@ DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is enabled by default, which results in a transparent
# background. Warning: Depending on the platform used, enabling this option
# may lead to badly anti-aliased labels on the edges of a graph (i.e. they
# become hard to read).
# background. This is disabled by default, because dot on Windows does not
# seem to support this out of the box. Warning: Depending on the platform used,
# enabling this option may lead to badly anti-aliased labels on the edges of
# a graph (i.e. they become hard to read).
DOT_TRANSPARENT = NO
documentation/Fl.html
-1392
View File
File diff suppressed because it is too large Load Diff
documentation/Fl_Adjuster.html
-53
View File
@@ -1,53 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Adjuster</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Adjuster>class Fl_Adjuster</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Valuator.html#Fl_Valuator>Fl_Valuator</A>
|
+----<B>Fl_Adjuster</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Adjuster.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Adjuster</TT> widget was stolen from Prisms, and has proven
to be very useful for values that need a large dynamic range.
<P ALIGN=CENTER><IMG SRC="adjuster1.gif" ALT="Fl_Adjuster widget."></P>
<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
<TT>100 * step()</TT>, the next by <TT>10 * step()</TT> and that
smallest button by <TT>step()</TT>. Clicking on the buttons
increments by 10 times the amount dragging by a pixel does. Shift +
click decrements by 10 times the amount.
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Adjuster.Fl_Adjuster>Fl_Adjuster</A></LI>
<LI><A href=#Fl_Adjuster.~Fl_Adjuster>~Fl_Adjuster</A></LI>
<LI><A href=#Fl_Adjuster.soft>soft</A></LI>
</UL>
<H4><A name=Fl_Adjuster.Fl_Adjuster>Fl_Adjuster::Fl_Adjuster(int x, int
y, int w, int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Adjuster</TT> widget using the given position,
size, and label string. It looks best if one of the dimensions is 3
times the other.
<H4><A name=Fl_Adjuster.~Fl_Adjuster>virtual Fl_Adjuster::~Fl_Adjuster()</A>
</H4>
Destroys the valuator.
<H4><A name=Fl_Adjuster.soft>uchar Fl_Adjuster::soft() const
<BR> void Fl_Adjuster::soft(uchar)</A></H4>
If &quot;soft&quot; 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.
</BODY></HTML>
documentation/Fl_BMP_Image.html
-57
View File
@@ -1,57 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_BMP_Image</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_BMP_Image">class Fl_BMP_Image</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A href="Fl_RGB_Image.html">Fl_RGB_Image</A>
|
+----<B>Fl_BMP_Image</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_BMP_Image.H&gt;
</PRE></UL>
<H3>Additional Libraries</H3>
<UL><PRE>
-lfltk_images / fltkimages.lib
</PRE></UL>
<H3>Description</H3>
<P>The <TT>Fl_BMP_Image</TT> class supports loading, caching,
and drawing of Windows Bitmap (BMP) image files.</P>
<H3>Methods</H3>
<UL>
<LI><A href="#Fl_BMP_Image.Fl_BMP_Image">Fl_BMP_Image</A></LI>
<LI><A href="#Fl_BMP_Image.~Fl_BMP_Image">~Fl_BMP_Image</A></LI>
</UL>
<H4><A name="Fl_BMP_Image.Fl_BMP_Image">Fl_BMP_Image::Fl_BMP_Image(const char *filename);</A></H4>
<P>The constructor loads the named BMP image.</P>
<H4><A name="Fl_BMP_Image.~Fl_BMP_Image">Fl_BMP_Image::~Fl_BMP_Image();</A></H4>
<P>The destructor free all memory and server resources that are used by
the image.</P>
</BODY>
</HTML>
documentation/Fl_Bitmap.html
-54
View File
@@ -1,54 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Bitmap</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_Bitmap">class Fl_Bitmap</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A href="Fl_Image.html">Fl_Image</A>
|
+----<B>Fl_Bitmap</B>
|
+----<A href="Fl_XBM_Image.html">Fl_XBM_Image</A>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_Bitmap.H&gt;
</PRE></UL>
<H3>Description</H3>
<P>The <TT>Fl_Bitmap</TT> class supports caching and drawing of mono-color
(bitmap) images. Images are drawn using the current color.</P>
<H3>Methods</H3>
<UL>
<LI><A href="#Fl_Bitmap.Fl_Bitmap">Fl_Bitmap</A></LI>
<LI><A href="#Fl_Bitmap.~Fl_Bitmap">~Fl_Bitmap</A></LI>
</UL>
<H4><A name="Fl_Bitmap.Fl_Bitmap">Fl_Bitmap::Fl_Bitmap(const char *array, int W, int H);<BR>
Fl_Bitmap::Fl_Bitmap(const unsigned char *array, int W, int H);</A></H4>
<P>The constructors create a new bitmap from the specified bitmap data.</P>
<H4><A name="Fl_Bitmap.~Fl_Bitmap">Fl_Bitmap::~Fl_Bitmap();</A></H4>
<P>The destructor free all memory and server resources that are used by
the bitmap.</P>
</BODY>
</HTML>
documentation/Fl_Box.html
-44
View File
@@ -1,44 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Box</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Box>class Fl_Box</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Widget.html#Fl_Widget>Fl_Widget</A>
|
+----<B>Fl_Box</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Box.H&gt;
</PRE>
</UL>
<H3>Description</H3>
This widget simply draws its box, and possibly it's label. Putting it
before some other widgets and making it big enough to surround them
will let you draw a frame around them.
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Box.Fl_Box>Fl_Box</A></LI>
<LI><A href=#Fl_Box.~Fl_Box>~Fl_Box</A></LI>
</UL>
<H4><A name=Fl_Box.Fl_Box>Fl_Box::Fl_Box(int x, int y, int w, int h,
const char * = 0)
<BR> Fl_Box::Fl_Box(Fl_Boxtype b, int x, int y, int w, int h, const
char *)</A></H4>
The first constructor sets <TT>box()</TT> to <TT>FL_NO_BOX</TT>, which
means it is invisible. However such widgets are useful as placeholders
or <A href="Fl_Group.html#Fl_Group.resizable"><TT>Fl_Group::resizable()</TT></A>
values. To change the box to something visible, use <TT>box(n)</TT>.
<P>The second form of the constructor sets the box to the specified box
type. </P>
<H4><A name=Fl_Box.~Fl_Box>Fl_Box::~Fl_Box(void)</A></H4>
The destructor removes the box.
</BODY></HTML>
documentation/Fl_Browser.html
-220
View File
@@ -1,220 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Browser</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Browser>class Fl_Browser</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Browser_.html#Fl_Browser_>Fl_Browser_</A>
|
+----<B>Fl_Browser</B>
|
+----<A href=Fl_File_Browser.html#Fl_File_Browser>Fl_File_Browser</A>, <A href=Fl_Hold_Browser.html#Fl_Hold_Browser>Fl_Hold_Browser</A>, <A href=Fl_Multi_Browser.html#Fl_Multi_Browser>Fl_Multi_Browser</A>, <A href=Fl_Select_Browser.html#Fl_Select_Browser>Fl_Select_Browser</A>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Browser.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Browser</TT> 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.
<P>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 &quot;no line&quot; 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;= <TT>size()</TT>.</I></P>
<P>Each line contains a null-terminated string of text and a <TT>void *</TT>
data pointer. The text string is displayed, the <TT>void *</TT>
pointer can be used by the callbacks to reference the object the text
describes. </P>
<P>The base class does nothing when the user clicks on it. The
subclasses <A href=Fl_Select_Browser.html#Fl_Select_Browser><TT>
Fl_Select_Browser</TT></A>, <A href=Fl_Hold_Browser.html#Fl_Hold_Browser>
<TT>Fl_Hold_Browser</TT></A>, and <A href=Fl_Multi_Browser.html#Fl_Multi_Browser>
<TT>Fl_Multi_Browser</TT></A> react to user clicks to select lines in
the browser and do callbacks. </P>
<P>The base class called <A href=Fl_Browser_.html#Fl_Browser_><TT>
Fl_Browser_</TT></A> 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 <TT>Fl_Browser_</TT>
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 <TT>Fl_Browser_</TT>. </P>
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Browser methods">
<TR><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Browser.Fl_Browser>Fl_Browser</A></LI>
<LI><A href=#Fl_Browser.~Fl_Browser>~Fl_Browser</A></LI>
<LI><A href=#Fl_Browser.add>add</A></LI>
<LI><A href=#Fl_Browser.bottomline>bottomline</A></LI>
<LI><A href=#Fl_Browser.clear>clear</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Browser.column_char>column_char</A></LI>
<LI><A href=#Fl_Browser.column_widths>column_widths</A></LI>
<LI><A href=#Fl_Browser.data>data</A></LI>
<LI><A href=#Fl_Browser.format_char>format_char</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Browser.hide>hide</A></LI>
<LI><A href=#Fl_Browser.insert>insert</A></LI>
<LI><A href=#Fl_Browser.load>load</A></LI>
<LI><A href=#Fl_Browser.middleline>middleline</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Browser.move>move</A></LI>
<LI><A href=#Fl_Browser.position>position</A></LI>
<LI><A href=#Fl_Browser.remove>remove</A></LI>
<LI><A href=#Fl_Browser.selected>selected</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Browser.show>show</A></LI>
<LI><A href=#Fl_Browser.size>size</A></LI>
<LI><A href=#Fl_Browser.swap>swap</A></LI>
<LI><A href=#Fl_Browser.text>text</A></LI>
</UL>
</TD>
<TD align=left valign=top>
<UL>
<LI><A href=#Fl_Browser.topline>topline</A></LI>
<LI><A href=#Fl_Browser.visible>visible</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name=Fl_Browser.Fl_Browser>Fl_Browser::Fl_Browser(int, int, int,
int, const char * = 0)</A></H4>
The constructor makes an empty browser.
<H4><A name=Fl_Browser.~Fl_Browser>Fl_Browser::~Fl_Browser(void)</A></H4>
The destructor deletes all list items and destroys the browser.
<H4><A name=Fl_Browser.add>void Fl_Browser::add(const char *, void * =
0)</A></H4>
Add a new line to the end of the browser. The text is copied using
the <TT>strdup()</TT> function. It may also be <TT>NULL</TT> to make a
blank line. The <TT>void *</TT> argument is returned as the <TT>data()</TT>
of the new item.
<H4><A name=Fl_Browser.bottomline>void Fl_Browser::bottomline(int n)</A></H4>
Scrolls the browser so the bottom line in the browser is <TT>n</TT>.
<H4><A name=Fl_Browser.clear>void Fl_Browser::clear()</A></H4>
Remove all the lines in the browser.
<H4><A name=Fl_Browser.column_char>uchar Fl_Browser::column_char() const
<BR> void Fl_Browser::column_char(char c)</A></H4>
The first form gets the current column separator character. By default
this is <TT>'\t'</TT> (tab).
<P>The second form sets the column separator to <TT>c</TT>. This will
only have an effect if you also set <TT>column_widths()</TT>. </P>
<H4><A name=Fl_Browser.column_widths>const int
*Fl_Browser::column_widths() const
<BR> void Fl_Browser::column_widths(const int *w)</A></H4>
The first form 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 <TT>column_char()</TT> 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 <TT>column_char()</TT>
. The default value is a one-element array of just a zero, which makes
there are no columns.
<P>The second form sets the current array to <TT>w</TT>. Make sure the
last entry is zero. </P>
<H4><A name=Fl_Browser.data>void *Fl_Browser::data(int n) const
<BR> void Fl_Browser::data(int n, void *)</A></H4>
The first form returns the data for line <TT>n</TT>. If <TT>n</TT> is
out of range this returns <TT>NULL</TT>.
<P>The second form sets the data for line <TT>n</TT>. </P>
<H4><A name=Fl_Browser.format_char>uchar Fl_Browser::format_char() const
<BR> void Fl_Browser::format_char(char c)</A></H4>
The first form gets the current format code prefix character, which by
default is <TT>@</TT>. 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:
<UL>
<LI><CODE>@.</CODE> Print rest of line, don't look for more '@' signs </LI>
<LI><CODE>@@</CODE> Print rest of line starting with '@' </LI>
<LI><CODE>@l</CODE> Use a <BIG>large</BIG> (24 point) font </LI>
<LI><CODE>@m</CODE> Use a <BIG>medium large</BIG> (18 point) font </LI>
<LI><CODE>@s</CODE> Use a <SMALL>small</SMALL> (11 point) font </LI>
<LI><CODE>@b</CODE> Use a <B>bold</B> font (adds FL_BOLD to font) </LI>
<LI><CODE>@i</CODE> Use an <I>italic</I> font (adds FL_ITALIC to font) </LI>
<LI><CODE>@f</CODE> or <CODE>@t</CODE> Use a <CODE>fixed-pitch</CODE>
font (sets font to FL_COURIER) </LI>
<LI><CODE>@c</CODE> Center the line horizontally </LI>
<LI><CODE>@r</CODE> Right-justify the text </LI>
<LI><CODE>@B0, @B1, ... @B255</CODE> Fill the backgound with
fl_color(n) </LI>
<LI><CODE>@C0, @C1, ... @C255</CODE> Use fl_color(n) to draw the text </LI>
<LI><CODE>@F0, @F1, ... </CODE> Use fl_font(n) to draw the text </LI>
<LI><CODE>@S1, @S2, ... </CODE> Use point size n to draw the text </LI>
<LI><CODE>@u</CODE> or <CODE>@_</CODE> Underline the text. </LI>
<LI><CODE>@-</CODE> draw an engraved line through the middle. </LI>
</UL>
Notice that the <CODE>@.</CODE> command can be used to reliably
terminate the parsing. To print a random string in a random color, use <TT>
sprintf(&quot;@C%d@.%s&quot;, color, string)</TT> and it will work even if the
string starts with a digit or has the format character in it.
<P>The second form sets the current prefix to <TT>c</TT>. Set the
prefix to 0 to disable formatting. </P>
<H4><A name=Fl_Browser.hide>void Fl_Browser::hide(int n)</A></H4>
Makes line <TT>n</TT> invisible, preventing selection by the user.
The line can still be selected under program control.
<H4><A name=Fl_Browser.insert>void Fl_Browser::insert(int n, const char
*, void * = 0)</A></H4>
Insert a new line <I>before</I> line <TT>n</TT>. If <TT>n</TT> &gt; <TT>
size()</TT> then the line is added to the end.
<H4><A name=Fl_Browser.load>int Fl_Browser::load(const char *filename)</A>
</H4>
Clears the browser and reads the file, adding each line from the file
to the browser. If the filename is <TT>NULL</TT> or a zero-length
string then this just clears the browser. This returns zero if there
was any error in opening or reading the file, in which case <TT>errno</TT>
is set to the system error. The <TT>data()</TT> of each line is set
to <TT>NULL</TT>.
<H4><A name=Fl_Browser.middleline>void Fl_Browser::middleline(int n)</A></H4>
Scrolls the browser so the middle line in the browser is <TT>n</TT>.
<H4><A name=Fl_Browser.move>void Fl_Browser::move(int to, int from)</A></H4>
Line <TT>from</TT> is removed and reinserted at <TT>to</TT>; <TT>to</TT>
is calculated after the line is removed.
<H4><A name=Fl_Browser.position>int Fl_Browser::position() const
<BR> void Fl_Browser::position(int p)</A></H4>
The first form returns the current vertical scrollbar position, where
0 corresponds to the top. If there is not vertical scrollbar then this
will always return 0.
<P>The second form sets the vertical scrollbar position to <TT>p</TT>. </P>
<H4><A name=Fl_Browser.remove>void Fl_Browser::remove(int n)</A></H4>
Remove line <TT>n</TT> and make the browser one line shorter.
<H4><A name=Fl_Browser.selected>int Fl_Browser::selected(int n) const</A></H4>
Return 1 if line <TT>n</TT> is selected, 0 if it not selected.
<H4><A name=Fl_Browser.show>void Fl_Browser::show(int n)</A></H4>
Makes line <TT>n</TT> visible for selection.
<H4><A name=Fl_Browser.size>int Fl_Browser::size() const</A></H4>
Returns how many lines are in the browser. The last line number is
equal to this.
<H4><A name=Fl_Browser.swap>void Fl_Browser::swap(int a, int b)</A></H4>
Swaps two lines in the browser.
<H4><A name=Fl_Browser.text>const char *Fl_Browser::text(int n) const
<BR> void Fl_Browser::text(int n, const char *)</A></H4>
The first form returns the text for line <TT>n</TT>. If <TT>n</TT> is
out of range it returns <TT>NULL</TT>.
<P>The second form sets the text for line <TT>n</TT>. </P>
<H4><A name=Fl_Browser.topline>int Fl_Browser::topline() const
<BR> void Fl_Browser::topline(int n)</A></H4>
The first form returns the current top line in the browser. If there
is no vertical scrollbar then this will always return 1.
<P>The second form scrolls the browser so the top line in the browser is <TT>n</TT>.</P>
<H4><A name=Fl_Browser.visible>int Fl_Browser::visible(int n) const</A></H4>
Returns a non-zero value if line <TT>n</TT> is visible. </BODY></HTML>
documentation/Fl_Browser_.html
-419
View File
@@ -1,419 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Browser_</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_Browser_">class Fl_Browser_</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href="Fl_Group.html#Fl_Group">Fl_Group</A>
|
+----<B>Fl_Browser_</B>
|
+----<A href=Fl_Browser.html#Fl_Browser>Fl_Browser</A>, <A href=Fl_Check_Browser.html#Fl_Check_Browser>Fl_Check_Browser</A>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Browser_.H&gt;
</PRE>
</UL>
<H3>Description</H3>
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.
<P>This has been designed so that the subclass has complete control
over the storage of the data, although because <TT>next()</TT> and <TT>
prev()</TT> 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. </P>
<P>A great deal of work has been done so that the &quot;height&quot; 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 <TT>stat()</TT> on a file or doing some
other slow operation. </P>
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Browser_ methods">
<TR><TD align=left valign=top>
<UL>
<LI><A href="#Fl_Browser_.Fl_Browser_">Fl_Browser_</A></LI>
<LI><A href="#Fl_Browser_.~Fl_Browser_">~Fl_Browser_</A></LI>
<LI><A href="#Fl_Browser_.bbox">bbox</A></LI>
<LI><A href="#Fl_Browser_.deleting">deleting</A></LI>
<LI><A href="#Fl_Browser_.deselect">deselect</A></LI>
<LI><A href="#Fl_Browser_.display">display</A></LI>
<LI><A href="#Fl_Browser_.displayed">displayed</A></LI>
<LI><A href="#Fl_Browser_.draw">draw</A></LI>
<LI><A href="#Fl_Browser_.find_item">find_item</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href="#Fl_Browser_.full_height">full_height</A></LI>
<LI><A href="#Fl_Browser_.full_width">full_width</A></LI>
<LI><A href="#Fl_Browser_.handle">handle</A></LI>
<LI><A href="#Fl_Browser_.has_scrollbar">has_scrollbar</A></LI>
<LI><A href="#Fl_Browser_.hposition">hposition</A></LI>
<LI><A href="#Fl_Browser_.incr_height">incr_height</A></LI>
<LI><A href="#Fl_Browser_.inserting">inserting</A></LI>
<LI><A href="#Fl_Browser_.item_draw">item_draw</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href="#Fl_Browser_.item_first">item_first</A></LI>
<LI><A href="#Fl_Browser_.item_height">item_height</A></LI>
<LI><A href="#Fl_Browser_.item_next">item_next</A></LI>
<LI><A href="#Fl_Browser_.item_prev">item_prev</A></LI>
<LI><A href="#Fl_Browser_.item_quick_height">item_quick_height</A></LI>
<LI><A href="#Fl_Browser_.item_select">item_select</A></LI>
<LI><A href="#Fl_Browser_.item_selected">item_selected</A></LI>
<LI><A href="#Fl_Browser_.item_width">item_width</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href="#Fl_Browser_.leftedge">leftedge</A></LI>
<LI><A href="#Fl_Browser_.new_list">new_list</A></LI>
<LI><A href="#Fl_Browser_.position">position</A></LI>
<LI><A href="#Fl_Browser_.redraw_line">redraw_line</A></LI>
<LI><A href="#Fl_Browser_.redraw_lines">redraw_lines</A></LI>
<LI><A href="#Fl_Browser_.replacing">replacing</A></LI>
<LI><A href="#Fl_Browser_.resize">resize</A></LI>
<LI><A href="#Fl_Browser_.scrollbar_left">scrollbar_left</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href="#Fl_Browser_.scrollbar_right">scrollbar_right</A></LI>
<LI><A href="#Fl_Browser_.scrollbar_width">scrollbar_width</A></LI>
<LI><A href="#Fl_Browser_.select">select</A></LI>
<LI><A href="#Fl_Browser_.select_only">select_only</A></LI>
<LI><A href="#Fl_Browser_.selection">selection</A></LI>
<LI><A href="#Fl_Browser_.textcolor">textcolor</A></LI>
<LI><A href="#Fl_Browser_.textfont">textfont</A></LI>
<LI><A href="#Fl_Browser_.textsize">textsize</A></LI>
<LI><A href="#Fl_Browser_.top">top</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name="Fl_Browser_.Fl_Browser_">Fl_Browser::Fl_Browser(int, int,
int, int, const char * = 0)</A></H4>
<P>The constructor makes an empty browser.
<H4><A name="Fl_Browser_.~Fl_Browser_">Fl_Browser::~Fl_Browser(void)</A></H4>
<P>The destructor deletes all list items and destroys the browser.
<H4><A NAME="Fl_Browser_.bbox">Fl_Browser_::bbox(int &amp;x, int &amp;y, int &amp;w, int &amp;h) const</A></H4>
<P><tt>[protected]</tt> This method returns the bounding box for the interior of the list, inside
the scrollbars.
<H4><A NAME="Fl_Browser_.deleting">Fl_Browser_::deleting(void *a)</A></H4>
<P><tt>[protected]</tt> This method should be used when an item is deleted from the list.
It allows the <TT>Fl_Browser_</TT> to discard any cached data it has
on the item.
<H4><A NAME="Fl_Browser_.deselect">int Fl_Browser_::deselect(int docb=0)</A></H4>
<P>Deselects all items in the list and returns 1 if the state changed
or 0 if it did not.
<P>If <TT>docb</TT> is non-zero, <TT>deselect</TT> tries to call the
callback function for the widget.
<H4><A NAME="Fl_Browser_.display">Fl_Browser_::display(void *p)</A></H4>
<P>Displays item <TT>p</TT>, scrolling the list as necessary.
<H4><A NAME="Fl_Browser_.displayed">int Fl_Browser_::displayed(void *p) const</A></H4>
<P><tt>[protected]</tt> This method returns non-zero if item <TT>p</TT> is currently visible in
the list.
<H4><A NAME="Fl_Browser_.draw">Fl_Browser_::draw()
<BR>Fl_Browser_::draw(int x, int y, int w, int h)</A></H4>
<P><tt>[protected]</tt> The first form draws the list within the normal widget bounding box.
<P><tt>[protected]</tt> The second form draws the contents of the browser within the
specified bounding box.
<H4><A NAME="Fl_Browser_.find_item">void *Fl_Browser_::find_item(int my)</A></H4>
<P>This method returns the item under mouse at <TT>my</TT>. If no item is
displayed at that position then <TT>NULL</TT> is returned.
<H4><A NAME="Fl_Browser_.full_height">virtual int Fl_Browser_::full_height() const</A></H4>
<P><tt>[protected]</tt> This method may be provided by the subclass to indicate the full height
of the item list in pixels. The default implementation computes the full
height from the item heights.
<H4><A NAME="Fl_Browser_.full_width">Fl_Browser_::full_width() const</A></H4>
<P><tt>[protected]</tt> This method may be provided by the subclass to indicate the full width
of the item list in pixels. The default implementation computes the full
width from the item widths.
<H4><A NAME="Fl_Browser_.handle">Fl_Browser_::handle(int event)
<BR>Fl_Browser_::handle(int event, int x, int y, int w, int h)</A></H4>
<P>The first form handles an event within the normal widget bounding box.
<P><tt>[protected]</tt> The second form handles an event within the specified bounding box.
<H4><A name="Fl_Browser_.has_scrollbar">void
Fl_Browser_::has_scrollbar(int h)</A></H4>
<P>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 <TT>h</TT>:
<UL>
<LI><CODE>0</CODE> - No scrollbars.
<LI><CODE>Fl_Browser_::HORIZONTAL</CODE> - Only a horizontal
scrollbar.
<LI><CODE>Fl_Browser_::VERTICAL</CODE> - Only a vertical
scrollbar.
<LI><CODE>Fl_Browser_::BOTH</CODE> - The default is both
scrollbars.
<LI><CODE>Fl_Browser_::HORIZONTAL_ALWAYS</CODE> - Horizontal
scrollbar always on, vertical always off.
<LI><CODE>Fl_Browser_::VERTICAL_ALWAYS</CODE> - Vertical
scrollbar always on, horizontal always off.
<LI><CODE>Fl_Browser_::BOTH_ALWAYS</CODE> - Both always on.
</UL>
<H4><A NAME="Fl_Browser_.hposition">int Fl_Browser_::hposition() const
<BR>Fl_Browser_::hposition(int h)</A></H4>
<P>Gets or sets the horizontal scrolling position of the list,
which is the pixel offset of the list items within the list
area.
<H4><A NAME="Fl_Browser_.incr_height">virtual int Fl_Browser_::incr_height() const</A></H4>
<P><tt>[protected]</tt> This method may be provided to return the average height of all items, to
be used for scrolling. The default implementation uses the height of the first
item.
<H4><A NAME="Fl_Browser_.inserting">Fl_Browser_::inserting(void *a, void *b)</A></H4>
<P><tt>[protected]</tt> This method should be used when an item is added to the list.
It allows the <TT>Fl_Browser_</TT> to update its cache data as needed.
<H4><A NAME="Fl_Browser_.item_draw">virtual void Fl_Browser_::item_draw(void *p, int x, int y, int w, int h)</A></H4>
<P><tt>[protected]</tt> This method must be provided by the subclass to draw the item
<TT>p</TT> in the area indicated by <TT>x</TT>, <TT>y</TT>, <TT>w</TT>,
and <TT>h</TT>.
<H4><A NAME="Fl_Browser_.item_first">virtual void *Fl_Browser_::item_first() const</A></H4>
<P><tt>[protected]</tt> This method must be provided by the subclass to return the first item in
the list.
<H4><A NAME="Fl_Browser_.item_height">virtual int Fl_Browser_::item_height(void *p) const</A></H4>
<P><tt>[protected]</tt> This method must be provided by the subclass to return the height of the
item <TT>p</TT> in pixels. Allow for two additional pixels for the list
selection box.
<H4><A NAME="Fl_Browser_.item_next">virtual void *Fl_Browser_::item_next(void *p) const</A></H4>
<P><tt>[protected]</tt> This method must be provided by the subclass to return the item in
the list after <TT>p</TT>.
<H4><A NAME="Fl_Browser_.item_prev">virtual void *Fl_Browser_::item_prev(void *p) const</A></H4>
<P><tt>[protected]</tt> This method must be provided by the subclass to return the item in
the list before <TT>p</TT>.
<H4><A NAME="Fl_Browser_.item_quick_height">virtual int Fl_Browser_::item_quick_height(void *p) const</A></H4>
<P><tt>[protected]</tt> This method may be provided by the subclass to return the height of the
item <TT>p</TT> in pixels. Allow for two additional pixels for the list
selection box. This method differs from
<A HREF="#Fl_Browser_.item_height"><TT>item_height</TT></A> in that it is only
called for selection and scrolling operations. The default implementation
calls <TT>item_height</TT>.
<H4><A NAME="Fl_Browser_.item_select">virtual void Fl_Browser_::item_select(void *p, int s=1)</A></H4>
<P><tt>[protected]</tt> This method must be implemented by the subclass if it supports
multiple selections in the browser. The <TT>s</TT> argument specifies the
selection state for item <TT>p</TT>: 0 = off, 1 = on.
<H4><A NAME="Fl_Browser_.item_selected">virtual int Fl_Browser_::item_selected(void *p) const</A></H4>
<P><tt>[protected]</tt> This method must be implemented by the subclass if it supports
multiple selections in the browser. The method should return 1 if <TT>p</TT>
is selected and 0 otherwise.
<H4><A NAME="Fl_Browser_.item_width">virtual int Fl_Browser_::item_width(void *p) const</A></H4>
<P><tt>[protected]</tt> This method must be provided by the subclass to return the width of the
item <TT>p</TT> in pixels. Allow for two additional pixels for the list
selection box.
<H4><A NAME="Fl_Browser_.leftedge">int Fl_Browser_::leftedge() const</A></H4>
<P><tt>[protected]</tt> This method returns the X position of the left edge of the list area
after adjusting for the scrollbar and border, if any.
<H4><A NAME="Fl_Browser_.new_list">Fl_Browser_::new_list()</A></H4>
<P><tt>[protected]</tt> This method should be called when the list data is completely replaced
or cleared. It informs the <TT>Fl_Browser_</TT> widget that any cached
information it has concerning the items is invalid.
<H4><A NAME="Fl_Browser_.position">int Fl_Browser_::position() const
<BR>Fl_Browser_::position(int v) const</A></H4>
<P>Gets or sets the vertical scrolling position of the list,
which is the pixel offset of the list items within the list
area.
<H4><A NAME="Fl_Browser_.redraw_line">Fl_Browser_::redraw_line(void *p)</A></H4>
<P><tt>[protected]</tt> This method should be called when the contents of an item have changed
but not changed the height of the item.
<H4><A NAME="Fl_Browser_.redraw_lines">Fl_Browser_::redraw_lines()</A></H4>
<P><tt>[protected]</tt> This method will cause the entire list to be redrawn.
<H4><A NAME="Fl_Browser_.replacing">Fl_Browser_::replacing(void *a, void *b)</A></H4>
<P><tt>[protected]</tt> This method should be used when an item is replaced in the list.
It allows the <TT>Fl_Browser_</TT> to update its cache data as needed.
<H4><A NAME="Fl_Browser_.resize">Fl_Browser_::resize(int x, int y, int w, int h)</A></H4>
<P>Repositions and/or resizes the browser.
<H4><A NAME="Fl_Browser_.scrollbar_left">Fl_Browser_::scrollbar_left()</A></H4>
<P>This method moves the vertical scrollbar to the lefthand side of the list.
<H4><A NAME="Fl_Browser_.scrollbar_right">Fl_Browser_::scrollbar_right()</A></H4>
<P>This method moves the vertical scrollbar to the righthand side of the list.
<H4><A NAME="Fl_Browser_.scrollbar_width">static void Fl_Browser_::scrollbar_width(int sw);</A><BR>
static int Fl_Browser_::scrollbar_width() const;</H4>
<P>Sets or gets the width of any scrollbars that are used.
<H4><A NAME="Fl_Browser_.select">int Fl_Browser_::select(void *p, int s=1, int docb=0)</A></H4>
<P>Sets the selection state of item <TT>p</TT> to <TT>s</TT> and
returns 1 if the state changed or 0 if it did not.
<P>If <TT>docb</TT> is non-zero, <TT>select</TT> tries to call the callback
function for the widget.
<H4><A NAME="Fl_Browser_.select_only">Fl_Browser_::select_only(void *p, int docb=0)</A></H4>
<P>Selects item <TT>p</TT> and returns 1 if the state changed or 0 if it did
not. Any other items in the list are deselected.
<P>If <TT>docb</TT> is non-zero, <TT>select_only</TT> tries to call the
callback function for the widget.
<H4><A NAME="Fl_Browser_.selection">void *Fl_Browser_::selection() const</A></H4>
<P><tt>[protected]</tt> Returns the item currently selected, or NULL if there is no selection.
<P>For multiple selection browsers this call returns the currently focused item,
even if it is not selected. To find all selected items, call
<TT><A href=Fl_Multi_Browser.html#Fl_Multi_Browser.select>
Fl_Multi_Browser::selected()</A></TT> for every item in question.
<H4><A name="Fl_Browser_.textcolor">Fl_Color Fl_Browser_::textcolor() const
<BR>void Fl_Browser_::textcolor(Fl_Color color)</A></H4>
<P>The first form gets the default text color for the lines in the
browser.
<P>The second form sets the default text color to <TT>color</TT></P>
<H4><A name="Fl_Browser_.textfont">Fl_Font Fl_Browser_::textfont() const
<BR>void Fl_Browser_::textfont(Fl_Font font)</A></H4>
<P>The first form gets the default text font for the lines in the
browser.
<P>The second form sets the default text font to <TT>font</TT></P>
<H4><A name="Fl_Browser_.textsize">uchar Fl_Browser_::textsize() const
<BR>void Fl_Browser_::textsize(uchar size)</A></H4>
<P>The first form gets the default text size for the lines in the
browser.
<P>The second form sets the default text size to <TT>size</TT></P>
<H4><A NAME="Fl_Browser_.top">void *Fl_Browser_::top() const</A></H4>
<P><tt>[protected]</tt> Returns the item the appears at the top of the list.
</BODY>
</HTML>
documentation/Fl_Button.html
-134
View File
@@ -1,134 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Button</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Button>class Fl_Button</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Widget.html#Fl_Widget>Fl_Widget</A>
|
+----<B>Fl_Button</B>
|
+----<A href=Fl_Check_Button.html#Fl_Check_Button>Fl_Check_Button</A>, <A href=Fl_Light_Button.html#Fl_Light_Button>Fl_Light_Button</A>, <A href=Fl_Repeat_Button.html#Fl_Repeat_Button>Fl_Repeat_Button</A>,
<A href=Fl_Return_Button.html#Fl_Return_Button>Fl_Return_Button</A>, <A href=Fl_Round_Button.html#Fl_Round_Button>Fl_Round_Button</A>, <A href=Fl_Toggle_Button.html#Fl_Toggle_Button>Fl_Toggle_Button</A>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Button.H&gt;
</PRE>
</UL>
<H3>Description</H3>
<P>Buttons generate callbacks when they are clicked by the user. You
control exactly when and how by changing the values for <TT>type()</TT>
and <TT>when()</TT>. </P>
<P>Buttons can also generate callbacks in response to <TT>FL_SHORTCUT</TT>
events. The button can either have an explicit <A href=#Fl_Button.shortcut>
<TT>shortcut()</TT></A> value or a letter shortcut can be indicated in
the <TT>label()</TT> with an '&amp;' character before it. For the label
shortcut it does not matter if <I>Alt</I> is held down, but if you have
an input field in the same window, the user will have to hold down the <I>
Alt</I> key so that the input field does not eat the event first as an <TT>
FL_KEYBOARD</TT> event. </P>
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Button methods">
<TR><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Button.Fl_Button>Fl_Button</A></LI>
<LI><A href=#Fl_Button.~Fl_Button>~Fl_Button</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Button.clear>clear</A></LI>
<LI><A href=#Fl_Button.down_box>down_box</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Button.set>set</A></LI>
<LI><A href=#Fl_Button.setonly>setonly</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Button.shortcut>shortcut</A></LI>
<LI><A href=#Fl_Button.type>type</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Button.value>value</A></LI>
<LI><A href=#Fl_Button.when>when</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name=Fl_Button.Fl_Button>Fl_Button::Fl_Button(int x, int y, int
w, int h, const char *label = 0)</A></H4>
The constructor creates the button using the position, size, and
label.
<H4><A name=Fl_Button.~Fl_Button>Fl_Button::~Fl_Button(void)</A></H4>
The destructor removes the button.
<H4><A name=Fl_Button.clear>int Fl_Button::clear()</A></H4>
Same as <TT>value(0)</TT>.
<H4><A name=Fl_Button.down_box>Fl_Boxtype Fl_Button::down_box() const
<BR> void Fl_Button::down_box(Fl_Boxtype bt)</A></H4>
The first form returns the current down box type, which is drawn when <TT>
value()</TT> is non-zero.
<P>The second form sets the down box type. The default value of 0
causes FLTK to figure out the correct matching down version of <TT>box()</TT>
. </P>
<H4><A name=Fl_Button.set>int Fl_Button::set()</A></H4>
Same as <TT>value(1)</TT>.
<H4><A name=Fl_Button.setonly>void Fl_Button::setonly()</A></H4>
Turns on this button and turns off all other radio buttons in the
group (calling <TT>value(1)</TT> or <TT>set()</TT> does not do this).
<H4><A name=Fl_Button.shortcut>ulong Fl_Button::shortcut() const
<BR> void Fl_Button::shortcut(ulong key)</A></H4>
The first form returns the current shortcut key for the button.
<P>The second form sets the shortcut key to <TT>key</TT>. Setting this
overrides the use of '&amp;' in the <TT>label()</TT>. The value is a bitwise
OR of a key and a set of shift flags, for example <CODE>FL_ALT | 'a'</CODE>
, <CODE>FL_ALT | (FL_F + 10)</CODE>, or just <CODE>'a'</CODE>. A value
of 0 disables the shortcut. </P>
<P>The key can be any value returned by <A href="Fl.html#Fl.event_key">
<TT>Fl::event_key()</TT></A>, but will usually be an ASCII letter. Use
a lower-case letter unless you require the shift key to be held down. </P>
<P>The shift flags can be any set of values accepted by <A href="Fl.html#Fl.event_state">
<TT>Fl::event_state()</TT></A>. 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 &quot;don't care&quot;
setting). </P>
<H4><A name=Fl_Button.type>uchar Fl_Button::type() const
<BR> void Fl_Button::type(uchar t)</A></H4>
The first form of <TT>type()</TT> returns the current button type,
which can be one of:
<UL>
<LI><CODE>0</CODE>: The value is unchanged. </LI>
<LI><CODE>FL_TOGGLE_BUTTON</CODE>: The value is inverted. </LI>
<LI><CODE>FL_RADIO_BUTTON</CODE>: The value is set to 1, and all other
buttons in the current group with <CODE>type() == FL_RADIO_BUTTON</CODE>
are set to zero. </LI>
</UL>
The second form sets the button type to <TT>t</TT>.
<H4><A name=Fl_Button.value>char Fl_Button::value() const
<BR> int Fl_Button::value(int)</A></H4>
The first form returns the current value (0 or 1). The second form
sets the current value.
<H4><A name=Fl_Button.when>Fl_When Fl_Widget::when() const
<BR> void Fl_Widget::when(Fl_When w)</A></H4>
Controls when callbacks are done. The following values are useful,
the default value is <CODE>FL_WHEN_RELEASE</CODE>:
<UL>
<LI><CODE>0</CODE>: The callback is not done, instead changed() is
turned on. </LI>
<LI><CODE>FL_WHEN_RELEASE</CODE>: The callback is done after the user
successfully clicks the button, or when a shortcut is typed. </LI>
<LI><CODE>FL_WHEN_CHANGED </CODE>: 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). </LI>
</UL>
</BODY></HTML>
documentation/Fl_Chart.html
-123
View File
@@ -1,123 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Chart</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Chart>class Fl_Chart</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Widget.html#Fl_Widget>Fl_Widget</A>
|
+----<B>Fl_Chart</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Chart.H&gt;
</PRE>
</UL>
<H3>Description</H3>
This widget displays simple charts and is provided for Forms compatibility.
<CENTER><IMG src="charts.gif" width="80%" alt="Fl_Chart widget"></CENTER>
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Chart methods.">
<TR><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Chart.Fl_Chart>Fl_Chart</A></LI>
<LI><A href=#Fl_Chart.~Fl_Chart>~Fl_Chart</A></LI>
<LI><A href=#Fl_Chart.add>add</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Chart.autosize>autosize</A></LI>
<LI><A href=#Fl_Chart.bounds>bounds</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Chart.clear>clear</A></LI>
<LI><A href=#Fl_Chart.insert>insert</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Chart.maxsize>maxsize</A></LI>
<LI><A href=#Fl_Chart.replace>replace</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Chart.size>size</A></LI>
<LI><A href=#Fl_Chart.type>type</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name=Fl_Chart.Fl_Chart>Fl_Chart::Fl_Chart(int x, int y, int w,
int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Chart</TT> widget using the given position, size,
and label string. The default boxtype is <TT>FL_NO_BOX</TT>.
<H4><A name=Fl_Chart.~Fl_Chart>virtual Fl_Chart::~Fl_Chart()</A></H4>
Destroys the <TT>Fl_Chart</TT> widget and all of its data.
<H4><A name=Fl_Chart.add>void add(double value, const char *label =
NULL, uchar color = 0)</A></H4>
The <TT>add</TT> method adds the <TT>value</TT> and optionally <TT>
label</TT> and <TT>color</TT> to the chart.
<H4><A name=Fl_Chart.autosize>uchar autosize(void) const
<BR> void autosize(uchar onoff)</A></H4>
The <TT>autosize</TT> method controls whether or not the chart will
automatically adjust the bounds of the chart. The first form returns a
boolean value that is non-zero if auto-sizing is enabled and zero is
auto-sizing is disabled.
<P>The second form of <TT>autosize</TT> sets the auto-sizing property
to <TT>onoff</TT>. </P>
<H4><A name=Fl_Chart.bounds>void bounds(double *a, double *b)
<BR> void bounds(double a, double b)</A></H4>
The <TT>bounds</TT> method gets or sets the lower and upper bounds of
the chart values to <TT>a</TT> and <TT>b</TT> respectively.
<H4><A name=Fl_Chart.clear>void clear(void)</A></H4>
The <TT>clear</TT> method removes all values from the chart.
<H4><A name=Fl_Chart.insert>void insert(int pos, double value, const
char *label = NULL, uchar color = 0)</A></H4>
The <TT>insert</TT> method inserts a data value at the given position <TT>
pos</TT>. Position 1 is the first data value.
<H4><A name=Fl_Chart.maxsize>int maxsize(void) const
<BR> void maxsize(int n)</A></H4>
The <TT>maxsize</TT> method gets or sets the maximum number of data
values for a chart. If you do not call this method then the chart will
be allowed to grow to any size depending on available memory.
<H4><A name=Fl_Chart.replace>void replace(int pos, double value, const
char *label = NULL, uchar color = 0)</A></H4>
The <TT>replace</TT> method replaces data value <TT>pos</TT> with <TT>
value</TT>, <TT>label</TT>, and <TT>color</TT>. Position 1 is the
first data value.
<H4><A name=Fl_Chart.size>int size(void) const</A></H4>
The <TT>size</TT> method returns the number of data values in the
chart.
<H4><A name=Fl_Chart.type>uchar type() const
<BR> void type(uchar t)</A></H4>
The first form of <TT>type()</TT> returns the current chart type. The
chart type can be one of the following:
<DL>
<DT>FL_BAR_CHART</DT>
<DD>Each sample value is drawn as a vertical bar.</DD>
<DT>FL_FILLED_CHART</DT>
<DD>The chart is filled from the bottom of the graph to the sample
values.</DD>
<DT>FL_HORBAR_CHART</DT>
<DD>Each sample value is drawn as a horizontal bar.</DD>
<DT>FL_LINE_CHART</DT>
<DD>The chart is drawn as a polyline with vertices at each sample
value.</DD>
<DT>FL_PIE_CHART</DT>
<DD>A pie chart is drawn with each sample value being drawn as a
proportionate slice in the circle.</DD>
<DT>FL_SPECIALPIE_CHART</DT>
<DD>Like FL_PIE_CHART, but the first slice is separated from the pie.</DD>
<DT>FL_SPIKE_CHART</DT>
<DD>Each sample value is drawn as a vertical line.</DD>
</DL>
The second form of <TT>type()</TT> sets the chart type to <TT>t</TT>.
</BODY></HTML>
documentation/Fl_Check_Browser.html
-104
View File
@@ -1,104 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Check_Browser</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Check_Browser>class Fl_Check_Browser</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Browser_.html#Fl_Browser_>Fl_Browser_</A>
|
+----<B>Fl_Check_Browser</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Check_Browser.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Check_Browser</TT> widget displays a scrolling list of text
lines that may be selected and/or checked by the user.
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Check_Browser methods">
<TR><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Check_Browser.Fl_Check_Browser>Fl_Check_Browser</A></LI>
<!-- <LI><A href=#Fl_Check_Browser.~Fl_Check_Browser>~Fl_Check_Browser</A></LI>-->
<LI><A href=#Fl_Check_Browser.add>add</A></LI>
<LI><A href=#Fl_Check_Browser.check_all>check_all</A></LI>
<LI><A href=#Fl_Check_Browser.check_none>check_none</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Check_Browser.checked>checked</A></LI>
<LI><A href=#Fl_Check_Browser.clear>clear</A></LI>
<LI><A href=#Fl_Check_Browser.nchecked>nchecked</A></LI>
<LI><A href=#Fl_Check_Browser.nitems>nitems</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Check_Browser.remove>remove</A></LI>
<LI><A href=#Fl_Check_Browser.set_checked>set_checked</A></LI>
<LI><A href=#Fl_Check_Browser.text>text</A></LI>
<LI><A href=#Fl_Check_Browser.value>value</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name=Fl_Check_Browser.Fl_Check_Browser>Fl_Check_Browser::Fl_Check_Browser(int, int, int, int, const char * = 0)</A></H4>
The constructor makes an empty browser.
<!--
<H4><A name=Fl_Check_Browser.~Fl_Check_Browser>Fl_Check_Browser::~Fl_Check_Browser(void)</A></H4>
The destructor deletes all list items and destroys the browser.
-->
<H4><A name=Fl_Check_Browser.add>int Fl_Check_Browser::add(const char *)<BR>
int Fl_Check_Browser::add(const char *, int)</A></H4>
Add a new unchecked line to the end of the browser. The text is copied
using the <TT>strdup()</TT> function. It may also be <TT>NULL</TT> to make
a blank line. The second form can set the item checked.
<H4><A name=Fl_Check_Browser.check_all>void Fl_Check_Browser::check_all()</A></H4>
Sets all the items checked.
<H4><A name=Fl_Check_Browser.check_none>void Fl_Check_Browser::check_none()</A></H4>
Sets all the items unchecked.
<H4><A name=Fl_Check_Browser.checked>int Fl_Check_Browser::checked(int item) const<BR>
void Fl_Check_Browser::checked(int item, int b)</A></H4>
The first form gets the current status of item <TT>item</TT>. The second form
sets the check status of item <TT>item</TT> to <TT>b</TT>.
<H4><A name=Fl_Check_Browser.clear>void Fl_Check_Browser::clear()</A></H4>
Remove every item from the browser.
<H4><A name=Fl_Check_Browser.nchecked>int Fl_Check_Browser::nchecked() const</A></H4>
Returns how many items are currently checked.
<H4><A name=Fl_Check_Browser.nitems>int Fl_Check_Browser::nitems() const</A></H4>
Returns how many lines are in the browser. The last line number is equal to
this.
<H4><A name=Fl_Check_Browser.remove>int Fl_Check_Browser::remove(int n)</A></H4>
Remove line <TT>n</TT> and make the browser one line shorter. Returns the
number of lines left in the browser.
<H4><A name=Fl_Check_Browser.set_checked>void Fl_Check_Browser::set_checked(int item)</A></H4>
Equivalent to <TT>Fl_Check_Browser::checked(item, 1)</TT>.
<H4><A name=Fl_Check_Browser.text>char *Fl_Check_Browser::text(int item) const</A></H4>
Return a pointer to an internal buffer holding item <TT>item</TT>'s text.
<H4><A name=Fl_Check_Browser.value>int Fl_Check_Browser::value() const</A></H4>
Returns the index of the currently selected item.
</BODY>
</HTML>
documentation/Fl_Check_Button.html
-45
View File
@@ -1,45 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Check_Button</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Check_Button>class Fl_Check_Button</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Button.html#Fl_Button>Fl_Button</A>
|
+----<B>Fl_Check_Button</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Check_Button.H&gt;
</PRE>
</UL>
<H3>Description</H3>
Buttons generate callbacks when they are clicked by the user. You
control exactly when and how by changing the values for <TT>type()</TT>
and <TT>when()</TT>.
<P ALIGN=CENTER><IMG SRC="Fl_Check_Button.gif" ALT="Fl_Check_Button widget"></P>
<P>The <TT>Fl_Check_Button</TT> subclass display the &quot;on&quot; state by
turning on a light, rather than drawing pushed in. The shape of the
&quot;light&quot; is initially set to FL_DIAMOND_DOWN_BOX. The color of the
light when on is controlled with <TT>selection_color()</TT>, which
defaults to FL_RED.</P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Check_Button.Fl_Check_Button>Fl_Check_Button</A></LI>
<LI><A href=#Fl_Check_Button.~Fl_Check_Button>~Fl_Check_Button</A></LI>
</UL>
<H4><A name=Fl_Check_Button.Fl_Check_Button>
Fl_Check_Button::Fl_Check_Button(int x, int y, int w, int h, const char
*label = 0)</A></H4>
Creates a new <TT>Fl_Check_Button</TT> widget using the given
position, size, and label string.
<H4><A name=Fl_Check_Button.~Fl_Check_Button>
Fl_Check_Button::~Fl_Check_Button()</A></H4>
The destructor deletes the check button. </BODY></HTML>
documentation/Fl_Choice.html
-88
View File
@@ -1,88 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Choice</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Choice>class Fl_Choice</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Menu_.html#Fl_Menu_>Fl_Menu_</A>
|
+----<B>Fl_Choice</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Choice.H&gt;
</PRE>
</UL>
<H3>Description</H3>
This is a button that when pushed pops up a menu (or hierarchy of
menus) defined by an array of <A href=Fl_Menu_Item.html#Fl_Menu_Item><TT>
Fl_Menu_Item</TT></A> objects. Motif calls this an OptionButton.
<P>The only difference between this and a <A href=Fl_Menu_Button.html#Fl_Menu_Button>
<TT>Fl_Menu_Button</TT></A> 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 <TT>Fl_Menu_Button</TT> methods are redescribed here in those
terms. </P>
<P>When the user picks an item off the menu the <TT>value()</TT>
is set to that item and then the item's callback is done with
the menu_button as the <TT>Fl_Widget*</TT> argument. If the
item does not have a callback the menu_button's callback is done
instead. </P>
<P>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. </P>
<P>The menu will also pop up in response to shortcuts indicated by
putting a '&amp;' character in the <TT>label()</TT>. See <A href=Fl_Button.html#Fl_Button>
<TT>Fl_Button</TT></A> for a description of this. </P>
<P>Typing the <TT>shortcut()</TT> of any of the items will do exactly
the same as when you pick the item with the mouse. The '&amp;' character in
item names are only looked at when the menu is popped up, however. </P>
<P ALIGN=CENTER><IMG src="choice.gif" ALT="Fl_Choice widget."></P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Choice.Fl_Choice>Fl_Choice</A></LI>
<LI><A href=#Fl_Choice.~Fl_Choice>~Fl_Choice</A></LI>
<LI><A href=#Fl_Choice.clear_changed>clear_changed</A></LI>
<LI><A href=#Fl_Choice.changed>changed</A></LI>
<LI><A href=#Fl_Choice.down_box>down_box</A></LI>
<LI><A href=#Fl_Choice.set_changed>set_changed</A></LI>
<LI><A href=#Fl_Choice.value>value</A></LI>
</UL>
<H4><A name=Fl_Choice.Fl_Choice>Fl_Choice::Fl_Choice(int x, int y, int
w, int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Choice</TT> widget using the given position,
size, and label string. The default boxtype is <TT>FL_UP_BOX</TT>.
<P>The constructor sets <TT>menu()</TT> to <TT>NULL</TT>. See <A href=Fl_Menu_.html#Fl_Menu_>
<TT>Fl_Menu_</TT></A> for the methods to set or change the menu. </P>
<H4><A name=Fl_Choice.~Fl_Choice>virtual Fl_Choice::~Fl_Choice()</A></H4>
The destructor removes the <TT>Fl_Choice</TT> widget and all of its
menu items.
<H4><A name=Fl_Choice.value>int Fl_Choice::value() const
<BR> int Fl_Choice::value(int)
<BR> int Fl_Choice::value(const Fl_Menu *)</A></H4>
The value is the index into the <TT>Fl_Menu</TT> array 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.
Changing it causes a <TT>redraw()</TT>.
<H4><A name=Fl_Choice.changed>int Fl_Widget::changed() const</A></H4>
This value is true if the user picks a different value. <I>It is
turned off by <TT>value()</TT> and just before doing a callback (the
callback can turn it back on if desired).</I>
<H4><A name=Fl_Choice.set_changed>void Fl_Widget::set_changed()</A></H4>
This method sets the <TT>changed()</TT> flag.
<H4><A name=Fl_Choice.clear_changed>void Fl_Widget::clear_changed()</A></H4>
This method clears the <TT>changed()</TT> flag.
<H4><A name=Fl_Choice.down_box>Fl_Boxtype Fl_Choice::down_box() const
<BR> void Fl_Choice::down_box(Fl_Boxtype b)</A></H4>
The first form gets the current down box, which is used when the menu
is popped up. The default down box type is <TT>FL_DOWN_BOX</TT> The
second form sets the current down box type to <TT>b</TT>. </BODY></HTML>
documentation/Fl_Clock.html
-52
View File
@@ -1,52 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Clock</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Clock>class Fl_Clock</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Clock_Output.html#Fl_Clock_Output>Fl_Clock_Output</A>
|
+----<B>Fl_Clock</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Clock.H&gt;
</PRE>
</UL>
<H3>Description</H3>
This widget provides a round analog clock display and is provided for
Forms compatibility. It installs a 1-second timeout callback using <A href="Fl.html#Fl.add_timeout">
<TT>Fl::add_timeout()</TT></A>.
<P ALIGN=CENTER><IMG src="clock.gif" ALT="Fl_Clock widget."> <IMG src="round_clock.gif" ALT="Fl_Clock widget."></P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Clock.Fl_Clock>Fl_Clock</A></LI>
<LI><A href=#Fl_Clock.~Fl_Clock>~Fl_Clock</A></LI>
<LI><A href=#Fl_Clock.hour>hour</A></LI>
<LI><A href=#Fl_Clock.minute>minute</A></LI>
<LI><A href=#Fl_Clock.second>second</A></LI>
<LI><A href=#Fl_Clock.value>value</A></LI>
</UL>
<H4><A name=Fl_Clock.Fl_Clock>Fl_Clock::Fl_Clock(int x, int y, int w,
int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Clock</TT> widget using the given position, size,
and label string. The default boxtype is <TT>FL_NO_BOX</TT>.
<H4><A name=Fl_Clock.~Fl_Clock>virtual Fl_Clock::~Fl_Clock()</A></H4>
The destructor removes the clock.
<H4><A name=Fl_Clock.hour>int Fl_Clock_Output::hour() const</A></H4>
Returns the current hour (0 to 23).
<H4><A name=Fl_Clock.minute>int Fl_Clock_Output::minute() const</A></H4>
Returns the current minute (0 to 59).
<H4><A name=Fl_Clock.second>int Fl_Clock_Output::second() const</A></H4>
Returns the current second (0 to 60, 60 = leap second).
<H4><A name=Fl_Clock.value>ulong Fl_Clock::value(void)</A></H4>
Returns the displayed time in seconds since the UNIX epoch (January 1, 1970).
</BODY>
</HTML>
documentation/Fl_Clock_Output.html
-62
View File
@@ -1,62 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Clock_Output</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Clock_Output>class Fl_Clock_Output</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Widget.html#Fl_Widget>Fl_Widget</A>
|
+----<B>Fl_Clock_Output</B>
|
+----<A href=Fl_Clock.html#Fl_Clock>Fl_Clock</A>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Clock.H&gt;
</PRE>
</UL>
<H3>Description</H3>
<P>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 <TT><A href=Fl_Clock.html#Fl_Clock>Fl_Clock</A></TT>
instead.
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Clock_Output.Fl_Clock_Output>Fl_Clock_Output</A></LI>
<LI><A href=#Fl_Clock_Output.~Fl_Clock_Output>~Fl_Clock_Output</A></LI>
<LI><A href=#Fl_Clock_Output.hour>hour</A></LI>
<LI><A href=#Fl_Clock_Output.minute>minute</A></LI>
<LI><A href=#Fl_Clock_Output.second>second</A></LI>
<LI><A href=#Fl_Clock_Output.value>value</A></LI>
</UL>
<H4><A name=Fl_Clock_Output.Fl_Clock_Output>Fl_Clock_Output::Fl_Clock_Output(int x, int y, int w,
int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Clock_Output</TT> widget using the given position, size,
and label string. The default boxtype is <TT>FL_NO_BOX</TT>.
<H4><A name=Fl_Clock_Output.~Fl_Clock_Output>virtual Fl_Clock_Output::~Fl_Clock_Output()</A></H4>
The destructor removes the clock.
<H4><A name=Fl_Clock_Output.hour>int Fl_Clock_Output::hour() const</A></H4>
Returns the current hour (0 to 23).
<H4><A name=Fl_Clock_Output.minute>int Fl_Clock_Output::minute() const</A></H4>
Returns the current minute (0 to 59).
<H4><A name=Fl_Clock_Output.second>int Fl_Clock_Output::second() const</A></H4>
Returns the current second (0 to 60, 60 = leap second).
<H4><A name=Fl_Clock_Output.value>void Fl_Clock_Output::value(ulong v)
<BR> void Fl_Clock_Output::value(int h, int m, int s)
<BR> ulong Fl_Clock_Output::value(void)</A></H4>
The first two forms of <TT>value</TT> set the displayed time to the
given UNIX time value or specific hours, minutes, and seconds.
<P>The third form of <TT>value</TT> returns the displayed time in
seconds since the UNIX epoch (January 1, 1970). </P>
</BODY>
</HTML>
documentation/Fl_Color_Chooser.html
-91
View File
@@ -1,91 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Color_Chooser</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Color_Chooser>class Fl_Color_Chooser</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Group.html#Fl_Group>Fl_Group</A>
|
+----<B>Fl_Color_Chooser</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Color_Chooser.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Color_Chooser</TT> widget provides a standard RGB color
chooser. You can place any number of these into a panel of your own
design. This 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 <I>same</I> rgb value, such as when saturation
or value is zero.
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Color_Chooser.Fl_Color_Chooser>Fl_Color_Chooser</A></LI>
<LI><A href=#Fl_Color_Chooser.~Fl_Color_Chooser>~Fl_Color_Chooser</A></LI>
<LI><A href=#Fl_Color_Chooser.b>b</A></LI>
<LI><A href=#Fl_Color_Chooser.g>g</A></LI>
<LI><A href=#Fl_Color_Chooser.hsv2rgb>hsv2rgb</A></LI>
<LI><A href=#Fl_Color_Chooser.hsv>hsv</A></LI>
<LI><A href=#Fl_Color_Chooser.hue>hue</A></LI>
<LI><A href=#Fl_Color_Chooser.rgb2hsv>rgb2hsv</A></LI>
<LI><A href=#Fl_Color_Chooser.rgb>rgb</A></LI>
<LI><A href=#Fl_Color_Chooser.r>r</A></LI>
<LI><A href=#Fl_Color_Chooser.saturation>saturation</A></LI>
<LI><A href=#Fl_Color_Chooser.value>value</A></LI>
</UL>
<H4><A name=Fl_Color_Chooser.Fl_Color_Chooser>
Fl_Color_Chooser::Fl_Color_Chooser(int x, int y, int w, int h, const
char *label = 0)</A></H4>
Creates a new <TT>Fl_Color_Chooser</TT> widget using the given
position, size, and label string. The recommended dimensions are
200x95. The color is initialized to black.
<H4><A name=Fl_Color_Chooser.~Fl_Color_Chooser>virtual
Fl_Color_Chooser::~Fl_Color_Chooser()</A></H4>
The destructor removes the color chooser and all of its controls.
<H4><A name=Fl_Color_Chooser.hue>double Fl_Color_Chooser::hue() const</A>
</H4>
Return the current hue. 0 &lt;= hue &lt; 6. Zero is red, one is yellow,
two is green, etc. <I>This value is convienent for the internal
calculations - some other systems consider hue to run from zero to one,
or from 0 to 360.</I>
<H4><A name=Fl_Color_Chooser.saturation>double
Fl_Color_Chooser::saturation() const</A></H4>
Returns the saturation. 0 &lt;= saturation &lt;= 1.
<H4><A name=Fl_Color_Chooser.value>double Fl_Color_Chooser::value()
const</A></H4>
Returns the value/brightness. 0 &lt;= value &lt;= 1.
<H4><A name=Fl_Color_Chooser.r>double Fl_Color_Chooser::r() const</A></H4>
Returns the current red value. 0 &lt;= r &lt;= 1.
<H4><A name=Fl_Color_Chooser.g>double Fl_Color_Chooser::g() const</A></H4>
Returns the current green value. 0 &lt;= g &lt;= 1.
<H4><A name=Fl_Color_Chooser.b>double Fl_Color_Chooser::b() const</A></H4>
Returns the current blue value. 0 &lt;= b &lt;= 1.
<H4><A name=Fl_Color_Chooser.rgb>int Fl_Color_Chooser::rgb(double,
double, double)</A></H4>
Sets the current rgb color values. Does not do the callback. Does
not clamp (but out of range values will produce psychedelic effects in
the hue selector).
<H4><A name=Fl_Color_Chooser.hsv>int
Fl_Color_Chooser::hsv(double,double,double)</A></H4>
Set the hsv values. The passed values are clamped (or for hue,
modulus 6 is used) to get legal values. Does not do the callback.
<H4><A name=Fl_Color_Chooser.hsv2rgb>static void
Fl_Color_Chooser::hsv2rgb(double, double, double, double&amp;, double&amp;,
double&amp;)</A></H4>
This <I>static</I> method converts HSV colors to RGB colorspace.
<H4><A name=Fl_Color_Chooser.rgb2hsv>static void
Fl_Color_Chooser::rgb2hsv(double, double, double, double&amp;, double&amp;,
double&amp;)</A></H4>
This <I>static</I> method converts RGB colors to HSV colorspace. </BODY>
</HTML>
documentation/Fl_Counter.html
-51
View File
@@ -1,51 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Counter</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Counter>class Fl_Counter</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Valuator.html#Fl_Valuator>Fl_Valuator</A>
|
+----<B>Fl_Counter</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Counter.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Counter</TT> widget is provided for forms compatibility.
It controls a single floating point value.
<P ALIGN=CENTER><IMG src="counter.gif" ALT="Fl_Counter widget."></P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Counter.Fl_Counter>Fl_Counter</A></LI>
<LI><A href=#Fl_Counter.~Fl_Counter>~Fl_Counter</A></LI>
<LI><A href=#Fl_Counter.lstep>lstep</A></LI>
<LI><A href=#Fl_Counter.type>type</A></LI>
</UL>
<H4><A name=Fl_Counter.Fl_Counter>Fl_Counter::Fl_Counter(int x, int y,
int w, int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Counter</TT> widget using the given position,
size, and label string. The default type is <TT>FL_NORMAL_COUNTER</TT>.
<H4><A name=Fl_Counter.~Fl_Counter>virtual Fl_Counter::~Fl_Counter()</A></H4>
Destroys the valuator.
<H4><A name=Fl_Counter.lstep>double Fl_Counter::lstep() const</A></H4>
Set the increment for the double-arrow buttons. The default
value is 1.0.
<H4><A name=Fl_Counter.type>type(uchar)</A></H4>
Sets the type of counter:
<UL>
<LI><TT>FL_NORMAL_COUNTER</TT> - Displays a counter with 4 arrow
buttons. </LI>
<LI><TT>FL_SIMPLE_COUNTER</TT> - Displays a counter with only 2 arrow
buttons. </LI>
</UL>
</BODY></HTML>
documentation/Fl_Dial.html
-65
View File
@@ -1,65 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Dial</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Dial>class Fl_Dial</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Valuator.html#Fl_Valuator>Fl_Valuator</A>
|
+----<B>Fl_Dial</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Dial.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Dial</TT> widget provides a circular dial to control a
single floating point value.
<P ALIGN=CENTER><IMG src="dial.gif" ALT="Fl_Dial widget."></P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Dial.Fl_Dial>Fl_Dial</A></LI>
<LI><A href=#Fl_Dial.~Fl_Dial>~Fl_Dial</A></LI>
<LI><A href=#Fl_Dial.angles>angle1</A></LI>
<LI><A href=#Fl_Dial.angles>angle2</A></LI>
<LI><A href=#Fl_Dial.angles>angles</A></LI>
<LI><A href=#Fl_Dial.type>type</A></LI>
</UL>
<H4><A name=Fl_Dial.Fl_Dial>Fl_Dial::Fl_Dial(int x, int y, int w, int
h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Dial</TT> widget using the given position, size,
and label string. The default type is <TT>FL_NORMAL_DIAL</TT>.
<H4><A name=Fl_Dial.~Fl_Dial>virtual Fl_Dial::~Fl_Dial()</A></H4>
Destroys the valuator.
<H4>
<A name=Fl_Dial.angles>
short Fl_Dial::angle1() const;<br>
void Fl_Dial::angle1(short);<br>
short Fl_Dial::angle2() const;<br>
void Fl_Dial::angle2(short);<br>
void Fl_Dial::angles(short a, short b);
</A>
</H4>
Sets 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.
<H4><A name=Fl_Dial.type>type(uchar)</A></H4>
Sets the type of the dial to:
<UL>
<LI><TT>FL_NORMAL_DIAL</TT> - Draws a normal dial with a knob. </LI>
<LI><TT>FL_LINE_DIAL</TT> - Draws a dial with a line. </LI>
<LI><TT>FL_FILL_DIAL</TT> - Draws a dial with a filled arc. </LI>
</UL>
</BODY></HTML>
documentation/Fl_Double_Window.html
-54
View File
@@ -1,54 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Double_Window</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Double_Window>class Fl_Double_Window</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Window.html#Fl_Window>Fl_Window</A>
|
+----<B>Fl_Double_Window</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Double_Window.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Double_Window</TT> class 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 <TT>show()</TT> of <I>any</I> window in your program: </P>
<UL>
<PRE>
Fl::visual(FL_DOUBLE|FL_INDEX)
</PRE>
</UL>
This makes sure you can use Xdbe on servers where double buffering
does not exist for every visual.
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Double_Window.Fl_Double_Window>Fl_Double_Window</A></LI>
<LI><A href=#Fl_Double_Window.~Fl_Double_Window>~Fl_Double_Window</A></LI>
</UL>
<H4><A name=Fl_Double_Window.Fl_Double_Window>
Fl_Double_Window::Fl_Double_Window(int w, int h, const
char *label = 0)<br>
Fl_Double_Window::Fl_Double_Window(int x, int y, int w, int h, const
char *label = 0)</A></H4>
<p>Creates a new <TT>Fl_Double_Window</TT> widget using the given
position, size, and label (title) string.</p>
<H4><A name=Fl_Double_Window.~Fl_Double_Window>virtual
Fl_Double_Window::~Fl_Double_Window()</A></H4>
The destructor <I>also deletes all the children</I>. This allows a
whole tree to be deleted at once, without having to keep a pointer to
all the children in the user code.
</BODY></HTML>
documentation/Fl_End.html
-45
View File
@@ -1,45 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_End</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_End>class Fl_End</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<B>Fl_End</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Group.H&gt;
</PRE>
</UL>
<H3>Description</H3>
This is a dummy class that allows you to end a <A
href=Fl_Group.html#Fl_Group>Fl_Group</A> in a constructor list of a
class:
<UL>
<PRE>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)
{}</PRE>
</UL>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_End.Fl_End>Fl_End</A></LI>
</UL>
<H4><A name=Fl_End.Fl_End>Fl_End::Fl_End</A></H4>
The constructor does <TT>Fl_Group::current()-&gt;end()</TT>. </BODY></HTML>
documentation/Fl_File_Browser.html
-84
View File
@@ -1,84 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_File_Browser</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A NAME="Fl_File_Browser">class Fl_File_Browser</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A HREF="Fl_Browser.html#Fl_Browser">Fl_Browser</A>
|
+----<B>Fl_File_Browser</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_File_Browser.H&gt;
</PRE></UL>
<H3>Description</H3>
<P>The <CODE>Fl_File_Browser</CODE> widget displays a list of filenames,
optionally with file-specific icons.
<H3>Methods</H3>
<UL>
<LI><A HREF="#Fl_File_Browser.Fl_File_Browser">Fl_File_Browser</A>
<LI><A HREF="#Fl_File_Browser.~Fl_File_Browser">~Fl_File_Browser</A>
<LI><A HREF="#Fl_File_Browser.iconsize">iconsize</A>
<LI><A HREF="#Fl_File_Browser.filter">filter</A>
<LI><A HREF="#Fl_File_Browser.filetype">filetype</A>
<LI><A HREF="#Fl_File_Browser.load">load</A>
</UL>
<H4><A NAME="Fl_File_Browser.Fl_File_Browser">Fl_File_Browser(int xx, int yy, int ww, int hh, const char *l = 0)</A></H4>
<P>The constructor creates the <CODE>Fl_File_Browser</CODE> widget at the specified
position and size.
<H4><A NAME="Fl_File_Browser.~Fl_File_Browser">~Fl_File_Browser()</A></H4>
<P>The destructor destroys the widget and frees all memory that has been
allocated.
<H4><A NAME="Fl_File_Browser.iconsize">void iconsize(uchar s)<BR>
uchar iconsize() const</A></H4>
<P>Sets or gets the size of the icons. The default size is 20 pixels.
<H4><A NAME="Fl_File_Browser.filter">void filter(const char *pattern)<BR>
const char *filter() const</A></H4>
<P>Sets or gets the filename filter. The pattern matching uses
the <A
HREF="functions.html#fl_filename_match"><CODE>fl_filename_match()</CODE></A>
function in FLTK.
<H4><A NAME="Fl_File_Browser.filetype">void filetype(int type)<BR>
int filetype() const</A></H4>
<P>Sets or gets the file browser type, <CODE>FILES</CODE> or
<CODE>DIRECTORIES</CODE>. When set to <CODE>FILES</CODE>, both
files and directories are shown. Otherwise only directories are
shown.
<H4><A NAME="Fl_File_Browser.load">int load(const char *directory, Fl_File_Sort_F *sort = fl_numeric_sort)</A></H4>
<P>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 <tt>sort</tt> argument specifies a sort function to be used with
<A HREF="functions.html#fl_filename_list"><tt>fl_filename_list()</tt></A>.
</BODY>
</HTML>
documentation/Fl_File_Chooser.html
-303
View File
@@ -1,303 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_File_Chooser</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A NAME="Fl_File_Chooser">class Fl_File_Chooser</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<B>Fl_File_Chooser</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_File_Chooser.H&gt;
</PRE></UL>
<H3>Description</H3>
<P>The <CODE>Fl_File_Chooser</CODE> widget displays a standard file selection
dialog that supports various selection modes.
<CENTER><IMG SRC="Fl_File_Chooser.jpg" WIDTH="498" HEIGHT="408" ALT="Fl_File_Chooser widget"></CENTER>
<P>The <CODE>Fl_File_Chooser</CODE> class also exports several static values
that may be used to localize or customize the appearance of all file chooser
dialogs:
<CENTER><TABLE BORDER="1">
<TR>
<TH>Member</TH>
<TH>Default value</TH>
</TR>
<TR>
<TD><TT>add_favorites_label</TT></TD>
<TD>"Add to Favorites"</TD>
</TR>
<TR>
<TD><TT>all_files_label</TT></TD>
<TD>"All Files (*)"</TD>
</TR>
<TR>
<TD><TT>custom_filter_label</TT></TD>
<TD>"Custom Filter"</TD>
</TR>
<TR>
<TD><TT>existing_file_label</TT></TD>
<TD>"Please choose an existing file!"</TD>
</TR>
<TR>
<TD><TT>favorites_label</TT></TD>
<TD>"Favorites"</TD>
</TR>
<TR>
<TD><TT>filename_label</TT></TD>
<TD>"Filename:"</TD>
</TR>
<TR>
<TD><TT>filesystems_label</TT></TD>
<TD>"My Computer" (WIN32)<BR>
"File Systems" (all others)</TD>
</TR>
<TR>
<TD><TT>manage_favorites_label</TT></TD>
<TD>"Manage Favorites"</TD>
</TR>
<TR>
<TD><TT>new_directory_label</TT></TD>
<TD>"New Directory?"</TD>
</TR>
<TR>
<TD><TT>new_directory_tooltip</TT></TD>
<TD>"Create a new directory."</TD>
</TR>
<TR>
<TD><TT>preview_label</TT></TD>
<TD>"Preview"</TD>
</TR>
<TR>
<TD><TT>save_label</TT></TD>
<TD>"Save"</TD>
</TR>
<TR>
<TD><TT>show_label</TT></TD>
<TD>"Show:"</TD>
</TR>
<TR>
<TD><TT>sort</TT></TD>
<TD>fl_numericsort</TD>
</TR>
</TABLE></CENTER>
<P>The <TT>sort</TT> member specifies the sort function that is
used when loading the contents of a directory.
<H3>Public Members</H3>
<P>The <CODE>Fl_File_Chooser</CODE> class exports the "new
directory" (<CODE>newButton</CODE>) and "preview"
(<CODE>previewButton</CODE>) widgets so that application
developers can control their appearance and use. For more
complex customization, consider copying the FLTK file chooser
code and changing it accordingly.
<H3>Methods</H3>
<UL>
<LI><A HREF="#Fl_File_Chooser.Fl_File_Chooser">Fl_File_Chooser</A>
<LI><A HREF="#Fl_File_Chooser.~Fl_File_Chooser">~Fl_File_Chooser</A>
<LI><A HREF="#Fl_File_Chooser.add_extra">add_extra</A>
<LI><A HREF="#Fl_File_Chooser.color">color</A>
<LI><A HREF="#Fl_File_Chooser.count">count</A>
<LI><A HREF="#Fl_File_Chooser.directory">directory</A>
<LI><A HREF="#Fl_File_Chooser.filter">filter</A>
<LI><A HREF="#Fl_File_Chooser.filter_value">filter_value</A>
<LI><A HREF="#Fl_File_Chooser.hide">hide</A>
<LI><A HREF="#Fl_File_Chooser.iconsize">iconsize</A>
<LI><A HREF="#Fl_File_Chooser.label">label</A>
<LI><A HREF="#Fl_File_Chooser.ok_label">ok_label</A>
<LI><A HREF="#Fl_File_Chooser.preview">preview</A>
<LI><A HREF="#Fl_File_Chooser.rescan">rescan</A>
<LI><A HREF="#Fl_File_Chooser.show">show</A>
<LI><A HREF="#Fl_File_Chooser.textcolor">textcolor</A>
<LI><A HREF="#Fl_File_Chooser.textfont">textfont</A>
<LI><A HREF="#Fl_File_Chooser.textsize">textsize</A>
<LI><A HREF="#Fl_File_Chooser.type">type</A>
<LI><A HREF="#Fl_File_Chooser.value">value</A>
<LI><A HREF="#Fl_File_Chooser.visible">visible</A>
</UL>
<H4><A NAME="Fl_File_Chooser.Fl_File_Chooser">Fl_File_Chooser(const char *pathname, const char *pattern,
int type, const char *title)</A></H4>
<P>The constructor creates the <CODE>Fl_File_Chooser</CODE> dialog pictured
above. The <CODE>pathname</CODE> argument can be a directory name or a
complete file name (in which case the corresponding file is highlighted
in the list and in the filename input field.)
<P>The <CODE>pattern</CODE> argument can be a <CODE>NULL</CODE>
string or <CODE>"*"</CODE> to list all files, or it can be a
series of descriptions and filter strings separated by tab
characters (<TT>\t</TT>). The format of filters is either
"Description text (patterns)" or just "patterns". A file chooser
that provides filters for HTML and image files might look like:
<UL><PRE>
"HTML Files (*.html)\tImage Files (*.{bmp,gif,jpg,png})"
</PRE></UL>
<P>The file chooser will automatically add the "All Files (*)"
pattern to the end of the string you pass if you do not provide
one. The first filter in the string is the default filter.
<P>See the FLTK documentation on <A
HREF="functions.html#fl_filename_match"><CODE>fl_filename_match()</CODE></A>
for the kinds of pattern strings that are supported.
<P>The <CODE>type</CODE> argument can be one of the following:
<UL>
<LI><CODE>SINGLE</CODE> - allows the user to select a
single, existing file.
<LI><CODE>MULTI</CODE> - allows the user to select one
or more existing files.
<LI><CODE>CREATE</CODE> - allows the user to select a
single, existing file or specify a new filename.
<LI><CODE>DIRECTORY</CODE> - allows the user to select a
single, existing directory.
</UL>
<P>The <CODE>title</CODE> argument is used to set the title bar text for the
<CODE>Fl_File_Chooser</CODE> window.
<H4><A NAME="Fl_File_Chooser.~Fl_File_Chooser">~Fl_File_Chooser()</A></H4>
<P>Destroys the widget and frees all memory used by it.
<H4><A NAME="Fl_File_Chooser.color">void color(Fl_Color c)<BR>
Fl_Color color()</A></H4>
<P>Sets or gets the background color of the <CODE>Fl_File_Browser</CODE> list.
<H4><A NAME="Fl_File_Chooser.count">int count()</A></H4>
<P>Returns the number of selected files.
<H4><A NAME="Fl_File_Chooser.directory">void directory(const char *pathname)<BR>
const char *directory()</A></H4>
<P>Sets or gets the current directory.
<H4><A NAME="Fl_File_Chooser.filter">void filter(const char *pattern)<BR>
const char *filter()</A></H4>
<P>Sets or gets the current filename filter patterns. The filter
patterns use <A
href="functions.html#fl_filename_match"><tt>fl_filename_match()</tt></A>.
Multiple patterns can be used by separating them with tabs, like
"*.jpg\t*.png\t*.gif\t*". In addition, you can provide
human-readable labels with the patterns inside parenthesis, like
"JPEG&nbsp;Files&nbsp;(*.jpg)\tPNG&nbsp;Files&nbsp;(*.png)\tGIF&nbsp;Files&nbsp;(*.gif)\tAll&nbsp;Files&nbsp;(*)".
Use <tt>filter(NULL)</tt> to show all files.</p>
<H4><A NAME="Fl_File_Chooser.filter_value">void filter_value(int f)<BR>
int filter_value()</A></H4>
<P>Sets or gets the current filename filter selection.
<H4><A NAME="Fl_File_Chooser.hide">void hide()</A></H4>
<P>Hides the <CODE>Fl_File_Chooser</CODE> window.
<H4><A NAME="Fl_File_Chooser.iconsize">void iconsize(uchar s)<BR>
uchar iconsize()</A></H4>
<P>Sets or gets the size of the icons in the <CODE>Fl_File_Browser</CODE>. By
default the icon size is set to 1.5 times the <CODE>textsize()</CODE>.
<H4><A NAME="Fl_File_Chooser.label">void label(const char *l)<BR>
const char *label()</A></H4>
<P>Sets or gets the title bar text for the <CODE>Fl_File_Chooser</CODE>.
<H4><A NAME="Fl_File_Chooser.ok_label">void ok_label(const char *l)<BR>
const char *ok_label()</A></H4>
<P>Sets or gets the label for the "ok" button in the
<CODE>Fl_File_Chooser</CODE>.
<H4><A NAME="Fl_File_Chooser.preview">void preview(int e)<BR>
int preview()</A></H4>
<P>The first form enables or disables the preview box in the file chooser.
The second form returns the current state of the preview box.
<H4><A NAME="Fl_File_Chooser.rescan">void rescan()</A></H4>
<P>Reloads the current directory in the <CODE>Fl_File_Browser</CODE>.
<H4><A NAME="Fl_File_Chooser.show">void show()</A></H4>
<P>Shows the <CODE>Fl_File_Chooser</CODE> window.
<H4><A NAME="Fl_File_Chooser.textcolor">void textcolor(Fl_Color c)<BR>
Fl_Color textcolor()</A></H4>
<P>Sets or gets the current <CODE>Fl_File_Browser</CODE> text color.
<H4><A NAME="Fl_File_Chooser.textfont">void textfont(uchar f)<BR>
uchar textfont()</A></H4>
<P>Sets or gets the current <CODE>Fl_File_Browser</CODE> text font.
<H4><A NAME="Fl_File_Chooser.textsize">void textsize(uchar s)<BR>
uchar textsize()</A></H4>
<P>Sets or gets the current <CODE>Fl_File_Browser</CODE> text size.
<H4><A NAME="Fl_File_Chooser.type">void type(int t)<BR>
int type()</A></H4>
<P>Sets or gets the current type of <CODE>Fl_File_Chooser</CODE>.
<H4><A NAME="Fl_File_Chooser.value">const char *value(const char *pathname)<BR>
const char *value(int file)<BR>
const char *value()</A></H4>
<P>Sets or gets the current value of the selected file.
<P>In the second form, <i>file</i> is a <i>1</i>-based index into a list of
file names. The number of selected files is returned by
<CODE>Fl_File_Chooser::count()</CODE>.
<P>This sample code loops through all selected files:
<PRE>
// Get list of filenames user selected from a MULTI chooser
for ( int t=1; t&lt;=chooser-&gt;count(); t++ ) {
const char *filename = chooser-&gt;value(t);
..
}
</PRE>
<H4><A NAME="Fl_File_Chooser.visible">int visible()</A></H4>
<P>Returns 1 if the <CODE>Fl_File_Chooser</CODE> window is visible.
<H4><A NAME="Fl_File_Chooser.add_extra">Fl_Widget* add_extra(Fl_Widget*)</A></H4>
<P>Adds extra widget at the bottom of <CODE>Fl_File_Chooser</CODE> window.
Returns pointer for previous extra widget or <CODE>NULL</CODE> if not set previously.
If argument is <CODE>NULL</CODE> only remove previous extra widget.<BR>
<I>NOTE! <CODE>Fl_File_Chooser</CODE> doesn't delete extra widget in destructor! To prevent memory leakage don't forget
delete unused extra widgets by yuorself.</I>
</BODY>
</HTML>
documentation/Fl_File_Icon.html
-156
View File
@@ -1,156 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_File_Icon</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A NAME="Fl_File_Icon">class Fl_File_Icon</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<B>Fl_File_Icon</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_File_Icon.H&gt;
</PRE></UL>
<H3>Description</H3>
<P>The <CODE>Fl_File_Icon</CODE> class manages icon images that can be
used as labels in other widgets and as icons in the <CODE>FileBrowser</CODE>
widget.
<H3>Methods</H3>
<UL>
<LI><A HREF="#Fl_File_Icon.Fl_File_Icon">Fl_File_Icon</A>
<LI><A HREF="#Fl_File_Icon.~Fl_File_Icon">~Fl_File_Icon</A>
<LI><A HREF="#Fl_File_Icon.add">add</A>
<LI><A HREF="#Fl_File_Icon.add_color">add_color</A>
<LI><A HREF="#Fl_File_Icon.add_vertex">add_vertex</A>
<LI><A HREF="#Fl_File_Icon.clear">clear</A>
<LI><A HREF="#Fl_File_Icon.draw">draw</A>
<LI><A HREF="#Fl_File_Icon.find">find</A>
<LI><A HREF="#Fl_File_Icon.first">first</A>
<LI><A HREF="#Fl_File_Icon.label">label</A>
<LI><A HREF="#Fl_File_Icon.labeltype">labeltype</A>
<LI><A HREF="#Fl_File_Icon.load_fti">load_fti</A>
<LI><A HREF="#Fl_File_Icon.load">load</A>
<LI><A HREF="#Fl_File_Icon.load_system_icons">load_system_icons</A>
<LI><A HREF="#Fl_File_Icon.load_xpm">load_xpm</A>
<LI><A HREF="#Fl_File_Icon.pattern">pattern</A>
<LI><A HREF="#Fl_File_Icon.size">size</A>
<LI><A HREF="#Fl_File_Icon.type">type</A>
<LI><A HREF="#Fl_File_Icon.value">value</A>
</UL>
<H4><A NAME="Fl_File_Icon.Fl_File_Icon">Fl_File_Icon()</A></H4>
<P>The constructor creates a new <CODE>Fl_File_Icon</CODE> with the specified
information.
<H4><A NAME="Fl_File_Icon.~Fl_File_Icon">~Fl_File_Icon()</A></H4>
<P>The destructor destroys the icon and frees all memory that has been
allocated for it.
<H4><A NAME="Fl_File_Icon.add">short *add(short d)</A></H4>
<P>Adds a keyword value to the icon array, returning a pointer to it.
<H4><A NAME="Fl_File_Icon.add_color">short *add_color(short c)</A></H4>
<P>Adds a color value to the icon array, returning a pointer to it.
<H4><A NAME="Fl_File_Icon.add_vertex">short *add_vertex(int x, int y)<BR>
short *add_vertex(float x, float y)</A></H4>
<P>Adds a vertex value to the icon array, returning a pointer to it.
The integer version accepts coordinates from 0 to 10000, while the
floating point version goes from 0.0 to 1.0. The origin (0.0) is in
the lower-lefthand corner of the icon.
<H4><A NAME="Fl_File_Icon.clear">void clear()</A></H4>
<P>Clears all icon data from the icon.
<H4><A NAME="Fl_File_Icon.draw">void draw(int x, int y, int w, int h, Fl_Color ic, int active = 1)</A></H4>
<P>Draws the icon in the indicated area.
<H4><A NAME="Fl_File_Icon.find">static Fl_File_Icon *find(const char *filename, int filetype = ANY);</A></H4>
<P>Finds an icon that matches the given filename and file type.
<H4><A NAME="Fl_File_Icon.first">static Fl_File_Icon *first()</A></H4>
<P>Returns a pointer to the first icon in the list.
<H4><A NAME="Fl_File_Icon.label">void label(Fl_Widget *w)</A></H4>
<P>Applies the icon to the widget, registering the <CODE>Fl_File_Icon</CODE>
label type as needed.
<H4><A NAME="Fl_File_Icon.labeltype">static void labeltype(const Fl_Label *o, int x, int y, int w, int h, Fl_Align a)</A></H4>
<P>The labeltype function for icons.
<H4><A NAME="Fl_File_Icon.load">void load(const char *f)</A></H4>
<P>Loads the specified icon image. The format is deduced from the filename.
<H4><A NAME="Fl_File_Icon.load_fti">void load_fti(const char *fti)</A></H4>
<P>Loads an SGI icon file.
<H4><A NAME="Fl_File_Icon.load_system_icons">static void load_system_icons(void)</A></H4>
<P>Loads all system-defined icons. This call is useful when using the
<CODE>FileChooser</CODE> widget and should be used when the application
starts:
<UL><PRE>
Fl_File_Icon::load_system_icons();
</PRE></UL>
<H4><A NAME="Fl_File_Icon.load_xpm">void load_xpm(const char *xpm)</A></H4>
<P>Loads an XPM icon file.
<H4><A NAME="Fl_File_Icon.pattern">const char *pattern()</A></H4>
<P>Returns the filename matching pattern for the icon.
<H4><A NAME="Fl_File_Icon.size">int size()</A></H4>
<P>Returns the number of words of data used by the icon.
<H4><A NAME="Fl_File_Icon.type">int type()</A></H4>
<P>Returns the filetype associated with the icon, which can be one of the
following:
<UL>
<LI><CODE>Fl_File_Icon::ANY</CODE>, any kind of file.
<LI><CODE>Fl_File_Icon::PLAIN</CODE>, plain files.
<LI><CODE>Fl_File_Icon::FIFO</CODE>, named pipes.
<LI><CODE>Fl_File_Icon::DEVICE</CODE>, character and block devices.
<LI><CODE>Fl_File_Icon::LINK</CODE>, symbolic links.
<LI><CODE>Fl_File_Icon::DIRECTORY</CODE>, directories.
</UL>
<H4><A NAME="Fl_File_Icon.value">short *value()</A></H4>
<P>Returns the data array for the icon.
</BODY>
</HTML>
documentation/Fl_File_Input.html
-60
View File
@@ -1,60 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_File_Input</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_File_Input">class Fl_File_Input</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A href="Fl_Input.html#Fl_Input">Fl_Input</A>
|
+----<B>Fl_File_Input</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_File_Input.H&gt;
</PRE></UL>
<H3>Description</H3>
<P>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.
<CENTER><IMG src="Fl_File_Input.gif" ALT="Fl_File_Input widget."></CENTER>
<H3>Methods</H3>
<UL>
<LI><A href="#Fl_File_Input.Fl_File_Input">Fl_File_Input</A></LI>
<LI><A href="#Fl_File_Input.~Fl_File_Input">~Fl_File_Input</A></LI>
<LI><A href="#Fl_File_Input.down_box">down_box</A></LI>
</UL>
<H4><A name="Fl_File_Input.Fl_File_Input">Fl_File_Input::Fl_File_Input(int x, int y, int
w, int h, const char *label = 0)</A></H4>
<P>Creates a new <TT>Fl_File_Input</TT> widget using the given position,
size, and label string. The default boxtype is <TT>FL_DOWN_BOX</TT>.
<H4><A name="Fl_File_Input.~Fl_File_Input">virtual Fl_File_Input::~Fl_File_Input()</A></H4>
<P>Destroys the widget and any value associated with it.
<H4><A name="Fl_File_Input.down_box">Fl_Boxtype Fl_File_Input::down_box() const
<BR>void Fl_File_Input::down_box(Fl_Boxtype b)</A></H4>
<P>Gets or sets the box type to use for the navigation bar.
</BODY>
</HTML>
documentation/Fl_Float_Input.html
-39
View File
@@ -1,39 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Float_Input</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Float_Input>class Fl_Float_Input</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Input.html#Fl_Input>Fl_Input</A>
|
+----<B>Fl_Float_Input</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Float_Input.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Float_Input</TT> class is a subclass of <TT>Fl_Input</TT>
that only allows the user to type floating point numbers (sign,
digits, decimal point, more digits, 'E' or 'e', sign, digits).
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Float_Input.Fl_Float_Input>Fl_Float_Input</A></LI>
<LI><A href=#Fl_Float_Input.~Fl_Float_Input>~Fl_Float_Input</A></LI>
</UL>
<H4><A name=Fl_Float_Input.Fl_Float_Input>
Fl_Float_Input::Fl_Float_Input(int x, int y, int w, int h, const char
*label = 0)</A></H4>
Creates a new <TT>Fl_Float_Input</TT> widget using the given position,
size, and label string. The default boxtype is <TT>FL_DOWN_BOX</TT>.
<H4><A name=Fl_Float_Input.~Fl_Float_Input>virtual
Fl_Float_Input::~Fl_Float_Input()</A></H4>
Destroys the widget and any value associated with it. </BODY></HTML>
documentation/Fl_Free.html
-78
View File
@@ -1,78 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Free</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Free>class Fl_Free</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Widget.html#Fl_Widget>Fl_Widget</A>
|
+----<B>Fl_Free</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Free.H&gt;
</PRE>
</UL>
<H3>Description</H3>
Emulation of the Forms &quot;free&quot; 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.
<P>There are five types of free, which determine when the handle
function is called: </P>
<UL>
<PRE>
#define FL_NORMAL_FREE 1
#define FL_SLEEPING_FREE 2
#define FL_INPUT_FREE 3
#define FL_CONTINUOUS_FREE 4
#define FL_ALL_FREE 5
</PRE>
</UL>
<P>An FL_INPUT_FREE accepts FL_FOCUS events. A FL_CONTINUOUS_FREE sets
a timeout callback 100 times a second and provides a FL_STEP event,
this has obvious detrimental effects on machine performance.
FL_ALL_FREE does both. FL_SLEEPING_FREE are deactivated. </P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Free.Fl_Free>Fl_Free</A></LI>
<LI><A href=#Fl_Free.~Fl_Free>~Fl_Free</A></LI>
</UL>
<H4><A name=Fl_Free.Fl_Free>Fl_Free(uchar type, int, int, int, int,
const char*l, FL_HANDLEPTR hdl)</A></H4>
The constructor takes both the <TT>type</TT> and the <TT>handle</TT>
function. The handle function should be declared as follows:
<UL>
<PRE>
int
handle_function(Fl_Widget *w,
int event,
float event_x,
float event_y,
char key)
</PRE>
</UL>
This function is called from the the <TT>handle()</TT> method in
response to most events, and is called by the <TT>draw()</TT> method.
The <TT>event</TT> argument contains the event type:
<UL>
<PRE>
// old event names for compatability:
#define FL_MOUSE FL_DRAG
#define FL_DRAW 0
#define FL_STEP 9
#define FL_FREEMEM 12
#define FL_FREEZE FL_UNMAP
#define FL_THAW FL_MAP
</PRE>
</UL>
<H4><A name=Fl_Free.~Fl_Free>virtual Fl_Free::~Fl_Free()</A></H4>
The destructor will call the handle function with the event <TT>
FL_FREE_MEM</TT>. </BODY></HTML>
documentation/Fl_GIF_Image.html
-58
View File
@@ -1,58 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_GIF_Image</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_GIF_Image">class Fl_GIF_Image</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A href="Fl_Pixmap.html">Fl_Pixmap</A>
|
+----<B>Fl_GIF_Image</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_GIF_Image.H&gt;
</PRE></UL>
<H3>Additional Libraries</H3>
<UL><PRE>
-lfltk_images / fltkimages.lib
</PRE></UL>
<H3>Description</H3>
<P>The <TT>Fl_GIF_Image</TT> class supports loading, caching,
and drawing of Compuserve GIF<SUP>SM</SUP> images. The class
loads the first image and supports transparency.</P>
<H3>Methods</H3>
<UL>
<LI><A href="#Fl_GIF_Image.Fl_GIF_Image">Fl_GIF_Image</A></LI>
<LI><A href="#Fl_GIF_Image.~Fl_GIF_Image">~Fl_GIF_Image</A></LI>
</UL>
<H4><A name="Fl_GIF_Image.Fl_GIF_Image">Fl_GIF_Image::Fl_GIF_Image(const char *filename);</A></H4>
<P>The constructor loads the named GIF image.</P>
<H4><A name="Fl_GIF_Image.~Fl_GIF_Image">Fl_GIF_Image::~Fl_GIF_Image();</A></H4>
<P>The destructor free all memory and server resources that are used by
the image.</P>
</BODY>
</HTML>
documentation/Fl_Gl_Window.html
-244
View File
@@ -1,244 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Gl_Window</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Gl_Window>class Fl_Gl_Window</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A href=Fl_Window.html#Fl_Window>Fl_Window</A>
|
+----<B>Fl_Gl_Window</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_Gl_Window.H&gt;
</PRE></UL>
<H3>Additional Libraries</H3>
<UL><PRE>
-lfltk_gl / fltkgl.lib
</PRE></UL>
<H3>Description</H3>
The <TT>Fl_Gl_Window</TT> widget sets things up so OpenGL works, and
also keeps an OpenGL &quot;context&quot; 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 <TT>draw()</TT>
returns.
<P>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. </P>
<P>Please note that the FLTK drawing and clipping functions
will not work inside an <tt>Fl_Gl_Window</tt>. All drawing
should be done using OpenGL calls exclusively.
Even though <tt>Fl_Gl_Window</tt> is derived from <tt>Fl_Group</tt>,
it is not useful to add other FLTK Widgets as children,
unless those Widgets are modified to draw using OpenGL calls.</P>
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Gl_Window methods.">
<TR><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Gl_Window.Fl_Gl_Window>Fl_Gl_Window</A></LI>
<LI><A href=#Fl_Gl_Window.~Fl_Gl_Window>~Fl_Gl_Window</A></LI>
<LI><A href=#Fl_Gl_Window.can_do>can_do</A></LI>
<LI><A href=#Fl_Gl_Window.can_do_overlay>can_do_overlay</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Gl_Window.context>context</A></LI>
<LI><A href=#Fl_Gl_Window.context_valid>context_valid</A></LI>
<LI><A href=#Fl_Gl_Window.draw>draw</A></LI>
<LI><A href=#Fl_Gl_Window.draw_overlay>draw_overlay</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Gl_Window.hide>hide</A></LI>
<LI><A href=#Fl_Gl_Window.invalidate>invalidate</A></LI>
<LI><A href=#Fl_Gl_Window.make_current>make_current</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Gl_Window.make_overlay_current>make_overlay_current</A></LI>
<LI><A href=#Fl_Gl_Window.mode>mode</A></LI>
<LI><A href=#Fl_Gl_Window.ortho>ortho</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Gl_Window.redraw_overlay>redraw_overlay</A></LI>
<LI><A href=#Fl_Gl_Window.swap_buffers>swap_buffers</A></LI>
<LI><A href=#Fl_Gl_Window.valid>valid</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name=Fl_Gl_Window.Fl_Gl_Window>Fl_Gl_Window::Fl_Gl_Window(int x,
int y, int w, int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Gl_Window</TT> widget using the given position,
size, and label string. The default boxtype is <TT>FL_NO_BOX</TT>. The
default mode is <TT>FL_RGB|FL_DOUBLE|FL_DEPTH</TT>.
<H4><A name=Fl_Gl_Window.~Fl_Gl_Window>virtual
Fl_Gl_Window::~Fl_Gl_Window()</A></H4>
The destructor removes the widget and destroys the OpenGL context
associated with it.
<H4><A name=Fl_Gl_Window.draw>virtual void Fl_Gl_Window::draw(void)</A></H4>
<TT>Fl_Gl_Window::draw()</TT> is a pure virtual method. You must
subclass <TT>Fl_Gl_Window</TT> and provide an implementation for <TT>
draw()</TT>. You may also provide an implementation of draw_overlay()
if you want to draw into the overlay planes. You can avoid
reinitializing the viewport and lights and other things by checking <TT>
valid()</TT> at the start of <TT>draw()</TT> and only doing the
initialization if it is false.
<P>The <TT>draw()</TT> method can <I>only</I> use OpenGL calls. Do not
attempt to call X, any of the functions in &lt;FL/fl_draw.H&gt;, or <TT>glX</TT>
directly. Do not call <TT>gl_start()</TT> or <TT>gl_finish()</TT>. </P>
<P>If double-buffering is enabled in the window, the back and front
buffers are swapped after this function is completed. </P>
<H4><A name=Fl_Gl_Window.mode>const int Fl_Gl_Window::mode() const
<BR> int Fl_Gl_Window::mode(int m)</A></H4>
Set or change the OpenGL capabilites of the window. The value can be
any of the following OR'd together:
<UL>
<LI><TT>FL_RGB</TT> - RGB color (not indexed) </LI>
<LI><TT>FL_RGB8</TT> - RGB color with at least 8 bits of each color </LI>
<LI><TT>FL_INDEX</TT> - Indexed mode </LI>
<LI><TT>FL_SINGLE</TT> - not double buffered </LI>
<LI><TT>FL_DOUBLE</TT> - double buffered </LI>
<LI><TT>FL_ACCUM</TT> - accumulation buffer </LI>
<LI><TT>FL_ALPHA</TT> - alpha channel in color </LI>
<LI><TT>FL_DEPTH</TT> - depth buffer </LI>
<LI><TT>FL_STENCIL</TT> - stencil buffer </LI>
<LI><TT>FL_MULTISAMPLE</TT> - multisample antialiasing </LI>
</UL>
<TT>FL_RGB</TT> and <TT>FL_SINGLE</TT> have a value of zero, so they
are &quot;on&quot; unless you give <TT>FL_INDEX</TT> or <TT>FL_DOUBLE</TT>.
<P>If the desired combination cannot be done, FLTK will try turning off <TT>
FL_MULTISAMPLE</TT>. If this also fails the <TT>show()</TT> will call <TT>
Fl::error()</TT> and not show the window. </P>
<P>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 <TT>xid()</TT>
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! </P>
<H4><A name=Fl_Gl_Window.can_do>static int Fl_Gl_Window::can_do(int)
<BR> int Fl_Gl_Window::can_do() const</A></H4>
Returns non-zero if the hardware supports the given or current OpenGL
mode.
<h4><a name=Fl_Gl_Window.context>void* Fl_Gl_Window::context() const;
<br>void Fl_Gl_Window::context(void*, int destroy_flag = false);</a></h4>
Return or set a pointer to the GLContext that this window is
using. This is a system-dependent structure, but it is portable to copy
the context from one window to another. You can also set it to NULL,
which will force FLTK to recreate the context the next time <a
href=#Fl_Gl_Window.make_current><tt>make_current()</tt></a> is called, this is
useful for getting around bugs in OpenGL implementations.
<p>If <i>destroy_flag</i> is true the context will be destroyed by
fltk when the window is destroyed, or when the <a
href=#Fl_Gl_Window.mode><tt>mode()</tt></a> is changed, or the next time
<tt>context(x)</tt> is called.
<H4><A name=Fl_Gl_Window.valid>char Fl_Gl_Window::valid() const
<BR> void Fl_Gl_Window::valid(char i)</A></H4>
<TT>Fl_Gl_Window::valid()</TT> is turned off when FLTK creates a new
context for this window or when the window resizes, and is turned on <I>
after</I> <TT>draw()</TT> is called. You can use this inside your <TT>
draw()</TT> method to avoid unneccessarily initializing the OpenGL
context. Just do this:
<UL><PRE>
void mywindow::draw() {
if (!valid()) {
glViewport(0,0,w(),h());
glFrustum(...);
...other initialization...
}
if (!context_valid()) {
...load textures, etc. ...
}
... draw your geometry here ...
}
</PRE></UL>
You can turn <TT>valid()</TT> on by calling <TT>valid(1)</TT>. You
should only do this after fixing the transformation inside a <TT>draw()</TT>
or after <TT>make_current()</TT>. This is done automatically after <TT>
draw()</TT> returns.
<H4><A name=Fl_Gl_Window.invalidate>void Fl_Gl_Window::invalidate()</A></H4>
The <TT>invalidate()</TT> method turns off <TT>valid()</TT> and is
equivalent to calling <TT>value(0)</TT>.
<H4><A name=Fl_Gl_Window.context_valid>char Fl_Gl_Window::context_valid() const
<BR> void Fl_Gl_Window::context_valid(char i)</A></H4>
<TT>Fl_Gl_Window::context_valid()</TT> will only be set if the
OpenGL context is created or recreated. It differs from
<TT>Fl_Gl_Window::valid()</TT> which is also set whenever the context
changes size.
<H4><A name=Fl_Gl_Window.ortho>void Fl_Gl_Window::ortho()</A></H4>
Set the projection so 0,0 is in the lower left of the window and each
pixel is 1 unit wide/tall. If you are drawing 2D images, your <TT>
draw()</TT> method may want to call this if <TT>valid()</TT> is false.
<H4><A name=Fl_Gl_Window.make_current>void Fl_Gl_Window::make_current()</A>
</H4>
The <TT>make_current()</TT> method selects the OpenGL context for the
widget. It is called automatically prior to the <TT>draw()</TT> method
being called and can also be used to implement feedback and/or
selection within the <TT>handle()</TT> method.
<H4><A name=Fl_Gl_Window.make_overlay_current>void
Fl_Gl_Window::make_overlay_current()</A></H4>
The <TT>make_overlay_current()</TT> method selects the OpenGL context
for the widget's overlay. It is called automatically prior to the <TT>
draw_overlay()</TT> method being called and can also be used to
implement feedback and/or selection within the <TT>handle()</TT>
method.
<H4><A name=Fl_Gl_Window.swap_buffers>void Fl_Gl_Window::swap_buffers()</A>
</H4>
The <TT>swap_buffers()</TT> method swaps the back and front buffers.
It is called automatically after the <TT>draw()</TT> method is called.
<H4><A name=Fl_Gl_Window.hide>void Fl_Gl_Window::hide()</A></H4>
Hides the window and destroys the OpenGL context.
<H4><A name=Fl_Gl_Window.can_do_overlay>int
Fl_Gl_Window::can_do_overlay()</A></H4>
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.
<H4><A name=Fl_Gl_Window.redraw_overlay>void
Fl_Gl_Window::redraw_overlay()</A></H4>
This method causes <TT>draw_overlay</TT> 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 <TT>show()</TT> your window.
<H4><A name=Fl_Gl_Window.draw_overlay>virtual void
Fl_Gl_Window::draw_overlay()</A></H4>
You must implement this virtual function if you want to draw into the
overlay. The overlay is cleared before this is called. You should
draw anything that is not clear using OpenGL. You must use <TT>
gl_color(i)</TT> to choose colors (it allocates them from the colormap
using system-specific calls), and remember that you are in an indexed
OpenGL mode and drawing anything other than flat-shaded will probably
not work.
<P>Both this function and <TT>Fl_Gl_Window::draw()</TT> should check <TT>
Fl_Gl_Window::valid()</TT> and set the same transformation. If you
don't your code may not work on other systems. Depending on the OS,
and on whether overlays are real or simulated, the OpenGL context may
be the same or different between the overlay and main window. </P>
</BODY>
</HTML>
documentation/Fl_Group.html
-190
View File
@@ -1,190 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Group</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Group>class Fl_Group</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Widget.html#Fl_Widget>Fl_Widget</A>
|
+----<B>Fl_Group</B>
|
+----<A href=Fl_Browser_.html#Fl_Browser_>Fl_Browser_</A>, <A href=Fl_Color_Chooser.html#Fl_Color_Chooser>Fl_Color_Chooser</A>, <A href=Fl_Help_View.html#Fl_Help_View>Fl_Help_View</A>, <A href=Fl_Input_Choice.html#Fl_Input_Choice>Fl_Input_Choice</A>, <A href=Fl_Pack.html#Fl_Pack>Fl_Pack</A>,
<A href=Fl_Scroll.html#Fl_Scroll>Fl_Scroll</A>, <A href=Fl_Tabs.html#Fl_Tabs>Fl_Tabs</A>, <A href=Fl_Spinner.html#Fl_Spinner>Fl_Spinner</A>, <A href=Fl_Tabs.html#Fl_Tabs>Fl_Tabs</A>, <A href=Fl_Text_Display.html#Fl_Text_Display>Fl_Text_Display</A>, <A href=Fl_Tile.html#Fl_Tile>Fl_Tile</A>,
<A href=Fl_Window.html#Fl_Window>Fl_Window</A>, <A href=Fl_Wizard.html#Fl_Wizard>Fl_Wizard</A>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Group.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Group</TT> class is the FLTK container widget. It maintains
an array of child widgets. These children can themselves be any widget
including <TT>Fl_Group</TT>. The most important subclass of <TT>Fl_Group</TT>
is <A href=Fl_Window.html#Fl_Window><TT>Fl_Window</TT></A>, however
groups can also be used to control radio buttons or to enforce resize
behavior.
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Group methods.">
<TR><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Group.Fl_Group>Fl_Group</A></LI>
<LI><A href=#Fl_Group.~Fl_Group>~Fl_Group</A></LI>
<LI><A href=#Fl_Group.add>add</A></LI>
<LI><A href=#Fl_Group.add_resizable>add_resizable</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Group.array>array</A></LI>
<LI><A href=#Fl_Group.begin>begin</A></LI>
<LI><A href=#Fl_Group.child>child</A></LI>
<LI><A href=#Fl_Group.children>children</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href="#Fl_Group.clear">clear</A></LI>
<LI><A href="#Fl_Group.clip_children">clip_children</A></LI>
<LI><A href=#Fl_Group.current>current</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Group.end>end</A></LI>
<LI><A href=#Fl_Group.find>find</A></LI>
<LI><A href=#Fl_Group.init_sizes>init_sizes</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Group.insert>insert</A></LI>
<LI><A href=#Fl_Group.remove>remove</A></LI>
<LI><A href=#Fl_Group.resizable>resizable</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name=Fl_Group.Fl_Group>Fl_Group::Fl_Group(int x, int y, int w,
int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Group</TT> widget using the given position, size,
and label string. The default boxtype is <TT>FL_NO_BOX</TT>.
<H4><A name=Fl_Group.~Fl_Group>virtual Fl_Group::~Fl_Group()</A></H4>
The destructor <I>also deletes all the children</I>. This allows a
whole tree to be deleted at once, without having to keep a pointer to
all the children in the user code. A kludge has been done so the <TT>
Fl_Group</TT> and all of it's children can be automatic (local)
variables, but you must declare the <TT>Fl_Group</TT> <I>first</I>, so
that it is destroyed last.
<H4><A name=Fl_Group.add>void Fl_Group::add(Fl_Widget &amp;w)
<BR> void Fl_Group::add(Fl_Widget *w)</A></H4>
The widget is removed from it's current group (if any) and then added
to the end of this group.
<H4><A name="Fl_Group.clear">void Fl_Group::clear()</A></H4>
<p>The <tt>clear()</tt> method deletes all child widgets from
memory recursively.</p>
<p>This method differs from the <a
href='#Fl_Group.remove'><tt>remove()</tt></a> method in that it
affects all child widgets and deletes them from memory.</p>
<H4><A name="Fl_Group.clip_children">void Fl_Group::clip_children(int c);<br>
int Fl_Group::clip_children();</A></H4>
The first method controls whether the group widget clips the drawing of
child widgets to its bounding box.
<p>The second method returns the current clipping mode.
<p>The default is to not clip (0) the drawing of child widgets.
<H4><A name="Fl_Group.init_sizes">void Fl_Group::init_sizes()</A></H4>
The <TT>Fl_Group</TT> widget keeps track of the original widget sizes and
positions when resizing occurs so that if you resize a window back to its
original size the widgets will be in the correct places. If you rearrange
the widgets in your group, call this method to register the new arrangement
with the <TT>Fl_Group</TT> that contains them.
<H4><A name=Fl_Group.insert>void Fl_Group::insert(Fl_Widget &amp;w, int n)</A></H4>
The widget is removed from it's current group (if any) and then
inserted into this group. It is put at index <TT>n</TT> (or at the end
if <tt>n &gt;= children()</tt>. This can also be used to rearrange
the widgets inside a group.
<H4>void Fl_Group::insert(Fl_Widget &amp;w, Fl_Widget* beforethis)</H4>
This does <tt>insert(w, find(beforethis))</tt>. This will append the
widget if <tt>beforethis</tt> is not in the group.
<H4><A name=Fl_Group.remove>void Fl_Group::remove(Fl_Widget &amp;w)</A></H4>
<p>Removes a widget from the group but does not delete it. This
method does nothing if the widget is not a child of the
group.</p>
<p>This method differs from the <a
href='#Fl_Group.clear'><tt>clear()</tt></a> method in that it
only affects a single widget and does not delete it from
memory.</p>
<H4><A name=Fl_Group.current>static Fl_Group *Fl_Group::current()
<BR> static void Fl_Group::current(Fl_Group *w)</A></H4>
<TT>current()</TT> returns the currently active group. The Fl_Widget
constructor automatically does <tt>current()-&gt;add(widget)</tt> if this is not null.
To prevent new widgets from being added to a group, call <TT>Fl_Group::current(0)</TT>.
<H4><A name=Fl_Group.begin>void Fl_Group::begin()</A></H4>
<TT>begin()</TT> sets the current group so you can build the widget
tree by just constructing the widgets. <TT>begin()</TT> is
automatically called by the constructor for Fl_Group (and thus for
Fl_Window as well). <TT>begin()</TT> <i>is exactly the same as</i> <TT>current(this)</TT>.
<P><I>Don't forget to <TT>end()</TT> the group or window!</I></P>
<H4><A name=Fl_Group.end>void Fl_Group::end()</A></H4>
<TT>end()</TT> <i>is exactly the same as</i> <TT>current(this-&gt;parent())</TT>. Any new widgets
added to the widget tree will be added to the parent of the group.
<H4><A name=Fl_Group.array>const Fl_Widget **Fl_Group::array() const</A></H4>
Returns a pointer to the array of children. <I>This pointer is only
valid until the next time a child is added or removed.</I>
<H4><A name=Fl_Group.child>Fl_Widget *Fl_Group::child(int n) const</A></H4>
Returns <tt>array()[n]</tt>. <i>No range checking is done!</i>
<H4><A name=Fl_Group.children>int Fl_Group::children() const</A></H4>
Returns how many child widgets the group has.
<H4><A name=Fl_Group.find>int Fl_Group::find(const Fl_Widget *w) const
<BR> int Fl_Group::find(const Fl_Widget &amp;w) const</A></H4>
Searches the child array for the widget and returns the index. Returns <A
href=#Fl_Group.children><TT>children()</TT></A> if the widget is <TT>
NULL</TT> or not found.
<H4><A name=Fl_Group.resizable>void Fl_Group::resizable(Fl_Widget *box)
<BR> void Fl_Group::resizable(Fl_Widget &amp;box)
<BR> Fl_Widget *Fl_Group::resizable() const</A></H4>
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.
<P>In these examples the gray area is the resizable:
<BR></P>
<P align=center><IMG align=TOP SRC="resizebox1.gif" ALT="Resizeable groups">&nbsp;&nbsp;
<IMG align=TOP SRC="resizebox2.gif" ALT="Resizeable groups"></P>
<P>The resizable may be set to the group itself (this is the default
value for an <TT>Fl_Group</TT>, although <TT>NULL</TT> is the default
for <TT>Fl_Window</TT> and <TT>Fl_Pack</TT>), in which case all the
contents are resized.
If the resizable is <TT>NULL</TT> then all widgets remain a fixed size
and distance from the top-left corner. </P>
<P>It is possible to achieve any type of resize behavior by using an
invisible <TT>Fl_Box</TT> as the resizable and/or by using a hierarchy
of child <TT>Fl_Group</TT>'s. </P>
<H4><A name=Fl_Group.add_resizable>Fl_Group
&amp;Fl_Group::add_resizable(Fl_Widget &amp;box)</A></H4>
Adds a widget to the group and makes it the resizable widget.
</BODY></HTML>
documentation/Fl_Help_Dialog.html
-120
View File
@@ -1,120 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Help_Dialog</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A NAME="Fl_Help_Dialog">class Fl_Help_Dialog</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<B>Fl_Help_Dialog</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include "Fl_Help_Dialog.h"
</PRE></UL>
<H3>Additional Libraries</H3>
<UL><PRE>
-lfltk_images / fltkimages.lib
</PRE></UL>
<H3>Description</H3>
<P>The <CODE>Fl_Help_Dialog</CODE> widget displays a standard help dialog window
using the <CODE>Fl_Help_View</CODE> widget.
<CENTER><IMG SRC="Fl_Help_Dialog.gif" WIDTH="80%" ALT="Fl_Help_Dialog Window"></CENTER>
<H3>Methods</H3>
<UL>
<LI><A HREF="#Fl_Help_Dialog.Fl_Help_Dialog">Fl_Help_Dialog</A>
<LI><A HREF="#Fl_Help_Dialog.~Fl_Help_Dialog">~Fl_Help_Dialog</A>
<LI><A HREF="#Fl_Help_Dialog.xywh">h</A>
<LI><A HREF="#Fl_Help_Dialog.hide">hide</A>
<LI><A HREF="#Fl_Help_Dialog.load">load</A>
<LI><A HREF="#Fl_Help_Dialog.position">position</A>
<LI><A HREF="#Fl_Help_Dialog.resize">resize</A>
<LI><A HREF="#Fl_Help_Dialog.show">show</A>
<LI><A HREF="#Fl_Help_Dialog.textsize">textsize</A>
<LI><A HREF="#Fl_Help_Dialog.topline">topline</A>
<LI><A HREF="#Fl_Help_Dialog.value">value</A>
<LI><A HREF="#Fl_Help_Dialog.visible">visible</A>
<LI><A HREF="#Fl_Help_Dialog.xywh">w</A>
<LI><A HREF="#Fl_Help_Dialog.xywh">x</A>
<LI><A HREF="#Fl_Help_Dialog.xywh">y</A>
</UL>
<H4><A NAME="Fl_Help_Dialog.Fl_Help_Dialog">Fl_Help_Dialog()</A></H4>
<P>The constructor creates the dialog pictured above.
<H4><A NAME="Fl_Help_Dialog.~Fl_Help_Dialog">~Fl_Help_Dialog()</A></H4>
<P>The destructor destroys the widget and frees all memory that has been
allocated for the current file.
<H4><A NAME="Fl_Help_Dialog.hide">void hide()</A></H4>
<P>Hides the <code>Fl_Help_Dialog</code> window.
<H4><A NAME="Fl_Help_Dialog.load">void load(const char *f)</A></H4>
<P>Loads the specified HTML file into the <CODE>Fl_Help_View</CODE> widget.
The filename can also contain a target name ("filename.html#target").
<H4><A NAME="Fl_Help_Dialog.position">void position(int x, int y)</A></H4>
<P>Set the screen position of the dialog.
<H4><A NAME="Fl_Help_Dialog.resize">void resize(int xx, int yy, int ww, int hh)</A></H4>
<P>Change the position and size of the dialog.
<H4><A NAME="Fl_Help_Dialog.show">void show()</A></H4>
<P>Shows the <code>Fl_Help_Dialog</code> window.
<H4><A NAME="Fl_Help_Dialog.textsize">void textsize(uchar s)<BR>
uchar textsize()</A></H4>
<P>Sets or gets the default text size for the help view.
<H4><A NAME="Fl_Help_Dialog.topline">void topline(const char *n)<BR>
void topline(int n)</A></H4>
<P>Sets the top line in the <CODE>Fl_Help_View</CODE> widget to the named or
numbered line.
<H4><A NAME="Fl_Help_Dialog.value">void value(const char *v)<BR>
const char *value() const</A></H4>
<P>The first form sets the current buffer to the string provided and
reformats the text. It also clears the history of the "back" and
"forward" buttons. The second form returns the current buffer contents.
<H4><A NAME="Fl_Help_Dialog.visible">int visible()</A></H4>
<P>Returns 1 if the <code>Fl_Help_Dialog</code> window is visible.
<H4><A NAME="Fl_Help_Dialog.xywh">int x()<BR>
int y()<BR>
int w()<BR>
int h()<BR>
</A></H4>
<P>Returns the position and size of the help dialog.
</BODY>
</HTML>
documentation/Fl_Help_View.html
-141
View File
@@ -1,141 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Help_View</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_Help_View">class Fl_Help_View</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
Fl_Group
|
+----<B>Fl_Help_View</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include "Fl_Help_View.h"
</PRE></UL>
<H3>Description</H3>
<P>The <CODE>Fl_Help_View</CODE> 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.
<H3>Methods</H3>
<UL>
<LI><A HREF="#Fl_Help_View.Fl_Help_View">Fl_Help_View</A>
<LI><A HREF="#Fl_Help_View.~Fl_Help_View">~Fl_Help_View</A>
<LI><A HREF="#Fl_Help_View.directory">directory</A>
<LI><A HREF="#Fl_Help_View.filename">filename</A>
<LI><A HREF="#Fl_Help_View.link">link</A>
<LI><A HREF="#Fl_Help_View.load">load</A>
<LI><A HREF="#Fl_Help_View.size">size</A>
<LI><A HREF="#Fl_Help_View.textcolor">textcolor</A>
<LI><A HREF="#Fl_Help_View.textfont">textfont</A>
<LI><A HREF="#Fl_Help_View.textsize">textsize</A>
<LI><A HREF="#Fl_Help_View.title">title</A>
<LI><A HREF="#Fl_Help_View.topline">topline</A>
<LI><A HREF="#Fl_Help_View.value">value</A>
</UL>
<H4><A NAME="Fl_Help_View.Fl_Help_View">Fl_Help_View(int xx, int yy, int ww, int hh, const char *l = 0)</A></H4>
<P>The constructor creates the <CODE>Fl_Help_View</CODE> widget at the specified
position and size.
<H4><A NAME="Fl_Help_View.~Fl_Help_View">~Fl_Help_View()</A></H4>
<P>The destructor destroys the widget and frees all memory that has been
allocated for the current file.
<H4><A NAME="Fl_Help_View.directory">const char *directory() const</A></H4>
<P>This method returns the current directory (base) path for the file
in the buffer.
<H4><A NAME="Fl_Help_View.filename">const char *filename() const</A></H4>
<P>This method returns the current filename for the text in the buffer.
<H4><A NAME="Fl_Help_View.link">void link(Fl_Help_Func *fn)</A></H4>
<P>This method assigns a callback function to use when a link is
followed or a file is loaded (via
<CODE>Fl_Help_View::load()</CODE>) that requires a different
file or path. The callback function receives a pointer to the
<CODE>Fl_Help_View</CODE> 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 <TT>NULL</TT>:</P>
<UL><PRE>
const char *fn(Fl_Widget *w, const char *uri);
</PRE></UL>
<P>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 <TT>NULL</TT>, the value of
the <TT>Fl_Help_View</TT> widget will remain unchanged.</P>
<P>If the link callback cannot handle the URI scheme, it should
return the <TT>uri</TT> value unchanged or set the <A
HREF="#Fl_Help_View.value"><TT>value()</TT></A> of the widget
before returning <TT>NULL</TT>.</P>
<H4><A NAME="Fl_Help_View.load">int load(const char *f)</A></H4>
<P>This method loads the specified file or URL.
<H4><A NAME="Fl_Help_View.size">int size() const</A></H4>
<P>This method returns the length of the buffer text in pixels.
<H4><A NAME="Fl_Help_View.textcolor">void textcolor(Fl_Color c)<BR>
Fl_Color textcolor() const</A></H4>
<P>The first form sets the default text color. The second returns
the current default text color.
<H4><A NAME="Fl_Help_View.textfont">void textfont(uchar f)<BR>
uchar textfont() const</A></H4>
<P>The first form sets the default text font. The second returns
the current default text font.
<H4><A NAME="Fl_Help_View.textsize">void textsize(uchar s)<BR>
uchar textsize() const</A></H4>
<P>The first form sets the default text size. The second returns
the current default text size.
<H4><A NAME="Fl_Help_View.title">const char *title()</A></H4>
<P>This method returns the current document title, or NULL if there
is no title.
<H4><A NAME="Fl_Help_View.topline">void topline(const char *n)<BR>
void topline(int)<BR>
int topline() const</A></H4>
<P>The first two forms scroll the text to the indicated position, either
with a named destination or by pixel line.
<P>The second form returns the current top line in pixels.
<H4><A NAME="Fl_Help_View.value">void value(const char *v)<BR>
const char *value() const</A></H4>
<P>The first form sets the current buffer to the string provided and
reformats the text. The second form returns the current buffer contents.
</BODY>
</HTML>
documentation/Fl_Hold_Browser.html
-59
View File
@@ -1,59 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Hold_Browser</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Hold_Browser>class Fl_Hold_Browser</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Browser.html#Fl_Browser>Fl_Browser</A>
|
+----<B>Fl_Hold_Browser</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Hold_Browser.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Hold_Browser</TT> class is a subclass of <TT>Fl_Browser</TT>
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 <TT>when()</TT>.
<P>See <A href=Fl_Browser.html#Fl_Browser><TT>Fl_Browser</TT></A> for
methods to add and remove lines from the browser. </P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Hold_Browser.Fl_Hold_Browser>Fl_Hold_Browser</A></LI>
<LI><A href=#Fl_Hold_Browser.~Fl_Hold_Browser>~Fl_Hold_Browser</A></LI>
<LI><A href=#Fl_Hold_Browser.deselect>deselect</A></LI>
<LI><A href=#Fl_Hold_Browser.select>select</A></LI>
<LI><A href=#Fl_Hold_Browser.value>value</A></LI>
</UL>
<H4><A name=Fl_Hold_Browser.Fl_Hold_Browser>
Fl_Hold_Browser::Fl_Hold_Browser(int x, int y, int w, int h, const char
*label = 0)</A></H4>
Creates a new <TT>Fl_Hold_Browser</TT> widget using the given
position, size, and label string. The default boxtype is <TT>FL_DOWN_BOX</TT>
.
<H4><A name=Fl_Hold_Browser.~Fl_Hold_Browser>virtual
Fl_Hold_Browser::~Fl_Hold_Browser()</A></H4>
The destructor <I>also deletes all the items in the list</I>.
<H4><A name=Fl_Hold_Browser.deselect>int Fl_Browser::deselect()</A></H4>
<P>Deselects any selected item.
<H4><A name=Fl_Hold_Browser.select>int Fl_Browser::select(int,int=1)
<BR> int Fl_Browser::selected(int) const</A></H4>
You can use these for compatibility with <A href=Fl_Multi_Browser.html#Fl_Multi_Browser>
<TT>Fl_Multi_Browser</TT></A>. If you turn on the selection of more
than one line the results are unpredictable.
<H4><A name=Fl_Hold_Browser.value>int Fl_Browser::value() const
<BR> void Fl_Browser::value(int)</A></H4>
Set or get which line is selected. This returns zero if no line is
selected, so be aware that this can happen in a callback. </BODY></HTML>
documentation/Fl_Image.html
-212
View File
@@ -1,212 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Image</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_Image">class Fl_Image</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<B>Fl_Image</B>
|
+----<A href="Fl_Bitmap.html">Fl_Bitmap</A>,
<A href="Fl_Pixmap.html">Fl_Pixmap</A>,
<A href="Fl_RGB_Image.html">Fl_RGB_Image</A>,
<A href="Fl_Shared_Image.html">Fl_Shared_Image</A>,
<A href="Fl_Tiled_Image.html">Fl_Tiled_Image</A>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_Image.H&gt;
</PRE></UL>
<H3>Description</H3>
<P><TT>Fl_Image</TT> 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.</P>
<P>Since the <TT>Fl_Image</TT> class does not support image
drawing by itself, calling the <TT>draw()</TT> method results in
a box with an X in it being drawn instead.</P>
<H3>Methods</H3>
<UL>
<LI><A href="#Fl_Image.Fl_Image">Fl_Image</A></LI>
<LI><A href="#Fl_Image.~Fl_Image">~Fl_Image</A></LI>
<LI><A href="#Fl_Image.color_average">color_average</A></LI>
<LI><A href="#Fl_Image.copy">copy</A></LI>
<LI><A href="#Fl_Image.count">count</A></LI>
<LI><A href="#Fl_Image.d">d</A></LI>
<LI><A href="#Fl_Image.data">data</A></LI>
<LI><A href="#Fl_Image.desaturate">desaturate</A></LI>
<LI><A href="#Fl_Image.draw">draw</A></LI>
<LI><A href="#Fl_Image.draw_empty">draw_empty</A></LI>
<LI><A href="#Fl_Image.h">h</A></LI>
<LI><A href="#Fl_Image.inactive">inactive</A></LI>
<LI><A href="#Fl_Image.label">label</A></LI>
<LI><A href="#Fl_Image.ld">ld</A></LI>
<LI><A href="#Fl_Image.uncache">uncache</A></LI>
<LI><A href="#Fl_Image.w">w</A></LI>
</UL>
<H4><A NAME="Fl_Image.Fl_Image">Fl_Image(int W, int H, int D);</A></H4>
<P>The constructor creates an empty image with the specified
width, height, and depth. The width and height are in pixels.
The depth is 0 for bitmaps, 1 for pixmap (colormap) images, and
1 to 4 for color images.</P>
<H4><A NAME="Fl_Image.~Fl_Image">virtual ~Fl_Image();</A></H4>
<P>The destructor is a virtual method that frees all memory used
by the image.</P>
<H4><A NAME="Fl_Image.color_average">virtual void color_average(Fl_Color c, float i);</A></H4>
<P>The <TT>color_average()</TT> method averages the colors in
the image with the FLTK color value <TT>c</TT>. The <TT>i</TT>
argument specifies the amount of the original image to combine
with the color, so a value of 1.0 results in no color blend, and
a value of 0.0 results in a constant image of the specified
color. <I>The original image data is not altered by this
method.</I></P>
<H4><A NAME="Fl_Image.copy">virtual Fl_Image *copy(int W, int H);<BR>
copy();</A></H4>
<P>The <TT>copy()</TT> 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 <tt>Fl_Shared_Image</tt>, released) when you are done
with it.</P>
<H4><A NAME="Fl_Image.count">int count();</A></H4>
<P>The <TT>count()</TT> 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.</P>
<H4><A NAME="Fl_Image.d">int d();<BR>
protected void d(int D);</A></H4>
<P>The first form of the <TT>d()</TT> method returns the current
image depth. The return value will be 0 for bitmaps, 1 for
pixmaps, and 1 to 4 for color images.</P>
<P>The second form is a protected method that sets the current
image depth.</P>
<H4><A NAME="Fl_Image.data">const char * const *data();<BR>
protected void data(const char * const *data, int count);</A></H4>
<P>The first form of the <TT>data()</TT> method returns a
pointer to the current image data array. Use the
<TT>count()</TT> method to find the size of the data array.</P>
<P>The second form is a protected method that sets the current
array pointer and count of pointers in the array.</P>
<H4><A NAME="Fl_Image.desaturate">virtual void desaturate()</A></H4>
<P>The <TT>desaturate()</TT> method converts an image to
grayscale. If the image contains an alpha channel (depth = 4),
the alpha channel is preserved. <I>This method does not alter
the original image data.</I></P>
<H4><A NAME="Fl_Image.draw">void draw(int X, int Y);<BR>
virtual void draw(int X, int Y, int W, int H, int cx, int cy);</A></H4>
<P>The <TT>draw()</TT> methods draw the image. The first form
specifies the upper-lefthand corner of the image. The second
form specifies a bounding box for the image, with the origin
(upper-lefthand corner) of the image offset by the <TT>cx</TT>
and <TT>cy</TT> arguments.</P>
<H4><A NAME="Fl_Image.draw_empty">protected void draw_empty(int X, int Y);</A></H4>
<P>The protected method <TT>draw_empty()</TT> draws a box with
an X in it. It can be used to draw any image that lacks image
data.</P>
<H4><A NAME="Fl_Image.h">int h();<BR>
protected void h(int H);</A></H4>
<P>The first form of the <TT>h()</TT> method returns the current
image height in pixels.</P>
<P>The second form is a protected method that sets the current
image height.</P>
<H4><A NAME="Fl_Image.inactive">void inactive();</A></H4>
<P>The <TT>inactive()</TT> method calls
<TT>color_average(FL_BACKGROUND_COLOR, 0.33f)</TT> to produce
an image that appears grayed out. <I>This method does not
alter the original image data.</I></P>
<H4><A NAME="Fl_Image.label">virtual void label(Fl_Widget *w);
virtual void label(Fl_Menu_Item *m);</A></H4>
<P>The <TT>label()</TT> methods are an obsolete way to set the
image attribute of a widget or menu item. Use the
<TT>image()</TT> or <TT>deimage()</TT> methods of the
<TT>Fl_Widget</TT> and <TT>Fl_Menu_Item</TT> classes
instead.</P>
<H4><A NAME="Fl_Image.ld">int ld();<BR>
protected void ld(int LD);</A></H4>
<P>The first form of the <TT>ld()</TT> method returns the current
line data size in bytes. Line data is extra data that is included
after each line of color image data and is normally not present.</P>
<P>The second form is a protected method that sets the current
line data size in bytes.</P>
<H4><A NAME="Fl_Image.uncache">void uncache();</A></H4>
<P>If the image has been cached for display, delete the cache
data. This allows you to change the data used for the image and
then redraw it without recreating an image object.
<H4><A NAME="Fl_Image.w">int w();<BR>
protected void w(int W);</A></H4>
<P>The first form of the <TT>w()</TT> method returns the current
image width in pixels.</P>
<P>The second form is a protected method that sets the current
image width.</P>
</BODY>
</HTML>
documentation/Fl_Input.html
-383
View File
@@ -1,383 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Input</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Input>class Fl_Input</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A href=Fl_Input_.html#Fl_Input_>Fl_Input_</A>
|
+----<B>Fl_Input</B>
|
+----<A href="Fl_File_Input.html">Fl_File_Input</A>, <A href=Fl_Float_Input.html#Fl_Float_Input>Fl_Float_Input</A>,
<A href=Fl_Int_Input.html#Fl_Int_Input>Fl_Int_Input</A>, <A href=Fl_Multiline_Input.html#Fl_Multiline_Input>Fl_Multiline_Input</A>,
<A href=Fl_Output.html#Fl_Output>Fl_Output</A>, <A href=Fl_Secret_Input.html#Fl_Secret_Input>Fl_Secret_Input</A>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_Input.H&gt;
</PRE></UL>
<H3>Description</H3>
<P>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 (even 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-8859-1 character set.</P>
<CENTER><TABLE border=1 WIDTH=90% summary="Fl_Input keyboard and mouse bindings.">
<TR><TD WIDTH=200><B>Mouse button 1</B></TD><TD>Moves the cursor to
this point. Drag selects characters. Double click selects words.
Triple click selects all text. Shift+click extends the selection.
When you select text it is automatically copied to the clipboard.
</TD></TR>
<TR><TD><B>Mouse button 2</B></TD><TD>Insert the clipboard at
the point clicked. You can also select a region and replace it with the
clipboard by selecting the region with mouse button 2.
</TD></TR>
<TR><TD><B>Mouse button 3</B></TD><TD>Currently acts like button 1.</TD></TR>
<TR><TD><B>Backspace</B></TD><TD>Deletes one character to the left, or
deletes the selected region.</TD></TR>
<TR><TD><B>Enter</B></TD><TD>May cause the callback, see when().</TD></TR>
<TR><TD><B>^A or Home</B></TD><TD>Go to start of line.</TD></TR>
<TR><TD><B>^B or Left</B></TD><TD>Move left</TD></TR>
<TR><TD><B>^C</B></TD><TD>Copy the selection to the clipboard</TD></TR>
<TR><TD><B>^D or Delete</B></TD><TD>Deletes one character to the right
or deletes the selected region.</TD></TR>
<TR><TD><B>^E or End</B></TD><TD>Go to the end of line.</TD></TR>
<TR><TD><B>^F or Right</B></TD><TD>Move right</TD></TR>
<TR><TD><B>^K</B></TD><TD>Delete to the end of line (next \n character)
or deletes a single \n character. These deletions are all concatenated
into the clipboard.</TD></TR>
<TR><TD><B>^N or Down</B></TD><TD>Move down (for Fl_Multiline_Input
only, otherwise it moves to the next input field).</TD></TR>
<TR><TD><B>^P or Up</B></TD><TD>Move up (for Fl_Multiline_Input only,
otherwise it moves to the previous input field).</TD></TR>
<TR><TD><B>^U</B></TD><TD>Delete everything.</TD></TR>
<TR><TD><B>^V or ^Y</B></TD><TD>Paste the clipboard</TD></TR>
<TR><TD><B>^X or ^W</B></TD><TD>Copy the region to the clipboard and
delete it.</TD></TR>
<TR><TD><B>^Z or ^_</B></TD><TD>Undo. This is a single-level undo
mechanism, but all adjacent deletions and insertions are concatenated
into a single &quot;undo&quot;. Often this will undo a lot more than you
expected.</TD></TR>
<TR><TD><B>Shift+move</B></TD><TD>Move the cursor but also extend the
selection.</TD></TR>
<TR><TD><B>RightCtrl or
<BR>Compose</B></TD><TD><a name=compose>Start</A>
a <A href="events.html#compose">compose-character</A>
sequence. The next one or two keys typed define the character to
insert (see table that follows.)
<p>For instance, to type "á" type [compose][a]['] or [compose]['][a].
<P>The character "nbsp" (non-breaking space) is typed by using
[compose][space].
<P>The single-character sequences may be followed by a space if
necessary to remove ambiguity. For instance, if you really want to
type "ª~" rather than "ã" you must type [compose][a][space][~].
<p>The same key may be used to "quote" control characters into the
text. If you need a <tt>^Q</tt> character you can get one by typing
[compose][Control+Q].
<p>X may have a key on the keyboard
defined as <tt>XK_Multi_key</tt>. If so this key may be used as well
as the right-hand control key. You can set this up with the program
<tt>xmodmap</tt>.
<p>If your keyboard is set to support a foreign language you should
also be able to type "dead key" prefix characters. On X you will
actually be able to see what dead key you typed, and if you then move
the cursor without completing the sequence the accent will remain
inserted.</TD></TR>
</TABLE></CENTER>
<!-- NEW PAGE -->
<center><table border=1 summary="Character Composition Table">
<caption align="top">Character Composition Table</caption>
<tr>
<th>Keys</th><th>Char</th>
<th>Keys</th><th>Char</th>
<th>Keys</th><th>Char</th>
<th>Keys</th><th>Char</th>
<th>Keys</th><th>Char</th>
<th>Keys</th><th>Char</th>
</tr><tr>
<td align=center><TT>sp</TT></td><td align=center><small>nbsp</small></td>
<td align=center><TT>*</tt></td><td align=center>°</td>
<td align=center><TT>` A</tt></td><td align=center>À</td>
<td align=center><TT>D -</tt></td><td align=center>Ð</td>
<td align=center><TT>` a</tt></td><td align=center>à</td>
<td align=center><TT>d -</tt></td><td align=center>ð</td>
</tr><tr>
<td align=center><TT>!</tt></td><td align=center>¡</td>
<td align=center><TT>+ -</tt></td><td align=center>±</td>
<td align=center><TT>' A</tt></td><td align=center>Á</td>
<td align=center><TT>~ N</tt></td><td align=center>Ñ</td>
<td align=center><TT>' a</tt></td><td align=center>á</td>
<td align=center><TT>~ n</tt></td><td align=center>ñ</td>
</tr><tr>
<td align=center><TT>%</tt></td><td align=center>¢</td>
<td align=center><TT>2</tt></td><td align=center>²</td>
<td align=center><TT>A ^</tt></td><td align=center>Â</td>
<td align=center><TT>` O</tt></td><td align=center>Ò</td>
<td align=center><TT>^ a</tt></td><td align=center>â</td>
<td align=center><TT>` o</tt></td><td align=center>ò</td>
</tr><tr>
<td align=center><TT>#</tt></td><td align=center>£</td>
<td align=center><TT>3</tt></td><td align=center>³</td>
<td align=center><TT>~ A</tt></td><td align=center>Ã</td>
<td align=center><TT>' O</tt></td><td align=center>Ó</td>
<td align=center><TT>~ a</tt></td><td align=center>ã</td>
<td align=center><TT>' o</tt></td><td align=center>ó</td>
</tr><tr>
<td align=center><TT>$</tt></td><td align=center>¤</td>
<td align=center><TT>'</tt></td><td align=center>´</td>
<td align=center><TT>: A</tt></td><td align=center>Ä</td>
<td align=center><TT>^ O</tt></td><td align=center>Ô</td>
<td align=center><TT>: a</tt></td><td align=center>ä</td>
<td align=center><TT>^ o</tt></td><td align=center>ô</td>
</tr><tr>
<td align=center><TT>y =</tt></td><td align=center>¥</td>
<td align=center><TT>u</tt></td><td align=center>µ</td>
<td align=center><TT>* A</tt></td><td align=center>Å</td>
<td align=center><TT>~ O</tt></td><td align=center>Õ</td>
<td align=center><TT>* a</tt></td><td align=center>å</td>
<td align=center><TT>~ o</tt></td><td align=center>õ</td>
</tr><tr>
<td align=center><TT>|</tt></td><td align=center>¦</td>
<td align=center><TT>p</tt></td><td align=center></td>
<td align=center><TT>A E</tt></td><td align=center>Æ</td>
<td align=center><TT>: O</tt></td><td align=center>Ö</td>
<td align=center><TT>a e</tt></td><td align=center>æ</td>
<td align=center><TT>: o</tt></td><td align=center>ö</td>
</tr><tr>
<td align=center><TT>&amp;</tt></td><td align=center>§</td>
<td align=center><TT>.</tt></td><td align=center>·</td>
<td align=center><TT>, C</tt></td><td align=center>Ç</td>
<td align=center><TT>x</tt></td><td align=center>×</td>
<td align=center><TT>, c</tt></td><td align=center>ç</td>
<td align=center><TT>- :</tt></td><td align=center>÷</td>
</tr><tr>
<td align=center><TT>:</tt></td><td align=center>¨</td>
<td align=center><TT>,</tt></td><td align=center>¸</td>
<td align=center><TT>E `</tt></td><td align=center>È</td>
<td align=center><TT>O /</tt></td><td align=center>Ø</td>
<td align=center><TT>` e</tt></td><td align=center>è</td>
<td align=center><TT>o /</tt></td><td align=center>ø</td>
</tr><tr>
<td align=center><TT>c</tt></td><td align=center>©</td>
<td align=center><TT>1</tt></td><td align=center>¹</td>
<td align=center><TT>' E</tt></td><td align=center>É</td>
<td align=center><TT>` U</tt></td><td align=center>Ù</td>
<td align=center><TT>' e</tt></td><td align=center>é</td>
<td align=center><TT>` u</tt></td><td align=center>ù</td>
</tr><tr>
<td align=center><TT>a</tt></td><td align=center>ª</td>
<td align=center><TT>o</tt></td><td align=center>º</td>
<td align=center><TT>^ E</tt></td><td align=center>Ê</td>
<td align=center><TT>' U</tt></td><td align=center>Ú</td>
<td align=center><TT>^ e</tt></td><td align=center>ê</td>
<td align=center><TT>' u</tt></td><td align=center>ú</td>
</tr><tr>
<td align=center><TT>&lt; &lt;</tt></td><td align=center>«</td>
<td align=center><TT>&gt; &gt;</tt></td><td align=center>»</td>
<td align=center><TT>: E</tt></td><td align=center>Ë</td>
<td align=center><TT>^ U</tt></td><td align=center>Û</td>
<td align=center><TT>: e</tt></td><td align=center>ë</td>
<td align=center><TT>^ u</tt></td><td align=center>û</td>
</tr><tr>
<td align=center><TT>~</tt></td><td align=center>¬</td>
<td align=center><TT>1 4</tt></td><td align=center>¼</td>
<td align=center><TT>` I</tt></td><td align=center>Ì</td>
<td align=center><TT>: U</tt></td><td align=center>Ü</td>
<td align=center><TT>` i</tt></td><td align=center>ì</td>
<td align=center><TT>: u</tt></td><td align=center>ü</td>
</tr><tr>
<td align=center><TT>-</tt></td><td align=center>­</td>
<td align=center><TT>1 2</tt></td><td align=center>½</td>
<td align=center><TT>' I</tt></td><td align=center>Í</td>
<td align=center><TT>' Y</tt></td><td align=center>Ý</td>
<td align=center><TT>' i</tt></td><td align=center>í</td>
<td align=center><TT>' y</tt></td><td align=center>ý</td>
</tr><tr>
<td align=center><TT>r</tt></td><td align=center>®</td>
<td align=center><TT>3 4</tt></td><td align=center>¾</td>
<td align=center><TT>^ I</tt></td><td align=center>Î</td>
<td align=center><TT>T H</tt></td><td align=center>Þ</td>
<td align=center><TT>^ i</tt></td><td align=center>î</td>
<td align=center><TT>t h</tt></td><td align=center>þ</td>
</tr><tr>
<td align=center><TT>_</tt></td><td align=center>¯</td>
<td align=center><TT>?</tt></td><td align=center>¿</td>
<td align=center><TT>: I</tt></td><td align=center>Ï</td>
<td align=center><TT>s s</tt></td><td align=center>ß</td>
<td align=center><TT>: i</tt></td><td align=center>ï</td>
<td align=center><TT>: y</tt></td><td align=center>ÿ</td>
</tr>
</table></center>
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Input methods.">
<TR><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Input.Fl_Input>Fl_Input</A></LI>
<LI><A href=#Fl_Input.~Fl_Input>~Fl_Input</A></LI>
<LI><A href=#Fl_Input.cursor_color>cursor_color</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Input.index>index</A></LI>
<LI><A href=#Fl_Input.size>size</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Input.static_value>static_value</A></LI>
<LI><A href=#Fl_Input.textcolor>textcolor</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Input.textfont>textfont</A></LI>
<LI><A href=#Fl_Input.textsize>textsize</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Input.value>value</A></LI>
<LI><A href=#Fl_Input.when>when</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name="Fl_Input.Fl_Input">Fl_Input::Fl_Input(int x, int y, int w,
int h, const char *label = 0)</A></H4>
<P>Creates a new <TT>Fl_Input</TT> widget using the given position, size,
and label string. The default boxtype is <TT>FL_DOWN_BOX</TT>.
<H4><A name="Fl_Input.~Fl_Input">virtual Fl_Input::~Fl_Input()</A></H4>
<P>Destroys the widget and any value associated with it.
<H4><A name="Fl_Input.value">const char *Fl_Input::value() const
<BR>int Fl_Input::value(const char*)
<BR>int Fl_Input::value(const char*, int)</A></H4>
<P>The first form returns the current value, which is a pointer
to the internal buffer and is valid only until the next event is
handled.
<P>The second two forms change the text and set the mark and the
point to the end of it. The string is copied to the internal
buffer. Passing <TT>NULL</TT> is the same as &quot;&quot;.
This returns non-zero if the new value is different than the
current one. You can use the second version to directly set the
length if you know it already or want to put nul's in the
text.</P>
<H4><A name="Fl_Input.static_value">int Fl_Input::static_value(const
char*)
<BR>int Fl_Input::static_value(const char*, int)</A></H4>
<P>Change the text and set the mark and the point to the end of
it. The string is <I>not</I> copied. If the user edits the
string it is copied to the internal buffer then. This can save a
great deal of time and memory if your program is rapidly
changing the values of text fields, but this will only work if
the passed string remains unchanged until either the
<TT>Fl_Input</TT> is destroyed or <TT>value()</TT> is called
again.
<H4><A name="Fl_Input.size">int Fl_Input::size() const</A></H4>
<P>Returns the number of characters in <TT>value()</TT>. This
may be greater than <TT>strlen(value())</TT> if there are nul
characters in it.
<H4><A name="Fl_Input.index">char Fl_Input::index(int) const</A></H4>
<P>Same as <TT>value()[n]</TT>, but may be faster in plausible
implementations. No bounds checking is done.
<H4><A name="Fl_Input.when">Fl_When Fl_Widget::when() const
<BR>void Fl_Widget::when(Fl_When)</A></H4>
<P>Controls when callbacks are done. The following values are useful,
the default value is <TT>FL_WHEN_RELEASE</TT>:
<UL>
<LI><TT>0</TT>: The callback is not done, but
<TT>changed()</TT> is turned on.</LI>
<LI><TT>FL_WHEN_CHANGED</TT>: The callback is done each
time the text is changed by the user.</LI>
<LI><TT>FL_WHEN_RELEASE</TT>: The callback will be done
when this widget loses the focus, including when the
window is unmapped. This is a useful value for text
fields in a panel where doing the callback on every
change is wasteful. However the callback will also
happen if the mouse is moved out of the window, which
means it should not do anything visible (like pop up an
error message). You might do better setting this to
zero, and scanning all the items for <TT>changed()</TT>
when the OK button on a panel is pressed.</LI>
<LI><TT>FL_WHEN_ENTER_KEY</TT>: If the user types the
Enter key, the entire text is selected, and the callback
is done if the text has changed. Normally the Enter key
will navigate to the next field (or insert a newline for
a <TT>Fl_Mulitline_Input</TT>), this changes the
behavior.</LI>
<LI><TT>FL_WHEN_ENTER_KEY|FL_WHEN_NOT_CHANGED</TT>: The
Enter key will do the callback even if the text has not
changed. Useful for command fields.</LI>
</UL>
<H4><A name="Fl_Input.textcolor">Fl_Color Fl_Input::textcolor() const
<BR>void Fl_Input::textcolor(Fl_Color)</A></H4>
<P>Gets or sets the color of the text in the input field.
<H4><A name="Fl_Input.textfont">Fl_Font Fl_Input::textfont() const
<BR>void Fl_Input::textfont(Fl_Font)</A></H4>
<P>Gets or sets the font of the text in the input field.
<H4><A name="Fl_Input.textsize">uchar Fl_Input::textsize() const
<BR>void Fl_Input::textsize(uchar)</A></H4>
<P>Gets or sets the size of the text in the input field.
<H4><A name="Fl_Input.cursor_color">Fl_Color Fl_Input::cursor_color()
const
<BR>void Fl_Input::cursor_color(Fl_Color)</A></H4>
<P>Get or set the color of the cursor. This is black by default.
</BODY>
</HTML>
documentation/Fl_Input_.html
-283
View File
@@ -1,283 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Input_</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_Input_">class Fl_Input_</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A href=Fl_Widget.html#Fl_Widget>Fl_Widget</A>
|
+----<B>Fl_Input_</B>
|
+----<A href=Fl_Input.html#Fl_Input>Fl_Input</A>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_Input_.H&gt;
</PRE></UL>
<H3>Description</H3>
<P>This is a virtual base class below <A
href="Fl_Input.html#Fl_Input"><TT>Fl_Input</TT></A>. It has all
the same interfaces, but lacks the <TT>handle()</TT> and
<TT>draw()</TT> method. You may want to subclass it if you are
one of those people who likes to change how the editing keys
work.
<P>This can act like any of the subclasses of Fl_Input, by
setting <TT>type()</TT> to one of the following values:</P>
<UL><PRE>
#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)
</PRE></UL>
<H3>Methods</H3>
<CENTER>
<TABLE width="90%" summary="Fl_Input_ methods.">
<TR><TD align="left" valign="top">
<UL>
<LI><A href="#Fl_Input_.Fl_Input_">Fl_Input_</A></LI>
<LI><A href="#Fl_Input_.~Fl_Input_">~Fl_Input_</A></LI>
<LI><A href="#Fl_Input_.copy">copy</A></LI>
<LI><A href="#Fl_Input_.copy_cuts">copy_cuts</A></LI>
</UL>
</TD><TD align="left" valign="top">
<UL>
<LI><A href="#Fl_Input_.cut">cut</A></LI>
<LI><A href="#Fl_Input_.drawtext">drawtext</A></LI>
<LI><A href="#Fl_Input_.handletext">handletext</A></LI>
<LI><A href="#Fl_Input_.input_type">input_type</A></LI>
</UL>
</TD><TD align="left" valign="top">
<UL>
<LI><A href="#Fl_Input_.insert">insert</A></LI>
<LI><A href="#Fl_Input_.lineboundary">lineboundary</A></LI>
<LI><A href="#Fl_Input_.mark">mark</A></LI>
<LI><A href="#Fl_Input_.maybe_do_callback">maybe_do_callback</A></LI>
</UL>
</TD><TD align="left" valign="top">
<UL>
<LI><A href="#Fl_Input_.maximum_size">maximum_size</A></LI>
<LI><A href="#Fl_Input_.position">position</A></LI>
<LI><A href="#Fl_Input_.readonly">readonly</A></LI>
<LI><A href="#Fl_Input_.replace">replace</A></LI>
</UL>
</TD><TD align="left" valign="top">
<UL>
<LI><A href="#Fl_Input_.shortcut">shortcut</A></LI>
<LI><A href="#Fl_Input_.undo">undo</A></LI>
<LI><A href="#Fl_Input_.up_down_position">up_down_position</A></LI>
<LI><A href="#Fl_Input_.wrap">wrap</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name="Fl_Input_.Fl_Input_">Fl_Input_::Fl_Input_(int x, int y, int
w, int h, const char *label = 0)</A></H4>
<P>Creates a new <TT>Fl_Input_</TT> widget using the given
position, size, and label string. The default boxtype is
<TT>FL_DOWN_BOX</TT>.
<H4><A name="Fl_Input_.~Fl_Input_">virtual Fl_Input_::~Fl_Input_()</A></H4>
<P>The destructor removes the widget and any value associated with it.
<H4><A name="Fl_Input_.wordboundary">int Fl_Input_::wordboundary(int i)
const</A></H4>
<P>Returns true if position <TT>i</TT> is at the start or end of a word.
<H4><A name="Fl_Input_.lineboundary">int Fl_Input_::lineboundary(int i)
const</A></H4>
<P>Returns true if position <TT>i</TT> is at the start or end of a line.
<H4><A name="Fl_Input_.drawtext">void Fl_Input_::drawtext(int,int,int,int)</A></H4>
<P>Draw the text in the passed bounding box. If <TT>damage()
&amp; FL_DAMAGE_ALL</TT> is true, this assumes the area has
already been erased to <TT>color()</TT>. Otherwise it does
minimal update and erases the area itself.
<H4><A name="Fl_Input_.handletext">int Fl_Input_::handletext(int
e,int,int,int,int)</A></H4>
<P>Default handler for all event types. Your <TT>handle()</TT>
method should call this for all events that it does not handle
completely. You must pass it the same bounding box as you do
when calling <TT>drawtext()</TT> from your <tt>draw()</tt>
method. Handles <TT>FL_PUSH</TT>, <TT>FL_DRAG</TT>,
<TT>FL_RELEASE</TT> to select text, handles <TT>FL_FOCUS</TT>
and <TT>FL_UNFOCUS</TT> to show and hide the cursor.
<H4><A name="Fl_Input_.up_down_position">int
Fl_Input_::up_down_position(int i, int keepmark=0)</A></H4>
<P>Do the correct thing for arrow keys. Sets the position (and
mark if <I>keepmark</I> is zero) to somewhere in the same line
as <I>i</I>, such that pressing the arrows repeatedly will cause
the point to move up and down.
<H4><A name="Fl_Input_.maybe_do_callback">void
Fl_Input_::maybe_do_callback()</A></H4>
<P>Does the callback if <TT>changed()</TT> is true or if
<TT>when() &amp; FL_WHEN_NOT_CHANGED</TT> is non-zero. You
should call this at any point you think you should generate a
callback.
<H4><A name="Fl_Input_.maximum_size">void Fl_Input_::maximum_size(int m)<BR>
int Fl_Input_::maximum_size() const</A></H4>
<P>Sets or returns the maximum length of the input field.
<H4><A name="Fl_Input_.position">int Fl_Input_::position() const
<BR>int Fl_Input_::position(int new_position, int new_mark)
<BR>int Fl_Input_::position(int new_position_and_new_mark)</A></H4>
<P>The input widget maintains two pointers into the string. The
&quot;position&quot; is where the cursor is. The
&quot;mark&quot; is the other end of the selected text. If they
are equal then there is no selection. Changing this does not
affect the clipboard (use <TT>copy()</TT> to do that).
<P>Changing these values causes a <TT>redraw()</TT>. The new
values are bounds checked. The return value is non-zero if the
new position is different than the old one. <TT>position(n)</TT>
is the same as <TT>position(n,n)</TT>. <TT>mark(n)</TT> is the
same as <TT>position(position(),n)</TT>.</P>
<H4><A name="Fl_Input_.mark">int Fl_Input_::mark() const
<BR> int Fl_Input_::mark(int new_mark)</A></H4>
<P>Gets or sets the current selection mark. <TT>mark(n)</TT> is
the same as <TT>position(position(),n)</TT>.
<H4><A name="Fl_Input_.replace">int Fl_Input_::replace(int a, int b,
const char *insert, int length=0)</A></H4>
<P>This call does all editing of the text. It deletes the region
between <TT>a</TT> and <TT>b</TT> (either one may be less or
equal to the other), and then inserts the string <TT>insert</TT>
at that point and leaves the <TT>mark()</TT> and
<TT>position()</TT> after the insertion. Does the callback if
<TT>when() &amp; FL_WHEN_CHANGED</TT> and there is a change.
<P>Set <TT>start</TT> and <TT>end</TT> equal to not delete
anything. Set <TT>insert</TT> to <TT>NULL</TT> to not insert
anything.</P>
<P><TT>length</TT> must be zero or <TT>strlen(insert)</TT>, this
saves a tiny bit of time if you happen to already know the
length of the insertion, or can be used to insert a portion of a
string or a string containing nul's.</P>
<P><TT>a</TT> and <TT>b</TT> are clamped to the
0..<TT>size()</TT> range, so it is safe to pass any values.</P>
<P><TT>cut()</TT> and <TT>insert()</TT> are just inline
functions that call <TT>replace()</TT>.</P>
<H4><A name="Fl_Input_.cut">int Fl_Input_::cut()
<BR> int Fl_Input_::cut(int n)
<BR> int Fl_Input_::cut(int a, int b);</A></H4>
<P><TT>Fl_Input_::cut()</TT> deletes the current selection.
<TT>cut(n)</TT> deletes <TT>n</TT> characters after the
<TT>position()</TT>. <TT>cut(-n)</TT> deletes <TT>n</TT>
characters before the <TT>position()</TT>. <TT>cut(a,b)</TT>
deletes the characters between offsets <TT>a</TT> and
<TT>b</TT>. <TT>A</TT>, <TT>b</TT>, and <TT>n</TT> are all
clamped to the size of the string. The mark and point are left
where the deleted text was.
<P>If you want the data to go into the clipboard, do
<TT>Fl_Input_::copy()</TT> before calling
<TT>Fl_Input_::cut()</TT>, or do <TT>Fl_Input_::copy_cuts()</TT>
afterwards.</P>
<H4><A name="Fl_Input_.insert">int Fl_Input_::insert(const char *t,int
l=0)</A></H4>
<P>Insert the string <TT>t</TT> at the current position, and
leave the mark and position after it. If <TT>l</TT> is not zero
then it is assumed to be <TT>strlen(t)</TT>.
<H4><A name="Fl_Input_.copy">int Fl_Input_::copy(int clipboard)</A></H4>
<P>Put the current selection between <TT>mark()</TT> and
<TT>position()</TT> into the specified clipboard. Does not
replace the old clipboard contents if <TT>position()</TT> and
<TT>mark()</TT> are equal. Clipboard 0 maps to the current text
selection and clipboard 1 maps to the cut/paste clipboard.
<H4><A name="Fl_Input_.undo">int Fl_Input_::undo()</A></H4>
<P>Does undo of several previous calls to <TT>replace()</TT>.
Returns non-zero if any change was made.
<H4><A name="Fl_Input_.copy_cuts">int Fl_Input_::copy_cuts()</A></H4>
<P>Copy all the previous contiguous cuts from the undo
information to the clipboard. This is used to make ^K work.
<H4><A name="Fl_Input_.input_type">int Fl_Input_::input_type() const
<BR>void Fl_Input_::input_type(int)</A></H4>
<P>Gets or sets the input field type.
<H4><A name="Fl_Input_.readonly">int Fl_Input_::readonly() const
<BR>void Fl_Input_::readonly(int)</A></H4>
<P>Gets or sets the read-only state of the input field.
<H4><A name="Fl_Input_.shortcut">ulong Fl_Input_::shortcut() const
<BR> void Fl_Input_::shortcut(ulong key)</A></H4>
The first form returns the current shortcut key for the Input.
<P>The second form sets the shortcut key to <TT>key</TT>. Setting this
overrides the use of '&amp;' in the <TT>label()</TT>. The value is a bitwise
OR of a key and a set of shift flags, for example <CODE>FL_ALT | 'a'</CODE>
, <CODE>FL_ALT | (FL_F + 10)</CODE>, or just <CODE>'a'</CODE>. A value
of 0 disables the shortcut. </P>
<P>The key can be any value returned by <A href="Fl.html#Fl.event_key">
<TT>Fl::event_key()</TT></A>, but will usually be an ASCII letter. Use
a lower-case letter unless you require the shift key to be held down. </P>
<P>The shift flags can be any set of values accepted by <A href="Fl.html#Fl.event_state">
<TT>Fl::event_state()</TT></A>. 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 &quot;don't care&quot;
setting). </P>
<H4><A name="Fl_Input_.wrap">int Fl_Input_::wrap() const
<BR>void Fl_Input_::wrap(int)</A></H4>
<P>Gets or sets the word wrapping state of the input field. Word
wrap is only functional with multi-line input fields.
</BODY>
</HTML>
documentation/Fl_Input_Choice.html
-100
View File
@@ -1,100 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Input_Choice</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Input_Choice>class Fl_Input_Choice</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A href=Fl_Group.html#Fl_Group>Fl_Group</A>
|
+----<B>Fl_Input_Choice</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_Input_Choice.H&gt;
</PRE></UL>
<P align='center'>
<IMG SRC='input_choice.jpg'><BR>
<I>Plastic and normal Fl::scheme()s.</I>
</P>
<H3>Description</H3>
<P>A combination of the input widget and a menu button.
The user can either type into the input area, or use the
menu button chooser on the right, which loads the input area
with predefined text. Normally it is drawn with an inset box
and a white background.
<P>
The application can directly access both the input and menu
widgets directly, using the <A HREF=#Fl_Input_Choice.menubutton>menubutton()</A>
and <A HREF=#Fl_Input_Choice.input>input()</A> accessor methods.
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Input_Choice methods."><TR><TD align=left valign=top>
<UL TYPE=DISC>
<LI><A href='#Fl_Input_Choice.Fl_Input_Choice'>Fl_Input_Choice</A></LI>
<LI><A href='#Fl_Input_Choice.~Fl_Input_Choice'>~Fl_Input_Choice</A></LI>
<LI><A href='#Fl_Input_Choice.add'>add</A></LI>
<LI><A href='#Fl_Input_Choice.clear'>clear</A></LI>
<LI><A href='#Fl_Input_Choice.input'>input</A></LI>
<LI><A href='#Fl_Input_Choice.menu'>menu</A></LI>
<LI><A href='#Fl_Input_Choice.menubutton'>menubutton</A></LI>
<LI><A href='#Fl_Input_Choice.value'>value</A></LI>
</TD></TR></TABLE>
</CENTER>
<H4><A name="Fl_Input_Choice.Fl_Input_Choice">Fl_Input_Choice::Fl_Input_Choice(int x, int y, int w,
int h, const char *label = 0)</A></H4>
<P>Creates a new <TT>Fl_Input_Choice</TT> widget using the given position, size,
and label string.
<H4><A name="Fl_Input_Choice.~Fl_Input_Choice">virtual Fl_Input_Choice::~Fl_Input_Choice()</A></H4>
<P>Destroys the widget and any value associated with it.
<h4><a name='Fl_Input_Choice.add'>void Fl_Input_Choice::add(const char *s)</a></h4>
<p>Adds an item to the menu.</p>
<h4><a name='Fl_Input_Choice.clear'>void Fl_Input_Choice::clear()</a></h4>
<p>Removes all items from the menu.</p>
<H4><A name="Fl_Input_Choice.input">Fl_Input *Fl_Input_Choice::input()</A></H4>
<p>Returns a reference to the internal <tt>Fl_Input</tt> widget.</p>
<h4><a name='Fl_Input_Choice.menu'>void Fl_Input_Choice::menu(const Fl_Menu_Item *m)<br>
const Fl_Menu_Item *menu()</A></h4>
<p>Gets or sets the <tt>Fl_Menu_Item</tt> array used for the menu.</p>
<H4><A name="Fl_Input_Choice.menubutton">Fl_Menu_Button *Fl_Input_Choice::menubutton()</A></H4>
<P>Returns a reference to the internal <tt>Fl_Menu_Button</tt> widget.
<H4><A name="Fl_Input_Choice.value">void Fl_Input_Choice::value(const char *s)<br>
void Fl_Input_Choice::value(int v)<br>
const char *Fl_Input_Choice::value() const</A></H4>
<P>Sets or returns the input widget's current contents. The
second form sets the contents using the index into the menu
which you can set as an integer. Setting the value effectively
'chooses' this menu item, and sets it as the new input text,
deleting the previous text.</p>
</BODY>
</HTML>
documentation/Fl_Int_Input.html
-38
View File
@@ -1,38 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Int_Input</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Int_Input>class Fl_Int_Input</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Input.html#Fl_Input>Fl_Input</A>
|
+----<B>Fl_Int_Input</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Int_Input.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Int_Input</TT> class is a subclass of <TT>Fl_Input</TT>
that only allows the user to type decimal digits (or hex numbers of
the form <tt>0xaef</tt>).
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Int_Input.Fl_Int_Input>Fl_Int_Input</A></LI>
<LI><A href=#Fl_Int_Input.~Fl_Int_Input>~Fl_Int_Input</A></LI>
</UL>
<H4><A name=Fl_Int_Input.Fl_Int_Input>Fl_Int_Input::Fl_Int_Input(int x,
int y, int w, int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Int_Input</TT> widget using the given position,
size, and label string. The default boxtype is <TT>FL_DOWN_BOX</TT>.
<H4><A name=Fl_Int_Input.~Fl_Int_Input>virtual
Fl_Int_Input::~Fl_Int_Input()</A></H4>
Destroys the widget and any value associated with it. </BODY></HTML>
documentation/Fl_JPEG_Image.html
-59
View File
@@ -1,59 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_JPEG_Image</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_JPEG_Image">class Fl_JPEG_Image</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A href="Fl_RGB_Image.html">Fl_RGB_Image</A>
|
+----<B>Fl_JPEG_Image</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_JPEG_Image.H&gt;
</PRE></UL>
<H3>Additional Libraries</H3>
<UL><PRE>
-lfltk_images / fltkimages.lib
</PRE></UL>
<H3>Description</H3>
<P>The <TT>Fl_JPEG_Image</TT> 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.</P>
<H3>Methods</H3>
<UL>
<LI><A href="#Fl_JPEG_Image.Fl_JPEG_Image">Fl_JPEG_Image</A></LI>
<LI><A href="#Fl_JPEG_Image.~Fl_JPEG_Image">~Fl_JPEG_Image</A></LI>
</UL>
<H4><A name="Fl_JPEG_Image.Fl_JPEG_Image">Fl_JPEG_Image::Fl_JPEG_Image(const char *filename);</A></H4>
<P>The constructor loads the named JPEG image.</P>
<H4><A name="Fl_JPEG_Image.~Fl_JPEG_Image">Fl_JPEG_Image::~Fl_JPEG_Image();</A></H4>
<P>The destructor free all memory and server resources that are used by
the image.</P>
</BODY>
</HTML>
documentation/Fl_Light_Button.html
-45
View File
@@ -1,45 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Light_Button</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Light_Button>class Fl_Light_Button</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Button.html#Fl_Button>Fl_Button</A>
|
+----<B>Fl_Light_Button</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Light_Button.H&gt;
</PRE>
</UL>
<H3>Description</H3>
Buttons generate callbacks when they are clicked by the user. You
control exactly when and how by changing the values for <TT>type()</TT>
and <TT>when()</TT>.
<P ALIGN=CENTER><IMG SRC="Fl_Light_Button.gif" ALT="Fl_Light_Button widget."></P>
<P>The <TT>Fl_Light_Button</TT> subclass display the &quot;on&quot; state by
turning on a light, rather than drawing pushed in. The shape of the
&quot;light&quot; is initially set to FL_DOWN_BOX. The color of the light when
on is controlled with <TT>selection_color()</TT>, which defaults to
FL_YELLOW.</P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Light_Button.Fl_Light_Button>Fl_Light_Button</A></LI>
<LI><A href=#Fl_Light_Button.~Fl_Light_Button>~Fl_Light_Button</A></LI>
</UL>
<H4><A name=Fl_Light_Button.Fl_Light_Button>
Fl_Light_Button::Fl_Light_Button(int x, int y, int w, int h, const char
*label = 0)</A></H4>
Creates a new <TT>Fl_Light_Button</TT> widget using the given
position, size, and label string.
<H4><A name=Fl_Light_Button.~Fl_Light_Button>
Fl_Light_Button::~Fl_Light_Button()</A></H4>
The destructor deletes the check button. </BODY></HTML>
documentation/Fl_Menu_.html
-316
View File
@@ -1,316 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Menu_</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Menu_>class Fl_Menu_</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Widget.html#Fl_Widget>Fl_Widget</A>
|
+----<B>Fl_Menu_</B>----<A href=Fl_Menu_Item.html#Fl_Menu_Item>Fl_Menu_Item</A>
|
+----<A href=Fl_Choice.html#Fl_Choice>Fl_Choice</A>, <A href=Fl_Menu_Bar.html#Fl_Menu_Bar>Fl_Menu_Bar</A>, <A href=Fl_Menu_Button.html#Fl_Menu_Button>Fl_Menu_Button</A>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Menu_.H&gt;
</PRE>
</UL>
<H3>Description</H3>
All widgets that have a menu in FLTK are subclassed off of this class.
Currently FLTK provides you with <A href=Fl_Menu_Button.html#Fl_Menu_Button>
<TT>Fl_Menu_Button</TT></A>, <A href=Fl_Menu_Bar.html#Fl_Menu_Bar><TT>
Fl_Menu_Bar</TT></A>, and <A href=Fl_Choice.html#Fl_Choice><TT>Fl_Choice</TT>
</A>.
<P>The class contains a pointer to an array of structures of type <A
href=Fl_Menu_Item.html#Fl_Menu_Item> <TT>Fl_Menu_Item</TT></A>. 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_.
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Menu_ methods.">
<TR><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Menu_.Fl_Menu_>Fl_Menu_</A></LI>
<LI><A href=#Fl_Menu_.~Fl_Menu_>~Fl_Menu_</A></LI>
<LI><A href=#Fl_Menu_.add>add</A></LI>
<LI><A href=#Fl_Menu_.clear>clear</A></LI>
<LI><A href=#Fl_Menu_.copy>copy</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Menu_.down_box>down_box</A></LI>
<LI><A href=#Fl_Menu_.find_item>find_item</A></LI>
<LI><A href=#Fl_Menu_.global>global</A></LI>
<LI><A href=#Fl_Menu_.item_pathname>item_pathname</A></LI>
<LI><A href=#Fl_Menu_.menu>menu</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Menu_.mode>mode</A></LI>
<LI><A href=#Fl_Menu_.mvalue>mvalue</A></LI>
<LI><A href=#Fl_Menu_.remove>remove</A></LI>
<LI><A href=#Fl_Menu_.replace>replace</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Menu_.shortcut>shortcut</A></LI>
<LI><A href=#Fl_Menu_.size>size</A></LI>
<LI><A href=#Fl_Menu_.test_shortcut>test_shortcut</A></LI>
<LI><A href=#Fl_Menu_.text>text</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Menu_.textfont>textfont</A></LI>
<LI><A href=#Fl_Menu_.textsize>textsize</A></LI>
<LI><A href=#Fl_Menu_.value>value</A></LI>
<LI><A href=#Fl_Menu_.textcolor>textcolor</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name=Fl_Menu_.Fl_Menu_>Fl_Menu_::Fl_Menu_(int x, int y, int w,
int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Menu_</TT> widget using the given position, size,
and label string.<tt> menu()</tt> is initialized to null.
<H4><A name=Fl_Menu_.~Fl_Menu_>virtual Fl_Menu_::~Fl_Menu_()</A></H4>
If the menu array is private the memory it uses is freed.
<H4><A name=Fl_Menu_.add>int Fl_Menu_::add(const char* label, const
char* shortcut, Fl_Callback*, void *user_data=0, int flags=0)</a><br>
int Fl_Menu_::add(const char* label, int shortcut, Fl_Callback*,
void *user_data=0, int flags=0)</h4>
<p>Adds a new menu item, with a <TT>title</TT> string, <TT>
shortcut</TT> string, <TT>callback</TT>, argument to the
callback, and flags. If the menu array was directly set with
<tt>menu(x)</tt> then <tt>copy()</tt> is done to make a private
array.
<p>The characters "&amp;", "/", "\", and "_" are treated as
special characters in the label string. The "&amp;" character
specifies that the following character is an accelerator and
will be underlined. The "\" character is used to escape the next
character in the string. Labels starting with the "_" character
cause a divider to be placed after that menu item.</p>
<p>A label of the form &quot;foo/bar/baz&quot; will create a
submenus called &quot;foo&quot; and &quot;bar&quot; with an
entry called &quot;baz&quot;. The "/" character is ignored if it
appears as the first character of the label string, e.g.
"/foo/bar/baz".</p>
<p>The label string is copied to new memory and can be freed.
The other arguments (including the shortcut) are copied into the
menu item unchanged. </P>
<P>If an item exists already with that name then it is replaced with
this new one. Otherwise this new one is added to the end of the
correct menu or submenu. The return value is the offset into the array
that the new entry was placed at.</P>
<P>Shortcut can be 0L, or either a modifier/key combination (for example
FL_CTRL+'A') or a string describing the shortcut in one of two ways:</p>
<pre>
[#+^]&lt;ascii_value&gt;  eg. "97", "^97", "+97", "#97"
[#+^]&lt;ascii_char&gt;  eg. "a", "^a", "+a", "#a"
</pre>
..where &lt;ascii_value&gt; is a decimal value representing an
ascii character (eg. 97 is the ascii for 'a'), and the optional
prefixes enhance the value that follows. Multiple prefixes must
appear in the above order.
<pre>
# - Alt
+ - Shift
^ - Control
</pre>
Text shortcuts are converted to integer shortcut by calling
<tt>int fl_old_shortcut(const char*)</tt>.
<P>The return value is the index into the array that the entry was put. </P>
<P>No items must be added to a menu during a callback to the same menu.</P>
<h4>int Fl_Menu_::add(const char *)</H4>
<P>The passed string is split at any '|' characters and then
<TT>add(s,0,0,0,0)</TT> is done with each section. This is
often useful if you are just using the value, and is compatible
with Forms and other GL programs. The section strings use the
same special characters as described for the long version of <a
href='#Fl_Menu_.add'><tt>add()</tt></a></p>
<P>No items must be added to a menu during a callback to the same menu.</P>
<H4><A name=Fl_Menu_.clear>void Fl_Menu_::clear()</A></H4>
Same as <tt>menu(NULL)</tt>, set the array pointer to null, indicating
a zero-length menu.
<P>Menus must no be cleared during a callback to the same menu.</P>
<H4><A name=Fl_Menu_.copy>void Fl_Menu_::copy(const
Fl_Menu_Item*, void* user_data = 0)</A></H4>
<P>The menu is set to a private copy of the passed Fl_Menu_Item
array. This is useful if you want to modify the flags of the
menu items. If the <tt>user_data</tt> argument is non-NULL, then
the <tt>user_data</tt> members of the menu items are set to the
given value.
<H4><A name=Fl_Menu_.down_box>Fl_Boxtype Fl_Menu_::down_box() const
<BR> void Fl_Menu_::down_box(Fl_Boxtype)</A></H4>
This box type is used to surround the currently-selected items in the
menus. If this is <TT>FL_NO_BOX</TT> then it acts like <TT>
FL_THIN_UP_BOX</TT> and <TT>selection_color()</TT> acts like <TT>
FL_WHITE</TT>, for back compatability.
<h4><a name="Fl_Menu_.find_item">const Fl_Menu_Item *Fl_Menu_::find_item(const char *name);</a></h4>
<p>Returns a pointer to the menu item with the given (full)
pathname. If no matching menu item can be found, a NULL pointer
is returned. This function does not search submenus that are linked
via FL_SUBMENU_POINTER.</p>
<h4><a name=Fl_Menu_.item_pathname>int Fl_Menu_::item_pathname(char *name, int namelen ) const;</a><br>
int Fl_Menu_::item_pathname(char *name, int namelen, const Fl_Menu_Item *finditem) const;</h4>
<p>Returns the 'menu pathname' (eg. "File/Quit") for the recently picked item in user supplied string 'name'. Useful in the callback function for a menu item, to determine the last picked item's 'menu pathname' string.
<p>If finditem is specified, name will contain the 'menu pathname' for that item.
<p>Returns:
<ul>
<li>0 - OK: 'name' has the pathname, guaranteed not longer than namelen
<li>-1 - Failed: 'finditem' was not found in the menu
<li>-2 - Failed: 'name' is not large enough to handle the menu names
</ul>
<p>In the case of errors (-1 or -2), 'name' will be an empty string.
<H4><A name=Fl_Menu_.menu>const Fl_Menu_Item* Fl_Menu_::menu()
const</a></h4>
Returns a pointer to the array of Fl_Menu_Items. This will either be
the value passed to <tt>menu(value)</tt> or the private copy.
<h4>void Fl_Menu_::menu(const Fl_Menu_Item*)</H4>
Set the menu array pointer directly. If the old menu is private it is
deleted. <tt>NULL</tt> is allowed and acts the same as a zero-length
menu. If you try to modify the array (with add(), replace(), or
delete()) a private copy is automatically done.
<H4><A name=Fl_Menu_.mode>void Fl_Menu_::mode(int i, int x);</A></H4>
Changes the flags of item <TT>i</TT>. For a list of the flags, see <a
href=Fl_Menu_Item.html>Fl_Menu_Item</a>.
<H4><A name=Fl_Menu_.mvalue>const Fl_Menu_Item* Fl_Menu_::mvalue()
const</a></h4>
<P>Returns a pointer to the last menu item that was picked.
<H4><A name=Fl_Menu_.remove>void Fl_Menu_::remove(int n)</A></H4>
Deletes item <TT>n</TT> from the menu. If the menu array was directly
set with menu(x) then copy() is done to make a private array.
<P>No items must be removed from a menu during a callback to the same menu.</P>
<H4><A name=Fl_Menu_.replace>void Fl_Menu_::replace(int n, const char *)</A>
</H4>
Changes the text of item <TT>n</TT>. This is the only way to get
slash into an add()'ed menu item. If the menu array was directly set
with menu(x) then copy() is done to make a private array.
<H4><A name=Fl_Menu_.shortcut>void Fl_Menu_::shortcut(int i, int n);</A></H4>
Changes the shortcut of item <TT>i</TT> to <TT>n</TT>.
<H4><A name=Fl_Menu_.size>int Fl_Menu_::size() const</A></H4>
This returns the number of Fl_Menu_Item structures that make up the
menu, correctly counting submenus. This includes the "terminator"
item at the end. To copy a menu array you need to copy
<tt>size()*sizeof(Fl_Menu_Item)</tt> bytes. If the menu is
<TT>NULL</TT> this returns zero (an empty menu will return 1).
<H4><A name=Fl_Menu_.test_shortcut>const Fl_Menu_Item*
Fl_Menu_::test_shortcut()</A></H4>
Only call this in response to <TT>FL_SHORTCUT events</TT>. If the
event matches an entry in the menu that entry is selected and the
callback will be done (or <TT>changed()</TT> will be set). This allows
shortcuts directed at one window to call menus in another.
<H4><A name=Fl_Menu_.global>void Fl_Menu_::global()</A></H4>
Make the shortcuts for this menu work no matter what window has the
focus when you type it. This is done by using <A href=osissues.html#add_handler>
<TT>Fl::add_handler()</TT></A>. This <TT>Fl_Menu_</TT> widget does not
have to be visible (ie the window it is in can be hidden, or it does
not have to be put in a window at all).
<P>Currently there can be only one <TT>global()</TT>menu. Setting a new
one will replace the old one. There is no way to remove the <TT>
global()</TT> setting (so don't destroy the widget!)</P>
<H4><A name=Fl_Menu_.text>const char* Fl_Menu_::text() const
<BR> const char* Fl_Menu_::text(int i) const</A></H4>
Returns the title of the last item chosen, or of item <TT>i</TT>.
<H4><A name=Fl_Menu_.textcolor>Fl_Color Fl_Menu_::textcolor() const
<BR> void Fl_Menu_::textcolor(Fl_Color)</A></H4>
Get or set the current color of menu item labels.
<H4><A name=Fl_Menu_.textfont>Fl_Font Fl_Menu_::textfont() const
<BR> void Fl_Menu_::textfont(Fl_Font)</A></H4>
Get or set the current font of menu item labels.
<H4><A name=Fl_Menu_.textsize>uchar Fl_Menu_::textsize() const
<BR> void Fl_Menu_::textsize(uchar)</A></H4>
Get or set the font size of menu item labels.
<H4><A name=Fl_Menu_.value>int Fl_Menu_::value() const
<BR> int Fl_Menu_::value(int)
<BR> const Fl_Menu_Item* mvalue() const
<BR> int Fl_Menu_::value(const Fl_Menu_Item*)</A></H4>
The value is the index into <TT>menu()</TT> 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.
</body>
</html>
documentation/Fl_Menu_Bar.html
-67
View File
@@ -1,67 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Menu_Bar</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Menu_Bar>class Fl_Menu_Bar</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Menu_.html#Fl_Menu_>Fl_Menu_</A>
|
+----<B>Fl_Menu_Bar</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Menu_Bar.H&gt;
</PRE>
</UL>
<H3>Description</H3>
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.
<P>The items on the bar and the menus they bring up are defined by a
single <A href=Fl_Menu_Item.html#Fl_Menu_Item><TT>Fl_Menu_Item</TT></A>
array. Because a <TT>Fl_Menu_Item</TT> 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. </P>
<P ALIGN=CENTER><IMG src="menubar.gif" ALT="Fl_Menu_Bar widget."></P>
<P>If there is an item in the top menu that is not a title of a
submenu, then it acts like a &quot;button&quot; in the menubar. Clicking on it
will pick it. </P>
<P>When the user picks an item off the menu, the item's callback is
done with the menubar as the <TT>Fl_Widget*</TT> argument. If the item
does not have a callback the menubar's callback is done instead. </P>
<P>Submenus will also pop up in response to shortcuts indicated by
putting a '&amp;' character in the name field of the menu item. If you put a
'&amp;' character in a top-level &quot;button&quot; then the shortcut picks it. The
'&amp;' character in submenus is ignored until the menu is popped up. </P>
<P>Typing the <TT>shortcut()</TT> of any of the menu items will cause
callbacks exactly the same as when you pick the item with the mouse. </P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Menu_Bar.Fl_Menu_Bar>Fl_Menu_Bar</A></LI>
<LI><A href=#Fl_Menu_Bar.~Fl_Menu_Bar>~Fl_Menu_Bar</A></LI>
</UL>
<H4><A name=Fl_Menu_Bar.Fl_Menu_Bar>Fl_Menu_Bar::Fl_Menu_Bar(int x, int
y, int w, int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Menu_Bar</TT> widget using the given position,
size, and label string. The default boxtype is <TT>FL_UP_BOX</TT>.
<P>The constructor sets <TT>menu()</TT> to <TT>NULL</TT>. See <A href=Fl_Menu_.html#Fl_Menu_>
<TT>Fl_Menu_</TT></A> for the methods to set or change the menu. </P>
<P><TT>labelsize()</TT>, <TT>labelfont()</TT>, and <TT>labelcolor()</TT>
are used to control how the menubar items are drawn. They are
initialized from the <TT>Fl_Menu</TT> static variables, but you can
change them if desired. </P>
<P><TT>label()</TT> is ignored unless you change <TT>align()</TT> to
put it outside the menubar. </P>
<H4><A name=Fl_Menu_Bar.~Fl_Menu_Bar>virtual Fl_Menu_Bar::~Fl_Menu_Bar()</A>
</H4>
The destructor removes the <TT>Fl_Menu_Bar</TT> widget and all of its
menu items. </BODY></HTML>
documentation/Fl_Menu_Button.html
-83
View File
@@ -1,83 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Menu_Button</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Menu_Button>class Fl_Menu_Button</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Menu_.html#Fl_Menu_>Fl_Menu_</A>
|
+----<B>Fl_Menu_Button</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Menu_Button.H&gt;
</PRE>
</UL>
<H3>Description</H3>
This is a button that when pushed pops up a menu (or hierarchy of
menus) defined by an array of <A href=Fl_Menu_Item.html#Fl_Menu_Item><TT>
Fl_Menu_Item</TT></A> objects.
<P ALIGN=CENTER><IMG src="menu_button.gif" ALT="Fl_Menu_Button widget."></P>
<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 <TT>Fl_Menu_Button</TT>
may also control a pop-up menu. This is done by setting the <TT>type()</TT>
, see below. </P>
<P>The menu will also pop up in response to shortcuts indicated by
putting a '&amp;' character in the <TT>label()</TT>. </P>
<P>Typing the <TT>shortcut()</TT> of any of the menu items will cause
callbacks exactly the same as when you pick the item with the mouse.
The '&amp;' character in menu item names are only looked at when the menu is
popped up, however. </P>
<P>When the user picks an item off the menu, the item's callback is
done with the menu_button as the <TT>Fl_Widget*</TT> argument. If the
item does not have a callback the menu_button's callback is done
instead. </P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Menu_Button.Fl_Menu_Button>Fl_Menu_Button</A></LI>
<LI><A href=#Fl_Menu_Button.~Fl_Menu_Button>~Fl_Menu_Button</A></LI>
<LI><A href=#Fl_Menu_Button.popup>popup</A></LI>
<LI><A href=#Fl_Menu_Button.type>type</A></LI>
</UL>
<H4><A name=Fl_Menu_Button.Fl_Menu_Button>
Fl_Menu_Button::Fl_Menu_Button(int x, int y, int w, int h, const char
*label = 0)</A></H4>
Creates a new <TT>Fl_Menu_Button</TT> widget using the given position,
size, and label string. The default boxtype is <TT>FL_UP_BOX</TT>.
<P>The constructor sets <TT>menu()</TT> to <TT>NULL</TT>. See <A href=Fl_Menu_.html#Fl_Menu_>
<TT>Fl_Menu_</TT></A> for the methods to set or change the menu. </P>
<H4><A name=Fl_Menu_Button.~Fl_Menu_Button>virtual
Fl_Menu_Button::~Fl_Menu_Button()</A></H4>
The destructor removes the <TT>Fl_Menu_Button</TT> widget and all of
its menu items.
<H4><A name=Fl_Menu_Button.popup>const Fl_Menu* Fl_Menu_Button::popup()</A>
</H4>
Act exactly as though the user clicked the button or typed the
shortcut key. The menu appears, it waits for the user to pick an item,
and if they pick one it sets <TT>value()</TT> and does the callback or
sets <TT>changed()</TT> as described above. The menu item is returned
or <TT>NULL</TT> if the user dismisses the menu.
<H4><A name=Fl_Menu_Button.type>void Fl_Menu_Button::type(uchar)</A></H4>
If <TT>type()</TT> is zero a normal menu button is produced. If it is
nonzero then this is a pop-up menu. The bits in <TT>type()</TT>
indicate what mouse buttons pop up the menu. For convienece the
constants <TT>Fl_Menu_Button::POPUP1, POPUP2, POPUP3, POPUP12, POPUP13,
POPUP23</TT>, and <TT>POPUP123</TT> are defined. <TT>
Fl_Menu_Button::POPUP3</TT> is usually what you want.
<P>A popup menu button is invisible and does not interfere with any
events other than the mouse button specified (and any shortcuts). The
widget can be stretched to cover all your other widgets by putting it
last in the hierarchy so it is &quot;on top&quot;. You can also make several
widgets covering different areas for context-sensitive popup menus. </P>
<P>The popup menus appear with the cursor pointing at the previously
selected item. This is a <I>feature</I>. If you don't like it, do <TT>
value(0)</TT> after the menu items are picked to forget the current
item. </P>
</BODY></HTML>
documentation/Fl_Menu_Item.html
-300
View File
@@ -1,300 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Menu_Item</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Menu_Item>struct Fl_Menu_Item</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<B>struct Fl_Menu_Item</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Menu_Item.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Menu_Item</TT> structure defines a single menu item that
is used by the <A href=Fl_Menu_.html#Fl_Menu_>Fl_Menu_</A> class. This
structure is defined in <TT> &lt;FL/Fl_Menu_Item.H&gt;</TT>
<UL>
<PRE>
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,
FL_MENU_TOGGLE = 2,
FL_MENU_VALUE = 4,
FL_MENU_RADIO = 8,
FL_MENU_INVISIBLE = 0x10,
FL_SUBMENU_POINTER = 0x20,
FL_SUBMENU = 0x40,
FL_MENU_DIVIDER = 0x80,
FL_MENU_HORIZONTAL = 0x100
};
</PRE>
</UL>
Typically menu items are statically defined; for example:
<UL><PRE>
Fl_Menu_Item popup[] = {
{&quot;&amp;alpha&quot;, FL_ALT+'a', the_cb, (void*)1},
{&quot;&amp;beta&quot;, FL_ALT+'b', the_cb, (void*)2},
{&quot;gamma&quot;, FL_ALT+'c', the_cb, (void*)3, FL_MENU_DIVIDER},
{&quot;&amp;strange&quot;, 0, strange_cb},
{&quot;&amp;charm&quot;, 0, charm_cb},
{&quot;&amp;truth&quot;, 0, truth_cb},
{&quot;b&amp;eauty&quot;, 0, beauty_cb},
{&quot;sub&amp;menu&quot;, 0, 0, 0, FL_SUBMENU},
{&quot;one&quot;},
{&quot;two&quot;},
{&quot;three&quot;},
{0},
{&quot;inactive&quot;, FL_ALT+'i', 0, 0, FL_MENU_INACTIVE|FL_MENU_DIVIDER},
{&quot;invisible&quot;,FL_ALT+'i', 0, 0, FL_MENU_INVISIBLE},
{&quot;check&quot;, FL_ALT+'i', 0, 0, FL_MENU_TOGGLE|FL_MENU_VALUE},
{&quot;box&quot;, FL_ALT+'i', 0, 0, FL_MENU_TOGGLE},
{0}};
</PRE></UL>
produces:
<P ALIGN=CENTER><IMG src="menu.gif" ALT="Fl_Menu_Item widgets."></P>
A submenu title is identified by the bit <TT>FL_SUBMENU</TT> in the <TT>
flags</TT> field, and ends with a <TT>label()</TT> that is <TT>NULL</TT>.
You can nest menus to any depth. A pointer to the first item in the
submenu can be treated as an <TT>Fl_Menu</TT> array itself. It is also
possible to make seperate submenu arrays with <TT>FL_SUBMENU_POINTER</TT>
flags.
<P>You should use the method functions to access structure members and
not access them directly to avoid compatibility problems with future
releases of FLTK. </P>
<H3>Methods</H3>
<CENTER>
<TABLE width=90% summary="Fl_Menu_Item methods.">
<TR><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Menu_Item.label>label</A></LI>
<LI><A href=#Fl_Menu_Item.labeltype>labeltype</A></LI>
<LI><A href=#Fl_Menu_Item.labelcolor>labelcolor</A></LI>
<LI><A href=#Fl_Menu_Item.labelfont>labelfont</A></LI>
<LI><A href=#Fl_Menu_Item.labelsize>labelsize</A></LI>
<LI><A href=#Fl_Menu_Item.callback>callback</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Menu_Item.user_data>user_data</A></LI>
<LI><A href=#Fl_Menu_Item.argument>argument</A></LI>
<LI><A href=#Fl_Menu_Item.do_callback>do_callback</A></LI>
<LI><A href=#Fl_Menu_Item.shortcut>shortcut</A></LI>
<LI><A href=#Fl_Menu_Item.submenu>submenu</A></LI>
<LI><A href=#Fl_Menu_Item.checkbox>checkbox</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Menu_Item.radio>radio</A></LI>
<LI><A href=#Fl_Menu_Item.value>value</A></LI>
<LI><A href=#Fl_Menu_Item.set>set</A></LI>
<LI><A href=#Fl_Menu_Item.setonly>setonly</A></LI>
<LI><A href=#Fl_Menu_Item.clear>clear</A></LI>
<LI><A href=#Fl_Menu_Item.visible>visible</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Menu_Item.show>show</A></LI>
<LI><A href=#Fl_Menu_Item.hide>hide</A></LI>
<LI><A href=#Fl_Menu_Item.active>active</A></LI>
<LI><A href=#Fl_Menu_Item.activate>activate</A></LI>
<LI><A href=#Fl_Menu_Item.deactivate>deactivate</A></LI>
</UL>
</TD><TD align=left valign=top>
<UL>
<LI><A href=#Fl_Menu_Item.popup>popup</A></LI>
<LI><A href=#Fl_Menu_Item.pulldown>pulldown</A></LI>
<LI><A href=#Fl_Menu_Item.test_shortcut>test_shortcut</A></LI>
<LI><A href=#Fl_Menu_Item.size>size</A></LI>
<LI><A href=#Fl_Menu_Item.next>next</A></LI>
</UL>
</TD></TR>
</TABLE>
</CENTER>
<H4><A name=Fl_Menu_Item.label>const char* Fl_Menu_Item::label() const
<BR> void Fl_Menu_Item::label(const char*)
<BR> void Fl_Menu_Item::label(Fl_Labeltype, const char*)</A></H4>
This is the title of the item. A <TT>NULL</TT> here indicates the end
of the menu (or of a submenu). A '&amp;' in the item will print an
underscore under the next letter, and if the menu is popped up that
letter will be a &quot;shortcut&quot; to pick that item. To get a
real '&amp;' put two
in a row.
<H4><A name=Fl_Menu_Item.labeltype>Fl_Labeltype
Fl_Menu_Item::labeltype() const
<BR> void Fl_Menu_Item::labeltype(Fl_Labeltype)</A></H4>
A <TT>labeltype</TT> identifies a routine that draws the label of the
widget. This can be used for special effects such as emboss, or to use
the <TT>label()</TT> pointer as another form of data such as a bitmap.
The value <TT>FL_NORMAL_LABEL</TT> prints the label as text.
<H4><A name=Fl_Menu_Item.labelcolor>Fl_Color Fl_Menu_Item::labelcolor()
const
<BR> void Fl_Menu_Item::labelcolor(Fl_Color)</A></H4>
This color is passed to the labeltype routine, and is typically the
color of the label text. This defaults to <TT>FL_BLACK</TT>. If this
color is not black fltk will <I>not</I> use overlay bitplanes to draw
the menu - this is so that images put in the menu draw correctly.
<H4><A name=Fl_Menu_Item.labelfont>Fl_Font Fl_Menu_Item::labelfont()
const
<BR> void Fl_Menu_Item::labelfont(Fl_Font)</A></H4>
Fonts are identified by small 8-bit indexes into a table. See the <A href=enumerations.html#Enumerations>
enumeration list</A> for predefined fonts. The default value is a
Helvetica font. The function <A href="Fl.html#Fl.set_font"><TT>
Fl::set_font()</TT></A> can define new fonts.
<H4><A name=Fl_Menu_Item.labelsize>uchar Fl_Menu_Item::labelsize() const
<BR> void Fl_Menu_Item::labelsize(uchar)</A></H4>
Gets or sets the label font pixel size/height.
<H4><A name=Fl_Menu_Item.callback>typedef void
(Fl_Callback)(Fl_Widget*, void*)
<BR> Fl_Callback* Fl_Menu_Item::callback() const
<BR> void Fl_Menu_Item::callback(Fl_Callback*, void* = 0)
<BR> void Fl_Menu_Item::callback(void (*)(Fl_Widget*))</A></H4>
Each item has space for a callback function and an argument for that
function. Due to back compatability, the <TT>Fl_Menu_Item</TT> itself
is not passed to the callback, instead you have to get it by calling <TT>
((Fl_Menu_*)w)-&gt;mvalue()</TT> where <TT>w</TT> is the widget argument.
<H4><A name=Fl_Menu_Item.user_data>void* Fl_Menu_Item::user_data() const
<BR> void Fl_Menu_Item::user_data(void*)</A></H4>
Get or set the <TT>user_data</TT> argument that is sent to the
callback function.
<H4><A name=Fl_Menu_Item.argument>void Fl_Menu_Item::callback(void
(*)(Fl_Widget*, long), long = 0)
<BR> long Fl_Menu_Item::argument() const
<BR> void Fl_Menu_Item::argument(long)</A></H4>
For convenience you can also define the callback as taking a <TT>long</TT>
argument. This is implemented by casting this to a <TT>Fl_Callback</TT>
and casting the <TT>long</TT> to a <TT>void*</TT> and may not be
portable to some machines.
<H4><A name=Fl_Menu_Item.do_callback>void
Fl_Menu_Item::do_callback(Fl_Widget*)
<BR> void Fl_Menu_Item::do_callback(Fl_Widget*, void*)
<BR> void Fl_Menu_Item::do_callback(Fl_Widget*, long)</A></H4>
Call the <TT>Fl_Menu_Item</TT> item's callback, and provide the <TT>
Fl_Widget</TT> argument (and optionally override the user_data()
argument). You must first check that <TT>callback()</TT> is non-zero
before calling this.
<H4><A name=Fl_Menu_Item.shortcut>ulong Fl_Menu_Item::shortcut() const
<BR> void Fl_Menu_Item::shortcut(ulong)</A></H4>
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 <TT>
FL_ALT+'a'</TT> or <TT>FL_ALT+FL_F+10</TT> or just 'a'. A value of
zero disables the shortcut.
<P>The key can be any value returned by <A href="Fl.html#Fl.event_key">
<TT>Fl::event_key()</TT></A>, but will usually be an ASCII letter. Use
a lower-case letter unless you require the shift key to be held down. </P>
<P>The shift flags can be any set of values accepted by <A href="Fl.html#Fl.event_state">
<TT>Fl::event_state()</TT></A>. 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 &quot;don't care&quot;
setting). </P>
<H4><A name=Fl_Menu_Item.submenu>int Fl_Menu_Item::submenu() const</A></H4>
Returns true if either <TT>FL_SUBMENU</TT> or <TT>FL_SUBMENU_POINTER</TT>
is on in the flags. <TT>FL_SUBMENU</TT> indicates an embedded submenu
that goes from the next item through the next one with a <TT>NULL</TT>
<TT>label()</TT>. <TT>FL_SUBMENU_POINTER</TT> indicates that <TT>user_data()</TT>
is a pointer to another menu array.
<H4><A name=Fl_Menu_Item.checkbox>int Fl_Menu_Item::checkbox() const</A></H4>
Returns true if a checkbox will be drawn next to this item. This is
true if <TT>FL_MENU_TOGGLE</TT> or <TT>FL_MENU_RADIO</TT> is set in the
flags.
<H4><A name=Fl_Menu_Item.radio>int Fl_Menu_Item::radio() const</A></H4>
Returns true if this item is a radio item. When a radio button is
selected all &quot;adjacent&quot; radio buttons are turned off. A set of radio
items is delimited by an item that has <TT>radio()</TT> false, or by an
item with <TT>FL_MENU_DIVIDER</TT> turned on.
<H4><A name=Fl_Menu_Item.value>int Fl_Menu_Item::value() const</A></H4>
Returns the current value of the check or radio item.
<H4><A name=Fl_Menu_Item.set>void Fl_Menu_Item::set()</A></H4>
Turns the check or radio item &quot;on&quot; for the menu item. Note that this
does not turn off any adjacent radio items like <TT>set_only()</TT>
does.
<H4><A name=Fl_Menu_Item.setonly>void Fl_Menu_Item::setonly()</A></H4>
Turns the radio item &quot;on&quot; for the menu item and turns off adjacent
radio item.
<H4><A name=Fl_Menu_Item.clear>void Fl_Menu_Item::clear()</A></H4>
Turns the check or radio item &quot;off&quot; for the menu item.
<H4><A name=Fl_Menu_Item.visible>int Fl_Menu_Item::visible() const</A></H4>
Gets the visibility of an item.
<H4><A name=Fl_Menu_Item.show>void Fl_Menu_Item::show()</A></H4>
Makes an item visible in the menu.
<H4><A name=Fl_Menu_Item.hide>void Fl_Menu_Item::hide()</A></H4>
Hides an item in the menu.
<H4><A name=Fl_Menu_Item.active>int Fl_Menu_Item::active() const</A></H4>
Get whether or not the item can be picked.
<H4><A name=Fl_Menu_Item.activate>void Fl_Menu_Item::activate()</A></H4>
Allows a menu item to be picked.
<H4><A name=Fl_Menu_Item.deactivate>void Fl_Menu_Item::deactivate()</A></H4>
Prevents a menu item from being picked. Note that this will also cause
the menu item to appear grayed-out.
<H4><A name=Fl_Menu_Item.popup>const Fl_Menu_Item
*Fl_Menu_Item::popup(int X, int Y, const char* title = 0, const
Fl_Menu_Item* picked = 0, const Fl_Menu_* button = 0) const</A></H4>
This method is called by widgets that want to display menus. The menu
stays up until the user picks an item or dismisses it. The selected
item (or <TT>NULL</TT> if none) is returned. <I>This does not do the
callbacks or change the state of check or radio items.</I>
<P><TT>X,Y</TT> is the position of the mouse cursor, relative to the
window that got the most recent event (usually you can pass <TT>
Fl::event_x()</TT> and <TT>Fl::event_y()</TT> unchanged here). </P>
<P><TT>title</TT> is a character string title for the menu. If
non-zero a small box appears above the menu with the title in it. </P>
<P>The menu is positioned so the cursor is centered over the item <TT>
picked</TT>. This will work even if <TT>picked</TT> is in a submenu.
If <TT>picked</TT> is zero or not in the menu item table the menu is
positioned with the cursor in the top-left corner. </P>
<P><TT>button</TT> is a pointer to an <A href=Fl_Menu_.html#Fl_Menu_><TT>
Fl_Menu_</TT></A> from which the color and boxtypes for the menu are
pulled. If <TT>NULL</TT> then defaults are used. </P>
<H4><A name=Fl_Menu_Item.pulldown>const Fl_Menu_Item
*Fl_Menu_Item::pulldown(int X, int Y, int W, int H, const Fl_Menu_Item*
picked = 0, const Fl_Menu_* button = 0, const Fl_Menu_Item* title = 0,
int menubar=0) const</A></H4>
<TT>pulldown()</TT> is similar to <TT>popup()</TT>, but a rectangle is
provided to position the menu. The menu is made at least <TT>W</TT>
wide, and the <TT>picked</TT> item is centered over the rectangle
(like <TT>Fl_Choice</TT> uses). If <TT>picked</TT> is zero or not
found, the menu is aligned just below the rectangle (like a pulldown
menu).
<P>The <TT>title</TT> and <TT>menubar</TT> arguments are used
internally by the <TT>Fl_Menu_Bar</TT> widget. </P>
<H4><A name=Fl_Menu_Item.test_shortcut>const Fl_Menu_Item*
Fl_Menu_Item::test_shortcut() const</A></H4>
This is designed to be called by a widgets <TT>handle()</TT> method in
response to a <TT>FL_SHORTCUT</TT> event. If the current event matches
one of the items shortcut, that item is returned. If the keystroke
does not match any shortcuts then <TT>NULL</TT> is returned. This only
matches the <TT>shortcut()</TT> fields, not the letters in the title
preceeded by '
<H4><A name=Fl_Menu_Item.size>int Fl_Menu_Item::size()</A></H4>
Returns the number of Fl_Menu_Item structures that make up this menu,
correctly counting submenus. This includes the "terminator" item at
the end. So to copy a menu you need to copy
<tt>size()*sizeof(Fl_Menu_Item)</tt> bytes.
<H4><A name=Fl_Menu_Item.next>const Fl_Menu_Item*
Fl_Menu_Item::next(int n=1) const
<BR> Fl_Menu_Item* Fl_Menu_Item::next(int n=1);</A></H4>
Advance a pointer by <TT>n</TT> 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. </BODY></HTML>
documentation/Fl_Menu_Window.html
-49
View File
@@ -1,49 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Menu_Window</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Menu_Window>class Fl_Menu_Window</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Single_Window.html#Fl_Single_Window>Fl_Single_Window</A>
|
+----<B>Fl_Menu_Window</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Menu_Window.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Menu_Window</TT> 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.
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Menu_Window.Fl_Menu_Window>Fl_Menu_Window</A></LI>
<LI><A href=#Fl_Menu_Window.~Fl_Menu_Window>~Fl_Menu_Window</A></LI>
<LI><A href=#Fl_Menu_Window.clear_overlay>clear_overlay</A></LI>
<LI><A href=#Fl_Menu_Window.set_overlay>set_overlay</A></LI>
</UL>
<H4><A name=Fl_Menu_Window.Fl_Menu_Window>
Fl_Menu_Window::Fl_Menu_Window(int x, int y, int w, int h, const char
*label = 0)</A></H4>
Creates a new <TT>Fl_Menu_Window</TT> widget using the given position,
size, and label string.
<H4><A name=Fl_Menu_Window.~Fl_Menu_Window>virtual
Fl_Menu_Window::~Fl_Menu_Window()</A></H4>
Destroys the window and all of its children.
<H4><A name=Fl_Menu_Window.clear_overlay>
Fl_Menu_Window::clear_overlay();</A></H4>
Tells FLTK to use normal drawing planes instead of overlay planes.
This is usually necessary if your menu contains multi-color pixmaps.
<H4><A name=Fl_Menu_Window.set_overlay>Fl_Menu_Window::set_overlay()</A></H4>
Tells FLTK to use hardware overlay planes if they are available. </BODY>
</HTML>
documentation/Fl_Multi_Browser.html
-79
View File
@@ -1,79 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Multi_Browser</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Multi_Browser>class Fl_Multi_Browser</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Browser.html#Fl_Browser>Fl_Browser</A>
|
+----<B>Fl_Multi_Browser</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Multi_Browser.H&gt;
</PRE>
</UL>
<H3>Description</H3>
The <TT>Fl_Multi_Browser</TT> class is a subclass of <TT>Fl_Browser</TT>
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 shift + click toggles the items. This is different then how forms
did it. Normally the callback is done when the user releases the
mouse, but you can change this with <TT>when()</TT>.
<P>See <A href=Fl_Browser.html#Fl_Browser><TT>Fl_Browser</TT></A> for
methods to add and remove lines from the browser. </P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Multi_Browser.Fl_Multi_Browser>Fl_Multi_Browser</A></LI>
<LI><A href=#Fl_Multi_Browser.~Fl_Multi_Browser>~Fl_Multi_Browser</A></LI>
<LI><A href=#Fl_Multi_Browser.deselect>deselect</A></LI>
<LI><A href=#Fl_Multi_Browser.select>select</A></LI>
<LI><A href=#Fl_Multi_Browser.value>value</A></LI>
</UL>
<H4><A name=Fl_Multi_Browser.Fl_Multi_Browser>
Fl_Multi_Browser::Fl_Multi_Browser(int x, int y, int w, int h, const
char *label = 0)</A></H4>
Creates a new <TT>Fl_Multi_Browser</TT> widget using the given
position, size, and label string. The default boxtype is <TT>FL_DOWN_BOX</TT>
.
<H4><A name=Fl_Multi_Browser.~Fl_Multi_Browser>virtual
Fl_Multi_Browser::~Fl_Multi_Browser()</A></H4>
The destructor <I>also deletes all the items in the list</I>.
<H4><A name=Fl_Multi_Browser.deselect>int Fl_Browser::deselect()</A></H4>
Deselects all lines.
<H4><A name=Fl_Multi_Browser.select>int Fl_Browser::select(int line_no,int v=1)
<BR> int Fl_Browser::selected(int line_no) const</A></H4>
The first version of this call selects (v=1) or deselects (v=0)
a line in the browser. The second call returns the current selection
state of a line.
<H4><A name=Fl_Multi_Browser.value>void Fl_Browser::value(int)
<BR> int Fl_Browser::value() const</A></H4>
The first version of this call selects a single line. The second version returns
the currently focused item, even if it is not selected. To find all
selected items, call
<TT><A href=Fl_Multi_Browser.html#Fl_Multi_Browser.select>
Fl_Multi_Browser::selected()</A></TT> for every item in question.
</BODY></HTML>
documentation/Fl_Multiline_Input.html
-47
View File
@@ -1,47 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Multiline_Input</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Multiline_Input>class Fl_Multiline_Input</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Input.html#Fl_Input>Fl_Input</A>
|
+----<B>Fl_Multiline_Input</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Multiline_Input.H&gt;
</PRE>
</UL>
<H3>Description</H3>
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.
<P>This is far from the nirvana of text editors, and is probably only
good for small bits of text, 10 lines at most. I think FLTK can be
used to write a powerful text editor, but it is not going to be a
built-in feature. Powerful text editors in a toolkit are a big source
of bloat. </P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Multiline_Input.Fl_Multiline_Input>Fl_Multiline_Input</A>
</LI>
<LI><A href=#Fl_Multiline_Input.~Fl_Multiline_Input>~Fl_Multiline_Input</A>
</LI>
</UL>
<H4><A name=Fl_Multiline_Input.Fl_Multiline_Input>
Fl_Multiline_Input::Fl_Multiline_Input(int x, int y, int w, int h,
const char *label = 0)</A></H4>
Creates a new <TT>Fl_Multiline_Input</TT> widget using the given
position, size, and label string. The default boxtype is <TT>FL_DOWN_BOX</TT>
.
<H4><A name=Fl_Multiline_Input.~Fl_Multiline_Input>virtual
Fl_Multiline_Input::~Fl_Multiline_Input()</A></H4>
Destroys the widget and any value associated with it. </BODY></HTML>
documentation/Fl_Multiline_Output.html
-42
View File
@@ -1,42 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Multiline_Output</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Multiline_Output>class Fl_Multiline_Output</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Output.html#Fl_Output>Fl_Output</A>
|
+----<B>Fl_Multiline_Output</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Multiline_Output.H&gt;
</PRE>
</UL>
<H3>Description</H3>
This widget is a subclass of <TT>Fl_Output</TT> that displays multiple
lines of text. It also displays tab characters as whitespace to the
next column.
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Multiline_Output.Fl_Multiline_Output>Fl_Multiline_Output</A>
</LI>
<LI><A href=#Fl_Multiline_Output.~Fl_Multiline_Output>
~Fl_Multiline_Output</A></LI>
</UL>
<H4><A name=Fl_Multiline_Output.Fl_Multiline_Output>
Fl_Multiline_Output::Fl_Multiline_Output(int x, int y, int w, int h,
const char *label = 0)</A></H4>
Creates a new <TT>Fl_Multiline_Output</TT> widget using the given
position, size, and label string. The default boxtype is <TT>FL_DOWN_BOX</TT>
.
<H4><A name=Fl_Multiline_Output.~Fl_Multiline_Output>virtual
Fl_Multiline_Output::~Fl_Multiline_Output()</A></H4>
Destroys the widget and any value associated with it. </BODY></HTML>
documentation/Fl_Output.html
-83
View File
@@ -1,83 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Output</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_Output">class Fl_Output</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href="Fl_Input.html#Fl_Input">Fl_Input</A>
|
+----<B>Fl_Output</B>
|
+----<A href=Fl_Multiline_Output.html#Fl_Multiline_Output>Fl_Multiline_Output</A>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Output.H&gt;
</PRE>
</UL>
<H3>Description</H3>
This widget displays a piece of text. When you set the <TT>value()</TT>
, <TT>Fl_Output</TT> does a <TT>strcpy()</TT> to it's 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.
<CENTER><IMG src="text.gif" ALT="Fl_Output widget."></CENTER>
<P>There is a single subclass, <A href=Fl_Multiline_Output.html#Fl_Multiline_Output>
Fl_Multiline_Output</A>, which allows you to display multiple lines of
text. </P>
<P>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. </P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Output.Fl_Output>Fl_Output</A></LI>
<LI><A href=#Fl_Output.~Fl_Output>~Fl_Output</A></LI>
<LI><A href=#Fl_Output.index>index</A></LI>
<LI><A href=#Fl_Output.size>size</A></LI>
<LI><A href=#Fl_Output.textcolor>textcolor</A></LI>
<LI><A href=#Fl_Output.textfont>textfont</A></LI>
<LI><A href=#Fl_Output.textsize>textsize</A></LI>
<LI><A href=#Fl_Output.value>value</A></LI>
</UL>
<H4><A name=Fl_Output.Fl_Output>Fl_Output::Fl_Output(int x, int y, int
w, int h, const char *label = 0)</A></H4>
Creates a new <TT>Fl_Output</TT> widget using the given position,
size, and label string. The default boxtype is <TT>FL_DOWN_BOX</TT>.
<H4><A name=Fl_Output.~Fl_Output>virtual Fl_Output::~Fl_Output()</A></H4>
Destroys the widget and any value associated with it.
<H4><A name=Fl_Output.value>const char *Fl_Output::value() const
<BR> int Fl_Output::value(const char*)
<BR> int Fl_Output::value(const char*, int)</A></H4>
The first form returns the current value, which is a pointer to the
internal buffer and is valid only until the value is changed.
<P>The second two forms change the text and set the mark and the point
to the end of it. The string is copied to the internal buffer. Passing <TT>
NULL</TT> is the same as &quot;&quot;. This returns non-zero if the new value is
different than the current one. You can use the second version to
directly set the length if you know it already or want to put nul's in
the text. </P>
<H4><A name=Fl_Output.size>int Fl_Output::size() const</A></H4>
Returns the number of characters in <TT>value()</TT>. This may be
greater than <TT>strlen(value())</TT> if there are nul characters in
it.
<H4><A name=Fl_Output.index>char Fl_Output::index(int) const</A></H4>
Same as <TT>value()[n]</TT>, but may be faster in plausible
implementations. No bounds checking is done.
<H4><A name=Fl_Output.textcolor>Fl_Color Fl_Output::textcolor() const
<BR> void Fl_Output::textcolor(Fl_Color)</A></H4>
Gets or sets the color of the text in the input field.
<H4><A name=Fl_Output.textfont>Fl_Font Fl_Output::textfont() const
<BR> void Fl_Output::textfont(Fl_Font)</A></H4>
Gets or sets the font of the text in the input field.
<H4><A name=Fl_Output.textsize>uchar Fl_Output::textsize() const
<BR> void Fl_Output::textsize(uchar)</A></H4>
Gets or sets the size of the text in the input field. </BODY></HTML>
documentation/Fl_Overlay_Window.html
-59
View File
@@ -1,59 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_Overlay_Window</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name=Fl_Overlay_Window>class Fl_Overlay_Window</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL>
<PRE>
<A href=Fl_Double_Window.html#Fl_Double_Window>Fl_Double_Window</A>
|
+----<B>Fl_Overlay_Window</B>
</PRE>
</UL>
<H3>Include Files</H3>
<UL>
<PRE>
#include &lt;FL/Fl_Overlay_Window.H&gt;
</PRE>
</UL>
<H3>Description</H3>
This window provides double buffering and also the ability to draw the
&quot;overlay&quot; 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. <TT>Fl_Overlay_Window</TT> 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
&quot;erased&quot; by copying the backbuffer over it again. This means the
overlay will blink if you change the image in the window. </P>
<H3>Methods</H3>
<UL>
<LI><A href=#Fl_Overlay_Window.Fl_Overlay_Window>Fl_Overlay_Window</A></LI>
<LI><A href=#Fl_Overlay_Window.~Fl_Overlay_Window>~Fl_Overlay_Window</A></LI>
<LI><A href=#Fl_Overlay_Window.draw_overlay>draw_overlay</A></LI>
<LI><A href=#Fl_Overlay_Window.redraw_overlay>redraw_overlay</A></LI>
</UL>
<H4><A name=Fl_Overlay_Window.Fl_Overlay_Window>
Fl_Overlay_Window::Fl_Overlay_Window(int x, int y, int w, int h, const
char *label = 0)</A></H4>
Creates a new <TT>Fl_Overlay_Window</TT> widget using the given
position, size, and label (title) string.
<H4><A name=Fl_Overlay_Window.~Fl_Overlay_Window>virtual
Fl_Overlay_Window::~Fl_Overlay_Window()</A></H4>
Destroys the window and all child widgets.
<H4><A name=Fl_Overlay_Window.draw_overlay>virtual void
Fl_Overlay_Window::draw_overlay() = 0</A></H4>
You must subclass <TT>Fl_Overlay_Window</TT> and provide this method.
It is just like a <TT>draw()</TT> method, except it draws the overlay.
The overlay will have already been &quot;cleared&quot; when this is called. You
can use any of the routines described in <A href="drawing.html#drawing">&lt;FL/fl_draw.H&gt;</A>.
<H4><A name=Fl_Overlay_Window.redraw_overlay>void Fl_Overlay_Window::redraw_overlay()</A>
</H4>
Call this to indicate that the overlay data has changed and needs to
be redrawn. The overlay will be clear until the first time this is
called, so if you want an initial display you must call this after
calling <TT>show()</TT>. </BODY></HTML>
documentation/Fl_PNG_Image.html
-59
View File
@@ -1,59 +0,0 @@
<HTML>
<HEAD>
<TITLE>Fl_PNG_Image</TITLE>
</HEAD>
<BODY>
<!-- NEW PAGE -->
<H2><A name="Fl_PNG_Image">class Fl_PNG_Image</A></H2>
<HR>
<H3>Class Hierarchy</H3>
<UL><PRE>
<A href="Fl_RGB_Image.html">Fl_RGB_Image</A>
|
+----<B>Fl_PNG_Image</B>
</PRE></UL>
<H3>Include Files</H3>
<UL><PRE>
#include &lt;FL/Fl_PNG_Image.H&gt;
</PRE></UL>
<H3>Additional Libraries</H3>
<UL><PRE>
-lfltk_images / fltkimages.lib
</PRE></UL>
<H3>Description</H3>
<P>The <TT>Fl_PNG_Image</TT> 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.</P>
<H3>Methods</H3>
<UL>
<LI><A href="#Fl_PNG_Image.Fl_PNG_Image">Fl_PNG_Image</A></LI>
<LI><A href="#Fl_PNG_Image.~Fl_PNG_Image">~Fl_PNG_Image</A></LI>
</UL>
<H4><A name="Fl_PNG_Image.Fl_PNG_Image">Fl_PNG_Image::Fl_PNG_Image(const char *filename);</A></H4>
<P>The constructor loads the named PNG image.</P>
<H4><A name="Fl_PNG_Image.~Fl_PNG_Image">Fl_PNG_Image::~Fl_PNG_Image();</A></H4>
<P>The destructor free all memory and server resources that are used by
the image.</P>
</BODY>
</HTML>

Some files were not shown because too many files have changed in this diff Show More