---

Fl_Config.h

/*
 * $Id: Fl_Config.h,v 1.16 2003/04/11 16:26:09 laza2000 Exp $
 *
 * Extended Fast Light Toolkit (EFLTK)
 * Copyright (C) 2002-2003 by EDE-Team
 * WWW: http://www.sourceforge.net/projects/ede
 *
 * Fast Light Toolkit (FLTK)
 * Copyright (C) 1998-2003 by Bill Spitzak and others.
 * WWW: http://www.fltk.org
 *
 * This library is distributed under the GNU LIBRARY GENERAL PUBLIC LICENSE
 * version 2. See COPYING for details.
 *
 * Author : Mikko Lahteenmaki
 * Email  : mikko@fltk.net
 *
 * Please report all bugs and problems to "efltk-bugs@fltk.net"
 *
 */

#ifndef _FL_CONFIG_H_
#define _FL_CONFIG_H_

#include "Enumerations.h"
#include "Fl_Util.h"
#include "Fl_String.h"
#include "Fl_Color.h"
#include "Fl_Ptr_List.h"
#include "Fl_Map.h"

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#ifdef _WIN32_WCE
#include "x.h"
#endif


enum ConfErrors {
    CONF_SUCCESS = 0,   
    CONF_ERR_FILE,      
    CONF_ERR_SECTION,   
    CONF_ERR_KEY,       
    CONF_ERR_MEMORY,    
    CONF_ERR_NOVALUE,   
};

typedef Fl_Ptr_List Fl_Config_Sections;

typedef Fl_String_String_Map Fl_Config_Lines;

class Fl_Config;

class FL_API Fl_Config_Section
{
    friend class Fl_Config;
public:
    Fl_Config_Section(const Fl_String &name, const Fl_String &path, Fl_Config_Section *par);
    virtual ~Fl_Config_Section();

    virtual void clear();

    Fl_Config_Section *parent() const { return m_parent; }

    const Fl_String &name() const { return m_name; }

    const Fl_String &path() const { return m_path; }

    const Fl_Config_Lines &lines() const { return m_lines; }

    Fl_Config_Lines &lines() { return m_lines; }

    const Fl_Config_Sections &sections() const { return m_sections; }

    Fl_Config_Sections &sections() { return m_sections; }

    Fl_Config_Section *find(const char *section_name, bool recursive=false) const;

protected:
    Fl_Config_Section *m_parent;
    Fl_String m_name, m_path;

    Fl_Config_Lines m_lines; //Line map
    Fl_Config_Sections m_sections; //Section list

    void write_section(int indent, FILE *fp) const;

    void add_entry(const Fl_String &key, const Fl_String &value);
    bool remove_entry(const Fl_String &key);
    Fl_String *find_entry(const char *key) const;
};

class FL_API Fl_Config : public Fl_Config_Section {
public:

    enum ConfigType {
        USER=1, 
        SYSTEM  
    };

    Fl_Config(const char *vendor, const char *application, int mode=USER);

    Fl_Config(const char *filename, bool readfile=true, bool createfile=true);

    virtual ~Fl_Config();

    static char *find_config_file(const char *filename, bool create=true, int mode=USER);


    bool read_file(bool create = true);

    bool flush();

    const Fl_String &filename() const { return m_filename; }
    void filename(const char *filename) { m_filename = filename; }
    void filename(const Fl_String &filename) { m_filename = filename; }

    const Fl_String &vendor() const { return m_vendor; }
    void vendor(const char *vendor) { m_vendor = vendor; }
    void vendor(const Fl_String &vendor) { m_vendor = vendor; }

    const Fl_String &application() const { return m_app; }
    void application(const char *app) { m_app = app; }
    void application(const Fl_String &app) { m_app = app; }

    bool is_changed() const { return m_changed; }

    void set_changed() { m_changed = true; }

    int error() const { return m_error; }

    void reset_error() { m_error = 0; }

    const char *strerror() const { return Fl_Config::strerror(m_error); }

    static const char *strerror(int errnum);

    Fl_Config_Section *create_section(const char *path) { Fl_String tmp(path); return create_section(tmp); }

    Fl_Config_Section *create_section(const Fl_String &path);

    Fl_Config_Section *find_section(const char *path, bool perfect_match=true) const;

    Fl_Config_Sections *section_list(const char *secpath) const { Fl_Config_Section *s=find_section(secpath); return s ? (&s->sections()) : 0; }

    Fl_Config_Lines *line_list(const char *secpath) const { Fl_Config_Section *s=find_section(secpath); return s ? (&s->lines()) : 0; }

    void set_section(const char *secpath) { set_section(create_section(secpath)); }

    void set_section(Fl_Config_Section *sec) { m_cur_sec = sec; }

    void remove_key(const char *section, const char *key);

    void remove_sec(const char *section);


    int read(const char *key, Fl_String &ret, const char *def_value) { return _read_string(m_cur_sec, key, ret, def_value); }

    int read(const char *key, char *ret, const char *def_value, int size) { return _read_string(m_cur_sec, key, ret, def_value, size); }

    int read(const char *key, char *&ret, const char *def_value=0) { return _read_string(m_cur_sec, key, ret, def_value); }

