10 - Advanced FLTK
This chapter explains advanced programming and design topics that will help you to get the most out of FLTK.
Multithreading
FLTK supports multithreaded application using a locking mechanism based on "pthreads". We do not provide a threading interface as part of the library. However a simple example how threads can be implemented for all supported platforms can be found in test/threads.h and test/threads.cxx.
To use the locking mechanism, FLTK must be compiled with --enable-threads set during the configure process. IDE-based versions of FLTK are automatically compiled with locking enabled if possible.
In main(), call Fl::lock() before Fl::run() or Fl::wait() to start the runtime multithreading support for your program. All callbacks and derived functions like handle() and draw() will now be properly locked:
int main() {
Fl::lock();
/* run thread */
while (Fl::wait() > 0) {
if (Fl::thread_message()) {
/* process your data */
}
}
}
You can now start as many threads as you like. From within a thread (other than the main thread) FLTK calls must be wrapped with calls to Fl::lock() and Fl::unlock():
Fl::lock(); // avoid conflicting calls
... // your code here
Fl::unlock(); // allow other threads to access FLTK again
You can send messages from child threads to the main thread using Fl::awake(msg):
void *msg; // "msg" is a pointer to your message
Fl::awake(msg); // send "msg" to main thread
You can also tell the main thread to call a function for you as soon as possible by using Fl::awake(callback, userdata):
void do_something(void *userdata) {
// running with the main thread
}
// running in another thread
void *data; // "data" is a pointer to your user data
Fl::awake(do_something, data); // call something in main thread
FLTK supports multiple platforms, some of them which do not allow any other but the main thread to handle system events and open or close windows. The safe thing to do is to adhere to the following rules for threads on all operating systems:
- Don't show() or hide()anything that contains widgets derived from Fl_Window, including dialogs, file choosers, subwindows or Fl_GL_Windows
- Don't call Fl::wait(), Fl::flush() or any related methods that will handle system messages
- Don't start or cancel timers
- Don't change window decorations or titles
- The make_current() method may or may not work well for regular windows, but should always work for Fl_GL_Windows to allow for high speed rendering on graphics cards with multiple pipelines
See also: void awake(void *message), void lock(), void *thread_message(), void unlock(). fltk-1.1.10/documentation/basics.html 0000644 0000765 0000000 00000032107 11110073653 016360 0 ustar matt wheel
2 - FLTK Basics
This chapter teaches you the basics of compiling programs that use FLTK.
Writing Your First FLTK Program
All programs must include the file <FL/Fl.H>. In addition the program must include a header file for each FLTK class it uses. Listing 1 shows a simple "Hello, World!" program that uses FLTK to display the window.
Listing 1 - "hello.cxx"
#include <FL/Fl.H>
#include <FL/Fl_Window.H>
#include <FL/Fl_Box.H>
int main(int argc, char **argv) {
Fl_Window *window = new Fl_Window(300,180);
Fl_Box *box = new Fl_Box(20,40,260,100,"Hello, World!");
box->box(FL_UP_BOX);
box->labelsize(36);
box->labelfont(FL_BOLD+FL_ITALIC);
box->labeltype(FL_SHADOW_LABEL);
window->end();
window->show(argc, argv);
return Fl::run();
}
After including the required header files, the program then creates a window. All following widgets will automatically be children of this window.
Fl_Window *window = new Fl_Window(300,180);
Then we create a box with the "Hello, World!" string in it. FLTK automatically adds the new box to window, the current grouping widget.
Fl_Box *box = new Fl_Box(20,40,260,100,"Hello, World!");
Next, we set the type of box and the size, font, and style of the label:
box->box(FL_UP_BOX); box->labelsize(36); box->labelfont(FL_BOLD+FL_ITALIC); box->labeltype(FL_SHADOW_LABEL);
We tell FLTK that we will not add any more widgets to window.
window->end();
Finally, we show the window and enter the FLTK event loop:
window->show(argc, argv); return Fl::run();
The resulting program will display the window in Figure 2-1. You can quit the program by closing the window or pressing the ESCape key.
Figure 2-1: The Hello, World! Window
Creating the Widgets
The widgets are created using the C++ new operator. For most widgets the arguments to the constructor are:
Fl_Widget(x, y, width, height, label)
The x and y parameters determine where the widget or window is placed on the screen. In FLTK the top left corner of the window or screen is the origin (i.e. x = 0, y = 0) and the units are in pixels.
The width and height parameters determine the size of the widget or window in pixels. The maximum widget size is typically governed by the underlying window system or hardware.
label is a pointer to a character string to label the widget with or NULL. If not specified the label defaults to NULL. The label string must be in static storage such as a string constant because FLTK does not make a copy of it - it just uses the pointer.
Creating Widget hierarchies
Widgets are commonly ordered into functional groups, which in turn may be grouped again, creating a hierarchy of widgets. FLTK makes it easy to fill groups by automatically adding all widgets that are created between a myGroup->begin() and myGroup->end(). In this example, myGroup would be the current group.
Newly created groups and their derived widgets implicitly call begin() in the constructor, effectively adding all subsequently created widgets to itself until end() is called.
Setting the current group to NULL will stop automatic hierarchies. New widgets can now be added manually using Fl_Group::add(...) and Fl_Group::insert(...).
Get/Set Methods
box->box(FL_UP_BOX) sets the type of box the Fl_Box draws, changing it from the default of FL_NO_BOX, which means that no box is drawn. In our "Hello, World!" example we use FL_UP_BOX, which means that a raised button border will be drawn around the widget. You can learn more about boxtypes in Chapter 3.
You could examine the boxtype in by doing box->box(). FLTK uses method name overloading to make short names for get/set methods. A "set" method is always of the form "void name(type)", and a "get" method is always of the form "type name() const".
Redrawing After Changing Attributes
Almost all of the set/get pairs are very fast, short inline functions and thus very efficient. However, the "set" methods do not call redraw() - you have to call it yourself. This greatly reduces code size and execution time. The only common exceptions are value() which calls redraw() and label() which calls redraw_label() if necessary.
Labels
All widgets support labels. In the case of window widgets, the label is used for the label in the title bar. Our example program calls the labelfont, labelsize, and labeltype methods.
The labelfont method sets the typeface and style that is used for the label, which for this example we are using FL_BOLD and FL_ITALIC. You can also specify typefaces directly.
The labelsize method sets the height of the font in pixels.
The labeltype method sets the type of label. FLTK supports normal, embossed, and shadowed labels internally, and more types can be added as desired.
A complete list of all label options can be found in Chapter 3.
Showing the Window
The show() method shows the widget or window. For windows you can also provide the command-line arguments to allow users to customize the appearance, size, and position of your windows.
The Main Event Loop
All FLTK applications (and most GUI applications in general) are based on a simple event processing model. User actions such as mouse movement, button clicks, and keyboard activity generate events that are sent to an application. The application may then ignore the events or respond to the user, typically by redrawing a button in the "down" position, adding the text to an input field, and so forth.
FLTK also supports idle, timer, and file pseudo-events that cause a function to be called when they occur. Idle functions are called when no user input is present and no timers or files need to be handled - in short, when the application is not doing anything. Idle callbacks are often used to update a 3D display or do other background processing.
Timer functions are called after a specific amount of time has expired. They can be used to pop up a progress dialog after a certain amount of time or do other things that need to happen at more-or-less regular intervals. FLTK timers are not 100% accurate, so they should not be used to measure time intervals, for example.
File functions are called when data is ready to read or write, or when an error condition occurs on a file. They are most often used to monitor network connections (sockets) for data-driven displays.
FLTK applications must periodically check (Fl::check()) or wait (Fl::wait()) for events or use the Fl::run() method to enter a standard event processing loop. Calling Fl::run() is equivalent to the following code:
while (Fl::wait());
Fl::run() does not return until all of the windows under FLTK control are closed by the user or your program.
Compiling Programs with Standard Compilers
Under UNIX (and under Microsoft Windows when using the GNU development tools) you will probably need to tell the compiler where to find the header files. This is usually done using the -I option:
CC -I/usr/local/include ... gcc -I/usr/local/include ...
The fltk-config script included with FLTK can be used to get the options that are required by your compiler:
CC `fltk-config --cxxflags` ...
Similarly, when linking your application you will need to tell the compiler to use the FLTK library:
CC ... -L/usr/local/lib -lfltk -lXext -lX11 -lm gcc ... -L/usr/local/lib -lfltk -lXext -lX11 -lm
Aside from the "fltk" library, there is also a "fltk_forms"
library for the XForms compatibility classes, "fltk_gl" for the
OpenGL and GLUT classes, and "fltk_images" for the image file
classes, Fl_Help_Dialog
widget, and system icon support.
| Note:
The libraries are named "fltk.lib", "fltkgl.lib", "fltkforms.lib", and "fltkimages.lib", respectively under Windows. |
As before, the fltk-config script included with FLTK can be used to get the options that are required by your linker:
CC ... `fltk-config --ldflags`
The forms, GL, and images libraries are included with the "--use-foo" options, as follows:
CC ... `fltk-config --use-forms --ldflags` CC ... `fltk-config --use-gl --ldflags` CC ... `fltk-config --use-images --ldflags` CC ... `fltk-config --use-forms --use-gl --use-images --ldflags`
Finally, you can use the fltk-config script to compile a single source file as a FLTK program:
fltk-config --compile filename.cpp fltk-config --use-forms --compile filename.cpp fltk-config --use-gl --compile filename.cpp fltk-config --use-images --compile filename.cpp fltk-config --use-forms --use-gl --use-images --compile filename.cpp
Any of these will create an executable named filename.
Compiling Programs with Microsoft Visual C++
In Visual C++ you will need to tell the compiler where to find the FLTK header files. This can be done by selecting "Settings" from the "Project" menu and then changing the "Preprocessor" settings under the "C/C++" tab. You will also need to add the FLTK (FLTK.LIB or FLTKD.LIB), the Windows Common Controls (COMCTRL32.LIB), and WinSock (WSOCK32.LIB) libraries to the "Link" settings.
You can build your Microsoft Windows applications as Console or WIN32 applications. If you want to use the standard C main() function as the entry point, FLTK includes a WinMain() function that will call your main() function for you.
Note: The Visual C++ 5.0 optimizer is known to cause problems with many programs. We only recommend using the "Favor Small Code" optimization setting. The Visual C++ 6.0 optimizer seems to be much better and can be used with the "optimized for speed" setting.
Naming
All public symbols in FLTK start with the characters 'F' and 'L':
- Functions are either Fl::foo() or fl_foo().
- Class and type names are capitalized: Fl_Foo.
- Constants and enumerations are uppercase: FL_FOO.
- All header files start with <FL/...>.
Header Files
The proper way to include FLTK header files is:
#include <FL/Fl_xyz.H>
| Note:
Case is significant on many operating systems, and the C standard uses the forward slash (/) to separate directories. Do not use any of the following include lines: #include <FL\Fl_xyz.H> #include <fl/fl_xyz.h> #include <Fl/fl_xyz.h> |
3 - Common Widgets and Attributes
This chapter describes many of the widgets that are provided with FLTK and covers how to query and set the standard attributes.
Buttons
FLTK provides many types of buttons:
- Fl_Button - A standard push button.
- Fl_Check_Button - A button with a check box.
- Fl_Light_Button - A push button with a light.
- Fl_Repeat_Button - A push button that repeats when held.
- Fl_Return_Button - A push button that is activated by the Enter key.
- Fl_Round_Button - A button with a radio circle.
Figure 3-1: FLTK Button Widgets
All of these buttons just need the corresponding <FL/Fl_xyz_Button.H> header file. The constructor takes the bounding box of the button and optionally a label string:
Fl_Button *button = new Fl_Button(x, y, width, height, "label"); Fl_Light_Button *lbutton = new Fl_Light_Button(x, y, width, height); Fl_Round_Button *rbutton = new Fl_Round_Button(x, y, width, height, "label");
Each button has an associated type() which allows it to behave as a push button, toggle button, or radio button:
button->type(FL_NORMAL_BUTTON); lbutton->type(FL_TOGGLE_BUTTON); rbutton->type(FL_RADIO_BUTTON);
For toggle and radio buttons, the value() method returns the current button state (0 = off, 1 = on). The set() and clear() methods can be used on toggle buttons to turn a toggle button on or off, respectively. Radio buttons can be turned on with the setonly() method; this will also turn off other radio buttons in the same group.
Text
FLTK provides several text widgets for displaying and receiving text:
- Fl_Input - A one-line text input field.
- Fl_Output - A one-line text output field.
- Fl_Multiline_Input - A multi-line text input field.
- Fl_Multiline_Output - A multi-line text output field.
- Fl_Text_Display - A multi-line text display widget.
- Fl_Text_Editor - A multi-line text editing widget.
- Fl_Help_View - A HTML text display widget.
The Fl_Output and Fl_Multiline_Output widgets allow the user to copy text from the output field but not change it.
The value() method is used to get or set the string that is displayed:
Fl_Input *input = new Fl_Input(x, y, width, height, "label");
input->value("Now is the time for all good men...");
The string is copied to the widget's own storage when you set the value() of the widget.
The Fl_Text_Display and Fl_Text_Editor widgets use an associated Fl_Text_Buffer class for the value, instead of a simple string.
Valuators
Unlike text widgets, valuators keep track of numbers instead of strings. FLTK provides the following valuators:
- Fl_Counter - A widget with arrow buttons that shows the current value.
- Fl_Dial - A round knob.
- Fl_Roller - An SGI-like dolly widget.
- Fl_Scrollbar - A standard scrollbar widget.
- Fl_Slider - A scrollbar with a knob.
- Fl_Value_Slider - A slider that shows the current value.
Figure 3-2: FLTK valuator widgets
The value() method gets and sets the current value of the widget. The minimum() and maximum() methods set the range of values that are reported by the widget.
Groups
The Fl_Group widget class is used as a general purpose "container" widget. Besides grouping radio buttons, the groups are used to encapsulate windows, tabs, and scrolled windows. The following group classes are available with FLTK:
- Fl_Double_Window - A double-buffered window on the screen.
- Fl_Gl_Window - An OpenGL window on the screen.
- Fl_Group - The base container class; can be used to group any widgets together.
- Fl_Pack - A collection of widgets that are packed into the group area.
- Fl_Scroll - A scrolled window area.
- Fl_Tabs - Displays child widgets as tabs.
- Fl_Tile - A tiled window area.
- Fl_Window - A window on the screen.
Setting the Size and Position of Widgets
The size and position of widgets is usually set when you create them. You can access them with the x(), y(), w(), and h() methods.
You can change the size and position by using the position(), resize(), and size() methods:
button->position(x, y); group->resize(x, y, width, height); window->size(width, height);
If you change a widget's size or position after it is displayed you will have to call redraw() on the widget's parent.
Colors
FLTK stores the colors of widgets as an 32-bit unsigned number that is either an index into a color palette of 256 colors or a 24-bit RGB color. The color palette is not the X or WIN32 colormap, but instead is an internal table with fixed contents.
There are symbols for naming some of the more common colors:
- FL_BLACK
- FL_RED
- FL_GREEN
- FL_YELLOW
- FL_BLUE
- FL_MAGENTA
- FL_CYAN
- FL_WHITE
These symbols are the default colors for all FLTK widgets. They are explained in more detail in the chapter Enumerations
- FL_FOREGROUND_COLOR
- FL_BACKGROUND_COLOR
- FL_INACTIVE_COLOR
- FL_SELECTION_COLOR
RGB colors can be set using the fl_rgb_color() function:
Fl_Color c = fl_rgb_color(85, 170, 255);
The widget color is set using the color() method:
button->color(FL_RED);
Similarly, the label color is set using the labelcolor() method:
button->labelcolor(FL_WHITE);
Box Types
The type Fl_Boxtype stored and returned in Fl_Widget::box() is an enumeration defined in <Enumerations.H>. Figure 3-3 shows the standard box types included with FLTK.
Figure 3-3: FLTK box types
FL_NO_BOX means nothing is drawn at all, so whatever is already on the screen remains. The FL_..._FRAME types only draw their edges, leaving the interior unchanged. The blue color in Figure 3-3 is the area that is not drawn by the frame types.
Making Your Own Boxtypes
You can define your own boxtypes by making a small function that draws the box and adding it to the table of boxtypes.
| Note:
This interface has changed in FLTK 2.0! |
The Drawing Function
The drawing function is passed the bounding box and background color for the widget:
void xyz_draw(int x, int y, int w, int h, Fl_Color c) {
...
}
A simple drawing function might fill a rectangle with the given color and then draw a black outline:
void xyz_draw(int x, int y, int w, int h, Fl_Color c) {
fl_color(c);
fl_rectf(x, y, w, h);
fl_color(FL_BLACK);
fl_rect(x, y, w, h);
}
Fl_Boxtype fl_down(Fl_Boxtype)
fl_down returns the "pressed" or "down" version of a box. If no "down" version of a given box exists, the behavior of this function is undefined and some random box or frame is returned. See also: fl_frame drawing.
Fl_Boxtype fl_frame(Fl_Boxtype)
fl_frame returns the unfilled, frame-only version of a box. If no frame version of a given box exists, the behavior of this function is undefined and some random box or frame is returned. See also: fl_frame drawing.
Fl_Boxtype fl_box(Fl_Boxtype)
fl_box returns the filled version of a frame. If no filled version of a given frame exists, the behavior of this function is undefined and some random box or frame is returned. See also: fl_frame.
Adding Your Box Type
The Fl::set_boxtype() method adds or replaces the specified box type:
#define XYZ_BOX FL_FREE_BOXTYPE Fl::set_boxtype(XYZ_BOX, xyz_draw, 1, 1, 2, 2);
The last 4 arguments to Fl::set_boxtype() are the offsets for the x, y, width, and height values that should be subtracted when drawing the label inside the box.
A complete box design contains four box types in this order: a filled, neutral box (UP_BOX), a filled, depressed box (DOWN_BOX), and the same as outlines only (UP_FRAME and DOWN_FRAME). The function fl_down(Fl_Boxtype) expects the neutral design on a boxtype with a numerical value evenly dividable by two. fl_frame(Fl_Boxtype) expects the UP_BOX design at a value dividable by four.
Labels and Label Types
The label(), align(), labelfont(), labelsize(), labeltype(), image(), and deimage() methods control the labeling of widgets.
label()
The label() method sets the string that is displayed for the label. Symbols can be included with the label string by escaping them using the "@" symbol - "@@" displays a single at sign. Figure 3-4 shows the available symbols.
Figure 3-4: FLTK label symbols
The @ sign may also be followed by the following optional "formatting" characters, in this order:
- '#' forces square scaling, rather than distortion to the widget's shape.
- +[1-9] or -[1-9] tweaks the scaling a little bigger or smaller.
- '$' flips the symbol horizontally, '%' flips it vertically.
- [0-9] - rotates by a multiple of 45 degrees. '5' and '6' do no rotation while the others point in the direction of that key on a numeric keypad. '0', followed by four more digits rotates the symbol by that amount in degrees.
Thus, to show a very large arrow pointing downward you would use the label string "@+92->".
align()
The align() method positions the label. The following constants are defined and may be OR'd together as needed:
- FL_ALIGN_CENTER - center the label in the widget.
- FL_ALIGN_TOP - align the label at the top of the widget.
- FL_ALIGN_BOTTOM - align the label at the bottom of the widget.
- FL_ALIGN_LEFT - align the label to the left of the widget.
- FL_ALIGN_RIGHT - align the label to the right of the widget.
- FL_ALIGN_INSIDE - align the label inside the widget.
- FL_ALIGN_CLIP - clip the label to the widget's bounding box.
- FL_ALIGN_WRAP - wrap the label text as needed.
- FL_TEXT_OVER_IMAGE - show the label text over the image.
- FL_IMAGE_OVER_TEXT - show the label image over the text (default).
labeltype()
The labeltype() method sets the type of the label. The following standard label types are included:
- FL_NORMAL_LABEL - draws the text.
- FL_NO_LABEL - does nothing.
- FL_SHADOW_LABEL - draws a drop shadow under the text.
- FL_ENGRAVED_LABEL - draws edges as though the text is engraved.
- FL_EMBOSSED_LABEL - draws edges as thought the text is raised.
- FL_ICON_LABEL - draws the icon associated with the text.
image() and deimage()
The image() and deimage() methods set an image that will be displayed with the widget. The deimage() method sets the image that is shown when the widget is inactive, while the image() method sets the image that is shown when the widget is active.
To make an image you use a subclass of Fl_Image.
Making Your Own Label Types
Label types are actually indexes into a table of functions that draw them. The primary purpose of this is to use this to draw the labels in ways inaccessible through the fl_font mechanism (e.g. FL_ENGRAVED_LABEL) or with program-generated letters or symbology.
| Note:
This interface has changed in FLTK 2.0! |
Label Type Functions
To setup your own label type you will need to write two functions: one to draw and one to measure the label. The draw function is called with a pointer to a Fl_Label structure containing the label information, the bounding box for the label, and the label alignment:
void xyz_draw(const Fl_Label *label, int x, int y, int w, int h, Fl_Align align) {
...
}
The label should be drawn inside this bounding box, even if FL_ALIGN_INSIDE is not enabled. The function is not called if the label value is NULL.
The measure function is called with a pointer to a Fl_Label structure and references to the width and height:
void xyz_measure(const Fl_Label *label, int &w, int &h) {
...
}
The function should measure the size of the label and set w and h to the size it will occupy.
Adding Your Label Type
The Fl::set_labeltype method creates a label type using your draw and measure functions:
#define XYZ_LABEL FL_FREE_LABELTYPE Fl::set_labeltype(XYZ_LABEL, xyz_draw, xyz_measure);
The label type number n can be any integer value starting at the constant FL_FREE_LABELTYPE. Once you have added the label type you can use the labeltype() method to select your label type.
The Fl::set_labeltype method can also be used to overload an existing label type such as FL_NORMAL_LABEL.
Making your own symbols
It is also possible to define your own drawings and add them to the symbol list, so they can be rendered as part of any label.
To create a new symbol, you implement a drawing function void drawit(Fl_Color c) which typically uses the complex drawing functions to generate a vector shape inside a two-by-two units sized box around the origin. This function is then linked into the symbols table using fl_add_symbol:
int fl_add_symbol(const char *name, void (*drawit)(Fl_Color), int scalable)
name is the name of the symbol without the "@"; scalable must be set to 1 if the symbol is generated using scalable vector drawing functions.
int fl_draw_symbol(const char *name,int x,int y,int w,int h,Fl_Color col)
This function draw a named symbol fitting the given rectangle.
Callbacks
Callbacks are functions that are called when the value of a widget changes. A callback function is sent a Fl_Widget pointer of the widget that changed and a pointer to data that you provide:
void xyz_callback(Fl_Widget *w, void *data) {
...
}
The callback() method sets the callback function for a widget. You can optionally pass a pointer to some data needed for the callback:
int xyz_data; button->callback(xyz_callback, &xyz_data);
Normally callbacks are performed only when the value of the widget changes. You can change this using the when() method:
button->when(FL_WHEN_NEVER); button->when(FL_WHEN_CHANGED); button->when(FL_WHEN_RELEASE); button->when(FL_WHEN_RELEASE_ALWAYS); button->when(FL_WHEN_ENTER_KEY); button->when(FL_WHEN_ENTER_KEY_ALWAYS); button->when(FL_WHEN_CHANGED | FL_WHEN_NOT_CHANGED);
| Note:
You cannot delete a widget inside a callback, as the widget may still be accessed by FLTK after your callback is completed. Instead, use the Fl::delete_widget() method to mark your widget for deletion when it is safe to do so. Hint: Many programmers new to FLTK or C++ try to use a non-static class method instead of a static class method or function for their callback. Since callbacks are done outside a C++ class, the this pointer is not initialized for class methods. To work around this problem, define a static method in your class that accepts a pointer to the class, and then have the static method call the class method(s) as needed. The data pointer you provide to the callback() method of the widget can be a pointer to the instance of your class.
class Foo {
void my_callback(Fl_Widget *w);
static void my_static_callback(Fl_Widget *w, void *f) { ((Foo *)f)->my_callback(w); }
...
}
...
w->callback(my_static_callback, (void *)this);
|
Shortcuts
Shortcuts are key sequences that activate widgets such as buttons or menu items. The shortcut() method sets the shortcut for a widget:
button->shortcut(FL_Enter); button->shortcut(FL_SHIFT + 'b'); button->shortcut(FL_CTRL + 'b'); button->shortcut(FL_ALT + 'b'); button->shortcut(FL_CTRL + FL_ALT + 'b'); button->shortcut(0); // no shortcut
The shortcut value is the key event value - the ASCII value or one of the special keys like FL_Enter - combined with any modifiers like Shift, Alt, and Control.
fltk-1.1.10/documentation/counter.gif 0000644 0000765 0000000 00000003527 10332207117 016377 0 ustar matt wheel GIF89aÒ s ã úúúÜÜÜ èè躺ºÿÿÿÏÏÏÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ!ù , Ò s @þÈI«½8ëÍ»ÿ`(Ž$hª®lë¾0< í,Ó¯m£»°Ï4 çÃý€Ä˜rÉŒ™LͨtJZ¯Ø¬3 Õz¿à°xüzž”B.9Téeoõ~îø¼~Ïïûÿ€wq5l.o…m+st‡-fKŠH”•I‰j,–u Ÿx¢£y¤ ƒŠŒ–-˜*››)oK‘h™V¯Wž¨½¾¿{ª¸Uº¹œ+¶dÊËÌÍËÉÎÑÒÓÔ.Ð/«`¼ÀÜÝÞßxÂd´J×.Ù.1ÛàÜH|ïíÝâ7”Lä[]1è†öëväý:%ª )Àèñ§ s-øia‡°¢Å_ Ã8,ÃåLµ&þB|,äA2I‘(‡5 - Drawing Things in FLTK
This chapter covers the drawing functions that are provided with FLTK.
When Can You Draw Things in FLTK?
There are only certain places you can execute drawing code in FLTK. Calling these functions at other places will result in undefined behavior!
- The most common place is inside the virtual method Fl_Widget::draw(). To write code here, you must subclass one of the existing Fl_Widget classes and implement your own version of draw().
- You can also write boxtypes and labeltypes. These are small procedures that can be called by existing Fl_Widget::draw() methods. These "types" are identified by an 8-bit index that is stored in the widget's box(), labeltype(), and possibly other properties.
- You can call Fl_Window::make_current() to do incremental update of a widget. Use Fl_Widget::window() to find the window.
FLTK Drawing Functions
To use the drawing functions you must first include the <FL/fl_draw.H> header file. FLTK provides the following types of drawing functions:
- Boxes
- Clipping
- Colors
- Line dashes and thickness
- Fast Shapes
- Complex Shapes
- Text
- Images
- Overlay
- Offscreen Drawing
Boxes
FLTK provides three functions that can be used to draw boxes for buttons and other UI controls. Each function uses the supplied upper-lefthand corner and width and height to determine where to draw the box.
void fl_draw_box(Fl_Boxtype b, int x, int y, int w, int h, Fl_Color c);
The first box drawing function is fl_draw_box()
which draws a standard boxtype c in the specified
color c.
void fl_frame(const char *s, int x, int y, int w, int h);
The fl_frame() function draws a series of line
segments around the given box. The string s must
contain groups of 4 letters which specify one of 24 standard
grayscale values, where 'A' is black and 'X' is white. The order
of each set of 4 characters is: top, left, bottom, right. The
results of calling fl_frame() with a string that is
not a multiple of 4 characters in length are undefined.
The only difference between this function and
fl_frame2() is the order of the line segments.
See also: fl_frame boxtype.
void fl_frame2(const char *s, int x, int y, int w, int h);
The fl_frame2() function draws a series of line
segments around the given box. The string s must
contain groups of 4 letters which specify one of 24 standard
grayscale values, where 'A' is black and 'X' is white. The order
of each set of 4 characters is: bottom, right, top, left. The
results of calling fl_frame2() with a string that is
not a multiple of 4 characters in length are undefined.
The only difference between this function and
fl_frame() is the order of the line segments.
Clipping
You can limit all your drawing to a rectangular region by calling fl_push_clip, and put the drawings back by using fl_pop_clip. This rectangle is measured in pixels and is unaffected by the current transformation matrix.
In addition, the system may provide clipping when updating windows which may be more complex than a simple rectangle.
void fl_clip(int x, int y, int w, int h)
void fl_push_clip(int x, int y, int w, int h)
Intersect the current clip region with a rectangle and push this new
region onto the stack. The fl_clip() name is deprecated and
will be removed from future releases.
void fl_push_no_clip()
Pushes an empty clip region on the stack so nothing will be clipped.
void fl_pop_clip()
Restore the previous clip region.
| Note:
You must call fl_pop_clip() once for every time you call fl_push_clip(). If you return to FLTK with the clip stack not empty unpredictable results occur. |
int fl_not_clipped(int x, int y, int w, int h)
Returns non-zero if any of the rectangle intersects the current clip region. If this returns 0 you don't have to draw the object.
| Note:
Under X this returns 2 if the rectangle is partially clipped, and 1 if it is entirely inside the clip region. |
int fl_clip_box(int x, int y, int w, int h, int &X, int &Y, int &W, int &H)
Intersect the rectangle x,y,w,h with the current clip region and returns the bounding box of the result in X,Y,W,H. Returns non-zero if the resulting rectangle is different than the original. This can be used to limit the necessary drawing to a rectangle. W and H are set to zero if the rectangle is completely outside the region.
void fl_clip_region(Fl_Region r)
Fl_Region fl_clip_region()
Replace the top of the clip stack with a clipping region of any shape. Fl_Region is an operating system specific type. The second form returns the current clipping region.
Colors
FLTK manages colors as 32-bit unsigned integers. Values from 0 to 255 represent colors from the FLTK 1.0.x standard colormap and are allocated as needed on screens without TrueColor support. The Fl_Color enumeration type defines the standard colors and color cube for the first 256 colors. All of these are named with symbols in <FL/Enumerations.H>.
Color values greater than 255 are treated as 24-bit RGB values. These are mapped to the closest color supported by the screen, either from one of the 256 colors in the FLTK 1.0.x colormap or a direct RGB value on TrueColor screens. You can generate 24-bit RGB color values using the fl_rgb_color() function.
void fl_color(Fl_Color)
Sets the color for all subsequent drawing operations.
For colormapped displays, a color cell will be allocated out of fl_colormap the first time you use a color. If the colormap fills up then a least-squares algorithm is used to find the closest color.
Fl_Color fl_color()
Returns the last fl_color() that was set. This can be used for state save/restore.
void fl_color(uchar r, uchar g, uchar b)
Set the color for all subsequent drawing operations. The closest possible match to the RGB color is used. The RGB color is used directly on TrueColor displays. For colormap visuals the nearest index in the gray ramp or color cube is used.
Line Dashes and Thickness
FLTK supports drawing of lines with different styles and widths. Full functionality is not available under Windows 95, 98, and Me due to the reduced drawing functionality these operating systems provide.
void fl_line_style(int style, int width=0, char* dashes=0)
Set how to draw lines (the "pen"). If you change this it is your responsibility to set it back to the default with fl_line_style(0).
| Note:
Because of how line styles are implemented on WIN32 systems, you must set the line style after setting the drawing color. If you set the color after the line style you will lose the line style settings! |
style is a bitmask which is a bitwise-OR of the following values. If you don't specify a dash type you will get a solid line. If you don't specify a cap or join type you will get a system-defined default of whatever value is fastest.
- FL_SOLID -------
- FL_DASH - - - -
- FL_DOT .......
- FL_DASHDOT - . - .
- FL_DASHDOTDOT - .. -
- FL_CAP_FLAT
- FL_CAP_ROUND
- FL_CAP_SQUARE (extends past end point 1/2 line width)
- FL_JOIN_MITER (pointed)
- FL_JOIN_ROUND
- FL_JOIN_BEVEL (flat)
width is the number of pixels thick to draw the lines. Zero results in the system-defined default, which on both X and Windows is somewhat different and nicer than 1.
dashes is a pointer to an array of dash lengths, measured in pixels. The first location is how long to draw a solid portion, the next is how long to draw the gap, then the solid, etc. It is terminated with a zero-length entry. A NULL pointer or a zero-length array results in a solid line. Odd array sizes are not supported and result in undefined behavior.
| Note:
The dashes array does not work under Windows 95, 98, or Me, since those operating systems do not support complex line styles. |
Drawing Fast Shapes
These functions are used to draw almost all the FLTK widgets. They draw on exact pixel boundaries and are as fast as possible. Their behavior is duplicated exactly on all platforms FLTK is ported. It is undefined whether these are affected by the transformation matrix, so you should only call these while the matrix is set to the identity matrix (the default).
void fl_point(int x, int y)
Draw a single pixel at the given coordinates.
void fl_rectf(int x, int y, int w, int h)
void fl_rectf(int x, int y, int w, int h)
Color a rectangle that exactly fills the given bounding box.
void fl_rectf(int x, int y, int w, int h, uchar r, uchar g, uchar b)
Color a rectangle with "exactly" the passed r,g,b color. On screens with less than 24 bits of color this is done by drawing a solid-colored block using fl_draw_image() so that the correct color shade is produced.
void fl_rect(int x, int y, int w, int h)
void fl_rect(int x, int y, int w, int h, Fl_Color c)
Draw a 1-pixel border inside this bounding box.
void fl_line(int x, int y, int x1, int y1)
void fl_line(int x, int y, int x1, int y1, int x2, int y2)
Draw one or two lines between the given points.
void fl_loop(int x, int y, int x1, int y1, int x2, int y2)
void fl_loop(int x, int y, int x1, int y1, int x2, int y2, int x3,
int y3)
Outline a 3 or 4-sided polygon with lines.
void fl_polygon(int x, int y, int x1, int y1, int x2, int y2)
void fl_polygon(int x, int y, int x1, int y1, int x2, int y2, int
x3, int y3)
Fill a 3 or 4-sided polygon. The polygon must be convex.
void fl_xyline(int x, int y, int x1)
void fl_xyline(int x, int y, int x1, int y2)
void fl_xyline(int x, int y, int x1, int y2, int x3)
Draw horizontal and vertical lines. A horizontal line is drawn first, then a vertical, then a horizontal.
void fl_yxline(int x, int y, int y1)
void fl_yxline(int x, int y, int y1, int x2)
void fl_yxline(int x, int y, int y1, int x2, int y3)
Draw vertical and horizontal lines. A vertical line is drawn first, then a horizontal, then a vertical.
void fl_arc(int x, int y, int w, int h, double a1, double a2)
void fl_pie(int x, int y, int w, int h, double a1, double a2)
Draw ellipse sections using integer coordinates. These functions match the rather limited circle drawing code provided by X and WIN32. The advantage over using fl_arc with floating point coordinates is that they are faster because they often use the hardware, and they draw much nicer small circles, since the small sizes are often hard-coded bitmaps.
If a complete circle is drawn it will fit inside the passed bounding box. The two angles are measured in degrees counterclockwise from 3'oclock and are the starting and ending angle of the arc, a2 must be greater or equal to a1.
fl_arc() draws a series of lines to approximate the arc. Notice that the integer version of fl_arc() has a different number of arguments than the fl_arc() function described later in this chapter.
fl_pie() draws a filled-in pie slice. This slice may extend outside the line drawn by fl_arc; to avoid this use w - 1 and h - 1.
void fl_scroll(int X, int Y, int W, int H, int dx, int dy, void (*draw_area)(void*, int,int,int,int), void* data)
Scroll a rectangle and draw the newly exposed portions. The contents of the rectangular area is first shifted by dx and dy pixels. The callback is then called for every newly exposed rectangular area,
Drawing Complex Shapes
The complex drawing functions let you draw arbitrary shapes with 2-D linear transformations. The functionality matches that found in the Adobe® PostScriptTM language. The exact pixels that are filled are less defined than for the fast drawing functions so that FLTK can take advantage of drawing hardware. On both X and WIN32 the transformed vertices are rounded to integers before drawing the line segments: this severely limits the accuracy of these functions for complex graphics, so use OpenGL when greater accuracy and/or performance is required.
void fl_push_matrix()
void fl_pop_matrix()
Save and restore the current transformation. The maximum depth of the stack is 4.
void fl_scale(float x, float y)
void fl_scale(float x)
void fl_translate(float x, float y)
void fl_rotate(float d)
void fl_mult_matrix(float a, float b, float c, float d, float
x, float y)
Concatenate another transformation onto the current one. The rotation angle is in degrees (not radians) and is counter-clockwise.
double fl_transform_x(double x, double y)
double fl_transform_y(double x, double y)
double fl_transform_dx(double x, double y)
double fl_transform_dy(double x, double y)
void fl_transformed_vertex(double xf, double yf)
Transform a coordinate or a distance trough the current transformation matrix. After transforming a coordinate pair, it can be added to the vertex list without any further translations using fl_transformed_vertex.
void fl_begin_points()
void fl_end_points()
Start and end drawing a list of points. Points are added to the list with fl_vertex.
void fl_begin_line()
void fl_end_line()
Start and end drawing lines.
void fl_begin_loop()
void fl_end_loop()
Start and end drawing a closed sequence of lines.
void fl_begin_polygon()
void fl_end_polygon()
Start and end drawing a convex filled polygon.
void fl_begin_complex_polygon()
void fl_gap()
void fl_end_complex_polygon()
Start and end drawing a complex filled polygon. This polygon may be concave, may have holes in it, or may be several disconnected pieces. Call fl_gap() to separate loops of the path. It is unnecessary but harmless to call fl_gap() before the first vertex, after the last one, or several times in a row.
| Note:
For portability, you should only draw polygons that appear the same whether "even/odd" or "non-zero" winding rules are used to fill them. Holes should be drawn in the opposite direction of the outside loop. |
fl_gap() should only be called between fl_begin_complex_polygon() and fl_end_complex_polygon(). To outline the polygon, use fl_begin_loop() and replace each fl_gap() with fl_end_loop();fl_begin_loop().
void fl_vertex(float x, float y)
Add a single vertex to the current path.void fl_curve(float x, float y, float x1, float y1, float x2, float y2, float x3, float y3)
Add a series of points on a Bezier curve to the path. The curve ends (and two of the points) are at x,y and x3,y3.
void fl_arc(float x, float y, float r, float start, float end)
Add a series of points to the current path on the arc of a circle; you can get elliptical paths by using scale and rotate before calling fl_arc(). x,y are the center of the circle, and r is its radius. fl_arc() takes start and end angles that are measured in degrees counter-clockwise from 3 o'clock. If end is less than start then it draws the arc in a clockwise direction.
void fl_circle(float x, float y, float r)
fl_circle() is equivalent to fl_arc(...,0,360) but may be faster. It must be the only thing in the path: if you want a circle as part of a complex polygon you must use fl_arc().
| Note:
fl_circle() draws incorrectly if the transformation is both rotated and non-square scaled. |
Drawing Text
All text is drawn in the current font. It is undefined whether this location or the characters are modified by the current transformation.
void fl_draw(const char *, int x, int y)
void fl_draw(const char *, int n, int x, int y)
Draw a nul-terminated string or an array of n characters starting at the given location. Text is aligned to the left and to the baseline of the font. To align to the bottom, subtract fl_descent() from y. To align to the top, subtract fl_descent() and add fl_height(). This version of fl_draw provides direct access to the text drawing function of the underlying OS. It does not apply any special handling to control characters.
void fl_draw(const char *, int x, int y, int w, int h, Fl_Align align, Fl_Image *img = 0, int draw_symbols = 1)
Fancy string drawing function which is used to draw all the labels. The string is formatted and aligned inside the passed box. Handles '\t' and '\n', expands all other control characters to ^X, and aligns inside or against the edges of the box described by x, y, w and h. See Fl_Widget::align() for values for align. The value FL_ALIGN_INSIDE is ignored, as this function always prints inside the box.
If img is provided and is not NULL, the image is drawn above or below the text as specified by the align value.
The draw_symbols argument specifies whether or not to look for symbol names starting with the "@" character.
The text length is limited to 1024 caracters per line.
void fl_measure(const char *, int &w, int &h, int draw_symbols = 1)
Measure how wide and tall the string will be when printed by the fl_draw(...align) function. If the incoming w is non-zero it will wrap to that width.
int fl_height()
Recommended minimum line spacing for the current font. You can also just use the value of size passed to fl_font().
int fl_descent()
Recommended distance above the bottom of a fl_height() tall box to draw the text at so it looks centered vertically in that box.
float fl_width(const char*)
float fl_width(const char*, int n)
float fl_width(uchar)
Return the pixel width of a nul-terminated string, a sequence of n characters, or a single character in the current font.
const char *fl_shortcut_label(ulong)
Unparse a shortcut value as used by Fl_Button or Fl_Menu_Item into a human-readable string like "Alt+N". This only works if the shortcut is a character key or a numbered function key. If the shortcut is zero an empty string is returned. The return value points at a static buffer that is overwritten with each call.
Fonts
FLTK supports a set of standard fonts based on the Times, Helvetica/Arial, Courier, and Symbol typefaces, as well as custom fonts that your application may load. Each font is accessed by an index into a font table.
Initially only the first 16 faces are filled in. There are symbolic names for them: FL_HELVETICA, FL_TIMES, FL_COURIER, and modifier values FL_BOLD and FL_ITALIC which can be added to these, and FL_SYMBOL and FL_ZAPF_DINGBATS. Faces greater than 255 cannot be used in Fl_Widget labels, since Fl_Widget stores the index as a byte.
void fl_font(int face, int size)
Set the current font, which is then used by the routines described above. You may call this outside a draw context if necessary to call fl_width(), but on X this will open the display.
The font is identified by a face and a size. The size of the font is measured in pixels and not "points". Lines should be spaced size pixels apart or more.
int fl_font()
int fl_size()
Returns the face and size set by the most recent call to fl_font(a,b). This can be used to save/restore the font.
Character Encoding
FLTK 1 supports western character sets using the eight bit encoding of the user-selected global code page. For MS Windows and X11, the code page is assumed to be Windows-1252/Latin1, a superset to ISO 8859-1. On Mac OS X, we assume MacRoman.
FLTK provides the functions fl_latin1_to_local, fl_local_to_latin1, fl_mac_roman_to_local, and fl_local_to_mac_roman to convert strings between both encodings. These functions are only required if your source code contains "C"-strings with international characters and if this source will be compiled on multiple platforms.
Assuming that the following source code was written on MS Windows, this example will output the correct label on OS X and X11 as well. Without the conversion call, the label on OS X would read Fahrvergn¸gen with a deformed umlaut u.
btn = new Fl_Button(10, 10, 300, 25);
btn->copy_label(fl_latin1_to_local("Fahrvergnügen"));
If your application uses characters that are not part of both encodings, or it will be used in areas that commonly use different code pages, yoou might consider upgrading to FLTK 2 which supports UTF-8 encoding.
Drawing Overlays
These functions allow you to draw interactive selection rectangles without using the overlay hardware. FLTK will XOR a single rectangle outline over a window.
void fl_overlay_rect(int x, int y, int w, int h);
void fl_overlay_clear();
fl_overlay_rect() draws a selection rectangle, erasing any previous rectangle by XOR'ing it first. fl_overlay_clear() will erase the rectangle without drawing a new one.
Using these functions is tricky. You should make a widget with both a handle() and draw() method. draw() should call fl_overlay_clear() before doing anything else. Your handle() method should call window()->make_current() and then fl_overlay_rect() after FL_DRAG events, and should call fl_overlay_clear() after a FL_RELEASE event.
Drawing Images
To draw images, you can either do it directly from data in your memory, or you can create a Fl_Image object. The advantage of drawing directly is that it is more intuitive, and it is faster if the image data changes more often than it is redrawn. The advantage of using the object is that FLTK will cache translated forms of the image (on X it uses a server pixmap) and thus redrawing is much faster.
Direct Image Drawing
The behavior when drawing images when the current transformation matrix is not the identity is not defined, so you should only draw images when the matrix is set to the identity.
void fl_draw_image(const uchar *, int X, int Y, int W, int H, int D
= 3, int LD = 0)
void fl_draw_image_mono(const uchar *, int X, int Y, int W, int H,
int D = 1, int LD = 0)
Draw an 8-bit per color RGB or luminance image. The pointer points at the "r" data of the top-left pixel. Color data must be in r,g,b order. X,Y are where to put the top-left corner. W and H define the size of the image. D is the delta to add to the pointer between pixels, it may be any value greater or equal to 3, or it can be negative to flip the image horizontally. LD is the delta to add to the pointer between lines (if 0 is passed it uses W * D), and may be larger than W * D to crop data, or negative to flip the image vertically.
It is highly recommended that you put the following code before the first show() of any window in your program to get rid of the dithering if possible:
Fl::visual(FL_RGB);
Gray scale (1-channel) images may be drawn. This is done if abs(D) is less than 3, or by calling fl_draw_image_mono(). Only one 8-bit sample is used for each pixel, and on screens with different numbers of bits for red, green, and blue only gray colors are used. Setting D greater than 1 will let you display one channel of a color image.
| Note:
The X version does not support all possible visuals. If FLTK cannot draw the image in the current visual it will abort. FLTK supports any visual of 8 bits or less, and all common TrueColor visuals up to 32 bits. |
typedef void (*fl_draw_image_cb)(void *, int x, int y, int w, uchar
*)
void fl_draw_image(fl_draw_image_cb, void *, int X, int Y, int W,
int H, int D = 3)
void fl_draw_image_mono(fl_draw_image_cb, void *, int X, int Y,
int W, int H, int D = 1)
Call the passed function to provide each scan line of the image. This lets you generate the image as it is being drawn, or do arbitrary decompression of stored data, provided it can be decompressed to individual scan lines easily.
The callback is called with the void * user data pointer which can be used to point at a structure of information about the image, and the x, y, and w of the scan line desired from the image. 0,0 is the upper-left corner of the image, not X,Y. A pointer to a buffer to put the data into is passed. You must copy w pixels from scanline y, starting at pixel x, to this buffer.
Due to cropping, less than the whole image may be requested. So x may be greater than zero, the first y may be greater than zero, and w may be less than W. The buffer is long enough to store the entire W * D pixels, this is for convenience with some decompression schemes where you must decompress the entire line at once: decompress it into the buffer, and then if x is not zero, copy the data over so the x'th pixel is at the start of the buffer.
You can assume the y's will be consecutive, except the first one may be greater than zero.
If D is 4 or more, you must fill in the unused bytes with zero.
int fl_draw_pixmap(char **data, int X, int Y, Fl_Color = FL_GRAY)
Draws XPM image data, with the top-left corner at the given position. The image is dithered on 8-bit displays so you won't lose color space for programs displaying both images and pixmaps. This function returns zero if there was any error decoding the XPM data.
To use an XPM, do:
#include "foo.xpm" ... fl_draw_pixmap(foo, X, Y);
Transparent colors are replaced by the optional Fl_Color argument. To draw with true transparency you must use the Fl_Pixmap class.
int fl_measure_pixmap(char **data, int &w, int &h)
An XPM image contains the dimensions in its data. This function finds and returns the width and height. The return value is non-zero if the dimensions were parsed ok and zero if there was any problem.
Direct Image Reading
FLTK provides a single function for reading from the current window or off-screen buffer into a RGB(A) image buffer.
uchar *fl_read_image(uchar *p, int X, int Y, int W, int H, int alpha = 0);
Read a RGB(A) image from the current window or off-screen buffer. The p argument points to a buffer that can hold the image and must be at least W*H*3 bytes when reading RGB images and W*H*4 bytes when reading RGBA images. If NULL, fl_read_image() will create an array of the proper size which can be freed using delete[].
The alpha parameter controls whether an alpha channel is created and the value that is placed in the alpha channel. If 0, no alpha channel is generated.
Image Classes
FLTK provides a base image class called Fl_Image which supports creating, copying, and drawing images of various kinds, along with some basic color operations. Images can be used as labels for widgets using the image() and deimage() methods or drawn directly.
The Fl_Image class does almost nothing by itself, but is instead supported by three basic image types:
The Fl_Bitmap class encapsulates a mono-color bitmap image. The draw() method draws the image using the current drawing color.
The Fl_Pixmap class encapsulates a colormapped image. The draw() method draws the image using the colors in the file, and masks off any transparent colors automatically.
The Fl_RGB_Image class encapsulates a full-color (or grayscale) image with 1 to 4 color components. Images with an even number of components are assumed to contain an alpha channel that is used for transparency. The transparency provided by the draw() method is either a 24-bit blend against the existing window contents or a "screen door" transparency mask, depending on the platform and screen color depth.
char fl_can_do_alpha_blending()
fl_can_do_alpha_blending() will return 1, if your platform supports true alpha blending for RGBA images, or 0, if FLTK will use screen door transparency.
FLTK also provides several image classes based on the three standard image types for common file formats:
Each of these image classes load a named file of the corresponding format. The Fl_Shared_Image class can be used to load any type of image file - the class examines the file and constructs an image of the appropriate type.
Finally, FLTK provides a special image class called Fl_Tiled_Image to tile another image object in the specified area. This class can be used to tile a background image in a Fl_Group widget, for example.
virtual void copy();
virtual void copy(int w, int h);
The copy() method creates a copy of the image. The second form specifies the new size of the image - the image is resized using the nearest-neighbor algorithm.
void draw(int x, int y, int w, int h, int ox = 0, int oy = 0);
The draw() method draws the image object. x,y,w,h indicates a destination rectangle. ox,oy,w,h is a source rectangle. This source rectangle is copied to the destination. The source rectangle may extend outside the image, i.e. ox and oy may be negative and w and h may be bigger than the image, and this area is left unchanged.
void draw(int x, int y)
Draws the image with the upper-left corner at x,y. This is the same as doing draw(x,y,img->w(),img->h(),0,0).
Offscreen Drawing
Sometimes it can be very useful to generate a complex drawing in memory first and copy it to the screen at a later point in time. This technique can significantly reduce the amount of repeated drawing. Fl_Double_Window uses offscreen rendering to avoid flickering on systems that don't support double-buffering natively.Fl_Offscreen fl_create_offscreen(int w, int h)
Create an RGB offscreen buffer with w*h pixels.
void fl_delete_offscreen(Fl_Offscreen)
Delete a previously created offscreen buffer. All drawings are lost.
void fl_begin_offscreen(Fl_Offscreen)
Send all subsequent drawing commands to this offscreen buffer. FLTK can draw into a buffer at any time. There is no need to wait for an Fl_Widget::draw() to occur.
void fl_end_offscreen()
Quit sending drawing commands to this offscreen buffer.
void fl_copy_offscreen(int x, int y, int w, int h, Fl_Offscreen osrc, int srcx, int srcy)
Copy a rectangular area of the size w*h from srcx, srcy in the offscreen
buffer into the current buffer at x, y.
fltk-1.1.10/documentation/editor-replace.gif 0000644 0000765 0000000 00000002761 10332207117 017616 0 ustar matt wheel GIF87a,i  ÜÜÜ ºººÿÿÿÏÏÏúúúèèè, ,i @þºÜþ0ÊI«½8ëÍ»ÿ`(Ždižhª®Yà¾[s#Cîæ|ïÿÀ pH,ȤrÉ,
¬N1›VÓÅ·kz¿à°xLvB£h˶Ìn»ßðï3MŸîø¼~Ïïûÿ€‚ƒ„…†‡ˆˆg'YYŽ!kq“”•–as( 0œ /ž2.ŸU œ¦Ÿ ’—¬®™u²
µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇ ³³7´ËÌÑ"Î ÊÒÔÖV§¢ß¤2à£áåääÜ¡â©Ù
ÛXñã¥ãóöæŽWëçúì5 ¸`‘–,ðÔq£‡ï ¿u6 UHÈAâ5î PÔ`þñ¢6 7zq¤É“(Sª\ɲ¥Ë—0cÊœI“æªW8sêÄd¥D†Í©Â¡ƒèΣH“úˆU³ƒ¤.J£J}Å´©Õ«X³Ö¹9µ«WJUItՉݾS¦þÁ€Äõ«Û·cÂj¥Ð®Ý»IäÎÝË·ï‘k;Fü! ĈϖmaÝáY
ĈÚT)؆ ˜ÊãÃúÆŠ¦°él»ÊéäýS
ºµYÝúy®i‘/ʉS‡½›µî¡É,ûÅ]Møp!›,y¼¹óçУKŸN½ºõ—‰²kßν»÷ïÙ{Jj¯ùó?ôzÜ This chapter takes you through the design of a simple
FLTK-based text editor.
Since this will be the first big project you'll be doing with FLTK,
lets define what we want our text editor to do:
Now that we've outlined the goals for our editor, we can begin with
the design of our GUI. Obviously the first thing that we need is a
window, which we'll place inside a class called EditorWindow:
Our text editor will need some global variables to keep track of
things:
The textbuf variable is the text editor buffer for
our window class described previously. We'll cover the other
variables as we build the application. The first goal requires us to use a menubar and menus that
define each function the editor needs to perform. The Fl_Menu_Item structure is
used to define the menus and items in a menubar: Once we have the menus defined we can create the
Fl_Menu_Bar widget and assign the menus to it with: We'll define the callback functions later.
To keep things simple our text editor will use the
Fl_Text_Editor
widget to edit the text:
So that we can keep track of changes to the file, we also want to add
a "modify" callback: Finally, we want to use a mono-spaced font like FL_COURIER:
We can use the FLTK convenience functions for many of the
editor's dialogs, however the replace dialog needs its own
custom window. To keep things simple we will have a
"find" string, a "replace" string, and
"replace all", "replace next", and
"cancel" buttons. The strings are just
Fl_Input widgets, the "replace all" and
"cancel" buttons are Fl_Button widgets, and
the "replace next " button is a
Fl_Return_Button widget: Now that we've defined the GUI components of our editor, we
need to define our callback functions. This function will be called whenever the user changes any text in the
editor widget:
The set_title() function is one that we will write to set
the changed status on the current file. We're doing it this way
because we want to show the changed status in the window's
title bar.
This callback function will call kf_copy()
to copy the currently selected text to the clipboard: This callback function will call kf_cut()
to cut the currently selected text to the clipboard: This callback function will call remove_selection()
to delete the currently selected text to the clipboard: This callback function asks for a search string using the fl_input()
convenience function and then calls the find2_cb()
function to find the string:
This function will find the next occurrence of the search
string. If the search string is blank then we want to pop up the
search dialog:
If the search string cannot be found we use the fl_alert()
convenience function to display a message to that effect.
This callback function will clear the editor widget and current
filename. It also calls the check_save() function to give the
user the opportunity to save the current file first as needed:
This callback function will ask the user for a filename and then load
the specified file into the input widget and current filename. It also
calls the check_save() function to give the user the
opportunity to save the current file first as needed:
We call the load_file() function to actually load the file.
This callback function will call kf_paste()
to paste the clipboard at the current position: The quit callback will first see if the current file has been
modified, and if so give the user a chance to save it. It then exits
from the program:
The replace callback just shows the replace dialog:
This callback will replace the next occurence of the replacement
string. If nothing has been entered for the replacement string, then
the replace dialog is displayed instead:
This callback will replace all occurences of the search
string in the file:
This callback just hides the replace dialog:
This callback saves the current file. If the current filename is
blank it calls the "save as" callback:
The save_file() function saves the current file to the
specified filename.
This callback asks the user for a filename and saves the current file:
The save_file() function saves the current file to the
specified filename.
Now that we've defined the callback functions, we need our support
functions to make it all work:
This function checks to see if the current file needs to be saved. If
so, it asks the user if they want to save it:
This function loads the specified file into the textbuf class:
When loading the file we use the loadfile()
method to "replace" the text in the buffer, or the insertfile()
method to insert text in the buffer from the named file.
This function saves the current buffer to the specified file:
This function checks the changed variable and updates the
window label accordingly:
Once we've created all of the support functions, the only thing left
is to tie them all together with the main() function.
The main() function creates a new text buffer, creates a
new view (window) for the text, shows the window, loads the file on
the command-line (if any), and then enters the FLTK event loop:
The complete source for our text editor can be found in the test/editor.cxx source file. Both the Makefile and Visual C++
workspace include the necessary rules to build the editor. You can
also compile it using a standard compiler with:
or by using the fltk-config script with:
As noted in Chapter 1, you may need to
include compiler and linker options to tell them where to find the FLTK
library. Also, the CC command may also be called gcc
or c++ on your system.
Congratulations, you've just built your own text editor! Now that we've implemented the basic functionality, it is
time to show off some of the advanced features of the
The Styles are defined using the
The For our text editor we'll define 7 styles for plain code,
comments, keywords, and preprocessor directives:
You'll notice that the comments show a letter next to each
style - each style in the style buffer is referenced using a
character starting with the letter 'A'.
You call the Finally, you need to add a callback to the main text buffer so
that changes to the text buffer are mirrored in the style buffer:
The The This appendix lists the enumerations provided in the
<FL/Enumerations.H> header file, organized by
section. Constants whose value is zero are marked with "(0)",
this is often useful to know when programming.
The following constants define the button numbers for FL_PUSH and
FL_RELEASE events:
The Fl_Color enumeration type holds a FLTK color value.
Colors are either 8-bit indexes into a virtual colormap or 24-bit RGB
color values. Color indices occupy the lower 8 bits of the value, while
RGB colors occupy the upper 24 bits, for a byte organization of RGBI.
Constants are defined for the user-defined foreground and background
colors, as well as specific colors and the start of the grayscale ramp
and color cube in the virtual colormap. Inline functions are provided to
retrieve specific grayscale, color cube, or RGB color values.
The following color constants can be used to access the user-defined
colors:
The following color constants can be used to access the colors from the
FLTK standard color cube:
The inline methods for getting a grayscale, color cube, or
RGB color value are described in Appendix B - Function
Reference.
The following constants define the mouse cursors that are available in
FLTK. The double-headed arrows are bitmaps
provided by FLTK on X, the others are provided by system-defined
cursors. This chapter discusses the FLTK event model and how to handle
events in your program or widget.
Every time a user moves the mouse pointer, clicks a button,
or presses a key, an event is generated and sent to your
application. Events can also come from other programs like the
window manager.
Events are identified by the integer argument passed to the
Fl_Widget::handle() virtual
method. Other information about the most recent event is stored in
static locations and acquired by calling the Fl::event_*() methods. This static
information remains valid until the next event is read from the window
system, so it is ok to look at it outside of the handle()
method.
A mouse button has gone down with the mouse pointing at this
widget. You can find out what button by calling
Fl::event_button(). You find out the mouse position by
calling Fl::event_x() and Fl::event_y().
A widget indicates that it "wants" the mouse click
by returning non-zero from its handle() method. It
will then become the
Fl::pushed() widget and will get FL_DRAG and
the matching FL_RELEASE events. If handle()
returns zero then FLTK will try sending the FL_PUSH to
another widget. The mouse has moved with a button held down. The current
button state is in Fl::event_state().
The mouse position is in Fl::event_x() and Fl::event_y().
In order to receive FL_DRAG events, the widget must
return non-zero when handling FL_PUSH. A mouse button has been released. You can find out what
button by calling Fl::event_button().
In order to receive the FL_RELEASE event, the widget must
return non-zero when handling FL_PUSH. The mouse has moved without any mouse buttons held down.
This event is sent to the Fl::belowmouse()
widget. In order to receive FL_MOVE events, the widget must
return non-zero when handling FL_ENTER. The user has moved the mouse wheel. The Fl::event_dx() and Fl::event_dy() methods
can be used to find the amount to scroll horizontally and
vertically.
The mouse has been moved to point at this widget. This can
be used for highlighting feedback. If a widget wants to
highlight or otherwise track the mouse, it indicates this by
returning non-zero from its handle() method. It then
becomes the Fl::belowmouse()
widget and will receive FL_MOVE and FL_LEAVE
events.
The mouse has moved out of the widget.
In order to receive the FL_LEAVE event, the widget must
return non-zero when handling FL_ENTER. This indicates an attempt to give a widget the
keyboard focus.
If a widget wants the focus, it should change itself to
display the fact that it has the focus, and return non-zero from
its handle()
method. It then becomes the Fl::focus() widget and gets
FL_KEYDOWN, FL_KEYUP, and FL_UNFOCUS
events.
The focus will change either because the window manager
changed which window gets the focus, or because the user tried
to navigate using tab, arrows, or other keys. You can check Fl::event_key() to
figure out why it moved. For navigation it will be the key
pressed and interaction with the window manager it will be
zero.
This event is sent to the previous Fl::focus() widget when
another widget gets the focus or the window loses focus.
A key was pressed or released. The key can be found in Fl::event_key(). The
text that the key should insert can be found with Fl::event_text() and
its length is in Fl::event_length().
If you use the key handle() should return 1. If you
return zero then FLTK assumes you ignored the key and will
then attempt to send it to a parent widget. If none of them want
it, it will change the event into a FL_SHORTCUT event.
To receive If you are writing a text-editing widget you may also want to
call the Fl::compose()
function to translate individual keystrokes into foreign
characters.
If the Fl::focus()
widget is zero or ignores an FL_KEYBOARD event then
FLTK tries sending this event to every widget it can, until one
of them returns non-zero. FL_SHORTCUT is first sent to
the Fl::belowmouse() widget, then its parents and
siblings, and eventually to every widget in the window, trying
to find an object that returns non-zero. FLTK tries really hard
to not to ignore any keystrokes!
You can also make "global" shortcuts by using Fl::add_handler(). A
global shortcut will work no matter what windows are displayed
or which one has the focus. This widget is no longer active, due to deactivate()
being called on it or one of its parents. active() may
still be true after this, the widget is only active if
active() is true on it and all its parents (use active_r() to check this).
This widget is now active, due to activate()
being called on it or one of its parents.
This widget is no longer visible, due to hide() being
called on it or one of its parents, or due to a parent window
being minimized. visible() may still be true after
this, but the widget is visible only if visible() is
true for it and all its parents (use visible_r() to
check this).
This widget is visible again, due to show() being
called on it or one of its parents, or due to a parent window
being restored. Child Fl_Windows respond to this by
actually creating the window if not done already, so if you
subclass a window, be sure to pass FL_SHOW to the base
class handle() method!
You should get this event some time after you call Fl::paste(). The contents
of Fl::event_text()
is the text to insert and the number of characters is in Fl::event_length().
The Fl::selection_owner()
will get this event before the selection is moved to another
widget. This indicates that some other widget or program has
claimed the selection. Motif programs used this to clear the
selection indication. Most modern programs ignore this.
FLTK supports drag and drop of text and files from any
application on the desktop. Text is transfered using
the current code page. Files are received as a list of full path
and file names, separated by newline. On some platforms, path
names are prepended with file://.
The drag and drop data is available in Fl::event_text()
at the concluding FL_PASTE. On some platforms, the
event text is also available for the FL_DND_* events,
however application must not depend on that behavior because it
depends on the protocol used on each platform.
FL_DND_* events cannot be used in widgets derived
from Fl_Group or Fl_Window.
The mouse has been moved to point at this widget. A widget
that is interested in receiving drag'n'drop data must return 1
to receive FL_DND_DRAG, FL_DND_LEAVE and FL_DND_RELEASE events.
The mouse has been moved inside a widget while dragging data.
A widget that is interested in receiving drag'n'drop data should
indicate the possible drop position.
The mouse has moved out of the widget.
The user has released the mouse button dropping data into
the widget. If the widget returns 1, it will receive the data in
the immediately following FL_PASTE event.
FLTK keeps the information about the most recent event in
static storage. This information is good until the next event is
processed. Thus it is valid inside handle() and
callback() methods.
These are all trivial inline functions and thus very fast and small: FLTK follows very simple and unchangeable rules for sending
events. The major innovation is that widgets can indicate (by
returning 0 from the handle() method) that they are not
interested in an event, and FLTK can then send that event
elsewhere. This eliminates the need for "interests"
(event masks or tables), and this is probably the main reason
FLTK is much smaller than other toolkits.
Most events are sent directly to the handle() method
of the Fl_Window that the window system says they
belong to. The window (actually the Fl_Group that
Fl_Window is a subclass of) is responsible for sending
the events on to any child widgets. To make the
Fl_Group code somewhat easier, FLTK sends some events
(FL_DRAG, FL_RELEASE, FL_KEYBOARD,
FL_SHORTCUT, FL_UNFOCUS, and
FL_LEAVE) directly to leaf widgets. These procedures
control those leaf widgets:
The foreign-letter compose processing done by the Fl_Input widget is provided in
a function that you can call if you are writing your own text editor
widget.
FLTK uses its own compose processing to allow "preview" of
the partially composed sequence, which is impossible with the
usual "dead key" processing.
Although currently only characters in the ISO-8859-1
character set are handled, you should call this in case any
enhancements to the processing are done in the future. The
interface has been designed to handle arbitrary UTF-8 encoded
text.
The following methods are provided for character composition:
March 19, 2005 The FLTK distribution contains over 60 sample applications written
in, or ported to, FLTK. If the FLTK archive you received does not
contain a 'test' directory, you can download the complete FLTK
distribution from
http://fltk.org/software.php. Most of the example programs were created while testing a group of widgets.
They are not meant to be great achievements in clean C++ programming, but merely
a test platform to verify the functionality of the FLTK library. The tabs application shows the Fl_Tabs widget
on the left and the Fl_Wizard widget on the right side
for direct comparison of these two panel management widgets.
The Fl class is the FLTK global (static) class containing
state information and global methods for the current application. FLTK will call this callback just before it flushes the display and
waits for events. This is different than an idle callback because it
is only called once, then FLTK calls the system and tells it not to
return until an event happens.
This can be used by code that wants to monitor the
application's state, such as to keep a display up to date. The
advantage of using a check callback is that it is called only when no
events are pending. If events are coming in quickly, whole blocks of
them will be processed before this is called once. This can save
significant time and avoid the application falling behind the events.
Sample code:
Add file descriptor fd to listen to. When the fd
becomes ready for reading Fl::wait() will call the callback
and then return. The callback is
passed the fd and the arbitrary void* argument. The second version takes a when bitfield, with the bits
FL_READ, FL_WRITE, and FL_EXCEPT defined,
to indicate when the callback should be done.
There can only be one callback of each type for a file descriptor.
Fl::remove_fd() gets rid of all the callbacks for a given
file descriptor.
Under UNIX any file descriptor can be monitored (files,
devices, pipes, sockets, etc.) Due to limitations in Microsoft Windows,
WIN32 applications can only monitor sockets.
Install a function to parse unrecognized events. If FLTK cannot
figure out what to do with an event, it calls each of these functions
(most recent first) until one of them returns non-zero. If none of
them returns non zero then the event is ignored. Events that cause
this to be called are:
Adds a callback function that is called every time by
Fl::wait() and also makes it act as though the timeout is
zero (this makes Fl::wait() return immediately, so if it is
in a loop it is called repeatedly, and thus the idle fucntion is
called repeatedly). The idle function can be used to get background
processing done.
You can have multiple idle callbacks. To remove an idle callback use Fl::remove_idle().
Fl::wait() and Fl::check() call idle callbacks,
but Fl::ready() does not.
The idle callback can call any FLTK functions, including
Fl::wait(), Fl::check(), and Fl::ready().
FLTK will not recursively call the idle callback.
Add a one-shot timeout callback. The function will be called by
Fl::wait() at t seconds after this function is called.
The optional void* argument is passed to the callback.
You can have multiple timeout callbacks. To remove an timeout
callback use Fl::remove_timeout().
If you need more accurate, repeated timeouts, use Fl::repeat_timeout() to
reschedule the subsequent timeouts. The following code will print "TICK" each second on
stdout with a fair degree of accuracy: Consume a single switch from argv, starting at word i.
Returns the number of words eaten (1 or 2, or 0 if it is not
recognized) and adds the same value to i. You can use this
function if you prefer to control the incrementing through the
arguments yourself.
FLTK provides an entirely optional command-line switch parser.
You don't have to call it if you don't like them! Everything it can do
can be done with other calls to FLTK.
To use the switch parser, call Fl::args(...) near the start
of your program. This does not open the display, instead
switches that need the display open are stashed into static variables.
Then you must display your first window by calling
window->show(argc,argv), which will do anything stored in the
static variables.
callback lets you define your own switches. It is called
with the same argc and argv, and with i the
index of each word. The callback should return zero if the switch is
unrecognized, and not change i. It should return non-zero if
the switch is recognized, and add at least 1 to i (it can add
more to consume words after the switch). This function is called
before any other tests, so you can override any FLTK
switch (this is why FLTK can use very short switches instead of
the long ones all other toolkits force you to use).
On return i is set to the index of the first non-switch.
This is either:
The return value is i unless an unrecognized switch is found,
in which case it is zero. If your program takes no arguments other
than switches you should produce an error if the return value is less
than argc.
All switches except -bg2 may be abbreviated one letter and case is ignored:
Sets the background color using Fl::background(). Sets the secondary background color using Fl::background2(). Sets the X display to use; this option is silently
ignored under WIN32 and MacOS. Enables or disables drag and drop text operations
using Fl::dnd_text_ops(). Sets the foreground color using Fl::foreground(). Sets the initial window position and size according
the the standard X geometry string. Iconifies the window using Fl_Window::iconize(). Enables or disables visible keyboard focus for
non-text widgets using Fl::visible_focus(). Sets the window class using Fl_Window::xclass(). Sets the widget scheme using Fl::scheme(). Sets the window title using Fl_Window::label(). Enables or disables tooltips using Fl_Tooltip::enable(). The second form of Fl::args() is useful if your program does
not have command line switches of its own. It parses all the switches,
and if any are not recognized it calls Fl::abort(Fl::help).
A usage string is displayed if Fl::args() detects an invalid
argument on the command-line. You can change the message by setting the
Fl::help pointer.
The awake() method sends a message pointer to the main thread,
causing any pending Fl::wait() call to
terminate so that the main thread can retrieve the message and any pending
redraws can be processed.
Multiple calls to Fl::awake() will queue multiple pointers
for the main thread to process, up to a system-defined (typically several
thousand) depth. The default message handler saves the last message which
can be accessed using the
Fl::thread_message() function.
The second form of awake() registers a function that will be
called by the main thread during the next message handling cycle.
awake() will return 0 if the callback function was registered,
and -1 if registration failed. Over a thousand awake callbacks can be
registered simultaneously.
See also: multithreading.
Changes the alternative background color. This color is used as a
background by Fl_Input and other text widgets.
This call may change fl_color(FL_FOREGROUND_COLOR) if it
does not provide sufficient contrast to FL_BACKGROUND2_COLOR.
Changes fl_color(FL_BACKGROUND_COLOR) to the given color,
and changes the gray ramp from 32 to 56 to black to white. These are
the colors used as backgrounds by almost all widgets and used to draw
the edges of all the boxtypes.
Get or set the widget that is below the mouse. This is for
highlighting buttons. It is not used to send FL_PUSH or
FL_MOVE directly, for several obscure reasons, but those events
typically go to this widget. This is also the first widget tried for
FL_SHORTCUT events.
If you change the belowmouse widget, the previous one and all
parents (that don't contain the new widget) are sent FL_LEAVE
events. Changing this does not send FL_ENTER to this
or any widget, because sending FL_ENTER is supposed to test
if the widget wants the mouse (by it returning non-zero from
handle()).
Returns the height offset for the given boxtype.
See box_dy.
Returns the width offset for the given boxtype.
See box_dy.
Returns the X offset for the given boxtype.
See box_dy.
Returns the Y offset for the given boxtype.
These functions return the offset values necessary for a given
boxtype, useful for computing the area inside a box's borders, to
prevent overdrawing the borders.
For instance, in the case of a boxtype like FL_DOWN_BOX
where the border width might be 2 pixels all around, the above
functions would return 2, 2, 4, and 4 for box_dx,
box_dy, box_dw, and box_dh
respectively.
An example to compute the area inside a widget's box():
These functions are mainly useful in the draw() code
for deriving custom widgets, where one wants to avoid drawing
over the widget's own border box().
Same as Fl::wait(0). Calling this during a big calculation
will keep the screen up to date and the interface responsive:
The returns non-zero if any windows are displayed, and 0 if no
windows are displayed (this is likely to change in future versions of
FLTK).
Use of this function is very simple. Any text editing widget should
call this for each FL_KEYBOARD event.
If true is returned, then it has modified the
Fl::event_text() and Fl::event_length() to a set of bytes to
insert (it may be of zero length!). In will also set the "del"
parameter to the number of bytes to the left of the cursor to
delete, this is used to delete the results of the previous call to
Fl::compose().
If false is returned, the keys should be treated as function
keys, and del is set to zero. You could insert the text anyways, if
you don't know what else to do.
Though the current implementation returns immediately, future
versions may take quite awhile, as they may pop up a window or do
other user-interface things to allow characters to be selected.
If the user moves the cursor, be sure to call Fl::compose_reset().
The next call to Fl::compose() will start out in an initial state. In
particular it will not set "del" to non-zero. This call is very fast
so it is ok to call it many times and in many places.
Copies the data pointed to by stuff to the selection
(0) or primary (1) clipboard. The selection clipboard is used
for middle-mouse pastes and for drag-and-drop selections. The
primary clipboard is used for traditional copy/cut/paste
operations.
If true then flush() will do something.
This is the default callback for window widgets. It hides the
window and then calls the default widget callback. Schedules a widget for deletion at the next call to the event loop.
Use this method to delete a widget inside a callback function. As with
normal widget deletion it is your responsibility to remove() the widget
from any parent group or window before calling this. To avoid early deletion of widgets, this function
should be called toward the end of a callback and only after any call
to the event loop (Fl::wait(), Fl::flush(),
Fl::check(), fl_ask(), etc.). When deleting groups or windows, you must only delete the group or
window widget and not the individual child widgets. Sets the X display to use for all windows. Actually this just sets
the environment variable $DISPLAY to the passed string, so this only
works before you show() the first window or otherwise open the display,
and does nothing useful under WIN32.
Initiate a Drag And Drop operation. The clipboard should be
filled with relevant data before calling this method. FLTK will
then initiate the system wide drag and drop handling. Dropped data
will be marked as text.
Gets or sets whether drag and drop text operations are
supported. This specifically affects whether selected text can
be dragged from text fields or dragged within a text field as a
cut/paste shortcut.
FLTK calls this to print a normal error message. You can
override the behavior by setting the function pointer to your
own routine.
Fl::error means there is a recoverable error such as
the inability to read an image file. The default implementation
prints the error message to stderr and returns.
Returns non-zero if the Alt key is pressed.
Returns non-zero if button 1 is currently held down.
For more details, see Fl::event_buttons().
Returns non-zero if button 2 is currently held down.
For more details, see Fl::event_buttons().
Returns non-zero if button 3 is currently held down.
For more details, see Fl::event_buttons().
Returns which mouse button caused te current event. This returns garbage if the
most recent event was not a FL_PUSH or FL_RELEASE
event.
Returns the button state bits; if non-zero, then at least one
button is pressed. This function returns the button state at the
time of the event. During an FL_RELEASE event, the state
of the released button will be 0. To find out, which button
caused an FL_RELEASE event, you can use
Fl::event_button() instead.
The first form returns non-zero if the most recent FL_PUSH or
FL_KEYBOARD was a "double click". Returns N-1 for
N clicks. A double click is counted if the same button is pressed
again while event_is_click() is true.
The second form directly sets the number returned by
Fl::event_clicks(). This can be used to set it to zero so that
later code does not think an item was double-clicked.
Returns non-zero if the Control key is pressed.
Returns the last event that was processed. This can be used
to determine if a callback is being done in response to a
keypress, mouse click, etc.
Returns non-zero if the current event_x and event_y
put it inside the widget or inside an arbitrary bounding box. You
should always call this rather than doing your own comparison so you
are consistent about edge effects.
The first form returns non-zero if the mouse has not moved far enough
and not enough time has passed since the last FL_PUSH or
FL_KEYBOARD event for it to be considered a "drag" rather than a
"click". You can test this on FL_DRAG, FL_RELEASE,
and FL_MOVE events. The second form clears the value returned
by Fl::event_is_click(). Useful to prevent the next
click from being counted as a double-click or to make a popup menu
pick an item with a single click. Don't pass non-zero to this.
Fl::event_key() returns which key on the keyboard was last
pushed. It returns zero if the last event was not a key press or release.
Fl::event_key(int) returns true if the given key was held
down (or pressed) during the last event. This is constant until
the next event is read from the server.
Fl::get_key(int) returns true if the given key is held down
now. Under X this requires a round-trip to the server and is
much slower than Fl::event_key(int).
Keys are identified by the unshifted values. FLTK defines a
set of symbols that should work on most modern machines for every key
on the keyboard:
On X Fl::get_key(FL_Button+n) does not work.
On WIN32 Fl::get_key(FL_KP_Enter) and
Fl::event_key(FL_KP_Enter) do not work.
Returns the length of the text in Fl::event_text(). There
will always be a nul at this position in the text. However there may
be a nul before that if the keystroke translates to a nul character or
you paste a nul character.
If NumLock is deactivated, FLTK translates events from the
numeric keypad into the corresponding arrow key events.
event_key() returns the translated key code, whereas
event_original_key() returns the keycode before
NumLock translation.
Returns non-zero if the Shift key is pressed.
This is a bitfield of what shift states were on and what mouse buttons
were held down during the most recent event. The second version
returns non-zero if any of the passed bits are turned on. The legal
bits are:
X servers do not agree on shift states, and FL_NUM_LOCK, FL_META, and
FL_SCROLL_LOCK may not work. The values were selected to match the
XFree86 server on Linux. In addition there is a bug in the way X works
so that the shift state is not correctly reported until the first event
after the shift key is pressed or released.
Returns the mouse position of the event relative to the Fl_Window
it was passed to.
Returns the mouse position on the screen of the event. To find the
absolute position of an Fl_Window on the screen, use the
difference between event_x_root(),event_y_root() and
event_x(),event_y().
Returns the mouse position of the event relative to the Fl_Window
it was passed to.
Returns the mouse position on the screen of the event. To find the
absolute position of an Fl_Window on the screen, use the
difference between event_x_root(),event_y_root() and
event_x(),event_y().
FLTK calls this to print a fatal error message. You can
override the behavior by setting the function pointer to your
own routine.
Fl::fatal must not return, as FLTK is in an unusable
state, however your version may be able to use longjmp
or an exception to continue, as long as it does not call FLTK
again. The default implementation prints the error message to
stderr and exits with status 1.
Returns the first top-level window in the list of shown() windows. If
a modal() window is shown this is the top-most modal window, otherwise
it is the most recent window to get an event.
The second form sets the window that is returned by
first_window. The window is removed from wherever it is in the
list and inserted at the top. This is not done if Fl::modal()
is on or if the window is not shown(). Because the first window
is used to set the "parent" of modal windows, this is often
useful.
Causes all the windows that need it to be redrawn and graphics forced
out through the pipes. This is what wait() does before
looking for events.
Get or set the widget that will receive FL_KEYBOARD events.
If you change Fl::focus(), the previous widget and all
parents (that don't contain the new widget) are sent FL_UNFOCUS
events. Changing the focus does not send FL_FOCUS to
this or any widget, because sending FL_FOCUS is supposed to
test if the widget wants the focus (by it returning non-zero from
handle()).
Changes fl_color(FL_FOREGROUND_COLOR).
Frees the specified color from the colormap, if applicable.
If overlay is non-zero then the color is freed from the
overlay colormap.
Gets the current box drawing function for the specified box type.
Returns the RGB value(s) for the given FLTK color index. The
first form returns the RGB values packed in a 32-bit unsigned
integer with the red value in the upper 8 bits, the green value
in the next 8 bits, and the blue value in bits 8-15. The lower
8 bits will always be 0.
The second form returns the red, green, and blue values
separately in referenced variables.
Get the string for this face. This string is different for each
face. Under X this value is passed to XListFonts to get all the sizes
of this face.
Get a human-readable string describing the family of this face. This
is useful if you are presenting a choice to the user. There is no
guarantee that each face has a different name. The return value points
to a static buffer that is overwritten each call.
The integer pointed to by attributes (if the pointer is not
zero) is set to zero, FL_BOLD or FL_ITALIC or
FL_BOLD | FL_ITALIC. To locate a "family" of fonts, search
forward and back for a set with non-zero attributes, these faces along
with the face with a zero attribute before them constitute a family.
Return an array of sizes in sizep. The return value is the
length of this array. The sizes are sorted from smallest to largest
and indicate what sizes can be given to fl_font() that will
be matched exactly (fl_font() will pick the closest size for
other sizes). A zero in the first location of the array indicates a
scalable font, where any size works, although the array may list sizes
that work "better" than others. Warning: the returned array
points at a static buffer that is overwritten each call. Under X this
will open the display.
Return where the mouse is on the screen by doing a round-trip query to
the server. You should use Fl::event_x_root() and
Fl::event_y_root() if possible, but this is necessary if you are
not sure if a mouse event has been processed recently (such as to
position your first window). If the display is not open, this will
open it.
Read the user preference colors from the system and use them to call
Fl::foreground(), Fl::background(), and
Fl::background2(). This is done by
Fl_Window::show(argc,argv) before applying the -fg and -bg
switches.
On X this reads some common values from the Xdefaults database.
KDE users can set these values by running the "krdb" program, and
newer versions of KDE set this automatically if you check the "apply
style to other X programs" switch in their control panel.
This does the same thing as
Fl::visual(int) but also
requires OpenGL drawing to work. This must be done if
you want to draw in normal windows with OpenGL with gl_start() and
gl_end(). It may be useful to call this so your X
windows use the same visual as an
Fl_Gl_Window, which on
some servers will reduce colormap flashing.
See Fl_Gl_Window
for a list of additional values for the argument.
This is used when pop-up menu systems are active. Send all events to
the passed window no matter where the pointer or focus is (including
in other programs). The window does not have to be
shown() , this lets the handle() method of a
"dummy" window override all event handling and allows you to
map and unmap a complex set of windows (under both X and WIN32
some window must be mapped because the system interface needs a
window id).
If grab() is on it will also affect show() of windows by
doing system-specific operations (on X it turns on
override-redirect). These are designed to make menus popup reliably
and faster on the system.
To turn off grabbing do Fl::grab(0).
Be careful that your program does not enter an infinite loop
while grab() is on. On X this will lock up your screen!
To avoid this potential lockup, all newer operating systems seem to
limit mouse pointer grabbing to the time during which a mouse button
is held down. Some OS's may not support grabbing at all.
Returns the height of the screen in pixels.
Sends the event to a window for processing. Returns non-zero if any
widget uses the event.
Returns true if the check exists and has not been called yet.
Returns true if the specified idle callback is currently installed.
Returns true if the timeout exists and has not been called yet.
The lock() method blocks the current thread until it
can safely access FLTK widgets and data. Child threads should
call this method prior to updating any widgets or accessing
data. The main thread must call lock() to initialize
the threading support in FLTK.
Child threads must call unlock() when they are done
accessing FLTK.
When the wait() method is waiting
for input or timeouts, child threads are given access to FLTK.
Similarly, when the main thread needs to do processing, it will
wait until all child threads have called unlock() before processing
additional data.
See also: multithreading
Returns the top-most modal() window currently shown.
This is the most recently
shown() window with
modal() true, or NULL if there are no modal()
windows shown().
The modal() window has its handle() method called
for all events, and no other windows will have handle()
called (grab() overrides this).
Returns the next top-level window in the list of shown() windows. You can
use this call to iterate through all the windows that are shown().
Makes FLTK use its own colormap. This may make FLTK display better
and will reduce conflicts with other programs that want lots of colors.
However the colors may flash as you move the cursor between windows.
This does nothing if the current visual is not colormapped.
Set things up so the receiver widget will be called with an FL_PASTE event some
time in the future for the specified clipboard. The reciever
should be prepared to be called directly by this, or for
it to happen later, or possibly not at all. This
allows the window system to take as long as necessary to retrieve
the paste buffer (or even to screw up completely) without complex
and error-prone synchronization code in FLTK.
Get or set the widget that is being pushed. FL_DRAG or
FL_RELEASE (and any more FL_PUSH) events will be sent to
this widget.
If you change the pushed widget, the previous one and all parents
(that don't contain the new widget) are sent FL_RELEASE
events. Changing this does not send FL_PUSH to this
or any widget, because sending FL_PUSH is supposed to test
if the widget wants the mouse (by it returning non-zero from
handle()).
All Fl_Widgets that don't have a callback defined use a
default callback that puts a pointer to the widget in this queue, and
this method reads the oldest widget out of this queue.
This is similar to Fl::check() except this does not
call Fl::flush() or any callbacks, which is useful if your
program is in a state where such callbacks are illegal. This returns
true if Fl::check() would do anything (it will continue to
return true until you call Fl::check() or Fl::wait()).
Redraws all widgets.
Removes a check callback. It is harmless to remove a check
callback that no longer exists.
Removes a file descriptor handler.
Removes a previously added event handler.
Removes the specified idle callback, if it is installed.
Removes a timeout callback. It is harmless to remove a timeout
callback that no longer exists.
This method repeats a timeout callback from the expiration of the
previous timeout, allowing for more accurate timing. You may only call
this method inside a timeout callback.
The following code will print "TICK" each second on
stdout with a fair degree of accuracy: As long as any windows are displayed this calls Fl::wait()
repeatedly. When all the windows are closed it returns zero
(supposedly it would return non-zero on any errors, but FLTK calls
exit directly for these). A normal program will end main()
with return Fl::run();.
Gets or sets the current widget scheme. NULL will use
the scheme defined in the FLTK_SCHEME environment
variable or the scheme resource under X11. Otherwise,
any of the following schemes can be used: Gets the number of available screens. Gets the bounding box of a screen. The first form gets the
bounding box for the screen the mouse pointer is in. The second
form gets the bounding box for the screen that contains the
specified coordinates. The last form gets the bounding box for
the numbered screen, where n is a number from 0 to the
number of screens less 1. Sets or gets the default scrollbar size that is used by the
Fl_Browser_,
Fl_Help_View,
Fl_Scroll, and
Fl_Text_Display widgets. Changes the current selection. The block of text is
copied to an internal buffer by FLTK (be careful if doing this in
response to an FL_PASTE as this may be the same buffer
returned by event_text()). The selection_owner()
widget is set to the passed owner.
The single-argument selection_owner(x) call can be used to
move the selection to another widget or to set the owner to
NULL, without changing the actual text of the
selection. FL_SELECTIONCLEAR is sent to the previous
selection owner, if any.
Copying the buffer every time the selection is changed is
obviously wasteful, especially for large selections. An interface will
probably be added in a future version to allow the selection to be made
by a callback function. The current interface will be emulated on top
of this.
The first form sets the function to call to draw a specific boxtype.
The second form copies the from boxtype.
Sets an entry in the fl_color index table. You can set it to
any 8-bit RGB color. The color is not allocated until fl_color(i)
is used.
The first form changes a face. The string pointer is simply stored,
the string is not copied, so the string must be in static memory.
The second form copies one face to another.
FLTK will open the display, and add every font on the server to the
face table. It will attempt to put "families" of faces together, so
that the normal one is first, followed by bold, italic, and bold
italic.
The optional argument is a string to describe the set of fonts to
add. Passing NULL will select only fonts that have the
ISO8859-1 character set (and are thus usable by normal text). Passing
"-*" will select all fonts with any encoding as long as they have
normal X font names with dashes in them. Passing "*" will list every
font that exists (on X this may produce some strange output). Other
values may be useful but are system dependent. With WIN32 NULL
selects fonts with ISO8859-1 encoding and non-NULL selects
all fonts.
The return value is how many faces are in the table after this is
done.
Sets an idle callback.
This method is obsolete - use the add_idle() method instead.
Sets the functions to call to draw and measure a specific labeltype.
Test the current event, which must be an FL_KEYBOARD or
FL_SHORTCUT, against a shortcut value (described in
Fl_Button). Returns non-zero if there is a match. Not to
be confused with
Fl_Widget::test_shortcut().
The thread_message() method returns the last message
that was sent from a child by the awake() method.
See also: multithreading
The unlock() method releases the lock that was set
using the lock() method. Child
threads should call this method as soon as they are finished
accessing FLTK.
See also: multithreading
Returns the compiled-in value of the FL_VERSION constant. This
is useful for checking the version of a shared library.
Gets or sets the visible keyboard focus on buttons and other
non-text widgets. The default mode is to enable keyboard focus
for all widgets.
Selects a visual so that your graphics are drawn correctly. This is
only allowed before you call show() on any windows. This does nothing
if the default visual satisfies the capabilities, or if no visual
satisfies the capabilities, or on systems that don't have such
brain-dead notions.
Only the following combinations do anything useful:
This returns true if the system has the capabilities by default or
FLTK suceeded in turing them on. Your program will still work even if
this returns false (it just won't look as good).
Returns the width of the screen in pixels.
Waits until "something happens" and then returns. Call this
repeatedly to "run" your program. You can also check what happened
each time after this returns, which is quite useful for managing
program state.
What this really does is call all idle callbacks, all elapsed
timeouts, call Fl::flush() to get the screen to update, and
then wait some time (zero if there are idle callbacks, the shortest of
all pending timeouts, or infinity), for any events from the user or
any Fl::add_fd() callbacks. It then handles the events and
calls the callbacks and then returns.
The return value of the first form is non-zero if there are
any visible windows - this may change in future versions of
FLTK.
The second form waits a maximum of time
seconds. It can return much sooner if something happens.
The return value is positive if an event or fd happens before the
time elapsed. It is zero if nothing happens (on Win32 this will only
return zero if time is zero). It is negative if an error
occurs (this will happen on UNIX if a signal happens).
FLTK calls this to print a warning message. You can
override the behavior by setting the function pointer to your
own routine.
Fl::warning means that there was a recoverable
problem, the display may be messed up but the user can probably
keep working - all X protocol errors call this, for example.
Returns the origin of the current screen, where 0 indicates
the left side of the screen.
Returns the origin of the current screen, where 0 indicates
the top edge of the screen.
When you press a button and drag to the right the value increases.
When you drag to the left it decreases. The largest button adjusts by
100 * step(), the next by 10 * step() and that
smallest button by step(). Clicking on the buttons
increments by 10 times the amount dragging by a pixel does. Shift +
click decrements by 10 times the amount.
The Fl_Bitmap class supports caching and drawing of mono-color
(bitmap) images. Images are drawn using the current color. The constructors create a new bitmap from the specified bitmap data. The destructor free all memory and server resources that are used by
the bitmap. The Fl_BMP_Image class supports loading, caching,
and drawing of Windows Bitmap (BMP) image files. The constructor loads the named BMP image. The destructor free all memory and server resources that are used by
the image. The second form of the constructor sets the box to the specified box
type. Each line in the browser is identified by number. The numbers
start at one (this is so that zero can be reserved for "no line" in
the selective browsers). 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 <= size(). Each line contains a null-terminated string of text and a void *
data pointer. The text string is displayed, the void *
pointer can be used by the callbacks to reference the object the text
describes. The base class does nothing when the user clicks on it. The
subclasses
Fl_Select_Browser,
Fl_Hold_Browser, and
Fl_Multi_Browser react to user clicks to select lines in
the browser and do callbacks. The base class called
Fl_Browser_ provides the scrolling and selection mechanisms of
this and all the subclasses, but the dimensions and appearance of each
item are determined by the subclass. You can use Fl_Browser_
to display information other than text, or text that is dynamically
produced from your own data structures. If you find that loading the
browser is a lot of work or is inefficient, you may want to make a
subclass of Fl_Browser_. The second form sets the column separator to c. This will
only have an effect if you also set column_widths(). The second form sets the current array to w. Make sure the
last entry is zero. The second form sets the data for line n. The second form sets the current prefix to c. Set the
prefix to 0 to disable formatting. The second form sets the vertical scrollbar position to p. The second form sets the text for line n. The second form scrolls the browser so the top line in the browser is n. This has been designed so that the subclass has complete control
over the storage of the data, although because next() and
prev() functions are used to index, it works best as a linked list
or as a large block of characters in which the line breaks must be
searched for. A great deal of work has been done so that the "height" of a data
object does not need to be determined until it is drawn. This is
useful if actually figuring out the size of an object requires
accessing image data or doing stat() on a file or doing some
other slow operation. The constructor makes an empty browser.
The destructor deletes all list items and destroys the browser.
[protected] This method returns the bounding box for the interior of the list, inside
the scrollbars.
[protected] This method should be used when an item is deleted from the list.
It allows the Fl_Browser_ to discard any cached data it has
on the item.
Deselects all items in the list and returns 1 if the state changed
or 0 if it did not.
If docb is non-zero, deselect tries to call the
callback function for the widget.
Displays item p, scrolling the list as necessary.
[protected] This method returns non-zero if item p is currently visible in
the list.
[protected] The first form draws the list within the normal widget bounding box.
[protected] The second form draws the contents of the browser within the
specified bounding box.
This method returns the item under mouse at my. If no item is
displayed at that position then NULL is returned.
[protected] 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.
[protected] 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.
The first form handles an event within the normal widget bounding box.
[protected] The second form handles an event within the specified bounding box.
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 h:
Gets or sets the horizontal scrolling position of the list,
which is the pixel offset of the list items within the list
area.
[protected] 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.
[protected] This method should be used when an item is added to the list.
It allows the Fl_Browser_ to update its cache data as needed.
[protected] This method must be provided by the subclass to draw the item
p in the area indicated by x, y, w,
and h.
[protected] This method must be provided by the subclass to return the first item in
the list.
[protected] This method must be provided by the subclass to return the height of the
item p in pixels. Allow for two additional pixels for the list
selection box.
[protected] This method must be provided by the subclass to return the item in
the list after p.
[protected] This method must be provided by the subclass to return the item in
the list before p.
[protected] This method may be provided by the subclass to return the height of the
item p in pixels. Allow for two additional pixels for the list
selection box. This method differs from
item_height in that it is only
called for selection and scrolling operations. The default implementation
calls item_height.
[protected] This method must be implemented by the subclass if it supports
multiple selections in the browser. The s argument specifies the
selection state for item p: 0 = off, 1 = on.
[protected] This method must be implemented by the subclass if it supports
multiple selections in the browser. The method should return 1 if p
is selected and 0 otherwise.
[protected] This method must be provided by the subclass to return the width of the
item p in pixels. Allow for two additional pixels for the list
selection box.
[protected] This method returns the X position of the left edge of the list area
after adjusting for the scrollbar and border, if any.
[protected] This method should be called when the list data is completely replaced
or cleared. It informs the Fl_Browser_ widget that any cached
information it has concerning the items is invalid.
Gets or sets the vertical scrolling position of the list,
which is the pixel offset of the list items within the list
area.
[protected] This method should be called when the contents of an item have changed
but not changed the height of the item.
[protected] This method will cause the entire list to be redrawn.
[protected] This method should be used when an item is replaced in the list.
It allows the Fl_Browser_ to update its cache data as needed.
Repositions and/or resizes the browser.
This method moves the vertical scrollbar to the lefthand side of the list.
This method moves the vertical scrollbar to the righthand side of the list.
Sets or gets the width of any scrollbars that are used.
Sets the selection state of item p to s and
returns 1 if the state changed or 0 if it did not.
If docb is non-zero, select tries to call the callback
function for the widget.
Selects item p and returns 1 if the state changed or 0 if it did
not. Any other items in the list are deselected.
If docb is non-zero, select_only tries to call the
callback function for the widget.
[protected] Returns the item currently selected, or NULL if there is no selection.
For multiple selection browsers this call returns the currently focused item,
even if it is not selected. To find all selected items, call
Fl_Multi_Browser::selected() for every item in question.
The first form gets the default text color for the lines in the
browser.
The second form sets the default text color to color The first form gets the default text font for the lines in the
browser.
The second form sets the default text font to font The first form gets the default text size for the lines in the
browser.
The second form sets the default text size to size [protected] Returns the item the appears at the top of the list.
fltk-1.1.10/documentation/Fl_Button.html 0000644 0000765 0000000 00000013246 10521133643 017014 0 ustar matt wheel
Buttons generate callbacks when they are clicked by the user. You
control exactly when and how by changing the values for type()
and when(). Buttons can also generate callbacks in response to FL_SHORTCUT
events. The button can either have an explicit
shortcut() value or a letter shortcut can be indicated in
the label() with an '&' character before it. For the label
shortcut it does not matter if Alt is held down, but if you have
an input field in the same window, the user will have to hold down the
Alt key so that the input field does not eat the event first as an
FL_KEYBOARD event. The second form sets the down box type. The default value of 0
causes FLTK to figure out the correct matching down version of box()
. The second form sets the shortcut key to key. Setting this
overrides the use of '&' in the label(). The value is a bitwise
OR of a key and a set of shift flags, for example The key can be any value returned by
Fl::event_key(), but will usually be an ASCII letter. Use
a lower-case letter unless you require the shift key to be held down. The shift flags can be any set of values accepted by
Fl::event_state(). If the bit is on that shift key must
be pushed. Meta, Alt, Ctrl, and Shift must be off if they are not in
the shift flags (zero for the other bits indicates a "don't care"
setting). The second form of autosize sets the auto-sizing property
to onoff. The Fl_Check_Button subclass display the "on" state by
turning on a light, rather than drawing pushed in. The shape of the
"light" is initially set to FL_DIAMOND_DOWN_BOX. The color of the
light when on is controlled with selection_color(), which
defaults to FL_RED. The only difference between this and a
Fl_Menu_Button is that the name of the most recent chosen
menu item is displayed inside the box, while the label is displayed
outside the box. However, since the use of this is most often to
control a single variable rather than do individual callbacks, some of
the Fl_Menu_Button methods are redescribed here in those
terms. When the user picks an item off the menu the value()
is set to that item and then the item's callback is done with
the menu_button as the Fl_Widget* argument. If the
item does not have a callback the menu_button's callback is done
instead. All three mouse buttons pop up the menu. The Forms behavior of the
first two buttons to increment/decrement the choice is not implemented.
This could be added with a subclass, however. The menu will also pop up in response to shortcuts indicated by
putting a '&' character in the label(). See
Fl_Button for a description of this. Typing the shortcut() of any of the items will do exactly
the same as when you pick the item with the mouse. The '&' character in
item names are only looked at when the menu is popped up, however. The constructor sets menu() to NULL. See
Fl_Menu_ for the methods to set or change the menu. This widget can be used to display a program-supplied time.
The time shown on the clock is not updated.
To display the current time, use Fl_Clock
instead.
The third form of value returns the displayed time in
seconds since the UNIX epoch (January 1, 1970). 4 - Designing a Simple Text Editor
Determining the Goals of the Text Editor
Designing the Main Window
class EditorWindow : public Fl_Double_Window {
public:
EditorWindow(int w, int h, const char* t);
~EditorWindow();
Fl_Window *replace_dlg;
Fl_Input *replace_find;
Fl_Input *replace_with;
Fl_Button *replace_all;
Fl_Return_Button *replace_next;
Fl_Button *replace_cancel;
Fl_Text_Editor *editor;
char search[256];
};
Variables
int changed = 0;
char filename[256] = "";
Fl_Text_Buffer *textbuf;
Menubars and Menus
Fl_Menu_Item menuitems[] = {
{ "&File", 0, 0, 0, FL_SUBMENU },
{ "&New File", 0, (Fl_Callback *)new_cb },
{ "&Open File...", FL_CTRL + 'o', (Fl_Callback *)open_cb },
{ "&Insert File...", FL_CTRL + 'i', (Fl_Callback *)insert_cb, 0, FL_MENU_DIVIDER },
{ "&Save File", FL_CTRL + 's', (Fl_Callback *)save_cb },
{ "Save File &As...", FL_CTRL + FL_SHIFT + 's', (Fl_Callback *)saveas_cb, 0, FL_MENU_DIVIDER },
{ "New &View", FL_ALT + 'v', (Fl_Callback *)view_cb, 0 },
{ "&Close View", FL_CTRL + 'w', (Fl_Callback *)close_cb, 0, FL_MENU_DIVIDER },
{ "E&xit", FL_CTRL + 'q', (Fl_Callback *)quit_cb, 0 },
{ 0 },
{ "&Edit", 0, 0, 0, FL_SUBMENU },
{ "&Undo", FL_CTRL + 'z', (Fl_Callback *)undo_cb, 0, FL_MENU_DIVIDER },
{ "Cu&t", FL_CTRL + 'x', (Fl_Callback *)cut_cb },
{ "&Copy", FL_CTRL + 'c', (Fl_Callback *)copy_cb },
{ "&Paste", FL_CTRL + 'v', (Fl_Callback *)paste_cb },
{ "&Delete", 0, (Fl_Callback *)delete_cb },
{ 0 },
{ "&Search", 0, 0, 0, FL_SUBMENU },
{ "&Find...", FL_CTRL + 'f', (Fl_Callback *)find_cb },
{ "F&ind Again", FL_CTRL + 'g', find2_cb },
{ "&Replace...", FL_CTRL + 'r', replace_cb },
{ "Re&place Again", FL_CTRL + 't', replace2_cb },
{ 0 },
{ 0 }
};
Fl_Menu_Bar *m = new Fl_Menu_Bar(0, 0, 640, 30);
m->copy(menuitems);
Editing the Text
w->editor = new Fl_Text_Editor(0, 30, 640, 370);
w->editor->buffer(textbuf);
textbuf->add_modify_callback(changed_cb, w);
textbuf->call_modify_callbacks();
w->editor->textfont(FL_COURIER);
The Replace Dialog
Figure 4-1: The search and replace dialog.
Fl_Window *replace_dlg = new Fl_Window(300, 105, "Replace");
Fl_Input *replace_find = new Fl_Input(70, 10, 200, 25, "Find:");
Fl_Input *replace_with = new Fl_Input(70, 40, 200, 25, "Replace:");
Fl_Button *replace_all = new Fl_Button(10, 70, 90, 25, "Replace All");
Fl_Button *replace_next = new Fl_Button(105, 70, 120, 25, "Replace Next");
Fl_Button *replace_cancel = new Fl_Button(230, 70, 60, 25, "Cancel");
Callbacks
changed_cb()
void changed_cb(int, int nInserted, int nDeleted,int, const char*, void* v) {
if ((nInserted || nDeleted) && !loading) changed = 1;
EditorWindow *w = (EditorWindow *)v;
set_title(w);
if (loading) w->editor->show_insert_position();
}
copy_cb()
void copy_cb(Fl_Widget*, void* v) {
EditorWindow* e = (EditorWindow*)v;
Fl_Text_Editor::kf_copy(0, e->editor);
}
cut_cb()
void cut_cb(Fl_Widget*, void* v) {
EditorWindow* e = (EditorWindow*)v;
Fl_Text_Editor::kf_cut(0, e->editor);
}
delete_cb()
void delete_cb(Fl_Widget*, void* v) {
textbuf->remove_selection();
}
find_cb()
void find_cb(Fl_Widget* w, void* v) {
EditorWindow* e = (EditorWindow*)v;
const char *val;
val = fl_input("Search String:", e->search);
if (val != NULL) {
// User entered a string - go find it!
strcpy(e->search, val);
find2_cb(w, v);
}
find2_cb()
void find2_cb(Fl_Widget* w, void* v) {
EditorWindow* e = (EditorWindow*)v;
if (e->search[0] == '\0') {
// Search string is blank; get a new one...
find_cb(w, v);
return;
}
int pos = e->editor->insert_position();
int found = textbuf->search_forward(pos, e->search, &pos);
if (found) {
// Found a match; select and update the position...
textbuf->select(pos, pos+strlen(e->search));
e->editor->insert_position(pos+strlen(e->search));
e->editor->show_insert_position();
}
else fl_alert("No occurrences of \'%s\' found!", e->search);
}
new_cb()
void new_cb(Fl_Widget*, void*) {
if (!check_save()) return;
filename[0] = '\0';
textbuf->select(0, textbuf->length());
textbuf->remove_selection();
changed = 0;
textbuf->call_modify_callbacks();
}
open_cb()
void open_cb(Fl_Widget*, void*) {
if (!check_save()) return;
char *newfile = fl_file_chooser("Open File?", "*", filename);
if (newfile != NULL) load_file(newfile, -1);
}
paste_cb()
void paste_cb(Fl_Widget*, void* v) {
EditorWindow* e = (EditorWindow*)v;
Fl_Text_Editor::kf_paste(0, e->editor);
}
quit_cb()
void quit_cb(Fl_Widget*, void*) {
if (changed && !check_save())
return;
exit(0);
}
replace_cb()
void replace_cb(Fl_Widget*, void* v) {
EditorWindow* e = (EditorWindow*)v;
e->replace_dlg->show();
}
replace2_cb()
void replace2_cb(Fl_Widget*, void* v) {
EditorWindow* e = (EditorWindow*)v;
const char *find = e->replace_find->value();
const char *replace = e->replace_with->value();
if (find[0] == '\0') {
// Search string is blank; get a new one...
e->replace_dlg->show();
return;
}
e->replace_dlg->hide();
int pos = e->editor->insert_position();
int found = textbuf->search_forward(pos, find, &pos);
if (found) {
// Found a match; update the position and replace text...
textbuf->select(pos, pos+strlen(find));
textbuf->remove_selection();
textbuf->insert(pos, replace);
textbuf->select(pos, pos+strlen(replace));
e->editor->insert_position(pos+strlen(replace));
e->editor->show_insert_position();
}
else fl_alert("No occurrences of \'%s\' found!", find);
}
replall_cb()
void replall_cb(Fl_Widget*, void* v) {
EditorWindow* e = (EditorWindow*)v;
const char *find = e->replace_find->value();
const char *replace = e->replace_with->value();
find = e->replace_find->value();
if (find[0] == '\0') {
// Search string is blank; get a new one...
e->replace_dlg->show();
return;
}
e->replace_dlg->hide();
e->editor->insert_position(0);
int times = 0;
// Loop through the whole string
for (int found = 1; found;) {
int pos = e->editor->insert_position();
found = textbuf->search_forward(pos, find, &pos);
if (found) {
// Found a match; update the position and replace text...
textbuf->select(pos, pos+strlen(find));
textbuf->remove_selection();
textbuf->insert(pos, replace);
e->editor->insert_position(pos+strlen(replace));
e->editor->show_insert_position();
times++;
}
}
if (times) fl_message("Replaced %d occurrences.", times);
else fl_alert("No occurrences of \'%s\' found!", find);
}
replcan_cb()
void replcan_cb(Fl_Widget*, void* v) {
EditorWindow* e = (EditorWindow*)v;
e->replace_dlg->hide();
}
save_cb()
void save_cb(void) {
if (filename[0] == '\0') {
// No filename - get one!
saveas_cb();
return;
}
else save_file(filename);
}
saveas_cb()
void saveas_cb(void) {
char *newfile;
newfile = fl_file_chooser("Save File As?", "*", filename);
if (newfile != NULL) save_file(newfile);
}
Other Functions
check_save()
int check_save(void) {
if (!changed) return 1;
int r = fl_choice("The current file has not been saved.\n"
"Would you like to save it now?",
"Cancel", "Save", "Discard");
if (r == 1) {
save_cb(); // Save the file...
return !changed;
}
return (r == 2) ? 1 : 0;
}
load_file()
int loading = 0;
void load_file(char *newfile, int ipos) {
loading = 1;
int insert = (ipos != -1);
changed = insert;
if (!insert) strcpy(filename, "");
int r;
if (!insert) r = textbuf->loadfile(newfile);
else r = textbuf->insertfile(newfile, ipos);
if (r)
fl_alert("Error reading from file \'%s\':\n%s.", newfile, strerror(errno));
else
if (!insert) strcpy(filename, newfile);
loading = 0;
textbuf->call_modify_callbacks();
}
save_file()
void save_file(char *newfile) {
if (textbuf->savefile(newfile))
fl_alert("Error writing to file \'%s\':\n%s.", newfile, strerror(errno));
else
strcpy(filename, newfile);
changed = 0;
textbuf->call_modify_callbacks();
}
set_title()
void set_title(Fl_Window* w) {
if (filename[0] == '\0') strcpy(title, "Untitled");
else {
char *slash;
slash = strrchr(filename, '/');
#ifdef WIN32
if (slash == NULL) slash = strrchr(filename, '\\');
#endif
if (slash != NULL) strcpy(title, slash + 1);
else strcpy(title, filename);
}
if (changed) strcat(title, " (modified)");
w->label(title);
}
The main() Function
int main(int argc, char **argv) {
textbuf = new Fl_Text_Buffer;
Fl_Window* window = new_view();
window->show(1, argv);
if (argc > 1) load_file(argv[1], -1);
return Fl::run();
}
Compiling the Editor
CC -o editor editor.cxx -lfltk -lXext -lX11 -lm
fltk-config --compile editor.cxx
The Final Product
The final editor window should look like the image in Figure 4-2.
Figure 4-2: The completed editor windowAdvanced Features
Fl_Text_Editor widget.
Syntax Highlighting
Fl_Text_Editor widget supports highlighting
of text with different fonts, colors, and sizes. The
implementation is based on the excellent NEdit text editor core, which
uses a parallel "style" buffer which tracks the font, color, and
size of the text that is drawn.
Fl_Text_Display::Style_Table_Entry structure
defined in <FL/Fl_Text_Display.H>:
struct Style_Table_Entry {
Fl_Color color;
Fl_Font font;
int size;
unsigned attr;
};
color member sets the color for the text,
the font member sets the FLTK font index to use,
and the size member sets the pixel size of the
text. The attr member is currently not used.
Fl_Text_Display::Style_Table_Entry styletable[] = { // Style table
{ FL_BLACK, FL_COURIER, FL_NORMAL_SIZE }, // A - Plain
{ FL_DARK_GREEN, FL_COURIER_ITALIC, FL_NORMAL_SIZE }, // B - Line comments
{ FL_DARK_GREEN, FL_COURIER_ITALIC, FL_NORMAL_SIZE }, // C - Block comments
{ FL_BLUE, FL_COURIER, FL_NORMAL_SIZE }, // D - Strings
{ FL_DARK_RED, FL_COURIER, FL_NORMAL_SIZE }, // E - Directives
{ FL_DARK_RED, FL_COURIER_BOLD, FL_NORMAL_SIZE }, // F - Types
{ FL_BLUE, FL_COURIER_BOLD, FL_NORMAL_SIZE } // G - Keywords
};
highlight_data() method to associate the
style data and buffer with the text editor widget:
Fl_Text_Buffer *stylebuf;
w->editor->highlight_data(stylebuf, styletable,
sizeof(styletable) / sizeof(styletable[0]),
'A', style_unfinished_cb, 0);
textbuf->add_modify_callback(style_update, w->editor);
style_update() function, like the change_cb()
function described earlier, is called whenever text is added or removed from
the text buffer. It mirrors the changes in the style buffer and then updates
the style data as necessary:
//
// 'style_update()' - Update the style buffer...
//
void
style_update(int pos, // I - Position of update
int nInserted, // I - Number of inserted chars
int nDeleted, // I - Number of deleted chars
int nRestyled, // I - Number of restyled chars
const char *deletedText, // I - Text that was deleted
void *cbArg) { // I - Callback data
int start, // Start of text
end; // End of text
char last, // Last style on line
*style, // Style data
*text; // Text data
// If this is just a selection change, just unselect the style buffer...
if (nInserted == 0 && nDeleted == 0) {
stylebuf->unselect();
return;
}
// Track changes in the text buffer...
if (nInserted > 0) {
// Insert characters into the style buffer...
style = new char[nInserted + 1];
memset(style, 'A', nInserted);
style[nInserted] = '\0';
stylebuf->replace(pos, pos + nDeleted, style);
delete[] style;
} else {
// Just delete characters in the style buffer...
stylebuf->remove(pos, pos + nDeleted);
}
// Select the area that was just updated to avoid unnecessary
// callbacks...
stylebuf->select(pos, pos + nInserted - nDeleted);
// Re-parse the changed region; we do this by parsing from the
// beginning of the line of the changed region to the end of
// the line of the changed region... Then we check the last
// style character and keep updating if we have a multi-line
// comment character...
start = textbuf->line_start(pos);
end = textbuf->line_end(pos + nInserted - nDeleted);
text = textbuf->text_range(start, end);
style = stylebuf->text_range(start, end);
last = style[end - start - 1];
style_parse(text, style, end - start);
stylebuf->replace(start, end, style);
((Fl_Text_Editor *)cbArg)->redisplay_range(start, end);
if (last != style[end - start - 1]) {
// The last character on the line changed styles, so reparse the
// remainder of the buffer...
free(text);
free(style);
end = textbuf->length();
text = textbuf->text_range(start, end);
style = stylebuf->text_range(start, end);
style_parse(text, style, end - start);
stylebuf->replace(start, end, style);
((Fl_Text_Editor *)cbArg)->redisplay_range(start, end);
}
free(text);
free(style);
}
style_parse() function scans a copy of the
text in the buffer and generates the necessary style characters
for display. It assumes that parsing begins at the start of a line:
//
// 'style_parse()' - Parse text and produce style data.
//
void
style_parse(const char *text,
char *style,
int length) {
char current;
int col;
int last;
char buf[255],
*bufptr;
const char *temp;
for (current = *style, col = 0, last = 0; length > 0; length --, text ++) {
if (current == 'A') {
// Check for directives, comments, strings, and keywords...
if (col == 0 && *text == '#') {
// Set style to directive
current = 'E';
} else if (strncmp(text, "//", 2) == 0) {
current = 'B';
} else if (strncmp(text, "/*", 2) == 0) {
current = 'C';
} else if (strncmp(text, "\\\"", 2) == 0) {
// Quoted quote...
*style++ = current;
*style++ = current;
text ++;
length --;
col += 2;
continue;
} else if (*text == '\"') {
current = 'D';
} else if (!last && islower(*text)) {
// Might be a keyword...
for (temp = text, bufptr = buf;
islower(*temp) && bufptr < (buf + sizeof(buf) - 1);
*bufptr++ = *temp++);
if (!islower(*temp)) {
*bufptr = '\0';
bufptr = buf;
if (bsearch(&bufptr, code_types,
sizeof(code_types) / sizeof(code_types[0]),
sizeof(code_types[0]), compare_keywords)) {
while (text < temp) {
*style++ = 'F';
text ++;
length --;
col ++;
}
text --;
length ++;
last = 1;
continue;
} else if (bsearch(&bufptr, code_keywords,
sizeof(code_keywords) / sizeof(code_keywords[0]),
sizeof(code_keywords[0]), compare_keywords)) {
while (text < temp) {
*style++ = 'G';
text ++;
length --;
col ++;
}
text --;
length ++;
last = 1;
continue;
}
}
}
} else if (current == 'C' && strncmp(text, "*/", 2) == 0) {
// Close a C comment...
*style++ = current;
*style++ = current;
text ++;
length --;
current = 'A';
col += 2;
continue;
} else if (current == 'D') {
// Continuing in string...
if (strncmp(text, "\\\"", 2) == 0) {
// Quoted end quote...
*style++ = current;
*style++ = current;
text ++;
length --;
col += 2;
continue;
} else if (*text == '\"') {
// End quote...
*style++ = current;
col ++;
current = 'A';
continue;
}
}
// Copy style info...
if (current == 'A' && (*text == '{' || *text == '}')) *style++ = 'G';
else *style++ = current;
col ++;
last = isalnum(*text) || *text == '.';
if (*text == '\n') {
// Reset column and possibly reset the style
col = 0;
if (current == 'B' || current == 'E') current = 'A';
}
}
}
fltk-1.1.10/documentation/enumerations.html 0000644 0000765 0000000 00000030677 10623075057 017647 0 ustar matt wheel
C - FLTK Enumerations
Version Numbers
The FLTK version number is stored in a number of compile-time
constants:
Events
Events are identified by an Fl_Event enumeration value. The
following events are currently defined:
Callback "When" Conditions
The following constants determine when a callback is performed:
Fl::event_button() Values
Fl::event_key() Values
The following constants define the non-ASCII keys on the keyboard for
FL_KEYBOARD and FL_SHORTCUT events:
Fl::event_state() Values
The following constants define bits in the Fl::event_state()
value:
Alignment Values
The following constants define bits that can be used with
Fl_Widget::align() to control the positioning of the
label:
Fonts
The following constants define the standard FLTK fonts:
Colors
Color Constants
Cursors
FD "When" Conditions
Damage Masks
The following damage mask bits are used by the standard FLTK widgets:
fltk-1.1.10/documentation/events.html 0000644 0000765 0000000 00000033463 11304521751 016430 0 ustar matt wheel
6 - Handling Events
The FLTK Event Model
Mouse Events
FL_PUSH
FL_DRAG
FL_RELEASE
FL_MOVE
FL_MOUSEWHEEL
Focus Events
FL_ENTER
FL_LEAVE
FL_FOCUS
FL_UNFOCUS
Keyboard Events
FL_KEYDOWN, FL_KEYUP
FL_KEYBOARD events you must also
respond to the FL_FOCUS and FL_UNFOCUS
events.
FL_KEYUP events are sent to the widget that
currently has focus. This is not necessarily the same widget
that received the corresponding FL_KEYDOWN event
because focus may have changed between events.
FL_SHORTCUT
Widget Events
FL_DEACTIVATE
FL_ACTIVATE
FL_HIDE
FL_SHOW
Clipboard Events
FL_PASTE
FL_SELECTIONCLEAR
Drag And Drop Events
FL_DND_ENTER
FL_DND_DRAG
FL_DND_LEAVE
FL_DND_RELEASE
Fl::event_*() methods
Event Propagation
FLTK Compose-Character Sequences
I - Tests and Demo Source Code
adjuster
adjuster shows a nifty little widget for quickly
setting values in a great range.
arc
The arc demo explains how to derive your own widget to
generate some custom drawings. The sample drawings use the matrix
based arc drawing for some fun effects.
ask
ask shows some of FLTK's standard dialog boxes. Click
the correct answers or you may end up in a loop, or you may end
up in a loop, or you... .
bitmap
This simple test shows the use of a single color bitmap as a
label for a box widget. Bitmaps are stored in the X11 '.bmp'
file format and can be part of the source code.
blocks
A wonderful and addictive game that shows the usage of FLTK
timers, graphics, and how to implement sound on all platforms.
blocks is also a good example for the Mac OS X specific
bundle format.
boxtype
boxtype gives an overview of readily available boxes and
frames in FLTK. More types can be added by the application programmer.
When using themes, FLTK shuffles boxtypes around to give your program
a new look.
browser
browser shows the capabilities of the Fl_Browser widget.
Important features tested are loading of files, line formatting, and
correct positioning of the browser data window.
button
The button test is a simple demo of push-buttons and callbacks.
buttons
buttons shows a sample of FLTK button types.
checkers
Written by Steve Poulsen in early 1979, checkers shows
how to convert a VT100 text-terminal based program into a neat
application with a graphical UI. Check out the code that drags the
pieces, and how the pieces are drawn by layering. Then tell me
how to beat the computer at Checkers.
clock
The clock demo shows two analog clocks. The innards of
the Fl_Clock widget are pretty interesting, explaining
the use of timeouts and matrix based drawing.
colbrowser
colbrowser runs only on X11 systems. It reads
/usr/lib/X11/rgb.txt to show the color representation
of every text entry in the file. This is beautiful, but
only moderately useful unless your UI is written in Motif.
color_chooser
The color_chooser gives a short demo of FLTK's palette based
color chooser and of the RGB based color wheel.
cube
The cube demo shows the speed of OpenGL. It also tests
the ability to render two OpenGL buffers into a single window,
and shows OpenGL text.
CubeView
CubeView shows how to create a UI containing OpenGL with Fluid.
cursor
The cursor demo shows all mouse cursor shapes that come standard
with FLTK. The fgcolor and bgcolor sliders work only
on few systems (some version of Irix for example).
curve
curve draws a nice Bezier curve into a custom widget. The
points option for splines is not supported on all platforms.
demo
This tool allows quick access to all programs in the test directory.
demo is based on the visuals of the IrixGL demo program. The menu
tree can be changed by editing test/demo.menu.
doublebuffer
The doublebuffer demo shows the difference between a single
buffered window, which may flicker during a slow redraw, and a
double buffered window, which never flickers, but uses twice the
amount of RAM. Some modern OS's double buffer all windows automatically
to allow transparency and shadows on the desktop. FLTK is smart enough
to not tripple buffer a window in that case.
editor
FLTK has two very different text input widgets. Fl_Input
and derived classes are rather leight weight, however
Fl_Text_Editor is a complete port of nedit (with permission).
The editor test is almost a full application, showing custom
syntax highlighting and dialog creation.
fast_slow
fast_slow shows how an application can use the when()
setting to receive different kinds of callbacks.
file_chooser
The standard FLTK file_chooser is the result of many
iterations, trying to find a middle ground between a complex
browser and a fast light implementation.
fonts
fonts shows all available text fonts on the host system.
If your machine still has some pixmap based fonts, the supported
sizes will be shown in bold face. Only the first 256 fonts will
be listed.
forms
forms is an XForms program with very few changes.
Search for "fltk" to find all changes necessary to port to fltk.
This demo shows the different boxtypes. Note that some
boxtypes are not appropriate for some objects.
fractals
fractals shows how to mix OpenGL, Glut and FLTK code.
FLTK supports a rather large subset of Glut, so that many Glut
applications compile just fine.
fullscreen
This demo shows how to do many of the window manipulations that
are popular for games.
You can toggle the border on/off, switch between single-
and double-buffered rendering, and take over the entire
screen. More information in the source code.
gl_overlay
gl_overlay shows OpenGL overlay plane rendering. If no
hardware overlay plane is available, FLTK will simulate it
for you.
glpuzzle
The glpuzzle test shows how most Glut source code compiles
easily under FLTK.
hello
hello: Hello, World. Need I say more? Well, maybe. This
tiny demo shows how little is needed to get a functioning application
running with FLTK. Quite impressive, I'd say.
help
help displays the built-in FLTK help browser. The
Fl_Help_Dialog understands a subset of html and renders
various image formats. This widget makes it easy to provide help
pages to the user without depending on the operating system's
html browser.
iconize
iconize demonstrates the effect of the window functions
hide(), iconize(), and show().
image
The image demo shows how an image can be created on the fly.
This generated image contains an alpha (transparency) channel which
lets previous renderings 'shine through', either via true
transparency or by using screen door transparency (pixelation).
inactive
inactive tests the correct rendering of inactive widgets.
To see the inactive version of images, you can check out the pixmap
or image test.
input
This tool shows and tests different types of text input fields based on
Fl_Input_. The input program also tests various
settings of Fl_Input::when().
input_choice
input_choice tests the latest addition to FLTK1, a text input
field with an attached pulldown menu. Windows users will recognize
similarities to the 'ComboBox'. input_choice starts up in
'plastic' scheme, but the traditional scheme is also supported.
keyboard
FLTK unifies keyboard events for all platforms. The keyboard
test can be used to check the return values of Fl::event_key()
and Fl::event_text(). It is also great to see the modifier
buttons and the scroll wheel at work. Quit this application by closing
the window. The ESC key will not work.
label
Every FLTK widget can have a label attached to it. The label
demo shows alignment, clipping, and wrapping of text labels. Labels
can contain symbols at the start and end of the text, like @FLTK
or @circle uh-huh @square.
line_style
Advanced line drawing can be tested with line_style.
Not all platforms support all line styles.
list_visuals
This little app finds all available pixel formats for the current X11
screen. But since you are now an FLTK user, you don't have to worry
about any of this.
mandelbrot
mandelbrot shows two advanced topics in one test. It creates
grayscale images on the fly, updating them via the idle callback
system. This is one of the few occasions where the idle callback
is very useful by giving all available processor time to the application
without blocking the UI or other apps.
menubar
The menubar tests many aspects of FLTK's popup menu system.
Among the features are radio buttons, menus taller than the screen,
arbitrary sub menu depth, and global shortcuts.
message
message pops up a few of FLTK's standard message boxes.
minimum
The minimum test program verifies that the update regions
are set correctly. In a real life application, the trail would
be avoided by choosing a smaller label or by setting label clipping
differently.
navigation
navigation demonstrates how the text cursor moves from
text field to text field when using the arrow keys, tab, and shift-tab.
output
output shows the difference between the single line and
multi line mode of the Fl_Output widget. Fonts can be
selected from the FLTK standard list of fonts.
overlay
The overlay test app shows how easy an FLTK window can
be layered to display cursor and manipulator style elements. This
example derives a new class from Fl_Overlay_Window and
provides a new function to draw custom overlays.
pack
The pack test program demonstrates the resizing
and repositioning of children of the Fl_Pack group.
Putting an Fl_Pack into an Fl_Scroll is
a useful way to create a browser for large sets of data.
pixmap_browser
pixmap_browser tests the shared-image interface. When using
the same image multiple times, Fl_Shared_Image will keep it
only once in memory.
pixmap
This simple test shows the use of a LUT based pixmap as a
label for a box widget. Pixmaps are stored in the X11 '.xpm'
file format and can be part of the source code. Pixmaps support
one transparent color.
preferences
I do have my preferences in the morning, but sometimes I
just can't remember a thing. This is where the Fl_Preferences
come in handy. They remember any kind of data between program launches.
radio
The radio tool was created entirely with fluid. It
shows some of the available button types and tests radio
button behavior.
resizebox
resizebox shows some possible ways of FLTK's automatic
resize behavior.
resize
The resize demo tests size and position functions with
the given window manager.
scroll
scroll shows how to scroll an area of widgets, one of
them being a slow custom drawing. Fl_Scroll uses
clipping and smart window area copying to improve redraw speed.
The buttons at the bottom of the window control decoration rendering
and updates.
shape
shape is a very minimal demo that shows how to create
your own OpenGL rendering widget. Now that you know that, go ahead
and write that flight simulator you always dreamt of.
subwindow
The subwindow demo tests messaging and drawing between
the main window and 'true' sub windows. A sub window is different
to a group by resetting the FLTK coordinate system to 0, 0 in the
top left corner. On Win32 and X11, subwindows have their own
operating system specific handle.
sudoku
Another highly addictive game - don't play it, I warned you.
The implementation shows how to create application icons,
how to deal with OS specifics, and how to generate sound.
symbols
symbols are a speciality of FLTK. These little vector
drawings can be integrated into labels. They scale and rotate,
and with a little patience, you can define your own. The rotation
number refers to 45 degree rotations if you were looking at a
numeric keypad (2 is down, 6 is right, etc.).
tabs
The tabs tool was created with fluid. It tests
correct hiding and redisplaying of tabs, navigation across tabs,
resize behavior, and no unneeded redrawing of invisible widgets.
threads
FLTK can be used in a multithreading environment. There are some
limitations, mostly due to the underlying operating system.
threads shows how to use Fl::lock(),
Fl::unlock(), and Fl::awake() in secondary threads
to keep FLTK happy. Although locking works on all platforms,
this demo is not available on every machine.
tile
The tile tool shows a nice way of using Fl_Tile.
To test correct resizing of subwindows, the widget for region
1 is created from an Fl_Window class.
tiled_image
The tiled_image demo uses an image as the background
for a window by repeating it over the full size of the widget.
The window is resizable and shows how the image gets repeated.
valuators
valuators shows all of FLTK's nifty widgets to change
numeric values.
fluid
fluid is not only a big test program, but also a very
useful visual UI designer. Many parts of fluid were
created using fluid.
fltk-1.1.10/documentation/FL.gif 0000644 0000765 0000000 00000014467 10332207117 015226 0 ustar matt wheel GIF89aÈ Æ 222vv"þþîîþþþ¢¢ÞÞ
TT?¤¤¤™™&qq,zz"îîînn:““CnnDššš~~"ÒÒªªªrrB¾¾¾––vvvŠŠ^::2^^^zzzb662nnk††jÎÎΊŠnjjV¦¦~~~††zZZ5–––ššžžžžž^^*rrrŠŠŠ:::zz+ffV666bbbfffjj:æææss:ªªnnT‚‚vjjivv+™™2jjL†††‚‚‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ!ù
, È þ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕ£5-)ÚÛ)ÝßÜáÞâàãæåèäêçëéìïîñíóðôòõø÷úâÖý„Û'NÈ #Æ„‚
"\¨°a‡ !:ŒHq¢E‰+f¼¨±#ÇCz rdEÇùk–ℇ†c ñ£¦Í›8sêÜɳ§ÏŸ@ƒ
J´¨Ñ£8gÄŒyЃʕÁ¶½LHæÍ@hÝʵ«×¯`Ê K¶¬Ù³hÓª]˶k þIe.dñ*.TcXýµß¿€ L¸0×
-lÎk…]Z)¦œQ³¯á˘3kÞÌù+âš‹Ò}Ì*‹‚Uùfí̺µë×°Ã~^ óÂ6Ò¥ £¦l9¶ïßÀƒ žÍôîPx'«Î¼¹óç²á†ž`üø¦ä1fô†Î½»w߈§W·^ »öÕßÓ«_Ÿ9<Âñä ™ßξ¾ýûkÝ„ ?‘îìôá'à€z¥ uý!bÜdèàƒø ¸A‚„¼ zf¨¡}úñgݨé€á†$–ø]:ÄDB|/pž‰0ÆÈÝ[JÅànÈ%¢Œ<öÈ Š2¹0¡]ÉÉÐ H&þ¹™{ú3aA;*)唜iÐÔ€x!•\vi˜~+N“# Qzi晡H–Ï$W&špÆyM6ód oʩ瞞逛ÈÀàˆ|Z(˜Ê€H&¡†6ʧš1 :Ìåéè¥{ €¤ÀŠ'£˜†
§•a
£¨¥rVpM p€A«Øtd~pýC«
X$Ô³n)§»Púé¡pi @ A³Ï:Ûl 0,—Ög5aÐòÐÆÐØþð Ü:Û > ©)±¸xŠê™oÁ°ì¹
¨€‚
öâ{¯
œ e® ¼u=œm `¯ üP_¸!ô S´ þtP/
ƒÃêúC©¼Èô®—ñΫð òÊ,p
T…•À7i[îÁõæ{CÊ4°ñŒ‰ÙôT,³9ß»³Êôm’úòÒ SYrÅ,½²ËùªP@Ê[/àoÛ}pÂ]£ 5Ë4íí-”ðjÑC{n ûª
6Û¨]Õ%V°˜‡¶Œ™nª)b½¶Ê¼€j#°ír¿æ*œ·
‹óͲßT3×Â怷¾ø¢¬¹æ<ü
W>0oØþ{+ŸwFxè0Æà ½Ò‰Äåíi£ø0ACŠÈõÌiÓHFÒçêv4Ðõ›o#¸´v Û±;ϲy‰Á8ž@•Ý€ç›Ö«ïXS sÅ KzÍ‘Nõ£uàâb1%ÞÍrÕ7y¤ëZ¹GY€°_NC. Š›gi°Øo´ åËÌŽ/4˜ÒÍ«¨W0€¼³ûþîiÓ
Àí ‚_â„çÑÏ‹Îx Û;ÝSÅ/XîÍøô9 ñúƒô°ÍVW¾ei/Ñ2ñk*ýó¹&¶l g±põ–·îéuke®„
ÐYÇ[ö²˜a½@.ÇÄïc$lØ0Úaévú,€y‡zÞøš{8^‹oÖ]ªðq1ÈÚ¡]–€˜Ævjw%¸N¥^Ììqï]Sß5â’…òã»»ó–~¾ùð(<^±Ë¶£\1áNÍs1%¼Ñu3â' _–pr}Œ±B7'9°Bø8¯¦Wrþöj¸B¨fDp$hU$—z''ˆ¡, ¸5+µÖ"#?þà ˆç€²p6¡29›‡;n„+—|
çtï—„ö‡?.¢XH2z–PzzâOÈ<Ì·mm1{½ã~iñz—ÅLùWË×|‹E`.ã3Uˆ€õ|•0|姆£z€A}‘—‚8%…—bp—¥‡>§d’³ :"‡ö!~’@~zÂJØs ÆzÇfj÷l—o>ça“h‡“`R•Añ"Ñ5Ø
˜)–…Åuckè€|(<‰¶Ê·‰òãCk¦=«Ô%>@ƒ“pƒìv^—ˆƒ²dh…8p[!‰yȆ®‡Œ2–oST.ã}àç#XŒÊˆþÐÈlÎX˜>dæ`e‚ˆVffnlX‹Œ£ˆÜsg¨¨ÆH|å¸P†Xf€<Ȧv](<È—|Z¯†E`CŠ["©È)R&²xbˆ:ÛèPx¨nõˆw Y{ž\‰?ר$£÷r‰ za¦‰®ˆnO–jßØ„ˆoõÈŒ9F†žÑŽv¥A!©$£6 œ8%³Èi H!æ‰÷å‡×b”Ì3Ž „ðuÛcE¤“°Šz‚QÁÓl€q‹gfL\É<ýx_ B˜0â†Gô‚RIVÀ V)'á¸d©ðgDùhu‰-ùyy:™d Ê–U!Âþˆ$Òm sI"class Fl
Class Hierarchy
Fl
Include Files
#include <FL/Fl.H>
Description
Methods
void add_check(Fl_Timeout_Handler, void* = 0);
bool state_changed; // anything that changes the display turns this on
void callback(void*) {
if (!state_changed) return;
state_changed = false;
do_expensive_calculation();
widget->redraw();
}
main() {
Fl::add_check(callback);
return Fl::run();
}
void add_fd(int fd, void (*cb)(int,void*),void* =0);
void add_fd(int fd, int when, void (*cb)(int, void*), void* = 0);void add_handler(int (*h)(int));
void add_idle(void (*cb)(void*), void* = 0);
void add_timeout(double t, Fl_Timeout_Handler,void* = 0);
void callback(void*) {
puts("TICK");
Fl::repeat_timeout(1.0, callback);
}
int main() {
Fl::add_timeout(1.0, callback);
return Fl::run();
}
int arg(int, char**, int&);
int args(int, char**, int&, int (*)(int,char**,int&) = 0);
void (*atclose)(Fl_Window*,void*);
void awake(void *p);
int awake(void (*callback)(void*), void *userdata);
void background2(uchar, uchar, uchar);
void background(uchar, uchar, uchar);
Fl_Widget* belowmouse();
void belowmouse(Fl_Widget*);int box_dh(Fl_Boxtype);
int box_dw(Fl_Boxtype);
int box_dx(Fl_Boxtype);
int box_dy(Fl_Boxtype);
int X = yourwidget->x() + Fl::box_dx(yourwidget->box());
int Y = yourwidget->y() + Fl::box_dy(yourwidget->box());
int W = yourwidget->w() - Fl::box_dw(yourwidget->box());
int H = yourwidget->h() - Fl::box_dh(yourwidget->box());
int check();
while (!calculation_done()) {
calculate();
Fl::check();
if (user_hit_abort_button()) break;
}
int compose(int &del);
void compose_reset();
void copy(const char *stuff, int len, int clipboard);
int damage();
void damage(int x);void default_atclose(Fl_Window*,void*);
void delete_widget(Fl_Widget*);
void display(const char*);
int dnd();
void dnd_text_ops(int d);
int dnd_text_ops();void (*error)(const char*, ...);
int event_alt();
int event_button1();
int event_button2();
int event_button3();
int event_button();
int event_buttons();
int event_clicks();
void event_clicks(int i);int event_ctrl();
int event();
int event_inside(int,int,int,int);
int event_inside(const Fl_Widget*);int event_is_click();
void event_is_click(0);int event_key();
int event_key(int s);
int event_length();
int event_original_key();
int event_shift();
int event_state();
int event_state(int i);
int event_x();
int event_x_root();
int event_y();
int event_y_root();
void (*fatal)(const char*, ...);
Fl_Window* first_window();
void first_window(Fl_Window*);void flush();
Fl_Widget* focus();
void focus(Fl_Widget*);void foreground(uchar, uchar, uchar);
void free_color(Fl_Color c, int overlay = 0);
Fl_Box_Draw_F *get_boxtype(Fl_Boxtype);
unsigned get_color(Fl_Color c);
void get_color(Fl_Color c, uchar&r, uchar&g, uchar&b);const char* get_font(Fl_Font);
const char* get_font_name(Fl_Font, int* attributes = 0);
int get_font_sizes(Fl_Font, int*& sizep);
int get_key(int);
void get_mouse(int &x,int &y);
void get_system_colors();
int gl_visual(int, int *alist=0);
Fl_Window* grab();
void grab(Fl_Window&w) {grab(&w);}int h();
int handle(int, Fl_Window*);
int has_check(Fl_Timeout_Handler, void* = 0);
int has_idle(void (*cb)(void*), void* = 0);
int has_timeout(Fl_Timeout_Handler, void* = 0);
void lock();
Fl_Window* modal();
Fl_Window* next_window(const Fl_Window*);
void own_colormap();
void paste(Fl_Widget &receiver, int clipboard=0);
Fl_Widget* pushed();
void pushed(Fl_Widget*);Fl_Widget* readqueue();
int ready();
while (!calculation_done()) {
calculate();
if (Fl::ready()) {
do_expensive_cleanup();
Fl::check();
if (user_hit_abort_button()) break;
}
}
void redraw();
void release();
void remove_check(Fl_Timeout_Handler, void* = 0);
void remove_fd(int, int when);
void remove_fd(int);void remove_handler(int (*h)(int));
void remove_idle(void (*cb)(void*), void* = 0);
void remove_timeout(Fl_Timeout_Handler, void* = 0);
void repeat_timeout(double t, Fl_Timeout_Handler,void* = 0);
void callback(void*) {
puts("TICK");
Fl::repeat_timeout(1.0, callback);
}
int main() {
Fl::add_timeout(1.0, callback);
return Fl::run();
}
int run();
void scheme(const char *name);
const char *scheme();
int screen_count();
void screen_xywh(int &x, int &y, int &w, int &h);
void screen_xywh(int &x, int &y, int &w, int &h, int mx, int my);
void screen_xywh(int &x, int &y, int &w, int &h, int n);void scrollbar_size(int W);
int scrollbar_size();void selection(Fl_Widget &owner, const char* stuff, int len);
Fl_Widget* selection_owner();
void selection_owner(Fl_Widget*);void set_abort(void (*f)(const char*,...));
void set_atclose(void (*f)(Fl_Window*,void*));
void set_boxtype(Fl_Boxtype, Fl_Box_Draw_F*,uchar,uchar,uchar,uchar);
void set_boxtype(Fl_Boxtype, Fl_Boxtype from);void set_color(Fl_Color, uchar, uchar, uchar);
void set_color(Fl_Color, unsigned);void set_font(Fl_Font, const char*);
void set_font(Fl_Font, Fl_Font);Fl_Font set_fonts(const char* = 0);
void set_idle(void (*cb)());
void set_labeltype(Fl_Labeltype,Fl_Label_Draw_F*,Fl_Label_Measure_F*);
int test_shortcut(int);
void *thread_message();
void unlock();
double version();
void visible_focus(int v);
int visible_focus();int visual(int);
Full/true color (if there are several depths FLTK chooses the
largest). Do this if you use fl_draw_image
for much better (non-dithered) output.
Full color with at least 24 bits of color. FL_RGB will
always pick this if available, but if not it will happily return a
less-than-24 bit deep visual. This call fails if 24 bits are not
available.
Hardware double buffering. Call this if you are going to use
Fl_Double_Window.
Hardware double buffering and full color.
int w();
int wait();
double wait(double time);void (*warning)(const char*, ...);
int x();
int y();
int event_dx();
Returns the current horizontal mouse scrolling associated with the
FL_MOUSEWHEEL event. Right is positive.
int event_dy();
Returns the current vertical mouse scrolling assoaciated with the
FL_MOUSEWHEEL event. Down is positive.
const char* event_text();
Returns the text associated with the current FL_PASTE or
FL_DND_RELEASE event.
fltk-1.1.10/documentation/Fl_Adjuster.html 0000644 0000765 0000000 00000003520 10521133643 017314 0 ustar matt wheel
class Fl_Adjuster
Class Hierarchy
Fl_Valuator
|
+----Fl_Adjuster
Include Files
#include <FL/Fl_Adjuster.H>
Description
The Fl_Adjuster widget was stolen from Prisms, and has proven
to be very useful for values that need a large dynamic range.
Methods
Fl_Adjuster::Fl_Adjuster(int x, int
y, int w, int h, const char *label = 0)
Creates a new Fl_Adjuster widget using the given position,
size, and label string. It looks best if one of the dimensions is 3
times the other.
virtual Fl_Adjuster::~Fl_Adjuster()
Destroys the valuator.
uchar Fl_Adjuster::soft() const
If "soft" is turned on, the user is allowed to drag the value outside
the range. If they drag the value to one of the ends, let go, then
grab again and continue to drag, they can get to any value. Default is
one.
fltk-1.1.10/documentation/fl_alert.gif 0000644 0000765 0000000 00000003212 10332207117 016477 0 ustar matt wheel GIF87ašg  ÀÀÀõõõUUUÿÿÿ ÿ ÕÕÕŠŠŠ, šg @þºÜþ0ÊI«½8ëÍ»ÿ`(Ždižhª®lë¾° tmßx®ïµÿÀ pH,2f< a¹L&}‹ÂC
*¬…,¶š½j« ª´Ëu|Åáè—Ûµ‚½díXM¯áîè•m>óéy€zwlnra„‚hq†‰‚vŒm{w†{z‘^0HN:L
void Fl_Adjuster::soft(uchar)class Fl_Bitmap
Class Hierarchy
Fl_Image
|
+----Fl_Bitmap
|
+----Fl_XBM_Image
Include Files
#include <FL/Fl_Bitmap.H>
Description
Methods
Fl_Bitmap::Fl_Bitmap(const char *array, int W, int H);
Fl_Bitmap::Fl_Bitmap(const unsigned char *array, int W, int H);Fl_Bitmap::~Fl_Bitmap();
class Fl_BMP_Image
Class Hierarchy
Fl_RGB_Image
|
+----Fl_BMP_Image
Include Files
#include <FL/Fl_BMP_Image.H>
Additional Libraries
-lfltk_images / fltkimages.lib
Description
Methods
Fl_BMP_Image::Fl_BMP_Image(const char *filename);
Fl_BMP_Image::~Fl_BMP_Image();
class Fl_Box
Class Hierarchy
Fl_Widget
|
+----Fl_Box
Include Files
#include <FL/Fl_Box.H>
Description
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.
Methods
Fl_Box::Fl_Box(int x, int y, int w, int h,
const char * = 0)
The first constructor sets box() to FL_NO_BOX, which
means it is invisible. However such widgets are useful as placeholders
or Fl_Group::resizable()
values. To change the box to something visible, use box(n).
Fl_Box::Fl_Box(Fl_Boxtype b, int x, int y, int w, int h, const
char *)Fl_Box::~Fl_Box(void)
The destructor removes the box.
fltk-1.1.10/documentation/Fl_Browser.html 0000644 0000765 0000000 00000025351 10735300124 017161 0 ustar matt wheel
class Fl_Browser
Class Hierarchy
Fl_Browser_
|
+----Fl_Browser
|
+----Fl_File_Browser, Fl_Hold_Browser, Fl_Multi_Browser, Fl_Select_Browser
Include Files
#include <FL/Fl_Browser.H>
Description
The Fl_Browser widget displays a scrolling list of text
lines, and manages all the storage for the text. This is not a text
editor or spreadsheet! But it is useful for showing a vertical list of
named objects to the user.
Methods
Fl_Browser::Fl_Browser(int, int, int,
int, const char * = 0)
The constructor makes an empty browser.
Fl_Browser::~Fl_Browser(void)
The destructor deletes all list items and destroys the browser.
void Fl_Browser::add(const char *, void * =
0)
Add a new line to the end of the browser. The text is copied using
the strdup() function. It may also be NULL to make a
blank line. The void * argument is returned as the data()
of the new item.
void Fl_Browser::bottomline(int n)
Scrolls the browser so the bottom line in the browser is n.
void Fl_Browser::clear()
Remove all the lines in the browser.
uchar Fl_Browser::column_char() const
The first form gets the current column separator character. By default
this is '\t' (tab).
void Fl_Browser::column_char(char c)const int
*Fl_Browser::column_widths() const
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 column_char() and each part is formatted
into it's own column. After the last column any remaining text is
formatted into the space between the last column and the right edge of
the browser, even if the text contains instances of column_char()
. The default value is a one-element array of just a zero, which makes
there are no columns.
void Fl_Browser::column_widths(const int *w)void *Fl_Browser::data(int n) const
The first form returns the data for line n. If n is
out of range this returns NULL.
void Fl_Browser::data(int n, void *)uchar Fl_Browser::format_char() const
The first form gets the current format code prefix character, which by
default is @. A string of formatting codes at the start of
each column are stripped off and used to modify how the rest of the
line is printed:
void Fl_Browser::format_char(char c)
Notice that the @. Print rest of line, don't look for more '@' signs @@ Print rest of line starting with '@' @l Use a large (24 point) font @m Use a medium large (18 point) font @s Use a small (11 point) font @b Use a bold font (adds FL_BOLD to font) @i Use an italic font (adds FL_ITALIC to font) @f or @t Use a fixed-pitch
font (sets font to FL_COURIER) @c Center the line horizontally @r Right-justify the text @B0, @B1, ... @B255 Fill the backgound with
fl_color(n) @C0, @C1, ... @C255 Use fl_color(n) to draw the text @F0, @F1, ... Use fl_font(n) to draw the text @S1, @S2, ... Use point size n to draw the text @u or @_ Underline the text. @- draw an engraved line through the middle. @. command can be used to reliably
terminate the parsing. To print a random string in a random color, use
sprintf("@C%d@.%s", color, string) and it will work even if the
string starts with a digit or has the format character in it.
void Fl_Browser::hide(int n)
Makes line n invisible, preventing selection by the user.
The line can still be selected under program control.
void Fl_Browser::insert(int n, const char
*, void * = 0)
Insert a new line before line n. If n >
size() then the line is added to the end.
int Fl_Browser::load(const char *filename)
Clears the browser and reads the file, adding each line from the file
to the browser. If the filename is NULL 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 errno
is set to the system error. The data() of each line is set
to NULL.
void Fl_Browser::middleline(int n)
Scrolls the browser so the middle line in the browser is n.
void Fl_Browser::move(int to, int from)
Line from is removed and reinserted at to; to
is calculated after the line is removed.
int Fl_Browser::position() const
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.
void Fl_Browser::position(int p)void Fl_Browser::remove(int n)
Remove line n and make the browser one line shorter.
int Fl_Browser::selected(int n) const
Return 1 if line n is selected, 0 if it not selected.
void Fl_Browser::show(int n)
Makes line n visible for selection.
int Fl_Browser::size() const
Returns how many lines are in the browser. The last line number is
equal to this.
void Fl_Browser::swap(int a, int b)
Swaps two lines in the browser.
const char *Fl_Browser::text(int n) const
The first form returns the text for line n. If n is
out of range it returns NULL.
void Fl_Browser::text(int n, const char *)int Fl_Browser::topline() const
The first form returns the current top line in the browser. If there
is no vertical scrollbar then this will always return 1.
void Fl_Browser::topline(int n)int Fl_Browser::visible(int n) const
Returns a non-zero value if line n is visible.
fltk-1.1.10/documentation/Fl_Browser_.html 0000644 0000765 0000000 00000035534 10735300124 017324 0 ustar matt wheel
class Fl_Browser_
Class Hierarchy
Fl_Group
|
+----Fl_Browser_
|
+----Fl_Browser, Fl_Check_Browser
Include Files
#include <FL/Fl_Browser_.H>
Description
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.
Methods
Fl_Browser::Fl_Browser(int, int,
int, int, const char * = 0)
Fl_Browser::~Fl_Browser(void)
Fl_Browser_::bbox(int &x, int &y, int &w, int &h) const
Fl_Browser_::deleting(void *a)
int Fl_Browser_::deselect(int docb=0)
Fl_Browser_::display(void *p)
int Fl_Browser_::displayed(void *p) const
Fl_Browser_::draw()
Fl_Browser_::draw(int x, int y, int w, int h)void *Fl_Browser_::find_item(int my)
virtual int Fl_Browser_::full_height() const
Fl_Browser_::full_width() const
Fl_Browser_::handle(int event)
Fl_Browser_::handle(int event, int x, int y, int w, int h)void
Fl_Browser_::has_scrollbar(int h)
0 - No scrollbars.
Fl_Browser_::HORIZONTAL - Only a horizontal
scrollbar.
Fl_Browser_::VERTICAL - Only a vertical
scrollbar.
Fl_Browser_::BOTH - The default is both
scrollbars.
Fl_Browser_::HORIZONTAL_ALWAYS - Horizontal
scrollbar always on, vertical always off.
Fl_Browser_::VERTICAL_ALWAYS - Vertical
scrollbar always on, horizontal always off.
Fl_Browser_::BOTH_ALWAYS - Both always on.
int Fl_Browser_::hposition() const
Fl_Browser_::hposition(int h)virtual int Fl_Browser_::incr_height() const
Fl_Browser_::inserting(void *a, void *b)
virtual void Fl_Browser_::item_draw(void *p, int x, int y, int w, int h)
virtual void *Fl_Browser_::item_first() const
virtual int Fl_Browser_::item_height(void *p) const
virtual void *Fl_Browser_::item_next(void *p) const
virtual void *Fl_Browser_::item_prev(void *p) const
virtual int Fl_Browser_::item_quick_height(void *p) const
virtual void Fl_Browser_::item_select(void *p, int s=1)
virtual int Fl_Browser_::item_selected(void *p) const
virtual int Fl_Browser_::item_width(void *p) const
int Fl_Browser_::leftedge() const
Fl_Browser_::new_list()
int Fl_Browser_::position() const
Fl_Browser_::position(int v) constFl_Browser_::redraw_line(void *p)
Fl_Browser_::redraw_lines()
Fl_Browser_::replacing(void *a, void *b)
Fl_Browser_::resize(int x, int y, int w, int h)
Fl_Browser_::scrollbar_left()
Fl_Browser_::scrollbar_right()
static void Fl_Browser_::scrollbar_width(int sw);
static int Fl_Browser_::scrollbar_width() const;int Fl_Browser_::select(void *p, int s=1, int docb=0)
Fl_Browser_::select_only(void *p, int docb=0)
void *Fl_Browser_::selection() const
Fl_Color Fl_Browser_::textcolor() const
void Fl_Browser_::textcolor(Fl_Color color)Fl_Font Fl_Browser_::textfont() const
void Fl_Browser_::textfont(Fl_Font font)uchar Fl_Browser_::textsize() const
void Fl_Browser_::textsize(uchar size)void *Fl_Browser_::top() const
class Fl_Button
Class Hierarchy
Fl_Widget
|
+----Fl_Button
|
+----Fl_Check_Button, Fl_Light_Button, Fl_Repeat_Button,
Fl_Return_Button, Fl_Round_Button, Fl_Toggle_Button
Include Files
#include <FL/Fl_Button.H>
Description
Methods
Fl_Button::Fl_Button(int x, int y, int
w, int h, const char *label = 0)
The constructor creates the button using the position, size, and
label.
Fl_Button::~Fl_Button(void)
The destructor removes the button.
int Fl_Button::clear()
Same as value(0).
Fl_Boxtype Fl_Button::down_box() const
The first form returns the current down box type, which is drawn when
value() is non-zero.
void Fl_Button::down_box(Fl_Boxtype bt)int Fl_Button::set()
Same as value(1).
void Fl_Button::setonly()
Turns on this button and turns off all other radio buttons in the
group (calling value(1) or set() does not do this).
ulong Fl_Button::shortcut() const
The first form returns the current shortcut key for the button.
void Fl_Button::shortcut(ulong key)FL_ALT | 'a'
, FL_ALT | (FL_F + 10), or just 'a'. A value
of 0 disables the shortcut. uchar Fl_Button::type() const
The first form of type() returns the current button type,
which can be one of:
void Fl_Button::type(uchar t)
The second form sets the button type to t.
0: The value is unchanged. FL_TOGGLE_BUTTON: The value is inverted. FL_RADIO_BUTTON: The value is set to 1, and all other
buttons in the current group with type() == FL_RADIO_BUTTON
are set to zero. char Fl_Button::value() const
The first form returns the current value (0 or 1). The second form
sets the current value.
int Fl_Button::value(int)Fl_When Fl_Widget::when() const
Controls when callbacks are done. The following values are useful,
the default value is
void Fl_Widget::when(Fl_When w)FL_WHEN_RELEASE:
fltk-1.1.10/documentation/Fl_Chart.html 0000644 0000765 0000000 00000010732 10521133643 016577 0 ustar matt wheel
0: The callback is not done, instead changed() is
turned on. FL_WHEN_RELEASE: The callback is done after the user
successfully clicks the button, or when a shortcut is typed. FL_WHEN_CHANGED : The callback is done each time the
value() changes (when the user pushes and releases the button, and as
the mouse is dragged around in and out of the button). class Fl_Chart
Class Hierarchy
Fl_Widget
|
+----Fl_Chart
Include Files
#include <FL/Fl_Chart.H>
Description
This widget displays simple charts and is provided for Forms compatibility.
Methods
Fl_Chart::Fl_Chart(int x, int y, int w,
int h, const char *label = 0)
Creates a new Fl_Chart widget using the given position, size,
and label string. The default boxtype is FL_NO_BOX.
virtual Fl_Chart::~Fl_Chart()
Destroys the Fl_Chart widget and all of its data.
void add(double value, const char *label =
NULL, uchar color = 0)
The add method adds the value and optionally
label and color to the chart.
uchar autosize(void) const
The autosize 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.
void autosize(uchar onoff)void bounds(double *a, double *b)
The bounds method gets or sets the lower and upper bounds of
the chart values to a and b respectively.
void bounds(double a, double b)void clear(void)
The clear method removes all values from the chart.
void insert(int pos, double value, const
char *label = NULL, uchar color = 0)
The insert method inserts a data value at the given position
pos. Position 1 is the first data value.
int maxsize(void) const
The maxsize 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.
void maxsize(int n)void replace(int pos, double value, const
char *label = NULL, uchar color = 0)
The replace method replaces data value pos with
value, label, and color. Position 1 is the
first data value.
int size(void) const
The size method returns the number of data values in the
chart.
uchar type() const
The first form of type() returns the current chart type. The
chart type can be one of the following:
void type(uchar t)
The second form of type() sets the chart type to t.
fltk-1.1.10/documentation/Fl_Check_Browser.html 0000644 0000765 0000000 00000007272 10720330237 020262 0 ustar matt wheel
class Fl_Check_Browser
Class Hierarchy
Fl_Browser_
|
+----Fl_Check_Browser
Include Files
#include <FL/Fl_Check_Browser.H>
Description
The Fl_Check_Browser widget displays a scrolling list of text
lines that may be selected and/or checked by the user.
Methods
Fl_Check_Browser::Fl_Check_Browser(int, int, int, int, const char * = 0)
The constructor makes an empty browser.
int Fl_Check_Browser::add(const char *)
Add a new unchecked line to the end of the browser. The text is copied
using the strdup() function. It may also be NULL to make
a blank line. The second form can set the item checked.
int Fl_Check_Browser::add(const char *, int)void Fl_Check_Browser::check_all()
Sets all the items checked.
void Fl_Check_Browser::check_none()
Sets all the items unchecked.
int Fl_Check_Browser::checked(int item) const
The first form gets the current status of item item. The second form
sets the check status of item item to b.
void Fl_Check_Browser::checked(int item, int b)void Fl_Check_Browser::clear()
Remove every item from the browser.
int Fl_Check_Browser::nchecked() const
Returns how many items are currently checked.
int Fl_Check_Browser::nitems() const
Returns how many lines are in the browser. The last line number is equal to
this.
int Fl_Check_Browser::remove(int n)
Remove line n and make the browser one line shorter. Returns the
number of lines left in the browser.
void Fl_Check_Browser::set_checked(int item)
Equivalent to Fl_Check_Browser::checked(item, 1).
char *Fl_Check_Browser::text(int item) const
Return a pointer to an internal buffer holding item item's text.
int Fl_Check_Browser::value() const
Returns the index of the currently selected item.
fltk-1.1.10/documentation/Fl_Check_Button.gif 0000644 0000765 0000000 00000000552 10332207117 017704 0 ustar matt wheel GIF89a  ÜÜܺººúúú ÏÏÏÿÿÿÿÿÿÿÿÿ!ù
, @þºÜþ0ÊI«½Ø†Á»'BäuÊP‘‹™5*5¶külEmÛ Á¯Â¿ #à9|¥arYT6S²¨tJZ¯Ø¬öJ»Ýr»°n÷+—ÌE¢‘Å~.[p4ç¼Ûïø¼~Ïïûÿ]^5`B†cPn2k‡L‡ŒS‚ƒ…Gb–•‰/Ž)N™Np‰ož§¨©”m˜(Žqsœ²Šš³n²º¯@€¾¿ÀÁÂÃÄÅÆÇÈÉÊ~ÍÎÏÍ!ËÓ’^«¤ÙGq›+¤´[Ö_ÒÚèI¯iá ¢Hµì#g´&륃8æÛîÝéä \sÏ=XLB}•o ¡~¬"¶šHD¢:mzåbX0Q‘rüYdÁm 9 '>Ù• ÈœIs&µ›¿^„Ó£óΟ@ƒ
J4J ; fltk-1.1.10/documentation/Fl_Check_Button.html 0000644 0000765 0000000 00000002721 10521133643 020105 0 ustar matt wheel
class Fl_Check_Button
Class Hierarchy
Fl_Button
|
+----Fl_Check_Button
Include Files
#include <FL/Fl_Check_Button.H>
Description
Buttons generate callbacks when they are clicked by the user. You
control exactly when and how by changing the values for type()
and when().
Methods
Fl_Check_Button::Fl_Check_Button(int x, int y, int w, int h, const char
*label = 0)
Creates a new Fl_Check_Button widget using the given
position, size, and label string.
Fl_Check_Button::~Fl_Check_Button()
The destructor deletes the check button.
fltk-1.1.10/documentation/fl_choice.gif 0000644 0000765 0000000 00000002757 10332207117 016637 0 ustar matt wheel GIF87ašg  ÀÀÀõõõUUUÿÿÿ ÿ ÕÕÕŠŠŠ, šg @þºÜþ0ÊI«½8ëÍ»ÿ`(Ždižhª®lë¾° tmßx®ïµÿÀ pH,2f¼ ai[2“9ŸqJZ¯S$”çÜꤊBD\(3ÊæZ¬FŸÝµ ×rzÚn&ïõ||ltami„‰†…wnl„X‘’Z^7]–Q“››œŸ“•™£I` §¨©ª-¢¤®8¦«²³´µ¶·¸¹º»¸¼ž
¾dŒÇÆÉÈËÊÍÌÏÎÑÇÂ2¿ÀÔ×/¾Ã…sß‹qgx ÙÅÞãàîæàòÞsèöÖìåáßðü‰ˆ!Ÿ¶Ü.0HÌ@½\b Ù§P¢Â‹3jÜÈþ±£Ç,¯BjúH²äµV"_Å2ɲå*”PžÐp"ÓÒJ—8sJ‚i‰@ʦ ¶[4pž ¢ëü
ýGî ½y›.u7µ(@¥uòâ¹SÈ›ZÊ
Âõ§°cÓª]˶۷pãÊ•ÄçÝîÂÝxþ†¹Ç áBÔý ب…<»]üøQ@ËGbÖ“¹ñÉ}émž:ºóhO –‘/ÅÊ•–æLÑå
’Û®ÙÍ»·ïßÀƒ ¾›5ñãÈ“+ÿm|¹óçÐyÏN½ºõëسkß.$€÷ïàË O¾class Fl_Choice
Class Hierarchy
Fl_Menu_
|
+----Fl_Choice
Include Files
#include <FL/Fl_Choice.H>
Description
This is a button that when pushed pops up a menu (or hierarchy of
menus) defined by an array of
Fl_Menu_Item objects. Motif calls this an OptionButton.
Methods
Fl_Choice::Fl_Choice(int x, int y, int
w, int h, const char *label = 0)
Creates a new Fl_Choice widget using the given position,
size, and label string. The default boxtype is FL_UP_BOX.
virtual Fl_Choice::~Fl_Choice()
The destructor removes the Fl_Choice widget and all of its
menu items.
int Fl_Choice::value() const
The value is the index into the Fl_Menu 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 redraw().
int Fl_Choice::value(int)
int Fl_Choice::value(const Fl_Menu *)int Fl_Widget::changed() const
This value is true if the user picks a different value. It is
turned off by value() and just before doing a callback (the
callback can turn it back on if desired).
void Fl_Widget::set_changed()
This method sets the changed() flag.
void Fl_Widget::clear_changed()
This method clears the changed() flag.
Fl_Boxtype Fl_Choice::down_box() const
The first form gets the current down box, which is used when the menu
is popped up. The default down box type is FL_DOWN_BOX The
second form sets the current down box type to b.
fltk-1.1.10/documentation/Fl_Clock.html 0000644 0000765 0000000 00000003461 10563140610 016570 0 ustar matt wheel
void Fl_Choice::down_box(Fl_Boxtype b)class Fl_Clock
Class Hierarchy
Fl_Clock_Output
|
+----Fl_Clock
Include Files
#include <FL/Fl_Clock.H>
Description
This widget provides a round analog clock display and is provided for
Forms compatibility. It installs a 1-second timeout callback using
Fl::add_timeout().
Methods
Fl_Clock::Fl_Clock(int x, int y, int w,
int h, const char *label = 0)
Creates a new Fl_Clock widget using the given position, size,
and label string. The default boxtype is FL_NO_BOX.
virtual Fl_Clock::~Fl_Clock()
The destructor removes the clock.
int Fl_Clock_Output::hour() const
Returns the current hour (0 to 23).
int Fl_Clock_Output::minute() const
Returns the current minute (0 to 59).
int Fl_Clock_Output::second() const
Returns the current second (0 to 60, 60 = leap second).
ulong Fl_Clock::value(void)
Returns the displayed time in seconds since the UNIX epoch (January 1, 1970).
fltk-1.1.10/documentation/Fl_Clock_Output.html 0000644 0000765 0000000 00000004305 10563140610 020146 0 ustar matt wheel
class Fl_Clock_Output
Class Hierarchy
Fl_Widget
|
+----Fl_Clock_Output
|
+----Fl_Clock
Include Files
#include <FL/Fl_Clock.H>
Description
Methods
Fl_Clock_Output::Fl_Clock_Output(int x, int y, int w,
int h, const char *label = 0)
Creates a new Fl_Clock_Output widget using the given position, size,
and label string. The default boxtype is FL_NO_BOX.
virtual Fl_Clock_Output::~Fl_Clock_Output()
The destructor removes the clock.
int Fl_Clock_Output::hour() const
Returns the current hour (0 to 23).
int Fl_Clock_Output::minute() const
Returns the current minute (0 to 59).
int Fl_Clock_Output::second() const
Returns the current second (0 to 60, 60 = leap second).
void Fl_Clock_Output::value(ulong v)
The first two forms of value set the displayed time to the
given UNIX time value or specific hours, minutes, and seconds.
void Fl_Clock_Output::value(int h, int m, int s)
ulong Fl_Clock_Output::value(void)class Fl_Color_Chooser
Class Hierarchy
Fl_Group
|
+----Fl_Color_Chooser
Include Files
#include <FL/Fl_Color_Chooser.H>
Description
The Fl_Color_Chooser 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 same rgb value, such as when saturation
or value is zero.
Methods
Fl_Color_Chooser::Fl_Color_Chooser(int x, int y, int w, int h, const
char *label = 0)
Creates a new Fl_Color_Chooser widget using the given
position, size, and label string. The recommended dimensions are
200x95. The color is initialized to black.
virtual
Fl_Color_Chooser::~Fl_Color_Chooser()
The destructor removes the color chooser and all of its controls.
double Fl_Color_Chooser::hue() const
Return the current hue. 0 <= hue < 6. Zero is red, one is yellow,
two is green, etc. This value is convienent for the internal
calculations - some other systems consider hue to run from zero to one,
or from 0 to 360.
double
Fl_Color_Chooser::saturation() const
Returns the saturation. 0 <= saturation <= 1.
double Fl_Color_Chooser::value()
const
Returns the value/brightness. 0 <= value <= 1.
double Fl_Color_Chooser::r() const
Returns the current red value. 0 <= r <= 1.
double Fl_Color_Chooser::g() const
Returns the current green value. 0 <= g <= 1.
double Fl_Color_Chooser::b() const
Returns the current blue value. 0 <= b <= 1.
int Fl_Color_Chooser::rgb(double,
double, double)
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).
int
Fl_Color_Chooser::hsv(double,double,double)
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.
static void
Fl_Color_Chooser::hsv2rgb(double, double, double, double&, double&,
double&)
This static method converts HSV colors to RGB colorspace.
static void
Fl_Color_Chooser::rgb2hsv(double, double, double, double&, double&,
double&)
This static method converts RGB colors to HSV colorspace.
fltk-1.1.10/documentation/fl_color_chooser.jpg 0000644 0000765 0000000 00000017016 10332207117 020252 0 ustar matt wheel ÿØÿà JFIF H H ÿþ Created with The GIMPÿÛ C
$.' ",# (7),01444 '9=82<.342ÿÛ C
2! !22222222222222222222222222222222222222222222222222ÿÀ È ×" ÿÄ ÿÄ Q
!1“Ó"AQSTVat‘”²ÑÒ36u•³#2DERbr’Â57BUq£±Ôâ$&„e¡´ÿÄ ÿÄ - 1q‘¡±Ñ!4ABQRa$ÁÿÚ ? ëˆB纳V_mš¢Ku¶Z(àe,S=;¤qsœðxÃÛÅØJærP\¥ÐŽÛaL æð‘й/áƬð«W¨¿¥_?ug…Z½Eý*®õ”.²ðe?jé??èu´.Iøu«<*Õê/éW¡õYüîÕê/éWpÓ/«Áú ÏJúOÁú e ”g«ç–¯PJ¤»V Ïm^ þ•yí-/åàý c¢]%àΤ…̪ՇóëWÙïéTƒSjÃùý«ì÷ôË—ºi×àý UЗFt´.n5¬?¤m_g?¦^ÅûV ÒV¯³ŸÓ.}¯£üü ¡*÷ô:*;7ÝVô«ìçôÊ7j-VßÒ6¯³ŸÓ"Ýôoëð~„Š©¾ˆé\ÍÚŸUÒ¯³ßÓ'÷Ûãô«ê¤ª¢5ï¹ÓQÇ#i\#ce{IfÞ\FÑ?”9þg§]§¾\+–_côªq\¤½ÆÑ /j¯í_d?ýÂôËn¦ŽF¾ký¶HšA{js æöÀqœàã·ƒŽáWxH‡œGKu]|Öm;w¸R†o©)å–0ñ–å “‰s;§U9-7zÛl÷wºj:‰)ätv–—1ŤŒÖŒŽâ꺧kã–zÞ:y ‹ü±ïY¾ÀoûÔ|±ïY¾ÀoûÕ?ø:ÁžrGhBâÿ ,CûÖo°þñntåmïSXi®ôz†Ž:z½–ÏdpxÙyiÈ$r´öÔVéí©fqÁêiô5èIx7RøËlûÿ îÝ;Y]ToT÷
ˆj% ®m3%†sL,“;%ÎÁËÈåíE èåB \›[ý=©ó
oneÖW'ÖßOj¾¯¦öæPêkhÎݾÏ4$!y!{!|ÙÊƲ³ã‘ ŒjöÖ)ÌNu+¼÷U–5xªË£u´DúÆ©ÚÔ1ªfµE*jb|kTn¦µ}bK*5)‰ŽUdz–W*R? ˆÖÑ£\ïNéÿ f0÷/öÿ ¿‰fß"Jïû=ËõßD¶vxãR»æ²8¥~¾>l±Ãºýÿ •}eÀg•}“è`®¥^¨ Bµ'™Oì•Ä!ÓÔšªö¦†ç$ðÚi*î5•óÀà ,{ÎÐ öE£ ÇÉÛ]¿ªÐIæSû%p A¨jìúŸ][é#¼)p¨†Z’&db¡îsàFþ àrYÛ’Qëú‰§Ð³U§´• ™‡Q™/rÑO³KMK+¢¦žª¡§2ÌÓ‡†ÀцŒ³‚F2v6/fЗëÍÙ—¨ßc±Æg–hƒæ¥¸T‚ÖlFÞÁÀ4þI{š Æ\pKs¶+íŽNŸ‚ëuµÖPÛ7“õ]²gÕD^í©iãhÌ5å ÈrÝá=‰hEǪEuÎ+•%]¶Š®‚ºèû“¡¬ÞHö’݆Æ$kšàÖ´4Ý“Øã;$´êÊY˜ûñóìÏïõŸëû {‘SUiûuªÍ§®t&ª÷Zy&}d’XZ×ì²M Öe mìG!Á=Ýš÷ªôçR EÖÃIAYE¨5qMÝ,c'ãËÀ-Ç/F3Æ3³Ë¯×êíEsuus˜`ŠbnÄTñ7òc¼cG ÿ ÉÉ$ŸÐ]I¦‰Lí-tŒø‹‡‘TÝ•0Rë–u¥.§«Xk
«ÊŠÛIfnZ×Ç ‚IßɆeäƒÊì 1Ç’Ý>šþÕŸ[³ÿ Ë
m ©) Ž CC#˜kXÐ0 ˆ ;IN™ ×ê²A»3y¬+ |„! .Q>žÕ}_Mí̺ºå:ÏéíWÕôÞÜË™¬Çníðsþy¡.¶±zkr¦k9T|k'–±H#R5ŠV±W•&…Pclass Fl_Counter
Class Hierarchy
Fl_Valuator
|
+----Fl_Counter
Include Files
#include <FL/Fl_Counter.H>
Description
The Fl_Counter widget is provided for forms compatibility.
It controls a single floating point value.
Methods
Fl_Counter::Fl_Counter(int x, int y,
int w, int h, const char *label = 0)
Creates a new Fl_Counter widget using the given position,
size, and label string. The default type is FL_NORMAL_COUNTER.
virtual Fl_Counter::~Fl_Counter()
Destroys the valuator.
double Fl_Counter::lstep() const
Set the increment for the double-arrow buttons. The default
value is 1.0.
type(uchar)
Sets the type of counter: