doc-1.4/Fl_8H_source.html

 //

 // Main header file for the Fast Light Tool Kit (FLTK).

 //

 // Copyright 1998-2023 by Bill Spitzak and others.

 //

 // This library is free software. Distribution and use rights are outlined in

 // the file "COPYING" which should have been included with this file.  If this

 // file is missing or damaged, see the license at:

 //

 //     https://www.fltk.org/COPYING.php

 //

 // Please see the following page on how to report bugs and issues:

 //

 //     https://www.fltk.org/bugs.php

 //


 #ifndef Fl_H

 #  define Fl_H


 #include <FL/fl_config.h> // build configuration

 #include <FL/Fl_Export.H>

 #include <FL/platform_types.h> // for FL_SOCKET

 #include <FL/fl_casts.H>       // experimental


 #ifdef FLTK_HAVE_CAIRO

 # include <FL/Fl_Cairo.H>

 #endif


 #  include "fl_utf8.h"

 #  include "Enumerations.H"

 #  ifndef Fl_Object

 #    define Fl_Object Fl_Widget

 #  endif


 #  ifdef check

 #    undef check

 #  endif


 #  ifdef BSD

 #    undef BSD

 #  endif


 #include <string.h> // FIXME: Fl::is_scheme(): strcmp needs string.h


 class Fl_Widget;

 class Fl_Window;

 class Fl_Image;

 struct Fl_Label;

 class Fl_Screen_Driver;

 class Fl_System_Driver;


 // Pointers you can use to change FLTK to another language.

 // Note: Similar pointers are defined in FL/fl_ask.H and src/fl_ask.cxx


 extern FL_EXPORT const char* fl_local_alt;

 extern FL_EXPORT const char* fl_local_ctrl;

 extern FL_EXPORT const char* fl_local_meta;

 extern FL_EXPORT const char* fl_local_shift;


 typedef void (Fl_Label_Draw_F)(const Fl_Label *label, int x, int y, int w, int h, Fl_Align align);


 typedef void (Fl_Label_Measure_F)(const Fl_Label *label, int &width, int &height);


 typedef void (Fl_Box_Draw_F)(int x, int y, int w, int h, Fl_Color color);


 typedef void (*Fl_Timeout_Handler)(void *data);


 typedef void (*Fl_Awake_Handler)(void *data);


 typedef void (*Fl_Idle_Handler)(void *data);


 typedef void (*Fl_Old_Idle_Handler)();


 typedef void (*Fl_FD_Handler)(FL_SOCKET fd, void *data);


 typedef int (*Fl_Event_Handler)(int event);


 typedef int (*Fl_System_Handler)(void *event, void *data);


 typedef void (*Fl_Abort_Handler)(const char *format,...);


 typedef void (*Fl_Atclose_Handler)(Fl_Window *window, void *data);


 typedef int (*Fl_Args_Handler)(int argc, char **argv, int &i);


 typedef int (*Fl_Event_Dispatch)(int event, Fl_Window *w);


 typedef void (*Fl_Clipboard_Notify_Handler)(int source, void *data);

  /* group callback_functions */


 class FL_EXPORT Fl {

   friend class Fl_System_Driver;

   Fl() {} // no constructor!


 private:


   static int use_high_res_GL_;

   static int draw_GL_text_with_textures_;

   static int box_shadow_width_;

   static int box_border_radius_max_;

   static int selection_to_clipboard_;


 public:


   static Fl_Screen_Driver *screen_driver();

   static Fl_System_Driver *system_driver();

 #ifdef __APPLE__ // deprecated in 1.4 - only for compatibility with 1.3

   static void reset_marked_text();

   static void insertion_point_location(int x, int y, int height);

 #endif


   static int box_shadow_width() { return box_shadow_width_; }

   static void box_shadow_width(int W) { box_shadow_width_ = W < 1 ? 1 : W; }


   static int box_border_radius_max() { return box_border_radius_max_; }

   static void box_border_radius_max(int R) { box_border_radius_max_ = R < 5 ? 5 : R; }


 public: // should be private!


 #ifndef FL_DOXYGEN

   static int e_number;

   static int e_x;

   static int e_y;

   static int e_x_root;

   static int e_y_root;

   static int e_dx;

   static int e_dy;

   static int e_state;

   static int e_clicks;

   static int e_is_click;

   static int e_keysym;

   static char* e_text;

   static int e_length;

   static void *e_clipboard_data;

   static const char *e_clipboard_type;

   static Fl_Event_Dispatch e_dispatch;

   static Fl_Callback_Reason callback_reason_;

   static Fl_Widget* belowmouse_;

   static Fl_Widget* pushed_;

   static Fl_Widget* focus_;

   static int damage_;

   static Fl_Widget* selection_owner_;

   static Fl_Window* modal_;

   static Fl_Window* grab_;

   static int compose_state; // used for dead keys (Windows) or marked text (MacOS)

   static void call_screen_init(); // recompute screen number and dimensions

 #endif // FL_DOXYGEN


   static void damage(int d) {damage_ = d;}


 public:

   typedef enum {

     OPTION_ARROW_FOCUS = 0,

       // When switched on, FLTK will use the file chooser dialog that comes

       // with your operating system whenever possible. When switched off, FLTK

       // will present its own file chooser.

       // \todo implement me

     // OPTION_NATIVE_FILECHOOSER,

       // When Filechooser Preview is enabled, the FLTK or native file chooser

       // will show a preview of a selected file (if possible) before the user

       // decides to choose the file.

       // \todo implement me

     //OPTION_FILECHOOSER_PREVIEW,

     OPTION_VISIBLE_FOCUS,

     OPTION_DND_TEXT,

     OPTION_SHOW_TOOLTIPS,

     OPTION_FNFC_USES_GTK,

     OPTION_PRINTER_USES_GTK,

     OPTION_SHOW_SCALING,

     OPTION_FNFC_USES_ZENITY,

       // don't change this, leave it always as the last element

     OPTION_LAST

   } Fl_Option;


 private:

   static unsigned char options_[OPTION_LAST];

   static unsigned char options_read_;

   static int program_should_quit_; // non-zero means the program was asked to cleanly terminate


 public:

   /*

    Return a global setting for all FLTK applications, possibly overridden

    by a setting specifically for this application.

    */

   static bool option(Fl_Option opt);


   /*

    Override an option while the application is running.

    */

   static void option(Fl_Option opt, bool val);


   static void (*idle)();


 #ifndef FL_DOXYGEN

 private:

   static Fl_Awake_Handler *awake_ring_;

   static void **awake_data_;

   static int awake_ring_size_;

   static int awake_ring_head_;

   static int awake_ring_tail_;

 public:

   static const char* scheme_;

   static Fl_Image* scheme_bg_;


   static int e_original_keysym; // late addition

   static int scrollbar_size_;

   static int menu_linespacing_; // STR #2927

 #endif


   static int add_awake_handler_(Fl_Awake_Handler, void*);

   static int get_awake_handler_(Fl_Awake_Handler&, void*&);


 public:


   // API version number

   static double version();

   static int api_version();


   // ABI version number

   static int abi_version();


   static inline int abi_check(const int val = FL_ABI_VERSION) {

     return val == abi_version();

   }


   // argument parsers:

   static int arg(int argc, char **argv, int& i);

   static int args(int argc, char **argv, int& i, Fl_Args_Handler cb = 0);

   static void args(int argc, char **argv);

   static const char* const help;


   // things called by initialization:

   static void display(const char*);

   static int visual(int);

   static int gl_visual(int, int *alist=0); // platform dependent

   static void own_colormap();

   static void get_system_colors();

   static void foreground(uchar, uchar, uchar);

   static void background(uchar, uchar, uchar);

   static void background2(uchar, uchar, uchar);


   // schemes:

   static int scheme(const char *name);

   static const char* scheme() {return scheme_;}


   static int is_scheme(const char *name) {

     return (scheme_ && name && !strcmp(name,scheme_));

   }


   static int reload_scheme(); // defined in 'src/Fl_get_system_colors.cxx'


   static int scrollbar_size();

   static void scrollbar_size(int W);

   static int menu_linespacing();

   static void menu_linespacing(int H);


   // execution:

   static int wait();

   static double wait(double time);

   static int check();

   static int ready();

   static int run();

   static int program_should_quit() {return program_should_quit_;}

   static void program_should_quit(int should_i) { program_should_quit_ = should_i; }

   static void hide_all_windows();


   static Fl_Widget* readqueue();


   //

   // cross-platform timer support

   //


   static void add_timeout(double t, Fl_Timeout_Handler cb, void *data = 0);

   static void repeat_timeout(double t, Fl_Timeout_Handler cb, void *data = 0);

   static int  has_timeout(Fl_Timeout_Handler cb, void *data = 0);

   static void remove_timeout(Fl_Timeout_Handler cb, void *data = 0);


   static void add_check(Fl_Timeout_Handler, void* = 0);

   static int  has_check(Fl_Timeout_Handler, void* = 0);

   static void remove_check(Fl_Timeout_Handler, void* = 0);

   // private

   static void run_idle();

   static void run_checks();

   static void add_fd(int fd, int when, Fl_FD_Handler cb, void* = 0); // platform dependent

   static void add_fd(int fd, Fl_FD_Handler cb, void* = 0); // platform dependent

   static void remove_fd(int, int when); // platform dependent

   static void remove_fd(int); // platform dependent


   static void add_idle(Fl_Idle_Handler cb, void* data = 0);

   static int  has_idle(Fl_Idle_Handler cb, void* data = 0);

   static void remove_idle(Fl_Idle_Handler cb, void* data = 0);

   static int damage() {return damage_;}

   static void redraw();

   static void flush();

   static void (*warning)(const char*, ...);

   static void (*error)(const char*, ...);

   static void (*fatal)(const char*, ...);

   static Fl_Window* first_window();

   static void first_window(Fl_Window*);

   static Fl_Window* next_window(const Fl_Window*);


   static Fl_Window* modal() {return modal_;}

   static Fl_Window* grab() {return grab_;}

   static void grab(Fl_Window*); // platform dependent

   // event information:

   static int event()            {return e_number;}

   static int event_x()  {return e_x;}

   static int event_y()  {return e_y;}

   static int event_x_root()     {return e_x_root;}

   static int event_y_root()     {return e_y_root;}

   static int event_dx() {return e_dx;}

   static int event_dy() {return e_dy;}

   static void get_mouse(int &,int &);

   static int event_clicks()     {return e_clicks;}

   static void event_clicks(int i) {e_clicks = i;}

   static int event_is_click()   {return e_is_click;}

   static void event_is_click(int i) {e_is_click = i;}

   static int event_button()     {return e_keysym-FL_Button;}

   static int event_state()      {return e_state;}


   static int event_state(int mask) {return e_state&mask;}

   static int event_key()        {return e_keysym;}

   static int event_original_key(){return e_original_keysym;}

   static int event_key(int key);

   static int get_key(int key); // platform dependent

   static const char* event_text() {return e_text;}

   static int event_length() {return e_length;}


   static void *event_clipboard() { return e_clipboard_data; }

   static const char *event_clipboard_type() {return e_clipboard_type; }


   static int compose(int &del);

   static void compose_reset();

   static int event_inside(int,int,int,int);

   static int event_inside(const Fl_Widget*);

   static int test_shortcut(Fl_Shortcut);


   static void enable_im();

   static void disable_im();


   // event destinations:

   static int handle(int, Fl_Window*);

   static int handle_(int, Fl_Window*);

   static Fl_Widget* belowmouse() {return belowmouse_;}

   static void belowmouse(Fl_Widget*);

   static Fl_Widget* pushed()    {return pushed_;}

   static void pushed(Fl_Widget*);

   static Fl_Widget* focus()     {return focus_;}

   static void focus(Fl_Widget*);

   static void add_handler(Fl_Event_Handler h);

   static void remove_handler(Fl_Event_Handler h);

   static void add_system_handler(Fl_System_Handler h, void *data);

   static void remove_system_handler(Fl_System_Handler h);

   static void event_dispatch(Fl_Event_Dispatch d);

   static Fl_Event_Dispatch event_dispatch();

   static Fl_Callback_Reason callback_reason();

   // cut/paste:

   static void copy(const char *stuff, int len, int destination = 0,

                    const char *type = Fl::clipboard_plain_text);


   static void selection_to_clipboard(int mode) {

     selection_to_clipboard_ = mode ? 1 : 0;

   }


   static int selection_to_clipboard() { return selection_to_clipboard_; }


   static void paste(Fl_Widget &receiver, int source, const char *type = Fl::clipboard_plain_text);


   static void add_clipboard_notify(Fl_Clipboard_Notify_Handler h, void *data = 0);

   static void remove_clipboard_notify(Fl_Clipboard_Notify_Handler h);

   static int clipboard_contains(const char *type);

   static char const * const clipboard_plain_text;

   static char const * const clipboard_image;


   static int dnd(); // platform dependent


   // These are for back-compatibility only:

   static Fl_Widget* selection_owner() {return selection_owner_;}

   static void selection_owner(Fl_Widget*);

   static void selection(Fl_Widget &owner, const char*, int len);

   static void paste(Fl_Widget &receiver);

   static int x(); // via screen driver

   static int y(); // via screen driver

   static int w(); // via screen driver

   static int h(); // via screen driver


   // multi-head support:

   static int screen_count(); // via screen driver

   static void screen_xywh(int &X, int &Y, int &W, int &H); // via screen driver

   static void screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my); // via screen driver

   static void screen_xywh(int &X, int &Y, int &W, int &H, int n); // via screen driver

   static void screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my, int mw, int mh); // via screen driver

   static int screen_num(int x, int y); // via screen driver

   static int screen_num(int x, int y, int w, int h); // via screen driver

   static void screen_dpi(float &h, float &v, int n=0); // via screen driver

   static void screen_work_area(int &X, int &Y, int &W, int &H, int mx, int my); // via screen driver

   static void screen_work_area(int &X, int &Y, int &W, int &H, int n); // via screen driver

   static void screen_work_area(int &X, int &Y, int &W, int &H); // via screen driver

   static float screen_scale(int n); // via screen driver

   static void screen_scale(int n, float factor); // via screen driver

   static int screen_scaling_supported();

   static void keyboard_screen_scaling(int value);


   // color map:

   static void   set_color(Fl_Color, uchar, uchar, uchar);

   static void   set_color(Fl_Color, uchar, uchar, uchar, uchar);

   static void   set_color(Fl_Color i, unsigned c); // platform dependent

   static unsigned get_color(Fl_Color i);

   static void   get_color(Fl_Color i, uchar &red, uchar &green, uchar &blue);

   static void   get_color(Fl_Color i, uchar &red, uchar &green, uchar &blue, uchar &alpha);

   static void   free_color(Fl_Color i, int overlay = 0); // platform dependent


   // fonts:

   static const char* get_font(Fl_Font);

   static const char* get_font_name(Fl_Font, int* attributes = 0);

   static int get_font_sizes(Fl_Font, int*& sizep);

   static void set_font(Fl_Font, const char*);

   static void set_font(Fl_Font, Fl_Font);

   static Fl_Font set_fonts(const char* = 0); // platform dependent


   // <Hack to re-order the 'Drawing functions' group>

   // labeltypes:

   static void set_labeltype(Fl_Labeltype,Fl_Label_Draw_F*,Fl_Label_Measure_F*);

   static void set_labeltype(Fl_Labeltype, Fl_Labeltype from); // is it defined ?


   // boxtypes:

   static Fl_Box_Draw_F *get_boxtype(Fl_Boxtype);

   static void set_boxtype(Fl_Boxtype, Fl_Box_Draw_F*,uchar,uchar,uchar,uchar);

   static void set_boxtype(Fl_Boxtype, Fl_Boxtype from);

   static int box_dx(Fl_Boxtype);

   static int box_dy(Fl_Boxtype);

   static int box_dw(Fl_Boxtype);

   static int box_dh(Fl_Boxtype);


   static int draw_box_active();

   static Fl_Color box_color(Fl_Color);

   static void set_box_color(Fl_Color);


   // back compatibility:

   static void set_abort(Fl_Abort_Handler f) {fatal = f;}

   static void (*atclose)(Fl_Window*,void*);

   static void default_atclose(Fl_Window*,void*);

   static void set_atclose(Fl_Atclose_Handler f) {atclose = f;}

   static int event_shift() {return e_state&FL_SHIFT;}

   static int event_ctrl() {return e_state&FL_CTRL;}

   static int event_command() {return e_state&FL_COMMAND;}

   static int event_alt() {return e_state&FL_ALT;}

   static int event_buttons() {return e_state&0x7f000000;}

   static int event_button1() {return e_state&FL_BUTTON1;}

   static int event_button2() {return e_state&FL_BUTTON2;}

   static int event_button3() {return e_state&FL_BUTTON3;}

   static void set_idle(Fl_Old_Idle_Handler cb) {idle = cb;}

   static void grab(Fl_Window& win) {grab(&win);}

   static void release() {grab(0);}


   // Visible focus methods...

   static void visible_focus(int v) { option(OPTION_VISIBLE_FOCUS, (v!=0)); }

   static int  visible_focus() { return option(OPTION_VISIBLE_FOCUS); }


   // Drag-n-drop text operation methods...

   static void dnd_text_ops(int v) { option(OPTION_DND_TEXT, (v!=0)); }

   static int  dnd_text_ops() { return option(OPTION_DND_TEXT); }

   // Multithreading support:

   static int lock();

   static void unlock();

   static void awake(void* message = 0);

   static int awake(Fl_Awake_Handler cb, void* message = 0);

   static void* thread_message(); // platform dependent

   // Widget deletion:

   static void delete_widget(Fl_Widget *w);

   static void do_widget_deletion();

   static void watch_widget_pointer(Fl_Widget *&w);

   static void release_widget_pointer(Fl_Widget *&w);

   static void clear_widget_pointer(Fl_Widget const *w);

   static void use_high_res_GL(int val) { use_high_res_GL_ = val; }

   static int use_high_res_GL() { return use_high_res_GL_; }


   static void draw_GL_text_with_textures(int val) { draw_GL_text_with_textures_ = val; }


   static int draw_GL_text_with_textures() { return draw_GL_text_with_textures_; }


   static int system(const char *command);


 #ifdef FLTK_HAVE_CAIRO

 public:

   // Cairo support API

   static cairo_t * cairo_make_current(Fl_Window* w);

   static void cairo_autolink_context(bool alink) {cairo_state_.autolink(alink);}

   static bool cairo_autolink_context() {return cairo_state_.autolink();}

   static cairo_t * cairo_cc() { return cairo_state_.cc(); }

   static void cairo_cc(cairo_t * c, bool own=false){ cairo_state_.cc(c, own); }


 private:

   static cairo_t * cairo_make_current(void* gc);

   static cairo_t * cairo_make_current(void* gc, int W, int H);

   static Fl_Cairo_State cairo_state_;

 public:

 #endif // FLTK_HAVE_CAIRO


 };


 class FL_EXPORT Fl_Widget_Tracker {


   Fl_Widget* wp_;


 public:


   Fl_Widget_Tracker(Fl_Widget *wi);

   ~Fl_Widget_Tracker();


   Fl_Widget *widget() {return wp_;}


   int deleted() {return wp_ == 0;}


   int exists()  {return wp_ != 0;}


 };


 #endif // !Fl_H

