You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
726 lines
20 KiB
726 lines
20 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2003 Lucijan Busch <lucijan@gmx.at>
|
|
Copyright (C) 2004 Cedric Pasteur <cedric.pasteur@free.fr>
|
|
Copyright (C) 2004-2006 Jaroslaw Staniek <js@iidea.pl>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "widgetfactory.h"
|
|
|
|
#include <tqcursor.h>
|
|
#include <tqobjectlist.h>
|
|
#include <tqdict.h>
|
|
#include <tqmetaobject.h>
|
|
|
|
#include <kdebug.h>
|
|
#include <klocale.h>
|
|
//#ifdef KEXI_KTEXTEDIT
|
|
#include <ktextedit.h>
|
|
//#else
|
|
#include <klineedit.h>
|
|
//#endif
|
|
#include <kdialogbase.h>
|
|
#include <keditlistbox.h>
|
|
#include <kxmlguiclient.h>
|
|
#include <kactioncollection.h>
|
|
|
|
#include "richtextdialog.h"
|
|
#include "editlistviewdialog.h"
|
|
#include "resizehandle.h"
|
|
#include "formmanager.h"
|
|
#include "form.h"
|
|
#include "container.h"
|
|
#include "objecttree.h"
|
|
#include "widgetlibrary.h"
|
|
#include "utils.h"
|
|
#include "widgetpropertyset.h"
|
|
#include "widgetwithsubpropertiesinterface.h"
|
|
#include <koproperty/property.h>
|
|
|
|
using namespace KFormDesigner;
|
|
|
|
///// Widget Info //////////////////////////
|
|
|
|
WidgetInfo::WidgetInfo(WidgetFactory *f)
|
|
: m_inheritedClass(0)
|
|
, m_overriddenAlternateNames(0)
|
|
, m_factory(f)
|
|
, m_propertiesWithDisabledAutoSync(0)
|
|
, m_customTypesForProperty(0)
|
|
{
|
|
}
|
|
|
|
WidgetInfo::WidgetInfo(WidgetFactory *f, const char* parentFactoryName,
|
|
const char* inheritedClassName)
|
|
: m_parentFactoryName( TQCString("kformdesigner_")+parentFactoryName )
|
|
, m_inheritedClassName(inheritedClassName)
|
|
, m_inheritedClass(0)
|
|
, m_overriddenAlternateNames(0)
|
|
, m_factory(f)
|
|
, m_propertiesWithDisabledAutoSync(0)
|
|
, m_customTypesForProperty(0)
|
|
{
|
|
m_class = inheritedClassName;
|
|
}
|
|
|
|
WidgetInfo::~WidgetInfo()
|
|
{
|
|
delete m_overriddenAlternateNames;
|
|
delete m_propertiesWithDisabledAutoSync;
|
|
delete m_customTypesForProperty;
|
|
}
|
|
|
|
void WidgetInfo::addAlternateClassName(const TQCString& alternateName, bool override)
|
|
{
|
|
m_alternateNames += alternateName;
|
|
if (override) {
|
|
if (!m_overriddenAlternateNames)
|
|
m_overriddenAlternateNames = new TQAsciiDict<char>(101);
|
|
m_overriddenAlternateNames->insert(alternateName, (char*)1);
|
|
}
|
|
else {
|
|
if (m_overriddenAlternateNames)
|
|
m_overriddenAlternateNames->take(alternateName);
|
|
}
|
|
}
|
|
|
|
bool WidgetInfo::isOverriddenClassName(const TQCString& alternateName) const
|
|
{
|
|
return m_overriddenAlternateNames && (m_overriddenAlternateNames->find(alternateName) != 0);
|
|
}
|
|
|
|
void WidgetInfo::setAutoSyncForProperty(const char *propertyName, tristate flag)
|
|
{
|
|
if (!m_propertiesWithDisabledAutoSync) {
|
|
if (~flag)
|
|
return;
|
|
m_propertiesWithDisabledAutoSync = new TQAsciiDict<char>(101);
|
|
}
|
|
|
|
if (~flag) {
|
|
m_propertiesWithDisabledAutoSync->remove(propertyName);
|
|
}
|
|
else {
|
|
m_propertiesWithDisabledAutoSync->insert(propertyName, flag==true ? (char*)1 : (char*)2);
|
|
}
|
|
}
|
|
|
|
tristate WidgetInfo::autoSyncForProperty(const char *propertyName) const
|
|
{
|
|
char* flag = m_propertiesWithDisabledAutoSync ? m_propertiesWithDisabledAutoSync->find(propertyName) : 0;
|
|
if (!flag)
|
|
return cancelled;
|
|
return flag==(char*)1 ? true : false;
|
|
}
|
|
|
|
void WidgetInfo::setCustomTypeForProperty(const char *propertyName, int type)
|
|
{
|
|
if (!propertyName || type==KoProperty::Auto)
|
|
return;
|
|
if (!m_customTypesForProperty) {
|
|
m_customTypesForProperty = new TQMap<TQCString,int>();
|
|
}
|
|
m_customTypesForProperty->replace(propertyName, type);
|
|
}
|
|
|
|
int WidgetInfo::customTypeForProperty(const char *propertyName) const
|
|
{
|
|
if (!m_customTypesForProperty || !m_customTypesForProperty->contains(propertyName))
|
|
return KoProperty::Auto;
|
|
return (*m_customTypesForProperty)[propertyName];
|
|
}
|
|
|
|
|
|
///// Widget Factory //////////////////////////
|
|
|
|
WidgetFactory::WidgetFactory(TQObject *parent, const char *name)
|
|
: TQObject(parent, (const char*)(TQCString("kformdesigner_")+name))
|
|
{
|
|
m_showAdvancedProperties = true;
|
|
m_classesByName.setAutoDelete(true);
|
|
m_hiddenClasses = 0;
|
|
m_guiClient = 0;
|
|
}
|
|
|
|
WidgetFactory::~WidgetFactory()
|
|
{
|
|
delete m_hiddenClasses;
|
|
}
|
|
|
|
void WidgetFactory::addClass(WidgetInfo *w)
|
|
{
|
|
WidgetInfo *oldw = m_classesByName[w->className()];
|
|
if (oldw==w)
|
|
return;
|
|
if (oldw) {
|
|
kdWarning() << "WidgetFactory::addClass(): class with name '" << w->className()
|
|
<< "' already exists for factory '" << name() << "'" << endl;
|
|
return;
|
|
}
|
|
m_classesByName.insert( w->className(), w );
|
|
}
|
|
|
|
void WidgetFactory::hideClass(const char *classname)
|
|
{
|
|
if (!m_hiddenClasses)
|
|
m_hiddenClasses = new TQAsciiDict<char>(101, false);
|
|
m_hiddenClasses->insert(classname, (char*)1);
|
|
}
|
|
|
|
void
|
|
WidgetFactory::createEditor(const TQCString &classname, const TQString &text,
|
|
TQWidget *w, Container *container, TQRect geometry,
|
|
int align, bool useFrame, bool multiLine, BackgroundMode background)
|
|
{
|
|
//#ifdef KEXI_KTEXTEDIT
|
|
if (multiLine) {
|
|
KTextEdit *textedit = new KTextEdit(text, TQString(), w->parentWidget());
|
|
textedit->setTextFormat(TQt::PlainText);
|
|
textedit->setAlignment(align);
|
|
if (dynamic_cast<TQTextEdit*>(w)) {
|
|
textedit->setWordWrap(dynamic_cast<TQTextEdit*>(w)->wordWrap());
|
|
textedit->setWrapPolicy(dynamic_cast<TQTextEdit*>(w)->wrapPolicy());
|
|
}
|
|
textedit->setPalette(w->palette());
|
|
textedit->setFont(w->font());
|
|
textedit->setResizePolicy(TQScrollView::Manual);
|
|
textedit->setGeometry(geometry);
|
|
if(background == TQt::NoBackground)
|
|
textedit->setBackgroundMode(w->backgroundMode());
|
|
else
|
|
textedit->setBackgroundMode(background);
|
|
// textedit->setPaletteBackgroundColor(textedit->colorGroup().color( TQColorGroup::Base ));
|
|
textedit->setPaletteBackgroundColor(w->paletteBackgroundColor());
|
|
for(int i =0; i <= textedit->paragraphs(); i++)
|
|
textedit->setParagraphBackgroundColor(i, w->paletteBackgroundColor());
|
|
textedit->selectAll(true);
|
|
textedit->setColor(w->paletteForegroundColor());
|
|
textedit->selectAll(false);
|
|
textedit->moveCursor(TQTextEdit::MoveEnd, false);
|
|
textedit->setParagraphBackgroundColor(0, w->paletteBackgroundColor());
|
|
textedit->setVScrollBarMode(TQScrollView::AlwaysOff); //ok?
|
|
textedit->setHScrollBarMode(TQScrollView::AlwaysOff); //ok?
|
|
textedit->installEventFilter(this);
|
|
textedit->setFrameShape(useFrame ? TQFrame::LineEditPanel : TQFrame::NoFrame);
|
|
textedit->setMargin(2); //to move away from resize handle
|
|
textedit->show();
|
|
textedit->setFocus();
|
|
textedit->selectAll();
|
|
setEditor(w, textedit);
|
|
|
|
connect(textedit, TQT_SIGNAL(textChanged()), this, TQT_SLOT(slotTextChanged()));
|
|
connect(w, TQT_SIGNAL(destroyed()), this, TQT_SLOT(widgetDestroyed()));
|
|
connect(textedit, TQT_SIGNAL(destroyed()), this, TQT_SLOT(editorDeleted()));
|
|
//#else
|
|
}
|
|
else {
|
|
KLineEdit *editor = new KLineEdit(text, w->parentWidget());
|
|
editor->setAlignment(align);
|
|
editor->setPalette(w->palette());
|
|
editor->setFont(w->font());
|
|
editor->setGeometry(geometry);
|
|
if(background == TQt::NoBackground)
|
|
editor->setBackgroundMode(w->backgroundMode());
|
|
else
|
|
editor->setBackgroundMode(background);
|
|
editor->installEventFilter(this);
|
|
editor->setFrame(useFrame);
|
|
editor->setMargin(2); //to move away from resize handle
|
|
editor->show();
|
|
editor->setFocus();
|
|
editor->selectAll();
|
|
connect(editor, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(changeTextInternal(const TQString&)));
|
|
connect(w, TQT_SIGNAL(destroyed()), this, TQT_SLOT(widgetDestroyed()));
|
|
connect(editor, TQT_SIGNAL(destroyed()), this, TQT_SLOT(editorDeleted()));
|
|
|
|
setEditor(w, editor);
|
|
// m_editor = editor;
|
|
}
|
|
//copy properties if available
|
|
WidgetWithSubpropertiesInterface* subpropIface = dynamic_cast<WidgetWithSubpropertiesInterface*>(w);
|
|
TQWidget *subwidget = (subpropIface && subpropIface->subwidget()) ? subpropIface->subwidget() : w;
|
|
if (-1!=m_editor->metaObject()->findProperty("margin", true) && -1!=subwidget->metaObject()->findProperty("margin", true))
|
|
m_editor->setProperty("margin", subwidget->property("margin"));
|
|
//#endif
|
|
//js m_handles = new ResizeHandleSet(w, container->form(), true);
|
|
m_handles = container->form()->resizeHandlesForWidget(w);
|
|
if (m_handles) {
|
|
m_handles->setEditingMode(true);
|
|
m_handles->raise();
|
|
}
|
|
|
|
ObjectTreeItem *tree = container->form()->objectTree()->lookup(w->name());
|
|
if(!tree)
|
|
return;
|
|
tree->eventEater()->setContainer(this);
|
|
|
|
//m_widget = w;
|
|
setWidget(w, container);
|
|
m_editedWidgetClass = classname;
|
|
m_firstText = text;
|
|
// m_container = container;
|
|
|
|
changeTextInternal(text); // to update size of the widget
|
|
}
|
|
|
|
void
|
|
WidgetFactory::disableFilter(TQWidget *w, Container *container)
|
|
{
|
|
ObjectTreeItem *tree = container->form()->objectTree()->lookup(w->name());
|
|
if(!tree)
|
|
return;
|
|
tree->eventEater()->setContainer(this);
|
|
|
|
w->setFocus();
|
|
//js m_handles = new ResizeHandleSet(w, container->form(), true);
|
|
m_handles = container->form()->resizeHandlesForWidget(w);
|
|
if (m_handles) {
|
|
m_handles->setEditingMode(true);
|
|
m_handles->raise();
|
|
}
|
|
|
|
//m_widget = w;
|
|
setWidget(w, container);
|
|
// m_container = container;
|
|
setEditor(w, 0);
|
|
// m_editor = 0;
|
|
|
|
// widget is disabled, so we re-enable it while editing
|
|
if(!tree->isEnabled()) {
|
|
TQPalette p = w->palette();
|
|
TQColorGroup cg = p.active();
|
|
p.setActive(p.disabled());
|
|
p.setDisabled(cg);
|
|
w->setPalette(p);
|
|
}
|
|
|
|
connect(w, TQT_SIGNAL(destroyed()), this, TQT_SLOT(widgetDestroyed()));
|
|
}
|
|
|
|
bool
|
|
WidgetFactory::editList(TQWidget *w, TQStringList &list)
|
|
{
|
|
KDialogBase dialog(w->topLevelWidget(), "stringlist_dialog", true, i18n("Edit List of Items"),
|
|
KDialogBase::Ok|KDialogBase::Cancel, KDialogBase::Ok, false);
|
|
|
|
KEditListBox *edit = new KEditListBox(i18n("Contents of %1").arg(w->name()), &dialog, "editlist");
|
|
dialog.setMainWidget(edit);
|
|
edit->insertStringList(list);
|
|
// edit->show();
|
|
|
|
if(dialog.exec() == TQDialog::Accepted)
|
|
{
|
|
list = edit->items();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
WidgetFactory::editRichText(TQWidget *w, TQString &text)
|
|
{
|
|
RichTextDialog dlg(w, text);
|
|
if(dlg.exec()== TQDialog::Accepted)
|
|
{
|
|
text = dlg.text();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
WidgetFactory::editListView(TQListView *listview)
|
|
{
|
|
EditListViewDialog dlg(((TQWidget*)listview)->topLevelWidget());
|
|
//dlg.exec(listview);
|
|
}
|
|
|
|
bool
|
|
WidgetFactory::eventFilter(TQObject *obj, TQEvent *ev)
|
|
{
|
|
if( ((ev->type() == TQEvent::Resize) || (ev->type() == TQEvent::Move) ) && (obj == m_widget) && editor(m_widget)) {
|
|
// resize widget using resize handles
|
|
TQWidget *ed = editor(m_widget);
|
|
resizeEditor(ed, m_widget, m_widget->className());
|
|
}
|
|
else if((ev->type() == TQEvent::Paint) && (obj == m_widget) && editor(m_widget)) {
|
|
// paint event for container edited (eg button group)
|
|
return m_container->eventFilter(obj, ev);
|
|
}
|
|
else if((ev->type() == TQEvent::MouseButtonPress) && (obj == m_widget) && editor(m_widget)) {
|
|
// click outside editor --> cancel editing
|
|
Container *cont = m_container;
|
|
resetEditor();
|
|
return cont->eventFilter(obj, ev);
|
|
}
|
|
|
|
if(ev->type() == TQEvent::FocusOut)
|
|
{
|
|
TQWidget *w = editor(m_widget);
|
|
if (!w)
|
|
w = (TQWidget *)m_widget;
|
|
if(obj != (TQObject *)w)
|
|
return false;
|
|
|
|
TQWidget *focus = w->topLevelWidget()->focusWidget();
|
|
if(focus && w != focus && !w->child(focus->name(), focus->className()))
|
|
resetEditor();
|
|
}
|
|
else if(ev->type() == TQEvent::KeyPress)
|
|
{
|
|
TQWidget *w = editor(m_widget);
|
|
if (!w)
|
|
w = (TQWidget *)m_widget;
|
|
if(obj != (TQObject *)w)
|
|
return false;
|
|
|
|
TQKeyEvent *e = TQT_TQKEYEVENT(ev);
|
|
if(((e->key() == TQt::Key_Return) || (e->key() == TQt::Key_Enter)) && (e->state() != AltButton))
|
|
resetEditor();
|
|
if(e->key() == TQt::Key_Escape)
|
|
{
|
|
setEditorText(m_firstText);
|
|
//changeText(m_firstText);
|
|
resetEditor();
|
|
}
|
|
}
|
|
else if(ev->type() == TQEvent::ContextMenu) {
|
|
TQWidget *w = editor(m_widget);
|
|
if (!w)
|
|
w = (TQWidget *)m_widget;
|
|
if(obj != (TQObject *)w)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
// if(obj == m_widget)
|
|
// return m_container->eventFilter(obj, ev);
|
|
// else
|
|
return false;
|
|
}
|
|
|
|
void
|
|
WidgetFactory::resetEditor()
|
|
{
|
|
if (m_container)
|
|
m_container->stopInlineEditing();
|
|
|
|
TQWidget *ed = editor(m_widget);
|
|
if(m_widget)
|
|
{
|
|
ObjectTreeItem *tree = m_container ? m_container->form()->objectTree()->lookup(m_widget->name()) : 0;
|
|
if(!tree)
|
|
{
|
|
kdDebug() << "WidgetFactory::resetEditor() : error cannot found a tree item " << endl;
|
|
return;
|
|
}
|
|
tree->eventEater()->setContainer(m_container);
|
|
if(m_widget) {// && !ed)
|
|
setRecursiveCursor(m_widget, m_container->form());
|
|
if (m_widget->inherits(TQLINEEDIT_OBJECT_NAME_STRING) || m_widget->inherits(TQTEXTEDIT_OBJECT_NAME_STRING)) { //fix weird behaviour
|
|
m_widget->unsetCursor();
|
|
m_widget->setCursor(TQt::ArrowCursor);
|
|
}
|
|
}
|
|
|
|
// disable again the widget
|
|
if(!ed && !tree->isEnabled()) {
|
|
TQPalette p = m_widget->palette();
|
|
TQColorGroup cg = p.active();
|
|
p.setActive(p.disabled());
|
|
p.setDisabled(cg);
|
|
m_widget->setPalette(p);
|
|
}
|
|
}
|
|
if(ed)
|
|
{
|
|
changeTextInternal(editorText());
|
|
disconnect(ed, 0, this, 0);
|
|
ed->deleteLater();
|
|
}
|
|
|
|
if(m_widget)
|
|
{
|
|
disconnect(m_widget, 0, this, 0);
|
|
m_widget->repaint();
|
|
}
|
|
|
|
//js delete m_handles;
|
|
if (m_handles) {
|
|
m_handles->setEditingMode(false);
|
|
}
|
|
setEditor(m_widget, 0);
|
|
// m_editor = 0;
|
|
setWidget(0, 0);
|
|
//m_widget = 0;
|
|
m_handles = 0;
|
|
// m_container = 0;
|
|
}
|
|
|
|
void
|
|
WidgetFactory::widgetDestroyed()
|
|
{
|
|
if(m_editor)
|
|
{
|
|
m_editor->deleteLater();
|
|
m_editor = 0;
|
|
}
|
|
|
|
//js delete m_handles;
|
|
if (m_handles) {
|
|
m_handles->setEditingMode(false);
|
|
|
|
}
|
|
m_widget = 0;
|
|
m_handles = 0;
|
|
m_container = 0;
|
|
}
|
|
|
|
void
|
|
WidgetFactory::editorDeleted()
|
|
{
|
|
//js delete m_handles;
|
|
if (m_handles) {
|
|
m_handles->setEditingMode(false);
|
|
}
|
|
setEditor(m_widget, 0);
|
|
setWidget(0, 0);
|
|
// m_widget = 0;
|
|
m_handles = 0;
|
|
// m_container = 0;
|
|
}
|
|
|
|
void
|
|
WidgetFactory::changeProperty(const char *name, const TQVariant &value, Form *form)
|
|
//WidgetFactory::changeProperty(const char *name, const TQVariant &value, Container *container)
|
|
{
|
|
// if (!form->manager())
|
|
// return;
|
|
if(form->selectedWidgets()->count() > 1)
|
|
{ // If eg multiple labels are selected, we only want to change the text of one of them (the one the user cliked on)
|
|
if(m_widget)
|
|
m_widget->setProperty(name, value);
|
|
else
|
|
form->selectedWidgets()->first()->setProperty(name, value);
|
|
}
|
|
else
|
|
{
|
|
WidgetPropertySet *set = KFormDesigner::FormManager::self()->propertySet();
|
|
if(set->contains(name))
|
|
(*set)[name] = value;
|
|
}
|
|
}
|
|
|
|
/*
|
|
void
|
|
WidgetFactory::addPropertyDescription(Container *container, const char *prop, const TQString &desc)
|
|
{
|
|
WidgetPropertySet *buff = container->form()->manager()->buffer();
|
|
buff->addPropertyDescription(prop, desc);
|
|
}
|
|
|
|
void
|
|
WidgetFactory::addValueDescription(Container *container, const char *value, const TQString &desc)
|
|
{
|
|
WidgetPropertySet *buff = container->form()->manager()->buffer();
|
|
buff->addValueDescription(value, desc);
|
|
}*/
|
|
|
|
bool
|
|
WidgetFactory::isPropertyVisible(const TQCString &classname, TQWidget *w,
|
|
const TQCString &property, bool multiple, bool isTopLevel)
|
|
{
|
|
if (multiple)
|
|
{
|
|
return property=="font" || property=="paletteBackgroundColor" || property=="enabled"
|
|
|| property=="paletteForegroundColor" || property=="cursor" || property=="paletteBackgroundPixmap";
|
|
}
|
|
|
|
// if(d->properties.isEmpty() && !isTopLevel)
|
|
// d->properties << "caption" << "icon" << "sizeIncrement" << "iconText";
|
|
// if(! (d->properties.grep(property)).isEmpty() )
|
|
// return false;
|
|
|
|
return isPropertyVisibleInternal(classname, w, property, isTopLevel);
|
|
// return !multiple && isPropertyVisibleInternal(classname, w, property);
|
|
}
|
|
|
|
bool
|
|
WidgetFactory::isPropertyVisibleInternal(const TQCString &, TQWidget *w,
|
|
const TQCString &property, bool isTopLevel)
|
|
{
|
|
Q_UNUSED( w );
|
|
|
|
#ifdef KEXI_NO_CURSOR_PROPERTY
|
|
//! @todo temporary unless cursor works properly in the Designer
|
|
if (property=="cursor")
|
|
return false;
|
|
#endif
|
|
|
|
if (!isTopLevel
|
|
&& (property=="caption" || property=="icon" || property=="sizeIncrement" || property=="iconText")) {
|
|
// don't show these properties for a non-toplevel widget
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
WidgetFactory::propertySetShouldBeReloadedAfterPropertyChange(const TQCString& classname, TQWidget *w,
|
|
const TQCString& property)
|
|
{
|
|
Q_UNUSED(classname);
|
|
Q_UNUSED(w);
|
|
Q_UNUSED(property);
|
|
return false;
|
|
}
|
|
|
|
void
|
|
WidgetFactory::resizeEditor(TQWidget *, TQWidget *, const TQCString&)
|
|
{
|
|
}
|
|
|
|
void
|
|
WidgetFactory::slotTextChanged()
|
|
{
|
|
changeTextInternal(editorText());
|
|
}
|
|
|
|
bool
|
|
WidgetFactory::clearWidgetContent(const TQCString &, TQWidget *)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void
|
|
WidgetFactory::changeTextInternal(const TQString& text)
|
|
{
|
|
if (changeText( text ))
|
|
return;
|
|
//try in inherited
|
|
if (!m_editedWidgetClass.isEmpty()) {
|
|
WidgetInfo *wi = m_classesByName[ m_editedWidgetClass ];
|
|
if (wi && wi->inheritedClass()) {
|
|
// wi->inheritedClass()->factory()->m_container = m_container;
|
|
wi->inheritedClass()->factory()->changeText( text );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
WidgetFactory::changeText(const TQString& text)
|
|
{
|
|
changeProperty( "text", text, m_container->form() );
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
WidgetFactory::readSpecialProperty(const TQCString &, TQDomElement &, TQWidget *, ObjectTreeItem *)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
WidgetFactory::saveSpecialProperty(const TQCString &, const TQString &, const TQVariant&, TQWidget *, TQDomElement &, TQDomDocument &)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool WidgetFactory::inheritsFactories()
|
|
{
|
|
for (TQAsciiDictIterator<WidgetInfo> it(m_classesByName); it.current(); ++it) {
|
|
if (!it.current()->parentFactoryName().isEmpty())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
TQString WidgetFactory::editorText() const {
|
|
TQWidget *ed = editor(m_widget);
|
|
return dynamic_cast<KTextEdit*>(ed) ? dynamic_cast<KTextEdit*>(ed)->text() : dynamic_cast<KLineEdit*>(ed)->text();
|
|
}
|
|
|
|
void WidgetFactory::setEditorText(const TQString& text) {
|
|
TQWidget *ed = editor(m_widget);
|
|
if (dynamic_cast<KTextEdit*>(ed))
|
|
dynamic_cast<KTextEdit*>(ed)->setText(text);
|
|
else
|
|
dynamic_cast<KLineEdit*>(ed)->setText(text);
|
|
}
|
|
|
|
void WidgetFactory::setEditor(TQWidget *widget, TQWidget *editor)
|
|
{
|
|
if (!widget)
|
|
return;
|
|
WidgetInfo *winfo = m_classesByName[widget->className()];
|
|
if (!winfo || winfo->parentFactoryName().isEmpty()) {
|
|
m_editor = editor;
|
|
}
|
|
else {
|
|
WidgetFactory *f = m_library->factory(winfo->parentFactoryName());
|
|
if (f!=this)
|
|
f->setEditor(widget, editor);
|
|
m_editor = editor; //keep a copy
|
|
}
|
|
}
|
|
|
|
TQWidget *WidgetFactory::editor(TQWidget *widget) const
|
|
{
|
|
if (!widget)
|
|
return 0;
|
|
WidgetInfo *winfo = m_classesByName[widget->className()];
|
|
if (!winfo || winfo->parentFactoryName().isEmpty()) {
|
|
return m_editor;
|
|
}
|
|
else {
|
|
WidgetFactory *f = m_library->factoryForClassName(widget->className());
|
|
if (f!=this)
|
|
return f->editor(widget);
|
|
return m_editor;
|
|
}
|
|
}
|
|
|
|
void WidgetFactory::setWidget(TQWidget *widget, Container* container)
|
|
{
|
|
WidgetInfo *winfo = widget ? m_classesByName[widget->className()] : 0;
|
|
if (winfo && !winfo->parentFactoryName().isEmpty()) {
|
|
WidgetFactory *f = m_library->factory(winfo->parentFactoryName());
|
|
if (f!=this)
|
|
f->setWidget(widget, container);
|
|
}
|
|
m_widget = widget; //keep a copy
|
|
m_container = container;
|
|
}
|
|
|
|
TQWidget *WidgetFactory::widget() const
|
|
{
|
|
return m_widget;
|
|
}
|
|
|
|
void WidgetFactory::setInternalProperty(const TQCString& classname, const TQCString& property,
|
|
const TQString& value)
|
|
{
|
|
m_internalProp[classname+":"+property]=value;
|
|
}
|
|
|
|
void WidgetFactory::setPropertyOptions( WidgetPropertySet& /*buf*/, const WidgetInfo& /*info*/, TQWidget * /*w*/ )
|
|
{
|
|
//nothing
|
|
}
|
|
|
|
#include "widgetfactory.moc"
|