kexiproject.h

/* This file is part of the KDE project
   Copyright (C) 2003 Lucijan Busch <lucijan@kde.org>
   Copyright (C) 2003-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.
*/
 
#ifndef KEXIPROJECT_H
#define KEXIPROJECT_H
 
#include <tqobject.h>
#include <tqintdict.h>
#include <tqptrdict.h>
#include <tqguardedptr.h>
 
#include <kexiutils/tristate.h>
#include <kexidb/object.h>
#include "kexiprojectdata.h"
#include "kexipartitem.h"
#include "kexi.h"

 
#define KEXIPROJECT_VERSION_MAJOR 1
#define KEXIPROJECT_VERSION_MINOR 0
 
namespace KexiDB
{
    class DriverManager;
    class Driver;
    class Connection;
    class Parser;
}
 
namespace KexiPart
{
    class Part;
    class Info;
}
 
class KexiMainWindow;
class KexiDialogBase;

class KEXICORE_EXPORT KexiProject : public TQObject, public KexiDB::Object
{
    TQ_OBJECT
  
 
    public:
        KexiProject(KexiProjectData* pdata, KexiDB::MessageHandler* handler = 0);

        KexiProject(KexiProjectData *pdata, KexiDB::MessageHandler* handler, 
            KexiDB::Connection* conn);
 
//      KexiProject(KexiDB::ConnectionData *cdata);
 
        ~KexiProject();

        int versionMajor() const;

        int versionMinor() const;

        tristate open();

        tristate open(bool &incompatibleWithKexi);

        tristate create(bool forceOverwrite = false);

        bool error() const { return KexiDB::Object::error(); }

        bool isConnected();

        KexiPart::ItemDict* items(KexiPart::Info *i);

        KexiPart::ItemDict* itemsForMimeType(const TQCString &mimeType);

        void getSortedItems(KexiPart::ItemList& list, KexiPart::Info *i);

        void getSortedItemsForMimeType(KexiPart::ItemList& list, const TQCString &mimeType);

        KexiPart::Item* itemForMimeType(const TQCString &mimeType, const TQString &name);

        KexiPart::Item* item(KexiPart::Info *i, const TQString &name);

        KexiPart::Item* item(int identifier);

        KexiDB::Connection *dbConnection() const;

        KexiProjectData *data() const;

        KexiDialogBase* openObject(KexiMainWindow *wnd, KexiPart::Item& item, 
            int viewMode = Kexi::DataViewMode, TQMap<TQString,TQString>* staticObjectArgs = 0);

        KexiDialogBase* openObject(KexiMainWindow *wnd, const TQCString &mimeType, 
            const TQString& name, int viewMode = Kexi::DataViewMode);

        bool removeObject(KexiMainWindow *wnd, KexiPart::Item& item);

        bool renameObject(KexiMainWindow *wnd, KexiPart::Item& item, const TQString& newName);

        KexiPart::Item* createPartItem(KexiPart::Info *info, 
            const TQString& suggestedCaption = TQString() );

        KexiPart::Item* createPartItem(KexiPart::Part *part, 
            const TQString& suggestedCaption = TQString());

        void addStoredItem(KexiPart::Info *info, KexiPart::Item *item);

        void deleteUnstoredItem(KexiPart::Item *item);
 
#if 0 //remove?
        bool createObject(KexiDialogBase *dlg);
#endif
 
        KexiDB::Parser* sqlParser();

        static KexiProject* createBlankProject(bool &cancelled, KexiProjectData* data,
            KexiDB::MessageHandler* handler = 0);

        static tristate dropProject(KexiProjectData* data, 
            KexiDB::MessageHandler* handler, bool dontAsk = false);

//      void setQuerySchemaObsolete( const TQString& queryName );
 
//      /** used to emit objectCreated() signal */
//      void emitObjectCreated(const TQCString &mime, const TQCString& name) { emit objectCreated(mime, name); }
//      void emitTableCreated(KexiDB::TableSchema& schema) { emit tableCreated(schema); }
 
    protected:
        bool createConnection();
        
        bool closeConnection();
 
        bool initProject();

        tristate openInternal(bool *incompatibleWithKexi);

        bool createInternalStructures(bool insideTransaction);

        KexiPart::Part *findPartFor(KexiPart::Item& item);
 
    signals:
        void error(const TQString &title, KexiDB::Object *obj);

        void error(const TQString &msg, const TQString &desc);

        void newItemStored(KexiPart::Item& item);

        void itemRemoved(const KexiPart::Item &item);

        void itemRenamed(const KexiPart::Item &item, const TQCString& oldName);
 
//      /** new table \a schema created */
//      void tableCreated(KexiDB::TableSchema& schema);
//      /** New object of mimetype \a mime and \a name has been created. */
//      void objectCreated(const TQCString &mime, const TQCString& name);
 
    protected:
        bool checkWritable();
 
        class Private;
        Private *d;
 
        friend class KexiMainWindowImpl;
};
 
 
#endif