    int read(const char *key, long &ret, long def_value=0)         { return _read_long(m_cur_sec, key, ret, def_value);   }

    int read(const char *key, int &ret, int def_value=0)           { return _read_int(m_cur_sec, key, ret, def_value);    }

    int read(const char *key, float &ret, float def_value=0)       { return _read_float(m_cur_sec, key, ret, def_value);  }

    int read(const char *key, double &ret, double def_value=0)     { return _read_double(m_cur_sec, key, ret, def_value); }

    int read(const char *key, bool &ret, bool def_value=0)         { return _read_bool(m_cur_sec, key, ret, def_value);   }

    int read(const char *key, Fl_Color &ret, Fl_Color def_value=0) { return _read_color(m_cur_sec, key, ret, def_value);  }


    int write(const char *key, const Fl_String &value) { return _write_string(m_cur_sec, key, value); }

    int write(const char *key, const char *value)    { return _write_string(m_cur_sec, key, value); }

    int write(const char *key, const long value)     { return _write_long(m_cur_sec, key, value); }

    int write(const char *key, const int value)      { return _write_int(m_cur_sec, key, value); }

    int write(const char *key, const float value)    { return _write_float(m_cur_sec, key, value); }

    int write(const char *key, const double value)   { return _write_double(m_cur_sec, key, value); }

    int write(const char *key, const bool value)     { return _write_bool(m_cur_sec, key, value); }

    int write(const char *key, const Fl_Color value) { return _write_color(m_cur_sec, key, value); }


    int get(const char *section, const char *key, Fl_String &ret, const char *def_value) { return _read_string(find_section(section), key, ret, def_value); }

    int get(const char *section, const char *key, char *ret, const char *def_value, int size) { return _read_string(find_section(section), key, ret, def_value, size); }

    int get(const char *section, const char *key, char *&ret, const char *def_value=0) { return _read_string(find_section(section), key, ret, def_value); }

    int get(const char *section, const char *key, long &ret, long def_value=0)         { return _read_long(find_section(section), key, ret, def_value);            }

    int get(const char *section, const char *key, int &ret, int def_value=0)           { return _read_int(find_section(section), key, ret, def_value);               }

    int get(const char *section, const char *key, float &ret, float def_value=0)       { return _read_float(find_section(section), key, ret, def_value);         }

    int get(const char *section, const char *key, double &ret, double def_value=0)     { return _read_double(find_section(section), key, ret, def_value);      }

    int get(const char *section, const char *key, bool &ret, bool def_value=0)         { return _read_bool(find_section(section), key, ret, def_value);            }

    int get(const char *section, const char *key, Fl_Color &ret, Fl_Color def_value=0) { return _read_color(find_section(section), key, ret, def_value);   }


    int set(const char *section, const char *key, const Fl_String &value) { return _write_string(create_section(section), key, value); }

    int set(const char *section, const char *key, const char *value) { return _write_string(create_section(section), key, value); }

    int set(const char *section, const char *key, const long value)  { return _write_long(create_section(section), key, value);   }

    int set(const char *section, const char *key, const int value)   { return _write_int(create_section(section), key, value);    }

    int set(const char *section, const char *key, const float value) { return _write_float(create_section(section), key, value);  }

    int set(const char *section, const char *key, const bool value)  { return _write_double(create_section(section), key, value); }

    int set(const char *section, const char *key, const Fl_Color value) { return _write_color(create_section(section), key, value); }

private:
    int m_error;
    Fl_String m_filename;
    Fl_String m_vendor, m_app;

    Fl_Config_Section *m_cur_sec;
    bool m_changed;

    int _read_string(Fl_Config_Section *s, const char *key, Fl_String &ret, const char *def_value);
    int _read_string(Fl_Config_Section *s, const char *key, char *ret, const char *def_value, int size);
    int _read_string(Fl_Config_Section *s, const char *key, char *&ret, const char *def_value);
    int _read_long  (Fl_Config_Section *s, const char *key, long &ret, long def_value);
    int _read_int   (Fl_Config_Section *s, const char *key, int &ret, int def_value);
    int _read_float (Fl_Config_Section *s, const char *key, float &ret, float def_value);
    int _read_double(Fl_Config_Section *s, const char *key, double &ret, double def_value);
    int _read_bool  (Fl_Config_Section *s, const char *key, bool &ret, bool def_value);
    int _read_color (Fl_Config_Section *s, const char *key, Fl_Color &ret, Fl_Color def_value);

    int _write_string(Fl_Config_Section *s, const char *key, const Fl_String &value);
    int _write_string(Fl_Config_Section *s, const char *key, const char *value);
    int _write_long  (Fl_Config_Section *s, const char *key, const long value);
    int _write_int   (Fl_Config_Section *s, const char *key, const int value);
    int _write_float (Fl_Config_Section *s, const char *key, const float value);
    int _write_double(Fl_Config_Section *s, const char *key, const double value);
    int _write_bool  (Fl_Config_Section *s, const char *key, const bool value);
    int _write_color (Fl_Config_Section *s, const char *key, const Fl_Color value);
};

// Backward compatibility...
static inline const char* fl_find_config_file(const char *filename, bool create=true) {
    return Fl_Config::find_config_file(filename, create, Fl_Config::USER);
}

#endif

---