Enumerations.H
This file contains type definitions and general enumerations.

FL_BUTTON2
#define FL_BUTTON2
Mouse button 2 is pushed.
Definition: Enumerations.H:579

FL_Button
#define FL_Button
A mouse button; use Fl_Button + n for mouse button n.
Definition: Enumerations.H:478

FL_CTRL
#define FL_CTRL
One of the ctrl keys is down.
Definition: Enumerations.H:570

Fl_Font
int Fl_Font
A font number is an index into the internal font table.
Definition: Enumerations.H:1040

Fl_Align
unsigned Fl_Align
FLTK type for alignment control.
Definition: Enumerations.H:963

FL_ALT
#define FL_ALT
One of the alt keys is down.
Definition: Enumerations.H:571

FL_ABI_VERSION
#define FL_ABI_VERSION
The FLTK ABI (Application Binary Interface) version number as an int.
Definition: Enumerations.H:171

Fl_Color
unsigned int Fl_Color
An FLTK color value; see also Colors
Definition: Enumerations.H:1097

FL_BUTTON3
#define FL_BUTTON3
Mouse button 3 is pushed.
Definition: Enumerations.H:580

FL_SHIFT
#define FL_SHIFT
One of the shift keys is down.
Definition: Enumerations.H:568

Fl_Labeltype
Fl_Labeltype
The labeltype() method sets the type of the label.
Definition: Enumerations.H:812

