You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
878 lines
24 KiB
878 lines
24 KiB
//=============================================================================
|
|
//
|
|
// File : libkviconfig.cpp
|
|
// Creation date : Thu Jan 31 2002 22:50:12 GMT by Szymon Stefanek
|
|
//
|
|
// This config is part of the KVirc irc client distribution
|
|
// Copyright (C) 2002-2005 Szymon Stefanek (pragma@kvirc.net)
|
|
//
|
|
// This program is FREE software. You can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation; either version 2
|
|
// of the License, or (at your opinion) any later version.
|
|
//
|
|
// This program is distributed in the HOPE that it will be USEFUL,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, write to the Free Software Foundation,
|
|
// Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "kvi_module.h"
|
|
#include "kvi_string.h"
|
|
#include "kvi_config.h"
|
|
#include "kvi_fileutils.h"
|
|
#include "kvi_app.h"
|
|
#include "kvi_locale.h"
|
|
|
|
#include "kvi_pointerhashtable.h"
|
|
|
|
static KviPointerHashTable<TQString,KviConfig> * g_pConfigDict = 0;
|
|
static int g_iNextConfigId = 0;
|
|
|
|
/*
|
|
@doc: config.open
|
|
@type:
|
|
function
|
|
@title:
|
|
$config.open
|
|
@short:
|
|
Opens a config file
|
|
@syntax:
|
|
$config.open(<filename:string>[,<flags:string>])
|
|
@description:
|
|
Opens a config file.
|
|
If the file already exists , its contents
|
|
are parsed and available for extracting by the [fnc]$config.read[/fnc]() function.[br]
|
|
<filename> may be an absolute path or a relative path: if a relative path is used,
|
|
KVIrc will complete it with a local kvirc directory suitable for writing script config files.[br]
|
|
If the config file doesn't exist , it is opened as empty config file.[br]
|
|
Flags can contain a combination of letters 'r' and 'w'.[br]
|
|
If only 'r' is specified , the config file is opened in "read-only" mode: no changes will be written to disk.[br]
|
|
If only 'w' is specified , the config file is opened in "write-only" mode: the contents of the file on disk
|
|
are not readed.[br]
|
|
If <flags> are not specified then 'rw' is assumed.[br]
|
|
The function returns an identifier for the open config file. This identifier
|
|
is a mandatory parameter in all the other config.* functions and commands.[br]
|
|
The config section is set to the default section name: you can change it by using
|
|
[cmd]config.setsection[/cmd].[br]
|
|
After you have finished using the file , don't forget to call [cmd]config.close[/cmd]!
|
|
KVIrc tries to not open a config file twice: if the file was already opened then
|
|
the identifier of the open file is returned.[br]
|
|
You can check if a config file is already open by using the
|
|
[fnc]$config.id[/fnc]() function.[br]
|
|
@examples:
|
|
[example]
|
|
# It is a good idea to store the returned id to a variable :)
|
|
%cfg = $config.open(myscript.kvc)
|
|
%num = [fnc]$config.read[/fnc](%cfg,Number,0)
|
|
[cmd]echo[/cmd] Number of entries is %num
|
|
%num++;
|
|
[cmd]config.write[/cmd] %cfg Number %num
|
|
[cmd]config.close[/cmd] %cfg
|
|
[/example]
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
|
|
static bool config_kvs_fnc_open(KviKvsModuleFunctionCall * c)
|
|
{
|
|
TQString szFile;
|
|
TQString szMode;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("filename",KVS_PT_STRING,0,szFile)
|
|
KVSM_PARAMETER("mode",KVS_PT_STRING,KVS_PF_OPTIONAL,szMode)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig::FileMode fileMode;
|
|
|
|
if(szMode.contains('r'))
|
|
{
|
|
if(szMode.contains('w'))fileMode = KviConfig::ReadWrite;
|
|
else fileMode = KviConfig::Read;
|
|
} else {
|
|
if(szMode.contains('w'))fileMode = KviConfig::Write;
|
|
else fileMode = KviConfig::ReadWrite;
|
|
}
|
|
|
|
KviFileUtils::adjustFilePath(szFile);
|
|
TQString szAbsFile;
|
|
|
|
if(KviFileUtils::isAbsolutePath(szFile))szAbsFile = szFile;
|
|
else g_pApp->getLocalKvircDirectory(szAbsFile,KviApp::ConfigScripts,szFile,true);
|
|
|
|
KviPointerHashTableIterator<TQString,KviConfig> it(*g_pConfigDict);
|
|
while(it.current())
|
|
{
|
|
if(KviTQString::equalCI(it.current()->fileName(),szAbsFile))
|
|
{
|
|
c->returnValue()->setString(it.currentKey());
|
|
if(it.current()->readOnly() && (fileMode & KviConfig::Write))
|
|
{
|
|
it.current()->setReadOnly(false);
|
|
}
|
|
return true;
|
|
}
|
|
++it;
|
|
}
|
|
|
|
KviConfig * cfg = new KviConfig(szAbsFile,fileMode);
|
|
g_iNextConfigId++;
|
|
TQString tmp = TQString("%1").arg(g_iNextConfigId);
|
|
g_pConfigDict->insert(tmp,cfg);
|
|
c->returnValue()->setString(tmp);
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.id
|
|
@type:
|
|
function
|
|
@title:
|
|
$config.id
|
|
@short:
|
|
Returns the id of an open config file
|
|
@syntax:
|
|
$config.id(<filename>)
|
|
@description:
|
|
Returns the id of an open config file specified by <filename>.[br]
|
|
(This is the same id that is returned by [fnc]$config.open[/fnc].[br]
|
|
If no such file is open, 0 is returned (that is an invalid config identifier).[br]
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_fnc_id(KviKvsModuleFunctionCall * c)
|
|
{
|
|
TQString szFile;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("file",KVS_PT_STRING,0,szFile)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviFileUtils::adjustFilePath(szFile);
|
|
|
|
TQString szAbsFile;
|
|
|
|
if(KviFileUtils::isAbsolutePath(szFile))szAbsFile = szFile;
|
|
else g_pApp->getLocalKvircDirectory(szAbsFile,KviApp::ConfigScripts,szFile,true);
|
|
|
|
KviPointerHashTableIterator<TQString,KviConfig> it(*g_pConfigDict);
|
|
while(it.current())
|
|
{
|
|
if(KviTQString::equalCI(it.current()->fileName(),szAbsFile))
|
|
{
|
|
c->returnValue()->setString(it.currentKey());
|
|
return true;
|
|
}
|
|
++it;
|
|
}
|
|
|
|
c->returnValue()->setString("0");
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.read
|
|
@type:
|
|
function
|
|
@title:
|
|
$config.read
|
|
@short:
|
|
Reads an entry from a config file
|
|
@syntax:
|
|
$config.read(<id:string>,<key:string>[,<default:string>])
|
|
@description:
|
|
Reads and returns the value associated to <key> in the current section of the config
|
|
file identified by <id>.[br]
|
|
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
|
|
If no value is associated with <key> in the current section the return value
|
|
is an empty string or the string <default> if it has been passed.[br]
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_fnc_read(KviKvsModuleFunctionCall * c)
|
|
{
|
|
TQString szId;
|
|
TQString szKey;
|
|
TQString szDefault;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETER("key",KVS_PT_STRING,0,szKey)
|
|
KVSM_PARAMETER("default",KVS_PT_STRING,KVS_PF_OPTIONAL,szDefault)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
c->returnValue()->setString(cfg->readEntry(szKey,szDefault));
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.section
|
|
@type:
|
|
function
|
|
@title:
|
|
$config.section
|
|
@short:
|
|
Returns the name of the current section of a config file
|
|
@syntax:
|
|
$config.section(<id>)
|
|
@description:
|
|
Returns the name of the current section in the config file identifier by <id>.[br]
|
|
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_fnc_section(KviKvsModuleFunctionCall * c)
|
|
{
|
|
TQString szId;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
c->returnValue()->setString(cfg->group());
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.readonly
|
|
@type:
|
|
function
|
|
@title:
|
|
$config.readonly
|
|
@short:
|
|
Checks wheter a config file is opened in readonly mode
|
|
@syntax:
|
|
$config.readonly(<id>)
|
|
@description:
|
|
Returns 1 if the config file identified by <id> is opened in readonly mode,
|
|
0 otherwise.[br]
|
|
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
|
|
If <id> does not identify an open config file, a warning is printed and 0 is returned.[br]
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_fnc_readonly(KviKvsModuleFunctionCall * c)
|
|
{
|
|
TQString szId;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
c->returnValue()->setBoolean(cfg->readOnly());
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
c->returnValue()->setInteger(false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.filename
|
|
@type:
|
|
function
|
|
@title:
|
|
$config.filename
|
|
@short:
|
|
Returns the filename of an open config file
|
|
@syntax:
|
|
$config.filename(<id>)
|
|
@description:
|
|
Returns the filename of the [b]open[/b] config file identifier by <id>.[br]
|
|
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
|
|
If the <id> doesn't match any open file, and empty string is returned.[br]
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_fnc_filename(KviKvsModuleFunctionCall * c)
|
|
{
|
|
TQString szId;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
c->returnValue()->setString(cfg->fileName());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.hassection
|
|
@type:
|
|
function
|
|
@title:
|
|
$config.hassection
|
|
@short:
|
|
Checks wheter a section is present in a config file
|
|
@syntax:
|
|
$config.hassection(<id>,<section_name>)
|
|
@description:
|
|
Returns 1 if the section <section_name> exists in the config file identifier by <id>,
|
|
0 otherwise.[br]
|
|
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_fnc_hassection(KviKvsModuleFunctionCall * c)
|
|
{
|
|
TQString szId;
|
|
TQString szSect;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szSect)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
c->returnValue()->setBoolean(cfg->hasGroup(szSect));
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.sectionlist
|
|
@type:
|
|
function
|
|
@title:
|
|
$config.sectionlist
|
|
@short:
|
|
Returns a list of the sections in a config file
|
|
@syntax:
|
|
$config.sectionlist(<id>)
|
|
@description:
|
|
Returns an array of sections present in the config file identified by <id>.[br]
|
|
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_fnc_sectionlist(KviKvsModuleFunctionCall * c)
|
|
{
|
|
TQString szId;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
KviConfigIterator it(*(cfg->dict()));
|
|
KviKvsArray* pArray = new KviKvsArray();
|
|
int id=0;
|
|
while(it.current())
|
|
{
|
|
pArray->set(id++, new KviKvsVariant(it.currentKey()));
|
|
++it;
|
|
}
|
|
c->returnValue()->setArray(pArray);
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.keylist
|
|
@type:
|
|
function
|
|
@title:
|
|
$config.keylist
|
|
@short:
|
|
Returns a list of keys in a config file
|
|
@syntax:
|
|
$config.keylist(<id>)
|
|
@description:
|
|
Returns an array of keys present in the current section of the config file identified by <id>.[br]
|
|
<id> must be a valid config identifier returned by [fnc]$config.open[/fnc]()
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_fnc_keylist(KviKvsModuleFunctionCall * c)
|
|
{
|
|
TQString szId;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
KviConfigGroup * d = cfg->dict()->find(cfg->group());
|
|
if(!d)return true;
|
|
|
|
KviConfigGroupIterator it(*d);
|
|
|
|
KviKvsArray* pArray = new KviKvsArray();
|
|
int id=0;
|
|
|
|
while(it.current())
|
|
{
|
|
pArray->set(id++, new KviKvsVariant(it.currentKey()));
|
|
++it;
|
|
}
|
|
c->returnValue()->setArray(pArray);
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.filelist
|
|
@type:
|
|
function
|
|
@title:
|
|
$config.filelist
|
|
@short:
|
|
Returns a list of open config files
|
|
@syntax:
|
|
$config.filelist
|
|
@description:
|
|
Returns an array of open config files.[br]
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_fnc_filelist(KviKvsModuleFunctionCall * c)
|
|
{
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviKvsArray* pArray = new KviKvsArray();
|
|
int id=0;
|
|
|
|
KviPointerHashTableIterator<TQString,KviConfig> it(*g_pConfigDict);
|
|
while(it.current())
|
|
{
|
|
pArray->set(id++, new KviKvsVariant(it.currentKey()));
|
|
++it;
|
|
}
|
|
c->returnValue()->setArray(pArray);
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.close
|
|
@type:
|
|
command
|
|
@title:
|
|
config.close
|
|
@keyterms:
|
|
storing & reading configuration entries
|
|
@short:
|
|
Closes a config file
|
|
@syntax:
|
|
config.close [-q] <id>
|
|
@description:
|
|
Closes the config file identified by <id>.[br]
|
|
<id> must be a a valid config file identifier returned by [fnc]$config.open[/fnc].[br]
|
|
If the config file was opened as read-write (default), the changes will be stored
|
|
to disk. If the config was opened as read-only , changes will not be written.[br]
|
|
If the <id> does not match any open config file, a warning is printed unless
|
|
the -q switch is used.[br]
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_cmd_close(KviKvsModuleCommandCall * c)
|
|
{
|
|
TQString szId;
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
if(cfg->dirty() && cfg->readOnly())
|
|
{
|
|
if(!c->hasSwitch('q',"quiet"))
|
|
c->warning(__tr2qs("The config file '%Q' has been changed but is opened as read-only: changes will be lost"),&cfg->fileName());
|
|
}
|
|
g_pConfigDict->remove(szId);
|
|
} else {
|
|
if(!c->hasSwitch('q',"quiet"))
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.flush
|
|
@type:
|
|
command
|
|
@title:
|
|
config.flush
|
|
@keyterms:
|
|
storing & reading configuration entries
|
|
@short:
|
|
Flushes a config file
|
|
@syntax:
|
|
config.flush <id>
|
|
@description:
|
|
Flushes the config file identified by <id>.[br]
|
|
<id> must be a a valid config file identifier returned by [fnc]$config.open[/fnc].[br]
|
|
If the config file was opened as read-write (default), the changes will be stored
|
|
to disk. If the config was opened as read-only ,an error is printed.[br]
|
|
If the <id> does not match any open config file, a warning is printed.
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_cmd_flush(KviKvsModuleCommandCall * c)
|
|
{
|
|
TQString szId;
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
if(cfg->readOnly())
|
|
c->warning(__tr2qs("The config file with id '%Q' is read only"),&szId);
|
|
else
|
|
cfg->sync();
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.clear
|
|
@type:
|
|
command
|
|
@title:
|
|
config.clear
|
|
@keyterms:
|
|
storing & reading configuration entries
|
|
@short:
|
|
Clears a config file
|
|
@syntax:
|
|
config.clear <id>
|
|
@description:
|
|
Clears the contents of the config file identified by <id>.[br]
|
|
All the sections are removed (except for the default section) and all the key=value
|
|
pairs are destroyed.[br]
|
|
<id> must be a a valid config file identifier returned by [fnc]$config.open[/fnc].[br]
|
|
If the <id> does not match any open config file, a warning is printed.
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_cmd_clear(KviKvsModuleCommandCall * c)
|
|
{
|
|
TQString szId;
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
cfg->clear();
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.clearsection
|
|
@type:
|
|
command
|
|
@title:
|
|
config.clearsection
|
|
@keyterms:
|
|
storing & reading configuration entries
|
|
@short:
|
|
Clears a section in a config file
|
|
@syntax:
|
|
config.clearsection <id> <section_name>
|
|
@description:
|
|
Clears the contents of the section <section_name> in the config file identified by <id>.[br]
|
|
All the key=value pairs in the section are destroyed.[br]
|
|
<id> must be a a valid config file identifier returned by [fnc]$config.open[/fnc].[br]
|
|
If the <id> does not match any open config file, a warning is printed.
|
|
If <section_name> was also the current section, the current section is set to the default one.[br]
|
|
No warning is printed if the section wasn't existing.[br]
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_cmd_clearsection(KviKvsModuleCommandCall * c)
|
|
{
|
|
TQString szId;
|
|
TQString szSect;
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETER("section",KVS_PT_STRING,0,szSect)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
cfg->clearGroup(szSect);
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.write
|
|
@type:
|
|
command
|
|
@title:
|
|
config.write
|
|
@keyterms:
|
|
storing & reading configuration entries
|
|
@short:
|
|
Writes a data field to a config file
|
|
@syntax:
|
|
config.write <id> <key> <value>
|
|
@description:
|
|
Writes the <key>=<value> pair to the config file identifier by <id>.[br]
|
|
<id> must be a valid config file id returned by [fnc]$config.open[/fnc]().[br]
|
|
<key> and <value> can be any strings.[br]
|
|
The <key>=<value> pair is written in the current section of the config file.[br]
|
|
If <key> already exists in the current section of the config , the corresponding value is replaced with <value>.[br]
|
|
If <value> is an empty string, the <key> is simply removed from the current section.[br]
|
|
If a section remains empty (with no keys) at file write time, that section will be removed.[br]
|
|
The changes are NOT written to disk: you must call [cmd]config.flush[/cmd] or (better) [cmd]config.close[/cmd]
|
|
for the changes to be effectively written.[br]
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_cmd_write(KviKvsModuleCommandCall * c)
|
|
{
|
|
TQString szId;
|
|
TQString szKey;
|
|
TQString szVal;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETER("key",KVS_PT_STRING,0,szKey)
|
|
KVSM_PARAMETER("value",KVS_PT_STRING,0,szVal)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
cfg->writeEntry(szKey,szVal);
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config.setsection
|
|
@type:
|
|
command
|
|
@title:
|
|
config.setsection
|
|
@keyterms:
|
|
storing & reading configuration entries
|
|
@short:
|
|
Changes the current section of a config file
|
|
@syntax:
|
|
config.setsection <id> <section_name>
|
|
@description:
|
|
Changes the current section of the config file <id> to <section_name>.[br]
|
|
Sections are effectively namespaces for the keys: each section can contain
|
|
a set of keys and equal keys in different sections do not collide.[br]
|
|
<id> must be a valid config file id returned by [fnc]$config.open[/fnc]().[br]
|
|
@seealso:
|
|
[module:config]Config module documentation[/module]
|
|
*/
|
|
|
|
static bool config_kvs_cmd_setsection(KviKvsModuleCommandCall * c)
|
|
{
|
|
TQString szId;
|
|
TQString szSect;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
KVSM_PARAMETER("id",KVS_PT_STRING,0,szId)
|
|
KVSM_PARAMETER("section",KVS_PT_STRING,0,szSect)
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviConfig * cfg = g_pConfigDict->find(szId);
|
|
|
|
if(cfg)
|
|
{
|
|
cfg->setGroup(szSect);
|
|
} else {
|
|
c->warning(__tr2qs("The config file with id '%Q' is not open"),&szId);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
@doc: config
|
|
@type:
|
|
module
|
|
@short:
|
|
Managing of configuration files
|
|
@title:
|
|
The config module
|
|
@body:
|
|
The config module is a powerful interface that manages text configuration files.[br]
|
|
The files are arranged in named sections and the data is stored in key=value pairs
|
|
belonging to each section.[br]
|
|
[br]
|
|
[section1_name][br]
|
|
<key1>=<value1>[br]
|
|
<key2>=<value2>[br]
|
|
<key3>=<value3>[br]
|
|
....[br]
|
|
[section2_name][br]
|
|
<key1>=<value1>[br]
|
|
....[br]
|
|
[br]
|
|
Keys and values are plain text strings. Eventual newlines in values are encoded using
|
|
a simple hexadecimal notation.[br]
|
|
The config files can be also edited by using any text editor.[br]
|
|
The config module works on config files loaded in memory. For this reason,
|
|
you must first open a config file by the means of [fnc]$config.open[/fnc]().[br]
|
|
Once you open the file , if it exists on disk , its contents are loaded into memory
|
|
and you can access the data stored in it. If the file wasn't existing, and empty
|
|
memory config file is created.[br]
|
|
The config file is opened in read-write mode by default. You can also choose
|
|
the "read-only" method: a read-only config file is never flushed to disk (but you can
|
|
set the values in memory!).[br]
|
|
It is not a good idea to keep a config file open forever: a good approach
|
|
is to keep settings in memory variables and write them all at once when it comes to
|
|
write settings: you open the config file , write all your values and close the file.[br]
|
|
You can obviously keep the config file open for some time but remember that
|
|
no change is written to the disk until [cmd]config.flush[/cmd] or [cmd]config.close[/cmd] is called.[br]
|
|
You write entries by using [cmd]config.write[/cmd] and read them by using [fnc]$config.read[/fnc]().[br]
|
|
You can change the "current" config section by using [cmd]config.setsection[/cmd].[br]
|
|
Here comes a complete list of commands and functions exported by this module:[br]
|
|
[fnc]$config.open[/fnc][br]
|
|
[fnc]$config.read[/fnc][br]
|
|
[fnc]$config.section[/fnc][br]
|
|
[fnc]$config.hassection[/fnc][br]
|
|
[fnc]$config.sectionlist[/fnc][br]
|
|
[fnc]$config.keylist[/fnc][br]
|
|
[fnc]$config.filelist[/fnc][br]
|
|
[fnc]$config.filename[/fnc][br]
|
|
[fnc]$config.id[/fnc][br]
|
|
[fnc]$config.readonly[/fnc][br]
|
|
[cmd]config.close[/cmd][br]
|
|
[cmd]config.flush[/cmd][br]
|
|
[cmd]config.clear[/cmd][br]
|
|
[cmd]config.clearsection[/cmd][br]
|
|
[cmd]config.setsection[/cmd][br]
|
|
[cmd]config.write[/cmd][br]
|
|
*/
|
|
|
|
static bool config_module_init(KviModule * m)
|
|
{
|
|
g_pConfigDict = new KviPointerHashTable<TQString,KviConfig>;
|
|
g_pConfigDict->setAutoDelete(true);
|
|
|
|
KVSM_REGISTER_FUNCTION(m,"open",config_kvs_fnc_open);
|
|
KVSM_REGISTER_FUNCTION(m,"id",config_kvs_fnc_id);
|
|
KVSM_REGISTER_FUNCTION(m,"read",config_kvs_fnc_read);
|
|
KVSM_REGISTER_FUNCTION(m,"section",config_kvs_fnc_section);
|
|
KVSM_REGISTER_FUNCTION(m,"hassection",config_kvs_fnc_hassection);
|
|
KVSM_REGISTER_FUNCTION(m,"sectionlist",config_kvs_fnc_sectionlist);
|
|
KVSM_REGISTER_FUNCTION(m,"keylist",config_kvs_fnc_keylist);
|
|
KVSM_REGISTER_FUNCTION(m,"filelist",config_kvs_fnc_filelist);
|
|
KVSM_REGISTER_FUNCTION(m,"filename",config_kvs_fnc_filename);
|
|
KVSM_REGISTER_FUNCTION(m,"readonly",config_kvs_fnc_readonly);
|
|
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"close",config_kvs_cmd_close);
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"flush",config_kvs_cmd_flush);
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"clear",config_kvs_cmd_clear);
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"clearsection",config_kvs_cmd_clearsection);
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"setsection",config_kvs_cmd_setsection);
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"write",config_kvs_cmd_write);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool config_module_cleanup(KviModule *m)
|
|
{
|
|
delete g_pConfigDict;
|
|
g_pConfigDict = 0;
|
|
return true;
|
|
}
|
|
|
|
static bool config_module_can_unload(KviModule *m)
|
|
{
|
|
return g_pConfigDict->isEmpty();
|
|
}
|
|
|
|
KVIRC_MODULE(
|
|
"Config", // module name
|
|
"1.0.0", // module version
|
|
"Copyright (C) 2001 Szymon Stefanek (pragma at kvirc dot net)", // author & (C)
|
|
"Config file system for KVIrc",
|
|
config_module_init,
|
|
config_module_can_unload,
|
|
0,
|
|
config_module_cleanup
|
|
)
|