path: root/sip/kparts/part.sip

//
//     Copyright 2006 Jim Bublitz <jbublitz@nwinternet.com>
//     Earlier copyrights 1998 - 2005 Jim Bublitz and/or Phil Thompson
//     may also apply


//                 Generated by preSip
//            module kparts  version KDE 3.5.3


// This software is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// This software 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public
// License along with this library; see the file COPYING.
// If not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

namespace KParts
{

class PartBase : KXMLGUIClient
{
%TypeHeaderCode
#include <part.h>
%End


public:
                         PartBase ();
    void                 setPartObject (TQObject*);
    TQObject*             partObject () const;

protected:
    virtual void         setInstance (TDEInstance*);
    virtual void         setInstance (TDEInstance*, bool);

%If ( KDE_3_1_0 -  )
    void                 loadPlugins (TQObject* /Transfer/, KXMLGUIClient*, TDEInstance*);
//ig     void                 setPluginLoadingMode (KParts::PartBase::PluginLoadingMode);
%End


};  // class PartBase


class Part : TQObject, KParts::PartBase
{
%TypeHeaderCode
#include <part.h>
%End


public:
                         Part (TQObject* /TransferThis/ = 0, const char* = 0);
    virtual void         embed (TQWidget*);
    virtual TQWidget*     widget ();
    virtual void         setManager (KParts::PartManager*);
    KParts::PartManager* manager ();
    virtual KParts::Part* hitTest (TQWidget*, const TQPoint&);
    virtual void         setSelectable (bool);
    bool                 isSelectable () const;

signals:
    void                 setWindowCaption (const TQString&);
    void                 setStatusBarText (const TQString&);

protected:
    virtual void         setWidget (TQWidget*);
    virtual void         customEvent (TQCustomEvent*);
    virtual void         partActivateEvent (KParts::PartActivateEvent*);
    virtual void         partSelectEvent (KParts::PartSelectEvent*);
    virtual void         guiActivateEvent (KParts::GUIActivateEvent*);
    TQWidget*             hostContainer (const TQString&);

//force
%ConvertToSubClassCode
    // The table of Python class objects indexed by their names.  The table
    // must be sorted by name.

    static sipStringTypeClassMap map[] = {
        {sipName_BrowserExtension,        &sipClass_KParts_BrowserExtension},
        {sipName_BrowserHostExtension,    &sipClass_KParts_BrowserHostExtension},
        {sipName_BrowserInterface,        &sipClass_KParts_BrowserInterface},
        {sipName_BrowserRun,              &sipClass_KParts_BrowserRun},
        {sipName_Factory,                 &sipClass_KParts_Factory},
        {sipName_HistoryProvider,         &sipClass_KParts_HistoryProvider},
#if TDE_VERSION >= 0x030100
        {sipName_LiveConnectExtension,    &sipClass_KParts_LiveConnectExtension},
#endif
        {sipName_MainWindow,              &sipClass_KParts_MainWindow},
        {sipName_Part,                    &sipClass_KParts_Part},
        {sipName_PartManager,             &sipClass_KParts_PartManager},
        {sipName_Plugin,                  &sipClass_KParts_Plugin},
        {sipName_ReadOnlyPart,            &sipClass_KParts_ReadOnlyPart},
        {sipName_ReadWritePart,           &sipClass_KParts_ReadWritePart},
    };

    sipClass = sipMapStringToClass(sipCpp -> className(),map,sizeof (map)/sizeof (map[0]));
%End
//end

};  // class Part

//doc
// Even though this is an abstract class, you can use
// createReadOnlyPart (see below) without creating
// a concrete instance of this class.
//end

class ReadOnlyPart : KParts::Part
{
%TypeHeaderCode
#include <part.h>
%End


public:
                         ReadOnlyPart (TQObject* /TransferThis/ = 0, const char* = 0);
    void                 setProgressInfoEnabled (bool);
    bool                 isProgressInfoEnabled () const;
    void                 showProgressInfo (bool);

public slots:
    virtual bool         openURL (const KURL&);

public:
    KURL                 url () const;
    virtual bool         closeURL ();

public:
    bool                 openStream (const TQString&, const KURL&);
    bool                 writeStream (const TQByteArray&);
    bool                 closeStream ();

signals:
    void                 started (KIO::Job*);
    void                 completed ();
    void                 completed (bool);
    void                 canceled (const TQString&);

protected slots:
    void                 slotJobFinished (KIO::Job*);

protected:
    virtual bool         openFile ()  = 0;
    void                 abortLoad ();
    virtual void         guiActivateEvent (KParts::GUIActivateEvent*);

};  // class ReadOnlyPart

//doc
// Even though this is an abstract class, you can use
// createReadWritePart (see below) without creating a concrete instance
// of this class.
//end

class ReadWritePart : KParts::ReadOnlyPart
{
%TypeHeaderCode
#include <part.h>
%End


public:
                         ReadWritePart (TQObject* /TransferThis/ = 0, const char* = 0);
    bool                 isReadWrite () const;
    virtual void         setReadWrite (bool = 1);
    bool                 isModified () const;

%If ( KDE_3_1_3 -  )
    bool                 queryClose ();
%End