Fl_Boxtype
Fl_Boxtype
FLTK standard box types.
Definition: Enumerations.H:627

Fl_Callback_Reason
Fl_Callback_Reason
These constants describe why a callback is performed.
Definition: Enumerations.H:446

FL_BUTTON1
#define FL_BUTTON1
Mouse button 1 is pushed.
Definition: Enumerations.H:578

fl_local_meta
FL_EXPORT const char * fl_local_meta
string pointer used in shortcuts, you can change it to another language
Definition: Fl.cxx:2245

fl_local_shift
FL_EXPORT const char * fl_local_shift
string pointer used in shortcuts, you can change it to another language
Definition: Fl.cxx:2244

fl_local_ctrl
FL_EXPORT const char * fl_local_ctrl
string pointer used in shortcuts, you can change it to another language
Definition: Fl.cxx:2247

fl_local_alt
FL_EXPORT const char * fl_local_alt
string pointer used in shortcuts, you can change it to another language
Definition: Fl.cxx:2246

Fl_Cairo_State
Contains all the necessary info on the current cairo context.
Definition: Fl_Cairo.H:49

Fl_Image
Base class for image caching, scaling and drawing.
Definition: Fl_Image.H:60

Fl_Widget_Tracker
This class should be used to control safe widget deletion.
Definition: Fl.H:1471

