00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
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
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);
00069 advancedProperties.insert("layout", (char*)1);
00070
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
00082 WidgetInfo::Dict widgets;
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;
00123
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
00138 w->m_inheritedClass = inheritedClass;
00139 if (w->pixmap().isEmpty())
00140 w->setPixmap( inheritedClass->pixmap() );
00141
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
00156 QValueList<QCString> l = w->alternateClassNames();
00157 l.prepend( w->className() );
00158
00159
00160
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
00166
00167
00168 d->widgets.replace( *it, w);
00169 }
00170
00171
00172
00173
00174
00175
00176
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;
00233 d->factories.insert( f->name(), f );
00234
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
00243 QPtrList<WidgetFactory> loadLater;
00244 for (QAsciiDictIterator<WidgetFactory> it(d->factories); it.current(); ++it) {
00245
00246
00248 if (it.current()->inheritsFactories())
00249 loadLater.append( it.current() );
00250 else
00251 loadFactoryWidgets(it.current());
00252 }
00253
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
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
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
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
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
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
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
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
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
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
00558 if (wi->factory()->internalProperty(classname, "forceShowAdvancedProperty:"+property).isEmpty()
00559 && (!wi->inheritedClass() || wi->inheritedClass()->factory()->internalProperty(classname, "forceShowAdvancedProperty:"+property).isEmpty()))
00560 {
00561 return false;
00562 }
00563 }
00564
00565 if (!wi->factory()->isPropertyVisible(classname, w, property, multiple, isTopLevel))
00566 return false;
00567
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
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
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
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
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())
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())
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;
00718 }
00719 delete popup;
00720 return result;
00721 }
00722
00723 #include "widgetlibrary.moc"