00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <klocale.h>
00025
00026 #include <kstandarddirs.h>
00027 #include <kconfig.h>
00028 #include <kdebug.h>
00029
00030 #include <kio/kprotocolmanager.h>
00031 #include <kio/kmimetype.h>
00032 #include <kio/kservice.h>
00033 #include <kio/ktrader.h>
00034 #include "kjs_navigator.h"
00035 #include "kjs/lookup.h"
00036 #include "kjs_binding.h"
00037 #include "khtml_part.h"
00038 #include <sys/utsname.h>
00039 #include "kjs_navigator.lut.h"
00040
00041 using namespace KJS;
00042
00043 namespace KJS {
00044
00045
00046
00047 class PluginBase : public ObjectImp {
00048 public:
00049 PluginBase(ExecState *exec);
00050 virtual ~PluginBase();
00051
00052 struct MimeClassInfo;
00053 struct PluginInfo;
00054
00055 struct MimeClassInfo {
00056 QString type;
00057 QString desc;
00058 QString suffixes;
00059 PluginInfo *plugin;
00060 };
00061
00062 struct PluginInfo {
00063 QString name;
00064 QString file;
00065 QString desc;
00066 QPtrList<MimeClassInfo> mimes;
00067 };
00068
00069 static QPtrList<PluginInfo> *plugins;
00070 static QPtrList<MimeClassInfo> *mimes;
00071
00072 private:
00073 static int m_refCount;
00074 };
00075
00076
00077 class Plugins : public PluginBase {
00078 public:
00079 Plugins(ExecState *exec) : PluginBase(exec) {};
00080 virtual Value get(ExecState *exec, const Identifier &propertyName) const;
00081 virtual const ClassInfo* classInfo() const { return &info; }
00082 static const ClassInfo info;
00083 private:
00084 };
00085 const ClassInfo Plugins::info = { "PluginArray", 0, 0, 0 };
00086
00087
00088 class MimeTypes : public PluginBase {
00089 public:
00090 MimeTypes(ExecState *exec) : PluginBase(exec) { };
00091 virtual Value get(ExecState *exec, const Identifier &propertyName) const;
00092 virtual const ClassInfo* classInfo() const { return &info; }
00093 static const ClassInfo info;
00094 private:
00095 };
00096 const ClassInfo MimeTypes::info = { "MimeTypeArray", 0, 0, 0 };
00097
00098
00099 class Plugin : public PluginBase {
00100 public:
00101 Plugin( ExecState *exec, PluginBase::PluginInfo *info )
00102 : PluginBase( exec )
00103 { m_info = info; };
00104 virtual Value get(ExecState *exec, const Identifier &propertyName) const;
00105 virtual const ClassInfo* classInfo() const { return &info; }
00106 static const ClassInfo info;
00107 private:
00108 PluginBase::PluginInfo *m_info;
00109 };
00110 const ClassInfo Plugin::info = { "Plugin", 0, 0, 0 };
00111
00112
00113 class MimeType : public PluginBase {
00114 public:
00115 MimeType( ExecState *exec, PluginBase::MimeClassInfo *info )
00116 : PluginBase( exec )
00117 { m_info = info; };
00118 virtual Value get(ExecState *exec, const Identifier &propertyName) const;
00119 virtual const ClassInfo* classInfo() const { return &info; }
00120 static const ClassInfo info;
00121 private:
00122 PluginBase::MimeClassInfo *m_info;
00123 };
00124 const ClassInfo MimeType::info = { "MimeType", 0, 0, 0 };
00125
00126 }
00127
00128
00129 QPtrList<PluginBase::PluginInfo> *KJS::PluginBase::plugins = 0;
00130 QPtrList<PluginBase::MimeClassInfo> *KJS::PluginBase::mimes = 0;
00131 int KJS::PluginBase::m_refCount = 0;
00132
00133 const ClassInfo Navigator::info = { "Navigator", 0, &NavigatorTable, 0 };
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151 IMPLEMENT_PROTOFUNC_DOM(NavigatorFunc)
00152
00153 Navigator::Navigator(ExecState *exec, KHTMLPart *p)
00154 : ObjectImp(exec->interpreter()->builtinObjectPrototype()), m_part(p) { }
00155
00156 Value Navigator::get(ExecState *exec, const Identifier &propertyName) const
00157 {
00158 #ifdef KJS_VERBOSE
00159 kdDebug(6070) << "Navigator::get " << propertyName.ascii() << endl;
00160 #endif
00161 return lookupGet<NavigatorFunc,Navigator,ObjectImp>(exec,propertyName,&NavigatorTable,this);
00162 }
00163
00164 Value Navigator::getValueProperty(ExecState *exec, int token) const
00165 {
00166 KURL url = m_part->url();
00167 QString userAgent = KProtocolManager::userAgentForHost(url.host());
00168 switch (token) {
00169 case AppCodeName:
00170 return String("Mozilla");
00171 case AppName:
00172
00173 if (userAgent.find(QString::fromLatin1("Mozilla")) >= 0 &&
00174 userAgent.find(QString::fromLatin1("compatible")) == -1)
00175 {
00176
00177 return String("Netscape");
00178 }
00179 if (userAgent.find(QString::fromLatin1("Microsoft")) >= 0 ||
00180 userAgent.find(QString::fromLatin1("MSIE")) >= 0)
00181 {
00182
00183 return String("Microsoft Internet Explorer");
00184 }
00185
00186 return String("Konqueror");
00187 case AppVersion:
00188
00189 return String(userAgent.mid(userAgent.find('/') + 1));
00190 case Product:
00191 return String("Konqueror/khtml");
00192 case Vendor:
00193 return String("KDE");
00194 case Language:
00195 case UserLanguage:
00196 return String(KGlobal::locale()->language());
00197 case UserAgent:
00198 return String(userAgent);
00199 case Platform:
00200
00201 if ( (userAgent.find(QString::fromLatin1("Win"),0,false)>=0) )
00202 return String(QString::fromLatin1("Win32"));
00203 else if ( (userAgent.find(QString::fromLatin1("Macintosh"),0,false)>=0) ||
00204 (userAgent.find(QString::fromLatin1("Mac_PowerPC"),0,false)>=0) )
00205 return String(QString::fromLatin1("MacPPC"));
00206 else
00207 {
00208 struct utsname name;
00209 int ret = uname(&name);
00210 if ( ret >= 0 )
00211 return String(QString::fromLatin1("%1 %1 X11").arg(name.sysname).arg(name.machine));
00212 else
00213 return String(QString::fromLatin1("Unix X11"));
00214 }
00215 case _Plugins:
00216 return Value(new Plugins(exec));
00217 case _MimeTypes:
00218 return Value(new MimeTypes(exec));
00219 case CookieEnabled:
00220 return Boolean(true);
00221 default:
00222 kdDebug(6070) << "WARNING: Unhandled token in DOMEvent::getValueProperty : " << token << endl;
00223 return Value();
00224 }
00225 }
00226
00227
00228
00229 PluginBase::PluginBase(ExecState *exec)
00230 : ObjectImp(exec->interpreter()->builtinObjectPrototype() )
00231 {
00232 if ( !plugins ) {
00233 plugins = new QPtrList<PluginInfo>;
00234 mimes = new QPtrList<MimeClassInfo>;
00235 plugins->setAutoDelete( true );
00236 mimes->setAutoDelete( true );
00237
00238
00239 KConfig kc("konquerorrc", true);
00240 if (!KConfigGroup(&kc, "Java/JavaScript Settings").readBoolEntry("EnablePlugins", true))
00241 return;
00242
00243
00244 KTrader::OfferList offers = KTrader::self()->query("Browser/View");
00245 KTrader::OfferList::iterator it;
00246 for ( it = offers.begin(); it != offers.end(); ++it ) {
00247
00248 QVariant pluginsinfo = (**it).property( "X-KDE-BrowserView-PluginsInfo" );
00249 if ( !pluginsinfo.isValid() ) {
00250
00251 if ((**it).library() == QString("libnsplugin"))
00252 pluginsinfo = QVariant("nsplugins/pluginsinfo");
00253 else
00254
00255 continue;
00256 }
00257
00258 KConfig kc( locate ("data", pluginsinfo.toString()) );
00259 unsigned num = (unsigned int) kc.readNumEntry("number");
00260 for ( unsigned n = 0; n < num; n++ ) {
00261 kc.setGroup( QString::number(n) );
00262 PluginInfo *plugin = new PluginInfo;
00263
00264 plugin->name = kc.readEntry("name");
00265 plugin->file = kc.readPathEntry("file");
00266 plugin->desc = kc.readEntry("description");
00267
00268 plugins->append( plugin );
00269
00270
00271 QStringList types = QStringList::split( ';', kc.readEntry("mime") );
00272 QStringList::Iterator type;
00273 for ( type=types.begin(); type!=types.end(); ++type ) {
00274
00275
00276 QStringList tokens = QStringList::split(':', *type, true);
00277 if ( tokens.count() < 3 )
00278 continue;
00279
00280 MimeClassInfo *mime = new MimeClassInfo;
00281 QStringList::Iterator token = tokens.begin();
00282 mime->type = (*token).lower();
00283
00284 ++token;
00285
00286 mime->suffixes = *token;
00287 ++token;
00288
00289 mime->desc = *token;
00290 ++token;
00291
00292 mime->plugin = plugin;
00293
00294 mimes->append( mime );
00295 plugin->mimes.append( mime );
00296
00297 }
00298 }
00299 }
00300 }
00301
00302 m_refCount++;
00303 }
00304
00305 PluginBase::~PluginBase()
00306 {
00307 m_refCount--;
00308 if ( m_refCount==0 ) {
00309 delete plugins;
00310 delete mimes;
00311 plugins = 0;
00312 mimes = 0;
00313 }
00314 }
00315
00316
00317
00318 IMPLEMENT_PROTOFUNC_DOM(PluginsFunc)
00319
00320 Value Plugins::get(ExecState *exec, const Identifier &propertyName) const
00321 {
00322 #ifdef KJS_VERBOSE
00323 kdDebug(6070) << "Plugins::get " << propertyName.qstring() << endl;
00324 #endif
00325 if (propertyName == "refresh")
00326 return lookupOrCreateFunction<PluginsFunc>(exec,propertyName,this,0,0,DontDelete|Function);
00327 else if ( propertyName ==lengthPropertyName )
00328 return Number(plugins->count());
00329 else {
00330
00331
00332 bool ok;
00333 unsigned int i = propertyName.toULong(&ok);
00334 if( ok && i<plugins->count() )
00335 return Value( new Plugin( exec, plugins->at(i) ) );
00336
00337
00338 for ( PluginInfo *pl = plugins->first(); pl!=0; pl = plugins->next() ) {
00339 if ( pl->name==propertyName.string() )
00340 return Value( new Plugin( exec, pl ) );
00341 }
00342 }
00343
00344 return PluginBase::get(exec, propertyName);
00345 }
00346
00347
00348
00349 Value MimeTypes::get(ExecState *exec, const Identifier &propertyName) const
00350 {
00351 #ifdef KJS_VERBOSE
00352 kdDebug(6070) << "MimeTypes::get " << propertyName.qstring() << endl;
00353 #endif
00354 if( propertyName==lengthPropertyName )
00355 return Number( mimes->count() );
00356 else {
00357
00358
00359 bool ok;
00360 unsigned int i = propertyName.toULong(&ok);
00361 if( ok && i<mimes->count() )
00362 return Value( new MimeType( exec, mimes->at(i) ) );
00363
00364
00365
00366 for ( MimeClassInfo *m=mimes->first(); m!=0; m=mimes->next() ) {
00367
00368 if ( m->type == propertyName.string() )
00369 return Value( new MimeType( exec, m ) );
00370 }
00371 }
00372
00373 return PluginBase::get(exec, propertyName);
00374 }
00375
00376
00377
00378
00379 Value Plugin::get(ExecState *exec, const Identifier &propertyName) const
00380 {
00381 #ifdef KJS_VERBOSE
00382 kdDebug(6070) << "Plugin::get " << propertyName.qstring() << endl;
00383 #endif
00384 if ( propertyName=="name" )
00385 return String( m_info->name );
00386 else if ( propertyName == "filename" )
00387 return String( m_info->file );
00388 else if ( propertyName == "description" )
00389 return String( m_info->desc );
00390 else if ( propertyName == lengthPropertyName )
00391 return Number( m_info->mimes.count() );
00392 else {
00393
00394
00395 bool ok;
00396 unsigned int i = propertyName.toULong(&ok);
00397
00398 if( ok && i<m_info->mimes.count() )
00399 {
00400
00401 return Value(new MimeType(exec, m_info->mimes.at(i)));
00402 }
00403
00404
00405 for ( PluginBase::MimeClassInfo *m=m_info->mimes.first();
00406 m!=0; m=m_info->mimes.next() ) {
00407 if ( m->type==propertyName.string() )
00408 return Value(new MimeType(exec, m));
00409 }
00410
00411 }
00412
00413 return ObjectImp::get(exec,propertyName);
00414 }
00415
00416
00417
00418
00419 Value MimeType::get(ExecState *exec, const Identifier &propertyName) const
00420 {
00421 #ifdef KJS_VERBOSE
00422 kdDebug(6070) << "MimeType::get " << propertyName.qstring() << endl;
00423 #endif
00424 if ( propertyName == "type" )
00425 return String( m_info->type );
00426 else if ( propertyName == "suffixes" )
00427 return String( m_info->suffixes );
00428 else if ( propertyName == "description" )
00429 return String( m_info->desc );
00430 else if ( propertyName == "enabledPlugin" )
00431 return Value(new Plugin(exec, m_info->plugin));
00432
00433 return ObjectImp::get(exec,propertyName);
00434 }
00435
00436
00437 Value PluginsFunc::tryCall(ExecState *, Object &, const List &)
00438 {
00439 return Undefined();
00440 }
00441
00442
00443 Value NavigatorFunc::tryCall(ExecState *exec, Object &thisObj, const List &)
00444 {
00445 KJS_CHECK_THIS( KJS::Navigator, thisObj );
00446 Navigator *nav = static_cast<Navigator *>(thisObj.imp());
00447
00448 return Boolean(nav->part()->javaEnabled());
00449 }