PtFileSel

A tree widget for selecting files and directories

Class hierarchy:

PtWidget → PtBasic → PtContainer → PtCompound → PtGenList → PtGenTree → PtFileSel

For more information, see the diagram of the widget hierarchy.

PhAB icon:

Public header:

<photon/PtFileSel.h>

Description:

The PtFileSel widget is a tree where items can be files, directories, links to files or directories, or custom entries.

A PtFileSel widget.

This widget is useful when a program lets you open or save files or directories. It reads a directory and displays the contents. You can also use the widget to navigate a filesystem and choose your own file and directory.

The items in the PtFileSel widget are displayed with images to show what type of file they are. Directory items are expandable and can show the files, directories and links under them. To expand and collapse items, you can use the pointer or these keys:

Each item is stored in a PtFileSelItem_t structure that contains at least:

PtGenTreeItem_t gen

Used internally.

short opened

A value that indicates whether the given directories' children have already been allocated or not:

• Pt_FS_NEW_DIR—an unallocated directory
• Pt_FS_OLD_DIR—an allocated directory

short type

The type of file the item is:

• Pt_FS_DIR_OP—an open directory, one that has visible items
• Pt_FS_DIR_CL—a closed directory, one that doesn't have visible items
• Pt_FS_DLINK_OP—a link to an open directory
• Pt_FS_DLINK_CL—a link to a closed directory
• Pt_FS_FILE—a file
• Pt_FS_FLINK—a link to a file
• Pt_FS_ERROR—a file that had a read error

short root

A value that indicates if this is the root item:

• 1—this is the root directory
• 0—this isn't the root directory

char *fullpath

The full pathname of the item

int tag

Used internally

The widget has two main modes of operation:

Tree mode (default)

Items are displayed in a tree structure; opening a directory causes a new branch to be created.

Single-level mode

Items are displayed in a single level or list; the list contains all the files in the current directory. When a directory is chosen, the existing items are freed and new ones are created for the new directory. You can traverse up the filesystem by using the .. item. To use this mode, set the Pt_FS_SINGLE_LEVEL bit in Pt_ARG_FS_FLAGS.

---

---

A single-level file selector.

In this mode, you can also turn on the “key seek” flag, Pt_FS_SEEK_KEY, which lets you use the keyboard to search for a file. In this mode, the widget selects the next file or directory whose name starts with a character that you type. The search is case-sensitive and wraps to the top of the list if the character isn't found. Whenever you press a key, the Pt_CB_FS_SELECTION callback is invoked with a reason_subtype of Pt_LIST_SELECTION_BROWSE.

The widget can also display file information including name, size, date, permissions, owner and group. You can use the Pt_ARG_FS_FORMAT resource to set the amount and order of information displayed. A PtDivider widget is automatically included in the file selector, along with a label for each column you request.

If you want to override the default headers, create a PtDivider of your own, add appropriate PtLabel widgets to it, and make the divider a child of the file selector. The information you requested is displayed in the proper columns.

For example, if you create a PtDivider with the headings “Filename”, “File size”, and “Modification time” as a child of a PtFileSel widget and set the Pt_ARG_FS_FORMAT to nsd, the PtFileSel items contain the name, size, and date information in the proper columns, but your divider is displayed.

By default, when you expand an item (directory) for the first time, the directory is read and items are allocated. After this, when you collapse and expand the item, the information is stored in memory to remove the delay of reading a directory. You can refresh an item at any time by using the Pt_ARG_FS_REFRESH resource. You can also set the Pt_FS_FREE_ON_COLLAPSE flag to cause a directory to be reread every time it's expanded. Every time a new root directory is set, all the previous items are freed.

If you plan to add items to the PtFileSel widget yourself by using the PtFSAllocItem(), PtFSAddFirst(), and PtFSAddAfter() convenience functions, you should have a state callback (Pt_CB_FS_STATE, subtype = Pt_FS_STATE_START) that returns Pt_END.

