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