def fl_read_bitmapfile(win, fname):
    """fl_read_bitmapfile(win, fname) -> pixmapid, width, height, hotx, hoty

    Makes a bitmap from a bitmap (.xpm format) file.

    Parameters
    ----------
        win : long_pos
            window id
        fname : str
            name of bitmap (.xbm format) file

    Returns
    -------
        pixmapid : long_pos
            pixmap resource id
        width : int_pos
            width
        height : int_pos
            height
        hotx : int
            hotspot horizontal position
        hoty : int
            hotspot vertical position

    Examples
    --------
        >>> pmap, w, h, hotx, hoty = fl_read_bitmapfile(win0, "xbmfile.xbm")

    API_diversion
    ----------
        API changed from XForms, upstream is
        fl_read_bitmapfile(win, filename, width, height, hotx, hoty)

    Notes
    -----
        Status: UnitTest + Doc + NoDemo = OK

    """
    _fl_read_bitmapfile = library.cfuncproto(
        library.load_so_libforms(), "fl_read_bitmapfile",
        xfdata.Pixmap, [xfdata.Window, xfdata.STRING, cty.POINTER(cty.c_uint),
        cty.POINTER(cty.c_uint), cty.POINTER(cty.c_int),
        cty.POINTER(cty.c_int)],
        """Pixmap fl_read_bitmapfile(Window win, const char * file,
           unsigned int * w, unsigned int * h, int * hotx, int * hoty)""")
    library.check_if_flinitialized()
    ul_win = library.convert_to_Window(win)
    s_fname = library.convert_to_bytestrc(fname)
    i_width, ptr_width = library.make_uintc_and_pointer()
    i_height, ptr_height = library.make_uintc_and_pointer()
    i_hotx, ptr_hotx = library.make_intc_and_pointer()
    i_hoty, ptr_hoty = library.make_intc_and_pointer()
    library.keep_elem_refs(win, fname, i_width, i_height, i_hotx, i_hoty, \
            ul_win, s_fname, ptr_width, ptr_height, ptr_hotx, ptr_hoty)
    retval = _fl_read_bitmapfile(ul_win, s_fname, ptr_width, ptr_height, \
            ptr_hotx, ptr_hoty)
    return retval, i_width.value, i_height.value, i_hotx.value, i_hoty.value
def fl_get_folder_area(ptr_flobject):
    """fl_get_folder_area(ptr_flobject) -> xpos, ypos, width, height

    Finds out the actual folder size. The folder area may not be constant
    depending on the current tabs. E.g. adding a multi-line tab will
    reduce the area for the folders).

    Parameters
    ----------
        ptr_flobject : pointer to xfdata.FL_OBJECT
            tabfolder flobject

    Returns
    -------
        xpos : int
            horizontal position of folder, relative to the (top-level)
            form the tabbed folder belongs to
        ypos : int
            vertical position of folder, relative to the (top-level)
            form the tabbed folder belongs to
        width : int
            width of folder
        height : int
            height of folder

    Examples
    --------
        >>> xpos, ypos, width, height = fl_get_folder_area(tbfobj)

    API_diversion
    -------------
        API changed from XForms, upstream is
        fl_get_folder_area(ptr_flobject, xpos, ypos, width, height)

    Notes
    -----
        Status: NA-UTest + Doc + NoDemo = Maybe

    """
    _fl_get_folder_area = library.cfuncproto(
        library.load_so_libforms(), "fl_get_folder_area",
        None, [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(xfdata.FL_Coord),
        cty.POINTER(xfdata.FL_Coord), cty.POINTER(xfdata.FL_Coord),
        cty.POINTER(xfdata.FL_Coord)],
        """void fl_get_folder_area(FL_OBJECT * ob, FL_Coord * x,
           FL_Coord * y, FL_Coord * w, FL_Coord * h)""")
    library.check_if_flinitialized()
    library.verify_flobjectptr_type(ptr_flobject)
    i_xpos, ptr_xpos = library.make_intc_and_pointer()
    i_ypos, ptr_ypos = library.make_intc_and_pointer()
    i_width, ptr_width = library.make_intc_and_pointer()
    i_height, ptr_height = library.make_intc_and_pointer()
    library.keep_elem_refs(ptr_flobject, i_xpos, i_ypos, i_width, \
            i_height, ptr_xpos, ptr_ypos, ptr_width, ptr_height)
    _fl_get_folder_area(ptr_flobject, ptr_xpos, ptr_ypos, ptr_width, \
            ptr_height)
    return i_xpos.value, i_ypos.value, i_width.value, i_height.value