Fl_Widget_Tracker::exists
int exists()
Returns 1, if the watched widget exists (has not been deleted).
Definition: Fl.H:1507

Fl_Widget_Tracker::deleted
int deleted()
Returns 1, if the watched widget has been deleted.
Definition: Fl.H:1496

Fl_Widget_Tracker::widget
Fl_Widget * widget()
Returns a pointer to the watched widget.
Definition: Fl.H:1485

Fl_Widget
Fl_Widget is the base class for all widgets in FLTK.
Definition: Fl_Widget.H:85

Fl_Window
This widget produces an actual window.
Definition: Fl_Window.H:55

Fl
The Fl is the FLTK global (static) class containing state information and global methods for the curr...
Definition: Fl.H:137

Fl::is_scheme
static int is_scheme(const char *name)
Returns whether the current scheme is the given name.
Definition: Fl.H:427

Fl::draw_GL_text_with_textures
static int draw_GL_text_with_textures()
returns whether whether OpenGL uses textures to draw all text.
Definition: Fl.H:1376

Fl::program_should_quit
static int program_should_quit()
Returns non-zero when a request for program termination was received and accepted.
Definition: Fl.H:450

Fl::use_high_res_GL
static void use_high_res_GL(int val)
sets whether GL windows should be drawn at high resolution on Apple computers with retina displays
Definition: Fl.H:1350

