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_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_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_replace_nmenu_item(ptr_flobject, ptr_flpopupentry, entryitemstxt, x=None, u=None, f=None, E=None, L=None, m=None, Rr=None, s=None): """fl_replace_nmenu_item(ptr_flobject, ptr_flpopupentry, entryitemstxt, x=None, u=None, f=None, E=None, L=None, m=None, Rr=None, s=None) -> ptr_flpopupentry Replaces an existing item of a nmenu flobject with another. If additional separated arguments are required by in-text special sequences, user must respect the same sequences' order. Parameters ---------- ptr_flobject : pointer to xfdata.FL_OBJECT nmenu flobject ptr_flpopupentry : pointer to xfdata.FL_POPUP_ENTRY old popup entry to be replaced entryitemstxt : str text of the entry to be replaced and in-text special sequences with or without not separated additional arguments (if required). Text may contain "|" for more than one entry newline character which allows to create entries that span more than a single line. Special sequences who are allowed are: %x, %u, %f, %E, %L, %m or %T or %t, %R or %r or %l, %d, %h, %S, %s, %%. Special sequences of same type cannot be repeated in xforms-python. x : long numeric data to be passed to callbacks for entry (separated additional argument corresponding to %x in-text special sequence) u : pointer to any type user data to be passed to callbacks for entry; invoked callback has to take care of type check and re-cast ptr_void to chosen type using appropriate xfstruct.fls_convert_ptrvoid_to_* function (separated additional argument corresponding to %u in-text special sequence) f : python callback function, returned value name referring to function(ptr_flpopupreturn) -> int function to be invoked on set (separated additional argument corresponding to %f in-text special sequence) E : python callback function, returned unused value name referring to function(ptr_flpopupreturn) -> int function to be invoked on enter (separated additional argument corresponding to %E in-text special sequence) L : python callback function, returned unused value name referring to function(ptr_flpopupreturn) -> int function to be invoked on leave (separated additional argument corresponding to %L in-text special sequence) m : pointer to xfdata.FL_POPUP popup class to be used as sub-popup (separated additional argument corresponding to %m in-text special sequence) Rr : int group number of a radio entry type (separated additional argument corresponding to %R or %r in-text special sequence) s : str shortcut text for the entry (separated additional argument corresponding to %s in-text special sequence) Returns ------- ptr_flpopupentry : pointer to xfdata.FL_POPUP_ENTRY popup entry Examples -------- >>> *todo* Notes ----- Status: NA-UTest + Doc + Demo = OK See: Special sequences in entry text documentation in xfdata.py. """ # managing additional separate parameters l_x = ptr_u = cfn_f = cfn_E = cfn_L = i_Rr = s_s = None cparam_argstypelist = [] specseqargslist = [] if x: # long x additional arg l_x = library.convert_to_longc(x) cparam_argstypelist.append(cty.c_long) specseqargslist.append(l_x) if u: # pointer to void u additional arg ptr_u = library.convert_userdata_to_ptrvoid(u) cparam_argstypelist.append(cty.c_void_p) specseqargslist.append(ptr_u) if f: # xfdata.FL_POPUP_CB f additional arg library.verify_function_type(f) cfn_f = xfdata.FL_POPUP_CB(f) cparam_argstypelist.append(xfdata.FL_POPUP_CB) specseqargslist.append(cfn_f) if E: # xfdata.FL_POPUP_CB E additional arg library.verify_function_type(E) cfn_E = xfdata.FL_POPUP_CB(E) cparam_argstypelist.append(xfdata.FL_POPUP_CB) specseqargslist.append(cfn_E) if L: # xfdata.FL_POPUP_CB L additional arg library.verify_function_type(L) cfn_L = xfdata.FL_POPUP_CB(L) cparam_argstypelist.append(xfdata.FL_POPUP_CB) specseqargslist.append(cfn_L) if m: # pointer to xfdata.FL_POPUP m additional arg library.verify_flpopupptr_type(m) # passed as is cparam_argstypelist.append(cty.POINTER(xfdata.FL_POPUP)) specseqargslist.append(m) if Rr: # int R or r additional arg i_Rr = library.convert_to_intc(Rr) cparam_argstypelist.append(cty.c_int) specseqargslist.append(i_Rr) if s: # str s additional arg s_s = library.convert_to_bytestrc(s) cparam_argstypelist.append(cty.c_char_p) specseqargslist.append(s_s) if not cparam_argstypelist: # no additional separate params cparam_argstypelist = [cty.c_char_p, cty.c_char_p] specseqargslist = [b"", b""] elif len(cparam_argstypelist) < 2: # just 1 param, add another cparam_argstypelist.append(cty.c_char_p) specseqargslist.append(b"") _fl_replace_nmenu_item = library.cfuncproto( library.load_so_libforms(), "fl_replace_nmenu_item", cty.POINTER(xfdata.FL_POPUP_ENTRY), [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(xfdata.FL_POPUP_ENTRY), xfdata.STRING, \ cparam_argstypelist], """FL_POPUP_ENTRY * fl_replace_nmenu_item(FL_OBJECT * p1, FL_POPUP_ENTRY * p2, const char * p3, ...)""") library.check_if_flinitialized() library.verify_flobjectptr_type(ptr_flobject) library.verify_flpopupentryptr_type(ptr_flpopupentry) s_entryitemstxt = library.convert_to_bytestrc(entryitemstxt) library.keep_elem_refs(ptr_flobject, ptr_flpopupentry, entryitemstxt, \ s_entryitemstxt, specseqargslist, cparam_argstypelist, x, u, f, \ E, L, m, Rr, s, l_x, ptr_u, cfn_f, cfn_E, cfn_L, i_Rr, s_s) retval = _fl_replace_nmenu_item(ptr_flobject, ptr_flpopupentry, \ s_entryitemstxt, *specseqargslist) return retval
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_insert_select_items(ptr_flobject, ptr_flpopupentry, entryitemstxt, \ x=None, u=None, f=None, E=None, L=None, s=None): """fl_insert_select_items(ptr_flobject, ptr_flpopupentry, entryitemstxt, x=None, u=None, f=None, E=None, L=None, s=None) -> ptr_flpopupentry Inserts a new item somewhere in the middle of a list of already existing items (it can be used several times). If additional separated arguments are required by in-text special sequences, user must respect the same sequences' order. Parameters ---------- ptr_flobject : pointer to xfdata.FL_OBJECT select flobject ptr_flpopupentry : pointer to xfdata.FL_POPUP_ENTRY popup entry. If it is None new items are inserted at the real start entryitemstxt : str text of the entry to be inserted and in-text special sequences with or without not separated additional arguments (if required). Text may contain "|" for more than one entry and newline character which allows to create entries that span more than a single line. Only some special sequences are allowed: %x, %u, %f, %E, %L, %d, %h, %S, %s, %% (other combinations do not make sense here). Special sequences of same type cannot be repeated in xforms-python. x : long numeric data to be passed to callbacks for entry (separated additional argument corresponding to %x in-text special sequence) u : pointer to any type user data to be passed to callbacks for entry; invoked callback has to take care of type check and re-cast ptr_void to chosen type using appropriate xfstruct.fls_convert_ptrvoid_to_* function (separated additional argument corresponding to %u in-text special sequence) f : python callback function, returned value name referring to function(ptr_flpopupreturn) -> int function to be invoked on set (separated additional argument corresponding to %f in-text special sequence) E : python callback function, returned unused value name referring to function(ptr_flpopupreturn) -> int function to be invoked on enter (separated additional argument corresponding to %E in-text special sequence) L : python callback function, returned unused value name referring to function(ptr_flpopupreturn) -> int function to be invoked on leave (separated additional argument corresponding to %L in-text special sequence) s : str shortcut text for the entry (separated additional argument corresponding to %s in-text special sequence) Returns ------- ptr_flpopupentry : pointer to xfdata.FL_POPUP_ENTRY popup entry, or None (on failure) Examples -------- >>> *todo* Notes ----- Status: NA-UTest + Doc + Demo = OK See: Special sequences in entry text documentation in xfdata.py. """ # managing additional separate parameters l_x = ptr_u = cfn_f = cfn_E = cfn_L = s_s = None cparam_argstypelist = [] specseqargslist = [] if x: # long x additional arg l_x = library.convert_to_longc(x) cparam_argstypelist.append(cty.c_long) specseqargslist.append(l_x) if u: # pointer to void u additional arg ptr_u = library.convert_userdata_to_ptrvoid(u) cparam_argstypelist.append(cty.c_void_p) specseqargslist.append(ptr_u) if f: # xfdata.FL_POPUP_CB f additional arg library.verify_function_type(f) cfn_f = xfdata.FL_POPUP_CB(f) cparam_argstypelist.append(xfdata.FL_POPUP_CB) specseqargslist.append(cfn_f) if E: # xfdata.FL_POPUP_CB E additional arg library.verify_function_type(E) cfn_E = xfdata.FL_POPUP_CB(E) cparam_argstypelist.append(xfdata.FL_POPUP_CB) specseqargslist.append(cfn_E) if L: # xfdata.FL_POPUP_CB L additional arg library.verify_function_type(L) cfn_L = xfdata.FL_POPUP_CB(L) cparam_argstypelist.append(xfdata.FL_POPUP_CB) specseqargslist.append(cfn_L) if s: # str s additional arg s_s = library.convert_to_bytestrc(s) cparam_argstypelist.append(cty.c_char_p) specseqargslist.append(s_s) if not cparam_argstypelist: # no additional separate params cparam_argstypelist = [cty.c_char_p, cty.c_char_p] specseqargslist = [b"", b""] elif len(cparam_argstypelist) < 2: # just 1 param, add another cparam_argstypelist.append(cty.c_char_p) specseqargslist.append(b"") _fl_insert_select_items = library.cfuncproto( library.load_so_libforms(), "fl_insert_select_items", cty.POINTER(xfdata.FL_POPUP_ENTRY), [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(xfdata.FL_POPUP_ENTRY), xfdata.STRING, cparam_argstypelist], """FL_POPUP_ENTRY * fl_insert_select_items(FL_OBJECT * p1, FL_POPUP_ENTRY * p2, const char * p3, ...)""") library.check_if_flinitialized() library.verify_flobjectptr_type(ptr_flobject) library.verify_flpopupentryptr_type(ptr_flpopupentry) s_entryitemstxt = library.convert_to_bytestrc(entryitemstxt) library.keep_elem_refs(ptr_flobject, ptr_flpopupentry, entryitemstxt, \ s_entryitemstxt, specseqargslist, cparam_argstypelist, x, u, \ f, E, L, s, l_x, ptr_u, cfn_f, cfn_E, cfn_L, s_s) retval = _fl_insert_select_items(ptr_flobject, ptr_flpopupentry, \ s_entryitemstxt, *specseqargslist) 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