TDE
/
kvirc
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/kvirc
0
0
Fork 0
Code Issues Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '482e263a24'
${ noResults }
kvirc/src/kvirc/kvs/kvi_kvs_corefunctions_gl.cpp

889 lines
22 KiB
Raw Blame History

//=============================================================================
//
// File : kvi_kvs_corefunctions_gl.cpp
// Created on Fri 31 Oct 2003 01:52:04 by Szymon Stefanek
//
// This file is part of the KVIrc IRC client distribution
// Copyright (C) 2003-2005 Szymon Stefanek <pragma at kvirc dot 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.
//
//=============================================================================
#define __KVIRC__
#include "kvi_kvs_corefunctions.h"
#include "kvi_kvs_kernel.h"
#include "kvi_kvs_timermanager.h"
#include "kvi_kvs_arraycast.h"
#include "kvi_locale.h"
#include "kvi_input.h"
#include "kvi_app.h"
#include "kvi_channel.h"
#include "kvi_console.h"
#include "kvi_iconmanager.h"
#include "kvi_mirccntrl.h"
#include "kvi_frame.h"
#include "kvi_time.h"
#include "kvi_kvs_eventmanager.h"
#include "kvi_kvs_eventhandler.h"
#include <tqregexp.h>
#include "kvi_lagmeter.h"
namespace KviKvsCoreFunctions
{
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: hash
@type:
function
@title:
$hash
@short:
Explicitly creates a hash
@syntax:
<hash> $hash([<key:string>,<value:variant>,[<key:string>,<value:variant>]],...)
@description:
Returns a hash with the specified items. Each <value> is indexed by the preceeding <key>.
This is just an explicit way of creating a hash with a defined set of items,
useful for increasing readability.
@examples:
[example]
[cmd]alias[/cmd](test){ [cmd]return[/cmd] $hash(1,X,2,Y,3,Z); };
%x = $test();
[cmd]foreach[/cmd](%y,%x)
{
[cmd]echo[/cmd] %y;
}
[cmd]foreach[/cmd](%y,[fnc]$keys[/fnc](%x))
{
[cmd]echo[/cmd] %y
}
[/example]
@seealso:
[fnc]$array[/fnc]
*/
KVSCF(hash)
{
#ifdef COMPILE_NEW_KVS
KviKvsHash * a = new KviKvsHash();
for(KviKvsVariant * key = KVSCF_pParams->first();key;key = KVSCF_pParams->next())
{
KviKvsVariant * val = KVSCF_pParams->next();
if(!val)break;
TQString sz;
key->asString(sz);
a->set(sz,new KviKvsVariant(*val));
}
KVSCF_pRetBuffer->setHash(a);
#endif
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: hextoAscii
@type:
function
@title:
$hexToAscii
@short:
Returns a decoded hex string
@syntax:
$hexToAscii(<hex_encoded_string>)
@description:
Decodes the <hex_encoded_string> to its ASCII representation.
@examples:
[example]
[cmd]echo[/cmd] $hexToAscii(6B76697263)
[/example]
@seealso:
[fnc]$asciiToHex[/fnc]
*/
KVSCF(hexToAscii)
{
TQString szHex;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("hex_encoded_string",KVS_PT_STRING,0,szHex)
KVSCF_PARAMETERS_END
KviStr tmp1(szHex);
char * buf;
int len = tmp1.hexToBuffer(&buf,true);
KVSCF_pRetBuffer->setString(TQString(KviTQCString(buf,len+1)));
KviStr::freeBuffer(buf);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: hostname
@type:
function
@title:
$hostname
@short:
Returns the hostname of the specified user
@syntax:
<string> $hostname(<nickname:string>)
@description:
Returns the hostname of the specified IRC user IF it is known.[br]
The hostname is known if [fnc]$isWellKnown[/fnc] returns 1.[br]
The hostname is generally known if the user is on a channel with you
or has an open query with you.[br]
Detailed explaination:[br]
KVIrc has an internal database of users that are currently
visible by *this client*: this includes users on open channels
and queries.[br] The other IRC users are NOT in the database:
this means that KVIrc knows NOTHING about them and can't return
any information immediately. In this case this function will return
an EMPTY string.[br]
If a user is in the database, at least his nickname is known.[br]
The username and hostname are known only if the server provides that information
spontaneously or after a KVIrc request.[br]
KVIrc requests user information for all the users in open queries
and channels. This information takes some time to be retrieved,
in this interval of time KVIrc knows only the user's nickname.
This function will return the string "*" in this case.[br]
@seealso:
[fnc]$isWellKnown[/fnc], [fnc]$username[/fnc], [cmd]awhois[/cmd]
*/
KVSCF(hostname)
{
TQString szNick;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("nick",KVS_PT_NONEMPTYSTRING,0,szNick)
KVSCF_PARAMETERS_END
if(KVSCF_pContext->window()->console())
{
if(KVSCF_pContext->window()->console()->isConnected())
{
KviIrcUserEntry * e = KVSCF_pContext->window()->connection()->userDataBase()->find(szNick);
if(e)
{
KVSCF_pRetBuffer->setString(e->host());
return true;
}
}
}
KVSCF_pRetBuffer->setNothing();
return true;
}
//-------------------------------------------------
/*
@doc: lag
@type:
function
@title:
$lag
@short:
Returns the lag on the current server
@syntax:
<integer> lag
@description:
This function returns the lag in the current server, in milliseconds.[br]
*/
KVSCF(lag)
{
if(!KVSCF_pContext->window()->console()) return KVSCF_pContext->errorNoIrcContext();
if(!KVSCF_pContext->window()->console()->connection()) return KVSCF_pContext->warningNoIrcConnection();
if(!KVSCF_pContext->window()->console()->connection()->lagMeter())
{
KVSCF_pContext->warning(__tr2qs("Lag meter was not enabled"));
return false;
}
KVSCF_pRetBuffer->setInteger( KVSCF_pContext->window()->console()->connection()->lagMeter()->lag());
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: hptimestamp
@type:
function
@title:
$hptimestamp
@short:
Returns a high precision timestamp
@syntax:
<float> $hptimestamp
@description:
Returns a high precision timestamp as a floaint point value.
The timestamp rappresent the number of seconds elapsed since
a certain moment in the past. The number of seconds
contains a "high precision" fractional part. The "certain moment" definition
depends on the platform KVIrc is executed. This means that
this timestamp is totally useless to rappresent a time value
but is useful to compute time intervals with sub-second precision.
@examples:
[example]
%tmp = $hptimestamp
[cmd]echo[/cmd] $($hptimestamp - %tmp)
[/example]
@seealso:
[fnc]$unixTime[/fnc], [fnc]$date[/fnc]
*/
KVSCF(hptimestamp)
{
struct timeval tv;
kvi_gettimeofday(&tv,0);
kvs_real_t dTimestamp = (kvs_real_t)(tv.tv_sec);
dTimestamp += (((kvs_real_t)(tv.tv_usec)) / 1000000.0);
KVSCF_pRetBuffer->setReal(dTimestamp);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: icon
@type:
function
@title:
$icon
@short:
Returns the ID of an icon
@syntax:
<integer> $icon(<iconname:string>)
@description:
Returns the ID of the icon <iconname>.
You should always use this function where an <image_id> is required
and you want to use an internal icon.
See [fnc]$iconname[/fnc] for a list of the icon names supported by kvirc.[br]
@examples:
[example]
[cmd]echo[/cmd] $icon(linux)
[/example]
@seealso:
[fnc]$iconName[/fnc]
*/
KVSCF(icon)
{
TQString szName;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("iconName",KVS_PT_NONEMPTYSTRING,0,szName)
KVSCF_PARAMETERS_END
KVSCF_pRetBuffer->setInteger(g_pIconManager->getSmallIconIdFromName(szName));
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: iconname
@type:
function
@title:
$iconname
@short:
Returns the name of an icon
@syntax:
$iconname(<iconid>)
@description:
Returns the name of a builtin icon given an <iconid>.
The <iconid> is returned by the function [fnc]$icon[/fnc].
If the <iconid> is not valid, an empty name is returned.[br]
The following code will list all the available icon names:[br]
[example]
%i = 0
[cmd]do[/cmd] {
%name = $iconname(%i)
echo The icon by ID %i is named %name
%i++
} [cmd]while[/cmd](%name != "")
[/example]
@examples:
[example]
[cmd]echo[/cmd] $iconname(24)
[cmd]echo[/cmd] $iconname([fnc]$icon[/fnc](linux))
[/example]
@seealso:
[fnc]$iconName[/fnc]
*/
KVSCF(iconName)
{
kvs_uint_t uIco;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("iconid",KVS_PT_UINT,0,uIco)
KVSCF_PARAMETERS_END
if(uIco < KVI_NUM_SMALL_ICONS)
{
KVSCF_pRetBuffer->setString(g_pIconManager->getSmallIconName(uIco));
} else {
KVSCF_pRetBuffer->setNothing();
}
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: integer
@type:
function
@title:
$integer
@short:
Casts a variable to an integer
@syntax:
<integer> $integer(<data:variant>)
@description:
Forces <data> to be an integer data type with the following
semantics:[br]
[ul]
[li]If <data> is an integer, <data> itself is returned.[/li]
[li]If <data> is a boolean, its numeric value is returned (either 1 or 0).[/li]
[li]If <data> is a real, its integer part is returned.[/li]
[li]If <data> is an array, the count of its items is returned.[/li]
[li]If <data> is a hash, the count of its items is returned.[/li]
[li]If <data> is a string, its length is returned.[/li]
[li]If <data> is an object, 0 is returned if the reference is null (invalid) and 1 otherwise[/li]
[/ul]
This function is similar to the C (int) cast and is internally
aliased to [fnc]$int[/fnc]() too.
Note that since KVIrc does most of the casting work automatically
you shouldn't need to use this function.
@seealso:
[fnc]$real[/fnc]
[fnc]$boolean[/fnc]
*/
/*
@doc: int
@type:
function
@title:
$int
@short:
Casts a variable to an integer
@syntax:
<integer> $int(<data:variant>)
@description:
This is an internal alias to [fnc]$integer[/fnc]().
@seealso:
[fnc]$real[/fnc]
[fnc]$boolean[/fnc]
*/
KVSCF(integer)
{
KviKvsVariant * v;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("data",KVS_PT_VARIANT,0,v)
KVSCF_PARAMETERS_END
kvs_int_t iVal;
v->castToInteger(iVal);
KVSCF_pRetBuffer->setInteger(iVal);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: isMainWindowActive
@type:
function
@title:
$isMainWindowActive
@short:
Checks if main KVirc window is active
@syntax:
<boolean> $isMainWindowActive()
@description:
Returns true if the KVIrc's window is currently
the active window on the current desktop.
*/
KVSCF(isMainWindowActive)
{
KVSCF_pRetBuffer->setBoolean(g_pFrame->isActiveWindow());
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: isMainWindowMinimized
@type:
function
@title:
$isMainWindowMinimized
@short:
Checks if main KVirc window is minimized
@syntax:
<boolean> $isMainWindowMinimized()
@description:
Returns true if main KVirc window is minimized and false otherwise.
*/
KVSCF(isMainWindowMinimized)
{
KVSCF_pRetBuffer->setBoolean(g_pFrame->isMinimized());
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: isempty
@type:
function
@title:
$isEmpty
@short:
Checks if a variable is set (empty or non empty)
@syntax:
<boolean> $isEmpty(<data:variant>)
@description:
Returns 0 if <data> is actually set to some non-empty value
and 1 otherwise. Since KVIrc treats unset variables as empty
ones then this function is the exact opposite of [fnc]$isSet[/fnc].
@seealso:
[fnc]$isSet[/fnc]
*/
KVSCF(isEmpty)
{
#ifdef COMPILE_NEW_KVS
KviKvsVariant * v;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("data",KVS_PT_VARIANT,0,v)
KVSCF_PARAMETERS_END
KVSCF_pRetBuffer->setBoolean(v->isEmpty());
#endif
return true;
}
//FIXME: documentation
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: iseventenabled
@type:
function
@title:
$isEventEnabled
@short:
Checks if an event enabled
@syntax:
<boolean> $isEventEnabled(<event_name:string>,<handler_name:string>)
@description:
Returns 1 if the event handler enabled
*/
///////////////////////////////////////////////////////////////////////////////////////////////
KVSCF(isEventEnabled)
{
TQString szEventName,szHandlerName;
KviKvsScriptEventHandler *h=0;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("event_name",KVS_PT_NONEMPTYSTRING,0,szEventName)
KVSCF_PARAMETER("handler_name",KVS_PT_NONEMPTYSTRING,0,szHandlerName)
KVSCF_PARAMETERS_END
bool bOk;
int iNumber = szEventName.toInt(&bOk);
bool bIsRaw = (bOk && (iNumber >= 0) && (iNumber < 1000));
if(bIsRaw)
{
if(!KviKvsEventManager::instance()->isValidRawEvent(iNumber))
{
KVSCF_pContext->warning(__tr2qs("No such event (%Q)"),&szEventName);
} else {
h=KviKvsEventManager::instance()->findScriptRawHandler(iNumber,szHandlerName);
}
} else {
iNumber = KviKvsEventManager::instance()->findAppEventIndexByName(szEventName);
if(!KviKvsEventManager::instance()->isValidAppEvent(iNumber))
{
KVSCF_pContext->warning(__tr2qs("No such event (%Q)"),&szEventName);
} else {
h=KviKvsEventManager::instance()->findScriptAppHandler(iNumber,szHandlerName);
}
}
if(h)
KVSCF_pRetBuffer->setBoolean(h->isEnabled());
else
KVSCF_pContext->warning(__tr2qs("No such event handler (%Q) for event %Q"),&szHandlerName,&szEventName);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: isnumeric
@type:
function
@title:
$isNumeric
@syntax:
<boolean> $isNumeric(<data:variant>)
@short:
Finds whether a variable contains a rappresentation of a number
@description:
Returns 1 if the <data> is an integer or a real number, 0 otherwise.
*/
KVSCF(isNumeric)
{
#ifdef COMPILE_NEW_KVS
KviKvsVariant * v;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("data",KVS_PT_VARIANT,0,v)
KVSCF_PARAMETERS_END
KviKvsNumber n;
KVSCF_pRetBuffer->setBoolean(v->asNumber(n));
#endif
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: isset
@type:
function
@title:
$isSet
@short:
Checks if a variable is set (non-empty)
@syntax:
<boolean> $isSet(<data:variant>)
@description:
Returns 1 if <data> is actually set to some non-empty value
and 0 otherwise. If <data> is a variable , then this function
simply checks if the variable is set. If <data> is a constant
then this function checks if the constant is non empty.
Since KVIrc treats empty strings as "unset" values then
this function could be also called "isNonEmpty" and it is
the perfect opposite of [fnc]$isEmpty[/fnc]
@seealso:
[fnc]$isEmpty[/fnc], [cmd]unset[/cmd]
*/
KVSCF(isSet)
{
#ifdef COMPILE_NEW_KVS
KviKvsVariant * v;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("data",KVS_PT_VARIANT,0,v)
KVSCF_PARAMETERS_END
KVSCF_pRetBuffer->setBoolean(!v->isEmpty());
#endif
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: istimer
@type:
function
@title:
$isTimer
@short:
Checks for a timer existence
@syntax:
<boolean> $istimer(<name:string>)
@description:
Returns 1 if the timer named <name> is actually running, else 0
@seealso:
[cmd]timer[/cmd], [cmd]killtimer[/cmd]
*/
KVSCF(isTimer)
{
TQString szName;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("timerName",KVS_PT_NONEMPTYSTRING,0,szName)
KVSCF_PARAMETERS_END
KVSCF_pRetBuffer->setBoolean(KviKvsTimerManager::instance()->timerExists(szName));
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: iswellknown
@type:
function
@title:
$isWellKnown
@short:
Returns $true if the specified user is well known
@syntax:
<bool> $isWellKnown(<nickname:string>)
@description:
Returns 1 if KVIrc has the basic user information about the specified <nickname>.[br]
The basic information include the username and hostname.[br]
This is almost always true if the user is on a channel with you or
you have an open query with him.[br]
If $isWellKnown returns 0, [fnc]$username[/fnc] and [fnc]$hostname[/fnc]
will return empty strings.[br]
In this case you must use [cmd]awhois[/cmd] to obtain the user basic information.[br]
*/
KVSCF(isWellKnown)
{
TQString szNick;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("nick",KVS_PT_NONEMPTYSTRING,0,szNick)
KVSCF_PARAMETERS_END
if(KVSCF_pContext->window()->console())
{
if(KVSCF_pContext->window()->console()->isConnected())
{
KviIrcUserEntry * e = KVSCF_pContext->window()->connection()->userDataBase()->find(szNick);
if(e)
{
KVSCF_pRetBuffer->setBoolean(e->hasHost() && e->hasUser());
return true;
}
}
}
KVSCF_pRetBuffer->setBoolean(false);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: k
@type:
function
@title:
$k
@short:
Returns the COLOR mIRC control character
@syntax:
<string> $k(<foreground:integer>[,<background:integer>])
<string> $k
@description:
Returns the COLOR mIRC control character (TQt::CTRL+K).[br]
If <foreground> and <background> are passed, a standard mIRC
color escape is returned.[br]
@seealso:
[fnc]$b[/fnc]
*/
KVSCF(k)
{
kvs_uint_t iFore,iBack;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("foreground",KVS_PT_UINT,KVS_PF_OPTIONAL,iFore)
KVSCF_PARAMETER("background",KVS_PT_UINT,KVS_PF_OPTIONAL,iBack)
KVSCF_PARAMETERS_END
TQString szRet = TQChar(KVI_TEXT_COLOR);
if(KVSCF_pParams->count() > 0)
{
KviTQString::appendFormatted(szRet,"%u",iFore);
if(KVSCF_pParams->count() > 1)
KviTQString::appendFormatted(szRet,",%u",iBack);
}
KVSCF_pRetBuffer->setString(szRet);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: keys
@type:
function
@title:
$keys
@short:
Returns the array of keys of a hash
@syntax:
<array> $keys(<hash_value:hash>)
@description:
Returns an array with the keys of the <hash> parameter.
<hash> must be obviously a hash (or eventually an empty variable
that is treated as an empty hash).
@seealso:
[cmd]foreach[/cmd]
*/
KVSCF(keys)
{
#ifdef COMPILE_NEW_KVS
KviKvsHash * pHash;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("hash",KVS_PT_HASH,0,pHash)
KVSCF_PARAMETERS_END
KviKvsArray * a = new KviKvsArray();
kvs_int_t idx = 0;
KviKvsHashIterator it(*(pHash->dict()));
while(it.current())
{
a->set(idx,new KviKvsVariant(it.currentKey()));
idx++;
++it;
}
KVSCF_pRetBuffer->setArray(a);
#endif
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: lang
@type:
function
@title:
$lang
@short:
Returns name of currently used language
@syntax:
<string> $lang([<type:string>])
@description:
Returns the short name of currently used language
Type <type> should be one of: [br]
"full" - returns full locale name, such as ru_RU.UTF-8 (default)
"lang" - return language name, such as "ru_RU"
"short" - returns only language group such as "ru"
*/
KVSCF(lang)
{
TQString szType;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("type",KVS_PT_NONEMPTYSTRING,KVS_PF_OPTIONAL,szType)
KVSCF_PARAMETERS_END
TQString szLocale(KviLocale::localeName().ptr());
if(szType=="lang") KVSCF_pRetBuffer->setString(szLocale.left(5));
else if(szType=="short") KVSCF_pRetBuffer->setString(szLocale.left(2));
else KVSCF_pRetBuffer->setString(szLocale);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: length
@type:
function
@title:
$length
@short:
Returns the length of a variable
@syntax:
<integer> $length(<value:variant>)
@description:
When <value> is an array or a hash, it returns the number
of its elements. When <value> is an object reference it returns 0.
In all the other cases <value> is interpreted
as a string and its length is returned.
@seealso:
[fnc]$str.len[/fnc]
*/
KVSCF(length)
{
KviKvsVariant * pVar;
KVSCF_PARAMETERS_BEGIN
KVSCF_PARAMETER("value",KVS_PT_VARIANT,0,pVar)
KVSCF_PARAMETERS_END
switch(pVar->type())
{
case KviKvsVariantData::Array:
KVSCF_pRetBuffer->setInteger(pVar->array()->size());
break;
case KviKvsVariantData::Hash:
KVSCF_pRetBuffer->setInteger(pVar->hash()->size());
break;
case KviKvsVariantData::HObject:
KVSCF_pRetBuffer->setInteger(0);
break;
default:
{
TQString tmp;
pVar->asString(tmp);
KVSCF_pRetBuffer->setInteger(tmp.length());
}
break;
}
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/*
@doc: lf
@type:
function
@title:
$lf
@short:
Returns a line feed character
@syntax:
<string> $lf
@description:
Returns a line feed character
@seealso:
[fnc]$cr[/fnc], [fnc]$ascii[/fnc], [fnc]$char[/fnc]
*/
KVSCF(lf)
{
KVSCF_pRetBuffer->setString(TQString(TQChar('\n')));
return true;
}
};
View Git Blame Copy Permalink