Fl::box_border_radius_max
static int box_border_radius_max()
Get the maximum border radius of all "rounded" boxtypes in pixels.
Definition: Fl.H:172

Fl::OPTION_FNFC_USES_GTK
@ OPTION_FNFC_USES_GTK
When switched on (default), Fl_Native_File_Chooser runs GTK file dialogs if the GTK library is availa...
Definition: Fl.H:268

Fl::OPTION_FNFC_USES_ZENITY
@ OPTION_FNFC_USES_ZENITY
Meaningful for the Wayland/X11 platform only.
Definition: Fl.H:279

Fl::OPTION_DND_TEXT
@ OPTION_DND_TEXT
If text drag-and-drop is enabled (default), the user can select and drag text from any text widget.
Definition: Fl.H:260

Fl::OPTION_PRINTER_USES_GTK
@ OPTION_PRINTER_USES_GTK
When switched on (default), Fl_Printer runs the GTK printer dialog if the GTK library is available on...
Definition: Fl.H:272

Fl::OPTION_SHOW_SCALING
@ OPTION_SHOW_SCALING
When switched on (default), the library shows in a transient yellow window the zoom factor value.
Definition: Fl.H:276

Fl::OPTION_VISIBLE_FOCUS
@ OPTION_VISIBLE_FOCUS
If visible focus is switched on (default), FLTK will draw a dotted rectangle inside the widget that w...
Definition: Fl.H:256

