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 }