Development/Tutorials/Write a Flake Plugin - Revision history

Neverendingo: Text replace - "" to ""

2011-06-29T20:56:32Z

Text replace - "</code>" to "</syntaxhighlight>"

Neverendingo: Text replace - "`" to ""`


2011-06-29T20:37:44Z
Text replace - "<code ini>" to "<syntaxhighlight lang="ini">"

				
				
				
				
			
			← Older revision
			Revision as of 20:37, 29 June 2011
			
Line 123:
Line 123:
    
  Example {{path|fooshape.desktop}} file:   Example {{path|fooshape.desktop}} file:
− <code ini> + <syntaxhighlight lang="ini">
  [Desktop Entry]   [Desktop Entry]
  Encoding=UTF-8   Encoding=UTF-8



Neverendingo: Text replace - "" to ""

2011-06-29T20:31:25Z
Text replace - "<code cppqt>" to "<syntaxhighlight lang="cpp-qt">"

				
				
				
				
			
			← Older revision
			Revision as of 20:31, 29 June 2011
			
Line 16:
Line 16:
    
  So here is an example how your code might look like:   So here is an example how your code might look like:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  #include <KoShape.h>   #include <KoShape.h>
    
Line 45:
Line 45:
    
  An example factory class definition:   An example factory class definition:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  class FooShapeFactory : public KoShapeFactory {   class FooShapeFactory : public KoShapeFactory {
  public:   public:
Line 55:
Line 55:
  </code>   </code>
  The according implementation:   The according implementation:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  FooShapeFactory::FooShapeFactory(QObject* parent)     FooShapeFactory::FooShapeFactory(QObject* parent)  
      : KoShapeFactory( parent, "FooShape",       : KoShapeFactory( parent, "FooShape",
Line 82:
Line 82:
    
  To register we would have to make a call like this:   To register we would have to make a call like this:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  KoShapeRegistry::instance()->add( new FooShapeFactory( parent ) );   KoShapeRegistry::instance()->add( new FooShapeFactory( parent ) );
  </code>   </code>
Line 90:
Line 90:
    
  Example plugin class definition:   Example plugin class definition:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  #include <QObject>   #include <QObject>
    
Line 101:
Line 101:
    
  Example plugin class implementation:   Example plugin class implementation:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  #include "FooShapePlugin.h"   #include "FooShapePlugin.h"
  #include <kgenericfactory.h>   #include <kgenericfactory.h>



Cyrille at 13:14, 20 May 2009
2009-05-20T13:14:42Z


				
				
				
				
			
			← Older revision
			Revision as of 13:14, 20 May 2009
			
Line 27:
Line 27:
       void paint( QPainter &painter,        void paint( QPainter &painter,
                   const KoViewConverter &converter );                    const KoViewConverter &converter );
  +     virtual bool loadOdf(const KoXmlElement & element, KoShapeLoadingContext &context);
  +     virtual void saveOdf(KoShapeSavingContext & context) const;
    
  private:   private:





Zander: Remove question; answer is that it hasn't changed.
2008-12-15T10:35:55Z
Remove question; answer is that it hasn't changed.

				
				
				
				
			
			← Older revision
			Revision as of 10:35, 15 December 2008
			
Line 34:
Line 34:
    
  =Make your shape loadable - create a factory and a plugin=   =Make your shape loadable - create a factory and a plugin=
−  
− XXX: Hasn't this changed? Look at the video or picture shape -- I think we do without all of this nowadays. (Boudewijn)  
    
  Now when you have created your shape class and implemented all the necessary things to make it at least compile you can think about the loading of your shape.   Now when you have created your shape class and implemented all the necessary things to make it at least compile you can think about the loading of your shape.



Pino: {{file}} -> {{path}}
2007-05-29T00:02:05Z
{{file}} -> {{path}}

				
				
				
				
			
			← Older revision
			Revision as of 00:02, 29 May 2007
			
Line 118:
Line 118:
  #include "FooShapePlugin.moc"   #include "FooShapePlugin.moc"
  </code>   </code>
− This demonstrates how for the plugin related tasks KDE provides services which are dynamic loaded libraries. The secret ingredient that makes this class the plugin of that library is the call to the K_EXPORT_COMPONENT_FACTORY macro defined in {{file|kgenericfactory.h}} + This demonstrates how for the plugin related tasks KDE provides services which are dynamic loaded libraries. The secret ingredient that makes this class the plugin of that library is the call to the K_EXPORT_COMPONENT_FACTORY macro defined in {{path|kgenericfactory.h}}
    
− We now have a way to create instances of your shape (FooShapeFactory), a way to register them for the apps (KoShapeRegistry) and a plugin that can dynamically be loaded (FooShapePlugin). The last step is to create a {{file|.desktop}} file that describes your plugin and makes it findable by KOffice. For "X-KDE-Library" you have to set the library name you have already specified within K_EXPORT_COMPONENT_FACTORY(). + We now have a way to create instances of your shape (FooShapeFactory), a way to register them for the apps (KoShapeRegistry) and a plugin that can dynamically be loaded (FooShapePlugin). The last step is to create a {{path|.desktop}} file that describes your plugin and makes it findable by KOffice. For "X-KDE-Library" you have to set the library name you have already specified within K_EXPORT_COMPONENT_FACTORY().
    
− Example {{file|fooshape.desktop}} file: + Example {{path|fooshape.desktop}} file:
  <code ini>   <code ini>
  [Desktop Entry]   [Desktop Entry]





Pino: use {{file}} for filenames
2007-05-28T10:18:14Z
use {{file}} for filenames

				
				
				
				
			
			← Older revision
			Revision as of 10:18, 28 May 2007
			
Line 118:
Line 118:
  #include "FooShapePlugin.moc"   #include "FooShapePlugin.moc"
  </code>   </code>
− This demonstrates how for the plugin related tasks KDE provides services which are dynamic loaded libraries. The secret ingredient that makes this class the plugin of that library is the call to the K_EXPORT_COMPONENT_FACTORY macro defined in kgenericfactory.h + This demonstrates how for the plugin related tasks KDE provides services which are dynamic loaded libraries. The secret ingredient that makes this class the plugin of that library is the call to the K_EXPORT_COMPONENT_FACTORY macro defined in {{file|kgenericfactory.h}}
    
− We now have a way to create instances of your shape (FooShapeFactory), a way to register them for the apps (KoShapeRegistry) and a plugin that can dynamically be loaded (FooShapePlugin). The last step is to create a .desktop file that describes your plugin and makes it findable by KOffice. For "X-KDE-Library" you have to set the library name you have already specified within K_EXPORT_COMPONENT_FACTORY(). + We now have a way to create instances of your shape (FooShapeFactory), a way to register them for the apps (KoShapeRegistry) and a plugin that can dynamically be loaded (FooShapePlugin). The last step is to create a {{file|.desktop}} file that describes your plugin and makes it findable by KOffice. For "X-KDE-Library" you have to set the library name you have already specified within K_EXPORT_COMPONENT_FACTORY().
    
− Example fooshape.desktop file: + Example {{file|fooshape.desktop}} file:
  <code ini>   <code ini>
  [Desktop Entry]   [Desktop Entry]
Line 133:
Line 133:
  </code>   </code>
    
− After installing that file in the kde services directory and installing your plugin where the application can open it, your plugin is system wide known and can be loaded by KOffice. + After installing that file in the KDE services directory and installing your plugin where the application can open it, your plugin is system wide known and can be loaded by KOffice.
    
  TODO; add example CMake file.   TODO; add example CMake file.



Pino: highlight the cpp and ini code properly
2007-05-28T10:14:20Z
highlight the cpp and ini code properly

				
				
				
				
			
			← Older revision
			Revision as of 10:14, 28 May 2007
			
Line 16:
Line 16:
    
  So here is an example how your code might look like:   So here is an example how your code might look like:
− <pre> + <code cppqt>
  #include <KoShape.h>   #include <KoShape.h>
    
Line 31:
Line 31:
       SomeDataClass* m_dataClass;        SomeDataClass* m_dataClass;
  };   };
− </pre> + </code>
    
  =Make your shape loadable - create a factory and a plugin=   =Make your shape loadable - create a factory and a plugin=
Line 45:
Line 45:
    
  An example factory class definition:   An example factory class definition:
− <pre> + <code cppqt>
  class FooShapeFactory : public KoShapeFactory {   class FooShapeFactory : public KoShapeFactory {
  public:   public:
Line 53:
Line 53:
       KoShape* createShape(const KoProperties* params) const;        KoShape* createShape(const KoProperties* params) const;
  };   };
− </pre> + </code>
  The according implementation:   The according implementation:
− <pre> + <code cppqt>
  FooShapeFactory::FooShapeFactory(QObject* parent)     FooShapeFactory::FooShapeFactory(QObject* parent)  
      : KoShapeFactory( parent, "FooShape",       : KoShapeFactory( parent, "FooShape",
Line 77:
Line 77:
       return fooShape;        return fooShape;
  }   }
− </pre> + </code>
    
  With the factory there is now a generic way to obtain an instance of your shape. But somehow you have to publish your shape as a plugin to let the KOffice application know that there is a plugin to load. Therefore the flake library provides the [http://koffice.org/developer/apidocs/libs-flake/classKoShapeRegistry.html KoShapeRegistry] class. Each application has access to the registry and to let the application know about your shape you have to register it within the registry.   With the factory there is now a generic way to obtain an instance of your shape. But somehow you have to publish your shape as a plugin to let the KOffice application know that there is a plugin to load. Therefore the flake library provides the [http://koffice.org/developer/apidocs/libs-flake/classKoShapeRegistry.html KoShapeRegistry] class. Each application has access to the registry and to let the application know about your shape you have to register it within the registry.
    
  To register we would have to make a call like this:   To register we would have to make a call like this:
−  KoShapeRegistry::instance()->add( new FooShapeFactory( parent ) ); + <code cppqt>
  + KoShapeRegistry::instance()->add( new FooShapeFactory( parent ) );
  + </code>
  In order to make that call, we will create a plugin class which is special in that it will be automatically loaded and created by KOffice when an application starts.  This means that the constructor of our plugin class will be the perfect place to actually register our shape using the above line.   In order to make that call, we will create a plugin class which is special in that it will be automatically loaded and created by KOffice when an application starts.  This means that the constructor of our plugin class will be the perfect place to actually register our shape using the above line.
    
Line 88:
Line 90:
    
  Example plugin class definition:   Example plugin class definition:
− <pre> + <code cppqt>
  #include <QObject>   #include <QObject>
    
Line 96:
Line 98:
       FooShapePlugin(QObject *parent, const QStringList&);        FooShapePlugin(QObject *parent, const QStringList&);
  };   };
− </pre> + </code>
    
  Example plugin class implementation:   Example plugin class implementation:
− <pre> + <code cppqt>
  #include "FooShapePlugin.h"   #include "FooShapePlugin.h"
  #include <kgenericfactory.h>   #include <kgenericfactory.h>
Line 115:
Line 117:
  }   }
  #include "FooShapePlugin.moc"   #include "FooShapePlugin.moc"
− </pre> + </code>
  This demonstrates how for the plugin related tasks KDE provides services which are dynamic loaded libraries. The secret ingredient that makes this class the plugin of that library is the call to the K_EXPORT_COMPONENT_FACTORY macro defined in kgenericfactory.h   This demonstrates how for the plugin related tasks KDE provides services which are dynamic loaded libraries. The secret ingredient that makes this class the plugin of that library is the call to the K_EXPORT_COMPONENT_FACTORY macro defined in kgenericfactory.h
    
Line 121:
Line 123:
    
  Example fooshape.desktop file:   Example fooshape.desktop file:
− <pre> + <code ini>
  [Desktop Entry]   [Desktop Entry]
  Encoding=UTF-8   Encoding=UTF-8
Line 129:
Line 131:
  X-KDE-Library=fooshapelibrary   X-KDE-Library=fooshapelibrary
  X-Flake-Version=1   X-Flake-Version=1
− </pre> + </code>
    
  After installing that file in the kde services directory and installing your plugin where the application can open it, your plugin is system wide known and can be loaded by KOffice.   After installing that file in the kde services directory and installing your plugin where the application can open it, your plugin is system wide known and can be loaded by KOffice.





Zander: /* Make your shape editable - create a tool */
2007-05-02T15:05:17Z
‎Make your shape editable - create a tool

				
				
				
				
			
			← Older revision
			Revision as of 15:05, 2 May 2007
			
Line 138:
Line 138:
    
  To edit your shape in the GUI the user wants to select a tool and alter your shape. Therefore you have to provide a KoTool derived class. This class implements all edit actions that can be done on your shape but it is also possible to have more than one tool per shape.   To edit your shape in the GUI the user wants to select a tool and alter your shape. Therefore you have to provide a KoTool derived class. This class implements all edit actions that can be done on your shape but it is also possible to have more than one tool per shape.
−  
−  Note from TZ:  I suggest creating a koffice/shapes/example dir in svn  
−  which you can refer to from this tutorial.  



Zander at 15:04, 2 May 2007
2007-05-02T15:04:30Z


				
				
				
				
			
			← Older revision
			Revision as of 15:04, 2 May 2007
			
Line 1:
Line 1:
  This tutorial will guide you step by step through the creation of a [http://wiki.koffice.org/index.php?title=Flake Flake] shape. At the end you will be able to write a shape that is loadable by any KOffice application.   This tutorial will guide you step by step through the creation of a [http://wiki.koffice.org/index.php?title=Flake Flake] shape. At the end you will be able to write a shape that is loadable by any KOffice application.
  + 
  + For an introduction of KOffice plugins, see [[Development/Tutorials/KOffice Overview]] and for a technical introduction to plugins in KOffice see [[Development/Tutorials/Generic KOffice Plugin Creation|Generic KOffice Plugin Creation]]
    
  =Do the groundwork - create a shape=   =Do the groundwork - create a shape=

← Older revision		Revision as of 10:35, 15 December 2008
Line 34:		Line 34:

	=Make your shape loadable - create a factory and a plugin=		=Make your shape loadable - create a factory and a plugin=
−
−	~~XXX: Hasn't this changed? Look at the video or picture shape -- I think we do without all of this nowadays. (Boudewijn)~~

	Now when you have created your shape class and implemented all the necessary things to make it at least compile you can think about the loading of your shape.		Now when you have created your shape class and implemented all the necessary things to make it at least compile you can think about the loading of your shape.

← Older revision		Revision as of 15:05, 2 May 2007
Line 138:		Line 138:

	To edit your shape in the GUI the user wants to select a tool and alter your shape. Therefore you have to provide a KoTool derived class. This class implements all edit actions that can be done on your shape but it is also possible to have more than one tool per shape.		To edit your shape in the GUI the user wants to select a tool and alter your shape. Therefore you have to provide a KoTool derived class. This class implements all edit actions that can be done on your shape but it is also possible to have more than one tool per shape.
−
−	~~Note from TZ: I suggest creating a koffice/shapes/example dir in svn~~
−	~~which you can refer to from this tutorial.~~

← Older revision		Revision as of 15:04, 2 May 2007
Line 1:		Line 1:
	This tutorial will guide you step by step through the creation of a [http://wiki.koffice.org/index.php?title=Flake Flake] shape. At the end you will be able to write a shape that is loadable by any KOffice application.		This tutorial will guide you step by step through the creation of a [http://wiki.koffice.org/index.php?title=Flake Flake] shape. At the end you will be able to write a shape that is loadable by any KOffice application.
		+
		+	For an introduction of KOffice plugins, see [[Development/Tutorials/KOffice Overview]] and for a technical introduction to plugins in KOffice see [[Development/Tutorials/Generic KOffice Plugin Creation\|Generic KOffice Plugin Creation]]

	=Do the groundwork - create a shape=		=Do the groundwork - create a shape=