Fl::OPTION_SHOW_TOOLTIPS
@ OPTION_SHOW_TOOLTIPS
If tooltips are enabled (default), hovering the mouse over a widget with a tooltip text will open a l...
Definition: Fl.H:264

Fl::damage
static void damage(int d)
If true then flush() will do something.
Definition: Fl.H:222

Fl::scheme
static const char * scheme()
See void scheme(const char *name)
Definition: Fl.H:398

Fl::box_shadow_width
static int box_shadow_width()
Get the box shadow width of all "shadow" boxtypes in pixels.
Definition: Fl.H:162

Fl::dnd_text_ops
static void dnd_text_ops(int v)
Sets whether drag and drop text operations are supported.
Definition: Fl.H:1282

Fl::help
static const char *const help
Usage string displayed if Fl::args() detects an invalid argument.
Definition: Fl.H:374

Fl::box_border_radius_max
static void box_border_radius_max(int R)
Set the maximum border radius of all "rounded" boxtypes in pixels.
Definition: Fl.H:185

Fl::release
static void release()
Releases the current grabbed window, equals grab(0).
Definition: Fl.H:1259

Fl::set_idle
static void set_idle(Fl_Old_Idle_Handler cb)
Sets an idle callback.
Definition: Fl.H:1253

Fl::gl_visual
static int gl_visual(int, int *alist=0)
This does the same thing as Fl::visual(int) but also requires OpenGL drawing to work.

Fl::program_should_quit
static void program_should_quit(int should_i)
Indicate to the FLTK library whether a program termination request was received and accepted.
Definition: Fl.H:456

Fl::use_high_res_GL
static int use_high_res_GL()
returns whether GL windows should be drawn at high resolution on Apple computers with retina displays...
Definition: Fl.H:1356

Fl::draw_GL_text_with_textures
static void draw_GL_text_with_textures(int val)
sets whether OpenGL uses textures to draw all text.
Definition: Fl.H:1369

Fl::dnd_text_ops
static int dnd_text_ops()
Gets whether drag and drop text operations are supported.
Definition: Fl.H:1289

Fl::grab
static void grab(Fl_Window &win)
See grab(Fl_Window*)
Definition: Fl.H:1255

Fl::damage
static int damage()
If true then flush() will do something.
Definition: Fl.H:487

Fl::box_shadow_width
static void box_shadow_width(int W)
Set the box shadow width of all "shadow" boxtypes in pixels.
Definition: Fl.H:167

Fl::set_labeltype
static void set_labeltype(Fl_Labeltype, Fl_Labeltype from)
Sets the functions to call to draw and measure a specific labeltype.

Fl::visible_focus
static void visible_focus(int v)
Gets or sets the visible keyboard focus on buttons and other non-text widgets.
Definition: Fl.H:1267

Fl::visible_focus
static int visible_focus()
Gets or sets the visible keyboard focus on buttons and other non-text widgets.
Definition: Fl.H:1273

Fl::abi_check
static int abi_check(const int val=FL_ABI_VERSION)
Returns whether the runtime library ABI version is correct.
Definition: Fl.H:362

