def fl_stuff_clipboard(ptr_flobject, clipbdtype, datablock, size, \
pyfn_LoseSelectionCb):
"""fl_stuff_clipboard(ptr_flobject, clipbdtype, datablock, size,
pyfn_LoseSelectionCb) -> size
Stores data in clipboard, read-write buffer shared by all applications
running on the X server.
Parameters
----------
ptr_flobject : pointer to xfdata.FL_OBJECT
clipboard flobject
clipbdtype : long
type of clipboard (not used)
datablock : pointer to void?
data contents to be stored (in str?) *todo*
size : long
size (in bytes) of the contents pointed to by datablock.
pyfn_LoseSelectionCb : python function callback, returned unused value
name referring to function(ptr_flobject, [long]type) -> [int]num.
Function to be invoked if selection is lost; type is unused. For
textual content the application that loses the clipboard should
typically undo the visual cues about the selection.
Returns
-------
size : int
size of stuffed data?, or 0 (on failure)
Examples
--------
>>> *todo*
Notes
-----
Status: NA-UTest + Doc + NoDemo = Maybe
"""
#FL_LOSE_SELECTION_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER( \
# xfdata.FL_OBJECT), cty.c_long)
_fl_stuff_clipboard = library.cfuncproto(
library.load_so_libforms(), "fl_stuff_clipboard",
cty.c_int, [cty.POINTER(xfdata.FL_OBJECT), cty.c_long, cty.c_void_p,
cty.c_long, xfdata.FL_LOSE_SELECTION_CB],
"""int fl_stuff_clipboard(FL_OBJECT * ob, long int type,
const char * data, long int size,
FL_LOSE_SELECTION_CB lose_callback)""")
library.check_if_flinitialized()
library.verify_flobjectptr_type(ptr_flobject)
l_clipbdtype = library.convert_to_longc(clipbdtype)
ptr_vdata = cty.cast(datablock, cty.c_void_p)
l_size = library.convert_to_longc(size)
library.verify_function_type(pyfn_LoseSelectionCb)
cfn_LoseSelectionCb = xfdata.FL_LOSE_SELECTION_CB(pyfn_LoseSelectionCb)
library.keep_cfunc_refs(cfn_LoseSelectionCb, pyfn_LoseSelectionCb)
library.keep_elem_refs(ptr_flobject, clipbdtype, datablock, size, \
l_clipbdtype, ptr_vdata, l_size)
retval = _fl_stuff_clipboard(ptr_flobject, l_clipbdtype, ptr_vdata, \
l_size, cfn_LoseSelectionCb)
return retval
def fl_add_canvas_handler(ptr_flobject, evtnum, pyfn_HandleCanvas, userdata):
"""fl_add_canvas_handler(ptr_flobject, evtnum, pyfn_HandleCanvas,
userdata) -> HandleCnavas
Defines a callback to be invoked in a canvas flobject for a specific
X event.
Parameters
----------
ptr_flobject : pointer to xfdata.FL_OBJECT
canvas flobject
evtnum : int
X event number. Values (from xfdata.py): Expose, KeyPress,
KeyRelease, ButtonRelease, etc..
pyfn_HandleCanvas : python function to handle canvas, returned value
name referring to function(ptr_flobject, [long_pos]win,
[int]width, [int]height, ptr_xevent, [pointer to void]pvdata)
-> [int]num
userdata : any type (e.g. None, int, str, etc..)
user data to be passed to function; invoked callback has to take
care of type check and re-cast from ptr_void to chosen type using
appropriate xfstruct.fls_convert_ptrvoid_to_*() function
Returns
-------
HandleCanvas : xfdata.FL_HANDLE_CANVAS
old canvas handler function
Examples
--------
>>> *todo*
Notes
-----
Status: NA-UTest + Doc + Demo = OK
"""
#FL_HANDLE_CANVAS = cty.CFUNCTYPE(cty.c_int, cty.POINTER(xfdata.FL_OBJECT),
# xfdata.Window, cty.c_int, cty.c_int, cty.POINTER(xfdata.XEvent),
# cty.c_void_p)
_fl_add_canvas_handler = library.cfuncproto(
library.load_so_libforms(), "fl_add_canvas_handler",
xfdata.FL_HANDLE_CANVAS, [cty.POINTER(xfdata.FL_OBJECT), cty.c_int,
xfdata.FL_HANDLE_CANVAS, cty.c_void_p],
"""FL_HANDLE_CANVAS fl_add_canvas_handler(FL_OBJECT * ob, int ev,
FL_HANDLE_CANVAS h, void * udata)""")
library.check_if_flinitialized()
library.verify_flobjectptr_type(ptr_flobject)
i_evtnum = library.convert_to_intc(evtnum)
library.verify_function_type(pyfn_HandleCanvas)
cfn_HandleCanvas = xfdata.FL_HANDLE_CANVAS(pyfn_HandleCanvas)
ptr_vdata = library.convert_userdata_to_ptrvoid(userdata)
library.keep_cfunc_refs(cfn_HandleCanvas, pyfn_HandleCanvas)
library.keep_elem_refs(ptr_flobject, evtnum, userdata, i_evtnum, \
ptr_vdata)
retval = _fl_add_canvas_handler(ptr_flobject, i_evtnum, \
cfn_HandleCanvas, ptr_vdata)
return retval
def fl_modify_canvas_prop(ptr_flobject, pyfn_initModifyCanvasProp,
pyfn_activateModifyCanvasProp, pyfn_cleanupModifyCanvasProp):
"""fl_modify_canvas_prop(ptr_flobject, pyfn_initModifyCanvasProp,
pyfn_activateModifyCanvasProp, pyfn_cleanupModifyCanvasProp)
Modifies init, activate and cleanup handler properties of a canvas
flobject.
Parameters
----------
ptr_flobject : pointer to xfdata.FL_OBJECT
canvas flobject
pyfn_initModifyCanvasProp : python function callback, returned value
name referring to function(ptr_flobject) -> [int]num
pyfn_activateModifyCanvasProp : python func. callback, returned value
name referring to function(ptr_flobject) -> [int]num.
pyfn_cleanupModifyCanvasProp : python func. callback, returned value
name referring to function(ptr_flobject) -> [int]num.
Examples
--------
>>> *todo*
Notes
-----
Status: NA-UTest + Doc + NoDemo = Maybe
"""
#FL_MODIFY_CANVAS_PROP = cty.CFUNCTYPE(cty.c_int,
# cty.POINTER(xfdata.FL_OBJECT))
_fl_modify_canvas_prop = library.cfuncproto(
library.load_so_libforms(), "fl_modify_canvas_prop",
None, [cty.POINTER(xfdata.FL_OBJECT), xfdata.FL_MODIFY_CANVAS_PROP,
xfdata.FL_MODIFY_CANVAS_PROP, xfdata.FL_MODIFY_CANVAS_PROP],
"""void fl_modify_canvas_prop(FL_OBJECT * obj,
FL_MODIFY_CANVAS_PROP init, FL_MODIFY_CANVAS_PROP activate,
FL_MODIFY_CANVAS_PROP cleanup)""")
library.check_if_flinitialized()
library.verify_flobjectptr_type(ptr_flobject)
library.verify_function_type(pyfn_initModifyCanvasProp)
cfn_initModifyCanvasProp = xfdata.FL_MODIFY_CANVAS_PROP( \
pyfn_initModifyCanvasProp)
library.verify_function_type(pyfn_activateModifyCanvasProp)
cfn_activateModifyCanvasProp = xfdata.FL_MODIFY_CANVAS_PROP( \
pyfn_activateModifyCanvasProp)
library.verify_function_type(pyfn_cleanupModifyCanvasProp)
cfn_cleanupModifyCanvasProp = xfdata.FL_MODIFY_CANVAS_PROP( \
pyfn_cleanupModifyCanvasProp)
library.keep_cfunc_refs(cfn_initModifyCanvasProp, \
pyfn_initModifyCanvasProp, cfn_activateModifyCanvasProp, \
pyfn_activateModifyCanvasProp, cfn_cleanupModifyCanvasProp, \
pyfn_cleanupModifyCanvasProp)
library.keep_elem_refs(ptr_flobject)
_fl_modify_canvas_prop(ptr_flobject, cfn_initModifyCanvasProp,
cfn_activateModifyCanvasProp, cfn_cleanupModifyCanvasProp)
def fl_request_clipboard(ptr_flobject, clipbdtype, pyfn_SelectionCb):
"""fl_request_clipboard(ptr_flobject, clipbdtype, pyfn_SelectionCb)
-> result
Retrieves data previously stuffed into the clipboard. Contents is
available in invoked callback function.
Parameters
----------
ptr_flobject : pointer to xfdata.FL_OBJECT
clipboard flobject
clipbdtype : long
type of clipboard (not used)
pyfn_SelectionCb : python function callback, returned value
name referring to function(ptr_flobject, [long]type,
[pointer to void]datablock, [long]size) -> [int]num.
Function to be invoked when the clipboard content is obtained;
type is unused. The content data passed to the callback
function should not be modified.
Returns
-------
result : int
positive number (if the requesting flobject owns the selection,
i.e. the callback could be invoked before the function returned),
or 0 (if it does not own the selection), or -1 (if there is no
selection)
Examples
--------
>>> *todo*
Notes
-----
Status: NA-UTest + Doc + NoDemo = Maybe
"""
#FL_SELECTION_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(xfdata.FL_OBJECT),
# cty.c_long, cty.c_void_p, cty.c_long)
_fl_request_clipboard = library.cfuncproto(
library.load_so_libforms(), "fl_request_clipboard",
cty.c_int, [cty.POINTER(xfdata.FL_OBJECT), cty.c_long,
xfdata.FL_SELECTION_CB],
"""int fl_request_clipboard(FL_OBJECT * ob, long int type,
FL_SELECTION_CB got_it_callback)""")
library.check_if_flinitialized()
library.verify_flobjectptr_type(ptr_flobject)
l_clipbdtype = library.convert_to_longc(clipbdtype)
library.verify_function_type(pyfn_SelectionCb)
cfn_SelectionCb = xfdata.FL_SELECTION_CB(pyfn_SelectionCb)
library.keep_cfunc_refs(cfn_SelectionCb, pyfn_SelectionCb)
library.keep_elem_refs(ptr_flobject, clipbdtype, l_clipbdtype)
retval = _fl_request_clipboard(ptr_flobject, l_clipbdtype, \
cfn_SelectionCb)
return retval
def fl_set_timer_filter(ptr_flobject, pyfn_TimerFilter):
"""fl_set_timer_filter(ptr_flobject, pyfn_TimerFilter) -> TimerFilter
Defines a function to change the way the time is presented in
xfdata.FL_VALUE_TIMER. By default, it gives the time in a
hour:minutes:seconds.fraction format
Parameters
----------
ptr_flobject : pointer to xfdata.FL_OBJECT
timer flobject
pyfn_TimerFilter : python callback function, returned value
name referring to function(ptr_flobject, [float]totalsecs)
-> [str]time
Param totalsecs is time left for count-down timers and the
elapsed time for up-counting timers (in units of seconds).
It gives textual formatted representation of time.
Returns
-------
TimerFilter : pointer to xfdata.FL_TIMER_FILTER
old timer filter function
Examples
--------
>>> def timefiltcb(pobj, elapsedsecs):
>>> ... <something>
>>> ... return fmtnewstr
>>> oldtimerfunc = fl_set_timer_filter(ptimerobj, timefiltcb)
Notes
-----
Status: NA-UTest + Doc + NoDemo = Maybe
"""
#FL_TIMER_FILTER = cty.CFUNCTYPE(xfdata.STRING,
# cty.POINTER(xfdata.FL_OBJECT), cty.c_double)
_fl_set_timer_filter = library.cfuncproto(
library.load_so_libforms(), "fl_set_timer_filter",
xfdata.FL_TIMER_FILTER, [cty.POINTER(xfdata.FL_OBJECT),
xfdata.FL_TIMER_FILTER],
"""FL_TIMER_FILTER fl_set_timer_filter(FL_OBJECT * ob,
FL_TIMER_FILTER filter)""")
library.check_if_flinitialized()
library.verify_flobjectptr_type(ptr_flobject)
library.verify_function_type(pyfn_TimerFilter)
cfn_TimerFilter = xfdata.FL_TIMER_FILTER(pyfn_TimerFilter)
library.keep_cfunc_refs(cfn_TimerFilter, pyfn_TimerFilter)
library.keep_elem_refs(ptr_flobject)
retval = _fl_set_timer_filter(ptr_flobject, cfn_TimerFilter)
return retval
def fl_add_button_class(btnclass, pyfn_DrawButton, pyfn_CleanupButton):
"""fl_add_button_class(btnclass, pyfn_DrawButton, pyfn_CleanupButton)
Associates a button class with a drawing function.
Parameters
----------
btnclass : int
value of a new button class
pyfn_DrawButton : python function, no return
name referring to function(ptr_flobject)
function to handle drawing of button
pyfn_CleanupButton : python function, no return
name referring to function(ptr_buttonspec)
function to cleanup button. The param is an instance of
xfdata.FL_BUTTON_SPEC class
Examples
--------
>>> def drawbtn(pobj):
>>> ... <something>
>>> def cleanbtn(pbuttonspec):
>>> ... <something>
>>> fl_add_button_class(1001, drawbtn, cleanbtn)
Notes
-----
Status: NA-UTest + Doc + NoDemo = Maybe
"""
#FL_DrawButton = cty.CFUNCTYPE(None, cty.POINTER(xfdata.FL_OBJECT))
#FL_CleanupButton = cty.CFUNCTYPE(None, cty.POINTER(xfdata.FL_BUTTON_SPEC))
_fl_add_button_class = library.cfuncproto(
library.load_so_libforms(), "fl_add_button_class",
None, [cty.c_int, xfdata.FL_DrawButton, xfdata.FL_CleanupButton],
"""void fl_add_button_class(int bclass, FL_DrawButton drawit,
FL_CleanupButton cleanup)""")
library.check_if_flinitialized()
i_btnclass = library.convert_to_intc(btnclass)
library.verify_function_type(pyfn_DrawButton)
cfn_DrawButton = xfdata.FL_DrawButton(pyfn_DrawButton)
library.verify_function_type(pyfn_CleanupButton)
cfn_CleanupButton = xfdata.FL_CleanupButton(pyfn_CleanupButton)
library.keep_cfunc_refs(cfn_DrawButton, pyfn_DrawButton, \
cfn_CleanupButton, pyfn_CleanupButton)
library.keep_elem_refs(btnclass, i_btnclass)
_fl_add_button_class(i_btnclass, cfn_DrawButton, cfn_CleanupButton)
def fl_remove_canvas_handler(ptr_flobject, evtnum, pyfn_HandleCanvas):
"""fl_remove_canvas_handler(ptr_flobject, evtnum, pyfn_HandleCanvas)
Removes a particular handler for a specified X event, previously
created with fl_add_canvas_handler().
Parameters
----------
ptr_flobject : pointer to xfdata.FL_OBJECT
canvas flobject
evtnum : int
X event number. Values (from xfdata.py): Expose, KeyPress,
KeyRelease, ButtonRelease, etc.. If it is invalid, removes all
handlers and their corresponding event mask.
pyfn_HandleCanvas : python function to handle canvas, returned value
name referring to function(ptr_flobject, [long_pos]win,
[int]width, [int]height, ptr_xevent, [pointer to void]vdata)
-> [int]num
Examples
--------
>>> *todo*
Notes
-----
Status: NA-UTest + Doc + Demo = OK
"""
#FL_HANDLE_CANVAS = cty.CFUNCTYPE(cty.c_int, cty.POINTER(xfdata.FL_OBJECT),
# xfdata.Window, cty.c_int, cty.c_int,
# cty.POINTER(xfdata.XEvent), cty.c_void_p)
_fl_remove_canvas_handler = library.cfuncproto(
library.load_so_libforms(), "fl_remove_canvas_handler",
None, [cty.POINTER(xfdata.FL_OBJECT), cty.c_int,
xfdata.FL_HANDLE_CANVAS],
"""void fl_remove_canvas_handler(FL_OBJECT * ob, int ev,
FL_HANDLE_CANVAS h)""")
library.check_if_flinitialized()
library.verify_flobjectptr_type(ptr_flobject)
i_evtnum = library.convert_to_intc(evtnum)
library.verify_function_type(pyfn_HandleCanvas)
cfn_HandleCanvas = xfdata.FL_HANDLE_CANVAS(pyfn_HandleCanvas)
library.keep_cfunc_refs(cfn_HandleCanvas, pyfn_HandleCanvas)
library.keep_elem_refs(ptr_flobject, evtnum, i_evtnum)
_fl_remove_canvas_handler(ptr_flobject, i_evtnum, cfn_HandleCanvas)
def fl_set_dirlist_filter(pyfn_DirFilter):
"""fl_set_dirlist_filter(pyfn_DirFilter) -> DirFilter
Changes the default filter by which file types are returned.
By default not all types of files are returned (only directories,
normal files and link files).
Parameters
----------
pyfn_DirFilter : python function, returned value
name referring to function ([str]name, [int]type) -> (non-zero if
is to be included, 0 otherwise)
Function used to filter types
Returns
-------
DirFilter : xfdata.FL_DIRLIST_FILTER class instance
old dirlist filter function
Examples
--------
>>> def dirfiltercb(fname, ftype):
>>> ... return (ftype == xfdata.FT_DIR || ftype == xfdata.FT_FILE ||
>>> ftype == xfdata.FT_SOCK || ftype == xfdata.FT_FIFO ||
>>> ftype == xfdata.FT_LINK || ftype == xfdata.FT_BLK ||
>>> ftype == xfdata.FT_CHR || type == xfdata.FT_OTHER)
>>> olddirfiltfunc = fl_set_dirlist_filter(dirfiltercb)
Notes
-----
Status: NA-UTest + Doc + NoDemo = Maybe
"""
#FL_DIRLIST_FILTER = cty.CFUNCTYPE(cty.c_int, xfdata.STRING, cty.c_int)
_fl_set_dirlist_filter = library.cfuncproto(
library.load_so_libforms(), "fl_set_dirlist_filter",
xfdata.FL_DIRLIST_FILTER, [xfdata.FL_DIRLIST_FILTER],
"""FL_DIRLIST_FILTER fl_set_dirlist_filter( \
FL_DIRLIST_FILTER filter)""")
library.check_if_flinitialized()
library.verify_function_type(pyfn_DirFilter)
cfn_DirFilter = xfdata.FL_DIRLIST_FILTER(pyfn_DirFilter)
library.keep_cfunc_refs(cfn_DirFilter, pyfn_DirFilter)
retval = _fl_set_dirlist_filter(cfn_DirFilter)
return retval
def fl_set_counter_filter(ptr_flobject, pyfn_ValFilter):
"""fl_set_counter_filter(ptr_flobject, pyfn_ValFilter)
Overrides the format and value shown by the counter. By default the
value is shown in floating point format.
Parameters
----------
ptr_flobject : pointer to xfdata.FL_OBJECT
counter flobject
pyfn_ValFilter : python callback function, returned value
name referring to function(ptr_flobject, [float]value, [int]precis)
-> str
Examples
--------
>>> def cvalfiltcb(pobj, fvalue, prec):
>>> ... <something>
>>> ... return string
>>> fl_set_counter_filter(ctrobj, cvalfiltcb)
Notes
-----
Status: NA-UTest + Doc + NoDemo = Maybe
"""
#FL_VAL_FILTER = cty.CFUNCTYPE(xfdata.STRING, \
# cty.POINTER(xfdata.FL_OBJECT), cty.c_double, cty.c_int)
_fl_set_counter_filter = library.cfuncproto(
library.load_so_libforms(), "fl_set_counter_filter",
None, [cty.POINTER(xfdata.FL_OBJECT), xfdata.FL_VAL_FILTER],
"""void fl_set_counter_filter(FL_OBJECT * ob,
FL_VAL_FILTER filter)""")
library.check_if_flinitialized()
library.verify_flobjectptr_type(ptr_flobject)
library.verify_function_type(pyfn_ValFilter)
cfn_ValFilter = xfdata.FL_VAL_FILTER(pyfn_ValFilter)
library.keep_cfunc_refs(cfn_ValFilter, pyfn_ValFilter)
library.keep_elem_refs(ptr_flobject)
_fl_set_counter_filter(ptr_flobject, cfn_ValFilter)
def fl_set_slider_filter(ptr_flobject, pyfn_ValFilter):
"""fl_set_slider_filter(ptr_flobject, pyfn_ValFilter)
Registers a filter function to show values in a slider flobject. By
default, slider value shown in floating point format.
Parameters
----------
ptr_flobject : pointer to xfdata.FL_OBJECT
slider flobject
pyfn_ValFilter : python function, returned value
name referring to function(ptr_flobject, [float]value,
[int]precis) -> [str]text
function to show values in slider, text is what will be shown
Examples
--------
>>> *todo*
Notes
-----
Status: NA-UTest + Doc + NoDemo = Maybe
"""
# FL_VAL_FILTER = cty.CFUNCTYPE(xfdata.STRING, cty.POINTER(FL_OBJECT),
# cty.c_double, cty.c_int)
_fl_set_slider_filter = library.cfuncproto(
library.load_so_libforms(), "fl_set_slider_filter",
None, [cty.POINTER(xfdata.FL_OBJECT), xfdata.FL_VAL_FILTER],
"""void fl_set_slider_filter(FL_OBJECT * ob, FL_VAL_FILTER filter)""")
library.check_if_flinitialized()
library.verify_flobjectptr_type(ptr_flobject)
library.verify_function_type(pyfn_ValFilter)
cfn_ValFilter = xfdata.FL_VAL_FILTER(pyfn_ValFilter)
library.keep_cfunc_refs(cfn_ValFilter, pyfn_ValFilter)
library.keep_elem_refs(ptr_flobject)
_fl_set_slider_filter(ptr_flobject, cfn_ValFilter)
def fl_add_free(freetype, xpos, ypos, width, height, label, pyfn_HandlePtr):
"""fl_add_free(freetype, xpos, ypos, width, height, label, pyfn_HandlePtr)
-> ptr_flobject
Adds a free object.
Parameters
----------
freetype : int
type of free to be added. Value (from xfdata.py)
- FL_NORMAL_FREE (The flobject will receive the events FL_DRAW,
FL_ENTER, FL_LEAVE, FL_MOTION, FL_PUSH, FL_RELEASE and FL_MOUSE),
- FL_INACTIVE_FREE or FL_SLEEPING_FREE (The flobject only receives
FL_DRAW events. This should be used for flobjects without
interaction, e.g. a picture),
- FL_INPUT_FREE (Same as FL_NORMAL_FREE but the flobject also
receives FL_FOCUS, FL_UNFOCUS and FL_KEYBOARD events. The
ptr_flobject.contents.wantkey is by default set to FL_KEY_NORMAL,
i.e., the free flobject will receive all normal keys (0-255)
except <Tab> and <Return> key. If you are interested in <Tab> or
<Return> key, you need to change ptr_flobject.contents.wantkey
to FL_KEY_TAB or FL_KEY_ALL),
- FL_CONTINUOUS_FREE (Same as FL_NORMAL_FREE but the flobject also
receives FL_STEP events. This should be used for flobjects that
change themselves continuously),
- FL_ALL_FREE (The flobject receives all types of events).
xpos : int
horizontal position (upper-left corner)
ypos : int
vertical position (upper-left corner)
width : int
width in coord units
height : int
height in coord units
label : str
text label of free
pyfn_HandlePtr : python function, returned value
name referring to function(ptr_flobject, [int]event, [int]xpos,
[int]ypos, [int]key, [pointer to void]ptr_xevent) -> [int]num
Function does the redrawing and handles the interaction with the
free flobject. First param is the flobject to which the event
applies; event indicates what has to happen to the object; xpos
and ypos indicate the position of the mouse (only meaningful with
mouse related events) relative to the form origin; key is the
KeySym of the key typed in by the user (only for xfdata.FL_KEYPRESS
events). ptr_xevent is pointer to X Event that causes the
invocation of this handler. event and ptr_xevent.contents.type can
both be used to obtain the event types. The routine should return
whether the status of the object has changed, i.e., whether
flbasic.fl_do_forms() or flbasic.fl_check_forms() should return
this flobject.
Returns
-------
ptr_flobject : pointer to xfdata.FL_OBJECT
free flobject added
Examples
--------
>>> *todo*
Notes
-----
Status: NA-UTest + Doc + Demo = OK
"""
#FL_HANDLEPTR = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), \
# cty.c_int, FL_Coord, FL_Coord, cty.c_int, cty.c_void_p)
_fl_add_free = library.cfuncproto(
library.load_so_libforms(), "fl_add_free",
cty.POINTER(xfdata.FL_OBJECT), [cty.c_int, xfdata.FL_Coord,
xfdata.FL_Coord, xfdata.FL_Coord, xfdata.FL_Coord, xfdata.STRING,
xfdata.FL_HANDLEPTR],
"""FL_OBJECT * fl_add_free(int type, FL_Coord x, FL_Coord y,
FL_Coord w, FL_Coord h, const char * label, FL_HANDLEPTR handle)""")
library.check_if_flinitialized()
library.checkfatal_allowed_value_in_list(freetype, xfdata.FREETYPE_list)
i_freetype = library.convert_to_intc(freetype)
i_xpos = library.convert_to_FL_Coord(xpos)
i_ypos = library.convert_to_FL_Coord(ypos)
i_width = library.convert_to_FL_Coord(width)
i_height = library.convert_to_FL_Coord(height)
s_label = library.convert_to_bytestrc(label)
library.verify_function_type(pyfn_HandlePtr)
cfn_HandlePtr = xfdata.FL_HANDLEPTR(pyfn_HandlePtr)
library.keep_cfunc_refs(cfn_HandlePtr, pyfn_HandlePtr)
library.keep_elem_refs(freetype, xpos, ypos, width, height, label, \
i_freetype, i_xpos, i_ypos, i_width,i_height, s_label)
retval = _fl_add_free(i_freetype, i_xpos, i_ypos, i_width, i_height, \
s_label, cfn_HandlePtr)
return retval
def fl_set_input_filter(ptr_flobject, pyfn_InputValidator):
"""fl_set_input_filter(ptr_flobject, pyfn_InputValidator) -> InputValidator
Defines up a validator function, that is is called whenever a new
(regular) character is entered.
Parameters
----------
ptr_flobject : pointer to xfdata.FL_OBJECT
input flobject
pyfn_InputValidator : python function, returned value
name referring to function(ptr_flobject, [str]oldtxt, [str]curtxt,
[int]newchar) -> [int]oldfilt
function to set validator is called whenever a new (regular)
character is entered. oldtxt is the str text in the input field
before the newly typed character newchar (in ordinal form) was
added to form the new str text curtxt. If the new character is not
an acceptable character for the input field, the function should
return xfdata.FL_INVALID otherwise xfdata.FL_VALID. If
xfdata.FL_INVALID is returned, the new character is discarded and
the input field remains unmodified. The function returns the old
filter. While the built-in filters also sound the keyboard bell,
this does not happen if a custom filter only returns
xfdata.FL_INVALID; to also sound the keyboard bell you can
logically OR it with (from xfdata.py) FL_INVALID|FL_RINGBELL. This
still leaves the possibility that the input is valid for every
character entered, but the string is invalid for the field because
it is incomplete. E.g. 12.0e is valid for a float input field for
every character typed, but the final string is not a valid floating
point number. To guard against this, the filter function is also
called just prior to returning the flobject with the argument
newchar (for the newly entered character) set to zero. If the
validator returns xfdata.FL_INVALID the flobject is not returned
to the application program, but input focus can change to the next
input field. If the return value is (from xfdata.py)
FL_INVALID|FL_RINGBELL, the keyboard bell is sounded and the
flobject is not returned to the application program and the input
focus remains in the flobject.
Returns
-------
InputValidator : xfdata.FL_INPUTVALIDATOR
old filter function for input
Examples
--------
>>> *todo*
Notes
-----
Status: NA-UTest + Doc + NoDemo = Maybe
"""
# FL_INPUTVALIDATOR = cty.CFUNCTYPE(cty.c_int, cty.POINTER( \
# xfdata.FL_OBJECT), xfdata.STRING, xfdata.STRING, cty.c_int)
_fl_set_input_filter = library.cfuncproto(
library.load_so_libforms(),
"fl_set_input_filter",
xfdata.FL_INPUTVALIDATOR,
[cty.POINTER(xfdata.FL_OBJECT), xfdata.FL_INPUTVALIDATOR],
"""FL_INPUTVALIDATOR fl_set_input_filter(FL_OBJECT * ob,
FL_INPUTVALIDATOR validate)""",
)
library.check_if_flinitialized()
library.verify_flobjectptr_type(ptr_flobject)
library.verify_function_type(pyfn_InputValidator)
cfn_InputValidator = xfdata.FL_INPUTVALIDATOR(pyfn_InputValidator)
library.keep_cfunc_refs(cfn_InputValidator, pyfn_InputValidator)
library.keep_elem_refs(ptr_flobject)
retval = _fl_set_input_filter(ptr_flobject, cfn_InputValidator)
return retval
