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 #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
00080 WidgetInfo::Dict widgets;
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;
00121
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
00136 w->m_inheritedClass = inheritedClass;
00137 if (w->pixmap().isEmpty())
00138 w->setPixmap( inheritedClass->pixmap() );
00139
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
00154 QValueList<QCString> l = w->alternateClassNames();
00155 l.prepend( w->className() );
00156
00157
00158
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
00164
00165
00166 d->widgets.replace( *it, w);
00167 }
00168
00169
00170
00171
00172
00173
00174
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;
00231 d->factories.insert( f->name(), f );
00232
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
00241 QPtrList<WidgetFactory> loadLater;
00242 for (QAsciiDictIterator<WidgetFactory> it(d->factories); it.current(); ++it) {
00243
00244
00246 if (it.current()->inheritsFactories())
00247 loadLater.append( it.current() );
00248 else
00249 loadFactoryWidgets(it.current());
00250 }
00251
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
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
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
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
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
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
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
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
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
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
00556 if (wi->factory()->internalProperty(classname, "forceShowAdvancedProperty:"+property).isEmpty()
00557 && (!wi->inheritedClass() || wi->inheritedClass()->factory()->internalProperty(classname, "forceShowAdvancedProperty:"+property).isEmpty()))
00558 {
00559 return false;
00560 }
00561 }
00562
00563 if (!wi->factory()->isPropertyVisible(classname, w, property, multiple, isTopLevel))
00564 return false;
00565
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
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
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
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
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())
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())
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;
00716 }
00717 delete popup;
00718 return result;
00719 }
00720
00721 #include "widgetlibrary.moc"