---

If you're in tree mode and you get a state callback for one of your items (i.e. not from a filesystem), you should deal with the expansion/collapse and return Pt_END from the callback to prevent PtFileSel from trying to find the item in the filesystem. If you're in single-level mode and you get a state callback for one of your items, you should deal with the expansion; it's your responsibility to free all the previous items. Return Pt_END from the callback as mentioned above.

---

Examples

In the examples below, Pt_FS_ALL_FLAGS is a value containing all the flag bits. It's used for a mask.

To display only directories, in tree mode:

...
PtSetArg(&args[0], Pt_ARG_FS_FLAGS, Pt_FS_SHOW_DIRS,
         Pt_FS_ALL_FLAGS);
PtSetArg(&args[1], Pt_ARG_FS_ROOT_DIR, "/", 0);
PtSetArg(&args[2], Pt_ARG_AREA, area, 0);
PtCreateWidget(PtFileSel, Pt_DEFAULT_PARENT, 3, args);
...

To display only files in single-level mode, with keyboard seek on:

...
PtSetArg(&args[0], Pt_ARG_FS_FLAGS,
         Pt_FS_SINGLE_LEVEL|Pt_FS_SHOW_FILES| \
         Pt_FS_KEY_SEEK, Pt_FS_ALL_FLAGS);
PtSetArg(&args[1], Pt_ARG_FS_ROOT_DIR, "/", 0);
PtSetArg(&args[2], Pt_ARG_AREA, area, 0);
PtCreateWidget(PtFileSel, Pt_DEFAULT_PARENT, 3, args);
...

To display a single level of directories with a “..” item to move up levels:

...
PtSetArg(&args[0], Pt_ARG_FS_FLAGS,
         Pt_FS_SHOW_DIRS|Pt_FS_SINGLE_LEVEL,
         Pt_FS_ALL_FLAGS);
PtSetArg(&args[1], Pt_ARG_FS_ROOT_DIR, "/", 0);
PtSetArg(&args[2], Pt_ARG_AREA, area, 0);
PtCreateWidget(PtFileSel, Pt_DEFAULT_PARENT, 3, args);
...

To display a combination of directories and files in tree mode:

...
PtSetArg(&args[0], Pt_ARG_FS_FLAGS,
         Pt_FS_SHOW_DIRS|Pt_FS_SHOW_FILES,
         Pt_FS_ALL_FLAGS);
PtSetArg(&args[1], Pt_ARG_FS_ROOT_DIR, "/", 0);
PtSetArg(&args[2], Pt_ARG_AREA, area, 0);
PtCreateWidget(PtFileSel, Pt_DEFAULT_PARENT, 3, args);
...

