KParts::ReadOnlyPart Class Referenceabstract

`#include <part.h>`

Inheritance diagram for KParts::ReadOnlyPart:

## Public Slots

virtual bool | openURL (const KURL &url)

## Signals

void | started (KIO::Job *)
void | completed ()
void | completed (bool pendingAction)
void | canceled (const QString &errMsg)
Signals inherited from KParts::Part
void | setWindowCaption (const QString &caption)
void | setStatusBarText (const QString &text)

## Public Member Functions

| ReadOnlyPart (QObject *parent=0, const char *name=0)
virtual | ~ReadOnlyPart ()
void | setProgressInfoEnabled (bool show)
bool | isProgressInfoEnabled () const
void | showProgressInfo (bool show)
KURL | url () const
virtual bool | closeURL ()
bool | openStream (const QString &mimeType, const KURL &url)
bool | writeStream (const QByteArray &data)
bool | closeStream ()
Public Member Functions inherited from KParts::Part
| Part (QObject *parent=0, const char *name=0)
virtual | ~Part ()
virtual void | embed (QWidget *parentWidget)
virtual QWidget * | widget ()
virtual void | setManager (PartManager *manager)
PartManager * | manager () const
virtual Part * | hitTest (QWidget *widget, const QPoint &globalPos)
virtual void | setSelectable (bool selectable)
bool | isSelectable () const
Public Member Functions inherited from KParts::PartBase
| PartBase ()
virtual | ~PartBase ()
void | setPartObject (QObject *object)
QObject * | partObject () const

## Protected Slots

void | slotJobFinished (KIO::Job *job)

## Protected Member Functions

virtual bool | openFile ()=0
void | abortLoad ()
virtual void | guiActivateEvent (GUIActivateEvent *event)
Protected Member Functions inherited from KParts::Part
virtual void | setWidget (QWidget *widget)
virtual void | customEvent (QCustomEvent *event)
virtual void | partActivateEvent (PartActivateEvent *event)
virtual void | partSelectEvent (PartSelectEvent *event)
QWidget * | hostContainer (const QString &containerName)
Protected Member Functions inherited from KParts::PartBase
virtual void | setInstance (KInstance *instance)
virtual void | setInstance (KInstance *instance, bool loadPlugins)
void | loadPlugins (QObject *parent, KXMLGUIClient *parentGUIClient, KInstance *instance)
void | setPluginLoadingMode (PluginLoadingMode loadingMode)

## Protected Attributes

KURL | m_url
QString | m_file
bool | m_bTemp

## Friends

class | ReadWritePart

## Additional Inherited Members

Protected Types inherited from KParts::PartBase
enum | PluginLoadingMode { DoNotLoadPlugins = 0, LoadPlugins = 1, LoadPluginsIfEnabled = 2 }

## Detailed Description

Base class for any "viewer" part.

This class takes care of network transparency for you, in the simplest way (downloading to a temporary file, then letting the part load from the temporary file). To use the built-in network transparency, you only need to implement openFile(), not openURL().

To implement network transparency differently (e.g. for progressive loading, like a web browser does for instance), or to prevent network transparency (but why would you do that?), you can override openURL().

KParts Application can use the signals to show feedback while the URL is being loaded.

ReadOnlyPart handles the window caption by setting it to the current URL (set in openURL(), and each time the part is activated). If you want another caption, set it in openFile() and (if the part might ever be used with a part manager) in guiActivateEvent()

Definition at line 338 of file part.h.

## Constructor & Destructor Documentation

ReadOnlyPart::ReadOnlyPart | ( | QObject * | parent = `0`,
|  | const char * | name = `0`
| ) |  |

Constructor See also Part for the setXXX methods to call.

Definition at line 304 of file part.cpp.

ReadOnlyPart::~ReadOnlyPart | ( |  | ) |

virtual

Destructor.

Definition at line 310 of file part.cpp.

## Member Function Documentation

void KParts::ReadOnlyPart::canceled | ( | const QString & | errMsg | ) |

signal

Emit this if loading is canceled by the user or by an error.

Parameters

  errMsg | the error message, empty if the user canceled the loading voluntarily.

bool ReadOnlyPart::closeStream | ( |  | ) |

Terminate the sending of data to the part.

With some data types (text, html...) closeStream might never actually be called, in the case of continuous streams, for instance plain text or HTML data.

Definition at line 440 of file part.cpp.

bool ReadOnlyPart::closeURL | ( |  | ) |

virtual

