diff --git a/libs/flake/KoFilterEffectRegistry.h b/libs/flake/KoFilterEffectRegistry.h index 8b3813124ec..7b33a008ee6 100644 --- a/libs/flake/KoFilterEffectRegistry.h +++ b/libs/flake/KoFilterEffectRegistry.h @@ -1,60 +1,61 @@ /* This file is part of the KDE project * Copyright (c) 2009 Jan Hambrecht * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 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 Lesser 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 KOFILTEREFFECTREGISTRY_H #define KOFILTEREFFECTREGISTRY_H #include #include #include "flake_export.h" class KoXmlElement; class KoFilterEffectLoadingContext; class FLAKE_EXPORT KoFilterEffectRegistry : public KoGenericRegistry { public: KoFilterEffectRegistry(); virtual ~KoFilterEffectRegistry(); /** * Return the only instance of KoFilterEffectRegistry. * Creates an instance on the first call. */ static KoFilterEffectRegistry *instance(); /** * Creates filter effect from given xml element. * @param element the xml element to load form + * @param context the loading context * @return the created filter effect if successful, otherwise returns 0 */ KoFilterEffect *createFilterEffectFromXml(const KoXmlElement &element, const KoFilterEffectLoadingContext &context); private: KoFilterEffectRegistry(const KoFilterEffectRegistry&); KoFilterEffectRegistry operator=(const KoFilterEffectRegistry&); void init(); class Private; Private * const d; }; #endif // KOFILTEREFFECTREGISTRY_H diff --git a/libs/rdf/KoDocumentRdf.h b/libs/rdf/KoDocumentRdf.h index f618c8d5153..e3de3777f7e 100644 --- a/libs/rdf/KoDocumentRdf.h +++ b/libs/rdf/KoDocumentRdf.h @@ -1,516 +1,517 @@ /* This file is part of the KDE project Copyright (C) 2010 KO GmbH 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 KO_DOCUMENT_Rdf_H #define KO_DOCUMENT_Rdf_H #include "kordf_export.h" #include "RdfForward.h" #include "KoSemanticStylesheet.h" #include "KoRdfSemanticItem.h" #include "KoRdfSemanticItemViewSite.h" #include "RdfSemanticTreeWidgetAction.h" #include "KoRdfSemanticTree.h" // Calligra #include #include #include // Soprano #include // Qt #include #include #include #include #include #include class QDomDocument; class KoStore; class KoXmlWriter; class KoDocument; class KoCanvasBase; class KoTextEditor; class KoDocumentRdfPrivate; class QAction; /** * @short The central access point for the Rdf metadata of an ODF document. * * @author Ben Martin * @see KoDocument * @see KoDocumentInfo * * The KoDocumentRdf object is possibly associated with a KoDocument. * There does not need to be a KoDocumentRdf for each KoDocument, but * if one exists it is a one-to-one relationship. The KoDocumentRdf * is also associated with the KoDocumentResourceManager of a canvas. * * Once again, the canvas to KoDocumentRdf is either a 1-1 or 1 to * zero relationship. * * ACCESS TO Rdf: * * You can get at the Rdf information in two main ways: either using * Soprano/SPARQL or through KoRdfSemanticItem objects. * * Subclasses of KoRdfSemanticItem exist for locations (foaf,vcard), * events (ical), and locations (two Rdf geolocation formats). To get * a list of these objects use the foaf(), calendarEvents(), and * locations() methods of this class. Each of these methods optionally * takes a Soprano::Model and returns a list of SemanticItems of a * particular subclass. If you do not pass an Soprano::Model to the * methods the default model() of the KoDocumentRdf is used. By * allowing you to pass a model explicitly, you can find contacts that * exist in a subset of the full Rdf graph for a document. This is * useful if you want to find the contacts in the users current * "selection" in the document. * * For example, to find the foaf entries related to the current KoTextEditor * * Soprano::Model* model = rdf->findStatements( editor ); * QList foaflist = rdf->semanticItems( "Contact", model ); * * Using the Soprano::Model directly is covered in a latter section of * this comment. * * STORAGE OF Rdf: * * Broadly there are two ways Rdf metadata is stored in an ODF * document. * * 1) inline in the content.xml file in an Rdfa style, though not * using the full Rdfa spec * * 2) externally in manifest.rdf or other Rdf/XML files linked to by * manifest.rdf * * The Rdf that is stored using these methods is collected and made * available by the KoDocumentRdf class. The inline Rdf using option * (1) is stored along with the Calligra C++ objects that are created * during document loading. This class also knows how to find the * scattered Rdf that option (1) loads. Leaving the Rdf from option * (1) scattered in the document allows it to be preserved in the * normal course of document editing such as copy and paste, undo and * redo operations. * * The scattered Rdf from option (1) is stored using the * KoTextInlineRdf class. You can convert a KoTextInlineRdf to * a Soprano::Statement with the toStatement() method of this class. * * LOW LEVEL Rdf ACCESS: * * The model() method will give you a Soprano::model with all the Rdf * for the document, be them from option (1) or (2) above. * * The findStatements() methods will give you a Soprano::model * containing the statements relevant to a cursor or xml:id in the * document. The xml:id is the same identifier that is used in the * content.xml file that was loaded. * * Note that the findStatements() returns a submodel containing only * the statements relevant to the xml:id or cursor position you * selected. This will be a subset of all the Rdf for the document. * The various expand() methods can be used to add more Rdf statements * from the document to the submodel returned by findStatements(). For * example, the expandStatementsReferencingSubject() method will * expand the soprano::model to add Rdf statements which refer to any * subject in the Rdf submodel you pass in. */ class KORDF_EXPORT KoDocumentRdf : public KoDocumentRdfBase { Q_OBJECT public: /** * For Rdf stored in manifest.rdf or another rdf file referenced * by the manifest, this prefix is used as the start of the graph * context. The filename.rdf is appended so that the Rdf can be * put back into the right file again during save. */ const static QString RDF_PATH_CONTEXT_PREFIX; /** * The constructor * @param parent a pointer to the parent object */ explicit KoDocumentRdf(QObject *parent = 0); /** The destructor */ ~KoDocumentRdf(); /** * Load from an OASIS document * @param store the store with the metaInformation * @return true if success */ bool loadOasis(KoStore *store); /** * Save to an OASIS document * @param store a pointer to a KoStore to save in + * @param manifestWriter the document writer * @return true if success */ bool saveOasis(KoStore *store, KoXmlWriter *manifestWriter); /** * Used by KoRdfSemanticItem when creating new semantic items so that the * KoDocumentRdf class can find them. */ void rememberNewInlineRdfObject(KoTextInlineRdf *inlineRdf); /** * Find all the KoTextInlineRdf objects that exist in the * document and update the statements in the Soprano::(model) to * reflect the current state of the inline Rdf. */ void updateInlineRdfStatements(const QTextDocument *qdoc); /** * During a save(), various Rdf objects in the document will * create new xmlid values which are used in the saved document. * As part of the save state a QMap from the old xmlid to the new * xmlid is built up. This method is then used to update the Rdf * triples to use the new xmlid values before that Rdf itself is * saved. This way the Rdf -> xmlid references will remain valid * in the saved ODF file. * * Since the Rdf is updated to use the new xmlid values, this method * also updates the C++ objects to use the new xmlid values so that * the instance of the document in memory is correctly linked. * * This way, Calligra is free to change the xml:id during save() and * the Rdf is still linked correctly. */ void updateXmlIdReferences(const QMap &m); /** * Get the namespace to URI prefix mapping object. */ KoRdfPrefixMapping* prefixMapping() const; /** * Get the Soprano::Model that contains all the Rdf * You do not own the model, do not delete it. */ virtual QSharedPointer model() const; /** * Convert an inlineRdf object into a Soprano::Statement */ Soprano::Statement toStatement(KoTextInlineRdf *inlineRdf) const; /** * Look for the semitem with the given xmlid and return the * start and end position for that semitem. If there is no semitem * with the \p xmlId then 0,0 is returned. */ QPair findExtent(const QString &xmlId) const; /** * Look for the semitem that is at or surrounding the cursor given. Note that if there * are nested semitems, the extend for the most nested semitem is returned. * for example, in the below scenario the return value will be QPair< start-b, end-b >. * * ... ... cursor ... ... */ QPair findExtent(KoTextEditor *handler) const; /** * find the xmlid of the semitem that is at or surrounding the cursor given. As with * findExtent() this will be only the most nested semitem. * @see findExtent() */ QString findXmlId(KoTextEditor *cursor) const; /** * Find all of the statements which are * in context for a given cursor position. * * Rdf is also added to the returned model from external manifest.rdf * and other files which attach to the xml:id * * The depth parameter allows triple expansion, ie, * depth=1 adds only triples which reference ?s ?p xml:id * depth=2 adds references to statements in depth=1, * ie, ?s1 ?p2 ?s2 and ?s2 ?p xml:id * Because of the complexity, depth should be <=2 or you should use * a custom query. * * FIXME: The logical thing here would be to chain up. * given a cursor in a table:cell, the Rdf for the containing * text:p and text:meta elements should be returned too. * * Note that the returned model is owned by the caller, you must delete it. */ QSharedPointer findStatements(const QString &xmlid, int depth = 1); QSharedPointer findStatements(KoTextEditor *handler, int depth = 1); /** * Add all the Rdf that is associated with the given xml:id */ void addStatements(QSharedPointer model, const QString &xmlid); /** * Find an inline Rdf object from the xml:id which * it has in the content.xml file */ KoTextInlineRdf* findInlineRdfByID(const QString &xmlid) const; /** * Obtain a list of semantic objects of the given class, if any, for the Rdf * in the default model() or the one you optionally pass in. */ QList< hKoRdfBasicSemanticItem > semanticItems(const QString &className, QSharedPointer< Soprano::Model > m = QSharedPointer(0)); /** * Create a SemanticItem subclass using its name from * classNames(). Useful for menus and other places that want to * allow the user to create new SemanticItem Objects. */ hKoRdfBasicSemanticItem createSemanticItem(const QString &semanticClass, QObject *parent = 0) const; /** * This is used for triples that do not specify their xhtml:about * ie, the subject URI. */ QString rdfInternalMetadataWithoutSubjectURI() const; /** * Soprano::Node that can be used as the model context for * statements which should be stored in the manifest.rdf file. */ Soprano::Node manifestRdfNode() const; /** * Soprano::Node that can be used as the model context for * statements which were stored in the context.xml file. */ Soprano::Node inlineRdfContext() const; /** * If model contains ?s ?p ?o * look for and add * ?s2 ?p2 ?s */ void expandStatementsReferencingSubject(QSharedPointer model) const; /** * If model contains ?s ?p ?o * look for and add * ?o ?p2 ?o2 */ void expandStatementsSubjectPointsTo(QSharedPointer model) const; /** * Add n ?p ?o from m_model to model */ void expandStatementsSubjectPointsTo(QSharedPointer model, const Soprano::Node &n) const; /** * Rdf allows for linked lists to be serialized as a graph. This method will * ensure that all data from m_model for any lists that are started in 'model' * is copied into 'model'. * * Lists have the format * prefix rdf: * ?id rdf:first ?value * ?id rdf:rest ?next1 * ?next1 rdf:first ?value2 * ?next1 rdf:rest ?nextN * ?nextN rdf:first ?valueN * ?nextN rdf:rest rdf:nil */ void expandStatementsToIncludeRdfLists(QSharedPointer model) const; /** * If model contains ?s ?p ?o * look for and add * ?s ?p3 ?o3 */ void expandStatementsToIncludeOtherPredicates(QSharedPointer model) const; /** * One round of all expandStatements methods */ void expandStatements(QSharedPointer model) const; /** * FIXME? What does this do? */ QAction * createInsertSemanticObjectReferenceAction(KoCanvasBase *host); /** * FIXME? What does this do? */ QList createInsertSemanticObjectNewActions(KoCanvasBase *host); /** * Collect together the semantic item, stylehseet, xmlid of the * site to apply it at and the extent in the document (start,end) * of the semantic item. Used when applying stylesheets in bulk so * that all the sites can be collected and the QMap map * will sort them in the order of start to end document position. * * @see insertReflow() * @see applyReflow() */ struct reflowItem { hKoRdfSemanticItem m_si; hKoSemanticStylesheet m_ss; QString m_xmlid; QPair m_extent; reflowItem(hKoRdfSemanticItem si, const QString &xmlid, hKoSemanticStylesheet ss, const QPair &extent); }; /** * Because applying a stylesheet to a semantic item could change * the length of the text showing the item in the document, it is * best to apply these stylesheets to semitems starting from the * end of the document. This is because any change in the length * of a semitem has no effect on all the other semitems that are * before it in the document. After we have applied all the * changes, the kwdoc will update the positions of all the * kotextmeta etc objects and they will once again be correct. * Doing things explicitly backwards is a huge efficiency gain * because no layout is needed on the document during our updates * because each update does not invalidate the positions of any * objects before the update in the document text. * * Call insertReflow() for all the items you want to apply a * stylesheet on and then applyReflow() with the built up * collection 'col' argument to will actually apply the * stylesheets starting from the semitem lowest in the document * and working backwards. * * @see applyReflow() */ void insertReflow(QMap &col, hKoRdfSemanticItem obj, hKoSemanticStylesheet ss); void insertReflow(QMap &col, hKoRdfSemanticItem obj, const QString &sheetType, const QString &stylesheetName); void insertReflow(QMap &col, hKoRdfSemanticItem obj); /** * @short Apply the stylesheets built up with insertReflow(). * * @see insertReflow() */ void applyReflow(const QMap &col); //FIXME: this method also seems to be STATIC and why it has such second default param?? /** * For debugging, output the model and a header string for identification */ void dumpModel(const QString &msg, QSharedPointer m = QSharedPointer(0)) const; Q_SIGNALS: /** * Emitted when a new semanticItem is created so that dockers can * update themselves accordingly. It is expected that when * semanticObjectViewSiteUpdated is emitted the view will take care * of reflowing the semantic item using it's stylesheet. */ void semanticObjectAdded(hKoRdfBasicSemanticItem item) const; void semanticObjectUpdated(hKoRdfBasicSemanticItem item) const; void semanticObjectViewSiteUpdated(hKoRdfBasicSemanticItem item, const QString &xmlid) const; public: void emitSemanticObjectAdded(hKoRdfBasicSemanticItem item) const; void emitSemanticObjectUpdated(hKoRdfBasicSemanticItem item); void emitSemanticObjectViewSiteUpdated(hKoRdfBasicSemanticItem item, const QString &xmlid); void emitSemanticObjectAddedConst(hKoRdfBasicSemanticItem const item) const; /** * You should use the KoRdfSemanticItem::userStylesheets() method instead of this one. * This is mainly an internal method to allow user stylesheets to be managed per document. */ QList userStyleSheetList(const QString& className) const; void setUserStyleSheetList(const QString& className,const QList& l); private: /** * @see expandStatementsToIncludeRdfLists() */ void expandStatementsToIncludeRdfListsRecurse(QSharedPointer model, QList &addList, const Soprano::Node &n) const; /** * Soprano can give undesirable behaviour when loading two files * into the same model. When parsing the second Rdf file, the sane * genid1 numbers can be reused, leading to semantic errors on * bnodes. This method updates all the bnodes in 'm' to be new * ones created using m_model->createBlankNode(). bnode identity * is preserved for the model m. ie. genid2 and another genid2 in * m will be replaced with the same m_model->createBlankNode() * value. After calling this method, you can add all the * statements to 'm' and be assured that no bnodes in 'm' are * going to accidentially be the same as a bnode in m_model. */ void freshenBNodes(QSharedPointer m); /** * Used by loadOasis() to load Rdf from a particular external * Rdf/XML file. */ bool loadRdf(KoStore *store, const Soprano::Parser *parser, const QString &fileName); /** * Used by saveOasis() to save Rdf to a the Rdf file nominated * with context. Note that this method can not be used to save to * content.xml, those Rdf statements must be saved as the * content.xml file is generated. */ bool saveRdf(KoStore *store, KoXmlWriter *manifestWriter, const Soprano::Node &context) const; /** * idrefList queries soprano after loading and creates a list of all rdfid's that * where found in the manifest.rdf document. This list is used to make sure we do not * create more inline rdf objects than necessary * @return a list of xml-id's */ QStringList idrefList() const; private: /** * Test whether a model is present that supports: * - context / graphs * - querying on graphs * - storage in memory. */ bool backendIsSane(); /// reimplemented virtual bool completeLoading(KoStore *store); /// reimplemented virtual bool completeSaving(KoStore *store, KoXmlWriter *manifestWriter, KoShapeSavingContext *context); KoDocumentRdfPrivate * const d; }; #endif diff --git a/libs/widgets/KoDialog.h b/libs/widgets/KoDialog.h index da36eed9be0..379eb7c3f2a 100644 --- a/libs/widgets/KoDialog.h +++ b/libs/widgets/KoDialog.h @@ -1,835 +1,836 @@ /* This file is part of the KDE Libraries * Copyright (C) 1998 Thomas Tanghus (tanghus@earthling.net) * Additions 1999-2000 by Espen Sand (espen@kde.org) * and Holger Freyther * 2005-2009 Olivier Goffart * 2006 Tobias Koenig * * 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 KODIALOG_H #define KODIALOG_H class QPushButton; class QMenu; class KoDialogPrivate; #include #include #include #include /** * @short A dialog base class with standard buttons and predefined layouts. * * Provides basic functionality needed by nearly all dialogs. * * It offers the standard action buttons you'd expect to find in a * dialog as well as the capability to define at most three configurable * buttons. You can define a main widget that contains your specific * dialog layout * * The class takes care of the geometry management. You only need to define * a minimum size for the widget you want to use as the main widget. * * By default, the dialog is non-modal. * * Standard buttons (action buttons):\n * * You select which buttons should be displayed, but you do not choose the * order in which they are displayed. This ensures a standard interface in * KDE. The button order can be changed, but this ability is only available * for a central KDE control tool. The following buttons are available: * OK, Cancel/Close, Apply/Try, Default, Help and three user definable * buttons: User1, User2 and User3. You must specify the text of the UserN * buttons. Each button emit a signal, so you can choose to connect that signal. * * The default action of the Help button will open the help system if you have * provided a path to the help text. * The default action of Ok and Cancel will run QDialog::accept() and QDialog::reject(), * which you can override by reimplementing slotButtonClicked(). The default * action of the Close button will close the dialog. * * Note that the KoDialog will animate a button press * when the user presses Escape. The button that is enabled is either Cancel, * Close or the button that is defined by setEscapeButton(). * Your custom dialog code should reimplement the keyPressEvent and * animate the cancel button so that the dialog behaves like regular * dialogs. * * Layout:\n * * The dialog consists of a help area on top (becomes visible if you define * a help path and use enableLinkedHelp()), the main area which is * the built-in dialog face or your own widget in the middle and by default * a button box at the bottom. The button box can also be placed at the * right edge (to the right of the main widget). Use * setButtonsOrientation() to control this behavior. A separator * can be placed above the button box (or to the left when the button box * is at the right edge). * * Standard compliance:\n * * The marginHint() and spacingHint() sizes shall be used * whenever you lay out the interior of a dialog. One special note. If * you make your own action buttons (OK, Cancel etc), the space * between the buttons shall be spacingHint(), whereas the space * above, below, to the right and to the left shall be marginHint(). * If you add a separator line above the buttons, there shall be a * marginHint() between the buttons and the separator and a * marginHint() above the separator as well. * * Example:\n * * \code * KoDialog *dialog = new KoDialog( this ); * dialog->setCaption( "My title" ); * dialog->setButtons( KoDialog::Ok | KoDialog::Cancel | KoDialog::Apply ); * * FooWidget *widget = new FooWidget( dialog ); * dialog->setMainWidget( widget ); * connect( dialog, SIGNAL(applyClicked()), widget, SLOT(save()) ); * connect( dialog, SIGNAL(okClicked()), widget, SLOT(save()) ); * connect( widget, SIGNAL(changed(bool)), dialog, SLOT(enableButtonApply(bool)) ); * * dialog->enableButtonApply( false ); * dialog->show(); * \endcode * * \image html kdialog.png "KDE Dialog example" * * This class can be used in many ways. Note that most KDE ui widgets * and many of KDE core applications use the KoDialog so for more * inspiration you should study the code for these. * * * @see KPageDialog * @author Thomas Tanghus * @author Espen Sand * @author Mirko Boehm * @author Olivier Goffart * @author Tobias Koenig */ class KOWIDGETS_EXPORT KoDialog : public QDialog //krazy:exclude=qclasses { Q_OBJECT Q_ENUMS(ButtonCode) Q_DECLARE_PRIVATE(KoDialog) public: enum ButtonCode { None = 0x00000000, Help = 0x00000001, ///< Show Help button. (this button will run the help set with setHelp) Default = 0x00000002, ///< Show Default button. Ok = 0x00000004, ///< Show Ok button. (this button accept()s the dialog; result set to QDialog::Accepted) Apply = 0x00000008, ///< Show Apply button. Try = 0x00000010, ///< Show Try button. Cancel = 0x00000020, ///< Show Cancel-button. (this button reject()s the dialog; result set to QDialog::Rejected) Close = 0x00000040, ///< Show Close-button. (this button closes the dialog) No = 0x00000080, ///< Show No button. (this button closes the dialog and sets the result to KoDialog::No) Yes = 0x00000100, ///< Show Yes button. (this button closes the dialog and sets the result to KoDialog::Yes) Reset = 0x00000200, ///< Show Reset button Details = 0x00000400, ///< Show Details button. (this button will show the detail widget set with setDetailsWidget) User1 = 0x00001000, ///< Show User defined button 1. User2 = 0x00002000, ///< Show User defined button 2. User3 = 0x00004000, ///< Show User defined button 3. NoDefault = 0x00008000 ///< Used when specifying a default button; indicates that no button should be marked by default. }; // TODO KDE5: remove NoDefault and use the value None instead Q_DECLARE_FLAGS(ButtonCodes, ButtonCode) enum ButtonPopupMode { InstantPopup = 0, DelayedPopup = 1 }; Q_DECLARE_FLAGS(ButtonPopupModes, ButtonPopupMode) public: /** * Creates a dialog. * * @param parent The parent of the dialog. * @param flags The widget flags passed to the QDialog constructor */ explicit KoDialog(QWidget *parent = 0, Qt::WindowFlags flags = 0); /** * Destroys the dialog. */ ~KoDialog(); /** * Creates (or recreates) the button box and all the buttons in it. * * Note that some combinations are not possible. That means, you can't * have the following pairs of buttons in a dialog: * - Default and Details * - Cancel and Close * - Ok and Try * * This will reset all default KGuiItem of all button. * * @param buttonMask Specifies what buttons will be made. * * @deprecated Since 5.0 use QDialogButtonBox */ void setButtons(ButtonCodes buttonMask); /** * Sets the orientation of the button box. * * It can be @p Vertical or @p Horizontal. If @p Horizontal * (default), the button box is positioned at the bottom of the * dialog. If @p Vertical it will be placed at the right edge of the * dialog. * * @param orientation The button box orientation. */ void setButtonsOrientation(Qt::Orientation orientation); /** * Sets the button that will be activated when the Escape key * is pressed. * * By default, the Escape key is mapped to either the Cancel or the Close button * if one of these buttons are defined. The user expects that Escape will * cancel an operation so use this function with caution. * * @param id The button code. */ void setEscapeButton(ButtonCode id); /** * Sets the button that will be activated when the Enter key * is pressed. * * By default, this is the Ok button if it is present * * @param id The button code. */ void setDefaultButton(ButtonCode id); /** * Returns the button code of the default button, * or NoDefault if there is no default button. */ ButtonCode defaultButton() const; /** * Hide or display the a separator line drawn between the action * buttons an the main widget. */ void showButtonSeparator(bool state); /** * Hide or display a general action button. * * Only buttons that have * been created in the constructor can be displayed. This method will * not create a new button. * * @param id Button identifier. * @param state true display the button(s). */ void showButton(ButtonCode id, bool state); /** * Sets the text of any button. * * @param id The button identifier. * @param text Button text. */ void setButtonText(ButtonCode id, const QString &text); /** * Returns the text of any button. */ QString buttonText(ButtonCode id) const; /** * Sets the icon of any button. * * @param id The button identifier. * @param icon Button icon. */ void setButtonIcon(ButtonCode id, const QIcon &icon); /** * Returns the icon of any button. */ QIcon buttonIcon(ButtonCode id) const; /** * Sets the tooltip text of any button. * * @param id The button identifier. * @param text Button text. */ void setButtonToolTip(ButtonCode id, const QString &text); /** * Returns the tooltip of any button. */ QString buttonToolTip(ButtonCode id) const; /** * Sets the "What's this?" text of any button. * * @param id The button identifier. * @param text Button text. */ void setButtonWhatsThis(ButtonCode id, const QString &text); /** * Returns the "What's this?" text of any button. */ QString buttonWhatsThis(ButtonCode id) const; /** * Sets the KGuiItem directly for the button instead of using 3 methods to * set the text, tooltip and whatsthis strings. This also allows to set an * icon for the button which is otherwise not possible for the extra * buttons beside Ok, Cancel and Apply. * * @param id The button identifier. * @param item The KGuiItem for the button. */ void setButtonGuiItem(ButtonCode id, const KGuiItem &item); /** * Sets the focus to the button of the passed @p id. */ void setButtonFocus(ButtonCode id); /** * Convenience method. Sets the initial dialog size. * * This method should only be called right before show() or exec(). * The initial size will be ignored if smaller than * the dialog's minimum size. * * @param size Startup size. */ void setInitialSize(const QSize &size); /** * Convenience method. Add a size to the default minimum size of a * dialog. * * This method should only be called right before show() or exec(). * * @param size Size added to minimum size. */ void incrementInitialSize(const QSize &size); /** * Returns the help link text. * * If no text has been defined, * "Get help..." (internationalized) is returned. * * @return The help link text. * * @see enableLinkedHelp() * @see setHelpLinkText() * @see setHelp() */ QString helpLinkText() const; /** * Returns whether any button is enabled. */ bool isButtonEnabled(ButtonCode id) const; /** * Returns the button that corresponds to the @p id. * * Normally you should not use this function. * @em Never delete the object returned by this function. * See also enableButton(), showButton(), setButtonGuiItem(). * * @param id Identifier of the button. * @return The button or 0 if the button does not exist. */ QPushButton *button(ButtonCode id) const; /** * Returns the number of pixels that should be used between a * dialog edge and the outermost widget(s) according to the KDE standard. * * @deprecated Use the style's pixelMetric() function to query individual margins. * Different platforms may use different values for the four margins. */ static int marginHint(); /** * Returns the number of pixels that should be used between * widgets inside a dialog according to the KDE standard. * * @deprecated Use the style's layoutSpacing() function to query individual spacings. * Different platforms may use different values depending on widget types and pairs. */ static int spacingHint(); /** * Returns the number of pixels that should be used to visually * separate groups of related options in a dialog according to * the KDE standard. * @since 4.2 */ static int groupSpacingHint(); /** - * @enum StandardCaptionFlag + * @enum CaptionFlag * Used to specify how to construct a window caption * - * @var AppName Indicates that the method shall include + * @var NoCaptionFlags Indicates that the method has no caption flags. + * @var AppNameCaption Indicates that the method shall include * the application name when making the caption string. - * @var Modified Causes a 'modified' sign will be included in the + * @var ModifiedCaption Causes a 'modified' sign will be included in the * returned string. This is useful when indicating that a file is * modified, i.e., it contains data that has not been saved. - * @var HIGCompliant The base minimum flags required to align a + * @var HIGCompliantCaption The base minimum flags required to align a * caption with the KDE Human Interface Guidelines */ enum CaptionFlag { NoCaptionFlags = 0, AppNameCaption = 1, ModifiedCaption = 2, HIGCompliantCaption = AppNameCaption }; Q_DECLARE_FLAGS(CaptionFlags, CaptionFlag) /** * Builds a caption that contains the application name along with the * userCaption using a standard layout. * * To make a compliant caption for your window, simply do: * @p setWindowTitle(KoDialog::makeStandardCaption(yourCaption)); * * To ensure that the caption is appropriate to the desktop in which the * application is running, pass in a pointer to the window the caption will * be applied to. * * If using a KoDialog or KMainWindow subclass, call setCaption instead and * an appropriate standard caption will be created for you * * @param userCaption The caption string you want to display in the * window caption area. Do not include the application name! * @param window a pointer to the window this application will apply to * @param flags * @return the created caption */ static QString makeStandardCaption(const QString &userCaption, QWidget *window = 0, CaptionFlags flags = HIGCompliantCaption); /** * Resize every layout manager used in @p widget and its nested children. * * @param widget The widget used. * @param margin The new layout margin. * @param spacing The new layout spacing. * * @deprecated Use QLayout functions where necessary. Setting margin and spacing * values recursively for all children prevents QLayout from creating platform native * layouts. */ static void resizeLayout(QWidget *widget, int margin, int spacing); /** * Resize every layout associated with @p lay and its children. * * @param lay layout to be resized * @param margin The new layout margin * @param spacing The new layout spacing * * @deprecated Use QLayout functions where necessary. Setting margin and spacing * values recursively for all children prevents QLayout from creating platform native * layouts. */ static void resizeLayout(QLayout *lay, int margin, int spacing); /** * Centers @p widget on the desktop, taking multi-head setups into * account. If @p screen is -1, @p widget will be centered on its * current screen (if it was shown already) or on the primary screen. * If @p screen is -3, @p widget will be centered on the screen that * currently contains the mouse pointer. * @p screen will be ignored if a merged display (like Xinerama) is not * in use, or merged display placement is not enabled in kdeglobals. */ static void centerOnScreen(QWidget *widget, int screen = -1); /** * Places @p widget so that it doesn't cover a certain @p area of the screen. * This is typically used by the "find dialog" so that the match it finds can * be read. * For @p screen, see centerOnScreen * @return true on success (widget doesn't cover area anymore, or never did), * false on failure (not enough space found) */ static bool avoidArea(QWidget *widget, const QRect &area, int screen = -1); /** * Sets the main widget of the dialog. */ void setMainWidget(QWidget *widget); /** * @return The current main widget. Will create a QWidget as the mainWidget * if none was set before. This way you can write * \code * ui.setupUi(mainWidget()); * \endcode * when using designer. */ QWidget *mainWidget(); /** * Reimplemented from QDialog. */ QSize sizeHint() const Q_DECL_OVERRIDE; /** * Reimplemented from QDialog. */ QSize minimumSizeHint() const Q_DECL_OVERRIDE; /** * Returns the status of the Details button. */ bool isDetailsWidgetVisible() const; public Q_SLOTS: /** * Make a KDE compliant caption. * * @param caption Your caption. Do @p not include the application name * in this string. It will be added automatically according to the KDE * standard. * * @deprecated Since 5.0 use QWidget::setWindowTitle */ virtual void setCaption(const QString &caption); /** * Makes a KDE compliant caption. * * @param caption Your caption. @em Do @em not include the application name * in this string. It will be added automatically according to the KDE * standard. * @param modified Specify whether the document is modified. This displays * an additional sign in the title bar, usually "**". * * @deprecated Since 5.0 use QWidget::setWindowTitle and QWidget::setWindowModified. */ virtual void setCaption(const QString &caption, bool modified); /** * Make a plain caption without any modifications. * * @param caption Your caption. This is the string that will be * displayed in the window title. */ virtual void setPlainCaption(const QString &caption); /** * Enable or disable (gray out) a general action button. * * @param id Button identifier. * @param state @p true enables the button(s). */ void enableButton(ButtonCode id, bool state); /** * Enable or disable (gray out) the OK button. * * @param state @p true enables the button. */ void enableButtonOk(bool state); /** * Enable or disable (gray out) the Apply button. * * @param state true enables the button. */ void enableButtonApply(bool state); /** * Enable or disable (gray out) the Cancel button. * * @param state true enables the button. */ void enableButtonCancel(bool state); /** * Display or hide the help link area on the top of the dialog. * * @param state @p true will display the area. * * @see helpLinkText() * @see setHelpLinkText() * @see setHelp() */ void enableLinkedHelp(bool state); /** * Sets the text that is shown as the linked text. * * If text is empty, * the text "Get help..." (internationalized) is used instead. * * @param text The link text. * * @see helpLinkText() * @see enableLinkedHelp() * @see setHelp() */ void setHelpLinkText(const QString &text); /** * Sets the help path and topic. * * @param anchor Defined anchor in your docbook sources * @param appname Defines the appname the help belongs to * If empty it's the current one * * @note The help button works differently for the class * KCMultiDialog, so it does not make sense to call this * function for Dialogs of that type. See * KCMultiDialog::slotHelp() for more information. */ void setHelp(const QString &anchor, const QString &appname = QString()); /** * Sets the status of the Details button. */ void setDetailsWidgetVisible(bool visible); /** * Sets the widget that gets shown when "Details" is enabled. * * The dialog takes over ownership of the widget. * Any previously set widget gets deleted. */ void setDetailsWidget(QWidget *detailsWidget); /** * Destruct the dialog delayed. * * You can call this function from slots like closeClicked() and hidden(). * You should not use the dialog any more after calling this function. * @deprecated use hide()+deleteLater() */ void delayedDestruct(); Q_SIGNALS: /** * Emitted when the margin size and/or spacing size * have changed. * * Use marginHint() and spacingHint() in your slot * to get the new values. * * @deprecated This signal is not emitted. Listen to QEvent::StyleChange events instead. */ void layoutHintChanged(); /** * The Help button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void helpClicked(); /** * The Default button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void defaultClicked(); /** * The Reset button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void resetClicked(); /** * The User3 button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void user3Clicked(); /** * The User2 button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void user2Clicked(); /** * The User1 button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void user1Clicked(); /** * The Apply button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void applyClicked(); /** * The Try button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void tryClicked(); /** * The OK button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void okClicked(); /** * The Yes button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void yesClicked(); /** * The No button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void noClicked(); /** * The Cancel button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void cancelClicked(); /** * The Close button was pressed. This signal is only emitted if * slotButtonClicked() is not replaced */ void closeClicked(); /** * A button has been pressed. This signal is only emitted if * slotButtonClicked() is not replaced * @param button is the code of the pressed button. */ void buttonClicked(KoDialog::ButtonCode button); /** * The dialog is about to be hidden. * * A dialog is hidden after a user clicks a button that ends * the dialog or when the user switches to another desktop or * minimizes the dialog. */ void hidden(); /** * The dialog has finished. * * A dialog emits finished after a user clicks a button that ends * the dialog. * * This signal is also emitted when you call hide() * * If you have stored a pointer to the * dialog do @em not try to delete the pointer in the slot that is * connected to this signal. * * You should use deleteLater() instead. */ void finished(); /** * The detailsWidget is about to get shown. This is your last chance * to call setDetailsWidget if you haven't done so yet. */ void aboutToShowDetails(); protected: /** * Emits the #hidden signal. You can connect to that signal to * detect when a dialog has been closed. */ void hideEvent(QHideEvent *) Q_DECL_OVERRIDE; /** * Detects when a dialog is being closed from the window manager * controls. If the Cancel or Close button is present then the button * is activated. Otherwise standard QDialog behavior * will take place. */ void closeEvent(QCloseEvent *e) Q_DECL_OVERRIDE; /** * @internal */ void keyPressEvent(QKeyEvent *) Q_DECL_OVERRIDE; protected Q_SLOTS: /** * Activated when the button @p button is clicked * * Sample that shows how to catch and handle button clicks within * an own dialog; * @code * class MyDialog : public KoDialog { * protected Q_SLOTS: * virtual void slotButtonClicked(int button) { * if (button == KoDialog::Ok) * accept(); * else * KoDialog::slotButtonClicked(button); * } * } * @endcode * * @param button is the type @a KoDialog::ButtonCode * * @deprecated since 5.0 use QDialogButtonBox and connect to the clicked signal */ virtual void slotButtonClicked(int button); /** * Updates the margins and spacings. * * @deprecated KoDialog respects the style's margins and spacings automatically. Calling * this function has no effect. */ void updateGeometry(); private: KoDialog(KoDialogPrivate &dd, QWidget *parent, Qt::WindowFlags flags = 0); KoDialogPrivate *const d_ptr; private: Q_DISABLE_COPY(KoDialog) Q_PRIVATE_SLOT(d_ptr, void queuedLayoutUpdate()) Q_PRIVATE_SLOT(d_ptr, void helpLinkClicked()) }; Q_DECLARE_OPERATORS_FOR_FLAGS(KoDialog::ButtonCodes) Q_DECLARE_OPERATORS_FOR_FLAGS(KoDialog::CaptionFlags) #endif // KODIALOG_H diff --git a/sheets/ValueFormatter.h b/sheets/ValueFormatter.h index 653c518ceb3..444901c4690 100644 --- a/sheets/ValueFormatter.h +++ b/sheets/ValueFormatter.h @@ -1,162 +1,164 @@ /* This file is part of the KDE project Copyright 2007 Stefan Nikolaus Copyright 2004 Tomas Mecir 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 CALLIGRA_SHEETS_VALUE_FORMATTER #define CALLIGRA_SHEETS_VALUE_FORMATTER #include #include "Global.h" #include "Number.h" #include "Style.h" namespace Calligra { namespace Sheets { class CalculationSettings; class Value; class ValueConverter; /** * \ingroup Value * Generates a textual representation of a Value with a given formatting. */ class CALLIGRA_SHEETS_ODF_EXPORT ValueFormatter { public: /** * Constructor. */ explicit ValueFormatter(const ValueConverter* converter); /** * Returns the calculation settings this ValueFormatter uses. */ const CalculationSettings* settings() const; /** * Creates a textual representation of \p value with the explicit given * formattings. * \param value the value * \param formatType the value format, e.g. number, date * \param precision the number of decimals * \param floatFormat the number format, i.e. signed/unsigned information * \param prefix the preceding text * \param postfix the subsequent text * \param currencySymbol the currency symbol * \param formatString the Qt format string * \param thousandsSep whether to use thousands separator */ Value formatText(const Value& value, Format::Type formatType, int precision = -1, Style::FloatFormat floatFormat = Style::OnlyNegSigned, const QString& prefix = QString(), const QString& postfix = QString(), const QString& currencySymbol = QString(), const QString& formatString = QString(), bool thousandsSep = true); /** * Creates a date format. * \param date the date * \param formatType the value format, e.g. number, date * \param formatString the Qt format string */ QString dateFormat(const QDate& date, Format::Type formatType, const QString& formatString = QString() ); /** * Creates a time format. * \param time the time * \param formatType the value format, e.g. number, date * \param formatString the Qt format string */ QString timeFormat(const QDateTime& time, Format::Type formatType, const QString& formatString = QString() ); /** * Creates a date and time format. * \param time the time * \param formatType the value format, e.g. number, date * \param formatString the Qt format string */ QString dateTimeFormat(const QDateTime& time, Format::Type formatType, const QString& formatString = QString() ); /** * Determines the formatting type that should be used to format this value * in a cell with a given format type * \param value the value * \param formatType the value format, e.g. number, date */ Format::Type determineFormatting(const Value& value, Format::Type formatType); protected: /** * Creates a number format. * \param value the value * \param precision the number of decimals * \param formatType the value format, e.g. number, date * \param floatFormat the number format, i.e. signed/unsigned information * \param currencySymbol the currency symbol * \param formatString the Qt format string * \param thousandsSep whether to use thousands separator */ QString createNumberFormat(Number value, int precision, Format::Type formatType, Style::FloatFormat floatFormat, const QString& currencySymbol, const QString& formatString, bool thousandsSep); /** * Creates a fraction format. * \param value the value * \param formatType the value format, e.g. number, date */ QString fractionFormat(Number value, Format::Type formatType); /** * Creates a complex number format. + * \param value the initial value * \param precision the number of decimals * \param formatType the value format, e.g. number, date * \param floatFormat the number format, i.e. signed/unsigned information * \param currencySymbol the currency symbol + * \param thousandsSep whether to use thousands separator */ QString complexFormat(const Value& value, int precision, Format::Type formatType, Style::FloatFormat floatFormat, const QString& currencySymbol, bool thousandsSep); /** * Removes the trailing zeros and the decimal symbol \p decimalSymbol in * \p string , if necessary. * \return the truncated string */ QString removeTrailingZeros(const QString& string, const QString& decimalSymbol); private: const ValueConverter* m_converter; }; } // namespace Sheets } // namespace Calligra #endif //CALLIGRA_SHEETS_VALUE_FORMATTER