Fl_Shortcut
unsigned int Fl_Shortcut
16-bit Unicode character + 8-bit indicator for keyboard flags.
Definition: fl_types.h:55

uchar
unsigned char uchar
unsigned char
Definition: fl_types.h:30

fl_utf8.h
header for Unicode and UTF-8 character handling

Fl_System_Handler
int(* Fl_System_Handler)(void *event, void *data)
Signature of add_system_handler functions passed as parameters.
Definition: Fl.H:112

Fl_Timeout_Handler
void(* Fl_Timeout_Handler)(void *data)
Signature of timeout callback functions passed as parameters.
Definition: Fl.H:94

Fl_Event_Handler
int(* Fl_Event_Handler)(int event)
Signature of add_handler functions passed as parameters.
Definition: Fl.H:109

Fl_Old_Idle_Handler
void(* Fl_Old_Idle_Handler)()
Signature of set_idle callback functions passed as parameters.
Definition: Fl.H:103

Fl_Awake_Handler
void(* Fl_Awake_Handler)(void *data)
Signature of some wakeup callback functions passed as parameters.
Definition: Fl.H:97

Fl_FD_Handler
void(* Fl_FD_Handler)(FL_SOCKET fd, void *data)
Signature of add_fd functions passed as parameters.
Definition: Fl.H:106

Fl_Event_Dispatch
int(* Fl_Event_Dispatch)(int event, Fl_Window *w)
Signature of event_dispatch functions passed as parameters.
Definition: Fl.H:125

Fl_Label_Draw_F
void() Fl_Label_Draw_F(const Fl_Label *label, int x, int y, int w, int h, Fl_Align align)
Signature of some label drawing functions passed as parameters.
Definition: Fl.H:83

Fl_Args_Handler
int(* Fl_Args_Handler)(int argc, char **argv, int &i)
Signature of args functions passed as parameters.
Definition: Fl.H:121

Fl_Label_Measure_F
void() Fl_Label_Measure_F(const Fl_Label *label, int &width, int &height)
Signature of some label measurement functions passed as parameters.
Definition: Fl.H:86

Fl_Abort_Handler
void(* Fl_Abort_Handler)(const char *format,...)
Signature of set_abort functions passed as parameters.
Definition: Fl.H:115

Fl_Atclose_Handler
void(* Fl_Atclose_Handler)(Fl_Window *window, void *data)
Signature of set_atclose functions passed as parameters.
Definition: Fl.H:118

Fl_Idle_Handler
void(* Fl_Idle_Handler)(void *data)
Signature of add_idle callback functions passed as parameters.
Definition: Fl.H:100

Fl_Box_Draw_F
void() Fl_Box_Draw_F(int x, int y, int w, int h, Fl_Color color)
Signature of some box drawing functions passed as parameters.
Definition: Fl.H:89

Fl_Clipboard_Notify_Handler
void(* Fl_Clipboard_Notify_Handler)(int source, void *data)
Signature of add_clipboard_notify functions passed as parameters.
Definition: Fl.H:128

Fl::clipboard_image
static char const  *const clipboard_image
Denotes image data.
Definition: Fl.H:1036

Fl::selection_to_clipboard
static int selection_to_clipboard()
Returns the current selection_to_clipboard mode.
Definition: Fl.H:954

Fl::clipboard_plain_text
static char const  *const clipboard_plain_text
Denotes plain textual data.
Definition: Fl.H:1033

Fl::selection_owner
static Fl_Widget * selection_owner()
back-compatibility only: Gets the widget owning the current selection
Definition: Fl.H:1052

Fl::selection_to_clipboard
static void selection_to_clipboard(int mode)
Copies selections on X11 directly to the clipboard if enabled.
Definition: Fl.H:945

Fl::event_clicks
static void event_clicks(int i)
Manually sets the number returned by Fl::event_clicks().
Definition: Fl.H:665

Fl::event_is_click
static void event_is_click(int i)
Clears the value returned by Fl::event_is_click().
Definition: Fl.H:680

Fl::event_y
static int event_y()
Returns the mouse position of the event relative to the Fl_Window it was passed to.
Definition: Fl.H:615

Fl::event_key
static int event_key()
Gets which key on the keyboard was last pushed.
Definition: Fl.H:735

Fl::event_alt
static int event_alt()
Returns non-zero if the Alt key is pressed.
Definition: Fl.H:1221

Fl::event_length
static int event_length()
Returns the length of the text in Fl::event_text().
Definition: Fl.H:812

Fl::event_state
static int event_state(int mask)
Returns non-zero if any of the passed event state bits are turned on.
Definition: Fl.H:723

Fl::event_dy
static int event_dy()
Returns the current vertical mouse scrolling associated with the FL_MOUSEWHEEL event.
Definition: Fl.H:639