Called when closing the current url (e.g.

document), for instance when switching to another url (note that openURL() calls it automatically in this case). If the current URL is not fully loaded yet, aborts loading. Deletes the temporary file used when the url is remote.

Returns
  always true, but the return value exists for reimplementations

Reimplemented in KParts::ReadWritePart.

Definition at line 385 of file part.cpp.

void KParts::ReadOnlyPart::completed | ( |  | ) |

signal

Emit this when you have completed loading data.

Hosting apps will want to know when the process of loading the data is finished, so that they can access the data when everything is loaded.

void KParts::ReadOnlyPart::completed | ( | bool | pendingAction | ) |

signal

Same as the above signal except it indicates whether there is a pending action to be executed on a delay timer.

An example of this is the meta-refresh tags on web pages used to reload/redirect after a certain period of time. This signal is useful if you want to give the user the ability to cancel such pending actions.

Parameters

  pendingAction | true if a pending action exists, false otherwise.

void ReadOnlyPart::guiActivateEvent | ( | GUIActivateEvent * | event | ) |

protected virtual

Reimplemented from Part, so that the window caption is set to the current url (decoded) when the part is activated.

This is the usual behavior in 99% of the apps. Reimplement if you don't like it - test for event->activated() !

Technical note : this is done with GUIActivateEvent and not with PartActivateEvent because it's handled by the mainwindow (which gets the even after the PartActivateEvent events have been sent)

Reimplemented from KParts::Part.

Definition at line 415 of file part.cpp.

bool ReadOnlyPart::isProgressInfoEnabled | ( |  | ) | const

Returns whether the part shows the progress info dialog used by internal KIO job.

Definition at line 321 of file part.cpp.

virtual bool KParts::ReadOnlyPart::openFile | ( |  | ) |

protected pure virtual

If the part uses the standard implementation of openURL(), it must reimplement this, to open `m_file`.

Otherwise simply define it to { return false; }

bool ReadOnlyPart::openStream | ( | const QString & | mimeType,
|  | const KURL & | url
| ) |  |

Initiate sending data to this part.

This is an alternative to openURL, which allows the user of the part to load the data itself, and send it progressively to the part.

Parameters

  mimeType | the type of data that is going to be sent to this part.
  url | the URL representing this data. Although not directly used, every ReadOnlyPart has a URL (see url()), so this simply sets it.

Returns
  true if the part supports progressive loading and accepts data, false otherwise.

Definition at line 427 of file part.cpp.

bool ReadOnlyPart::openURL | ( | const KURL & | url | ) |

virtual slot

Only reimplement openURL if you don't want the network transparency support to download from the url into a temporary file (when the url isn't local).

Otherwise, reimplement openFile() only .

If you reimplement it, don't forget to set the caption, usually with emit setWindowCaption( url.prettyURL() );

Definition at line 333 of file part.cpp.

void ReadOnlyPart::setProgressInfoEnabled | ( | bool | show | ) |

Call this to turn off the progress info dialog used by the internal KIO job.

Use this if you provide another way of displaying progress info (e.g. a statusbar), using the signals emitted by this class, and/or those emitted by the Job given by started.

Definition at line 316 of file part.cpp.

void KParts::ReadOnlyPart::started | ( | KIO::Job * |  | ) |

signal

The part emits this when starting data.

If using a KIO::Job, it sets the job in the signal, so that progress information can be shown. Otherwise, job is 0.

KURL KParts::ReadOnlyPart::url | ( |  | ) | const

inline

Returns the currently in part used URL.

Returns
  The current used URL.

Definition at line 390 of file part.h.

bool ReadOnlyPart::writeStream | ( | const QByteArray & | data | ) |

Send some data to the part.

openStream must have been called previously, and must have returned true.

Returns
  true if the data was accepted by the part. If false is returned, the application should stop sending data, and doesn't have to call closeStream.

Definition at line 435 of file part.cpp.

## Member Data Documentation

bool KParts::ReadOnlyPart::m_bTemp

protected

If `true`, `m_file` is a temporary file that needs to be deleted later.

Definition at line 523 of file part.h.

QString KParts::ReadOnlyPart::m_file

protected

Local file - the only one the part implementation should deal with.

Definition at line 519 of file part.h.

KURL KParts::ReadOnlyPart::m_url

protected

Remote (or local) url - the one displayed to the user.

Definition at line 515 of file part.h.

The documentation for this class was generated from the following files:

- part.h
- part.cpp

KDE Home | KDE Accessibility Home | Description of Access Keys