def fl_get_formbrowser_area(ptr_flobject):
    """fl_get_formbrowser_area(ptr_flobject)
    -> result, xpos, ypos, width, height

    Finds out the actual size of the form's area. The area occupied by
    the formbrowser contains the space for the scrollbars.

    Parameters
    ----------
        ptr_flobject : pointer to xfdata.FL_OBJECT
            formbrowser flobject

    Returns
    -------
        result : int
            1, or 0 (on failure)
        xpos : int
            horizontal position
        ypos : int
            vertical position
        width : int
            width of form's area
        height : int
            height of form's area

    Examples
    --------
        >>> exval, x, y, w, h = fl_get_formbrowser_area(pfrmbrobj)

    API_diversion
    ----------
        API changed from XForms, upstream is
        fl_get_formbrowser_area(ptr_flobject, xpos, ypos, width, height)

    Notes
    -----
        Status: NA-UTest + Doc + NoDemo = Maybe

    """
    _fl_get_formbrowser_area = library.cfuncproto(
        library.load_so_libforms(), "fl_get_formbrowser_area",
        cty.c_int, [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(cty.c_int),
        cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), \
        cty.POINTER(cty.c_int)],
        """int fl_get_formbrowser_area(FL_OBJECT * ob, int * x, int * y,
           int * w, int * h)""")
    library.check_if_flinitialized()
    library.verify_flobjectptr_type(ptr_flobject)
    i_xpos, ptr_xpos = library.make_intc_and_pointer()
    i_ypos, ptr_ypos = library.make_intc_and_pointer()
    i_width, ptr_width = library.make_intc_and_pointer()
    i_height, ptr_height = library.make_intc_and_pointer()
    library.keep_elem_refs(ptr_flobject, i_xpos, i_ypos, i_width, i_height, \
            ptr_xpos, ptr_ypos, ptr_width, ptr_height)
    retval = _fl_get_formbrowser_area(ptr_flobject, ptr_xpos, ptr_ypos, \
            ptr_width, ptr_height)
    return retval, i_xpos.value, i_ypos.value, i_width.value, i_height.value
def fl_get_input_selected_range(ptr_flobject):
    """fl_get_input_selected_range(ptr_flobject) -> selstr, beginchar, endchar

    Finds out the currently selected range, either selected by the
    application or by the user.

    Parameters
    ----------
        ptr_flobject : pointer to xfdata.FL_OBJECT
            input flobject

    Returns
    -------
        selstr : str
            selected string
        beginchar : int
            starting value of selection (in characters)
        endchar : int
            ending value of selection (in characters)

    Examples
    --------
        >>> selstr, vstart, vend = fl_get_input_selected_range(pinpobj)

    API_diversion
    ----------
        API changed from XForms, upstream is
        fl_get_input_selected_range(ptr_flobject, begin, end)

    Notes
    -----
        Status: NA-UTest + Doc + NoDemo = Maybe

    """
    _fl_get_input_selected_range = library.cfuncproto(
        library.load_so_libforms(),
        "fl_get_input_selected_range",
        xfdata.STRING,
        [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],
        """const char * fl_get_input_selected_range(FL_OBJECT * ob,
           int * begin, int * end)""",
    )
    library.check_if_flinitialized()
    library.verify_flobjectptr_type(ptr_flobject)
    i_beginchar, ptr_beginchar = library.make_intc_and_pointer()
    i_endchar, ptr_endchar = library.make_intc_and_pointer()
    library.keep_elem_refs(ptr_flobject, i_beginchar, i_endchar, ptr_beginchar, ptr_endchar)
    retval = _fl_get_input_selected_range(ptr_flobject, ptr_beginchar, ptr_endchar)
    if isinstance(retval, bytes):
        nretval = retval.decode("utf-8")
    else:  # str
        nretval = retval
    return nretval, i_beginchar.value, i_endchar.value
