Fl_Preferences Binding Map

Back to Index
Package name
Fl_Preferences FLTK.Environment
Types
Fl_Preferences Database
  Database_Reference
Fl_Preferences Pref_Group
  Pref_Group_Reference
Entry  
Name  
Root Scope
ID  
Errors
char Preference_Error
Protected Attributes
Node * node;
Intentionally left unbound. 
RootNode * rootNode;
Intentionally left unbound.
Constructors
Fl_Preferences(Root root, const char *vendor, const char *application);

function From_Scope
       (Extent              : in Scope;
        Vendor, Application : in String)
    return Database;

Fl_Preferences(const char *path, const char *vendor,
    const char *application);

function From_Filesystem
       (Directory, Vendor, Application : in String)
    return Database;

Fl_Preferences(Fl_Preferences &parent, const char *group);

Fl_Preferences(Fl_Preferences *parent, const char *group);

function By_Name
       (From : in Pref_Group;
        Name : in String)
    return Pref_Group'Class;

function In_Memory
       (Name : in String)
    return Pref_Group;

Fl_Preferences(Fl_Preferences &parent, int groupIndex);

Fl_Preferences(Fl_Preferences *parent, int groupIndex);

function By_Index
       (From  : in Pref_Group;
        Index : in Positive)
    return Pref_Group'Class;

Fl_Preferences(const Fl_Preferences &);

function Root
       (From : in Database)
    return Pref_Group'Class;
Static Functions and Procedures
static const char * newUUID();

function New_UUID
    return String;

static char remove(ID id_);
Intentionally left unbound.
Functions and Procedures
char clear();

procedure Clear
       (This : in out Pref_Group)
with Post => This.Number_Of_Entries = 0 and
        This.Number_Of_Groups = 0;

char deleteAllEntries();

procedure Delete_All_Entries
       (This : in out Pref_Group)
with Post => This.Number_Of_Entries = 0;

char deleteAllGroups();

procedure Delete_All_Groups
       (This : in out Pref_Group)
with Post => This.Number_Of_Groups = 0;

char deleteEntry(const char *entry);

procedure Delete_Entry
       (This : in out Pref_Group;
        Key  : in     String)
with Post => This.Key_Exists (Key) = False;

char deleteGroup(const char *group);

procedure Delete_Group
       (This : in out Pref_Group;
        Name : in     String)
with Post => This.Group_Exists (Name) = False;

int entries();

function Number_Of_Entries
       (This : in Pref_Group)
    return Natural;

const char * entry(int index);

function Entry_Key
       (This  : in Pref_Group;
        Index : in Positive)
    return String
with Pre => Index in 1 .. This.Number_Of_Entries;

char entryExists(const char *key);

function Key_Exists
       (This : in Pref_Group;
        Key  : in String)
    return Boolean;

void flush();

procedure Flush
       (This : in Database);

char get(const char *entry, int &value, int defaultValue);

function Get
       (This : in Pref_Group;
        Key  : in String)
    return Integer;

function Get
       (This    : in Pref_Group;
        Key     : in String;
        Default : in Integer)
    return Integer;

char get(const char *entry, float &value, float defaultValue);

function Get
       (This : in Pref_Group;
        Key  : in String)
    return Float;

function Get
       (This    : in Pref_Group;
        Key     : in String;
        Default : in Float)
    return Float;

char get(const char *entry, double &value, double defaultValue);

function Get
       (This : in Pref_Group;
        Key  : in String)
    return Long_Float;

function Get
       (This    : in Pref_Group;
        Key     : in String;
        Default : in Long_Float)
    return Long_Float;

char get(const char *entry, char *&value, const char *defaultValue);

function Get
       (This : in Pref_Group;
        Key  : in String)
    return String;

function Get
       (This    : in Pref_Group;
        Key     : in String;
        Default : in String)
    return String;

char get(const char *entry, char *value, const char *defaultValue,
    int maxSize);

function Get
       (This       : in Pref_Group;
        Key        : in String;
        Default    : in String;
        Max_Length : in Natural)
    return String
with Post => Get'Result'Length <= Max_Length;

char get(const char *entry, void *&value, const void *defaultValue,
    int defaultSize);

function Get
       (This : in Pref_Group;
        Key  : in String)
    return Binary_Data;

function Get
       (This    : in Pref_Group;
        Key     : in String;
        Default : in Binary_Data)
    return Binary_Data;

char get(const char *entry, void *value, const void *defaultValue,
    int defaultSize, int maxSize);

function Get
       (This       : in Pref_Group;
        Key        : in String;
        Default    : in Binary_Data;
        Max_Length : in Natural)
    return Binary_Data
with Post => Get'Result'Length <= Max_Length;

char getUserdataPath(char *path, int pathlen);

function Userdata_Path
       (This : in Database)
    return String;

const char * group(int num_group);

function Group_Name
       (This  : in Pref_Group;
        Index : in Positive)
    return String
with Pre => Index in 1 .. This.Number_Of_Groups;

char groupExists(const char *key);

function Group_Exists
       (This : in Pref_Group;
        Name : in String)
    return Boolean;

int groups();

function Number_Of_Groups
       (This : in Pref_Group)
    return Natural;

ID id();
Intentionally left unbound. 
const char * name();

function At_Name
       (This : in Pref_Group)
    return String;

const char * path();

function At_Path
       (This : in Pref_Group)
    return String;

char set(const char *entry, int value);

procedure Set
       (This  : in out Pref_Group;
        Key   : in     String;
        Value : in     Integer)
with Post => This.Key_Exists (Key);

char set(const char *entry, float value);

procedure Set
       (This  : in out Pref_Group;
        Key   : in     String;
        Value : in     Float)
with Post => This.Key_Exists (Key);

char set(const char *entry, float value, int precision);

procedure Set
       (This      : in out Pref_Group;
        Key       : in     String;
        Value     : in     Float;
        Precision : in     Natural)
with Post => This.Key_Exists (Key);

char set(const char *entry, double value);

procedure Set
       (This  : in out Pref_Group;
        Key   : in     String;
        Value : in     Long_Float)
with Post => This.Key_Exists (Key);

char set(const char *entry, double value, int precision);

procedure Set
       (This      : in out Pref_Group;
        Key       : in     String;
        Value     : in     Long_Float;
        Precision : in     Natural)
with Post => This.Key_Exists (Key);

char set(const char *entry, const char *value);

procedure Set
       (This  : in out Pref_Group;
        Key   : in     String;
        Value : in     String)
with Post => This.Key_Exists (Key);

char set(const char *entry, const void *value, int size);

procedure Set
       (This  : in out Pref_Group;
        Key   : in     String;
        Value : in     Binary_Data)
with Post => This.Key_Exists (Key);

int size(const char *entry);

function Value_Size
       (This : in Pref_Group;
        Key  : in String)
    return Natural;