kjs_navigator.cpp

00001 // -*- c-basic-offset: 2 -*-
00002 /*
00003  *  This file is part of the KDE libraries
00004  *  Copyright (C) 2000 Harri Porten (porten@kde.org)
00005  *  Copyright (c) 2000 Daniel Molkentin (molkentin@kde.org)
00006  *  Copyright (c) 2000 Stefan Schimanski (schimmi@kde.org)
00007  *  Copyright (C) 2003 Apple Computer, Inc.
00008  *
00009  *  This library is free software; you can redistribute it and/or
00010  *  modify it under the terms of the GNU Library General Public
00011  *  License as published by the Free Software Foundation; either
00012  *  version 2 of the License, or (at your option) any later version.
00013  *
00014  *  This library is distributed in the hope that it will be useful,
00015  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017  *  Library General Public License for more details.
00018  *
00019  *  You should have received a copy of the GNU Library General Public
00020  *  License along with this library; if not, write to the Free Software
00021  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
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     // All objects that need plugin info must inherit from PluginBase
00046     // Its ctor and dtor take care of the refcounting on the static lists.
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         Value getValueProperty(ExecState *exec, int token) const;
00082         virtual const ClassInfo* classInfo() const { return &info; }
00083         static const ClassInfo info;
00084         Value pluginByName( ExecState* exec, const QString& name ) const;
00085     };
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         Value getValueProperty(ExecState *exec, int token) const;
00095         Value mimeTypeByName( ExecState* exec, const QString& name ) const;
00096     };
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         Value mimeByName(ExecState* exec, const QString& name ) const;
00108         Value getValueProperty(ExecState *exec, int token) const;
00109         PluginBase::PluginInfo *pluginInfo() const { return m_info; }
00110     private:
00111         PluginBase::PluginInfo *m_info;
00112     };
00113 
00114 
00115     class MimeType : public PluginBase {
00116     public:
00117         MimeType( ExecState *exec, PluginBase::MimeClassInfo *info )
00118           : PluginBase( exec )
00119         { m_info = info; };
00120         virtual Value get(ExecState *exec, const Identifier &propertyName) const;
00121         virtual const ClassInfo* classInfo() const { return &info; }
00122         static const ClassInfo info;
00123         Value getValueProperty(ExecState *exec, int token) const;
00124     private:
00125         PluginBase::MimeClassInfo *m_info;
00126     };
00127 
00128 }
00129 
00130 
00131 QPtrList<PluginBase::PluginInfo> *KJS::PluginBase::plugins = 0;
00132 QPtrList<PluginBase::MimeClassInfo> *KJS::PluginBase::mimes = 0;
00133 int KJS::PluginBase::m_refCount = 0;
00134 
00135 const ClassInfo Navigator::info = { "Navigator", 0, &NavigatorTable, 0 };
00136 /*
00137 @begin NavigatorTable 12
00138   appCodeName   Navigator::AppCodeName  DontDelete|ReadOnly
00139   appName   Navigator::AppName  DontDelete|ReadOnly
00140   appVersion    Navigator::AppVersion   DontDelete|ReadOnly
00141   language  Navigator::Language DontDelete|ReadOnly
00142   userAgent Navigator::UserAgent    DontDelete|ReadOnly
00143   userLanguage  Navigator::UserLanguage DontDelete|ReadOnly
00144   browserLanguage Navigator::BrowserLanguage    DontDelete|ReadOnly
00145   platform  Navigator::Platform DontDelete|ReadOnly
00146   cpuClass      Navigator::CpuClass     DontDelete|ReadOnly
00147   plugins   Navigator::_Plugins DontDelete|ReadOnly
00148   mimeTypes Navigator::_MimeTypes   DontDelete|ReadOnly
00149   product   Navigator::Product  DontDelete|ReadOnly
00150   vendor    Navigator::Vendor   DontDelete|ReadOnly
00151   productSub    Navigator::ProductSub   DontDelete|ReadOnly
00152   cookieEnabled Navigator::CookieEnabled DontDelete|ReadOnly
00153   javaEnabled   Navigator::JavaEnabled  DontDelete|Function 0
00154 @end
00155 */
00156 IMPLEMENT_PROTOFUNC_DOM(NavigatorFunc)
00157 
00158 Navigator::Navigator(ExecState *exec, KHTMLPart *p)
00159   : ObjectImp(exec->interpreter()->builtinObjectPrototype()), m_part(p) { }
00160 
00161 Value Navigator::get(ExecState *exec, const Identifier &propertyName) const
00162 {
00163 #ifdef KJS_VERBOSE
00164   kdDebug(6070) << "Navigator::get " << propertyName.ascii() << endl;
00165 #endif
00166   return lookupGet<NavigatorFunc,Navigator,ObjectImp>(exec,propertyName,&NavigatorTable,this);
00167 }
00168 
00169 Value Navigator::getValueProperty(ExecState *exec, int token) const
00170 {
00171   KURL url = m_part->url();
00172   QString userAgent = url.host();
00173   if (userAgent.isEmpty())
00174      userAgent = "localhost";
00175   userAgent = KProtocolManager::userAgentForHost(userAgent);
00176   switch (token) {
00177   case AppCodeName:
00178     return String("Mozilla");
00179   case AppName:
00180     // If we find "Mozilla" but not "(compatible, ...)" we are a real Netscape
00181     if (userAgent.find(QString::fromLatin1("Mozilla")) >= 0 &&
00182         userAgent.find(QString::fromLatin1("compatible")) == -1)
00183     {
00184       //kdDebug() << "appName -> Mozilla" << endl;
00185       return String("Netscape");
00186     }
00187     if (userAgent.find(QString::fromLatin1("Microsoft")) >= 0 ||
00188         userAgent.find(QString::fromLatin1("MSIE")) >= 0)
00189     {
00190       //kdDebug() << "appName -> IE" << endl;
00191       return String("Microsoft Internet Explorer");
00192     }
00193     //kdDebug() << "appName -> Konqueror" << endl;
00194     return String("Konqueror");
00195   case AppVersion:
00196     // We assume the string is something like Mozilla/version (properties)
00197     return String(userAgent.mid(userAgent.find('/') + 1));
00198   case Product:
00199     // We are pretending to be Mozilla or Safari
00200     if (userAgent.find(QString::fromLatin1("Mozilla")) >= 0 &&
00201         userAgent.find(QString::fromLatin1("compatible")) == -1)
00202     {
00203         return String("Gecko");
00204     }
00205     // When spoofing as IE, we use Undefined().
00206     if (userAgent.find(QString::fromLatin1("Microsoft")) >= 0 ||
00207         userAgent.find(QString::fromLatin1("MSIE")) >= 0)
00208     {
00209         return Undefined();
00210     }
00211     // We are acting straight
00212     return String("Konqueror/khtml");
00213   case ProductSub:
00214     {
00215       int ix = userAgent.find("Gecko");
00216       if (ix >= 0 && userAgent.length() >= (uint)ix+14 && userAgent.unicode()[ix+5] == QChar('/') &&
00217           userAgent.find(QRegExp("\\d{8}"), ix+6) == ix+6)
00218       {
00219           // We have Gecko/<productSub> in the UA string
00220           return String(userAgent.mid(ix+6, 8));
00221       }
00222       else if (ix >= 0)
00223       {
00224           return String("20040107");
00225       }
00226     }
00227     return Undefined();
00228   case Vendor:
00229     return String("KDE");
00230   case BrowserLanguage:
00231   case Language:
00232   case UserLanguage:
00233     return String(KGlobal::locale()->language());
00234   case UserAgent:
00235     return String(userAgent);
00236   case Platform:
00237     // yet another evil hack, but necessary to spoof some sites...
00238     if ( (userAgent.find(QString::fromLatin1("Win"),0,false)>=0) )
00239       return String(QString::fromLatin1("Win32"));
00240     else if ( (userAgent.find(QString::fromLatin1("Macintosh"),0,false)>=0) ||
00241               (userAgent.find(QString::fromLatin1("Mac_PowerPC"),0,false)>=0) )
00242       return String(QString::fromLatin1("MacPPC"));
00243     else
00244     {
00245         struct utsname name;
00246         int ret = uname(&name);
00247         if ( ret >= 0 )
00248             return String(QString::fromLatin1("%1 %1 X11").arg(name.sysname).arg(name.machine));
00249         else // can't happen
00250             return String(QString::fromLatin1("Unix X11"));
00251     }
00252   case CpuClass:
00253   {
00254     struct utsname name;
00255     int ret = uname(&name);
00256     if ( ret >= 0 )
00257       return String(name.machine);
00258     else // can't happen
00259       return String("x86");
00260   }
00261   case _Plugins:
00262     return Value(new Plugins(exec));
00263   case _MimeTypes:
00264     return Value(new MimeTypes(exec));
00265   case CookieEnabled:
00266     return Boolean(true); 
00267   default:
00268     kdDebug(6070) << "WARNING: Unhandled token in DOMEvent::getValueProperty : " << token << endl;
00269     return Value();
00270   }
00271 }
00272 
00273 /*******************************************************************/
00274 
00275 PluginBase::PluginBase(ExecState *exec)
00276   : ObjectImp(exec->interpreter()->builtinObjectPrototype() )
00277 {
00278     if ( !plugins ) {
00279         plugins = new QPtrList<PluginInfo>;
00280         mimes = new QPtrList<MimeClassInfo>;
00281         plugins->setAutoDelete( true );
00282         mimes->setAutoDelete( true );
00283 
00284         // FIXME: add domain support here
00285         KConfig kc("konquerorrc", true);
00286         if (!KConfigGroup(&kc, "Java/JavaScript Settings").readBoolEntry("EnablePlugins", true))
00287             return; // plugins disabled
00288 
00289         // read in using KTrader
00290         KTrader::OfferList offers = KTrader::self()->query("Browser/View");
00291         KTrader::OfferList::iterator it;
00292         for ( it = offers.begin(); it != offers.end(); ++it ) {
00293 
00294             QVariant pluginsinfo = (**it).property( "X-KDE-BrowserView-PluginsInfo" );
00295             if ( !pluginsinfo.isValid() ) {
00296                 // <backwards compatible>
00297                 if ((**it).library() == QString("libnsplugin"))
00298                     pluginsinfo = QVariant("nsplugins/pluginsinfo");
00299                 else
00300                 // </backwards compatible>
00301                     continue;
00302             }
00303             // read configuration
00304             KConfig kc( locate ("data", pluginsinfo.toString()) );
00305             unsigned num = (unsigned int) kc.readNumEntry("number");
00306             for ( unsigned n = 0; n < num; n++ ) {
00307                 kc.setGroup( QString::number(n) );
00308                 PluginInfo *plugin = new PluginInfo;
00309 
00310                 plugin->name = kc.readEntry("name");
00311                 plugin->file = kc.readPathEntry("file");
00312                 plugin->desc = kc.readEntry("description");
00313 
00314                 plugins->append( plugin );
00315 
00316                 // get mime types from string
00317                 QStringList types = QStringList::split( ';', kc.readEntry("mime") );
00318                 QStringList::Iterator type;
00319                 for ( type=types.begin(); type!=types.end(); ++type ) {
00320 
00321                     // get mime information
00322                     QStringList tokens = QStringList::split(':', *type, true);
00323                     if ( tokens.count() < 3 ) // we need 3 items
00324                         continue;
00325 
00326                     MimeClassInfo *mime = new MimeClassInfo;
00327                     QStringList::Iterator token = tokens.begin();
00328                     mime->type = (*token).lower();
00329                     //kdDebug(6070) << "mime->type=" << mime->type << endl;
00330                     ++token;
00331 
00332                     mime->suffixes = *token;
00333                     ++token;
00334 
00335                     mime->desc = *token;
00336                     ++token;
00337 
00338                     mime->plugin = plugin;
00339 
00340                     mimes->append( mime );
00341                     plugin->mimes.append( mime );
00342 
00343                 }
00344             }
00345         }
00346     }
00347 
00348     m_refCount++;
00349 }
00350 
00351 PluginBase::~PluginBase()
00352 {
00353     m_refCount--;
00354     if ( m_refCount==0 ) {
00355         delete plugins;
00356         delete mimes;
00357         plugins = 0;
00358         mimes = 0;
00359     }
00360 }
00361 
00362 
00363 /*******************************************************************/
00364 
00365 const ClassInfo Plugins::info = { "PluginArray", 0, &PluginsTable, 0 };
00366 /*
00367 @begin PluginsTable 4
00368   length    Plugins_Length      DontDelete|ReadOnly
00369   refresh   Plugins_Refresh     DontDelete|Function 0
00370   item      Plugins_Item        DontDelete|Function 1
00371   namedItem     Plugins_NamedItem       DontDelete|Function 1
00372 @end
00373 */
00374 IMPLEMENT_PROTOFUNC_DOM(PluginsFunc)
00375 
00376 Value Plugins::get(ExecState *exec, const Identifier &propertyName) const
00377 {
00378 #ifdef KJS_VERBOSE
00379   kdDebug(6070) << "Plugins::get " << propertyName.qstring() << endl;
00380 #endif
00381   if ( propertyName == lengthPropertyName )
00382     return Number(plugins->count());
00383 
00384   // plugins[#]
00385   bool ok;
00386   unsigned int i = propertyName.toULong(&ok);
00387   if( ok && i<plugins->count() )
00388     return Value( new Plugin( exec, plugins->at(i) ) );
00389 
00390   // plugin[name]
00391   Value val = pluginByName( exec, propertyName.qstring() );
00392   if (!val.isA(UndefinedType))
00393     return val;
00394 
00395   return lookupGet<PluginsFunc,Plugins,ObjectImp>(exec,propertyName,&PluginsTable,this);
00396 }
00397 
00398 Value Plugins::pluginByName( ExecState* exec, const QString& name ) const
00399 {
00400   for ( PluginInfo *pl = plugins->first(); pl!=0; pl = plugins->next() ) {
00401     if ( pl->name == name )
00402       return Value( new Plugin( exec, pl ) );
00403   }
00404   return Undefined();
00405 }
00406 
00407 Value Plugins::getValueProperty(ExecState* /*exec*/, int token) const
00408 {
00409   kdDebug(6070) << "WARNING: Unhandled token in Plugins::getValueProperty : " << token << endl;
00410   return Undefined();
00411 }
00412 
00413 Value PluginsFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00414 {
00415   KJS_CHECK_THIS( KJS::Plugins, thisObj );
00416   KJS::Plugins* base = static_cast<KJS::Plugins *>(thisObj.imp());
00417   switch( id ) {
00418   case Plugins_Refresh:
00419     return Undefined(); //## TODO
00420   case Plugins_Item:
00421   {
00422     bool ok;
00423     unsigned int i = args[0].toString(exec).toArrayIndex(&ok);
00424     if( ok && i<base->plugins->count() )
00425       return Value( new Plugin( exec, base->plugins->at(i) ) );
00426     return Undefined();
00427   }
00428   case Plugins_NamedItem:
00429   {
00430     UString s = args[0].toString(exec);
00431     return base->pluginByName( exec, s.qstring() );
00432   }
00433   default:
00434     kdDebug(6070) << "WARNING: Unhandled token in PluginsFunc::tryCall : " << id << endl;
00435     return Undefined();
00436   }
00437 }
00438 
00439 /*******************************************************************/
00440 
00441 const ClassInfo MimeTypes::info = { "MimeTypeArray", 0, &MimeTypesTable, 0 };
00442 /*
00443 @begin MimeTypesTable 3
00444   length    MimeTypes_Length    DontDelete|ReadOnly
00445   item      MimeTypes_Item      DontDelete|Function 1
00446   namedItem     MimeTypes_NamedItem     DontDelete|Function 1
00447 @end
00448 */
00449 IMPLEMENT_PROTOFUNC_DOM(MimeTypesFunc)
00450 
00451 Value MimeTypes::get(ExecState *exec, const Identifier &propertyName) const
00452 {
00453 #ifdef KJS_VERBOSE
00454   kdDebug(6070) << "MimeTypes::get " << propertyName.qstring() << endl;
00455 #endif
00456   if( propertyName==lengthPropertyName )
00457     return Number( mimes->count() );
00458 
00459   // mimeTypes[#]
00460   bool ok;
00461   unsigned int i = propertyName.toULong(&ok);
00462   if( ok && i<mimes->count() )
00463     return Value( new MimeType( exec, mimes->at(i) ) );
00464 
00465   // mimeTypes[name]
00466   Value val = mimeTypeByName( exec, propertyName.qstring() );
00467   if (!val.isA(UndefinedType))
00468     return val;
00469 
00470   return lookupGet<MimeTypesFunc,MimeTypes,ObjectImp>(exec,propertyName,&MimeTypesTable,this);
00471 }
00472 
00473 Value MimeTypes::mimeTypeByName( ExecState* exec, const QString& name ) const
00474 {
00475   //kdDebug(6070) << "MimeTypes[" << name << "]" << endl;
00476   for ( MimeClassInfo *m = mimes->first(); m!=0; m = mimes->next() ) {
00477     if ( m->type == name )
00478       return Value( new MimeType( exec, m ) );
00479   }
00480   return Undefined();
00481 }
00482 
00483 Value MimeTypes::getValueProperty(ExecState* /*exec*/, int token) const
00484 {
00485   kdDebug(6070) << "WARNING: Unhandled token in MimeTypes::getValueProperty : " << token << endl;
00486   return Undefined();
00487 }
00488 
00489 Value MimeTypesFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00490 {
00491   KJS_CHECK_THIS( KJS::MimeTypes, thisObj );
00492   KJS::MimeTypes* base = static_cast<KJS::MimeTypes *>(thisObj.imp());
00493   switch( id ) {
00494   case MimeTypes_Item:
00495   {
00496     bool ok;
00497     unsigned int i = args[0].toString(exec).toArrayIndex(&ok);
00498     if( ok && i<base->mimes->count() )
00499       return Value( new MimeType( exec, base->mimes->at(i) ) );
00500     return Undefined();
00501   }
00502   case MimeTypes_NamedItem:
00503   {
00504     UString s = args[0].toString(exec);
00505     return base->mimeTypeByName( exec, s.qstring() );
00506   }
00507   default:
00508     kdDebug(6070) << "WARNING: Unhandled token in MimeTypesFunc::tryCall : " << id << endl;
00509     return Undefined();
00510   }
00511 }
00512 
00513 /************************************************************************/
00514 const ClassInfo Plugin::info = { "Plugin", 0, &PluginTable, 0 };
00515 /*
00516 @begin PluginTable 7
00517   name      Plugin_Name     DontDelete|ReadOnly
00518   filename      Plugin_FileName     DontDelete|ReadOnly
00519   description   Plugin_Description      DontDelete|ReadOnly
00520   length    Plugin_Length       DontDelete|ReadOnly
00521   item      Plugin_Item     DontDelete|Function 1
00522   namedItem     Plugin_NamedItem    DontDelete|Function 1
00523 @end
00524 */
00525 IMPLEMENT_PROTOFUNC_DOM(PluginFunc)
00526 
00527 Value Plugin::get(ExecState *exec, const Identifier &propertyName) const
00528 {
00529 #ifdef KJS_VERBOSE
00530   kdDebug(6070) << "Plugin::get " << propertyName.qstring() << endl;
00531 #endif
00532   if ( propertyName == lengthPropertyName )
00533     return Number( m_info->mimes.count() );
00534 
00535   // plugin[#]
00536   bool ok;
00537   unsigned int i = propertyName.toULong(&ok);
00538   //kdDebug(6070) << "Plugin::get plugin[" << i << "]" << endl;
00539   if( ok && i<m_info->mimes.count() )
00540   {
00541     //kdDebug(6070) << "returning mimetype " << m_info->mimes.at(i)->type << endl;
00542     return Value(new MimeType(exec, m_info->mimes.at(i)));
00543   }
00544 
00545   // plugin["name"]
00546   Value val = mimeByName( exec, propertyName.qstring() );
00547   if (!val.isA(UndefinedType))
00548     return val;
00549 
00550   return lookupGet<PluginFunc,Plugin,ObjectImp>(exec, propertyName, &PluginTable, this );
00551 }
00552 
00553 Value Plugin::mimeByName(ExecState* exec, const QString& name) const
00554 {
00555   for ( PluginBase::MimeClassInfo *m = m_info->mimes.first();
00556         m != 0; m = m_info->mimes.next() ) {
00557     if ( m->type == name )
00558       return Value(new MimeType(exec, m));
00559   }
00560   return Undefined();
00561 }
00562 
00563 Value Plugin::getValueProperty(ExecState* /*exec*/, int token) const
00564 {
00565   switch( token ) {
00566   case Plugin_Name:
00567     return String( m_info->name );
00568   case Plugin_FileName:
00569     return String( m_info->file );
00570   case Plugin_Description:
00571     return String( m_info->desc );
00572   default:
00573     kdDebug(6070) << "WARNING: Unhandled token in Plugin::getValueProperty : " << token << endl;
00574     return Undefined();
00575   }
00576 }
00577 
00578 Value PluginFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
00579 {
00580   KJS_CHECK_THIS( KJS::Plugin, thisObj );
00581   KJS::Plugin* plugin = static_cast<KJS::Plugin *>(thisObj.imp());
00582   switch( id ) {
00583   case Plugin_Item:
00584   {
00585     bool ok;
00586     unsigned int i = args[0].toString(exec).toArrayIndex(&ok);
00587     if( ok && i< plugin->pluginInfo()->mimes.count() )
00588       return Value( new MimeType( exec, plugin->pluginInfo()->mimes.at(i) ) );
00589     return Undefined();
00590   }
00591   case Plugin_NamedItem:
00592   {
00593     UString s = args[0].toString(exec);
00594     return plugin->mimeByName( exec, s.qstring() );
00595   }
00596   default:
00597     kdDebug(6070) << "WARNING: Unhandled token in PluginFunc::tryCall : " << id << endl;
00598     return Undefined();
00599   }
00600 }
00601 
00602 /*****************************************************************************/
00603 
00604 const ClassInfo MimeType::info = { "MimeType", 0, &MimeTypesTable, 0 };
00605 /*
00606 @begin MimeTypeTable 4
00607   description   MimeType_Description        DontDelete|ReadOnly
00608   enabledPlugin MimeType_EnabledPlugin      DontDelete|ReadOnly
00609   suffixes  MimeType_Suffixes           DontDelete|ReadOnly
00610   type      MimeType_Type           DontDelete|ReadOnly
00611 @end
00612 */
00613 
00614 Value MimeType::get(ExecState *exec, const Identifier &propertyName) const
00615 {
00616 #ifdef KJS_VERBOSE
00617   kdDebug(6070) << "MimeType::get " << propertyName.qstring() << endl;
00618 #endif
00619   return lookupGetValue<MimeType,ObjectImp>(exec, propertyName, &MimeTypeTable, this );
00620 }
00621 
00622 Value MimeType::getValueProperty(ExecState* exec, int token) const
00623 {
00624   switch( token ) {
00625   case MimeType_Type:
00626     return String( m_info->type );
00627   case MimeType_Suffixes:
00628     return String( m_info->suffixes );
00629   case MimeType_Description:
00630     return String( m_info->desc );
00631   case MimeType_EnabledPlugin:
00632     return Value(new Plugin(exec, m_info->plugin));
00633   default:
00634     kdDebug(6070) << "WARNING: Unhandled token in MimeType::getValueProperty : " << token << endl;
00635     return Undefined();
00636   }
00637 }
00638 
00639 
00640 Value NavigatorFunc::tryCall(ExecState *exec, Object &thisObj, const List &)
00641 {
00642   KJS_CHECK_THIS( KJS::Navigator, thisObj );
00643   Navigator *nav = static_cast<Navigator *>(thisObj.imp());
00644   // javaEnabled()
00645   return Boolean(nav->part()->javaEnabled());
00646 }
KDE Home | KDE Accessibility Home | Description of Access Keys