def fl_get_input_format(ptr_flobject):
    """fl_get_input_format(ptr_flobject) -> fmt, sep

    Provides means for the validator to retrieve some information about user
    preference or other state dependent informations.

    Parameters
    ----------
        ptr_flobject : pointer to xfdata.FL_OBJECT
            input flobject

    Returns
    -------
        fmt : int
            format (from xfdata.py, e.g. FL_INPUT_DDMM ..)
        sep : int
            separator in ordinal form. You can then use chr() to display
            character in ascii form

    Examples
    --------
        >>> fmt, sep =  fl_get_input_format(pinpobj)

    API_diversion
    -------------
        API changed from XForms, upstream is
        fl_get_input_format(ptr_flobject, fmt, sep)

    Notes
    -----
        Status: NA-UTest + Doc + NoDemo = Maybe

    """
    _fl_get_input_format = library.cfuncproto(
        library.load_so_libforms(),
        "fl_get_input_format",
        None,
        [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],
        """void fl_get_input_format(FL_OBJECT * ob, int * fmt, int * sep)""",
    )
    library.check_if_flinitialized()
    library.verify_flobjectptr_type(ptr_flobject)
    i_fmt, ptr_fmt = library.make_intc_and_pointer()
    i_sep, ptr_sep = library.make_intc_and_pointer()
    library.keep_elem_refs(ptr_flobject, i_fmt, i_sep, ptr_fmt, ptr_sep)
    _fl_get_input_format(ptr_flobject, ptr_fmt, ptr_sep)
    if isinstance(i_sep.value, bytes):
        ni_sep_val = i_sep.value.decode("utf-8")
    else:  # str
        ni_sep_val = i_sep.value
    return i_fmt.value, ni_sep.value
def fl_get_input_cursorpos(ptr_flobject):
    """fl_get_input_cursorpos(ptr_flobject) -> result, xpos, ypos

    Finds out the cursor position measured in number of characters
    (including newline characters) in front of the cursor.

    Parameters
    ----------
        ptr_flobject : pointer to xfdata.FL_OBJECT
            input flobject

    Returns
    -------
        result : int
            num. or -1 (if the input field does not have input focus, thus
            does not have a cursor)
        xpos : int
            horizontal position in characters
        ypos : int
            vertical position in characters

    Examples
    --------
        >>> rslt, x, y = fl_get_input_cursorpos(pinpobj)

    API_diversion
    -------------
        API changed from XForms, upstream is
        fl_get_input_cursorpos(ptr_flobject, xpos, ypos)

    Notes
    -----
        Status: NA-UTest + Doc + Demo = OK

    """
    _fl_get_input_cursorpos = library.cfuncproto(
        library.load_so_libforms(),
        "fl_get_input_cursorpos",
        cty.c_int,
        [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],
        """int fl_get_input_cursorpos(FL_OBJECT * ob, int * x, int * y)""",
    )
    library.check_if_flinitialized()
    library.verify_flobjectptr_type(ptr_flobject)
    i_xpos, ptr_xpos = library.make_intc_and_pointer()
    i_ypos, ptr_ypos = library.make_intc_and_pointer()
    library.keep_elem_refs(ptr_flobject, i_xpos, i_ypos, ptr_xpos, ptr_ypos)
    retval = _fl_get_input_cursorpos(ptr_flobject, ptr_xpos, ptr_ypos)
    return retval, i_xpos.value, i_ypos.value