    virtual bool         closeURL ();

%If ( KDE_3_1_3 -  )
    bool                 closeURL (bool);
%End

    virtual bool         saveAs (const KURL&);
    virtual void         setModified (bool);

signals:

%If ( KDE_3_2_0 -  )
//ig     void                 sigQueryClose (bool*, bool*);
%End


public slots:
    virtual void         setModified ();
    virtual bool         save ();

%If ( KDE_3_2_0 -  )
    bool                 waitSaveComplete ();
%End


protected:
    virtual bool         saveFile ()  = 0;
    virtual bool         saveToURL ();

protected slots:
    void                 slotUploadFinished (KIO::Job*);

};  // class ReadWritePart

};  // namespace KParts

//force
//doc
// <para>
// This is a PyKDE-only function that handles the machinery necessary
// to create a KParts::ReadOnlyPart. It executes the following C++ code:
// </para>
// <pre class="PROGRAMLISTING">
// KParts::ReadOnlyPart *createReadOnlyPart (const TQString&amp; lib, TQObject *parent,
//                                           const TQString&amp; name, const char *className,
//                                           const TQStringList &amp;args)
// {
//    KLibFactory *factory = KLibLoader::self ()-&gt;factory ((const char *)lib);
//
//    if (factory)
//            return static_cast&lt;KParts::ReadOnlyPart*&gt; (factory-&gt;create (parent,
//                                               (const char *)name, className, args));
//        else
//                return NULL;
// </pre>
// <para>
// Notice that it takes care of creating the KLibFactory for you, and
// returns the part cast to type KParts::ReadOnlyPart.  The actual
// part has a different class (derived from KParts::ReadOnlyPart),
// and calls to openURL or openFile will use the part's overloaded
// methods. Currently it isn't possible to call KParts::ReadOnlyPart::openURL
// if it has been overloaded.
// </para>
// <para>
// Usage: KParts.createReadOnlyPart (lib, parent, name, className, args)
// </para>
//end
KParts::ReadOnlyPart* createReadOnlyPart (const TQString&, TQObject* = 0, const TQString& = TQString ::null , const char* = "KParts::ReadOnlyPart", const TQStringList& = TQStringList ());
//doc
// <para>
// This is a PyKDE-only function that handles the machinery necessary
// to create a KParts::ReadWritePart. It executes the following C++ code:
// </para>
// <pre class="PROGRAMLISTING">
// KParts::ReadWritePart *createReadWritePart (const TQString&amp; lib, TQObject *parent,
//                                           const TQString&amp; name, const char *className,
//                                           const TQStringList &amp;args)
// {
//     KLibFactory *factory = KLibLoader::self ()-&gt;factory ((const char *)lib);
//
//     if (factory)
//             return static_cast&lt;KParts::ReadWritePart*&gt; (factory-&gt;create (parent,
//                                                (const char *)name, className, args));
//         else
//                 return NULL;
// </pre>
// <para>
// Notice that it takes care of creating the KLibFactory for you, and
// returns the part cast to type KParts::ReadWritePart.  The actual
// part has a different class (derived from KParts::ReadWritePart),
// and calls to openURL or openFile will use the part's overloaded
// methods. Currently it isn't possible to call KParts::ReadWritePart::openURL
// if it has been overloaded.
// </para>
// <para>
// Usage: KParts.createReadWritePart (lib, parent, name, className, args)
// </para>
//end
KParts::ReadWritePart* createReadWritePart (const TQString&, TQObject* = 0, const TQString& = TQString ::null , const char* = "KParts::ReadWritePart", const TQStringList& = TQStringList ());
//end


%ModuleCode
#include <klibloader.h>

KParts::ReadOnlyPart *createReadOnlyPart (const TQString& lib, TQObject *parent, const TQString& name, const char *className,
                                          const TQStringList &args)
{
        KParts::ReadOnlyPart *res = NULL;

        KLibFactory *factory = KLibLoader::self ()->factory ((const char *)lib);

        if (factory)
                res = static_cast<KParts::ReadOnlyPart*> (factory->create (parent, (const char *)name, className, args));

        return res;
}

KParts::ReadWritePart *createReadWritePart (const TQString& lib, TQObject *parent, const TQString& name, const char *className,
                                          const TQStringList &args)
{
        KParts::ReadWritePart *res = NULL;

        KLibFactory *factory = KLibLoader::self ()->factory ((const char *)lib);

        if (factory)
                res = static_cast<KParts::ReadWritePart*> (factory->create (parent, (const char *)name, className, args));

        return res;
}
%End