Fl::event_clipboard_type
static const char * event_clipboard_type()
Returns the type of the pasted data during an FL_PASTE event.
Definition: Fl.H:821

Fl::event_x_root
static int event_x_root()
Returns the mouse position on the screen of the event.
Definition: Fl.H:622

Fl::event_clipboard
static void * event_clipboard()
During an FL_PASTE event of non-textual data, returns a pointer to the pasted data.
Definition: Fl.H:817

Fl::belowmouse
static Fl_Widget * belowmouse()
Gets the widget that is below the mouse.
Definition: Fl.H:838

Fl::event_text
static const char * event_text()
Returns the text associated with the current event, including FL_PASTE or FL_DND_RELEASE events.
Definition: Fl.H:805

Fl::event_button1
static int event_button1()
Returns non-zero if mouse button 1 is currently held down.
Definition: Fl.H:1235

Fl::event_button3
static int event_button3()
Returns non-zero if button 3 is currently held down.
Definition: Fl.H:1245

Fl::event_command
static int event_command()
Returns non-zero if the FL_COMMAND key is pressed, either FL_CTRL or on OSX FL_META.
Definition: Fl.H:1219

Fl::event_button
static int event_button()
Gets which particular mouse button caused the current event.
Definition: Fl.H:690

Fl::focus
static Fl_Widget * focus()
Gets the current Fl::focus() widget.
Definition: Fl.H:845

Fl::event_x
static int event_x()
Returns the mouse position of the event relative to the Fl_Window it was passed to.
Definition: Fl.H:610

Fl::event_y_root
static int event_y_root()
Returns the mouse position on the screen of the event.
Definition: Fl.H:629

Fl::event_shift
static int event_shift()
Returns non-zero if the Shift key is pressed.
Definition: Fl.H:1215

Fl::event
static int event()
Returns the last event that was processed.
Definition: Fl.H:605

Fl::event_ctrl
static int event_ctrl()
Returns non-zero if the Control key is pressed.
Definition: Fl.H:1217

Fl::event_button2
static int event_button2()
Returns non-zero if button 2 is currently held down.
Definition: Fl.H:1240

Fl::pushed
static Fl_Widget * pushed()
Gets the widget that is being pushed.
Definition: Fl.H:842

Fl::event_dx
static int event_dx()
Returns the current horizontal mouse scrolling associated with the FL_MOUSEWHEEL event.
Definition: Fl.H:634

Fl::event_original_key
static int event_original_key()
Returns the keycode of the last key event, regardless of the NumLock state.
Definition: Fl.H:744

Fl::event_is_click
static int event_is_click()
Returns non-zero if the mouse has not moved far enough and not enough time has passed since the last ...
Definition: Fl.H:673

Fl::event_buttons
static int event_buttons()
Returns the mouse buttons state bits; if non-zero, then at least one button is pressed now.
Definition: Fl.H:1230

Fl::event_state
static int event_state()
Returns the keyboard and mouse button states of the last event.
Definition: Fl.H:716

Fl::event_clicks
static int event_clicks()
Returns non zero if we had a double click event.
Definition: Fl.H:657

Fl::grab
static Fl_Window * grab()
Returns the window that currently receives all events.
Definition: Fl.H:567

Fl::set_abort
static void set_abort(Fl_Abort_Handler f)
For back compatibility, sets the void Fl::fatal handler callback.
Definition: Fl.H:1203

Fl::modal
static Fl_Window * modal()
Returns the top-most modal() window currently shown.
Definition: Fl.H:561

Fl::set_atclose
static void set_atclose(Fl_Atclose_Handler f)
For back compatibility, sets the Fl::atclose handler callback.
Definition: Fl.H:1209

Fl::cairo_cc
static void cairo_cc(cairo_t *c, bool own=false)
Sets the current cairo context to c.
Definition: Fl.H:1416

Fl::cairo_cc
static cairo_t * cairo_cc()
Gets the current cairo context linked with a fltk window.
Definition: Fl.H:1411

Fl::cairo_autolink_context
static bool cairo_autolink_context()
Gets the current autolink mode for cairo support.
Definition: Fl.H:1409

Fl::cairo_autolink_context
static void cairo_autolink_context(bool alink)
when FLTK_HAVE_CAIRO is defined and cairo_autolink_context() is true, any current window dc is linked...
Definition: Fl.H:1401

platform_types.h
Definitions of platform-dependent types.

FL_COMMAND
#define FL_COMMAND
An alias for FL_CTRL on Windows and X11, or FL_META on MacOS X.
Definition: platform_types.h:65

FL_SOCKET
opaque FL_SOCKET
socket or file descriptor
Definition: platform_types.h:54

Fl_Label
This struct stores all information for a text or mixed graphics label.
Definition: Fl_Widget.H:48