def fl_get_clock(ptr_flobject):
    """fl_get_clock(ptr_flobject) -> hrs, mins, secs

    Finds out time values from a clock flobject, with hours in 0-23, minutes
    in 0-59 and seconds in 0-59.

    Parameters
    ----------
        ptr_flobject : pointer to xfdata.FL_OBJECT
            clock flobject

    Returns
    -------
        hrs : int
            hours
        mins : int
            minutes
        secs : int
            seconds

    Examples
    --------
        >>> hou, mnu, sec = fl_get_clock(pclkobj)

    API_diversion
    ----------
        API changed from XForms, upstream is
        fl_get_clock(ptr_flobject, hr, mn, sec)

    Notes
    -----
        Status: NA-UTest + Doc + NoDemo = Maybe

    """
    _fl_get_clock = library.cfuncproto(
        library.load_so_libforms(), "fl_get_clock",
        None, [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(cty.c_int),
        cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],
        """void fl_get_clock(FL_OBJECT * ob, int * h, int * m, int * s)""")
    library.check_if_flinitialized()
    library.verify_flobjectptr_type(ptr_flobject)
    i_hrs, ptr_hrs = library.make_intc_and_pointer()
    i_mins, ptr_mins = library.make_intc_and_pointer()
    i_secs, ptr_secs = library.make_intc_and_pointer()
    library.keep_elem_refs(ptr_flobject, i_hrs, i_mins, i_secs, ptr_hrs, \
            ptr_mins, ptr_secs)
    _fl_get_clock(ptr_flobject, ptr_hrs, ptr_mins, ptr_secs)
    return i_hrs.value, i_mins.value, i_secs.value
def fl_get_input_scrollbarsize(ptr_flobject):
    """fl_get_input_scrollbarsize(ptr_flobject) -> height, width

    Finds out the current settings for the horizontal scrollbar height and
    the vertical scrollbar width.

    Parameters
    ----------
        ptr_flobject : pointer to xfdata.FL_OBJECT
            input flobject

    Returns
    -------
        height : int
            horizontal height
        width : int
            vertical width

    API_diversion
    ----------
        API changed from XForms, upstream is
        fl_get_input_scrollbarsize(ptr_flobject, hh, vw)

    Examples
    --------
        >>> *todo*

    Notes
    -----
        Status: NA-UTest + Doc + NoDemo = Maybe

    """
    _fl_get_input_scrollbarsize = library.cfuncproto(
        library.load_so_libforms(),
        "fl_get_input_scrollbarsize",
        None,
        [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],
        """void fl_get_input_scrollbarsize(FL_OBJECT * ob, int * hh,
           int * vw)""",
    )
    library.check_if_flinitialized()
    library.verify_flobjectptr_type(ptr_flobject)
    i_height, ptr_height = library.make_intc_and_pointer()
    i_width, ptr_width = library.make_intc_and_pointer()
    library.keep_elem_refs(ptr_flobject, i_height, i_width)
    _fl_get_input_scrollbarsize(ptr_flobject, ptr_height, ptr_width)
    return i_height.value, i_width.value
def fl_get_select_text_font(ptr_flobject):
    """fl_get_select_text_font(ptr_flobject) -> result, style, size

    Finds out the font style and size used for the text of a select flobject.

    Parameters
    ----------
      ptr_flobject : pointer to xfdata.FL_OBJECT
        select flobject

    Returns
    -------
        result : int
            0, or -1 (on failure)
        style : int
            font style
        size : int
            font size

    Examples
    --------
        >>> rslt, style, size = fl_get_select_text_font(pselobj)

    API_diversion
    -------------
        API changed from XForms, upstream is
        fl_get_select_text_font(ptr_flobject, p2, p3)

    Notes
    -----
        Status: NA-UTest + Doc + NoDemo = Maybe

    """
    _fl_get_select_text_font = library.cfuncproto(
        library.load_so_libforms(), "fl_get_select_text_font",
        cty.c_int, [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(cty.c_int),
        cty.POINTER(cty.c_int)],
        """int fl_get_select_text_font(FL_OBJECT * p1, int * p2, int * p3)""")
    library.check_if_flinitialized()
    library.verify_flobjectptr_type(ptr_flobject)
    i_style, ptr_style = library.make_intc_and_pointer()
    i_size, ptr_size = library.make_intc_and_pointer()
    library.keep_elem_refs(ptr_flobject, i_style, ptr_style, i_size, ptr_size)
    retval = _fl_get_select_text_font(ptr_flobject, ptr_style, ptr_size)
    return retval, i_style.value, i_size.value
