kexi

widgetlibrary.cpp

00001 /* This file is part of the KDE project
00002    Copyright (C) 2003 Lucijan Busch <lucijan@gmx.at>
00003    Copyright (C) 2004 Cedric Pasteur <cedric.pasteur@free.fr>
00004    Copyright (C) 2004-2005 Jaroslaw Staniek <js@iidea.pl>
00005 
00006    This library is free software; you can redistribute it and/or
00007    modify it under the terms of the GNU Library General Public
00008    License as published by the Free Software Foundation; either
00009    version 2 of the License, or (at your option) any later version.
00010 
00011    This library is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014    Library General Public License for more details.
00015 
00016    You should have received a copy of the GNU Library General Public License
00017    along with this library; see the file COPYING.LIB.  If not, write to
00018    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00019  * Boston, MA 02110-1301, USA.
00020 */
00021 
00022 #include <qdom.h>
00023 
00024 #include <kdebug.h>
00025 #include <klocale.h>
00026 #include <klibloader.h>
00027 #include <kparts/componentfactory.h>
00028 #include <ktrader.h>
00029 #include <kiconloader.h>
00030 #include <kpopupmenu.h>
00031 
00032 #include "widgetfactory.h"
00033 #include "widgetlibrary.h"
00034 #include "libactionwidget.h"
00035 #include "container.h"
00036 #include "form.h"
00037 #include "formIO.h"
00038 
00039 namespace KFormDesigner {
00041 class WidgetLibraryPrivate
00042 {
00043     public:
00044         WidgetLibraryPrivate()
00045          : widgets(101)
00046 //       , alternateWidgets(101)
00047          , services(101, false)
00048          , supportedFactoryGroups(17, false)
00049          , factories(101, false)
00050          , advancedProperties(1009, true)
00051          , hiddenClasses(101, true)
00052          , showAdvancedProperties(true)
00053          , factoriesLoaded(false)
00054         {
00055             services.setAutoDelete(true);
00056             advancedProperties.insert("autoMask", (char*)1);
00057             advancedProperties.insert("baseSize", (char*)1);
00058             advancedProperties.insert("mouseTracking", (char*)1);
00059             advancedProperties.insert("acceptDrops", (char*)1);
00060             advancedProperties.insert("cursorPosition", (char*)1);
00061             advancedProperties.insert("contextMenuEnabled", (char*)1);
00062             advancedProperties.insert("trapEnterKeyEvent", (char*)1);
00063             advancedProperties.insert("dragEnabled", (char*)1);
00064             advancedProperties.insert("enableSqueezedText", (char*)1);
00065             advancedProperties.insert("sizeIncrement", (char*)1); advancedProperties.insert("palette", (char*)1);
00067             advancedProperties.insert("backgroundOrigin", (char*)1);
00068             advancedProperties.insert("backgroundMode", (char*)1);//this is rather useless
00069             advancedProperties.insert("layout", (char*)1);// too large risk to break things
00070                                                           // by providing this in propeditor
00071 #ifdef KEXI_NO_UNFINISHED
00072 
00073             advancedProperties.insert("paletteBackgroundPixmap", (char*)1);
00074             advancedProperties.insert("icon", (char*)1);
00075             advancedProperties.insert("pixmap", (char*)1);
00076             advancedProperties.insert("accel", (char*)1);
00077 #endif
00078         }
00079         // dict which associates a class name with a Widget class
00080         WidgetInfo::Dict widgets;//, alternateWidgets;
00081         QAsciiDict<KService::Ptr> services;
00082         QAsciiDict<char> supportedFactoryGroups;
00083         QAsciiDict<WidgetFactory> factories;
00084         QAsciiDict<char> advancedProperties;
00085         QAsciiDict<char> hiddenClasses;
00086         bool showAdvancedProperties : 1;
00087         bool factoriesLoaded : 1;
00088 };
00089 }
00090 
00091 using namespace KFormDesigner;
00092 
00093 //-------------------------------------------
00094 
00095 WidgetLibrary::WidgetLibrary(QObject *parent, const QStringList& supportedFactoryGroups)
00096  : QObject(parent)
00097  , d(new WidgetLibraryPrivate())
00098 {
00099     for (QStringList::ConstIterator it = supportedFactoryGroups.constBegin();
00100         it!=supportedFactoryGroups.constEnd(); ++it)
00101     {
00102         d->supportedFactoryGroups.insert( (*it).lower().latin1(), (char*)1);
00103     }
00104     lookupFactories();
00105 }
00106 
00107 WidgetLibrary::~WidgetLibrary()
00108 {
00109     delete d;
00110 }
00111 
00112 void
00113 WidgetLibrary::loadFactoryWidgets(WidgetFactory *f)
00114 {
00115     const WidgetInfo::Dict widgets = f->classes();
00116     WidgetInfo *w;
00117     for(QAsciiDictIterator<WidgetInfo> it(widgets); (w = it.current()); ++it)
00118     {
00119         if (0 != d->hiddenClasses[ w->className() ])
00120             continue; //this class is hidden
00121         // check if we want to inherit a widget from a different factory
00122         if (!w->m_parentFactoryName.isEmpty() && !w->m_inheritedClassName.isEmpty()) {
00123             WidgetFactory *parentFactory = d->factories[w->m_parentFactoryName];
00124             if (!parentFactory) {
00125                 kdWarning() << "WidgetLibrary::loadFactoryWidgets(): class '" << w->className()
00126                     << "' - no such parent factory '" << w->m_parentFactoryName << "'" << endl;
00127                 continue;
00128             }
00129             WidgetInfo* inheritedClass = parentFactory->m_classesByName[ w->m_inheritedClassName ];
00130             if (!inheritedClass) {
00131                 kdWarning() << "WidgetLibrary::loadFactoryWidgets(): class '" << w->m_inheritedClassName
00132                     << "' - no such class to inherit in factory '" << w->m_parentFactoryName << "'" << endl;
00133                 continue;
00134             }
00135             //ok: inherit properties:
00136             w->m_inheritedClass = inheritedClass;
00137             if (w->pixmap().isEmpty())
00138                 w->setPixmap( inheritedClass->pixmap() );
00139             //ok?
00140             foreach (QValueList<QCString>::ConstIterator, it_alt, inheritedClass->m_alternateNames) {
00141                 w->addAlternateClassName( *it_alt, inheritedClass->isOverriddenClassName( *it_alt ) );
00142             }
00143             if (w->includeFileName().isEmpty())
00144                 w->setIncludeFileName( inheritedClass->includeFileName() );
00145             if (w->name().isEmpty())
00146                 w->setName( inheritedClass->name() );
00147             if (w->namePrefix().isEmpty())
00148                 w->setNamePrefix( inheritedClass->namePrefix() );
00149             if (w->description().isEmpty())
00150                 w->setDescription( inheritedClass->description() );
00151         }
00152 
00153 //      kdDebug() << "WidgetLibrary::addFactory(): adding class " << w->className() << endl;
00154         QValueList<QCString> l = w->alternateClassNames();
00155         l.prepend( w->className() );
00156         //d->widgets.insert(w->className(), w);
00157 //      if(!w->alternateClassName().isEmpty()) {
00158 //          QStringList l = QStringList::split("|", w->alternateClassName());
00159         QValueList<QCString>::ConstIterator endIt = l.constEnd();
00160         for(QValueList<QCString>::ConstIterator it = l.constBegin(); it != endIt; ++it) {
00161             WidgetInfo *widgetForClass = d->widgets.find( *it );
00162             if (!widgetForClass || (widgetForClass && !widgetForClass->isOverriddenClassName(*it))) {
00163                 //insert a widgetinfo, if:
00164                 //1) this class has no alternate class assigned yet, or
00165                 //2) this class has alternate class assigned but without 'override' flag
00166                 d->widgets.replace( *it, w);
00167             }
00168 
00169 /*          WidgetInfo *widgetForClass = d->alternateWidgets.find(*it);
00170             if (!widgetForClass || (widgetForClass && !widgetForClass->isOverriddenClassName(*it))) {
00171                 //insert a widgetinfo, if:
00172                 //1) this class has no alternate class assigned yet, or
00173                 //2) this class has alternate class assigned but without 'override' flag
00174                 d->alternateWidgets.replace(*it, w);
00175             }*/
00176         }
00177     }
00178 }
00179 
00180 void
00181 WidgetLibrary::lookupFactories()
00182 {
00183     KTrader::OfferList tlist = KTrader::self()->query("KFormDesigner/WidgetFactory");
00184     KTrader::OfferList::Iterator it(tlist.begin());
00185     for(; it != tlist.end(); ++it)
00186     {
00187         KService::Ptr ptr = (*it);
00188         KService::Ptr* existingService = (d->services)[ptr->library().latin1()];
00189         if (existingService) {
00190             kdWarning() << "WidgetLibrary::lookupFactories(): factory '" << ptr->name()
00191                 << "' already found (library="<< (*existingService)->library()
00192                 <<")! skipping this one: library=" << ptr->library() << endl;
00193             continue;
00194         }
00195         kdDebug() << "WidgetLibrary::lookupFactories(): found factory: " << ptr->name() << endl;
00196 
00197         QCString groupName = ptr->property("X-KFormDesigner-FactoryGroup").toCString();
00198         if (!groupName.isEmpty() && !d->supportedFactoryGroups[groupName]) {
00199             kdDebug() << "WidgetLibrary::lookupFactories(): factory group '" << groupName
00200                 << "' is unsupported by this application (library=" << ptr->library() << ")"<< endl;
00201             continue;
00202         }
00203         const uint factoryVersion = ptr->property("X-KFormDesigner-WidgetFactoryVersion").toUInt();
00204         if (KFormDesigner::version()!=factoryVersion) {
00205             kdWarning() << QString("WidgetLibrary::lookupFactories(): factory '%1'" 
00206                 " has version '%2' but required Widget Factory version is '%3'\n"
00207                 " -- skipping this factory!").arg(ptr->library()).arg(factoryVersion)
00208                 .arg(KFormDesigner::version()) << endl;
00209             continue;
00210         }
00211         d->services.insert(ptr->library().latin1(), new KService::Ptr( ptr ));
00212     }
00213 }
00214 
00215 void
00216 WidgetLibrary::loadFactories()
00217 {
00218     if (d->factoriesLoaded)
00219         return;
00220     d->factoriesLoaded = true;
00221     for (QAsciiDictIterator<KService::Ptr> it(d->services); it.current(); ++it) {
00222         WidgetFactory *f = KParts::ComponentFactory::createInstanceFromService<WidgetFactory>(
00223             *it.current(), this, (*it.current())->library().latin1(), QStringList());
00224         if (!f) {
00225             kdWarning() << "WidgetLibrary::loadFactories(): creating factory failed! "
00226                 << (*it.current())->library() << endl;
00227             continue;
00228         }
00229         f->m_library = this;
00230         f->m_showAdvancedProperties = d->showAdvancedProperties; //inherit this flag from the library
00231         d->factories.insert( f->name(), f );
00232         //collect information about classes to be hidden
00233         if (f->m_hiddenClasses) {
00234             for (QAsciiDictIterator<char> it2(*f->m_hiddenClasses); it2.current(); ++it2) {
00235                 d->hiddenClasses.replace( it2.currentKey(), (char*)1 );
00236             }
00237         }
00238     }
00239 
00240     //now we have factories instantiated: load widgets
00241     QPtrList<WidgetFactory> loadLater;
00242     for (QAsciiDictIterator<WidgetFactory> it(d->factories); it.current(); ++it) {
00243         //ONE LEVEL, FLAT INHERITANCE, but works!
00244         //if this factory inherits from something, load its witgets later
00246         if (it.current()->inheritsFactories())
00247             loadLater.append( it.current() );
00248         else
00249             loadFactoryWidgets(it.current());
00250     }
00251     //load now the rest
00252     for (QPtrListIterator<WidgetFactory> it(loadLater); it.current(); ++it) {
00253         loadFactoryWidgets(it.current());
00254     }
00255 }
00256 
00257 QString
00258 WidgetLibrary::createXML()
00259 {
00260     loadFactories();
00261 
00262     QDomDocument doc("kpartgui");
00263     QDomElement root = doc.createElement("kpartgui");
00264 
00265     root.setAttribute("name", "kformdesigner");
00266     root.setAttribute("version", "0.3");
00267     doc.appendChild(root);
00268 
00269     QDomElement toolbar = doc.createElement("ToolBar");
00270     toolbar.setAttribute("name", "widgets");
00271     root.appendChild(toolbar);
00272 
00273     QDomElement texttb = doc.createElement("text");
00274     toolbar.appendChild(texttb);
00275     QDomText ttext = doc.createTextNode("Widgets");
00276     texttb.appendChild(ttext);
00277 
00278     QDomElement menubar = doc.createElement("MenuBar");
00279     toolbar.setAttribute("name", "widgets");
00280     root.appendChild(menubar);
00281 
00282     QDomElement Mtextb = doc.createElement("text");
00283     toolbar.appendChild(Mtextb);
00284     QDomText Mtext = doc.createTextNode("Widgets");
00285     Mtextb.appendChild(Mtext);
00286     QDomElement menu = doc.createElement("Menu");
00287     menu.setAttribute("name", "widgets");
00288 
00289     QAsciiDictIterator<WidgetInfo> it(d->widgets);
00290     int i = 0;
00291     for(; it.current(); ++it)
00292     {
00293         QDomElement action = doc.createElement("Action");
00294         action.setAttribute("name", "library_widget" + it.current()->className());
00295         toolbar.appendChild(action);
00296 
00297         i++;
00298     }
00299 
00300     return doc.toString();
00301 }
00302 
00303 ActionList
00304 WidgetLibrary::addCreateWidgetActions(KActionCollection *parent,  QObject *receiver, const char *slot)
00305 {
00306     loadFactories();
00307     ActionList actions;
00308     for (QAsciiDictIterator<WidgetInfo> it(d->widgets); it.current(); ++it)
00309     {
00310         LibActionWidget *a = new LibActionWidget(it.current(), parent);
00311         connect(a, SIGNAL(prepareInsert(const QCString &)), receiver, slot);
00312         actions.append(a);
00313     }
00314     return actions;
00315 }
00316 
00317 void
00318 WidgetLibrary::addCustomWidgetActions(KActionCollection *parent)
00319 {
00320     for (QAsciiDictIterator<WidgetFactory> it(d->factories); it.current(); ++it)
00321     {
00322         it.current()->createCustomActions( parent );
00323     }
00324 }
00325 
00326 QWidget*
00327 WidgetLibrary::createWidget(const QCString &classname, QWidget *parent, const char *name, Container *c,
00328     int options)
00329 {
00330     loadFactories();
00331     WidgetInfo *wclass = d->widgets[classname];
00332     if(!wclass)
00333         return 0;
00334 
00335     QWidget *widget = wclass->factory()->createWidget(wclass->className(), parent, name, c, options);
00336     if (!widget) {
00337         //try to instantiate from inherited class
00338         if (wclass->inheritedClass())
00339             widget = wclass->inheritedClass()->factory()->createWidget(
00340                 wclass->className(), parent, name, c, options);
00341     }
00342     return widget;
00343 }
00344 
00345 bool
00346 WidgetLibrary::createMenuActions(const QCString &c, QWidget *w, QPopupMenu *menu,
00347     KFormDesigner::Container *container)
00348 {
00349     loadFactories();
00350     WidgetInfo *wclass = d->widgets[c];
00351     if(!wclass)
00352         return false;
00353 
00354     wclass->factory()->m_widget = w;
00355     wclass->factory()->m_container = container;
00356     if (wclass->factory()->createMenuActions(c, w, menu, container))
00357         return true;
00358     //try from inherited class
00359     if (wclass->inheritedClass())
00360         return wclass->inheritedClass()->factory()
00361             ->createMenuActions(wclass->className(), w, menu, container);
00362     return false;
00363 }
00364 
00365 bool
00366 WidgetLibrary::startEditing(const QCString &classname, QWidget *w, Container *container)
00367 {
00368     loadFactories();
00369     WidgetInfo *wclass = d->widgets[classname];
00370     if(!wclass)
00371         return false;
00372 
00373     if (wclass->factory()->startEditing(classname, w, container))
00374         return true;
00375     //try from inherited class
00376     if (wclass->inheritedClass())
00377         return wclass->inheritedClass()->factory()->startEditing(wclass->className(), w, container);
00378     return false;
00379 }
00380 
00381 bool
00382 WidgetLibrary::previewWidget(const QCString &classname, QWidget *widget, Container *container)
00383 {
00384     loadFactories();
00385     WidgetInfo *wclass = d->widgets[classname];
00386     if(!wclass)
00387         return false;
00388 
00389     if (wclass->factory()->previewWidget(classname, widget, container))
00390         return true;
00391     //try from inherited class
00392     if (wclass->inheritedClass())
00393         return wclass->inheritedClass()->factory()->previewWidget(wclass->className(), widget, container);
00394     return false;
00395 }
00396 
00397 bool
00398 WidgetLibrary::clearWidgetContent(const QCString &classname, QWidget *w)
00399 {
00400     loadFactories();
00401     WidgetInfo *wclass = d->widgets[classname];
00402     if(!wclass)
00403         return false;
00404 
00405     if (wclass->factory()->clearWidgetContent(classname, w))
00406         return true;
00407     //try from inherited class
00408     if (wclass->inheritedClass())
00409         return wclass->inheritedClass()->factory()->clearWidgetContent(wclass->className(), w);
00410     return false;
00411 }
00412 
00413 QString
00414 WidgetLibrary::displayName(const QCString &classname)
00415 {
00416     loadFactories();
00417     WidgetInfo *wi = d->widgets.find(classname);
00418     if(wi)
00419         return wi->name();
00420 
00421     return classname;
00422 }
00423 
00424 QString
00425 WidgetLibrary::savingName(const QCString &classname)
00426 {
00427     loadFactories();
00428     QString s;
00429     WidgetInfo *wi = d->widgets.find(classname);
00430     if(wi && !wi->savingName().isEmpty())
00431         return wi->savingName();
00432 
00433     return classname;
00434 }
00435 
00436 QString
00437 WidgetLibrary::namePrefix(const QCString &classname)
00438 {
00439     loadFactories();
00440     WidgetInfo *wi = d->widgets.find(classname);
00441     if(wi)
00442         return wi->namePrefix();
00443 
00444     return classname;
00445 }
00446 
00447 QString
00448 WidgetLibrary::textForWidgetName(const QCString &name, const QCString &className)
00449 {
00450     loadFactories();
00451     WidgetInfo *widget = d->widgets[className];
00452     if(!widget)
00453         return QString::null;
00454 
00455     QString newName = name;
00456     newName.remove(widget->namePrefix());
00457     newName = widget->name() + " " + newName;
00458     return newName;
00459 }
00460 
00461 QCString
00462 WidgetLibrary::classNameForAlternate(const QCString &classname)
00463 {
00464     loadFactories();
00465     if(d->widgets.find(classname))
00466         return classname;
00467 
00468     WidgetInfo *wi =  d->widgets[classname];
00469     if (wi) {
00470         return wi->className();
00471     }
00472 
00473     // widget not supported
00474     return "CustomWidget";
00475 }
00476 
00477 QString
00478 WidgetLibrary::includeFileName(const QCString &classname)
00479 {
00480     loadFactories();
00481     WidgetInfo *wi = d->widgets.find(classname);
00482     if(wi)
00483         return wi->includeFileName();
00484 
00485     return QString::null;
00486 }
00487 
00488 QString
00489 WidgetLibrary::iconName(const QCString &classname)
00490 {
00491     loadFactories();
00492     WidgetInfo *wi = d->widgets.find(classname);
00493     if(wi)
00494         return wi->pixmap();
00495 
00496     return QString::fromLatin1("unknown_widget");
00497 }
00498 
00499 bool
00500 WidgetLibrary::saveSpecialProperty(const QCString &classname, const QString &name, const QVariant &value, QWidget *w, QDomElement &parentNode, QDomDocument &parent)
00501 {
00502     loadFactories();
00503     WidgetInfo *wi = d->widgets.find(classname);
00504     if (!wi)
00505         return false;
00506 
00507     if (wi->factory()->saveSpecialProperty(classname, name, value, w, parentNode, parent))
00508         return true;
00509     //try from inherited class
00510     if (wi->inheritedClass())
00511         return wi->inheritedClass()->factory()->saveSpecialProperty(wi->className(), name, value, w, parentNode, parent);
00512     return false;
00513 }
00514 
00515 bool
00516 WidgetLibrary::readSpecialProperty(const QCString &classname, QDomElement &node, QWidget *w, ObjectTreeItem *item)
00517 {
00518     loadFactories();
00519     WidgetInfo *wi = d->widgets.find(classname);
00520     if (!wi)
00521         return false;
00522     if (wi->factory()->readSpecialProperty(classname, node, w, item))
00523         return true;
00524     //try from inherited class
00525     if (wi->inheritedClass())
00526         return wi->inheritedClass()->factory()->readSpecialProperty(wi->className(), node, w, item);
00527     return false;
00528 }
00529 
00530 void WidgetLibrary::setAdvancedPropertiesVisible(bool set)
00531 {
00532     d->showAdvancedProperties = set;
00533 }
00534 
00535 bool WidgetLibrary::advancedPropertiesVisible() const
00536 {
00537     return d->showAdvancedProperties;
00538 }
00539 
00540 bool
00541 WidgetLibrary::isPropertyVisible(const QCString &classname, QWidget *w,
00542     const QCString &property, bool multiple, bool isTopLevel)
00543 {
00544     if (isTopLevel) {
00545         // no focus policy for top-level form widget...
00546         if (!d->showAdvancedProperties && property == "focusPolicy")
00547             return false;
00548     }
00549 
00550     loadFactories();
00551     WidgetInfo *wi = d->widgets.find(classname);
00552     if (!wi)
00553         return false;
00554     if (!d->showAdvancedProperties && d->advancedProperties[ property ]) {
00555         //this is advanced property, should we hide it?
00556         if (wi->factory()->internalProperty(classname, "forceShowAdvancedProperty:"+property).isEmpty()
00557             && (!wi->inheritedClass() || wi->inheritedClass()->factory()->internalProperty(classname, "forceShowAdvancedProperty:"+property).isEmpty()))
00558         {
00559             return false; //hide it
00560         }
00561     }
00562 
00563     if (!wi->factory()->isPropertyVisible(classname, w, property, multiple, isTopLevel))
00564         return false;
00565     //try from inherited class
00566     if (wi->inheritedClass()
00567         && !wi->inheritedClass()->factory()->isPropertyVisible(wi->className(), w, property, multiple, isTopLevel))
00568         return false;
00569 
00570     return true;
00571 }
00572 
00573 QValueList<QCString>
00574 WidgetLibrary::autoSaveProperties(const QCString &classname)
00575 {
00576     loadFactories();
00577     WidgetInfo *wi = d->widgets.find(classname);
00578     if(!wi)
00579         return QValueList<QCString>();
00580     QValueList<QCString> lst;
00581     //prepend from inherited class
00582     if (wi->inheritedClass())
00583         lst = wi->inheritedClass()->factory()->autoSaveProperties(wi->className());
00584     lst += wi->factory()->autoSaveProperties(classname);
00585     return lst;
00586 }
00587 
00588 WidgetInfo*
00589 WidgetLibrary::widgetInfoForClassName(const char* classname)
00590 {
00591     loadFactories();
00592     return d->widgets.find(classname);
00593 }
00594 
00595 WidgetFactory*
00596 WidgetLibrary::factoryForClassName(const char* classname)
00597 {
00598     WidgetInfo *wi = widgetInfoForClassName(classname);
00599     return wi ? wi->factory() : 0;
00600 }
00601 
00602 QString WidgetLibrary::propertyDescForName(WidgetInfo *winfo, const QCString& propertyName)
00603 {
00604     if (!winfo || !winfo->factory())
00605         return QString::null;
00606     QString desc( winfo->factory()->propertyDescForName(propertyName) );
00607     if (!desc.isEmpty())
00608         return desc;
00609     if (winfo->m_parentFactoryName.isEmpty())
00610         return QString::null;
00611 
00612     //try in parent factory, if exists
00613     WidgetFactory *parentFactory = d->factories[winfo->m_parentFactoryName];
00614     if (!parentFactory)
00615         return QString::null;
00616 
00617     return parentFactory->propertyDescForName(propertyName);
00618 }
00619 
00620 QString WidgetLibrary::propertyDescForValue(WidgetInfo *winfo, const QCString& name)
00621 {
00622     if (!winfo->factory())
00623         return QString::null;
00624     QString desc( winfo->factory()->propertyDescForValue(name) );
00625     if (!desc.isEmpty())
00626         return desc;
00627     if (winfo->m_parentFactoryName.isEmpty())
00628         return QString::null;
00629 
00630     //try in parent factory, if exists
00631     WidgetFactory *parentFactory = d->factories[winfo->m_parentFactoryName];
00632     if (!parentFactory)
00633         return QString::null;
00634 
00635     return parentFactory->propertyDescForValue(name);
00636 }
00637 
00638 void WidgetLibrary::setPropertyOptions( WidgetPropertySet& buf, const WidgetInfo& winfo, QWidget* w )
00639 {
00640     if (!winfo.factory())
00641         return;
00642     winfo.factory()->setPropertyOptions(buf, winfo, w);
00643     if (winfo.m_parentFactoryName.isEmpty())
00644         return;
00645     WidgetFactory *parentFactory = d->factories[winfo.m_parentFactoryName];
00646     if (!parentFactory)
00647         return;
00648     parentFactory->setPropertyOptions(buf, winfo, w);
00649 }
00650 
00651 WidgetFactory* WidgetLibrary::factory(const char* factoryName) const
00652 {
00653     return d->factories[factoryName];
00654 }
00655 
00656 QString WidgetLibrary::internalProperty(const QCString& classname, const QCString& property)
00657 {
00658     loadFactories();
00659     WidgetInfo *wclass = d->widgets[classname];
00660     if(!wclass)
00661         return QString::null;
00662     QString value( wclass->factory()->internalProperty(classname, property) );
00663     if (value.isEmpty() && wclass->inheritedClass())
00664         return wclass->inheritedClass()->factory()->internalProperty(classname, property);
00665     return value;
00666 }
00667 
00668 WidgetFactory::CreateWidgetOptions WidgetLibrary::showOrientationSelectionPopup(
00669     const QCString &classname, QWidget* parent, const QPoint& pos)
00670 {
00671     loadFactories();
00672     WidgetInfo *wclass = d->widgets[classname];
00673     if(!wclass)
00674         return WidgetFactory::AnyOrientation;
00675 
00676     //get custom icons and strings
00677     QPixmap iconHorizontal, iconVertical;
00678     QString iconName( wclass->factory()->internalProperty(classname, "orientationSelectionPopup:horizontalIcon") );
00679     if (iconName.isEmpty() && wclass->inheritedClass())
00680         iconName = wclass->inheritedClass()->factory()->internalProperty(classname, "orientationSelectionPopup:horizontalIcon");
00681     if (!iconName.isEmpty())
00682         iconHorizontal = SmallIcon(iconName);
00683 
00684     iconName = wclass->factory()->internalProperty(classname, "orientationSelectionPopup:verticalIcon");
00685     if (iconName.isEmpty() && wclass->inheritedClass())
00686         iconName = wclass->inheritedClass()->factory()->internalProperty(classname, "orientationSelectionPopup:verticalIcon");
00687     if (!iconName.isEmpty())
00688         iconVertical = SmallIcon(iconName);
00689 
00690     QString textHorizontal = wclass->factory()->internalProperty(classname, "orientationSelectionPopup:horizontalText");
00691     if (textHorizontal.isEmpty() && wclass->inheritedClass())
00692         iconName = wclass->inheritedClass()->factory()->internalProperty(classname, "orientationSelectionPopup:horizontalText");
00693     if (textHorizontal.isEmpty()) //default
00694         textHorizontal = i18n("Insert Horizontal Widget", "Insert Horizontal");
00695 
00696     QString textVertical = wclass->factory()->internalProperty(classname, "orientationSelectionPopup:verticalText");
00697     if (textVertical.isEmpty() && wclass->inheritedClass())
00698         iconName = wclass->inheritedClass()->factory()->internalProperty(classname, "orientationSelectionPopup:verticalText");
00699     if (textVertical.isEmpty()) //default
00700         textVertical = i18n("Insert Vertical Widget", "Insert Vertical");
00701 
00702     KPopupMenu* popup = new KPopupMenu(parent, "orientationSelectionPopup");
00703     popup->insertTitle(SmallIcon(wclass->pixmap()), i18n("Insert Widget: %1").arg(wclass->name()));
00704     popup->insertItem(iconHorizontal, textHorizontal, 1);
00705     popup->insertItem(iconVertical, textVertical, 2);
00706     popup->insertSeparator();
00707     popup->insertItem(SmallIcon("button_cancel"), i18n("Cancel"), 3);
00708     WidgetFactory::CreateWidgetOptions result;
00709     switch (popup->exec(pos)) {
00710     case 1:
00711         result = WidgetFactory::HorizontalOrientation; break;
00712     case 2:
00713         result = WidgetFactory::VerticalOrientation; break;
00714     default:
00715         result = WidgetFactory::AnyOrientation; //means "cancelled"
00716     }
00717     delete popup;
00718     return result;
00719 }
00720 
00721 #include "widgetlibrary.moc"
KDE Home | KDE Accessibility Home | Description of Access Keys