To show only hidden files (that is, those whose name begins with a “.” and aren't normally displayed):

...
PtSetArg(&args[0], Pt_ARG_FS_FLAGS,
         Pt_FS_SHOW_FILES|Pt_FS_SHOW_HIDDEN,
         Pt_FS_ALL_FLAGS);
PtSetArg(&args[1], Pt_ARG_FS_ROOT_DIR, "/", 0);
PtSetArg(&args[2], Pt_ARG_AREA, area, 0);
PtCreateWidget(PtFileSel, Pt_DEFAULT_PARENT, 3, args);
...

You can show hidden files or directories by combining the Pt_FS_SHOW_HIDDEN flag with Pt_FS_SHOW_DIRS or Pt_FS_SHOW_FILES.

The PtFileSel widget reads a filesystem, so there could be some delays on large directories. To help you cope with these delays, the widget does the following:

• The Pt_CB_FS_STATE callback is invoked when an item is expanded or collapsed. The expansion may take a long time if the directory is large, so the Pt_CB_FS_STATE callback is actually invoked twice, once at the start of the expansion/collapse (reason = Pt_FS_STATE_START) and once at the end (reason = Pt_FS_STATE_END). This lets you block the widget until the expansion/collapse is done. The code below gives an example of this.
• The Pt_CB_FS_BKGD_HANDLER callback is invoked each time a directory entry is read. You can use this callback to call something like PtBkgdHandlerProcess(). By doing this, any pending Photon events are handled and all the screen damage is fixed. This function should be small; if not, it will slow down the directory reading even further.

Here's a full PtFileSel example:

#include <stdio.h>
#include <stdlib.h>
#include <Pt.h>
#include <photon/PtFileSel.h>

PtWidget_t *window, *button, *fs;

/* Quit button callback */
int
quit( PtWidget_t *widget, void *data,
      PtCallbackInfo_t *info)
{
    PtExit(EXIT_SUCCESS);
    return (Pt_CONTINUE);
}

/* Open button callback */
int
file_open( PtWidget_t *widget, void *data,
           PtCallbackInfo_t *info)
{
    PtFileSelItem_t *item;
    char buffer[PATH_MAX+NAME_MAX + 40];
    char const *btns[] = { "&OK" };

    item = PtFSGetCurrent(fs);
    if (item == NULL)
        return(Pt_CONTINUE);

    strcpy(buffer, "The selected file is\n");
    strcat(buffer, item->fullpath);


    PtAlert( window, NULL, "Selected File", NULL,
                buffer, NULL, 1, btns, NULL, 1, 1, Pt_MODAL );

    return (Pt_CONTINUE);
}

/* State callback, will use the reason to block the
   widget for large directory opens. */
int
state_cb( PtWidget_t *widget,
          void * data,
          PtCallbackInfo_t *info)
{
    PtArg_t args[3];
    PtFileSelCallback_t *it;

    it = (PtFileSelCallback_t *)(info->cbdata);

    if (it->reason == Pt_FS_STATE_START)
    {
        PtSetArg(&args[0], Pt_ARG_FLAGS, Pt_BLOCKED,
                 Pt_BLOCKED);
        PtSetArg(&args[1], Pt_ARG_CURSOR_TYPE,
                 Ph_CURSOR_CLOCK, 0);
    }
    else
    {
        PtSetArg(&args[0], Pt_ARG_FLAGS, ~Pt_BLOCKED,
                 Pt_BLOCKED);
        PtSetArg(&args[1], Pt_ARG_CURSOR_TYPE,
                 Ph_CURSOR_INHERIT, 0);
    }
    PtSetResources(widget, 2, args);
    return (Pt_CONTINUE);
}

/* Function to handle photon draw events and fix
   screen damage */
int
handler_cb(PtWidget_t *widget,
           void * data,
           PtCallbackInfo_t *info)
{
    PtBkgdHandlerProcess();

    return (Pt_CONTINUE);
}

int main(void)
{
    PtArg_t     args[10];
    PtCallback_t cb, cb2;
    PhDim_t win_dim = { 300, 300 };
    PhArea_t area;

    if (PtInit(NULL) == -1)
       exit(EXIT_FAILURE);

    /* Make the main window. */
    PtSetArg( &args[0], Pt_ARG_WINDOW_TITLE,
              "PtFileSel Demo", 0 );
    PtSetArg( &args[1], Pt_ARG_DIM, &win_dim, 0 );

    if ((window = PtCreateWidget(PtWindow, Pt_NO_PARENT,
                                 2, args)) == NULL)
      PtExit(EXIT_FAILURE);

    /* Make a file selector. */
    area.size.w = 200;
    area.size.h = 200;
    area.pos.x = 10;
    area.pos.y = 10;
    cb.event_f = state_cb;
    cb2.event_f = handler_cb;
    PtSetArg(&args[0], Pt_ARG_AREA, &area, 0 );
    PtSetArg(&args[1], Pt_ARG_FS_FLAGS,
             Pt_FS_SHOW_DIRS|Pt_FS_SHOW_FILES,
             Pt_FS_ALL_FLAGS );
    PtSetArg(&args[2], Pt_ARG_FS_ROOT_DIR, "/", 0);
    PtSetArg(&args[3], Pt_CB_FS_STATE, &cb, 0);
    PtSetArg(&args[4], Pt_CB_FS_BKGD_HANDLER, &cb2, 0);
    fs = PtCreateWidget( PtFileSel, window, 5, args );

    /* Make a button for quitting. */
    area.size.w = 60;
    area.size.h = 20;
    area.pos.x = 230;
    area.pos.y = 250;
    cb.event_f = quit;
    PtSetArg( &args[0], Pt_ARG_AREA, &area, 0 );
    PtSetArg( &args[1], Pt_ARG_TEXT_STRING, "Quit", 0);
    PtSetArg( &args[2], Pt_CB_ACTIVATE, &cb, 0);
    button = PtCreateWidget( PtButton, window, 3, args );

    /* Make a open button. */
    area.size.w = 60;
    area.size.h = 20;
    area.pos.x = 160;
    area.pos.y = 250;
    cb.event_f = file_open;
    PtSetArg( &args[0], Pt_ARG_AREA, &area, 0 );
    PtSetArg( &args[1], Pt_ARG_TEXT_STRING, "Open", 0);
    PtSetArg( &args[2], Pt_CB_ACTIVATE, &cb, 0);
    PtCreateWidget( PtButton, window, 3, args );

    PtRealizeWidget( window );

    PtMainLoop();
    return (EXIT_SUCCESS);
}

New resources:

Pt_ARG_FS_FILE_SPEC

A string that you can use to limit the files listed, by specifying a pattern that the filenames must match. The default is *, but you can use values such as *.c, *.[ch] and so on. You can specify multiple patterns by separating them with a space or a comma (for example, *.gif, *.jpg).

Pt_ARG_FS_FLAGS

Flags that control the appearance and behavior of the file selector:

Pt_FS_CASE_INSENSITIVE

The file name's filtering (according to the file_spec ) is case-insensitive.

Pt_FS_ERROR_POPUP

Display an error dialog when the desired root directory is invalid.

Pt_FS_FREE_ON_COLLAPSE

Free items on every collapse. This means that every time an item expands, all its child items are reread from the disk.

Pt_FS_NO_ROOT_DISPLAY

Don't show the root item.

Pt_FS_SEEK_KEY

Keyboard seek mode, valid only for single-level mode. Type characters to seek an item.

Pt_FS_SHOW_DIRS

Show directories.

Pt_FS_SHOW_ERRORS

Show files that had a read error.

Pt_FS_SHOW_FILES

Show files.

Pt_FS_SHOW_HIDDEN

Show hidden files or directories. This flag must be combined with Pt_FS_SHOW_FILES and/or Pt_FS_SHOW_DIRS. A hidden file or directory is one whose name begins with a period (.).

Pt_FS_SINGLE_LEVEL

Single-level mode, instead of tree mode. Directories and possibly files are shown in one level with a .. item for moving up directory levels.

---

If the Pt_FS_NO_ROOT_DISPLAY and Pt_FS_SINGLE_LEVEL flags are both set, the Pt_FS_NO_ROOT_DISPLAY flag is ignored.

---

Pt_ARG_FS_FORMAT

A string that's used to set the order and amount of file information displayed and optionally the initial size (in pixels) of each column shown. The following information can be displayed for each item in the widget by including the corresponding letter in the Pt_ARG_FS_FORMAT string:

---

These letters must be in lower case.

---

The s and k options are mutually exclusive. If you try to set both, the first one found in the string is used and the other is ignored. The maximum number of characters is 6; any extra ones are ignored.

If you wish to display only the filename and no divider at the top, set this resource to NULL. To set the size of the column, specify a number of pixels before the corresponding letter. For example, if you want to have the name (100 pixels wide) and the date (200 pixels wide) displayed, set the Pt_ARG_FS_FORMAT resource as follows:

PtSetArg(&args[0], Pt_ARG_FS_FORMAT, "100n200d", 0);
    

Pt_ARG_FS_IMAGES (write-only)

A pointer to an array of image pointers (of type PhImage_t — see the Photon Library Reference) to be used for displaying items. The following constants are used to index into this array (the order shown is the order the images appear in the array):

• Pt_FS_DIR_OP—open directories
• Pt_FS_DIR_CL—closed directories
• Pt_FS_DLINK_OP—open directory links
• Pt_FS_DLINK_CL—closed directory links
• Pt_FS_FILE—files
• Pt_FS_FLINK—file links
• Pt_FS_ERROR—errors

If you don't want to change an image, specify NULL for that array element. For example, to change the file image, set the Pt_FS_FILE entry of the array to the image pointer and set all others to NULL.

For example, to change the Pt_FS_DIR_OP and Pt_FS_FILE images:

PhImage_t *images[7];
/* Fill the below image structures */
…
PhImage_t new_open_image, new_file_image;
...
images[Pt_FS_DIR_OP] = &new_open_image;
images[Pt_FS_DIR_CL] = NULL;
images[Pt_FS_DLINK_OP] = NULL;
images[Pt_FS_DLINK_CL] = NULL;
images[Pt_FS_FILE] = &new_file_image;
images[Pt_FS_FLINK] = NULL;
images[Pt_FS_ERROR] = NULL;

PtSetArg(&args[0], Pt_ARG_FS_IMAGES, images, 7);
...
    

If you want to save processing time, set the length parameter to PtSetArg() to the index of the last image you changed + 1.

---

Set the flags member of the PhImage_t structures to: Ph_RELEASE_IMAGE | Ph_RELEASE_PALETTE | Ph_RELEASE_TRANSPARENCY_MASK | Ph_RELEASE_GHOST_BITMAP before providing the images to the widget. If you do this, the memory used for the images is released when the widget is unrealized or destroyed.

---

Pt_ARG_FS_LBL_DATE

The label used for the column that displays the files' modification dates.

Pt_ARG_FS_LBL_GROUP

The label used for the column that displays the group for the owner of the files.

Pt_ARG_FS_LBL_NAME

The label used for the column that displays the names of the files.

Pt_ARG_FS_LBL_OWNER

The label used for the column that displays the owners of the files.

Pt_ARG_FS_LBL_PERMISSIONS

The label used for the column that displays the permissions for the files.

Pt_ARG_FS_LBL_SIZE

The label used for the column that displays the sizes of the files.

Pt_ARG_FS_REFRESH

A pointer to the PtFileSelItem_t structure for an expandable item that's to be refreshed (i.e. reread from the disk). For example, if you have a large directory displayed and someone adds a file, you may wish to refresh the directory item. To do this, set the Pt_ARG_FS_REFRESH resource to point to the root item for that subtree.

Pt_ARG_FS_ROOT_DIR

The root directory for the file selector. The default value is NULL or none.

The widget stores the actual path obtained via the realpath() function (see the QNX Neutrino Library Reference). For example, if you set this resource to ///home//fred/.././fred/src, the widget actually sets it to /home/fred/src or /fs/hd0-qnx4/home/fred/src (if home is a link to /fs/hd0-qnx4/home).

Setting Pt_ARG_FS_ROOT_DIR to NULL clears the PtFileSel directory tree, and setting it to "." loads the current working directory.

Pt_CB_FS_BKGD_HANDLER

A list of PtCallback_t structures that define the callbacks invoked each time a directory item is read. For example, if you have 5 files in a directory and expand that directory, this callback is invoked 5 times. This gives you a chance to translate any non-UTF-8 filenames into UTF-8 strings. It's also useful for handling pending Photon events.

Each callback is passed a PtCallbackInfo_t structure that contains at least the following members:

reason

Pt_CB_FS_BKGD_HANDLER

reason_subtype

One of:

• Pt_FS_NEW_ITEM — a new item is being added to the widget; see below.
• Pt_FS_OLD_ITEM — the PtFileSel widget is doing intensive work and you may want to process events.

event

A pointer to a PhEvent_t structure that describes the event that caused the callback to be invoked.

cbdata

Used only for the Pt_FS_NEW_ITEM subtype of this callback

For the Pt_FS_NEW_ITEM reason subtype, cbdata points to a structure of type PtFileSelBkgdCallback_t, which contains at least:

char* name

A pointer to a buffer that contains the filename that the widget will add to the list. You can use this callback to ensure that the buffer contains a valid UTF-8 string.

If this callback returns Pt_END, the item isn't added. If you want to make sure that the widget correctly displays filenames that aren't encoded in UTF-8, you can use PxTranslate... functions to translate them, copy the new string into name, and return Pt_CONTINUE. You may also wish to process events.

---

Set the Pt_CB_FS_BKGD_HANDLER callback resource before the Pt_ARG_FS_ROOT_DIR resource in order to translate all the filenames.

---

Here's an example of this callback:

int
handler_cb( PtWidget_t *widget, void *data,
             PtCallbackInfo_t *info)
{
     PtFileSelBkgdCallback_t *it = (void *) info->cbdata;
     if (info->reason_subtype == Pt_FS_NEW_ITEM)
     {
         int srctaken = 0, dstmade = 0;
         char dst[NAME_MAX * 3];

         /* ctrl is a PxTransCtrl structure that was set with a
            call to PxTranslateSet(). The following will convert
            the string and copy it back to the original: */

         if (PxTranslateToUTF( ctrl, it->name, strlen( it->name),
                       &srctaken, dst, sizeof(dst)-1, &dstmade) == 0)
         {
             dst[ dstmade ] = '\0';
             strcpy(it->name, dst);
         }
         else
             /* Can't translate to UTF-8 -- let's just ignore this file... */
             return Pt_END;
     }
     PtBkgdHandlerProcess();

     return(Pt_CONTINUE);
}

Pt_CB_FS_SELECTION

A list of PtCallback_t structures that define the callbacks invoked when you select an item. Each callback is passed a PtCallbackInfo_t structure that contains at least the following members:

reason

Pt_CB_FS_SELECTION

reason_subtype

Depending on the selection mode, this is one of:

• Pt_LIST_SELECTION_FINAL
• Pt_LIST_SELECTION_BROWSE
• Pt_LIST_SELECTION_CANCEL

event

A pointer to a PhEvent_t structure that describes the event that caused the callback to be invoked.

cbdata

A pointer to a PtFileSelCallback_t structure that contains:

• unsigned sel_mode—the current selection mode:
  • Pt_BROWSE_MODE
  • Pt_MULTIPLE_MODE
  • Pt_EXTENDED_MODE
  • Pt_SINGLE_MODE
  • Pt_RANGE_MODE
• PtFileSelItem_t *item—a pointer to the item that has been selected
• unsigned nitems—the number of selected items, which depends on the selection mode
• short reason—not valid for this callback

These callbacks should return Pt_CONTINUE.

Pt_CB_FS_STATE

A list of PtCallback_t structures that define the callbacks invoked when an item is expanded or collapsed. Each callback is passed a PtCallbackInfo_t structure that contains at least the following members:

reason

Pt_CB_FS_STATE

reason_subtype

Pt_TREE_COLLAPSING or Pt_TREE_EXPANDING.

event

A pointer to a PhEvent_t structure that describes the event that caused the callback to be invoked.

cbdata

A pointer to a PtFileSelCallback_t structure that contains:

• unsigned sel_mode—the current selection mode:
  • Pt_BROWSE_MODE
  • Pt_MULTIPLE_MODE
  • Pt_EXTENDED_MODE
  • Pt_SINGLE_MODE
  • Pt_RANGE_MODE
• PtFileSelItem_t *item—if the reason member is Pt_FS_STATE_START, this is a pointer to the item being collapsed or expanded; if the reason member is Pt_FS_STATE_END, this is NULL.

  ---

  If the Pt_FS_SINGLE_LEVEL flag is set in the Pt_ARG_FS_FLAGS resource, item is always NULL because all the previous items are destroyed when you select a new directory in single-level mode.

  ---

  
  
• unsigned nitems—not valid for this callback
• short reason—

  Pt_FS_STATE_START

  The callback is being called before the directory is read (useful for blocking the widget when reading a large directory).

  Pt_FS_STATE_END

  The callback is being called after the directory is read (useful for unblocking the widget).

These callbacks should return Pt_CONTINUE.

Inherited resources:

If the widget modifies an inherited resource, the “Default override” column indicates the new value. This modification affects any subclasses of the widget.

Pt_CB_DND

For Pt_CB_DND callbacks for a PtList, the cbinfo->cbdata is a pointer to a PtTreeDndCallback_t structure, containing at least the following members:

PtDndCallbackInfo_t dnd_info

See the description of Pt_CB_DND for PtWidget.

PtGenTreeItem_t *item

A pointer to the PtGenTreeItem_t structure for the target item involved in the drag-and-drop operation. You can cast this to be a pointer to a PtFileSelItem_t.

int item_pos

The index of that item.

unsigned long flags

Possible values:

• Pt_LIST_ITEM_DNDSELECTED_UP — the drop occurred above the item.
• Pt_LIST_ITEM_DNDSELECTED_DOWN — the drop occurred below the item.
• Pt_LIST_ITEM_DNDSELECTED_IN — the drop occurred inside the item.

int action

This member is initially set to Pt_LIST_ITEM_DNDSELECTED_UP | Pt_LIST_ITEM_DNDSELECTED_DOWN | Pt_LIST_ITEM_DNDSELECTED_IN. You can unset some of these values to indicate that the drag-and-drop isn't accepted in that case. For example, if you unset Pt_LIST_ITEM_DNDSELECTED_IN, the drag-and-drop can't occur inside the item, only above or below.

Convenience functions:

The PtFileSel widget defines the following convenience functions that make it easier to use the file selector once it's been created:

PtFileSelection()

Create a file-selector dialog — see the Photon Library Reference

PtFSAddAfter()

Insert an item after the specified item

PtFSAddFirst()

Add a root item to the widget

PtFSAllItems()

Fill a buffer with pointers to all items

PtFSAllocItem()

Create an item for a file-selector widget

PtFSClearSelection()

Clear the selection

PtFSDamageItem()

Redraw an item

PtFSExpandParents()

Expand an item's collapsed ancestors

PtFSFolderCollapse()

Collapse an expandable item (directory)

PtFSFolderExpand()

Expand an expandable item (directory)

PtFSFreeAllItems()

Unlink and frees all items

PtFSFreeItems()

Free an unlinked item

PtFSGetCurrent()

Get the current item (see “Current item” in the description of PtGenList)

PtFSGetSelIndexes()

Fill a buffer with indexes

PtFSGoto()

Set the current item

PtFSItemIndex()

Calculate the index of the specified item

PtFSRemoveChildren()

Unlink all the children of a given item

PtFSRemoveItem()

Unlink an item

PtFSRemoveList()

Unlink the root item

PtFSRootItem()

Return the first root item of the file selector

PtFSSelect()

Select the specified item

PtFSSelectedItems()

Fill a buffer with item pointers

PtFSSetSelIndexes()

Set the selection indexes

PtFSShow()

Set the position so that the specified item is visible

PtFSUnselect()

Unselect the specified item

PtFSUnselectNonBrothers()

Unselect all items that aren't siblings of the specified item