diff options
Diffstat (limited to 'kjsembed/jsfactory.cpp')
| -rw-r--r-- | kjsembed/jsfactory.cpp | 1132 |
1 files changed, 1132 insertions, 0 deletions
diff --git a/kjsembed/jsfactory.cpp b/kjsembed/jsfactory.cpp new file mode 100644 index 00000000..ff298b43 --- /dev/null +++ b/kjsembed/jsfactory.cpp @@ -0,0 +1,1132 @@ +/* +* Copyright (C) 2001-2004, Richard J. Moore <rich@kde.org> +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Library General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library 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 +* Library General Public License for more details. +* +* You should have received a copy of the GNU Library General Public License +* along with this library; see the file COPYING.LIB. If not, write to +* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +* Boston, MA 02110-1301, USA. +*/ + +#include <stdio.h> +#include <string.h> +#include <errno.h> + +#include <qobject.h> +#include <qcombobox.h> +#include <qdialog.h> +#include <qdir.h> +#include <qfile.h> +#include <qimage.h> +#include <qlistview.h> +#include <qmainwindow.h> +//#include <qpainter.h> +#include <qprogressdialog.h> +#include <qtextstream.h> +#include <qtimer.h> +#include <qwidget.h> +#include <qwidgetfactory.h> +#include <qsplitter.h> +#include <qscrollview.h> +#include <qcanvas.h> +#include <qlayout.h> +#include <qsplashscreen.h> + +#ifndef QT_ONLY + +#include <kapplication.h> +#include <dcopref.h> +#include <dcopclient.h> +#include <kaction.h> +#include <klibloader.h> +#include <klocale.h> +#include <kmainwindow.h> +#include <kservice.h> +#include <ksystemtray.h> +#include <ktrader.h> + +#include <kparts/part.h> +#include <kparts/mainwindow.h> +#include <kparts/componentfactory.h> + +#endif // QT_ONLY + +#include <kjs/interpreter.h> +#include <kjs/identifier.h> +#include <kjs/types.h> + +#include "jsbinding.h" +#include "jsbindingbase.h" +#include "jsobjectproxy.h" +#include "jsopaqueproxy.h" +#include "jsvalueproxy.h" +#include "jsconsolewidget.h" +#include "jseventmapper.h" +#include "jseventutils.h" +#include "kjsembedpart.h" +#include "customobject_imp.h" + +#include "builtins/stddialog_imp.h" +#include "builtins/textstream_imp.h" +#include "builtins/qdir_imp.h" + +#include "qtbindings/qcombobox_imp.h" +#include "qtbindings/qpopupmenu_imp.h" +#include "qtbindings/qlistviewitem_imp.h" +#include "qtbindings/qchecklistitem_imp.h" +#include "qtbindings/qcanvasellipse_imp.h" +#include "qtbindings/qcanvas_imp.h" +#include "qtbindings/qcanvasitem_imp.h" +#include "qtbindings/qcanvasitemlist_imp.h" +#include "qtbindings/qcanvasline_imp.h" +#include "qtbindings/qcanvaspixmaparray_imp.h" +#include "qtbindings/qcanvaspixmap_imp.h" +#include "qtbindings/qcanvaspolygonalitem_imp.h" +#include "qtbindings/qcanvaspolygon_imp.h" +#include "qtbindings/qcanvasrectangle_imp.h" +#include "qtbindings/qcanvasspline_imp.h" +#include "qtbindings/qcanvassprite_imp.h" +#include "qtbindings/qcanvastext_imp.h" +#include "qtbindings/qcanvasview_imp.h" + + +#ifndef QT_ONLY + +#include "builtins/stdaction_imp.h" + +#include "bindings/dcop_imp.h" +#include "bindings/netaccess_imp.h" +#endif // QT_ONLY + +#include "bindings/image_imp.h" +#include "bindings/pen_imp.h" +#include "bindings/pixmap_imp.h" +#include "bindings/painter_imp.h" +#include "bindings/movie_imp.h" +#include "bindings/sql_imp.h" +#include "bindings/kconfig_imp.h" +#include "bindings/brush_imp.h" +#include "bindings/size_imp.h" +#include "bindings/rect_imp.h" +#include "bindings/point_imp.h" + + +#include "global.h" +#include "jsbindingplugin.h" +#include "jsfactory_imp.h" +#include "jsfactory.h" + +// +// KPart Implementation +// +namespace KJSEmbed { + + typedef Bindings::JSFactoryImp JSFactoryImp; + typedef Bindings::CustomObjectImp CustomObjectImp; + typedef BuiltIns::StdDialogImp StdDialogImp; + typedef BuiltIns::TextStreamImp TextStreamImp; + + class JSFactoryPrivate { + public: + QDict<KJSEmbed::Bindings::JSBindingPlugin> plugins; + QDict<KJSEmbed::Bindings::JSBindingBase> opaqueTypes; + QDict<KJSEmbed::Bindings::JSBindingBase> objectTypes; + }; + + + JSFactory::JSFactory( KJSEmbedPart *part ) + : jspart( part ) { + evmapper = new JSEventMapper(); + d = new JSFactoryPrivate; + registerOpaqueType("QDir", new Bindings::QDirLoader()); + registerOpaqueType("QCheckListItem", new Bindings::QCheckListItemLoader()); + registerOpaqueType("QListViewItem", new Bindings::QListViewItemLoader()); + registerOpaqueType("Painter", new Bindings::PainterLoader()); + +#ifndef QT_ONLY + registerOpaqueType("DCOPClient", new Bindings::JSDCOPClientLoader()); + registerObjectType("DCOPInterface", new Bindings::JSDCOPInterfacerLoader()); + registerOpaqueType("DCOPRef", new Bindings::JSDCOPRefLoader()); +#endif + + } + + JSFactory::~JSFactory() { + delete evmapper; + } + + void JSFactory::addBindingPluginTypes( KJS::ExecState *exec, KJS::Object &parent ) { +#ifndef QT_ONLY + + // Get list of valid plugin types + KTrader::OfferList offers = KTrader::self() ->query( "JSBindingPlugin/Binding" ); + if ( !offers.count() ) + return ; + + KTrader::OfferListIterator itr = offers.begin(); + while ( itr != offers.end() ) { + QString classname = ( *itr ) ->name(); + JSFactoryImp *cons = new JSFactoryImp( exec, this, JSFactoryImp::NewInstance, classname ); + parent.put( exec, KJS::Identifier( cons->parameter() ), KJS::Object( cons ) ); + addType( classname, TypePlugin ); + ++itr; + } +#else + Q_UNUSED( exec ); + Q_UNUSED( parent ); +#endif // QT_ONLY + + } + + bool JSFactory::isBindingPlugin( const QString &classname ) const { + if ( !isSupported( classname ) ) + return false; + return ( objtypes[ classname ] & TypePlugin ); + } + + KJS::Object JSFactory::createBindingPlugin( KJS::ExecState *exec, const QString &classname, const KJS::List &args ) { +#ifndef QT_ONLY + + Bindings::JSBindingPlugin * plugin = d->plugins[ classname ]; + if ( plugin == 0L ) { + QString query = "JSBindingPlugin/Binding"; + QString constraint = "[Name] == '" + classname + "'"; + plugin = KParts::ComponentFactory::createInstanceFromQuery<Bindings::JSBindingPlugin>( query, constraint ); + if ( plugin != 0L ) + d->plugins.insert( classname, plugin ); + } + + if ( plugin != 0L ) + return plugin->createBinding( jspart, exec, args ); + +#else + + Q_UNUSED( exec ); + Q_UNUSED( args ); +#endif // QT_ONLY + + kdWarning( 80001 ) << "Unable to load binding " << classname << "." << endl; + + return KJS::Object(); + } + + KJS::Object JSFactory::create( KJS::ExecState *exec, const QString &classname, const KJS::List &args ) { + KJS::Object returnObject; + if ( !isSupported( classname ) ) { + QString msg = i18n( "Object of type '%1' is not supported." ).arg( classname ); + return throwError(exec, msg,KJS::TypeError); + } + if ( isQObject( classname ) ) { + // create via widget factory... + Bindings::JSBindingBase *factory = d->objectTypes.find(classname); + if( factory ) { + returnObject = factory->createBinding( jspart, exec, args ); + JSProxy::toProxy( returnObject.imp() ) ->setOwner( JSProxy::JavaScript ); + } else { + QObject *parent = extractQObject(exec, args, 0); + QString name = extractQString(exec, args, 1); + + QObject *obj = create( classname, parent, name.latin1() ); + if ( obj ) { + returnObject = createProxy( exec, obj ); + JSProxy::toProxy( returnObject.imp() ) ->setOwner( JSProxy::JavaScript ); + } else { + QString msg = i18n( "QObject of type '%1' could not be created." ).arg( classname ); + returnObject = throwError(exec, msg,KJS::TypeError); + } + } + } else if ( isOpaque( classname ) ) { + // Try to create from the registry + Bindings::JSBindingBase *factory = d->opaqueTypes.find(classname); + if( factory ) + returnObject = factory->createBinding( jspart, exec, args ); + else + returnObject = createOpaque( exec, classname, args ); + + if ( !returnObject.isValid() ) { + QString msg = i18n( "Opaque object of type '%1' could not be created." ).arg( classname ); + returnObject = throwError(exec, msg,KJS::TypeError); + } + } else if ( isValue( classname ) ) { + returnObject = createValue( exec, classname, args ); + if ( !returnObject.isValid() ) { + QString msg = i18n( "Value object of type '%1' could not be created." ).arg( classname ); + returnObject = throwError(exec, msg,KJS::TypeError); + } + } else if ( isBindingPlugin( classname ) ) { + returnObject = createBindingPlugin( exec, classname, args ); + if ( !returnObject.isValid() ) { + QString msg = i18n( "Plugin object of type '%1' could not be created." ).arg( classname ); + returnObject = throwError(exec, msg,KJS::TypeError); + } else + JSProxy::toProxy( returnObject.imp() ) ->setOwner( JSProxy::JavaScript ); + } else { + QString msg = i18n( "Could not create object of type '%1'." ).arg( classname ); + returnObject = throwError(exec, msg,KJS::TypeError); + } + return returnObject; + } + + KJS::Object JSFactory::createProxy( KJS::ExecState *exec, QObject *target, + const JSObjectProxy *ctx ) const { + kdDebug( 80001 ) << "JSFactory::createProxy: Target '" << target->name() + << "' type " << target->className() << endl; + + JSObjectProxy *prx; + if ( ctx ) + prx = new JSObjectProxy( jspart, target, ctx->rootObject(), ctx->securityPolicy() ); + else { + prx = new JSObjectProxy( jspart, target ); + + } + kdDebug( 80001 ) << "Proxy created" << endl; + + KJS::Object proxyObj( prx ); + prx->addBindings( exec, proxyObj ); + extendProxy( exec, proxyObj ); + prx->setOwner(JSProxy::Native); + + kdDebug( 80001 ) << "Returning object" << endl; + + return proxyObj; + } + + KJS::Object JSFactory::createProxy( KJS::ExecState *exec, + QTextStream *target, const JSObjectProxy *context ) const { + Q_UNUSED( context ) + kdDebug( 80001 ) << "TextStream proxy created" << endl; + + JSOpaqueProxy *prx = new JSOpaqueProxy( target ); + KJS::Object proxyObj( prx ); + prx->addBindings( exec, proxyObj ); + TextStreamImp::addBindings( exec, proxyObj ); + + return proxyObj; + } + + KJS::Object JSFactory::createProxy( KJS::ExecState *exec, + QEvent *target, const JSObjectProxy *context ) const { + switch ( target->type() ) { + case QEvent::MouseButtonPress: + case QEvent::MouseButtonRelease: + case QEvent::MouseMove: + case QEvent::MouseButtonDblClick: + return JSEventUtils::convertEvent( exec, ( QMouseEvent * ) target, context ); + break; + case QEvent::KeyPress: + case QEvent::KeyRelease: + case QEvent::Accel: + case QEvent::AccelOverride: + return JSEventUtils::convertEvent( exec, ( QKeyEvent * ) target, context ); + break; + case QEvent::IMStart: + case QEvent::IMCompose: + case QEvent::IMEnd: + return JSEventUtils::convertEvent( exec, ( QIMEvent * ) target, context ); + break; + case QEvent::Paint: + return JSEventUtils::convertEvent( exec, ( QPaintEvent * ) target, context ); + break; + case QEvent::Resize: + return JSEventUtils::convertEvent( exec, ( QResizeEvent * ) target, context ); + break; + case QEvent::FocusIn: + case QEvent::FocusOut: + return JSEventUtils::convertEvent( exec, ( QFocusEvent * ) target, context ); + break; + case QEvent::Close: + return JSEventUtils::convertEvent( exec, ( QCloseEvent * ) target, context ); + break; + case QEvent::ChildInserted: + case QEvent::ChildRemoved: + return JSEventUtils::convertEvent( exec, ( QChildEvent * ) target, context ); + break; + case QEvent::Move: + return JSEventUtils::convertEvent( exec, ( QMoveEvent * ) target, context ); + break; + case QEvent::Wheel: + return JSEventUtils::convertEvent( exec, ( QWheelEvent * ) target, context ); + break; + case QEvent::Timer: + return JSEventUtils::convertEvent( exec, ( QTimerEvent * ) target, context ); + break; + case QEvent::ContextMenu: + return JSEventUtils::convertEvent( exec, ( QContextMenuEvent * ) target, context ); + break; + case QEvent::DragMove: + case QEvent::DragEnter: + return JSEventUtils::convertEvent( exec, ( QDragMoveEvent * ) target, context ); + break; + case QEvent::Drop: + return JSEventUtils::convertEvent( exec, ( QDropEvent * ) target, context ); + break; + case QEvent::Enter: + case QEvent::Leave: + case QEvent::Clipboard: + case QEvent::DragLeave: + case QEvent::Show: + case QEvent::Hide: + return JSEventUtils::convertEvent( exec, ( QEvent * ) target, context ); + break; + default: + break; + } + + return JSEventUtils::convertEvent( exec, ( QEvent * ) target, context ); + } + + KJS::Object JSFactory::extendProxy( KJS::ExecState *exec, KJS::Object &target ) const { + CustomObjectImp::addBindings( exec, target ); + addBindingsPlugin( exec, target ); + return target; + } + + void JSFactory::addBindingsPlugin( KJS::ExecState *exec, KJS::Object &target ) const { + kdDebug( 800001 ) << "JSFactory::addBindingsPlugin" << endl; + JSObjectProxy *proxy = JSProxy::toObjectProxy( target.imp() ); + if ( !proxy ) + return ; + if ( !isBindingPlugin( proxy->object() ->className() ) ) + return ; + +#ifndef QT_ONLY + + Bindings::JSBindingPlugin *plugin = d->plugins[ proxy->object() ->className() ]; + if ( plugin == 0L ) { + QString query = "JSBindingPlugin/Binding"; + QString constraint = "[Name] == '" + QString::fromUtf8( proxy->object() ->className() ) + "'"; + plugin = KParts::ComponentFactory::createInstanceFromQuery<Bindings::JSBindingPlugin>( query, constraint ); + if ( plugin != 0L ) + d->plugins.insert( proxy->object() ->className(), plugin ); + } + + if ( plugin != 0L ) { + kdDebug( 800001 ) << "JSFactory::addBindingsPlugin: calling plugin function" << endl; + plugin->addBindings( exec, target ); + return ; + } +#else + Q_UNUSED( exec ); +#endif // QT_ONLY + + kdWarning( 80001 ) << "Unable to add bindings to " << proxy->object() ->className() << "." << endl; + return ; + + } + + + QObject *JSFactory::createBinding( const QString &cname, QObject *parent, const char *name ) { +#ifndef QT_ONLY + + // Bindings + /*if ( cname == "DCOPInterface" ) + return new Bindings::JSDCOPInterface( jspart->interpreter(), parent, name ); + else */if ( cname == "NetAccess" ) + return new Bindings::NetAccess( parent, name ); + else +#endif // QT_ONLY + if ( cname == "Movie" ) + return new Bindings::Movie( parent, name ); + else if ( cname == "SqlDatabase" ) + return new Bindings::SqlDatabase( parent, name ); + else if ( cname == "SqlQuery" ) + return new Bindings::SqlQuery( parent, name ); + else if ( cname == "Config" ) + return new Bindings::Config( parent, name ); + + return 0; + } + + QObject *JSFactory::createObject( const QString &cname, QObject *parent, const char *name ) { + + // QObjects defined by Qt + if ( cname == "QObject" ) + return new QObject( parent, name ); + else if ( cname == "QTimer" ) + return new QTimer( parent, name ); + else if ( cname == "QCanvas" ) + return new QCanvas( parent, name ); + +#ifndef QT_ONLY + // QObjects defined by KDE + else if ( cname == "KAction" ) + return new KAction( parent, name ); + else if ( cname == "KToggleAction" ) + return new KToggleAction( parent, name ); +#endif // QT_ONLY + + QWidget *w = dynamic_cast<QWidget *>( parent ); + if ( !w ) + return 0; + + if ( cname == "QHBoxLayout" ) + return new QHBoxLayout( w, 0, -1, name ); + else if ( cname == "QVBoxLayout" ) + return new QVBoxLayout( w, 0, -1, name ); + return 0; + } + + KJS::Object JSFactory::createOpaque( KJS::ExecState *exec, const QString &cname, const KJS::List &args ) { + + if ( cname == "QCanvasText" ) { + kdDebug( 80001 ) << "Creating canvas item, type is " << cname << endl; + + JSOpaqueProxy *prx = 0; + + if ( args.size() == 0 ) { + // FALL THRU + } else if ( args.size() == 1 ) { + + JSObjectProxy * arg0 = JSProxy::toObjectProxy( args[ 0 ].imp() ); + + if ( arg0 ) { + + QObject * obj0 = arg0->object(); + + if ( obj0->inherits( "QCanvas" ) ) { + QCanvas * parent = ( QCanvas * ) ( obj0 ); + prx = new JSOpaqueProxy( new QCanvasText( parent ), "QCanvasText" ); + + KJS::Object proxyObj( prx ); + QCanvasItemImp::addBindings( exec, proxyObj ); + QCanvasTextImp::addBindings( exec, proxyObj ); + return proxyObj; + } else { + kdDebug( 80001 ) << " canvas item create failed, arg0 is " << obj0->className() << endl; + return KJS::Object(); + } + } else { + kdDebug( 80001 ) << " canvas item create failed, arg0 is not an object" << endl; + return KJS::Object(); + } + + } else if ( args.size() == 2 ) { + + QString arg0 = args[ 0 ].toString( exec ).qstring(); + JSObjectProxy *arg1 = JSProxy::toObjectProxy( args[ 1 ].imp() ); + + if ( arg1 ) { + + QString arg0 = args[ 0 ].toString( exec ).qstring(); + QObject *obj1 = arg1->object(); + + if ( obj1->inherits( "QCanvas" ) ) { + QCanvas * parent = ( QCanvas * ) ( obj1 ); + prx = new JSOpaqueProxy( new QCanvasText( parent ), "QCanvasText" ); + + KJS::Object proxyObj( prx ); + QCanvasItemImp::addBindings( exec, proxyObj ); + QCanvasTextImp::addBindings( exec, proxyObj ); + return proxyObj; + } else { + kdDebug( 80001 ) << " canvas item create failed, arg0 is " << obj1->className() << endl; + return KJS::Object(); + } + } else { + kdDebug( 80001 ) << " canvas item create failed, arg1 is not an object" << endl; + return KJS::Object(); + } + } + } + + + return KJS::Object(); + } + + KJS::Object JSFactory::createValue( KJS::ExecState *exec, const QString &cname, const KJS::List & args ) { + if ( cname == "Image" ) { + QImage img = QImage(); + JSValueProxy *prx = new JSValueProxy( ); + prx->setValue( img ); + KJS::Object proxyObj( prx ); + Bindings::ImageImp::addBindings( exec, proxyObj ); + return proxyObj; + } + if ( cname == "Pixmap" ) { + QPixmap pix = QPixmap(); + JSValueProxy *prx = new JSValueProxy( ); + prx->setValue( pix ); + KJS::Object proxyObj( prx ); + Bindings::Pixmap::addBindings( exec, proxyObj ); + return proxyObj; + } + if ( cname == "Brush" ) { + QBrush brsh; + JSValueProxy *prx = new JSValueProxy( ); + prx->setValue( brsh ); + KJS::Object proxyObj( prx ); + Bindings::BrushImp::addBindings( exec, proxyObj ); + return proxyObj; + } + if ( cname == "Pen" ) { + QPen pen; + JSValueProxy *prx = new JSValueProxy( ); + prx->setValue( pen ); + KJS::Object proxyObj( prx ); + Bindings::Pen::addBindings( exec, proxyObj ); + return proxyObj; + } + if ( cname == "Rect" ) { + QRect rect; + if ( args.size() == 4 ) { + rect.setX( extractInt( exec, args, 0 ) ); + rect.setY( extractInt( exec, args, 1 ) ); + rect.setWidth( extractInt( exec, args, 2 ) ); + rect.setHeight( extractInt( exec, args, 3 ) ); + } + JSValueProxy *prx = new JSValueProxy( ); + prx->setValue( rect ); + KJS::Object proxyObj( prx ); + Bindings::Rect::addBindings( exec, proxyObj ); + return proxyObj; + } + if ( cname == "Point" ) { + QPoint point; + if ( args.size() == 2 ) { + point.setX( extractInt( exec, args, 0 ) ); + point.setY( extractInt( exec, args, 1 ) ); + } + JSValueProxy *prx = new JSValueProxy( ); + prx->setValue( point ); + KJS::Object proxyObj( prx ); + Bindings::Point::addBindings( exec, proxyObj ); + return proxyObj; + } + if ( cname == "Size" ) { + QSize size; + if ( args.size() == 2 ) { + size.setWidth( extractInt( exec, args, 0 ) ); + size.setHeight( extractInt( exec, args, 1 ) ); + } + JSValueProxy *prx = new JSValueProxy( ); + prx->setValue( size ); + KJS::Object proxyObj( prx ); + Bindings::Size::addBindings( exec, proxyObj ); + return proxyObj; + } + + + return KJS::Object(); + } + + QWidget *JSFactory::createWidget( const QString &cname, QWidget *pw, const char *name ) { + if ( cname == "QSplitter" ) + return new QSplitter( pw, name ); + else if ( cname == "QMainWindow" ) + return new QMainWindow( pw, name ); + else if ( cname == "QProgressDialog" ) + return new QProgressDialog( pw, name ); + else if ( cname == "QScrollView" ) + return new QScrollView( pw, name ); + else if ( cname == "QCanvasView" ) + return new QCanvasView( pw, name ); + else if ( cname == "QSplashScreen" ) { + QPixmap pix( 16, 16 ); + pix.fill(); + return new QSplashScreen( pix ); + } +#ifndef QT_ONLY + else if ( cname == "KMainWindow" ) + return new KMainWindow( pw, name ); + else if ( cname == "KParts_MainWindow" ) + return new KParts::MainWindow( pw, name ); + else if ( cname == "KSystemTray" ) + return new KSystemTray( pw, name ); +#endif // QT_ONLY + + return 0; + } + + QObject *JSFactory::create( const QString &cname, QObject *parent, const char *name ) { + kdDebug( 80001 ) << "KJSEmbedPart::create() name " << name << " class " << cname << endl; + + // Factory widgets + QWidgetFactory wf; + QWidget *pw = ( parent && parent->isWidgetType() ) ? static_cast<QWidget *>( parent ) : 0; + QWidget *w = wf.createWidget( cname, pw, name ); + if ( w ) { + kdDebug( 80001 ) << "Created from factory" << endl; + return w; + } + // Custom widgets + QObject *obj; + obj = createWidget( cname, pw, name ); + if ( obj ) { + if ( !isQObject( obj->className() ) ) + addType( obj->className() ); + kdDebug( 80001 ) << "Created from createWidget" << endl; + return obj; + } + + // Custom objects + obj = JSFactory::createObject( cname, parent, name ); + if ( obj ) { + if ( !isQObject( obj->className() ) ) + addType( obj->className() ); + kdDebug( 80001 ) << "Created from createObject" << endl; + return obj; + } + + // Binding objects + obj = JSFactory::createBinding( cname, parent, name ); + if ( obj ) { + if ( !isQObject( obj->className() ) ) + addType( obj->className() ); + kdDebug( 80001 ) << "Created from bindings" << endl; + return obj; + } + + kdDebug( 80001 ) << "Found nothing in :" << cname << ":" << endl; + return 0; + } + + KParts::ReadOnlyPart *JSFactory::createROPart( const QString &svc, QObject *parent, const char *name ) { + kdDebug( 80001 ) << "JSFactory::createROPart svc " << svc << " parent " << ( long ) parent << endl; + return createROPart( svc, "'KParts/ReadOnlyPart' in ServiceTypes", parent, name ); + } + + KParts::ReadOnlyPart *JSFactory::createROPart( const QString &svc, const QString &con, + QObject *parent, const char *name ) { + kdDebug( 80001 ) << "JSFactory::createROPart svc " << svc << " constraint " << con + << " parent " << ( long ) parent << endl; + + return createROPart( svc, con, parent, name, QStringList() ); + } + + KParts::ReadOnlyPart *JSFactory::createROPart( const QString &svc, const QString &con, + QObject *parent, const char *name, + const QStringList &args ) { +#ifndef QT_ONLY + kdDebug( 80001 ) << "JSFactory::createROPart svc " << svc << " constraint " << con + << " parent " << ( long ) parent + << " args: " << args << endl; + + KTrader::OfferList offers = KTrader::self() ->query( svc, con ); + if ( !offers.count() ) + return 0; + + KService::Ptr ptr = offers.first(); + KLibFactory *fact = KLibLoader::self() ->factory( ptr->library().ascii() ); + if ( !fact ) { + kdDebug( 80001 ) << "Unable to find a matching part" << endl; + return 0; + } + + QObject *obj = fact->create( parent, name, "KParts::ReadOnlyPart", args ); + addType( obj->className() ); + return static_cast<KParts::ReadOnlyPart *>( obj ); +#else // QT_ONLY + + Q_UNUSED( svc ); + Q_UNUSED( con ); + Q_UNUSED( parent ); + Q_UNUSED( name ); + Q_UNUSED( args ); + return 0; +#endif // QT_ONLY + + } + + KParts::ReadWritePart *JSFactory::createRWPart( const QString &svc, QObject *parent, const char *name ) { + kdDebug( 80001 ) << "JSFactory::createRWPart svc " << svc << " parent " << ( long ) parent << endl; + return createRWPart( svc, "'KParts/ReadWritePart' in ServiceTypes", parent, name ); + } + + KParts::ReadWritePart *JSFactory::createRWPart( const QString &svc, const QString &con, + QObject *parent, const char *name ) { + kdDebug( 80001 ) << "JSFactory::createRWPart svc " << svc << " constraint " << con + << " parent " << ( long ) parent << endl; + + return createRWPart( svc, con, parent, name, QStringList() ); + } + + KParts::ReadWritePart *JSFactory::createRWPart( const QString &svc, const QString &con, + QObject *parent, const char *name, + const QStringList &args ) { +#ifndef QT_ONLY + kdDebug( 80001 ) << "JSFactory::createRWPart svc " << svc << " constraint " << con + << " parent " << ( long ) parent + << " args: " << args << endl; + + KTrader::OfferList offers = KTrader::self() ->query( svc, con ); + if ( !offers.count() ) + return 0; + + KService::Ptr ptr = offers.first(); + KLibFactory *fact = KLibLoader::self() ->factory( ptr->library().ascii() ); + if ( !fact ) { + kdDebug( 80001 ) << "Unable to find a matching part" << endl; + return 0; + } + + QObject *obj = fact->create( parent, name, "KParts::ReadWritePart", args ); + addType( obj->className() ); + return static_cast<KParts::ReadWritePart *>( obj ); +#else // QT_ONLY + + Q_UNUSED( svc ); + Q_UNUSED( con ); + Q_UNUSED( parent ); + Q_UNUSED( name ); + Q_UNUSED( args ); + return 0; +#endif // QT_ONLY + + } + + QWidget *JSFactory::loadUI( const QString &uiFile, QObject *connector, QWidget *parent, const char *name ) { + return QWidgetFactory::create( uiFile, connector, parent, name ); + } + + QStringList JSFactory::listBindingPlugins( KJS::ExecState *exec, KJS::Object &self ) { + Q_UNUSED( exec ) + Q_UNUSED( self ) + QStringList pluginList; + QStringList allTypes = objtypes.keys(); + for ( uint idx = 0; idx < allTypes.count(); ++idx ) { + if ( objtypes[ allTypes[ idx ] ] & TypePlugin ) + pluginList.append( allTypes[ idx ] ); + } + return pluginList; + } + + bool JSFactory::isQObject( const QString &clazz ) const { + if ( !isSupported( clazz ) ) + return false; + + return ( objtypes[ clazz ] & TypeQObject ); + } + + bool JSFactory::isValue( const QString &clazz ) const { + if ( !isSupported( clazz ) ) + return false; + + return objtypes[ clazz ] == TypeValue; + } + + bool JSFactory::isOpaque( const QString &clazz ) const { + if ( !isSupported( clazz ) ) + return false; + return objtypes[ clazz ] == TypeOpaque; + } + + void JSFactory::addQObjectPlugin( const QString &classname, KJSEmbed::Bindings::JSBindingPlugin* plugin ) { + if ( plugin ) { + addType( classname, TypeQObjectPlugin ); + d->plugins.insert( classname, plugin ); + } + } + + void JSFactory::addType( const QString &clazz, uint prxtype ) { + if ( prxtype == TypeInvalid ) { + objtypes.remove( clazz ); + return ; + } + kdDebug() << "Add type " << clazz << endl; + objtypes[ clazz ] = prxtype; + } + + bool JSFactory::isSupported( const QString &clazz ) const { + kdDebug() << "Checking " << clazz << endl; + return objtypes.contains( clazz ); + } + + uint JSFactory::proxyType( const QString &clazz ) const { + if ( !isSupported( clazz ) ) + return TypeInvalid; + return objtypes[ clazz ]; + } + + void JSFactory::addTypes( KJS::ExecState *exec, KJS::Object &parent ) { + addWidgetFactoryTypes( exec, parent ); + addCustomTypes( exec, parent ); + addBindingTypes( exec, parent ); + addObjectTypes( exec, parent ); + addOpaqueTypes( exec, parent ); + addValueTypes( exec, parent ); + addBindingPluginTypes( exec, parent ); + } + + QStringList JSFactory::types() const { + return objtypes.keys(); + } + + void JSFactory::addWidgetFactoryTypes( KJS::ExecState *exec, KJS::Object &parent ) { + QStringList sl = QWidgetFactory::widgets(); + + for ( QStringList::Iterator it = sl.begin(); it != sl.end(); ++it ) { + JSFactoryImp *cons = new JSFactoryImp( exec, this, JSFactoryImp::NewInstance, *it ); + parent.put( exec, KJS::Identifier( KJS::UString( cons->parameter() ) ), KJS::Object( cons ) ); + addType( *it ); + } + } + + void JSFactory::addCustomTypes( KJS::ExecState *exec, KJS::Object &parent ) { + const char * classes[] = { + + "QSplitter", "QScrollView", "QCanvasView", "QCanvas", + "QObject", "QTimer", "QSplashScreen", "QProgressDialog", + "QLayout", "QBoxLayout", "QHBoxLayout", "QVBoxLayout", +#ifndef QT_ONLY + "KMainWindow", "KXMLGUIClient", "KSystemTray", + "KAction", "KToggleAction", + "KParts_MainWindow", +#endif // QT_ONLY + 0 + }; + + for ( int i = 0 ; classes[ i ] ; i++ ) { + JSFactoryImp *cons = new JSFactoryImp( exec, this, JSFactoryImp::NewInstance, classes[ i ] ); + parent.put( exec, KJS::Identifier( KJS::UString( cons->parameter() ) ), KJS::Object( cons ) ); + addType( classes[ i ] ); + } + } + + void JSFactory::addBindingTypes( KJS::ExecState *exec, KJS::Object &parent ) { + + + const char * bindings[] = { + "Pixmap", "KJSEmbed::Bindings::Pixmap", + "SqlDatabase", "KJSEmbed::Bindings::SqlDatabase", + "Movie", "KJSEmbed::Bindings::Movie", + "SqlQuery", "KJSEmbed::Bindings::SqlQuery", +#ifndef QT_ONLY + "NetAccess", "KJSEmbed::Bindings::NetAccess", + /*"DCOPInterface", "KJSEmbed::Bindings::JSDCOPInterface",*/ +#endif + "Config", "KJSEmbed::Bindings::Config", + 0, 0 + }; + + for ( int i = 0 ; bindings[ i ] ; i += 2 ) { + JSFactoryImp * cons = new JSFactoryImp( exec, this, JSFactoryImp::NewInstance, bindings[ i ] ); + parent.put( exec, KJS::Identifier( KJS::UString( cons->parameter() ) ), KJS::Object( cons ) ); + addType( bindings[ i ] ); + addType( bindings[ i + 1 ] ); + } + + + + } + + void JSFactory::addOpaqueTypes( KJS::ExecState *exec, KJS::Object &parent ) { + const char * classes[] = { + "QTextStream", + "TextStream", + "QCanvasItem", + "QCanvasText", + 0 + }; + + for ( int i = 0 ; classes[ i ] ; i++ ) { + JSFactoryImp *cons = new JSFactoryImp( exec, this, JSFactoryImp::NewInstance, classes[ i ] ); + parent.put( exec, KJS::Identifier( KJS::UString( cons->parameter() ) ), KJS::Object( cons ) ); + addType( classes[ i ], TypeOpaque ); + } + + // Create the custom added types. + QDictIterator<KJSEmbed::Bindings::JSBindingBase> idx( d->opaqueTypes ); + for( ; idx.current(); ++idx){ + JSFactoryImp *cons = new JSFactoryImp( exec, this, JSFactoryImp::NewInstance, idx.currentKey() ); + parent.put( exec, KJS::Identifier( KJS::UString( cons->parameter() ) ), KJS::Object( cons ) ); + addType( idx.currentKey(), TypeOpaque ); + } + + } + void JSFactory::addValueTypes( KJS::ExecState *exec, KJS::Object &parent ) { + const char * classes[] = { + "Image", + "Brush", + "Pixmap", + "Pen", + "Rect", + "Size", + "Point", + 0 + }; + + for ( int i = 0 ; classes[ i ] ; i++ ) { + JSFactoryImp *cons = new JSFactoryImp( exec, this, JSFactoryImp::NewInstance, classes[ i ] ); + parent.put( exec, KJS::Identifier( KJS::UString( cons->parameter() ) ), KJS::Object( cons ) ); + addType( classes[ i ], TypeValue ); + } + } + + + void JSFactory::addObjectTypes( KJS::ExecState *exec, KJS::Object & parent ) { + const char * classes[] = { + "QAccel", + "QAccessibleObject", + "QAction", + "QActionGroup", + "QApplication", + "QAquaStyle", + "QAssistantClient", + "QAxObject", + "QAxWidget", + "QButton", + "QCDEStyle", + "QClipboard", + "QColorDialog", + "QColorDrag", + "QComboBox", + "QCommonStyle", + "QCopChannel", + "QDataPump", + "QDateTimeEditBase", + "QDesktopWidget", + "QDns", + "QDockArea", + "QDockWindow", + "QDoubleValidator", + "QDragObject", + "QEditorFactory", + "QErrorMessage", + "QEventLoop", + "QFileDialog", + "QFileIconProvider", + "QFontDialog", + "QFtp", + "QGLWidget", + "QGridLayout", + "QGridView", + "QHButtonGroup", + "QHGroupBox", + "QHeader", + "QHttp", + "QIconDrag", + "QImageDrag", + "QInputDialog", + "QIntValidator", + "QLocalFs", + "QMacStyle", + "QMenuBar", + "QMessageBox", + "QMotif", + "QMotifDialog", + "QMotifPlusStyle", + "QMotifStyle", + "QMotifWidget", + "QNPInstance", + "QNPWidget", + "QNetworkOperation", + "QNetworkProtocol", + "QObjectCleanupHandler", + "QPlatinumStyle", + "QProcess", + "QPopupMenu", + "QProgressDialog", + "QRegExpValidator", + "QSGIStyle", + "QServerSocket", + "QSessionManager", + "QSignal", + "QSignalMapper", + "QSizeGrip", + "QSocket", + "QSocketNotifier", + "QSound", + "QSqlDatabase", + "QSqlDriver", + "QSqlEditorFactory", + "QSqlForm", + "QStatusBar", + "QStoredDrag", + "QStyle", + "QStyleSheet", + "QTabBar", + "QTabDialog", + "QTextDrag", + "QToolBar", + "QToolTipGroup", + "QTranslator", + "QUriDrag", + "QUrlOperator", + "QVButtonGroup", + "QVGroupBox", + "QValidator", + "QWSKeyboardHandler", + "QWindowsStyle", + "QWindowsXPStyle", + "QWorkspace", + "QXtWidget", + + 0 + }; + + for ( int i = 0 ; classes[ i ] ; i++ ) { + if ( !isSupported( classes[ i ] ) ) + addType( classes[ i ] ); + } + // Create the custom added types. + QDictIterator<KJSEmbed::Bindings::JSBindingBase> idx( d->objectTypes ); + for( ; idx.current(); ++idx){ + JSFactoryImp *cons = new JSFactoryImp( exec, this, JSFactoryImp::NewInstance, idx.currentKey() ); + parent.put( exec, KJS::Identifier( KJS::UString( cons->parameter() ) ), KJS::Object( cons ) ); + addType( idx.currentKey(), TypeQObject ); + } + } + + void JSFactory::registerOpaqueType( const QString & className, KJSEmbed::Bindings::JSBindingBase * bindingFactory ) + { + d->opaqueTypes.insert(className,bindingFactory); + } + + void JSFactory::unregisterOpaqueType( const QString & className ) + { + d->opaqueTypes.remove(className); + } + + void JSFactory::extendOpaqueProxy( KJS::ExecState * exec, KJS::Object &proxy ) const + { + JSOpaqueProxy *prx = JSProxy::toOpaqueProxy( proxy.imp() ); + if( prx ) + { + kdDebug() << "Looking for " << prx->typeName() << endl; + Bindings::JSBindingBase *bindingFactory = d->opaqueTypes.find( prx->typeName() ); + if( bindingFactory ) + { + kdDebug() << "Extending proxy" << endl; + bindingFactory->addBindings(jspart, exec, proxy ); + } + } + } + void JSFactory::registerObjectType( const QString & className, KJSEmbed::Bindings::JSBindingBase * bindingFactory ) + { + d->objectTypes.insert(className,bindingFactory); + } + + void JSFactory::unregisterObjectType( const QString & className ) + { + d->objectTypes.remove(className); + } + + void JSFactory::extendObjectProxy( KJS::ExecState * exec, KJS::Object &proxy ) const + { + JSObjectProxy *prx = JSProxy::toObjectProxy( proxy.imp() ); + if( prx ) + { + kdDebug() << "Looking for " << prx->typeName() << endl; + Bindings::JSBindingBase *bindingFactory = d->objectTypes.find( prx->typeName() ); + if( bindingFactory ) + { + kdDebug() << "Extending proxy" << endl; + bindingFactory->addBindings(jspart, exec, proxy ); + } + } + } + +}// namespace KJSEmbed + +// Local Variables: +// c-basic-offset: 4 +// End: |