File indexing completed on 2024-05-12 16:39:38

 /* This file is part of the KDE project
    Copyright (C) 2003 Lucijan Busch <lucijan@kde.org>
    Copyright (C) 2003-2015 Jarosław Staniek <staniek@kde.org>
 
    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 "kexipartinfo_p.h"
 #include "kexipartmanager.h"
 #include "KexiMainWindowIface.h"
 #include <KexiJsonTrader.h>
 
 #include <KDbGlobal>
 
 #include <KActionCollection>
 
 #include <QStringList>
 #include <QDebug>
 #include <QJsonArray>
 
 using namespace KexiPart;
 
 static bool isTrue(KPluginMetaData *metaData, const char* fieldName, bool defaultValue = false)
 {
     QString s = metaData->value(QLatin1String(fieldName));
     if (s.isEmpty()) {
         return defaultValue;
     }
     return 0 == s.compare(QLatin1String("true"), Qt::CaseInsensitive);
 }
 
 Info::Private::Private(Info *info, const QPluginLoader &loader)
     : untranslatedGroupName(info->value("X-Kexi-GroupName"))
     , typeName(info->value("X-Kexi-TypeName"))
     , supportedViewModes(0)
     , supportedUserViewModes(0)
     , isVisibleInNavigator(isTrue(info, "X-Kexi-VisibleInProjectNavigator"))
     , isDataExportSupported(isTrue(info, "X-Kexi-SupportsDataExport"))
     , isPrintingSupported(isTrue(info, "X-Kexi-SupportsPrinting"))
     , isExecuteSupported(isTrue(info, "X-Kexi-SupportsExecution"))
     , isPropertyEditorAlwaysVisibleInDesignMode(
           isTrue(info, "X-Kexi-PropertyEditorAlwaysVisibleInDesignMode", true))
 {
     const QJsonObject metaDataObject = KexiJsonTrader::metaDataObjectForPluginLoader(loader);
     groupName = info->readTranslatedString(metaDataObject, "X-Kexi-GroupName", untranslatedGroupName);
     const QStringList serviceTypes = info->serviceTypes();
     if (serviceTypes.contains("Kexi/Viewer")) {
         supportedViewModes |= Kexi::DataViewMode;
     }
     if (serviceTypes.contains("Kexi/Designer")) {
         supportedViewModes |= Kexi::DesignViewMode;
     }
     if (serviceTypes.contains("Kexi/Editor")) {
         supportedViewModes |= Kexi::TextViewMode;
     }
 
     const QStringList userServiceTypes = metaDataObject.value("X-Kexi-ServiceTypesInUserMode")
             .toString().split(QLatin1Char(',')); // NOTE: toArray() does not work
     if (userServiceTypes.contains("Kexi/Viewer")) {
         supportedUserViewModes |= Kexi::DataViewMode;
     }
     if (userServiceTypes.contains("Kexi/Designer")) {
         supportedUserViewModes |= Kexi::DesignViewMode;
     }
     if (userServiceTypes.contains("Kexi/Editor")) {
         supportedUserViewModes |= Kexi::TextViewMode;
     }
 }
 
 Info::Private::Private()
     : supportedViewModes(0)
     , supportedUserViewModes(0)
     , isVisibleInNavigator(false)
     , isDataExportSupported(false)
     , isPrintingSupported(false)
     , isExecuteSupported(false)
     , isPropertyEditorAlwaysVisibleInDesignMode(true)
 {
 }
 
 //------------------------------
 
 /*! \return "create" QAction's name for part defined by \a info.
  The result is like "tablepart_create". */
 static QString nameForCreateAction(const Info& info)
 {
     return info.id() + ".create";
 }
 
 //------------------------------
 
 KexiNewObjectAction::KexiNewObjectAction(Info* info, QObject *parent)
     : QAction(QIcon::fromTheme(info->iconName()), info->name() + "...", parent)
     , m_info(info)
 {
     setObjectName(nameForCreateAction(*m_info));
     // default tooltip and what's this
     setToolTip(xi18nc("@info",
                       "Create new object of type <resource>%1</resource>",
                       m_info->name().toLower()));
     setWhatsThis(xi18nc("@info",
                         "Creates new object of type <resource>%1</resource>",
                         m_info->name().toLower()));
     connect(this, SIGNAL(triggered()), this, SLOT(slotTriggered()));
     connect(this, SIGNAL(newObjectRequested(KexiPart::Info*)),
             &Kexi::partManager(), SIGNAL(newObjectRequested(KexiPart::Info*)));
 }
 
 void KexiNewObjectAction::slotTriggered()
 {
     emit newObjectRequested(m_info);
 }
 
 //------------------------------
 
 //Info::Info(const QString &id, const QString &iconName,
 //           const QString &objectName)
 //        : KPluginMetaData(), d(new Private)
 //{
 //    d->iconName = iconName;
 //    d->objectName = objectName;
 //}
 
 Info::Info(const QPluginLoader &loader)
     : KexiPluginMetaData(loader), d(new Private(this, loader))
 {
 }
 
 Info::~Info()
 {
     delete d;
 }
 
 QString Info::typeName() const
 {
     return d->typeName;
 }
 
 QString Info::groupName() const
 {
     return d->groupName;
 }
 
 QString Info::untranslatedGroupName() const
 {
     return d->untranslatedGroupName;
 }
 
 Kexi::ViewModes Info::supportedViewModes() const
 {
     return d->supportedViewModes;
 }
 
 Kexi::ViewModes Info::supportedUserViewModes() const
 {
     return d->supportedUserViewModes;
 }
 
 bool Info::isVisibleInNavigator() const
 {
     return d->isVisibleInNavigator;
 }
 
 bool Info::isDataExportSupported() const
 {
     return d->isDataExportSupported;
 }
 
 bool Info::isPrintingSupported() const
 {
     return d->isPrintingSupported;
 }
 
 bool Info::isExecuteSupported() const
 {
     return d->isExecuteSupported;
 }
 
 bool Info::isPropertyEditorAlwaysVisibleInDesignMode() const
 {
     return d->isPropertyEditorAlwaysVisibleInDesignMode;
 }
 
 QAction* Info::newObjectAction()
 {
     if (!isVisibleInNavigator()) {
         return 0;
     }
     if (!KexiMainWindowIface::global() || !KexiMainWindowIface::global()->actionCollection()) {
         qWarning() << "Missing Kexi's global action collection";
         return 0;
     }
     QAction *act = KexiMainWindowIface::global()->actionCollection()->action(nameForCreateAction(*this));
     if (!act) {
         act = new KexiNewObjectAction(this, KexiMainWindowIface::global()->actionCollection());
         KexiMainWindowIface::global()->actionCollection()->addAction(act->objectName(), act);
     }
     return act;
 }