def fl_get_dirlist(dirname, pattern, rescan):
    """fl_get_dirlist(dirname, pattern, rescan) -> ptr_dirlist, numfiles

    Finds out a listing of specified directory.

    Parameters
    ----------
        dirname : str
            name of directory
        pattern : str
            regular expression that is used to filter the directory entries
        rescan : int
            flag to request a re-read or not. Values 0 (no re-read) or
            non-zero (to do a re-read)

    Returns
    -------
        ptr_dirlist : pointer to xfdata.FL_DIRLIST
            array of DirList class instances
        numfiles : int
            number of files (total number of entries in directory dirname
            that match the pattern specified by pattern)

    Examples
    --------
        >>> pdirlist, nfiles = fl_get_dirlist("/home/userdir", "*.*", 1)
        >>> print(pdirlist[1].name)

    API_diversion
    ----------
        API changed from XForms, upstream is
        fl_get_dirlist(directory, pattern, n, rescan)

    Notes
    -----
        Status: NA-UTest + Doc + Demo = OK

    """
    _fl_get_dirlist = library.cfuncproto(
        library.load_so_libforms(), "fl_get_dirlist",
        cty.POINTER(xfdata.FL_Dirlist), [xfdata.STRING, xfdata.STRING,
        cty.POINTER(cty.c_int), cty.c_int],
        """const FL_Dirlist * fl_get_dirlist(const char * dir,
           const char * pattern, int * n, int rescan)""")
    library.check_if_flinitialized()
    s_dirname = library.convert_to_bytestrc(dirname)
    s_pattern = library.convert_to_bytestrc(pattern)
    i_numfiles, ptr_numfiles = library.make_intc_and_pointer()
    i_rescan = library.convert_to_intc(rescan)
    library.keep_elem_refs(dirname, pattern, i_numfiles, rescan, s_dirname, \
            s_pattern, ptr_numfiles, i_rescan)
    retval = _fl_get_dirlist(s_dirname, s_pattern, ptr_numfiles, i_rescan)
    return retval, i_numfiles.value
def fl_get_glcanvas_attributes(ptr_flobject):
    """fl_get_glcanvas_attributes(ptr_flobject) -> glconfig

    Finds out the attributes of a glcanvas flobject.

    Parameters
    ----------
        ptr_flobject : pointer to xfdata.FL_OBJECT
            glcanvas flobject

    Returns
    -------
        glconfig : int
            glcanvas configuration settings. Attributes are, as defined in
            OpenGL glXChooseVisual() function, GLX_USE_GL, GLX_BUFFER_SIZE,
            GLX_LEVEL, GLX_RGBA, GLX_DOUBLEBUFFER, GLX_STEREO, GLX_AUX_BUFFERS,
            GLX_RED_SIZE, GLX_GREEN_SIZE, GLX_BLUE_SIZE, GLX_ALPHA_SIZE,
            GLX_DEPTH_SIZE, GLX_STENCIL_SIZE, GLX_ACCUM_RED_SIZE,
            GLX_ACCUM_GREEN_SIZE, GLX_ACCUM_BLUE_SIZE, GLX_ACCUM_ALPHA_SIZE.
            See xfdata.py for values.

    Examples
    --------
        >>> attrb = fl_get_glcanvas_attributes(pglcnvobj)

    API_diversion
    ----------
        API changed from XForms, upstream is
        fl_get_glcanvas_attributes(ptr_flobject, attributes)

    Notes
    -----
        Status: NA-UTest + Doc + NoDemo = Maybe

    """
    _fl_get_glcanvas_attributes = library.cfuncproto(
        library.load_so_libformsgl(), "fl_get_glcanvas_attributes",
        None, [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(cty.c_int)],
        """void fl_get_glcanvas_attributes(FL_OBJECT * ob,
           int * attributes)""")
    library.check_if_flinitialized()
    library.verify_flobjectptr_type(ptr_flobject)
    glconfig, ptr_glconfig = library.make_intc_and_pointer()
    library.keep_elem_refs(ptr_flobject, glconfig, ptr_glconfig)
    _fl_get_glcanvas_attributes(ptr_flobject, ptr_glconfig)
    return glconfig.value
