|
|
|
//=============================================================================
|
|
|
|
//
|
|
|
|
// File : libkviobjects.cpp
|
|
|
|
// Creation date : Wed Sep 09 2000 20:59:01 by Szymon Stefanek
|
|
|
|
//
|
|
|
|
// This file is part of the KVirc irc client distribution
|
|
|
|
// Copyright (C) 2000-2006 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.
|
|
|
|
//
|
|
|
|
//=============================================================================
|
|
|
|
|
|
|
|
#include "kvi_tal_listview.h"
|
|
|
|
#include <tqimage.h>
|
|
|
|
#include "kvi_iconmanager.h"
|
|
|
|
#include "kvi_window.h"
|
|
|
|
#include "kvi_out.h"
|
|
|
|
#include "kvi_mirccntrl.h"
|
|
|
|
|
|
|
|
#include "kvi_app.h"
|
|
|
|
|
|
|
|
#include "kvi_module.h"
|
|
|
|
|
|
|
|
#include "kvi_locale.h"
|
|
|
|
#include "kvi_error.h"
|
|
|
|
#include "kvi_cmdformatter.h"
|
|
|
|
#include "kvi_out.h"
|
|
|
|
#include "kvi_app.h"
|
|
|
|
#include "kvi_fileutils.h"
|
|
|
|
#ifndef COMPILE_USE_QT4
|
|
|
|
#include <tqwidgetlist.h>
|
|
|
|
#include <tqobjectlist.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <tqdir.h>
|
|
|
|
|
|
|
|
#include "class_button.h"
|
|
|
|
#include "class_checkbox.h"
|
|
|
|
#include "class_urllabel.h"
|
|
|
|
#include "class_lineedit.h"
|
|
|
|
#include "class_multilineedit.h"
|
|
|
|
#include "class_combobox.h"
|
|
|
|
#include "class_widget.h"
|
|
|
|
#include "class_list.h"
|
|
|
|
#include "class_file.h"
|
|
|
|
#include "class_socket.h"
|
|
|
|
#include "class_layout.h"
|
|
|
|
#include "class_menubar.h"
|
|
|
|
#include "class_window.h"
|
|
|
|
#include "class_listbox.h"
|
|
|
|
#include "class_progressbar.h"
|
|
|
|
#include "class_slider.h"
|
|
|
|
#include "class_spinbox.h"
|
|
|
|
#include "class_lcd.h"
|
|
|
|
#include "class_radiobutton.h"
|
|
|
|
#include "class_process.h"
|
|
|
|
#include "class_groupbox.h"
|
|
|
|
#include "class_buttongroup.h"
|
|
|
|
#include "class_tabwidget.h"
|
|
|
|
#include "class_workspace.h"
|
|
|
|
#include "class_popupmenu.h"
|
|
|
|
#include "class_listview.h"
|
|
|
|
#include "class_listviewitem.h"
|
|
|
|
#include "class_toolbar.h"
|
|
|
|
#include "class_mainwindow.h"
|
|
|
|
#include "class_toolbutton.h"
|
|
|
|
#include "class_wizard.h"
|
|
|
|
#include "class_tbrowser.h"
|
|
|
|
#include "class_painter.h"
|
|
|
|
#include "class_pixmap.h"
|
|
|
|
#include "class_wrapper.h"
|
|
|
|
#include "class_dialog.h"
|
|
|
|
#include "class_xmlreader.h"
|
|
|
|
#include "class_dockwindow.h"
|
|
|
|
#include "class_vbox.h"
|
|
|
|
#include "class_hbox.h"
|
|
|
|
static void dumpChildObjects(KviWindow *pWnd, TQObject *parent, const char *spacing, bool bWidgetsOnly, KviKvsArray *n, int &idx);
|
|
|
|
|
|
|
|
static bool objects_module_cleanup(KviModule *m)
|
|
|
|
{
|
|
|
|
KviKvsObject_process::unregisterSelf();
|
|
|
|
KviKvsObject_socket::unregisterSelf();
|
|
|
|
KviKvsObject_xmlreader::unregisterSelf();
|
|
|
|
KviKvsObject_wrapper::unregisterSelf();
|
|
|
|
KviKvsObject_file::unregisterSelf();
|
|
|
|
KviKvsObject_progressbar::unregisterSelf();
|
|
|
|
KviKvsObject_dockwindow::unregisterSelf();
|
|
|
|
KviKvsObject_wizard::unregisterSelf();
|
|
|
|
KviKvsObject_window::unregisterSelf();
|
|
|
|
KviKvsObject_urlabel::unregisterSelf();
|
|
|
|
KviKvsObject_toolbutton::unregisterSelf();
|
|
|
|
KviKvsObject_toolbar::unregisterSelf();
|
|
|
|
KviKvsObject_tabwidget::unregisterSelf();
|
|
|
|
KviKvsObject_spinbox::unregisterSelf();
|
|
|
|
KviKvsObject_slider::unregisterSelf();
|
|
|
|
KviKvsObject_radiobutton::unregisterSelf();
|
|
|
|
KviKvsObject_popupmenu::unregisterSelf();
|
|
|
|
KviKvsObject_pixmap::unregisterSelf();
|
|
|
|
KviKvsObject_painter::unregisterSelf();
|
|
|
|
KviKvsObject_mainwindow::unregisterSelf();
|
|
|
|
KviKvsObject_listviewitem::unregisterSelf();
|
|
|
|
KviKvsObject_listview::unregisterSelf();
|
|
|
|
KviKvsObject_listbox::unregisterSelf();
|
|
|
|
KviKvsObject_combobox::unregisterSelf();
|
|
|
|
KviKvsObject_workspace::unregisterSelf();
|
|
|
|
KviKvsObject_menubar::unregisterSelf();
|
|
|
|
KviKvsObject_lineedit::unregisterSelf();
|
|
|
|
KviKvsObject_lcd::unregisterSelf();
|
|
|
|
KviKvsObject_layout::unregisterSelf();
|
|
|
|
KviKvsObject_hbox::unregisterSelf();
|
|
|
|
KviKvsObject_vbox::unregisterSelf();
|
|
|
|
KviKvsObject_label::unregisterSelf();
|
|
|
|
KviKvsObject_buttongroup::unregisterSelf();
|
|
|
|
KviKvsObject_groupbox::unregisterSelf();
|
|
|
|
KviKvsObject_dialog::unregisterSelf();
|
|
|
|
KviKvsObject_checkbox::unregisterSelf();
|
|
|
|
KviKvsObject_textbrowser::unregisterSelf();
|
|
|
|
KviKvsObject_mledit::unregisterSelf();
|
|
|
|
KviKvsObject_button::unregisterSelf();
|
|
|
|
KviKvsObject_widget::unregisterSelf();
|
|
|
|
KviKvsObject_list::unregisterSelf();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool objects_kvs_cmd_killClass(KviKvsModuleCommandCall * c)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
@doc: objects.killclass
|
|
|
|
@title:
|
|
|
|
objects.killclass
|
|
|
|
@type:
|
|
|
|
command
|
|
|
|
@short:
|
|
|
|
Removes a class definition
|
|
|
|
@syntax:
|
|
|
|
objects.killclass [-q] <classname:string>
|
|
|
|
@switches:
|
|
|
|
!sw: -q | --quiet
|
|
|
|
Suppresses any warning message
|
|
|
|
@description:
|
|
|
|
Removes the definition of the class <class_name>.[br]
|
|
|
|
All the instances of the class are killed (thus tqchildren objects are killed too).[br]
|
|
|
|
All the derived class definitions are removed as well.[br]
|
|
|
|
Builtin class definitions cannot be removed and this commands
|
|
|
|
kills only all the instances of that class (derived class definitions
|
|
|
|
and instances in this case are NOT killed).[br]
|
|
|
|
@seealso:
|
|
|
|
[cmd]class[/cmd], [cmd]objects.clear[/cmd], [fnc]$classDefined[/fnc](),
|
|
|
|
[doc:objects]Objects documentation[/doc]
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
TQString szClass;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
|
|
KVSM_PARAMETER("class",KVS_PT_NONEMPTYSTRING,0,szClass)
|
|
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviKvsObjectClass * pClass=KviKvsKernel::instance()->objectController()->lookupClass(szClass);
|
|
|
|
if(pClass)
|
|
|
|
{
|
|
|
|
if(pClass->isBuiltin())
|
|
|
|
{
|
|
|
|
KviKvsKernel::instance()->objectController()->killAllObjectsWithClass(pClass);
|
|
|
|
} else {
|
|
|
|
KviKvsKernel::instance()->objectController()->deleteClass(pClass); //Yahoo!!
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(!c->hasSwitch('q',"quiet"))c->warning(__tr2qs("Class '%Q' is not definited"),&szClass);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool objects_kvs_cmd_clearObjects(KviKvsModuleCommandCall * c)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
@doc: objects.clear
|
|
|
|
@title:
|
|
|
|
objects.clear
|
|
|
|
@type:
|
|
|
|
command
|
|
|
|
@short:
|
|
|
|
Removes all the user class definitions
|
|
|
|
@syntax:
|
|
|
|
objects.clear [-i]
|
|
|
|
@description:
|
|
|
|
Removes the definition of all the user classes and kill all the object
|
|
|
|
instances (also instances of the builtin classes).[br]
|
|
|
|
If the -i switch is used, only the object instances are cleared
|
|
|
|
but the class definitions are left unchanged.[br]
|
|
|
|
This command should be used only for debugging & testing purposes
|
|
|
|
and in particular should be NEVER used from inside an object
|
|
|
|
function handler (leads to SIGSEGV :).[br]
|
|
|
|
@seealso:
|
|
|
|
[cmd]class[/cmd], [cmd]objects.killclass[/cmd],
|
|
|
|
[doc:objects]Objects documentation[/doc]
|
|
|
|
*/
|
|
|
|
|
|
|
|
KviKvsKernel::instance()->objectController()->clearInstances();
|
|
|
|
if(!c->switches()->find('i',"ii")) KviKvsKernel::instance()->objectController()->clearUserClasses();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool objects_kvs_cmd_connect(KviKvsModuleCommandCall * c)
|
|
|
|
{
|
|
|
|
|
|
|
|
/*
|
|
|
|
@doc: objects.connect
|
|
|
|
@title:
|
|
|
|
objects.connect
|
|
|
|
@type:
|
|
|
|
command
|
|
|
|
@short:
|
|
|
|
Connects a signal to a slot
|
|
|
|
@syntax:
|
|
|
|
objects.connect <source_object:hobject> <signal_name:string> <target_object:hobject> <slot_name:string>
|
|
|
|
@description:
|
|
|
|
Connects the <source_object>'s signal <signal_name> to the
|
|
|
|
<target_object>'s slot <slot_name>.
|
|
|
|
When one of the two objects is destroyed, the signal/slot
|
|
|
|
connection is automatically removed.[br]
|
|
|
|
WARNING: This command name collides with the [doc:rfc2812]RFC2812[/doc]
|
|
|
|
CONNECT IRC Op command: this IRC command is available to operators only
|
|
|
|
and is rather rarely used: you can use it by the means of [doc:raw]raw[/doc].
|
|
|
|
@seealso:
|
|
|
|
[cmd]class[/cmd], [cmd]object.disconnect[/cmd], [doc:objects]objects documentation[/doc]
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
KviKvsObject *obSrc;
|
|
|
|
KviKvsObject *obTrg;
|
|
|
|
TQString szSignal,szSlot;
|
|
|
|
kvs_hobject_t hSrc,hTrg;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
|
|
KVSO_PARAMETER("object source",KVS_PT_HOBJECT,0,hSrc)
|
|
|
|
KVSM_PARAMETER("signal name",KVS_PT_NONEMPTYSTRING,0,szSignal)
|
|
|
|
KVSO_PARAMETER("object target",KVS_PT_HOBJECT,0,hTrg)
|
|
|
|
KVSM_PARAMETER("slot",KVS_PT_NONEMPTYSTRING,0,szSlot)
|
|
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
obTrg=KviKvsKernel::instance()->objectController()->lookupObject(hTrg);
|
|
|
|
obSrc=KviKvsKernel::instance()->objectController()->lookupObject(hSrc);
|
|
|
|
if(!obTrg)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Inexisting target object for objects.connect"));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if(!obSrc)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Inexisting source object for objects.connect"));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
obSrc->connectSignal(szSignal,obTrg,szSlot);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool objects_kvs_fnc_exists(KviKvsModuleFunctionCall * c)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
@doc: objects.exists
|
|
|
|
@title:
|
|
|
|
objects.exists
|
|
|
|
@type:
|
|
|
|
command
|
|
|
|
@short:
|
|
|
|
Check if an object exists.
|
|
|
|
@syntax:
|
|
|
|
<boolean> $object.exists(<obejct id:hobject>)
|
|
|
|
@description:
|
|
|
|
Check if an objects exists and return a boolean value.
|
|
|
|
@seealso:
|
|
|
|
[doc:objects]objects documentation[/doc]
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
kvs_hobject_t hObj;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
|
|
KVSO_PARAMETER("object",KVS_PT_HOBJECT,0,hObj)
|
|
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviKvsObject *ob=KviKvsKernel::instance()->objectController()->lookupObject(hObj);
|
|
|
|
c->returnValue()->setBoolean(ob ? true : false);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool objects_kvs_fnc_instances(KviKvsModuleFunctionCall * c)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
@doc: objects.instances
|
|
|
|
@title:
|
|
|
|
objects.instances
|
|
|
|
@type:
|
|
|
|
command
|
|
|
|
@short:
|
|
|
|
List object instances
|
|
|
|
@syntax:
|
|
|
|
<array> $object.instances(<class name:string>[,<flags:string>])
|
|
|
|
@description:
|
|
|
|
Returns an array with the instance handles of
|
|
|
|
of objects of the specified class. <flags> is a
|
|
|
|
string containing modifiers for the function behaviour.[br]
|
|
|
|
If <flags> contains the letter "s" then
|
|
|
|
only unsubclassed instances of the specified
|
|
|
|
class are returned. This means that if B is
|
|
|
|
a subclass of A then when asked for instances
|
|
|
|
of A without the flag "s" this function will return
|
|
|
|
both instances of A and B, and with the flag "s"
|
|
|
|
this function will return only instances of A (and not B).
|
|
|
|
If the class name does not define a valid class
|
|
|
|
then an empty array is returned and a warning is
|
|
|
|
printed unless the "q" flag is used.
|
|
|
|
@examples:
|
|
|
|
[example]
|
|
|
|
foreach(%x,$objects.instances(object))
|
|
|
|
{
|
|
|
|
echo "OBJECT WITH CLASS" %x->$className() "AND NAME \""%x->$name()"\""
|
|
|
|
}
|
|
|
|
[/example]
|
|
|
|
@seealso:
|
|
|
|
[doc:objects]objects documentation[/doc]
|
|
|
|
*/
|
|
|
|
|
|
|
|
TQString szClassName;
|
|
|
|
TQString szFlags;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
|
|
KVSO_PARAMETER("class name",KVS_PT_NONEMPTYSTRING,0,szClassName)
|
|
|
|
KVSO_PARAMETER("flags",KVS_PT_STRING,KVS_PF_OPTIONAL,szFlags)
|
|
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
|
|
|
|
KviKvsArray * pArry = new KviKvsArray();
|
|
|
|
c->returnValue()->setArray(pArry);
|
|
|
|
|
|
|
|
KviKvsObjectClass * pClass = KviKvsKernel::instance()->objectController()->lookupClass(szClassName);
|
|
|
|
if(!pClass)
|
|
|
|
{
|
|
|
|
if(!szFlags.contains(TQChar('q')))
|
|
|
|
c->warning(__tr2qs("The class '%Q' does not exist"),&szClassName);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
KviPointerHashTable<void *,KviKvsObject> * od = KviKvsKernel::instance()->objectController()->objectDict();
|
|
|
|
|
|
|
|
KviPointerHashTableIterator<void *,KviKvsObject> it(*od);
|
|
|
|
kvs_uint_t uIdx = 0;
|
|
|
|
if(szFlags.contains(TQChar('s')))
|
|
|
|
{
|
|
|
|
while(KviKvsObject * ob = it.current())
|
|
|
|
{
|
|
|
|
if(ob->getExactClass() == pClass)
|
|
|
|
{
|
|
|
|
pArry->set(uIdx,new KviKvsVariant(ob->handle()));
|
|
|
|
uIdx++;
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
while(KviKvsObject * ob = it.current())
|
|
|
|
{
|
|
|
|
if(ob->inheritsClass(pClass))
|
|
|
|
{
|
|
|
|
pArry->set(uIdx,new KviKvsVariant(ob->handle()));
|
|
|
|
uIdx++;
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
@doc: objects.variables
|
|
|
|
@title:
|
|
|
|
objects.variables
|
|
|
|
@type:
|
|
|
|
command
|
|
|
|
@short:
|
|
|
|
List object's variables.
|
|
|
|
@syntax:
|
|
|
|
<hash> objects.variables(<hobject>)
|
|
|
|
@description:
|
|
|
|
Returns an hash with the object's variables(useful only for debugging).
|
|
|
|
@seealso:
|
|
|
|
[doc:objects]objects documentation[/doc]
|
|
|
|
*/
|
|
|
|
static bool objects_kvs_fnc_variables(KviKvsModuleFunctionCall * c)
|
|
|
|
{
|
|
|
|
kvs_hobject_t hObj;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
|
|
KVSO_PARAMETER("object",KVS_PT_HOBJECT,0,hObj)
|
|
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviKvsObject *ob=KviKvsKernel::instance()->objectController()->lookupObject(hObj);
|
|
|
|
if (!ob)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Object does not exists"));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
KviPointerHashTableIterator<TQString,KviKvsVariant> it(* ob->dataContainer()->dict());
|
|
|
|
KviKvsHash* pHash = new KviKvsHash();
|
|
|
|
c->returnValue()->setHash(pHash);
|
|
|
|
while(KviKvsVariant * t = it.current())
|
|
|
|
{
|
|
|
|
pHash->set(it.currentKey(),new KviKvsVariant(*t));
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
@doc: objects.classAllHandlers
|
|
|
|
@title:
|
|
|
|
objects.classAllHandlers
|
|
|
|
@type:
|
|
|
|
function
|
|
|
|
@short:
|
|
|
|
List all the functions .
|
|
|
|
@syntax:
|
|
|
|
<hash> objects.classAllHandlers(<class name:string>)
|
|
|
|
@description:
|
|
|
|
Returns an hash with the class's functions(useful only for debugging).
|
|
|
|
@seealso:
|
|
|
|
[doc:objects]objects documentation[/doc]
|
|
|
|
*/
|
|
|
|
static bool objects_kvs_fnc_classAllHandlers(KviKvsModuleFunctionCall * c)
|
|
|
|
{
|
|
|
|
TQString szClassName;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
|
|
KVSO_PARAMETER("class name",KVS_PT_NONEMPTYSTRING,0,szClassName)
|
|
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
KviKvsObjectClass * pClass = KviKvsKernel::instance()->objectController()->lookupClass(szClassName);
|
|
|
|
if(!pClass)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("The class '%Q' does not exist"),&szClassName);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
KviPointerHashTableIterator<TQString,KviKvsObjectFunctionHandler> it(* pClass->getHandlers());
|
|
|
|
KviKvsHash* pHash = new KviKvsHash();
|
|
|
|
c->returnValue()->setHash(pHash);
|
|
|
|
while(KviKvsObjectFunctionHandler * t = it.current())
|
|
|
|
{
|
|
|
|
TQString szCode;
|
|
|
|
KviKvsObjectFunctionHandler *handler=pClass->lookupFunctionHandler(it.currentKey());
|
|
|
|
pClass->getFunctionCode(szCode,*handler);
|
|
|
|
pHash->set(it.currentKey(),new KviKvsVariant(szCode));
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
static bool objects_kvs_fnc_classes(KviKvsModuleFunctionCall * c)
|
|
|
|
{
|
|
|
|
|
|
|
|
/*
|
|
|
|
@doc: objects.classes
|
|
|
|
@title:
|
|
|
|
objects.classes
|
|
|
|
@type:
|
|
|
|
command
|
|
|
|
@short:
|
|
|
|
List user defined classes
|
|
|
|
@syntax:
|
|
|
|
<array> $object.classes()
|
|
|
|
@description:
|
|
|
|
Returns an array with the user defined classes.
|
|
|
|
@seealso:
|
|
|
|
[doc:objects]objects documentation[/doc]
|
|
|
|
*/
|
|
|
|
|
|
|
|
KviKvsArray * pArry = new KviKvsArray();
|
|
|
|
c->returnValue()->setArray(pArry);
|
|
|
|
int uIdx=0;
|
|
|
|
KviPointerHashTableIterator<TQString,KviKvsObjectClass> it(*KviKvsKernel::instance()->objectController()->classDict());
|
|
|
|
KviPointerHashTable<TQString,bool> *classdict=new KviPointerHashTable<TQString,bool>;
|
|
|
|
classdict->setAutoDelete(false);
|
|
|
|
bool bFake=true;
|
|
|
|
while(KviKvsObjectClass * pClass=it.current())
|
|
|
|
{
|
|
|
|
if (!pClass->isBuiltin())classdict->insert(it.currentKey(),&bFake);
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
TQString szPath;
|
|
|
|
g_pApp->getLocalKvircDirectory(szPath,KviApp::Classes);
|
|
|
|
TQDir d(szPath);
|
|
|
|
TQStringList sl;
|
|
|
|
sl = d.entryList(TQDir::Files);
|
|
|
|
for(TQStringList::Iterator it2 = sl.begin();it2 != sl.end();++it2)
|
|
|
|
{
|
|
|
|
TQString szName=*it2;
|
|
|
|
szName.replace("--","::");
|
|
|
|
if (szName!=".." && szName!=".") classdict->insert(szName.left(szName.length()-4),&bFake);
|
|
|
|
}
|
|
|
|
KviKvsArray* pArray = new KviKvsArray();
|
|
|
|
c->returnValue()->setArray(pArray);
|
|
|
|
int idx=0;
|
|
|
|
KviPointerHashTableIterator<TQString,bool> strIt(*classdict);
|
|
|
|
while(strIt.current())
|
|
|
|
{
|
|
|
|
pArray->set(idx,new KviKvsVariant(strIt.currentKey()));
|
|
|
|
idx++;
|
|
|
|
++strIt;
|
|
|
|
}
|
|
|
|
delete classdict;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool objects_kvs_cmd_disconnect(KviKvsModuleCommandCall * c)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
@doc: objects.disconnect
|
|
|
|
@title:
|
|
|
|
objects.disconnect
|
|
|
|
@type:
|
|
|
|
command
|
|
|
|
@short:
|
|
|
|
Disconnects a signal from a slot
|
|
|
|
@syntax:
|
|
|
|
disconnect <source_object:hobject> <signal_name:string> <target_object:hobject> <slot_name:string>
|
|
|
|
@description:
|
|
|
|
Disconnects the <source_object>'s signal <signal_name> from the
|
|
|
|
<target_object>'s slot <slot_name>.
|
|
|
|
When one of the two objects is destroyed, the signal/slot
|
|
|
|
connection is automatically removed.
|
|
|
|
@seealso:
|
|
|
|
[cmd]class[/cmd], [cmd]objects.connect[/cmd], [doc:objects]objects documentation[/doc]
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
KviKvsObject *obSrc;
|
|
|
|
KviKvsObject *obTrg;
|
|
|
|
TQString szSignal,szSlot;
|
|
|
|
kvs_hobject_t hSrc,hTrg;
|
|
|
|
KVSM_PARAMETERS_BEGIN(c)
|
|
|
|
KVSO_PARAMETER("object source",KVS_PT_HOBJECT,0,hSrc)
|
|
|
|
KVSM_PARAMETER("signal name",KVS_PT_NONEMPTYSTRING,0,szSignal)
|
|
|
|
KVSO_PARAMETER("object target",KVS_PT_HOBJECT,0,hTrg)
|
|
|
|
KVSM_PARAMETER("slot",KVS_PT_NONEMPTYSTRING,0,szSlot)
|
|
|
|
KVSM_PARAMETERS_END(c)
|
|
|
|
obTrg=KviKvsKernel::instance()->objectController()->lookupObject(hTrg);
|
|
|
|
obSrc=KviKvsKernel::instance()->objectController()->lookupObject(hSrc);
|
|
|
|
if(!obTrg)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Inexisting target object for objects.disconnect"));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if(!obSrc)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Inexisting source object for objects.disconnect"));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
obSrc->disconnectSignal(szSignal,obTrg,szSlot);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool objects_kvs_cmd_bitBlt(KviKvsModuleCommandCall * c)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
@doc: objects.bitblt
|
|
|
|
@type:
|
|
|
|
command
|
|
|
|
@title:
|
|
|
|
objects.bitblt
|
|
|
|
@keyterms:
|
|
|
|
widget pixmap painter
|
|
|
|
@short:
|
|
|
|
Copies a block of pixels from a source to a destination.
|
|
|
|
@syntax:
|
|
|
|
objects.bitblt <source> <x> <y> <destination>
|
|
|
|
@description:
|
|
|
|
Copies a block of pixels from <source> to <destination> at the coordinates <x>,<y> .[br]
|
|
|
|
Source and destination must be a widget or pixmap.[br]
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
KviKvsObject *obSrc;
|
|
|
|
KviKvsObject *obDst;
|
|
|
|
kvs_int_t iXdst,iYdst,iXsrc,iYsrc,uW,uH;
|
|
|
|
kvs_hobject_t hDst,hSrc;
|
|
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
|
|
KVSO_PARAMETER("destination",KVS_PT_HOBJECT,0,hDst)
|
|
|
|
KVSO_PARAMETER("x offset dest",KVS_PT_INT,0,iXdst)
|
|
|
|
KVSO_PARAMETER("y offset dest",KVS_PT_INT,0,iYdst)
|
|
|
|
KVSO_PARAMETER("source",KVS_PT_HOBJECT,0,hSrc)
|
|
|
|
KVSO_PARAMETER("x offset source",KVS_PT_INT,0,iXsrc)
|
|
|
|
KVSO_PARAMETER("y offset source",KVS_PT_INT,0,iYsrc)
|
|
|
|
KVSO_PARAMETER("width",KVS_PT_UNSIGNEDINTEGER,0,uW)
|
|
|
|
KVSO_PARAMETER("height",KVS_PT_UNSIGNEDINTEGER,0,uH)
|
|
|
|
KVSO_PARAMETERS_END(c)
|
|
|
|
obSrc=KviKvsKernel::instance()->objectController()->lookupObject(hSrc);
|
|
|
|
if (!obSrc)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Source is not an object"));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
obDst=KviKvsKernel::instance()->objectController()->lookupObject(hDst);
|
|
|
|
if (!obDst)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Destination is not an object"));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
TQImage * imgSource=0;
|
|
|
|
TQPaintDevice * pdSource = 0;
|
|
|
|
|
|
|
|
if(obSrc->inherits("KviKvsObject_pixmap")) pdSource =TQT_TQPAINTDEVICE(((KviKvsObject_pixmap *)obSrc)->getPixmap());
|
|
|
|
else if (obSrc->inherits("KviKvsObject_widget")) pdSource=TQT_TQPAINTDEVICE(((KviKvsObject_widget *)obSrc)->widget());
|
|
|
|
if (!pdSource)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Widget, Image or Pixmap required "));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
TQPaintDevice * pdDest = 0;
|
|
|
|
if(obDst->inherits("KviKvsObject_pixmap")){
|
|
|
|
pdDest= TQT_TQPAINTDEVICE(((KviKvsObject_pixmap *)obDst)->getPixmap());
|
|
|
|
}
|
|
|
|
else if (obDst->inherits("KviKvsObject_widget")) pdDest=TQT_TQPAINTDEVICE(((KviKvsObject_widget *)obDst)->widget());
|
|
|
|
if (!pdDest)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Widget or Pixmap required"));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if(obDst->inherits("KviKvsObject_pixmap")){
|
|
|
|
((KviKvsObject_pixmap *)obDst)->pixmapChanged();
|
|
|
|
}
|
|
|
|
#ifdef COMPILE_USE_QT4
|
|
|
|
/*TQPainter p(pdDest);
|
|
|
|
TQRect rectdest(iXdst,iYdst,uW,uH);
|
|
|
|
TQRect rectsrc(iXsrc,iYsrc,uW,uH);
|
|
|
|
|
|
|
|
p.drawPixmap(rectdest,pdSource,rectsrc);
|
|
|
|
*/
|
|
|
|
#else
|
|
|
|
bitBlt(pdDest,iXdst,iYdst,pdSource,iXsrc,iYsrc,uW,uH);
|
|
|
|
#endif
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
@doc: objects.blend
|
|
|
|
@type:
|
|
|
|
command
|
|
|
|
@title:
|
|
|
|
objects.blend
|
|
|
|
@keyterms:
|
|
|
|
widget pixmap image
|
|
|
|
@short:
|
|
|
|
Blends two images to a destination.
|
|
|
|
@syntax:
|
|
|
|
objects.blend <background: image hobject> <x_offset_bkg:unsigned integer> <y_offset_bkg:unsigned integer>
|
|
|
|
<foreground: image hobject> <x_offset_fgr:unsigned integer> <y_offset_fgr:unsigned integer>
|
|
|
|
<destination: image, pixmap. widget hobject> <x_offset_dest:unsigned integer> <y_offset_dest:unsigned integer> <width:unsigned integer> <height:unsigned integer> <blend_factor>
|
|
|
|
@description:
|
|
|
|
Blends two images <background> and <foreground> and copy the result to <destination> at the coordinates <x_offset>,<y_offset> with a <blend_factor> value .[br]
|
|
|
|
Destination must be a widget or pixmap.[br]
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
static bool objects_kvs_cmd_blend(KviKvsModuleCommandCall * c)
|
|
|
|
{
|
|
|
|
|
|
|
|
KviKvsObject *obFor;
|
|
|
|
KviKvsObject *obBck;
|
|
|
|
KviKvsObject *obDest;
|
|
|
|
|
|
|
|
kvs_int_t iBkX,iBkY;
|
|
|
|
kvs_int_t iFoX,iFoY;
|
|
|
|
kvs_int_t iDesX,iDesY,uW,uH;
|
|
|
|
kvs_real_t dBlend;
|
|
|
|
|
|
|
|
kvs_hobject_t hBk,hFo,hDest;
|
|
|
|
|
|
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
|
|
KVSO_PARAMETER("destination",KVS_PT_HOBJECT,0,hDest)
|
|
|
|
KVSO_PARAMETER("x_offset_dest",KVS_PT_INT,0,iDesX)
|
|
|
|
KVSO_PARAMETER("y_offset_dest",KVS_PT_INT,0,iDesY)
|
|
|
|
|
|
|
|
KVSO_PARAMETER("image_background",KVS_PT_HOBJECT,0,hBk)
|
|
|
|
KVSO_PARAMETER("x_offset_background",KVS_PT_UNSIGNEDINTEGER,0,iBkX)
|
|
|
|
KVSO_PARAMETER("y_offset_background",KVS_PT_UNSIGNEDINTEGER,0,iBkY)
|
|
|
|
KVSO_PARAMETER("image_foreground",KVS_PT_HOBJECT,0,hFo)
|
|
|
|
KVSO_PARAMETER("x_offset_foreground",KVS_PT_UNSIGNEDINTEGER,0,iFoX)
|
|
|
|
KVSO_PARAMETER("y_offset_foreground",KVS_PT_UNSIGNEDINTEGER,0,iFoY)
|
|
|
|
KVSO_PARAMETER("width",KVS_PT_UNSIGNEDINTEGER,0,uW)
|
|
|
|
KVSO_PARAMETER("height",KVS_PT_UNSIGNEDINTEGER,0,uH)
|
|
|
|
|
|
|
|
KVSO_PARAMETER("blend_value",KVS_PT_REAL,0,dBlend)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
KVSO_PARAMETERS_END(c)
|
|
|
|
|
|
|
|
obFor=KviKvsKernel::instance()->objectController()->lookupObject(hFo);
|
|
|
|
|
|
|
|
|
|
|
|
obBck=KviKvsKernel::instance()->objectController()->lookupObject(hBk);
|
|
|
|
obDest=KviKvsKernel::instance()->objectController()->lookupObject(hDest);
|
|
|
|
if (!obFor || !obBck || !obDest)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("One o more of background, foreground or destination aren't objects"));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!obBck->inherits("KviKvsObject_pixmap") || !obFor->inherits("KviKvsObject_pixmap"))
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Pixmap objects required"));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
TQPaintDevice * pdDest = 0;
|
|
|
|
if(obDest->inherits("KviKvsObject_pixmap")) pdDest = TQT_TQPAINTDEVICE(((KviKvsObject_pixmap *)obDest)->getPixmap());
|
|
|
|
else if (obDest->inherits("KviKvsObject_widget")) pdDest=TQT_TQPAINTDEVICE(((KviKvsObject_widget *)obDest)->widget());
|
|
|
|
|
|
|
|
if (!pdDest)
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Widget or Pixmap required "));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(obDest->inherits("KviKvsObject_pixmap")) ((KviKvsObject_pixmap *)obDest)->pixmapChanged();
|
|
|
|
|
|
|
|
|
|
|
|
TQImage *img_back=((KviKvsObject_pixmap *)obBck)->getImage();
|
|
|
|
TQImage *img_fore=((KviKvsObject_pixmap *)obFor)->getImage();
|
|
|
|
|
|
|
|
// check size
|
|
|
|
if ((iBkX+uW>img_back->width())||(iBkY+uH>img_back->height()))
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Values for background are out of image size "));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if ((iFoX+uW>img_fore->width())||(iFoY+uH>img_fore->height()))
|
|
|
|
{
|
|
|
|
c->warning(__tr2qs("Values for foreground are out of image size "));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
TQImage buffer;
|
|
|
|
buffer.create(uW,uH,32);
|
|
|
|
buffer.setAlphaBuffer(true);
|
|
|
|
for(int y = 0;y < buffer.height();y++)
|
|
|
|
{
|
|
|
|
TQRgb * dst = (TQRgb *)buffer.scanLine(y);
|
|
|
|
TQRgb * end = dst + buffer.width();
|
|
|
|
TQRgb * bkg = (TQRgb *)img_back->scanLine(y+iBkY);
|
|
|
|
bkg += iBkX;
|
|
|
|
TQRgb * fgn = (TQRgb *)img_fore->scanLine(y+iFoY);
|
|
|
|
fgn += iFoX;
|
|
|
|
double dRemaining = 1.0 - dBlend;
|
|
|
|
int a=0;
|
|
|
|
while(dst < end)
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
*dst = tqRgba(
|
|
|
|
(int)((tqRed(*bkg) * dRemaining) + (tqRed(*fgn) * dBlend)),
|
|
|
|
(int)((tqGreen(*bkg) * dRemaining) + (tqGreen(*fgn) * dBlend)),
|
|
|
|
(int)((tqBlue(*bkg) * dRemaining) + (tqBlue(*fgn) * dBlend)),
|
|
|
|
(int)((tqAlpha(*bkg) * dRemaining) + (tqAlpha(*fgn) * dBlend))
|
|
|
|
);
|
|
|
|
|
|
|
|
dst++;
|
|
|
|
bkg++;
|
|
|
|
fgn++;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
#ifdef COMPILE_USE_QT4
|
|
|
|
TQPainter p(pdDest);
|
|
|
|
TQRect rect(iDesX,iDesY,buffer.width(),buffer.height());
|
|
|
|
p.drawImage(rect,buffer);
|
|
|
|
#else
|
|
|
|
bitBlt(pdDest,iDesX,iDesY,&buffer,0,0,buffer.width(),buffer.height());
|
|
|
|
#endif
|
|
|
|
return true;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// ASSASSINI! LA DOVETE INDENTARE PER BENE :D
|
|
|
|
|
|
|
|
|
|
|
|
static bool objects_kvs_fnc_listObjects(KviKvsModuleFunctionCall * cmd)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
@doc: objects.dump
|
|
|
|
@type:
|
|
|
|
function
|
|
|
|
@title:
|
|
|
|
$objects.dump
|
|
|
|
@keyterms:
|
|
|
|
dump objects
|
|
|
|
@short:
|
|
|
|
Dump the kvirc widgets.
|
|
|
|
@syntax:
|
|
|
|
$objects.dump(<flag b>)
|
|
|
|
@description:
|
|
|
|
This function returns the tree of the widgets of the kvirc, if the flag <b> is planned to 1,[br]
|
|
|
|
will return it on the currente window, if it' is planned to 0 instead it will return it as a string.[br]
|
|
|
|
ES:
|
|
|
|
%A[]=$str.split("\|",$objects.dump(0))
|
|
|
|
%i=0
|
|
|
|
while (%i != %A[]#)
|
|
|
|
{
|
|
|
|
echo %A[%i]
|
|
|
|
%i++
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
bool bFlag;
|
|
|
|
KVSO_PARAMETERS_BEGIN(cmd)
|
|
|
|
KVSO_PARAMETER("flag on video",KVS_PT_BOOL,0,bFlag)
|
|
|
|
KVSO_PARAMETERS_END(cmd)
|
|
|
|
if (bFlag) cmd->window()->output(80, "Objects dump:");
|
|
|
|
#ifdef COMPILE_USE_QT4
|
|
|
|
TQWidgetList list = g_pApp->tqtopLevelWidgets();
|
|
|
|
|
|
|
|
KviStr spacing = ">";
|
|
|
|
TQString szTemp;
|
|
|
|
KviKvsArray * n = new KviKvsArray();
|
|
|
|
int idx=0;
|
|
|
|
for(int i=0;i<list.count();i++)
|
|
|
|
{
|
|
|
|
if( list.at(i)->isWidgetType())
|
|
|
|
{
|
|
|
|
if (bFlag)
|
|
|
|
{
|
|
|
|
cmd->window()->output(80, "Ptr %u: top level object: %c%s%c, class %s, %s, rect = %d, %d, %d, %d",
|
|
|
|
list.at(i),
|
|
|
|
KVI_TEXT_BOLD, list.at(i)->name(), KVI_TEXT_BOLD,
|
|
|
|
list.at(i)->className(),
|
|
|
|
list.at(i)->isVisible() ? "visible" : "hidden",
|
|
|
|
list.at(i)->x(), list.at(i)->y(), list.at(i)->width(), list.at(i)->height());
|
|
|
|
}
|
|
|
|
TQString szClass=list.at(i)->className();
|
|
|
|
TQString szObj=list.at(i)->name();
|
|
|
|
TQString szTemp;
|
|
|
|
szTemp = szClass + "::" + szObj;
|
|
|
|
KviKvsVariant v;
|
|
|
|
v.setString(szTemp);
|
|
|
|
n->set(idx,new KviKvsVariant(v));
|
|
|
|
debug ("string %s",szTemp.latin1());
|
|
|
|
debug ("class %s",szClass.latin1());
|
|
|
|
debug ("Obj %s",szObj.latin1());
|
|
|
|
|
|
|
|
idx++;
|
|
|
|
|
|
|
|
dumpChildObjects(cmd->window(), list.at(i), spacing.ptr(), bFlag,n,idx);
|
|
|
|
}
|
|
|
|
//++it;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
TQWidgetList *l = g_pApp->tqtopLevelWidgets();
|
|
|
|
l->setAutoDelete(false);
|
|
|
|
TQWidgetListIt it(*l);
|
|
|
|
KviStr spacing = ">";
|
|
|
|
TQString szTemp;
|
|
|
|
KviKvsArray * n = new KviKvsArray();
|
|
|
|
int idx=0;
|
|
|
|
while( it.current() )
|
|
|
|
{
|
|
|
|
if( it.current()->isWidgetType())
|
|
|
|
{
|
|
|
|
if (bFlag)
|
|
|
|
{
|
|
|
|
cmd->window()->output(80, "Ptr %u: top level object: %c%s%c, class %s, %s, rect = %d, %d, %d, %d",
|
|
|
|
it.current(),
|
|
|
|
KVI_TEXT_BOLD, it.current()->name(), KVI_TEXT_BOLD,
|
|
|
|
it.current()->className(),
|
|
|
|
it.current()->isVisible() ? "visible" : "hidden",
|
|
|
|
it.current()->x(), it.current()->y(), it.current()->width(), it.current()->height());
|
|
|
|
}
|
|
|
|
TQString szClass=it.current()->className();
|
|
|
|
TQString szObj=it.current()->name();
|
|
|
|
TQString szTemp;
|
|
|
|
szTemp = szClass + "::" + szObj;
|
|
|
|
KviKvsVariant v;
|
|
|
|
v.setString(szTemp);
|
|
|
|
n->set(idx,new KviKvsVariant(v));
|
|
|
|
debug ("string %s",szTemp.latin1());
|
|
|
|
debug ("class %s",szClass.latin1());
|
|
|
|
debug ("Obj %s",szObj.latin1());
|
|
|
|
|
|
|
|
idx++;
|
|
|
|
|
|
|
|
dumpChildObjects(cmd->window(), TQT_TQOBJECT(it.current()), spacing.ptr(), bFlag,n,idx);
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
cmd->returnValue()->setArray(n);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dumpChildObjects(KviWindow *pWnd, TQObject *parent, const char *spacing, bool bFlag, KviKvsArray *n, int &idx)
|
|
|
|
{
|
|
|
|
#ifdef COMPILE_USE_QT4
|
|
|
|
const TQObjectList list = parent->tqchildren();
|
|
|
|
if( !list.count() ) return;
|
|
|
|
TQString sp(spacing);
|
|
|
|
sp.append(">");
|
|
|
|
for(int i=0;i<list.count();i++)
|
|
|
|
{
|
|
|
|
if( list.at(i)->isWidgetType() )
|
|
|
|
{
|
|
|
|
if (bFlag)
|
|
|
|
{
|
|
|
|
pWnd->output(80, "%sPtr %u: object: %c%s%c, class %s",
|
|
|
|
spacing, list.at(i), KVI_TEXT_BOLD,
|
|
|
|
list.at(i)->name(), KVI_TEXT_BOLD, list.at(i)->className()
|
|
|
|
);
|
|
|
|
}
|
|
|
|
TQString szClass=list.at(i)->className();
|
|
|
|
TQString szObj=list.at(i)->name();
|
|
|
|
TQString szTemp;
|
|
|
|
szTemp=spacing+szClass+"::"+szObj;
|
|
|
|
KviKvsVariant v;
|
|
|
|
v.setString(szTemp);
|
|
|
|
n->set(idx,new KviKvsVariant(v));
|
|
|
|
debug ("string %s",szTemp.latin1());
|
|
|
|
idx++;
|
|
|
|
dumpChildObjects(pWnd, list.at(i), sp, bFlag, n, idx );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
const TQObjectList l = parent->childrenListObject();
|
|
|
|
if( l.isEmpty() ) return;
|
|
|
|
TQObjectListIt it(l);
|
|
|
|
TQString sp(spacing);
|
|
|
|
sp.append(">");
|
|
|
|
while( it.current() )
|
|
|
|
{
|
|
|
|
if( it.current()->isWidgetType() )
|
|
|
|
{
|
|
|
|
if (bFlag)
|
|
|
|
{
|
|
|
|
pWnd->output(80, "%sPtr %u: object: %c%s%c, class %s",
|
|
|
|
spacing, it.current(), KVI_TEXT_BOLD,
|
|
|
|
it.current()->name(), KVI_TEXT_BOLD, it.current()->className()
|
|
|
|
);
|
|
|
|
}
|
|
|
|
TQString szClass=it.current()->className();
|
|
|
|
TQString szObj=it.current()->name();
|
|
|
|
TQString szTemp;
|
|
|
|
szTemp=spacing+szClass+"::"+szObj;
|
|
|
|
KviKvsVariant v;
|
|
|
|
v.setString(szTemp);
|
|
|
|
n->set(idx,new KviKvsVariant(v));
|
|
|
|
debug ("string %s",szTemp.latin1());
|
|
|
|
idx++;
|
|
|
|
dumpChildObjects(pWnd, it.current(), sp, bFlag, n, idx );
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool objects_module_can_unload(KviModule *m)
|
|
|
|
{
|
|
|
|
// Actually this object remains locked in memory
|
|
|
|
// FIXME: unlock when no more instances & derived classes!
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
static bool objects_module_init(KviModule * m)
|
|
|
|
{
|
|
|
|
// functions
|
|
|
|
KVSM_REGISTER_FUNCTION(m,"exists",objects_kvs_fnc_exists);
|
|
|
|
KVSM_REGISTER_FUNCTION(m,"instances",objects_kvs_fnc_instances);
|
|
|
|
KVSM_REGISTER_FUNCTION(m,"classes",objects_kvs_fnc_classes);
|
|
|
|
KVSM_REGISTER_FUNCTION(m,"dump",objects_kvs_fnc_listObjects);
|
|
|
|
KVSM_REGISTER_FUNCTION(m,"variables",objects_kvs_fnc_variables);
|
|
|
|
KVSM_REGISTER_FUNCTION(m,"classAllHandlers",objects_kvs_fnc_classAllHandlers);
|
|
|
|
|
|
|
|
// commands
|
|
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"connect",objects_kvs_cmd_connect);
|
|
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"disconnect",objects_kvs_cmd_disconnect);
|
|
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"killClass",objects_kvs_cmd_killClass);
|
|
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"bitblt",objects_kvs_cmd_bitBlt);
|
|
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"blend",objects_kvs_cmd_blend);
|
|
|
|
KVSM_REGISTER_SIMPLE_COMMAND(m,"clearObjects",objects_kvs_cmd_clearObjects);
|
|
|
|
|
|
|
|
KviKvsObject_list::registerSelf();
|
|
|
|
|
|
|
|
KviKvsObject_widget::registerSelf();
|
|
|
|
KviKvsObject_button::registerSelf();
|
|
|
|
KviKvsObject_mledit::registerSelf();
|
|
|
|
|
|
|
|
KviKvsObject_textbrowser::registerSelf();
|
|
|
|
KviKvsObject_checkbox::registerSelf();
|
|
|
|
KviKvsObject_dialog::registerSelf();
|
|
|
|
KviKvsObject_groupbox::registerSelf();
|
|
|
|
KviKvsObject_buttongroup::registerSelf();
|
|
|
|
KviKvsObject_label::registerSelf();
|
|
|
|
KviKvsObject_vbox::registerSelf();
|
|
|
|
KviKvsObject_hbox::registerSelf();
|
|
|
|
KviKvsObject_layout::registerSelf();
|
|
|
|
KviKvsObject_lcd::registerSelf();
|
|
|
|
KviKvsObject_lineedit::registerSelf();
|
|
|
|
KviKvsObject_menubar::registerSelf();
|
|
|
|
KviKvsObject_workspace::registerSelf();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
KviKvsObject_combobox::registerSelf();
|
|
|
|
KviKvsObject_listbox::registerSelf();
|
|
|
|
KviKvsObject_listview::registerSelf();
|
|
|
|
KviKvsObject_listviewitem::registerSelf();
|
|
|
|
KviKvsObject_mainwindow::registerSelf();
|
|
|
|
KviKvsObject_painter::registerSelf();
|
|
|
|
KviKvsObject_pixmap::registerSelf();
|
|
|
|
KviKvsObject_popupmenu::registerSelf();
|
|
|
|
KviKvsObject_radiobutton::registerSelf();
|
|
|
|
KviKvsObject_slider::registerSelf();
|
|
|
|
KviKvsObject_spinbox::registerSelf();
|
|
|
|
KviKvsObject_tabwidget::registerSelf();
|
|
|
|
KviKvsObject_toolbar::registerSelf();
|
|
|
|
KviKvsObject_toolbutton::registerSelf();
|
|
|
|
KviKvsObject_urlabel::registerSelf();
|
|
|
|
KviKvsObject_window::registerSelf();
|
|
|
|
KviKvsObject_wizard::registerSelf();
|
|
|
|
KviKvsObject_dockwindow::registerSelf();
|
|
|
|
KviKvsObject_progressbar::registerSelf();
|
|
|
|
KviKvsObject_file::registerSelf();
|
|
|
|
KviKvsObject_wrapper::registerSelf();
|
|
|
|
KviKvsObject_xmlreader::registerSelf();
|
|
|
|
KviKvsObject_socket::registerSelf();
|
|
|
|
KviKvsObject_process::registerSelf();
|
|
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
KVIRC_MODULE(
|
|
|
|
"Objects",
|
|
|
|
"2.0.0",
|
|
|
|
"Copyright (C) 2000-2006:\n" \
|
|
|
|
" Szymon Stefanek (pragma at kvirc dot net)\n" \
|
|
|
|
" Krzysztof Godlewski (kristoff at poczta dot wprost dot pl)\n" \
|
|
|
|
" Tonino Imbesi (grifisx at barmes dot org)\n" \
|
|
|
|
" Alessandro Carbone (noldor at barmes dot org)",
|
|
|
|
"Object classes for KVIrc scripting language\n",
|
|
|
|
objects_module_init,
|
|
|
|
objects_module_can_unload,
|
|
|
|
0,
|
|
|
|
objects_module_cleanup
|
|
|
|
)
|