maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
93a6d4087df0237d643abe716fc5602ee996cd7a
openairinterface5g/common/utils/websrv/websrv_noforms.h
T

2444 lines
62 KiB
C
Raw Blame History

/*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.1 (the "License"); you may not use this file
* except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.openairinterface.org/?page_id=698
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org
*/
/*! \file common/utils/websrv/websrv_noforms.h
* \brief: include file to replace forms.h when compiling nr_phy_scope.c for the webserver shared lib
* \author Francois TABURET
* \date 2022
* \version 0.1
* \company NOKIA BellLabs France
* \email: francois.taburet@nokia-bell-labs.com
* \note
* \warning
*/
#ifndef FL_FORMS_H
#define FL_FORMS_H
#define FL_VERSION 1
#define FL_REVISION 2
#define FL_FIXLEVEL "3"
#define FL_INCLUDE_VERSION (FL_VERSION * 1000 + FL_REVISION)
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <limits.h>
#if defined __cplusplus
extern "C" {
#endif
#if defined _WIN32
#define FL_WIN32
#include <windows.h>
#endif
typedef void *Window;
typedef void *Pixmap;
#define FL_EXPORT inline
/**
* \file Basic.h
*
* Basic definitions and limits.
* Window system independent prototypes
*
* Modify with care
*/
#ifndef FL_BASIC_H
#define FL_BASIC_H
#include <math.h>
#if defined __GNUC__
#define FL_UNUSED_ARG __attribute__((unused))
#else
#define FL_UNUSED_ARG
#endif
/* Some general constants */
typedef int Visual;
typedef int XEvent;
typedef int *Display;
typedef void *Cursor;
typedef void *XVisualInfo;
typedef void *XFontStruct;
typedef void *XPoint;
typedef void *XRectangle;
typedef int GC;
typedef void *Colormap;
typedef void *XrmOptionDescRec;
#define LineSolid 0
#define LineOnOffDash 1
#define LineDoubleDash 2
typedef struct {
int f1;
} XSetWindowAttributes;
typedef struct {
int f1;
} Atom;
typedef int KeySym;
enum {
FL_ON = 1,
FL_OK = 1,
FL_VALID = 1,
FL_PREEMPT = 1,
FL_AUTO = 2,
FL_WHEN_NEEDED = FL_AUTO,
FL_OFF = 0,
FL_CANCEL = 0,
FL_INVALID = 0,
/* WM_DELETE_WINDOW callback return */
FL_IGNORE = -1,
};
/* Max directory length */
#ifndef FL_PATH_MAX
#ifndef PATH_MAX
#define FL_PATH_MAX 1024
#else
#define FL_PATH_MAX PATH_MAX
#endif
#endif /* ! def FL_PATH_MAX */
/* The screen coordinate unit, FL_Coord, must be of signed type */
typedef int FL_Coord;
#define FL_COORD FL_Coord
typedef unsigned long FL_COLOR;
/* Coordinates can be in pixels, milli-meters or points (1/72inch) */
typedef enum {
FL_COORD_PIXEL, /* default, Pixel */
FL_COORD_MM, /* milli-meter */
FL_COORD_POINT, /* point */
FL_COORD_centiMM, /* one hundredth of a mm */
FL_COORD_centiPOINT /* one hundredth of a point */
} FL_COORD_UNIT;
/* All object classes. */
typedef enum {
FL_INVALID_CLASS, /* 0 */
FL_BUTTON, /* 1 */
FL_LIGHTBUTTON, /* 2 */
FL_ROUNDBUTTON, /* 3 */
FL_ROUND3DBUTTON, /* 4 */
FL_CHECKBUTTON, /* 5 */
FL_BITMAPBUTTON, /* 6 */
FL_PIXMAPBUTTON, /* 7 */
FL_BITMAP, /* 8 */
FL_PIXMAP, /* 9 */
FL_BOX, /* 10 */
FL_TEXT, /* 11 */
FL_MENU, /* 12 */
FL_CHART, /* 13 */
FL_CHOICE, /* 14 */
FL_COUNTER, /* 15 */
FL_SLIDER, /* 16 */
FL_VALSLIDER, /* 17 */
FL_INPUT, /* 18 */
FL_BROWSER, /* 19 */
FL_DIAL, /* 20 */
FL_TIMER, /* 21 */
FL_CLOCK, /* 22 */
FL_POSITIONER, /* 23 */
FL_FREE, /* 24 */
FL_XYPLOT, /* 25 */
FL_FRAME, /* 26 */
FL_LABELFRAME, /* 27 */
FL_CANVAS, /* 28 */
FL_GLCANVAS, /* 29 */
FL_TABFOLDER, /* 30 */
FL_SCROLLBAR, /* 31 */
FL_SCROLLBUTTON, /* 32 */
FL_MENUBAR, /* 33 */
FL_TEXTBOX, /* 34, for internal use only */
FL_LABELBUTTON, /* 35 */
FL_COMBOBOX, /* 36 */
FL_IMAGECANVAS, /* 37 */
FL_THUMBWHEEL, /* 38 */
FL_COLORWHEEL, /* 39 */
FL_FORMBROWSER, /* 40 */
FL_SELECT, /* 41 */
FL_NMENU, /* 42 */
FL_SPINNER, /* 43 */
FL_TBOX, /* 44 */
FL_CLASS_END /* sentinel */
} FL_CLASS;
#define FL_BEGIN_GROUP 10000
#define FL_END_GROUP 20000
#define FL_USER_CLASS_START 1001 /* min. user class value */
#define FL_USER_CLASS_END 9999 /* max. user class value */
/* Maximum border width (in pixel) */
#define FL_MAX_BW 10
/* How to display a form onto screen */
typedef enum {
FL_PLACE_FREE = 0, /* size remain resizable */
FL_PLACE_MOUSE = 1, /* mouse centered on form */
FL_PLACE_CENTER = 2, /* center of the screen */
FL_PLACE_POSITION = 4, /* specific position */
FL_PLACE_SIZE = 8, /* specific size */
FL_PLACE_GEOMETRY = 16, /* specific size and position */
FL_PLACE_ASPECT = 32, /* keep aspect ratio */
FL_PLACE_FULLSCREEN = 64, /* scale to fit to screen */
FL_PLACE_HOTSPOT = 128, /* so mouse fall on (x,y) */
FL_PLACE_ICONIC = 256, /* start in iconified form */
/* Modifiers */
FL_FREE_SIZE = (1 << 14),
FL_FIX_SIZE = (1 << 15) /* seems to be useless, but some
programs seem to rely on it... */
} FL_PLACE;
#define FL_PLACE_FREE_CENTER (FL_PLACE_CENTER | FL_FREE_SIZE)
#define FL_PLACE_CENTERFREE (FL_PLACE_CENTER | FL_FREE_SIZE)
/* Window manager decoration request and forms attributes */
enum {
FL_FULLBORDER = 1, /* normal */
FL_TRANSIENT, /* set TRANSIENT_FOR property */
FL_NOBORDER, /* use override_redirect to supress decor. */
};
/* All box types */
typedef enum {
FL_NO_BOX, /* 0 */
FL_UP_BOX, /* 1 */
FL_DOWN_BOX, /* 2 */
FL_BORDER_BOX, /* 3 */
FL_SHADOW_BOX, /* 4 */
FL_FRAME_BOX, /* 5 */
FL_ROUNDED_BOX, /* 6 */
FL_EMBOSSED_BOX, /* 7 */
FL_FLAT_BOX, /* 8 */
FL_RFLAT_BOX, /* 9 */
FL_RSHADOW_BOX, /* 10 */
FL_OVAL_BOX, /* 11 */
FL_ROUNDED3D_UPBOX, /* 12 */
FL_ROUNDED3D_DOWNBOX, /* 13 */
FL_OVAL3D_UPBOX, /* 14 */
FL_OVAL3D_DOWNBOX, /* 15 */
FL_OVAL3D_FRAMEBOX, /* 16 */
FL_OVAL3D_EMBOSSEDBOX, /* 17 */
/* for internal use only */
FL_TOPTAB_UPBOX,
FL_SELECTED_TOPTAB_UPBOX,
FL_BOTTOMTAB_UPBOX,
FL_SELECTED_BOTTOMTAB_UPBOX,
FL_MAX_BOX_STYLES /* sentinel */
} FL_BOX_TYPE;
#define FL_IS_UPBOX(t) ((t) == FL_UP_BOX || (t) == FL_OVAL3D_UPBOX || (t) == FL_ROUNDED3D_UPBOX)
#define FL_IS_DOWNBOX(t) ((t) == FL_DOWN_BOX || (t) == FL_OVAL3D_DOWNBOX || (t) == FL_ROUNDED3D_DOWNBOX)
#define FL_TO_DOWNBOX(t) ((t) == FL_UP_BOX ? FL_DOWN_BOX : ((t) == FL_ROUNDED3D_UPBOX ? FL_ROUNDED3D_DOWNBOX : ((t) == FL_OVAL3D_UPBOX ? FL_OVAL3D_DOWNBOX : (t))))
/* How to place text relative to a box */
typedef enum {
FL_ALIGN_CENTER,
FL_ALIGN_TOP = 1,
FL_ALIGN_BOTTOM = 2,
FL_ALIGN_LEFT = 4,
FL_ALIGN_RIGHT = 8,
FL_ALIGN_LEFT_TOP = (FL_ALIGN_TOP | FL_ALIGN_LEFT),
FL_ALIGN_RIGHT_TOP = (FL_ALIGN_TOP | FL_ALIGN_RIGHT),
FL_ALIGN_LEFT_BOTTOM = (FL_ALIGN_BOTTOM | FL_ALIGN_LEFT),
FL_ALIGN_RIGHT_BOTTOM = (FL_ALIGN_BOTTOM | FL_ALIGN_RIGHT),
FL_ALIGN_INSIDE = (1 << 13),
FL_ALIGN_VERT = (1 << 14), /* not functional yet */
/* the rest is for backward compatibility only, don't use! */
FL_ALIGN_TOP_LEFT = FL_ALIGN_LEFT_TOP,
FL_ALIGN_TOP_RIGHT = FL_ALIGN_RIGHT_TOP,
FL_ALIGN_BOTTOM_LEFT = FL_ALIGN_LEFT_BOTTOM,
FL_ALIGN_BOTTOM_RIGHT = FL_ALIGN_RIGHT_BOTTOM
} FL_ALIGN;
FL_EXPORT int fl_is_inside_lalign(int align)
{
return 0;
};
FL_EXPORT int fl_is_outside_lalign(int align)
{
return 0;
};
FL_EXPORT int fl_is_center_lalign(int align)
{
return 0;
};
FL_EXPORT int fl_to_inside_lalign(int align)
{
return 0;
};
FL_EXPORT int fl_to_outside_lalign(int align)
{
return 0;
};
/* Mouse buttons. Don't have to be consecutive */
enum { FL_MBUTTON1 = 1, FL_MBUTTON2, FL_MBUTTON3, FL_MBUTTON4, FL_MBUTTON5 };
#define FL_LEFT_MOUSE FL_MBUTTON1
#define FL_MIDDLE_MOUSE FL_MBUTTON2
#define FL_RIGHT_MOUSE FL_MBUTTON3
#define FL_SCROLLUP_MOUSE FL_MBUTTON4
#define FL_SCROLLDOWN_MOUSE FL_MBUTTON5
#define FL_LEFTMOUSE FL_LEFT_MOUSE
#define FL_MIDDLEMOUSE FL_MIDDLE_MOUSE
#define FL_RIGHTMOUSE FL_RIGHT_MOUSE
#define FL_SCROLLUPMOUSE FL_SCROLLUP_MOUSE
#define FL_SCROLLDOWNMOUSE FL_SCROLLDOWN_MOUSE
/* control when to return input, slider and dial etc. object. */
#define FL_RETURN_NONE 0U
#define FL_RETURN_CHANGED 1U
#define FL_RETURN_END 2U
#define FL_RETURN_END_CHANGED 4U
#define FL_RETURN_SELECTION 8U
#define FL_RETURN_DESELECTION 16U
#define FL_RETURN_TRIGGERED 1024U
#define FL_RETURN_ALWAYS (~FL_RETURN_END_CHANGED)
/* Some special color indices for FL private colormap. It does not matter
* what the value of each enum is, but it must start from 0 and be
* consecutive. */
typedef enum {
FL_BLACK,
FL_RED,
FL_GREEN,
FL_YELLOW,
FL_BLUE,
FL_MAGENTA,
FL_CYAN,
FL_WHITE,
FL_TOMATO,
FL_INDIANRED,
FL_SLATEBLUE,
FL_COL1,
FL_RIGHT_BCOL,
FL_BOTTOM_BCOL,
FL_TOP_BCOL,
FL_LEFT_BCOL,
FL_MCOL,
FL_INACTIVE,
FL_PALEGREEN,
FL_DARKGOLD,
FL_ORCHID,
FL_DARKCYAN,
FL_DARKTOMATO,
FL_WHEAT,
FL_DARKORANGE,
FL_DEEPPINK,
FL_CHARTREUSE,
FL_DARKVIOLET,
FL_SPRINGGREEN,
FL_DODGERBLUE,
FL_LIGHTER_COL1,
FL_DARKER_COL1,
FL_ALICEBLUE,
FL_ANTIQUEWHITE,
FL_AQUA,
FL_AQUAMARINE,
FL_AZURE,
FL_BEIGE,
FL_BISQUE,
FL_BLANCHEDALMOND,
FL_BLUEVIOLET,
FL_BROWN,
FL_BURLYWOOD,
FL_CADETBLUE,
FL_CHOCOLATE,
FL_CORAL,
FL_CORNFLOWERBLUE,
FL_CORNSILK,
FL_CRIMSON,
FL_DARKBLUE,
FL_DARKGOLDENROD,
FL_DARKGRAY,
FL_DARKGREEN,
FL_DARKGREY,
FL_DARKKHAKI,
FL_DARKMAGENTA,
FL_DARKOLIVEGREEN,
FL_DARKORCHID,
FL_DARKRED,
FL_DARKSALMON,
FL_DARKSEAGREEN,
FL_DARKSLATEBLUE,
FL_DARKSLATEGRAY,
FL_DARKSLATEGREY,
FL_DARKTURQUOISE,
FL_DEEPSKYBLUE,
FL_DIMGRAY,
FL_DIMGREY,
FL_FIREBRICK,
FL_FLORALWHITE,
FL_FORESTGREEN,
FL_FUCHSIA,
FL_GAINSBORO,
FL_GHOSTWHITE,
FL_GOLD,
FL_GOLDENROD,
FL_GRAY,
FL_GREENYELLOW,
FL_GREY,
FL_HONEYDEW,
FL_HOTPINK,
FL_INDIGO,
FL_IVORY,
FL_KHAKI,
FL_LAVENDER,
FL_LAVENDERBLUSH,
FL_LAWNGREEN,
FL_LEMONCHIFFON,
FL_LIGHTBLUE,
FL_LIGHTCORAL,
FL_LIGHTCYAN,
FL_LIGHTGOLDENRODYELLOW,
FL_LIGHTGRAY,
FL_LIGHTGREEN,
FL_LIGHTGREY,
FL_LIGHTPINK,
FL_LIGHTSALMON,
FL_LIGHTSEAGREEN,
FL_LIGHTSKYBLUE,
FL_LIGHTSLATEGRAY,
FL_LIGHTSLATEGREY,
FL_LIGHTSTEELBLUE,
FL_LIGHTYELLOW,
FL_LIME,
FL_LIMEGREEN,
FL_LINEN,
FL_MAROON,
FL_MEDIUMAQUAMARINE,
FL_MEDIUMBLUE,
FL_MEDIUMORCHID,
FL_MEDIUMPURPLE,
FL_MEDIUMSEAGREEN,
FL_MEDIUMSLATEBLUE,
FL_MEDIUMSPRINGGREEN,
FL_MEDIUMTURQUOISE,
FL_MEDIUMVIOLETRED,
FL_MIDNIGHTBLUE,
FL_MINTCREAM,
FL_MISTYROSE,
FL_MOCCASIN,
FL_NAVAJOWHITE,
FL_NAVY,
FL_OLDLACE,
FL_OLIVE,
FL_OLIVEDRAB,
FL_ORANGE,
FL_ORANGERED,
FL_PALEGOLDENROD,
FL_PALETURQUOISE,
FL_PALEVIOLETRED,
FL_PAPAYAWHIP,
FL_PEACHPUFF,
FL_PERU,
FL_PINK,
FL_PLUM,
FL_POWDERBLUE,
FL_PURPLE,
FL_ROSYBROWN,
FL_ROYALBLUE,
FL_SADDLEBROWN,
FL_SALMON,
FL_SANDYBROWN,
FL_SEAGREEN,
FL_SEASHELL,
FL_SIENNA,
FL_SILVER,
FL_SKYBLUE,
FL_SLATEGRAY,
FL_SLATEGREY,
FL_SNOW,
FL_STEELBLUE,
FL_TAN,
FL_TEAL,
FL_THISTLE,
FL_TURQUOISE,
FL_VIOLET,
FL_WHITESMOKE,
FL_YELLOWGREEN,
FL_FREE_COL1 = 256,
FL_FREE_COL2,
FL_FREE_COL3,
FL_FREE_COL4,
FL_FREE_COL5,
FL_FREE_COL6,
FL_FREE_COL7,
FL_FREE_COL8,
FL_FREE_COL9,
FL_FREE_COL10,
FL_FREE_COL11,
FL_FREE_COL12,
FL_FREE_COL13,
FL_FREE_COL14,
FL_FREE_COL15,
FL_FREE_COL16,
FL_NOCOLOR = INT_MAX
} FL_PD_COL;
#define FL_BUILT_IN_COLS (FL_YELLOWGREEN + 1)
#define FL_INACTIVE_COL FL_INACTIVE
/* Some aliases for a number of colors */
#define FL_GRAY16 FL_RIGHT_BCOL
#define FL_GRAY35 FL_BOTTOM_BCOL
#define FL_GRAY80 FL_TOP_BCOL
#define FL_GRAY90 FL_LEFT_BCOL
#define FL_GRAY63 FL_COL1
#define FL_GRAY75 FL_MCOL
#define FL_LCOL FL_BLACK
#define FL_NoColor FL_NOCOLOR
/* An alias probably for an earlier typo */
#define FL_DOGERBLUE FL_DODGERBLUE
/* Events that a form reacts to */
typedef enum {
FL_NOEVENT, /* 0 No event */
FL_DRAW, /* 1 object is asked to redraw itself */
FL_PUSH, /* 2 mouse button was pressed on the object */
FL_RELEASE, /* 3 mouse button was release gain */
FL_ENTER, /* 4 mouse entered the object */
FL_LEAVE, /* 5 mouse left the object */
FL_MOTION, /* 6 mouse motion over the object happend */
FL_FOCUS, /* 7 object obtained focus */
FL_UNFOCUS, /* 8 object lost focus */
FL_KEYPRESS, /* 9 key was pressed while object has focus */
FL_UPDATE, /* 10 for objects that need to update something
from time to time */
FL_STEP, /* 11 */
FL_SHORTCUT, /* 12 */
FL_FREEMEM, /* 13 object is asked to free all its memory */
FL_OTHER, /* 14 property, selection etc */
FL_DRAWLABEL, /* 15 */
FL_DBLCLICK, /* 16 double click on object */
FL_TRPLCLICK, /* 17 triple click on object */
FL_ATTRIB, /* 18 an object attribute changed */
FL_KEYRELEASE, /* 19 key was released while object has focus */
FL_PS, /* 20 dump a form into EPS */
FL_MOVEORIGIN, /* 21 dragging the form across the screen
changes its absolute x,y coords. Objects
that themselves contain forms should
ensure that they are up to date. */
FL_RESIZED, /* 22 the object has been resized by scale_form
Tell it that this has happened so that
it can resize any FL_FORMs that it
contains. */
FL_PASTE, /* 23 text was pasted into input object */
FL_TRIGGER, /* 24 result of fl_trigger_object() */
/* The following are only for backward compatibility, not used anymore */
FL_MOVE = FL_MOTION,
FL_KEYBOARD = FL_KEYPRESS,
FL_MOUSE = FL_UPDATE
} FL_EVENTS;
/* Resize policies */
typedef enum { FL_RESIZE_NONE, FL_RESIZE_X, FL_RESIZE_Y, FL_RESIZE_ALL = (FL_RESIZE_X | FL_RESIZE_Y) } FL_RESIZE_T;
/* Keyboard focus control */
typedef enum {
FL_KEY_NORMAL = 1, /* normal keys(0-255) - tab +left/right */
FL_KEY_TAB = 2, /* normal keys + 4 direction cursor */
FL_KEY_SPECIAL = 4, /* only needs special keys (>255) */
FL_KEY_ALL = 7 /* all keys */
} FL_KEY;
#define FL_ALT_MASK (1L << 25) /* alt + Key --> FL_ALT_MASK + key */
#define FL_CONTROL_MASK (1L << 26)
#define FL_SHIFT_MASK (1L << 27)
#define FL_ALT_VAL FL_ALT_MASK /* Don' use! */
#define MAX_SHORTCUTS 8
/* Pop-up menu item attributes. NOTE if more than 8, need to change
* choice and menu class where mode is kept by a single byte */
enum { FL_PUP_NONE, FL_PUP_GREY = 1, FL_PUP_BOX = 2, FL_PUP_CHECK = 4, FL_PUP_RADIO = 8 };
#define FL_PUP_GRAY FL_PUP_GREY
#define FL_PUP_TOGGLE FL_PUP_BOX /* not used anymore */
#define FL_PUP_INACTIVE FL_PUP_GREY
/* Popup and menu entries */
typedef int (*FL_PUP_CB)(int); /* callback prototype */
typedef struct {
const char *text; /* label of a popup/menu item */
FL_PUP_CB callback; /* the callback function */
const char *shortcut; /* hotkeys */
int mode; /* FL_PUP_GRAY, FL_PUP_CHECK etc */
} FL_PUP_ENTRY;
#define FL_MENU_ENTRY FL_PUP_ENTRY
/*******************************************************************
* FONTS
******************************************************************/
#define FL_MAXFONTS 48 /* max number of fonts */
typedef enum {
FL_INVALID_STYLE = -1,
FL_NORMAL_STYLE,
FL_BOLD_STYLE,
FL_ITALIC_STYLE,
FL_BOLDITALIC_STYLE,
FL_FIXED_STYLE,
FL_FIXEDBOLD_STYLE,
FL_FIXEDITALIC_STYLE,
FL_FIXEDBOLDITALIC_STYLE,
FL_TIMES_STYLE,
FL_TIMESBOLD_STYLE,
FL_TIMESITALIC_STYLE,
FL_TIMESBOLDITALIC_STYLE,
FL_MISC_STYLE,
FL_MISCBOLD_STYLE,
FL_MISCITALIC_STYLE,
FL_SYMBOL_STYLE,
/* modfier masks. Need to fit a short */
FL_SHADOW_STYLE = (1 << 9),
FL_ENGRAVED_STYLE = (1 << 10),
FL_EMBOSSED_STYLE = (1 << 11)
} FL_TEXT_STYLE;
#define FL_FONT_STYLE FL_TEXT_STYLE
#define special_style(a) ((a) >= FL_SHADOW_STYLE && (a) <= (FL_EMBOSSED_STYLE + FL_MAXFONTS))
/* Standard sizes in XForms */
#define FL_TINY_SIZE 8
#define FL_SMALL_SIZE 10
#define FL_NORMAL_SIZE 12
#define FL_MEDIUM_SIZE 14
#define FL_LARGE_SIZE 18
#define FL_HUGE_SIZE 24
#define FL_DEFAULT_SIZE FL_SMALL_SIZE
/* Defines for compatibility */
#define FL_TINY_FONT FL_TINY_SIZE
#define FL_SMALL_FONT FL_SMALL_SIZE
#define FL_NORMAL_FONT FL_NORMAL_SIZE
#define FL_MEDIUM_FONT FL_MEDIUM_SIZE
#define FL_LARGE_FONT FL_LARGE_SIZE
#define FL_HUGE_FONT FL_HUGE_SIZE
#define FL_NORMAL_FONT1 FL_SMALL_FONT
#define FL_NORMAL_FONT2 FL_NORMAL_FONT
#define FL_DEFAULT_FONT FL_SMALL_FONT
#define FL_BOUND_WIDTH (FL_Coord)1 /* Border width of boxes */
/* Definition of basic struct that holds an object */
#define FL_CLICK_TIMEOUT 400 /* double click interval */
typedef struct FL_FORM_ FL_FORM;
typedef struct FL_OBJECT_ FL_OBJECT;
typedef struct FL_pixmap_ FL_pixmap;
struct FL_OBJECT_ {
FL_FORM *form; /* the form this object belongs to */
void *u_vdata; /* anything the user likes */
char *u_cdata; /* anything the user likes */
long u_ldata; /* anything the user likes */
int objclass; /* class of object, button, slider etc */
int type; /* type within the class */
int boxtype; /* what kind of box type */
FL_Coord x, /* current obj. location and size */
y, w, h;
double fl1, /* distances of upper left hand (1) and */
fr1, /* lower right hand corner (2) to left, */
ft1, /* right, top and bottom of enclosing */
fb1, /* form */
fl2, fr2, ft2, fb2;
FL_Coord bw;
FL_COLOR col1, /* colors of obj */
col2;
char *label; /* object label */
FL_COLOR lcol; /* label color */
int align;
int lsize, /* label size and style */
lstyle;
long *shortcut;
int (*handle)(FL_OBJECT *, int, FL_Coord, FL_Coord, int, void *);
void (*object_callback)(FL_OBJECT *, long);
long argument;
void *spec; /* instantiation */
int (*prehandle)(FL_OBJECT *, int, FL_Coord, FL_Coord, int, void *);
int (*posthandle)(FL_OBJECT *, int, FL_Coord, FL_Coord, int, void *);
void (*set_return)(FL_OBJECT *, unsigned int);
/* Re-configure preference */
unsigned int resize; /* what to do if WM resizes the FORM */
unsigned int nwgravity; /* how to re-position top-left corner */
unsigned int segravity; /* how to re-position lower-right corner */
FL_OBJECT *prev; /* prev. obj in form */
FL_OBJECT *next; /* next. obj in form */
FL_OBJECT *parent;
FL_OBJECT *child;
FL_OBJECT *nc; /* next child */
FL_pixmap *flpixmap; /* pixmap double buffering stateinfo */
int use_pixmap; /* true to use pixmap double buffering*/
/* Some interaction flags */
int returned; /* what last interaction returned */
unsigned int how_return; /* under which conditions to return */
int double_buffer; /* only used by mesa/gl canvas */
int pushed;
int focus;
int belowmouse;
int active; /* if object accepts events */
int input;
int wantkey;
int radio;
int automatic;
int redraw;
int visible;
int is_under; /* if (partially) hidden by other object */
int clip;
unsigned long click_timeout;
void *c_vdata; /* for class use */
char *c_cdata; /* for class use */
long c_ldata; /* for class use */
FL_COLOR dbl_background; /* double buffer background */
char *tooltip;
int tipID;
int group_id;
int want_motion;
int want_update;
};
/* Callback function for an entire form */
typedef void (*FL_FORMCALLBACKPTR)(FL_OBJECT *, void *);
/* Object callback function */
typedef void (*FL_CALLBACKPTR)(FL_OBJECT *, long);
/* Preemptive callback function */
typedef int (*FL_RAW_CALLBACK)(FL_FORM *, void *);
/* At close (WM menu delete/close etc.) function */
typedef int (*FL_FORM_ATCLOSE)(FL_FORM *, void *);
/* Deactivate/activate callback */
typedef void (*FL_FORM_ATDEACTIVATE)(FL_FORM *, void *);
typedef void (*FL_FORM_ATACTIVATE)(FL_FORM *, void *);
typedef int (*FL_HANDLEPTR)(FL_OBJECT *, int, FL_Coord, FL_Coord, int, void *);
/* Error callback */
typedef void (*FL_ERROR_FUNC)(const char *, const char *, ...);
__attribute__((unused)) static FL_OBJECT *FL_EVENT;
/*** FORM ****/
/* Form visibility state: form->visible */
enum { FL_BEING_HIDDEN = -1, FL_HIDDEN = 0, FL_INVISIBLE = FL_HIDDEN, FL_VISIBLE = 1 };
struct FL_FORM_ {
void *fdui; /* for fdesign */
void *u_vdata; /* for application */
char *u_cdata; /* for application */
long u_ldata; /* for application */
char *label; /* window title */
Window window; /* X resource ID for window */
FL_Coord x, /* current geometry info */
y, w, h;
int handle_dec_x, handle_dec_y;
FL_Coord hotx, /* hot-spot of the form */
hoty;
double w_hr, /* high resolution width and height */
h_hr; /* (needed for precise scaling) */
FL_OBJECT *first;
FL_OBJECT *last;
FL_OBJECT *focusobj;
FL_FORMCALLBACKPTR form_callback;
FL_FORM_ATACTIVATE activate_callback;
FL_FORM_ATDEACTIVATE deactivate_callback;
void *form_cb_data;
void *activate_data;
void *deactivate_data;
FL_RAW_CALLBACK key_callback;
FL_RAW_CALLBACK push_callback;
FL_RAW_CALLBACK crossing_callback;
FL_RAW_CALLBACK motion_callback;
FL_RAW_CALLBACK all_callback;
unsigned long compress_mask;
unsigned long evmask;
/* WM_DELETE_WINDOW message handler */
FL_FORM_ATCLOSE close_callback;
void *close_data;
FL_pixmap *flpixmap; /* back buffer */
Pixmap icon_pixmap;
Pixmap icon_mask;
/* Interaction and other flags */
int deactivated; /* non-zero if deactivated */
int use_pixmap; /* true if dbl buffering */
int frozen; /* true if sync change */
int visible; /* true if mapped */
int wm_border; /* window manager info */
unsigned int prop; /* other attributes */
int num_auto_objects;
int needs_full_redraw;
int sort_of_modal; /* internal use */
FL_FORM *parent;
FL_FORM *child;
FL_OBJECT *parent_obj;
int attached; /* not independent anymore */
void (*pre_attach)(FL_FORM *);
void *attach_data;
int in_redraw;
};
/* All FD_xxx structure emitted by fdesign contains at least the
* following */
typedef struct {
FL_FORM *form;
void *vdata;
char *cdata;
long ldata;
} FD_Any;
/* Async IO stuff */
enum { FL_READ = 1, FL_WRITE = 2, FL_EXCEPT = 4 };
/* IO other than XEvent Q */
typedef void (*FL_IO_CALLBACK)(int, void *);
FL_EXPORT void fl_add_io_callback(int fd, unsigned int mask, FL_IO_CALLBACK callback, void *data){};
FL_EXPORT void fl_remove_io_callback(int fd, unsigned int mask, FL_IO_CALLBACK cb){};
/* signals */
typedef void (*FL_SIGNAL_HANDLER)(int, void *);
FL_EXPORT void fl_add_signal_callback(int s, FL_SIGNAL_HANDLER cb, void *data){};
FL_EXPORT void fl_remove_signal_callback(int s){};
FL_EXPORT void fl_signal_caught(int s){};
FL_EXPORT void fl_app_signal_direct(int y){};
enum { FL_INPUT_END_EVENT_CLASSIC = 0, FL_INPUT_END_EVENT_ALWAYS = 1 };
FL_EXPORT int fl_input_end_return_handling(int type)
{
return 0;
};
/** Generic routines that deal with FORMS **/
FL_EXPORT FL_FORM *fl_bgn_form(int type, FL_Coord w, FL_Coord h)
{
return NULL;
};
FL_EXPORT void fl_end_form(void){};
FL_EXPORT FL_OBJECT *fl_do_forms(void)
{
return NULL;
};
FL_EXPORT FL_OBJECT *fl_check_forms(void)
{
return NULL;
};
FL_EXPORT FL_OBJECT *fl_do_only_forms(void)
{
return NULL;
};
FL_EXPORT FL_OBJECT *fl_check_only_forms(void)
{
return NULL;
};
FL_EXPORT void fl_freeze_form(FL_FORM *form){};
FL_EXPORT void fl_set_focus_object(FL_FORM *form, FL_OBJECT *obj){};
FL_EXPORT FL_OBJECT *fl_get_focus_object(FL_FORM *form)
{
return NULL;
};
FL_EXPORT void fl_reset_focus_object(FL_OBJECT *ob){};
#define fl_set_object_focus fl_set_focus_object
FL_EXPORT FL_FORM_ATCLOSE fl_set_form_atclose(FL_FORM *form, FL_FORM_ATCLOSE fmclose, void *data){};
FL_EXPORT FL_FORM_ATCLOSE fl_set_atclose(FL_FORM_ATCLOSE fmclose, void *data){};
FL_EXPORT FL_FORM_ATACTIVATE fl_set_form_atactivate(FL_FORM *form, FL_FORM_ATACTIVATE cb, void *data){};
FL_EXPORT FL_FORM_ATDEACTIVATE fl_set_form_atdeactivate(FL_FORM *form, FL_FORM_ATDEACTIVATE cb, void *data){};
FL_EXPORT void fl_unfreeze_form(FL_FORM *form){};
FL_EXPORT int fl_form_is_activated(FL_FORM *form){};
FL_EXPORT void fl_deactivate_form(FL_FORM *form){};
FL_EXPORT void fl_activate_form(FL_FORM *form){};
FL_EXPORT void fl_deactivate_all_forms(void){};
FL_EXPORT void fl_activate_all_forms(void){};
FL_EXPORT void fl_freeze_all_forms(void){};
FL_EXPORT void fl_unfreeze_all_forms(void){};
FL_EXPORT void fl_scale_form(FL_FORM *form, double xsc, double ysc){};
FL_EXPORT void fl_set_form_position(FL_FORM *form, FL_Coord x, FL_Coord y){};
FL_EXPORT void fl_set_form_title(FL_FORM *form, const char *name){};
FL_EXPORT void fl_set_form_title_f(FL_FORM *form, const char *fmt, ...){};
FL_EXPORT void fl_set_app_mainform(FL_FORM *form){};
FL_EXPORT FL_FORM *fl_get_app_mainform(void)
{
return NULL;
};
FL_EXPORT void fl_set_app_nomainform(int flag){};
FL_EXPORT void fl_set_form_callback(FL_FORM *form, FL_FORMCALLBACKPTR callback, void *d){};
#define fl_set_form_call_back fl_set_form_callback
FL_EXPORT void fl_set_form_size(FL_FORM *form, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_set_form_background_color(FL_FORM *form, FL_COLOR color){};
FL_EXPORT FL_COLOR fl_get_form_background_color(FL_FORM *form){};
FL_EXPORT void fl_set_form_hotspot(FL_FORM *form, FL_Coord x, FL_Coord y){};
FL_EXPORT void fl_set_form_hotobject(FL_FORM *form, FL_OBJECT *ob){};
FL_EXPORT void fl_set_form_minsize(FL_FORM *form, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_set_form_maxsize(FL_FORM *form, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_set_form_event_cmask(FL_FORM *form, unsigned long cmask){};
FL_EXPORT unsigned long fl_get_form_event_cmask(FL_FORM *form){};
FL_EXPORT void fl_set_form_geometry(FL_FORM *form, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h){};
#define fl_set_initial_placement fl_set_form_geometry
FL_EXPORT Window fl_show_form(FL_FORM *form, int place, int border, const char *name)
{
return NULL;
};
FL_EXPORT Window fl_show_form_f(FL_FORM *form, int place, int border, const char *fmt, ...)
{
return NULL;
};
FL_EXPORT void fl_hide_form(FL_FORM *form){};
FL_EXPORT void fl_free_form(FL_FORM *form){};
FL_EXPORT void fl_redraw_form(FL_FORM *form){};
FL_EXPORT void fl_set_form_dblbuffer(FL_FORM *form, int y){};
FL_EXPORT Window fl_prepare_form_window(FL_FORM *form, int place, int border, const char *name)
{
return NULL;
};
FL_EXPORT Window fl_prepare_form_window_f(FL_FORM *form, int place, int border, const char *fmt, ...)
{
return NULL;
};
FL_EXPORT Window fl_show_form_window(FL_FORM *form)
{
return NULL;
};
FL_EXPORT double fl_adjust_form_size(FL_FORM *form)
{
return 0;
};
FL_EXPORT int fl_form_is_visible(FL_FORM *form)
{
return 0;
};
FL_EXPORT int fl_form_is_iconified(FL_FORM *form)
{
return 0;
};
FL_EXPORT FL_RAW_CALLBACK fl_register_raw_callback(FL_FORM *form, unsigned long mask, FL_RAW_CALLBACK rcb){};
#define fl_register_call_back fl_register_raw_callback
FL_EXPORT FL_OBJECT *fl_bgn_group(void)
{
return NULL;
};
FL_EXPORT void fl_end_group(void){};
FL_EXPORT FL_OBJECT *fl_addto_group(FL_OBJECT *group)
{
return NULL;
};
/****** Routines that deal with FL_OBJECTS ********/
FL_EXPORT int fl_get_object_objclass(FL_OBJECT *obj)
{
return 0;
};
FL_EXPORT int fl_get_object_type(FL_OBJECT *obj)
{
return 0;
};
FL_EXPORT void fl_set_object_boxtype(FL_OBJECT *ob, int boxtype){};
FL_EXPORT int fl_get_object_boxtype(FL_OBJECT *obj)
{
return 0;
};
FL_EXPORT void fl_set_object_bw(FL_OBJECT *ob, int bw){};
FL_EXPORT int fl_get_object_bw(FL_OBJECT *ob)
{
return 0;
};
FL_EXPORT void fl_set_object_resize(FL_OBJECT *ob, unsigned int what){};
FL_EXPORT void fl_get_object_resize(FL_OBJECT *ob, unsigned int *what){};
FL_EXPORT void fl_set_object_gravity(FL_OBJECT *ob, unsigned int nw, unsigned int se){};
FL_EXPORT void fl_get_object_gravity(FL_OBJECT *ob, unsigned int *nw, unsigned int *se){};
FL_EXPORT void fl_set_object_lsize(FL_OBJECT *obj, int lsize){};
FL_EXPORT int fl_get_object_lsize(FL_OBJECT *obj){};
FL_EXPORT void fl_set_object_lstyle(FL_OBJECT *obj, int lstyle){};
FL_EXPORT int fl_get_object_lstyle(FL_OBJECT *obj)
{
return 0;
};
FL_EXPORT void fl_set_object_lcol(FL_OBJECT *ob, FL_COLOR lcol){};
FL_EXPORT FL_COLOR fl_get_object_lcol(FL_OBJECT *obj){};
FL_EXPORT int fl_set_object_return(FL_OBJECT *ob, unsigned int when){};
FL_EXPORT void fl_set_object_lalign(FL_OBJECT *obj, int align){};
FL_EXPORT int fl_get_object_lalign(FL_OBJECT *obj)
{
return 0;
};
FL_EXPORT void fl_set_object_shortcut(FL_OBJECT *obj, const char *sstr, int showit){};
FL_EXPORT void fl_set_object_shortcutkey(FL_OBJECT *obj, unsigned int keysym){};
FL_EXPORT void fl_set_object_dblbuffer(FL_OBJECT *ob, int y){};
FL_EXPORT void fl_set_object_color(FL_OBJECT *ob, FL_COLOR col1, FL_COLOR col2){};
FL_EXPORT void fl_get_object_color(FL_OBJECT *obj, FL_COLOR *col1, FL_COLOR *col2){};
FL_EXPORT void fl_set_object_label(FL_OBJECT *ob, const char *label){};
FL_EXPORT void fl_set_object_label_f(FL_OBJECT *obj, const char *fmt, ...){};
FL_EXPORT const char *fl_get_object_label(FL_OBJECT *obj)
{
return NULL;
};
FL_EXPORT void fl_set_object_helper(FL_OBJECT *ob, const char *tip){};
FL_EXPORT void fl_set_object_helper_f(FL_OBJECT *ob, const char *fmt, ...){};
FL_EXPORT void fl_set_object_position(FL_OBJECT *obj, FL_Coord x, FL_Coord y){};
FL_EXPORT void fl_get_object_size(FL_OBJECT *obj, FL_Coord *w, FL_Coord *h){};
FL_EXPORT void fl_set_object_size(FL_OBJECT *obj, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_set_object_automatic(FL_OBJECT *obj, int flag){};
FL_EXPORT int fl_object_is_automatic(FL_OBJECT *obj){};
FL_EXPORT void fl_draw_object_label(FL_OBJECT *ob){};
FL_EXPORT void fl_draw_object_label_outside(FL_OBJECT *ob){};
FL_EXPORT FL_OBJECT *fl_get_object_component(FL_OBJECT *composite, int objclass, int type, int numb)
{
return NULL;
};
FL_EXPORT void fl_for_all_objects(FL_FORM *form, int (*cb)(FL_OBJECT *, void *), void *v){};
#define fl_draw_object_outside_label fl_draw_object_label_outside
FL_EXPORT void fl_set_object_dblclick(FL_OBJECT *obj, unsigned long timeout){};
FL_EXPORT unsigned long fl_get_object_dblclick(FL_OBJECT *obj)
{
return 0;
};
FL_EXPORT void fl_set_object_geometry(FL_OBJECT *obj, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_move_object(FL_OBJECT *obj, FL_Coord dx, FL_Coord dy){};
#define fl_set_object_lcolor fl_set_object_lcol
#define fl_get_object_lcolor fl_get_object_lcol
FL_EXPORT void fl_fit_object_label(FL_OBJECT *obj, FL_Coord xmargin, FL_Coord ymargin){};
FL_EXPORT void fl_get_object_geometry(FL_OBJECT *ob, FL_Coord *x, FL_Coord *y, FL_Coord *w, FL_Coord *h){};
FL_EXPORT void fl_get_object_position(FL_OBJECT *ob, FL_Coord *x, FL_Coord *y){};
/* This one takes into account the label */
FL_EXPORT void fl_get_object_bbox(FL_OBJECT *obj, FL_Coord *x, FL_Coord *y, FL_Coord *w, FL_Coord *h)
{
*x = *y = *w = *h = 0;
};
#define fl_compute_object_geometry fl_get_object_bbox
FL_EXPORT void fl_call_object_callback(FL_OBJECT *ob){};
FL_EXPORT FL_HANDLEPTR fl_set_object_prehandler(FL_OBJECT *ob, FL_HANDLEPTR phandler){};
FL_EXPORT FL_HANDLEPTR fl_set_object_posthandler(FL_OBJECT *ob, FL_HANDLEPTR post){};
FL_EXPORT FL_CALLBACKPTR fl_set_object_callback(FL_OBJECT *obj, FL_CALLBACKPTR callback, long argument){};
#define fl_set_object_align fl_set_object_lalign
#define fl_set_call_back fl_set_object_callback
FL_EXPORT void fl_redraw_object(FL_OBJECT *obj){};
FL_EXPORT void fl_show_object(FL_OBJECT *ob){};
FL_EXPORT void fl_hide_object(FL_OBJECT *ob){};
FL_EXPORT int fl_object_is_visible(FL_OBJECT *obj){};
FL_EXPORT void fl_free_object(FL_OBJECT *obj){};
FL_EXPORT void fl_delete_object(FL_OBJECT *obj){};
FL_EXPORT int fl_get_object_return_state(FL_OBJECT *obj)
{
return 0;
};
FL_EXPORT void fl_trigger_object(FL_OBJECT *obj){};
FL_EXPORT void fl_activate_object(FL_OBJECT *ob){};
FL_EXPORT void fl_deactivate_object(FL_OBJECT *ob){};
FL_EXPORT int fl_object_is_active(FL_OBJECT *obj)
{
return 0;
};
FL_EXPORT int fl_enumerate_fonts(void (*output)(const char *s), int shortform)
{
return 0;
};
FL_EXPORT int fl_set_font_name(int n, const char *name)
{
return 0;
};
FL_EXPORT int fl_set_font_name_f(int n, const char *fmt, ...)
{
return 0;
};
FL_EXPORT void fl_set_font(int numb, int size){};
/* Routines that facilitate free object */
FL_EXPORT int fl_get_char_height(int style, int size, int *asc, int *desc)
{
return 0;
};
FL_EXPORT int fl_get_char_width(int style, int size)
{
return 0;
};
FL_EXPORT int fl_get_string_height(int style, int size, const char *s, int len, int *asc, int *desc)
{
return 0;
};
FL_EXPORT int fl_get_string_width(int style, int size, const char *s, int len)
{
return 0;
};
FL_EXPORT int fl_get_string_widthTAB(int style, int size, const char *s, int len)
{
return 0;
};
FL_EXPORT void fl_get_string_dimension(int fntstyle, int fntsize, const char *s, int len, int *width, int *height){};
#define fl_get_string_size fl_get_string_dimension
FL_EXPORT void fl_get_align_xy(int align, int x, int y, int w, int h, int xsize, int ysize, int xoff, int yoff, int *xx, int *yy){};
FL_EXPORT int fl_get_label_char_at_mouse(FL_OBJECT *obj)
{
return 0;
};
FL_EXPORT void fl_drw_text(int align, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, const char *istr){};
FL_EXPORT void fl_drw_text_beside(int align, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, const char *str){};
FL_EXPORT void fl_drw_text_cursor(int align, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, const char *str, int cc, int pos){};
FL_EXPORT void fl_drw_box(int style, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, FL_COLOR c, int bw_in){};
typedef void (*FL_DRAWPTR)(FL_Coord, FL_Coord, FL_Coord, FL_Coord, int, FL_COLOR);
FL_EXPORT int fl_add_symbol(const char *name, FL_DRAWPTR drawit, int scalable)
{
return 0;
};
FL_EXPORT int fl_delete_symbol(const char *name)
{
return 0;
};
FL_EXPORT int fl_draw_symbol(const char *label, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, FL_COLOR col)
{
return 0;
};
FL_EXPORT unsigned long fl_mapcolor(FL_COLOR col, int r, int g, int b)
{
return 0;
};
FL_EXPORT long fl_mapcolorname(FL_COLOR col, const char *name)
{
return 0;
};
#define fl_mapcolor_name fl_mapcolorname
FL_EXPORT void fl_free_colors(FL_COLOR *c, int n){};
FL_EXPORT void fl_free_pixels(unsigned long *pix, int n){};
FL_EXPORT void fl_set_color_leak(int y){};
FL_EXPORT unsigned long fl_getmcolor(FL_COLOR i, int *r, int *g, int *b)
{
return 0;
};
FL_EXPORT unsigned long fl_get_pixel(FL_COLOR col)
{
return 0;
};
#define fl_get_flcolor fl_get_pixel
FL_EXPORT void fl_get_icm_color(FL_COLOR col, int *r, int *g, int *b){};
FL_EXPORT void fl_set_icm_color(FL_COLOR col, int r, int g, int b){};
FL_EXPORT void fl_color(FL_COLOR col){};
FL_EXPORT void fl_bk_color(FL_COLOR col){};
FL_EXPORT void fl_set_gamma(double r, double g, double b){};
FL_EXPORT void fl_show_errors(int y){};
/* Some macros */
#define FL_max(a, b) ((a) > (b) ? (a) : (b))
#define FL_min(a, b) ((a) < (b) ? (a) : (b))
#define FL_abs(a) ((a) > 0 ? (a) : (-(a)))
#define FL_nint(a) ((int)((a) > 0 ? ((a) + 0.5) : ((a)-0.5)))
#define FL_clamp(a, amin, amax) ((a) < (amin) ? (amin) : ((a) > (amax) ? (amax) : (a)))
#define FL_crnd(a) ((FL_Coord)((a) > 0 ? ((a) + 0.5) : ((a)-0.5)))
typedef int (*FL_FSCB)(const char *, void *);
/* Utilities for new objects */
__attribute__((unused)) static FL_FORM *fl_current_form;
FL_EXPORT void fl_add_object(FL_FORM *form, FL_OBJECT *obj){};
FL_EXPORT FL_FORM *fl_addto_form(FL_FORM *form)
{
return NULL;
};
FL_EXPORT FL_OBJECT *fl_make_object(int objclass, int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label, FL_HANDLEPTR handle)
{
return NULL;
};
FL_EXPORT void fl_add_child(FL_OBJECT *oa, FL_OBJECT *ob){};
FL_EXPORT void fl_set_coordunit(int u){};
FL_EXPORT void fl_set_border_width(int bw){};
FL_EXPORT void fl_set_scrollbar_type(int t){};
#define fl_set_thinscrollbar(t) fl_set_scrollbar_type(t ? FL_THIN_SCROLLBAR : FL_NORMAL_SCROLLBAR)
FL_EXPORT void fl_flip_yorigin(void){};
FL_EXPORT int fl_get_coordunit(void)
{
return 0;
};
FL_EXPORT int fl_get_border_width(void)
{
return 0;
};
/* Misc. routines */
FL_EXPORT void fl_ringbell(int percent){};
FL_EXPORT void fl_gettime(long *sec, long *usec){};
FL_EXPORT const char *fl_now(void)
{
return NULL;
};
FL_EXPORT const char *fl_whoami(void)
{
return NULL;
};
FL_EXPORT long fl_mouse_button(void)
{
return 0;
};
FL_EXPORT int fl_current_event(void)
{
return 0;
};
FL_EXPORT char *fl_strdup(const char *s)
{
return NULL;
};
FL_EXPORT void fl_set_err_logfp(FILE *fp){};
FL_EXPORT void fl_set_error_handler(FL_ERROR_FUNC user_func){};
FL_EXPORT char **fl_get_cmdline_args(int *ia)
{
return NULL;
};
/* This function was called 'fl_set_error_logfp/' in XForms 0.89. */
#define fl_set_error_logfp fl_set_err_logfp
#define fl_mousebutton fl_mouse_button
/* These give more flexibility for future changes. Also application
* can re-assign these pointers to whatever function it wants, e.g.,
* to a shared memory pool allocator. */
/*
FL_EXPORT void ( * fl_free )( void * ){};
FL_EXPORT void * ( * fl_malloc )( size_t ){};
FL_EXPORT void * ( * fl_calloc )( size_t,
size_t ){};
FL_EXPORT void * ( * fl_realloc )( void *,
size_t ){};
*/
FL_EXPORT int fl_msleep(unsigned long msec)
{
return 0;
};
#define FL_MAX_MENU_CHOICE_ITEMS 128
typedef const char *(*FL_VAL_FILTER)(FL_OBJECT *, double, int);
FL_EXPORT int fl_is_same_object(FL_OBJECT *obj1, FL_OBJECT *obj2)
{
return 0;
};
#endif /* ! defined FL_BASIC_H */
/**
* \file XBasic.h
*
* X Window dependent stuff
*
*/
#ifndef FL_XBASIC_H
#define FL_XBASIC_H
/* Draw mode */
enum { FL_XOR = 0, FL_COPY = 1, FL_AND = 2 };
#define FL_MINDEPTH 1
/* FL_xxx does not do anything anymore, but kept for compatibility */
enum {
FL_IllegalVisual = -1,
FL_StaticGray = 0,
FL_GrayScale = 1,
FL_StaticColor = 2,
FL_PseudoColor = 3,
FL_TrueColor = 4,
FL_DirectColor = 5,
FL_DefaultVisual = 10 /* special request */
};
enum { FL_North = 0, FL_NorthEast, FL_NorthWest, FL_South, FL_SouthEast, FL_SouthWest, FL_East, FL_West, FL_NoGravity, FL_ForgetGravity };
#ifndef GreyScale
#define GreyScale GrayScale
#define StaticGrey StaticGray
#endif
#define FL_is_gray(v) ((v) == GrayScale || (v) == StaticGray)
#define FL_is_rgb(v) ((v) == TrueColor || (v) == DirectColor)
/* Internal colormap size. Not really very meaningful as fl_mapcolor
* and company allow color "leakage", that is, although only FL_MAX_COLS
* are kept in the internal colormap, the server might have substantially
* more colors allocated */
#define FL_MAX_COLORS 1024
#define FL_MAX_COLS FL_MAX_COLORS
/* FL graphics state information. Some are redundant. */
typedef struct {
// XVisualInfo * xvinfo;
// XFontStruct * cur_fnt; /* current font in default GC */
// Colormap colormap; /* colormap valid for xvinfo */
Window trailblazer; /* a valid window for xvinfo */
int vclass, /* visual class and color depth */
depth;
int rgb_bits; /* primary color resolution */
int dithered; /* true if dithered color */
int pcm; /* true if colormap is not shared */
// GC gc[ 16 ]; /* working GC */
// GC textgc[ 16 ]; /* GC used exclusively for text */
// GC dimmedGC; /* A GC having a checkboard stipple */
unsigned long lut[FL_MAX_COLS]; /* secondary lookup table */
unsigned int rshift, rmask, rbits;
unsigned int gshift, gmask, gbits;
unsigned int bshift, bmask, bbits;
} FL_State;
#define FL_STATE FL_State /* for compatibility */
/***** Global variables ******/
// static Display *fl_display;
__attribute__((unused)) static int fl_screen;
__attribute__((unused)) static Window fl_root; /* root window */
__attribute__((unused)) static Window fl_vroot; /* virtual root window */
__attribute__((unused)) static int fl_scrh, /* screen dimension in pixels */
fl_scrw;
__attribute__((unused)) static int fl_vmode;
/* Current version only runs in single visual mode */
#define fl_get_vclass() fl_vmode
#define fl_get_form_vclass(a) fl_vmode
#define fl_get_gc() fl_state[fl_vmode].gc[0]
__attribute__((unused)) static FL_State fl_state[];
__attribute__((unused)) static char *fl_ul_magic_char;
FL_EXPORT int fl_mode_capable(int mode, int warn)
{
return 0;
};
#define fl_default_win() (fl_state[fl_vmode].trailblazer)
#define fl_default_window() (fl_state[fl_vmode].trailblazer)
/* All pixmaps used by FL_OBJECT to simulate double buffering have the
* following entries in the structure. FL_Coord x,y are used to shift
* the origin of the drawing routines */
struct FL_pixmap_ {
Pixmap pixmap;
Window win;
Visual *visual;
FL_Coord x, y, w, h;
int depth;
FL_COLOR dbl_background;
FL_COLOR pixel;
};
/* Fonts related */
#define FL_MAX_FONTSIZES 10
#define FL_MAX_FONTNAME_LENGTH 80
typedef struct {
XFontStruct *fs[FL_MAX_FONTSIZES]; /* cached fontstruct */
short size[FL_MAX_FONTSIZES]; /* cached sizes */
short nsize; /* cached so far */
char fname[FL_MAX_FONTNAME_LENGTH + 1]; /* without size info */
} FL_FONT;
/* Some basic drawing routines */
typedef XPoint FL_POINT;
typedef XRectangle FL_RECT;
/* Rectangles */
FL_EXPORT void fl_rectangle(int fill, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, FL_COLOR col){};
FL_EXPORT void fl_rectbound(FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, FL_COLOR col){};
#define fl_rectf(x, y, w, h, c) fl_rectangle(1, x, y, w, h, c)
#define fl_rect(x, y, w, h, c) fl_rectangle(0, x, y, w, h, c)
/* Rectangle with rounded-corners */
FL_EXPORT void fl_roundrectangle(int fill, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, FL_COLOR col){};
#define fl_roundrectf(x, y, w, h, c) fl_roundrectangle(1, x, y, w, h, c)
#define fl_roundrect(x, y, w, h, c) fl_roundrectangle(0, x, y, w, h, c)
/* General polygon and polylines */
FL_EXPORT void fl_polygon(int fill, FL_POINT *xp, int n, FL_COLOR col){};
#define fl_polyf(p, n, c) fl_polygon(1, p, n, c)
#define fl_polyl(p, n, c) fl_polygon(0, p, n, c)
#define fl_polybound(p, n, c) \
do { \
fl_polygon(1, p, n, c); \
fl_polygon(0, p, n, FL_BLACK); \
} while (0)
FL_EXPORT void fl_lines(FL_POINT *xp, int n, FL_COLOR col){};
FL_EXPORT void fl_line(FL_Coord xi, FL_Coord yi, FL_Coord xf, FL_Coord yf, FL_COLOR c){};
FL_EXPORT void fl_point(FL_Coord x, FL_Coord y, FL_COLOR c){};
FL_EXPORT void fl_points(FL_POINT *p, int np, FL_COLOR c){};
#define fl_simple_line fl_line
FL_EXPORT void fl_dashedlinestyle(const char *dash, int ndash){};
FL_EXPORT void fl_update_display(int block){};
#define fl_diagline(x, y, w, h, c) fl_line(x, y, (x) + (w)-1, (y) + (h)-1, c)
/* Line attributes */
enum { FL_SOLID = LineSolid, FL_USERDASH = LineOnOffDash, FL_USERDOUBLEDASH = LineDoubleDash, FL_DOT, FL_DOTDASH, FL_DASH, FL_LONGDASH };
FL_EXPORT void fl_linewidth(int n){};
FL_EXPORT void fl_linestyle(int n){};
FL_EXPORT void fl_drawmode(int request){};
FL_EXPORT int fl_get_linewidth(void)
{
return 0;
};
FL_EXPORT int fl_get_linestyle(void)
{
return 0;
};
FL_EXPORT int fl_get_drawmode(void)
{
return 0;
};
#define fl_set_linewidth fl_linewidth
#define fl_set_linestyle fl_linestyle
#define fl_set_drawmode fl_drawmode
/*
* Interfaces
*/
FL_EXPORT XFontStruct *fl_get_fontstruct(int style, int size){};
#define fl_get_font_struct fl_get_fontstruct
#define fl_get_fntstruct fl_get_font_struct
FL_EXPORT Window fl_get_mouse(FL_Coord *x, FL_Coord *y, unsigned int *keymask)
{
return NULL;
};
FL_EXPORT void fl_set_mouse(FL_Coord mx, FL_Coord my){};
FL_EXPORT Window fl_get_win_mouse(Window win, FL_Coord *x, FL_Coord *y, unsigned int *keymask)
{
return NULL;
};
FL_EXPORT Window fl_get_form_mouse(FL_FORM *fm, FL_Coord *x, FL_Coord *y, unsigned int *keymask)
{
return NULL;
};
FL_EXPORT FL_FORM *fl_win_to_form(Window win)
{
return NULL;
};
FL_EXPORT void fl_set_form_icon(FL_FORM *form, Pixmap p, Pixmap m){};
FL_EXPORT int fl_get_decoration_sizes(FL_FORM *form, int *top, int *right, int *bottom, int *left)
{
return 0;
};
FL_EXPORT void fl_raise_form(FL_FORM *form){};
FL_EXPORT void fl_lower_form(FL_FORM *form){};
FL_EXPORT void fl_set_foreground(GC gc, FL_COLOR color){};
FL_EXPORT void fl_set_background(GC gc, FL_COLOR color){};
/* General windowing support */
FL_EXPORT Window fl_wincreate(const char *label)
{
return NULL;
};
FL_EXPORT Window fl_winshow(Window win)
{
return NULL;
};
FL_EXPORT Window fl_winopen(const char *label)
{
return NULL;
};
FL_EXPORT void fl_winhide(Window win){};
FL_EXPORT void fl_winclose(Window win){};
FL_EXPORT void fl_winset(Window win){};
FL_EXPORT int fl_winreparent(Window win, Window new_parent)
{
return 0;
};
FL_EXPORT void fl_winfocus(Window win){};
FL_EXPORT Window fl_winget(void)
{
return NULL;
};
FL_EXPORT int fl_iconify(Window win)
{
return 0;
};
FL_EXPORT void fl_winresize(Window win, FL_Coord neww, FL_Coord newh){};
FL_EXPORT void fl_winmove(Window win, FL_Coord dx, FL_Coord dy){};
FL_EXPORT void fl_winreshape(Window win, FL_Coord dx, FL_Coord dy, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_winicon(Window win, Pixmap p, Pixmap m){};
FL_EXPORT void fl_winbackground(Window win, unsigned long bk){};
FL_EXPORT void fl_winstepsize(Window win, FL_Coord dx, FL_Coord dy){};
FL_EXPORT int fl_winisvalid(Window win)
{
return 0;
};
FL_EXPORT void fl_wintitle(Window win, const char *title){};
FL_EXPORT void fl_wintitle_f(Window win, const char *fmt, ...){};
FL_EXPORT void fl_winicontitle(Window win, const char *title){};
FL_EXPORT void fl_winicontitle_f(Window win, const char *fmt, ...){};
FL_EXPORT void fl_winposition(FL_Coord x, FL_Coord y){};
#define fl_pref_winposition fl_winposition
#define fl_win_background fl_winbackground
#define fl_winstepunit fl_winstepsize
#define fl_set_winstepunit fl_winstepsize
FL_EXPORT void fl_winminsize(Window win, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_winmaxsize(Window win, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_winaspect(Window win, FL_Coord x, FL_Coord y){};
FL_EXPORT void fl_reset_winconstraints(Window win){};
FL_EXPORT void fl_winsize(FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_initial_winsize(FL_Coord w, FL_Coord h){};
#define fl_pref_winsize fl_winsize
FL_EXPORT void fl_initial_winstate(int state){};
FL_EXPORT Colormap fl_create_colormap(XVisualInfo *xv, int nfill){};
FL_EXPORT void fl_wingeometry(FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h){};
#define fl_pref_wingeometry fl_wingeometry
FL_EXPORT void fl_initial_wingeometry(FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_noborder(void){};
FL_EXPORT void fl_transient(void){};
FL_EXPORT void fl_get_winsize(Window win, FL_Coord *w, FL_Coord *h){};
FL_EXPORT void fl_get_winorigin(Window win, FL_Coord *x, FL_Coord *y){};
FL_EXPORT void fl_get_wingeometry(Window win, FL_Coord *x, FL_Coord *y, FL_Coord *w, FL_Coord *h){};
/* For compatibility */
#define fl_get_win_size fl_get_winsize
#define fl_get_win_origin fl_get_winorigin
#define fl_get_win_geometry fl_get_wingeometry
#define fl_initial_winposition fl_pref_winposition
#define fl_get_display() fl_display
#define FL_FormDisplay(form) fl_display
#define FL_ObjectDisplay(object) fl_display
#define FL_IS_CANVAS(o) ((o)->objclass == FL_CANVAS || (o)->objclass == FL_GLCANVAS)
/* The window an object belongs to - for drawing */
#define FL_ObjWin(o) (FL_IS_CANVAS(o) ? fl_get_canvas_id(o) : (o)->form->window)
FL_EXPORT Window fl_get_real_object_window(FL_OBJECT *ob){};
#define FL_OBJECT_WID FL_ObjWin
/* All registerable events, including Client Message */
#define FL_ALL_EVENT (KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | ButtonMotionMask | PointerMotionMask)
/* Replacements for X functions that access the event queue */
FL_EXPORT int fl_XNextEvent(XEvent *xev)
{
return 0;
};
FL_EXPORT int fl_XPeekEvent(XEvent *xev)
{
return 0;
};
FL_EXPORT int fl_XEventsQueued(int mode)
{
return 0;
};
FL_EXPORT void fl_XPutBackEvent(XEvent *xev){};
FL_EXPORT const XEvent *fl_last_event(void)
{
return NULL;
};
typedef int (*FL_APPEVENT_CB)(XEvent *, void *);
FL_EXPORT FL_APPEVENT_CB fl_set_event_callback(FL_APPEVENT_CB callback, void *user_data){};
FL_EXPORT FL_APPEVENT_CB fl_set_idle_callback(FL_APPEVENT_CB callback, void *user_data){};
FL_EXPORT long fl_addto_selected_xevent(Window win, long mask)
{
return 0;
};
FL_EXPORT long fl_remove_selected_xevent(Window win, long mask)
{
return 0;
};
#define fl_add_selected_xevent fl_addto_selected_xevent
FL_EXPORT void fl_set_idle_delta(long delta){};
FL_EXPORT FL_APPEVENT_CB fl_add_event_callback(Window win, int ev, FL_APPEVENT_CB wincb, void *user_data){};
FL_EXPORT void fl_remove_event_callback(Window win, int ev){};
FL_EXPORT void fl_activate_event_callbacks(Window win){};
FL_EXPORT XEvent *fl_print_xevent_name(const char *where, const XEvent *xev){};
FL_EXPORT void fl_XFlush(void){};
#define metakey_down(mask) ((mask)&Mod1Mask)
#define shiftkey_down(mask) ((mask)&ShiftMask)
#define controlkey_down(mask) ((mask)&ControlMask)
#define button_down(mask) (((mask)&Button1Mask) || ((mask)&Button2Mask) || ((mask)&Button3Mask) || ((mask)&Button4Mask) || ((mask)&Button5Mask))
#define fl_keypressed fl_keysym_pressed
/****************** Resources ***************/
typedef enum { FL_NONE, FL_SHORT = 10, FL_BOOL, FL_INT, FL_LONG, FL_FLOAT, FL_STRING } FL_RTYPE;
typedef struct {
const char *res_name; /* resource name */
const char *res_class; /* resource class */
FL_RTYPE type; /* FL_INT, FL_FLOAT, FL_BOOL, FL_STRING */
void *var; /* address for the variable */
const char *defval; /* default setting in string form */
int nbytes; /* used only for strings */
} FL_RESOURCE;
#define FL_resource FL_RESOURCE
#define FL_CMD_OPT XrmOptionDescRec
FL_EXPORT Display *fl_initialize(int *na, char *arg[], const char *appclass, FL_CMD_OPT *appopt, int nappopt)
{
return NULL;
};
FL_EXPORT void fl_finish(void){};
FL_EXPORT const char *fl_get_resource(const char *rname, const char *cname, FL_RTYPE dtype, const char *defval, void *val, int size)
{
return NULL;
};
FL_EXPORT void fl_set_resource(const char *str, const char *val){};
FL_EXPORT void fl_get_app_resources(FL_RESOURCE *appresource, int n){};
FL_EXPORT void fl_set_visualID(long id){};
FL_EXPORT int fl_keysym_pressed(KeySym k)
{
return 0;
};
#define buttonLabelSize buttonFontSize
#define sliderLabelSize sliderFontSize
#define inputLabelSize inputFontSize
/* All Form control variables. Named closely as its resource name */
typedef struct {
float rgamma, ggamma, bgamma;
int debug, sync;
int depth, vclass, doubleBuffer;
int ulPropWidth, /* underline stuff */
ulThickness;
int buttonFontSize;
int sliderFontSize;
int inputFontSize;
int browserFontSize;
int menuFontSize;
int choiceFontSize;
int labelFontSize; /* all other labels fonts */
int pupFontSize, /* font for pop-up menus */
pupFontStyle;
int privateColormap;
int sharedColormap;
int standardColormap;
int scrollbarType;
int backingStore;
int coordUnit;
int borderWidth;
int safe;
char *rgbfile; /* where RGB file is, not used */
char vname[24];
} FL_IOPT;
#define FL_PDButtonLabelSize FL_PDButtonFontSize
#define FL_PDSliderLabelSize FL_PDSliderFontSize
#define FL_PDInputLabelSize FL_PDInputFontSize
/* Program default masks */
enum {
FL_PDDepth = (1 << 1),
FL_PDClass = (1 << 2),
FL_PDDouble = (1 << 3),
FL_PDSync = (1 << 4),
FL_PDPrivateMap = (1 << 5),
FL_PDScrollbarType = (1 << 6),
FL_PDPupFontSize = (1 << 7),
FL_PDButtonFontSize = (1 << 8),
FL_PDInputFontSize = (1 << 9),
FL_PDSliderFontSize = (1 << 10),
FL_PDVisual = (1 << 11),
FL_PDULThickness = (1 << 12),
FL_PDULPropWidth = (1 << 13),
FL_PDBS = (1 << 14),
FL_PDCoordUnit = (1 << 15),
FL_PDDebug = (1 << 16),
FL_PDSharedMap = (1 << 17),
FL_PDStandardMap = (1 << 18),
FL_PDBorderWidth = (1 << 19),
FL_PDSafe = (1 << 20),
FL_PDMenuFontSize = (1 << 21),
FL_PDBrowserFontSize = (1 << 22),
FL_PDChoiceFontSize = (1 << 23),
FL_PDLabelFontSize = (1 << 24)
};
#define FL_PDButtonLabel FL_PDButtonLabelSize
FL_EXPORT void fl_set_defaults(unsigned long mask, FL_IOPT *cntl){};
FL_EXPORT void fl_set_tabstop(const char *s){};
FL_EXPORT int fl_get_visual_depth(void)
{
return 0;
};
FL_EXPORT int fl_is_global_clipped(void)
{
return 0;
};
FL_EXPORT int fl_is_clipped(int include_global)
{
return 0;
};
FL_EXPORT int fl_is_text_clipped(int include_global)
{
return 0;
};
FL_EXPORT void fl_set_clipping(FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_unset_clipping(){};
FL_EXPORT void fl_set_text_clipping(FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_unset_text_clipping(void){};
FL_EXPORT int fl_get_global_clipping(FL_COORD *x, FL_COORD *y, FL_COORD *w, FL_COORD *h)
{
return 0;
};
FL_EXPORT int fl_get_clipping(int include_global, FL_COORD *x, FL_COORD *y, FL_COORD *w, FL_COORD *h)
{
return 0;
};
FL_EXPORT int fl_get_text_clipping(int include_global, FL_COORD *x, FL_COORD *y, FL_COORD *w, FL_COORD *h)
{
return 0;
};
FL_EXPORT void fl_set_gc_clipping(GC gc, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h){};
FL_EXPORT void fl_unset_gc_clipping(GC gc){};
/* How we pack and unpack colors */
#ifndef FL_PCBITS
typedef unsigned char FL_PCTYPE; /* primary color type */
#define FL_PCBITS 8 /* primary color bits */
#define FL_PCMAX ((1 << FL_PCBITS) - 1)
#define FL_PCCLAMP(a) ((a) > (FL_PCMAX) ? (FL_PCMAX) : ((a) < 0 ? 0 : (a)))
typedef unsigned int FL_PACKED4;
#define FL_PACKED FL_PACKED4
#define FL_RMASK 0x000000ff
#define FL_RSHIFT 0
#define FL_GMASK 0x0000ff00
#define FL_GSHIFT 8
#define FL_BMASK 0x00ff0000
#define FL_BSHIFT 16
#define FL_AMASK 0xff000000
#define FL_ASHIFT 24
/* If PCBITS is not 8, we need to apply the RGBmask */
#define FL_GETR(packed) (((packed) >> FL_RSHIFT) & FL_RMASK)
#define FL_GETG(packed) (((packed) >> FL_GSHIFT) & FL_PCMAX)
#define FL_GETB(packed) (((packed) >> FL_BSHIFT) & FL_PCMAX)
#define FL_GETA(packed) (((packed) >> FL_ASHIFT) & FL_PCMAX)
#define FL_PACK3(r, g, b) (((r) << FL_RSHIFT) | ((g) << FL_GSHIFT) | ((b) << FL_BSHIFT))
#define FL_PACK FL_PACK3
#define FL_PACK4(r, g, b, a) (FL_PACK3(r, g, b) | ((a) << FL_ASHIFT))
#define FL_UNPACK(p, r, g, b) \
do { \
r = FL_GETR(p); \
g = FL_GETG(p); \
b = FL_GETB(p); \
} while (0)
#define FL_UNPACK3 FL_UNPACK
#define FL_UNPACK4(p, r, g, b, a) \
do { \
FL_UNPACK3(p, r, g, b); \
a = FL_GETA(p); \
} while (0)
#endif
typedef struct {
unsigned int rshift, rmask, rbits;
unsigned int gshift, gmask, gbits;
unsigned int bshift, bmask, bbits;
int bits_per_rgb;
int colormap_size;
} FL_RGB2PIXEL_;
#define FL_RGB2PIXEL FL_RGB2PIXEL_
#endif /* ! defined FL_XBASIC_H */
/**
* \file box.h
*
*/
#ifndef FL_BOX_H
#define FL_BOX_H
/* Type is already defined in Basic.h */
FL_EXPORT FL_OBJECT *fl_create_box(int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label)
{
return NULL;
};
FL_EXPORT FL_OBJECT *fl_add_box(int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label)
{
return NULL;
};
#endif /* ! defined FL_BOX_H */
/**
* \file canvas.h
*
* Header for FL_CANVAS
*
*/
#ifndef FL_CANVAS_H_
#define FL_CANVAS_H_
typedef enum { FL_NORMAL_CANVAS, FL_SCROLLED_CANVAS } FL_CANVAS_TYPE;
typedef int (*FL_HANDLE_CANVAS)(FL_OBJECT *, Window, int, int, XEvent *, void *);
typedef int (*FL_MODIFY_CANVAS_PROP)(FL_OBJECT *);
/******************** Default *********************/
#define FL_CANVAS_BOXTYPE FL_DOWN_BOX /* really the decoration frame */
#define FL_CANVAS_ALIGN FL_ALIGN_TOP
/************ Interfaces ************************/
FL_EXPORT FL_OBJECT *fl_create_generic_canvas(int canvas_class, int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label)
{
return NULL;
};
extern FL_OBJECT *websrv_fl_add_canvas(int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label);
FL_EXPORT FL_OBJECT *fl_create_canvas(int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label)
{
return NULL;
};
/* backward compatibility */
#define fl_set_canvas_decoration fl_set_object_boxtype
FL_EXPORT void fl_set_canvas_colormap(FL_OBJECT *ob, Colormap colormap){};
FL_EXPORT void fl_set_canvas_visual(FL_OBJECT *obj, Visual *vi){};
FL_EXPORT void fl_set_canvas_depth(FL_OBJECT *obj, int depth){};
FL_EXPORT void fl_set_canvas_attributes(FL_OBJECT *ob, unsigned int mask, XSetWindowAttributes *xswa){};
FL_EXPORT FL_HANDLE_CANVAS fl_add_canvas_handler(FL_OBJECT *ob, int ev, FL_HANDLE_CANVAS h, void *udata)
{
return NULL;
};
FL_EXPORT Window fl_get_canvas_id(FL_OBJECT *ob)
{
return NULL;
};
FL_EXPORT Colormap fl_get_canvas_colormap(FL_OBJECT *ob)
{
return NULL;
};
FL_EXPORT int fl_get_canvas_depth(FL_OBJECT *obj)
{
return 0;
};
FL_EXPORT void fl_remove_canvas_handler(FL_OBJECT *ob, int ev, FL_HANDLE_CANVAS h){};
FL_EXPORT void fl_share_canvas_colormap(FL_OBJECT *ob, Colormap colormap){};
FL_EXPORT void fl_clear_canvas(FL_OBJECT *ob){};
FL_EXPORT void fl_modify_canvas_prop(FL_OBJECT *obj, FL_MODIFY_CANVAS_PROP init, FL_MODIFY_CANVAS_PROP activate, FL_MODIFY_CANVAS_PROP cleanup){};
FL_EXPORT void fl_canvas_yield_to_shortcut(FL_OBJECT *ob, int yes){};
/* This is an attempt to maintain some sort of backwards compatibility
* with old code whilst also getting rid of the old, system-specific
* hack. */
#ifdef AUTOINCLUDE_GLCANVAS_H
#include <glcanvas.h>
#endif
#endif /* ! defined FL_CANVAS_H */
/**
* \file text.h
*/
#ifndef FL_TEXT_H
#define FL_TEXT_H
enum { FL_NORMAL_TEXT };
#define FL_TEXT_BOXTYPE FL_FLAT_BOX
#define FL_TEXT_COL1 FL_COL1
#define FL_TEXT_COL2 FL_MCOL
#define FL_TEXT_LCOL FL_LCOL
#define FL_TEXT_ALIGN (FL_ALIGN_LEFT | FL_ALIGN_INSIDE)
FL_EXPORT FL_OBJECT *fl_create_text(int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label)
{
return NULL;
};
FL_EXPORT FL_OBJECT *fl_add_text(int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label)
{
return NULL;
};
#endif /* ! defined FL_TEXT_H */
/**
* \file xyplot.h
*/
#ifndef FL_XYPLOT_H
#define FL_XYPLOT_H
/* Class FL_XYPLOT */
typedef enum {
FL_NORMAL_XYPLOT, /* solid line */
FL_SQUARE_XYPLOT, /* with added square */
FL_CIRCLE_XYPLOT, /* with added circle */
FL_FILL_XYPLOT, /* fill completely */
FL_POINTS_XYPLOT, /* only data points */
FL_DASHED_XYPLOT, /* dashed line */
FL_IMPULSE_XYPLOT,
FL_ACTIVE_XYPLOT, /* accepts interactive manipulations */
FL_EMPTY_XYPLOT,
FL_DOTTED_XYPLOT,
FL_DOTDASHED_XYPLOT,
FL_LONGDASHED_XYPLOT,
FL_LINEPOINTS_XYPLOT /* line & points */
} FL_XYPLOT_TYPE;
enum { FL_LINEAR, FL_LOG };
enum { FL_GRID_NONE = 0, FL_GRID_MAJOR = 1, FL_GRID_MINOR = 2 };
/***** Defaults *****/
#define FL_XYPLOT_BOXTYPE FL_FLAT_BOX
#define FL_XYPLOT_COL1 FL_COL1
#define FL_XYPLOT_LCOL FL_LCOL
#define FL_XYPLOT_ALIGN FL_ALIGN_BOTTOM
#define FL_MAX_XYPLOTOVERLAY 32
/***** Others *****/
FL_EXPORT FL_OBJECT *fl_create_xyplot(int t, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label)
{
return NULL;
};
extern FL_OBJECT *websrv_fl_add_xyplot(int t, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, const char *label);
FL_EXPORT void fl_set_xyplot_data(FL_OBJECT *ob, float *x, float *y, int n, const char *title, const char *xlabel, const char *ylabel){};
FL_EXPORT void fl_set_xyplot_data_double(FL_OBJECT *ob, double *x, double *y, int n, const char *title, const char *xlabel, const char *ylabel){};
FL_EXPORT int fl_set_xyplot_file(FL_OBJECT *ob, const char *f, const char *title, const char *xl, const char *yl)
{
return 0;
};
FL_EXPORT void fl_insert_xyplot_data(FL_OBJECT *ob, int id, int n, double x, double y){};
#define fl_set_xyplot_datafile fl_set_xyplot_file
FL_EXPORT void fl_add_xyplot_text(FL_OBJECT *ob, double x, double y, const char *text, int al, FL_COLOR col){};
FL_EXPORT void fl_delete_xyplot_text(FL_OBJECT *ob, const char *text){};
FL_EXPORT int fl_set_xyplot_maxoverlays(FL_OBJECT *ob, int maxover)
{
return 0;
};
FL_EXPORT void fl_add_xyplot_overlay(FL_OBJECT *ob, int id, float *x, float *y, int n, FL_COLOR col)
{
return;
};
FL_EXPORT void fl_set_xyplot_xbounds(FL_OBJECT *ob, double xmin, double xmax){};
FL_EXPORT void fl_set_xyplot_ybounds(FL_OBJECT *ob, double ymin, double ymax){};
FL_EXPORT void fl_get_xyplot_xbounds(FL_OBJECT *ob, float *xmin, float *xmax){};
FL_EXPORT void fl_get_xyplot_ybounds(FL_OBJECT *ob, float *ymin, float *ymax){};
FL_EXPORT void fl_get_xyplot(FL_OBJECT *ob, float *x, float *y, int *i){};
FL_EXPORT int fl_get_xyplot_data_size(FL_OBJECT *obj)
{
return 0;
};
extern void websrv_fl_get_xyplot_data(FL_OBJECT *ob, float *x, float *y, int *n);
extern void websrv_fl_get_xyplot_data_pointer(FL_OBJECT *ob, int id, float **x, float **y, int *n);
FL_EXPORT void fl_set_xyplot_xgrid(FL_OBJECT *ob, int xgrid){};
typedef void (*FL_XYPLOT_SYMBOL)(FL_OBJECT *, int, FL_POINT *, int, int, int);
FL_EXPORT FL_XYPLOT_SYMBOL fl_set_xyplot_symbol(FL_OBJECT *ob, int id, FL_XYPLOT_SYMBOL symbol)
{
return NULL;
};
#endif /* FL_XYPLOT_H */
/*----------------------------------------------------------------------*/
/* new functions for interfacing with webserver */
extern int websrv_nf_getdata(FL_OBJECT *graph, int layer, websrv_scopedata_msg_t **msg);
extern void websrv_free_xyplot(FL_OBJECT *obj);
#if defined __cplusplus
}
#endif
#endif /* FL_FORMS_H */
Reference in New Issue View Git Blame Copy Permalink