def fl_get_glcanvas_defaults():
    """fl_get_glcanvas_defaults() -> glconfig

    Finds out the global defaults attributes for glcanvas.

    Returns
    -------
        glconfig : array of int
            configuration settings, ending with -1. Attributes are, as defined
            in OpenGL glXChooseVisual() function, GLX_USE_GL, GLX_BUFFER_SIZE,
            GLX_LEVEL, GLX_RGBA, GLX_DOUBLEBUFFER, GLX_STEREO, GLX_AUX_BUFFERS,
            GLX_RED_SIZE, GLX_GREEN_SIZE, GLX_BLUE_SIZE, GLX_ALPHA_SIZE,
            GLX_DEPTH_SIZE, GLX_STENCIL_SIZE, GLX_ACCUM_RED_SIZE,
            GLX_ACCUM_GREEN_SIZE, GLX_ACCUM_BLUE_SIZE, GLX_ACCUM_ALPHA_SIZE.
            See xfdata.py for values.

    Examples
    --------
        >>> cnfset = fl_get_glcanvas_defaults()

    API_diversion
    ----------
        API changed from XForms, upstream is fl_get_glcanvas_defaults(config)

    Notes
    -----
        Status: NA-UTest + Doc + NoDemo = Maybe

    """
    _fl_get_glcanvas_defaults = library.cfuncproto(
        library.load_so_libformsgl(), "fl_get_glcanvas_defaults",
        None, [cty.POINTER(cty.c_int)],
        """void fl_get_glcanvas_defaults(int config[ ])""")
    library.check_if_flinitialized()     # unsure
    i_glconfig, ptr_glconfig = library.make_intc_and_pointer()
    library.keep_elem_refs(i_glconfig, ptr_glconfig)
    _fl_get_glcanvas_defaults(ptr_glconfig)
    return i_glconfig.value
def fl_create_from_pixmapdata(win, xpmdata, tran):
    """fl_create_from_pixmapdata(win, xpmdata, tran) -> pixmapid, width,
    height, smask, hotx, hoty

    Makes a pixmap from pixmap contents data.

    Parameters
    ----------
        win : long_pos
            window id
        xpmdata : str of ubytes
            pixmap contents data
        tran : long_pos
            XForms colormap index as color (currently not used)

    Returns
    -------
        pixmapid : long_pos
            created pixmap resource id
        width : int_pos
            width of pixmap in coord units
        height : int_pos
            height of pixmap in coord units
        smask : long_pos
            shape mask (of an existing pixmap) used as a clipping mask
            to achieve transparency, 0 for no transparency.
        hotx : int
            horizontal position of center of the pixmap (useful if the
            pixmap is to be used as a cursor)
        hoty : int
            vertical position of center of the pixmap (useful if the
            pixmap is to be used as a cursor)

    Examples
    --------
        >>> *todo*

     API_diversion
    -------------
        API changed from XForms, upstream is fl_create_from_pixmapdata(win,
        xpmdata, width, height, smask, hotx, hoty, tran)

    Notes
    -----
        Status: NA-UTest + Doc + NoDemo = Maybe

    """
    _fl_create_from_pixmapdata = library.cfuncproto(
        library.load_so_libforms(), "fl_create_from_pixmapdata",
        xfdata.Pixmap, [xfdata.Window, cty.POINTER(xfdata.STRING),
        cty.POINTER(cty.c_uint), cty.POINTER(cty.c_uint),
        cty.POINTER(xfdata.Pixmap), cty.POINTER(cty.c_int),
        cty.POINTER(cty.c_int), xfdata.FL_COLOR],
        """Pixmap fl_create_from_pixmapdata(Window win, char * * data,
        unsigned int * w, unsigned int * h, Pixmap * sm, int * hotx,
        int * hoty, FL_COLOR tran)""")
    library.check_if_flinitialized()
    ul_win = library.convert_to_Window(win)
    ptr_xpmdata = library.convert_to_ptr_stringc(xpmdata)
    ui_width, ptr_width = library.make_uintc_and_pointer()
    ui_height, ptr_height = library.make_uintc_and_pointer()
    ul_smask, ptr_smask = library.make_ulongc_and_pointer()
    i_hotx, ptr_hotx = library.make_intc_and_pointer()
    i_hoty, ptr_hoty = library.make_intc_and_pointer()
    #library.checknonfatal_allowed_value_in_list(tran, xfdata.COLOR_list)
    ul_tran = library.convert_to_FL_COLOR(tran)
    library.keep_elem_refs(win, xpmdata, ui_width, ptr_width, ui_height, \
            ptr_height, ul_smask, i_hotx, i_hoty, tran, ptr_xpmdata, ul_win, \
            ptr_smask, ptr_hotx, ptr_hoty, ul_tran)
    retval = _fl_create_from_pixmapdata(ul_win, ptr_xpmdata, ptr_width, \
            ptr_height, ptr_smask, ptr_hotx, ptr_hoty, ul_tran)
    return retval, ui_width.value, ui_height.value, ul_smask.value, \
            i_hotx.value, i_hoty.value
