kexi

kexiinternalpart.cpp

00001 /* This file is part of the KDE project
00002    Copyright (C) 2004 Lucijan Busch <lucijan@kde.org>
00003    Copyright (C) 2004-2006 Jaroslaw Staniek <js@iidea.pl>
00004 
00005    This library is free software; you can redistribute it and/or
00006    modify it under the terms of the GNU Library General Public
00007    License as published by the Free Software Foundation; either
00008    version 2 of the License, or (at your option) any later version.
00009 
00010    This library is distributed in the hope that it will be useful,
00011    but WITHOUT ANY WARRANTY; without even the implied warranty of
00012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013    Library General Public License for more details.
00014 
00015    You should have received a copy of the GNU Library General Public License
00016    along with this library; see the file COPYING.LIB.  If not, write to
00017    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00018  * Boston, MA 02110-1301, USA.
00019 */
00020 
00021 #include "kexiinternalpart.h"
00022 
00023 #include "kexidialogbase.h"
00024 #include "kexiviewbase.h"
00025 #include "keximainwindow.h"
00026 
00027 #include <qasciidict.h>
00028 #include <qdialog.h>
00029 
00030 #include <kdebug.h>
00031 #include <klibloader.h>
00032 #include <klocale.h>
00033 #include <ktrader.h>
00034 #include <kparts/componentfactory.h>
00035 #include <kexidb/msghandler.h>
00036 
00038 class KexiInternalPartManager
00039 {
00040     public:
00041         KexiInternalPartManager()
00042          : m_parts(101, false)
00043         {
00044             m_parts.setAutoDelete(false);
00045         }
00046         
00047         KexiInternalPart* findPart(KexiDB::MessageHandler *msgHdr, const char* partName)
00048         {
00049             KexiInternalPart *part = m_parts[partName];
00050             if (!part) {
00051                 QCString fullname("kexihandler_");
00052                 fullname += QCString(partName).lower();
00053                 part = KParts::ComponentFactory::createInstanceFromLibrary<KexiInternalPart>(
00054                     fullname, 0, fullname);
00055                 if (!part) {
00056                     if (msgHdr)
00057                         msgHdr->showErrorMessage(i18n("Could not load \"%1\" plugin.").arg(partName));
00058                 }
00059                 else
00060                     m_parts.insert(partName, part);
00061             }
00062             return part;
00063         }
00064     
00065     private:
00066         
00067         QAsciiDict<KexiInternalPart> m_parts;
00068 };
00069 
00070 KexiInternalPartManager internalPartManager;
00071 
00072 //----------------------------------------------
00073 
00074 KexiInternalPart::KexiInternalPart(QObject *parent, const char *name, const QStringList &)
00075  : QObject(parent, name)
00076  , m_uniqueDialog(true)
00077  , m_cancelled(false)
00078 {
00079 }
00080 
00081 KexiInternalPart::~KexiInternalPart()
00082 {
00083 }
00084 
00085 //static
00086 const KexiInternalPart *
00087 KexiInternalPart::part(KexiDB::MessageHandler *msgHdr, const char* partName)
00088 {
00089     return internalPartManager.findPart(msgHdr, partName);
00090 }
00091 
00092 //static
00093 QWidget* KexiInternalPart::createWidgetInstance(const char* partName, 
00094     const char* widgetClass, KexiDB::MessageHandler *msgHdr, KexiMainWindow* mainWin, 
00095     QWidget *parent, const char *objName, QMap<QString,QString>* args)
00096 {
00097     KexiInternalPart *part = internalPartManager.findPart(msgHdr, partName);
00098     if (!part)
00099         return 0; //fatal!
00100     return part->createWidget(widgetClass, mainWin, parent, objName ? objName : partName, args);
00101 }
00102 
00103 KexiDialogBase* KexiInternalPart::findOrCreateKexiDialog(
00104     KexiMainWindow* mainWin, const char *objName)
00105 {
00106     if (m_uniqueDialog && !m_uniqueWidget.isNull())
00107         return dynamic_cast<KexiDialogBase*>((QWidget*)m_uniqueWidget);
00108 //  KexiDialogBase *dlg = createDialog(mainWin, objName);
00109     KexiDialogBase * dlg = new KexiDialogBase(mainWin, "");
00110     KexiViewBase *view = createView(mainWin, 0, objName);
00111     if (!view)
00112         return 0;
00113 
00114 //  dlg->show();
00115     
00116     if (m_uniqueDialog)
00117         m_uniqueWidget = dlg; //recall unique!
00118     dlg->addView(view);
00119     dlg->setCaption( view->caption() );
00120     dlg->setTabCaption( view->caption() );
00121     dlg->resize(view->sizeHint());
00122     dlg->setMinimumSize(view->minimumSizeHint().width(),view->minimumSizeHint().height());
00123     dlg->setId( mainWin->generatePrivateID() );
00124     dlg->registerDialog();
00125     return dlg;
00126 }
00127 
00128 //static
00129 KexiDialogBase* KexiInternalPart::createKexiDialogInstance(
00130     const char* partName, 
00131     KexiDB::MessageHandler *msgHdr, KexiMainWindow* mainWin, const char *objName)
00132 {
00133     KexiInternalPart *part = internalPartManager.findPart(msgHdr, partName);
00134     if (!part) {
00135         kdDebug() << "KexiInternalPart::createDialogInstance() !part" << endl;
00136         return 0; //fatal!
00137     }
00138     return part->findOrCreateKexiDialog(mainWin, objName ? objName : partName);
00139 }
00140 
00141 //static
00142 QDialog* KexiInternalPart::createModalDialogInstance(const char* partName, 
00143     const char* dialogClass, KexiDB::MessageHandler *msgHdr, KexiMainWindow* mainWin, 
00144     const char *objName, QMap<QString,QString>* args)
00145 {
00146     KexiInternalPart *part = internalPartManager.findPart(msgHdr, partName);
00147     if (!part) {
00148         kdDebug() << "KexiInternalPart::createDialogInstance() !part" << endl;
00149         return 0; //fatal!
00150     }
00151     QWidget *w;
00152     if (part->uniqueDialog() && !part->m_uniqueWidget.isNull())
00153         w = part->m_uniqueWidget;
00154     else
00155         w = part->createWidget(dialogClass, mainWin, mainWin, objName ? objName : partName, args);
00156 
00157     if (dynamic_cast<QDialog*>(w)) {
00158         if (part->uniqueDialog())
00159             part->m_uniqueWidget = w;
00160         return dynamic_cast<QDialog*>(w);
00161     }
00162     //sanity
00163     if (! (part->uniqueDialog() && !part->m_uniqueWidget.isNull()))
00164         delete w;
00165     return 0;
00166 }
00167 
00168 //static 
00169 bool KexiInternalPart::executeCommand(const char* partName, 
00170     KexiMainWindow* mainWin, const char* commandName, QMap<QString,QString>* args)
00171 {
00172     KexiInternalPart *part = internalPartManager.findPart(0, partName);
00173     if (!part) {
00174         kdDebug() << "KexiInternalPart::createDialogInstance() !part" << endl;
00175         return 0; //fatal!
00176     }
00177     return part->executeCommand(mainWin, commandName, args);
00178 }
00179 
00180 QWidget* KexiInternalPart::createWidget(const char* widgetClass, KexiMainWindow* mainWin, 
00181     QWidget * parent, const char * objName, QMap<QString,QString>* args)
00182 {
00183     Q_UNUSED(widgetClass);
00184     Q_UNUSED(mainWin);
00185     Q_UNUSED(parent);
00186     Q_UNUSED(objName);
00187     Q_UNUSED(args);
00188     return 0;
00189 }
00190 
00191 KexiViewBase* KexiInternalPart::createView(KexiMainWindow* mainWin, QWidget * parent,
00192  const char * objName)
00193 {
00194     Q_UNUSED(mainWin);
00195     Q_UNUSED(parent);
00196     Q_UNUSED(objName);
00197     return 0;
00198 }
00199 
00200 bool KexiInternalPart::executeCommand(KexiMainWindow* mainWin, const char* commandName, 
00201     QMap<QString,QString>* args)
00202 {
00203     Q_UNUSED(mainWin);
00204     Q_UNUSED(commandName);
00205     Q_UNUSED(args);
00206     return false;
00207 }
00208 
00209 #include "kexiinternalpart.moc"
KDE Home | KDE Accessibility Home | Description of Access Keys