def fl_read_pixmapfile(win, fname, tran):
    """fl_read_pixmapfile(win, fname, tran) -> pixmapid, width, height,
    smask, hotx, hoty

    Makes a pixmap from a pixmap (.xpm format) file.

    Parameters
    ----------
        win : long_pos
            window id
        fname : str
            name of pixmap (.xpm format) file
        tran : long_pos
            XForms colormap index as color

    Returns
    -------
        pixmap : long_pos
            pixmap resource id
        width : int_pos
            width
        height : int_pos
            height
        smask : long_pos
            shapemask
        hotx : int
            hotspot horizontal position
        hoty : int
            hotspot vertical position

    Examples
    --------
        >>> pmap, w, h, shapmsk, hotx, hoty = fl_read_pixmapfile(win0,
                "xpmfile.xpm", xfdata.FL_WHITE)

    API_diversion
    ----------
        API changed from XForms, upstream is fl_read_pixmapfile(win,
        filename, width, height, shape_mask, hotx, hoty, tran)

    Notes
    -----
        Status: NA-UTest + Doc + Demo = OK

    """
    _fl_read_pixmapfile = library.cfuncproto(
        library.load_so_libforms(), "fl_read_pixmapfile",
        xfdata.Pixmap, [xfdata.Window, xfdata.STRING, cty.POINTER(cty.c_uint),
        cty.POINTER(cty.c_uint), cty.POINTER(xfdata.Pixmap),
        cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), xfdata.FL_COLOR],
        """Pixmap fl_read_pixmapfile(Window win, const char * file,
           unsigned int * w, unsigned int * h, Pixmap * shape_mask,
           int * hotx, int * hoty, FL_COLOR tran)""")
    library.check_if_flinitialized()
    ul_win = library.convert_to_Window(win)
    s_fname = library.convert_to_bytestrc(fname)
    #library.checknonfatal_allowed_value_in_list(tran, xfdata.COLOR_list)
    ul_tran = library.convert_to_FL_COLOR(tran)
    ui_width, ptr_width = library.make_uintc_and_pointer()
    ui_height, ptr_height = library.make_uintc_and_pointer()
    ul_shapemask, ptr_shapemask = library.make_ulongc_and_pointer()
    i_hotx, ptr_hotx = library.make_intc_and_pointer()
    i_hoty, ptr_hoty = library.make_intc_and_pointer()
    library.keep_elem_refs(win, fname, ui_width, ui_height, ul_shapemask, \
            i_hotx, i_hoty, tran, ul_win, s_fname, ul_tran, ptr_width, \
            ptr_height, ptr_shapemask, ptr_hotx, ptr_hoty)
    retval = _fl_read_pixmapfile(ul_win, s_fname, ptr_width, ptr_height, \
            ptr_shapemask, ptr_hotx, ptr_hoty, ul_tran)
    return retval, ui_width.value, ui_height.value, ul_shapemask.value, \
            i_hotx.value, i_hoty.value