Hide last authors
Manuel Smeria 85.2 1 {{box cssClass="floatinginfobox" title="**Contents**"}}
2 {{toc/}}
3 {{/box}}
Manuel Smeria 85.1 4
Manuel Smeria 85.2 5 Wiki macros allow macro authors to develop reusable and distributable macro modules. There is no java code involved; hence no compiling or packaging. The macro author simply needs to create a wiki page according to a particular specification and that's all!
Asiri Rathnayake 4.1 6
Vincent Massol 94.3 7 This page is a tutorial but you can also access the [[reference documentation for the Wiki Macro feature>>doc:extensions:Extension.WikiMacroStore.WebHome]].
Vincent Massol 92.1 8
Manuel Smeria 85.2 9 = Hello Macro =
Asiri Rathnayake 5.1 10
Asiri Rathnayake 6.1 11 We are going to start with a very simple xwiki/2.0 wiki macro which prints a greeting message to the document content. It isn't a very useful macro but the idea is to get you familiarised with the wiki macro creation process.
Asiri Rathnayake 5.1 12
Manuel Smeria 85.2 13 == Definition ==
Asiri Rathnayake 5.1 14
Thomas Mortagne 120.1 15 Wiki macros are defined using objects of type ##XWiki.WikiMacroClass##. You define a wiki macro by creating a new wiki page and attaching to it an object of type ##XWiki.WikiMacroClass##. You will need to [[be advanced>>Documentation.UserGuide.Features.PageEditing||anchor="HAdvancedProfile"]] to access the [[object editor>>Documentation.UserGuide.Features.PageEditing||anchor="HObjectseditingmode"]].
Asiri Rathnayake 5.1 16
Thomas Mortagne 90.1 17 {{warning}}
18 There can be only one object of type ##XWiki.WikiMacroClass## per wiki page (if you add more only the first will be used).
19 {{/warning}}
Valdis Vitolins 89.1 20
21 This class contains the following fields:
Thomas Mortagne 98.1 23 * **Macro id**: Id of the macro to be used by users when invoking your macro from wiki code
24 * **Macro name**: Name of the macro to be displayed on the wysiwyg editor
25 * **Macro description**: A short description of the macro to be displayed on the WYSIWYG editor
Manuel Leduc 123.2 26 * **Default categories**: Default categories under which this macro should be listed {{warning}}before 14.4RC1 this was called **Default category**{{/warning}}
Thomas Mortagne 98.1 27 * **Supports inline mode**: Whether the macro can be used in an inline context or not
Simon Urli 102.1 28 * **Macro Content availability**: {{warning}}before 11.5RC1 this was called **Macro Content Type**{{/warning}} whether this macro should support a body or not
Thomas Mortagne 118.1 29 * **Macro content type**: {{warning}}this field has been renamed **Macro Content Availability** since 11.5RC1{{/warning}} the type of accepted content: two values are proposed, ##WIKI## if this content should be editable like a wiki content, or ##UNKNOWN## if it should be displayed like a plain text. It's also possible to specify a custom java type such as {{code language="java"}}java.util.List<java.lang.String>{{/code}}. Leaving the field blank is equivalent to ##UNKWOWN## value.
Thomas Mortagne 98.1 30 * **Content description**: A short description about the macro's content to be displayed on the WYSIWYG editor
31 * **Macro code**: The actual wiki code that will be evaluated when the macro is executed, can be any xwiki content (should be in the same syntax as the document)
Vincent Massol 118.2 32 * {{version since="13.1RC1"}}**Priority**: The priority of execution relative to the other Macros. The lowest values have the highest priorities and execute first. For example a Macro with a priority of 100 will execute before one with a priority of 500. The default value is 1000.{{/version}}
33 * {{version since="10.10"}}**Asynchronous rendering**: Enabled or disable asynchronous rendering of the panel. Disabled by default.{{/version}}
34 * {{version since="10.10"}}**Cached**: Indicate if the result of the execution of the element should be cached. Disabled by default.{{/version}}
35 * {{version since="10.10"}}**Context elements**: The context information required during the execution of the extension (current user, current document, etc.). It's also used to generate the cache key.{{/version}}
Manuel Smeria 85.2 36
Asiri Rathnayake 24.1 37 Now we can define our hello macro as shown below:
Manuel Smeria 85.2 38
Manuel Leduc 123.2 39 {{image reference="macro1.png" width="650px"/}}
Asiri Rathnayake 7.1 40
Manuel Smeria 85.2 41 == Invocation ==
Asiri Rathnayake 10.1 42
Manuel Leduc 125.1 43 A wiki macro can be invoked just like any other macro is invoked. Since we are writing a xwiki/2.1 wiki macro, we can invoke our **hello macro** as below:
Asiri Rathnayake 10.1 44
Thomas Mortagne 118.1 45 {{code language="none"}}
Valdis Vitolins 86.1 46 {{hello/}}
47 {{/code}}
Asiri Rathnayake 13.1 48
Asiri Rathnayake 16.1 49 And if you view the result it would say "Hello World!" (of course).
Asiri Rathnayake 13.1 50
Valdis Vitolins 86.1 51 == Content ==
Thomas Mortagne 118.1 53 {{version since="11.4RC1"}}
Michael Hamann 122.1 54 The easiest way to insert the content of the wiki macro is to use a dedicated macro in the body of the wikimacro:
Simon Urli 102.1 55
Vincent Massol 117.2 56 {{code language='none'}}
Simon Urli 99.1 57 {{wikimacrocontent/}}
58 {{/code}}
60 Note that by default this makes the content of the macro directly editable in [[the WYSIWYG editor>>https://extensions.xwiki.org/xwiki/bin/view/Extension/CKEditor%20Integration/#HWikiMacros]].
Vincent Massol 117.3 61 {{/version}}
Valdis Vitolins 87.1 62
Vincent Massol 117.4 63 For more details, see the [[Scripting Tips section below>>||anchor="HScriptingTips"]].
Vincent Massol 87.2 64
Manuel Smeria 85.2 65 == Parameters ==
Asiri Rathnayake 38.1 66
Manuel Smeria 85.2 67 Introducing a parameter to a wiki macro is pretty straight forward; you simply need to add an object of type ##XWiki.WikiMacroParameterClass## into your wiki macro document (one object per parameter). This class contains several fields that allow you to define your parameter clearly:
Asiri Rathnayake 42.1 68
Asiri Rathnayake 43.1 69 * Parameter name: Name of the parameter, users will refer this name when invoking your macro with parameters
Vincent Massol 98.2 70 * Parameter description (optional): A short description of the parameter, this description will be made available on the WYSIWYG editor
Asiri Rathnayake 43.1 71 * Parameter mandatory: Indicates if this particular parameter is mandatory, wiki macro will fail to execute if a mandatory parameter is missing
Vincent Massol 118.2 72 * {{version since="10.10"}}Parameter default value (optional): The default value of the parameter when it's empty{{/version}}
73 * {{version since="10.10"}}Parameter type (optional): Indicates to which Java type the parameter value (defined as a String) must be converted to (##java.lang.String## by default).{{/version}}
Anca Luca 131.1 74 ** For more information about parameter types and parameter pickers, see: [[Using pickers for XWiki Rendering Macro parameters>>Documentation.DevGuide.Tutorials.WritingMacros.Using custom pickers for XWiki Rendering Macro parameters.WebHome]]
Manuel Smeria 85.2 75
76 Now we're going to extend our **hello macro** with a parameter. We will introduce a parameter named //greetUser// that will indicate if the greeting message should be tailored for the current user viewing the page. The definition of the parameter is shown below:
Manuel Smeria 85.1 78 [[image:macro3.png]]
Asiri Rathnayake 42.1 79
Manuel Smeria 85.2 80 A macro parameter defined this way can be accessed from any scripting language within the macro code. For example, we are going to utilize our //greetUser// parameter within **hello macro** as shown below:
Thomas Mortagne 118.1 82 {{code language="none"}}
Simon Urli 113.1 83 {{velocity}}
84 #if ($wikimacro.parameters.greetUser && "XWiki.XWikiGuest" != "$xcontext.user")
Michael Hamann 121.1 85 Hello $services.rendering.escape($xwiki.user.email, 'xwiki/2.1')!
Simon Urli 113.1 86 #else
87 Hello world!
88 #end
89 {{/velocity}}
90 {{/code}}
Asiri Rathnayake 44.1 91
Simon Urli 111.1 92 As you might have realized already, direct binding of parameters is not supported at the moment. That is, you cannot access //greetUser// parameter with **$greetUser**. Instead you must use **$wikimacro.parameters.greetUser**. We plan to introduce some form of direct parameter binding in near future.
Asiri Rathnayake 38.1 93
Simon Urli 103.1 94 Since {{info}}11.5RC1{{/info}}, it is also possible to display the content of a macro parameter by using a dedicated macro:
Michael Hamann 121.1 95 {{code language="none"}}Hello {{wikimacroparameter name="greetUsers" /}}{{/code}}
Simon Urli 103.1 96
Manuel Smeria 85.2 97 Finally, we can test our new version of **hello macro** with the following invocation:
Asiri Rathnayake 42.1 98
Thomas Mortagne 118.1 99 {{code language="none"}}
Valdis Vitolins 86.1 100 {{hello greetUser="true"/}}
101 {{/code}}
Asiri Rathnayake 14.1 102
Robert 94.1 103 If you want to call the new version of the **hello macro** with a parameter from a variable you will need to wrap the call in a velocity macro like this:
Thomas Mortagne 118.1 105 {{code language="none"}}
Robert 94.1 106 {{velocity}}
107 #set ($greet = true)
108 {{hello greetUser="$greet"/}}
109 {{/velocity}}
Simon Urli 104.1 110 {{/code}}
Robert 94.1 111
Pascal Bastien 91.2 112 == Translations ==
Anca Luca 91.1 113
Vincent Massol 93.3 114 When your macro is ready, you might want to provide the description of the macro and its parameters in different languages. For that, you need to create a set of translation keys and values (as described [[here>>platform:DevGuide.InternationalizingApplications]]) and then just use the following convention for the keys you add in this storage (no modification is needed on the macro itself, the association of the translations to the macro is done based on a convention of the form of the translation keys):
Anca Luca 91.1 115
Thomas Mortagne 118.1 116 {{code language="properties"}}
Anca Luca 91.1 117 rendering.macro.<macro id>.name=Name of the macro, displayed in the macros list in the macros wizard
118 rendering.macro.<macro id>.description=Description of the macro, displayed as a help in the macros list in the macros wizard
120 rendering.macro.<macro id>.parameter.<parameter name>.name=Name of the macro parameter, to be displayed in the form for the macro settings in the macros wizard
121 rendering.macro.<macro id>.parameter.<parameter name>.description=Description of the macro parameter, to be displayed as a help in the form for the macro settings in the macros wizard
122 {{/code}}
124 Don't forget to make sure that the visibility of the translations is the same as the visibility of the macro, so that anywhere you use the macro you also have the translations.
126 In our example, french translations would be something like this:
Thomas Mortagne 118.1 128 {{code language="properties"}}
Anca Luca 91.1 129 rendering.macro.hello.name=Macro pour dire bonjour
130 rendering.macro.hello.description=Ceci est une macro qui va dire "Bonjour" a l'utilisateur
131 rendering.macro.hello.parameter.greetUser.name=Personnaliser le message
Pascal Bastien 91.2 132 rendering.macro.hello.parameter.greetUser.description=Personnaliser le message pour l'utilisateur courant en train de visualiser la page. Les valeurs possibles sont "true" (oui) et "false" (non).
Anca Luca 91.1 133 {{/code}}
Vincent Massol 117.5 135 = Macro Visibility and Rights =
137 There are 3 levels of visibility for a macro:
139 * ##Global##
140 ** on main wiki (or {{info}}before XWiki 10.4RC1{{/info}}) the macro will be available in all the pages of all the (sub)wikis. Requires the macro author to have **Programming Rights**
141 ** on subwiki {{info}}in 10.4RC1+{{/info}} synonym of ##Current Wiki## visibility
142 * ##Current Wiki##, which means that the macro will be available in all the pages of the wiki the macro is in. Requires the macro author to have **Admin Rights**
143 * ##Current User##, which means that the macro will only be available to the user who is its author. No special rights required.
145 == Using protected API in wiki macros ==
147 Also, if the macro needs to use [[protected API>>platform:DevGuide.Scripting||anchor="HXWikiCoreAccess"]], the author of the macro will need to have programming rights. Note that the macro will always be executed with the rights of its author, and not with the rights of the author of the calling document (the document using the macro). Specifically, if the macro uses protected API, only the macro author needs to have programming rights, not all the authors of the documents that call this macro.
149 = Bindings =
Anca Luca 129.1 151 The usual XWiki [[scripting context bindings>>doc:extensions:Extension.Script Macro||anchor="HBindings"]] are available in the scripts of the wiki macros, with the mention that contextual variables (such as ##$doc##) will point to the XWiki document (page) in which the macro is called, not to the XWiki document containing the objects that define the macro. This makes it easy to write features that are contextualized to the page where they're called.
Vincent Massol 117.5 152
Anca Luca 126.1 153 Then, specific bindings for the wiki macro context are available, see [[the reference documentation page>>doc:extensions:Extension.WikiMacroStore.WebHome||anchor="HBindings"]].
Manuel Smeria 85.2 155 = WYSIWYG Access =
Manuel Smeria 85.1 157 A wiki macros is treated just like any other rendering macro in the system. As such, the moment you save your wiki macro it will be available to the users through the WYSIWYG editor's **Insert Macro** dialog box:
Manuel Smeria 85.2 158
Manuel Leduc 125.1 159 [[image:macro2.png||height="293" width="350"]]
Manuel Smeria 85.2 160
Manuel Leduc 125.1 161 [[image:macro4.png||height="149" width="350"]]
Asiri Rathnayake 15.1 162
Manuel Smeria 85.2 163 == Special code for WYSIWYG edit mode ==
Asiri Rathnayake 16.1 164
Denis Gervalle 84.1 165 Even in edit mode, the WYSIWYG editor will execute the macro and feed the result back into the document. If your macro use some JSX, these will not be loaded. But, if your macro produce some Javascript that use those JSX or manipulate the document's DOM (injecting new elements, moving existing elements, removing elements, etc.), you may want to protect the content in WYSIWYG edit mode in order to prevent the performed transformation to get saved. Here is how you can prevent this behavior:
simba 69.1 166
Thomas Mortagne 118.1 167 {{code language="velocity"}}
Denis Gervalle 84.1 168 {{velocity}}
Vincent Massol 77.1 169 #if("$xcontext.action" != "edit")
Denis Gervalle 84.1 170 {{html}}
Denis Gervalle 85.3 171 <script type="text/javascript">
Denis Gervalle 84.1 172 //<![CDATA[
173 ... some javascript ...
174 // ]]>
175 </script>
176 {{/html}}
simba 69.1 177 #end
JeromeVelociter 70.1 178 ##
179 ## Rest of the code.
Thomas Mortagne 90.1 180 {{/velocity}}
Manuel Smeria 85.1 181 {{/code}}
simba 69.1 182
Simon Urli 116.1 183 == WYSIWYG editing of macro content or parameter ==
Thomas Mortagne 118.1 185 As specified above you can use the dedicated macros {{code language="none"}}{{wikimacrocontent/}}{{/code}} and {{code language="none"}}{{wikimacroparameter name="foo"/}}{{/code}} to allow the users of your macro to be able to edit the values of the macro directly in the WYSIWYG editor once the macro is inserted.
Simon Urli 116.1 186 Note that this is currently only possible if you specified that the macro content (or parameter) type is ##WIKI## type.
188 {{info}}
189 There is also a known limitation related to CKEditor that prevents editing directly those macros if they are not used as "standalone" macro. Details can be found on the related issue: https://jira.xwiki.org/browse/CKEDITOR-248.
190 {{/info}}
Manuel Smeria 85.2 192 = Scripting Tips =
Asiri Rathnayake 31.1 193
Manuel Smeria 85.2 194 Following are a few useful hints if you plan to do advanced scripting inside your wiki macros:
Asiri Rathnayake 33.1 195
Valdis Vitolins 86.1 196 * Since 2.4M1, it's possible to directly return the desired list of rendering blocks without having to render them first to let them be parsed back by the macro transformation. The benefits are that it could be a lots quicker and most of all it means supporting syntax which does not provide any renderer. It also makes it possible to generate some XDOM which is impossible to write in any some syntax. For example the following wiki macro is generating a LinkBlock targeting a relative URL:(((
Thomas Mortagne 118.1 197 {{code language="groovy"}}
Thomas Mortagne 74.1 198 {{groovy}}
199 import java.util.Collections;
200 import org.xwiki.rendering.listener.Link;
201 import org.xwiki.rendering.block.WordBlock;
202 import org.xwiki.rendering.block.LinkBlock;
204 ref link = new Link();
205 link.setReference("/xwiki/edit/Main/WebHome");
206 link.setType(LinkType.URI);
208 ref linkBlock = new LinkBlock(Collections.singletonList(new WordBlock("Edit home page"))), link, false);
Simon Urli 111.1 210 wikimacro.result = Collections.singletonList(linkBlock)
Thomas Mortagne 74.1 211 {{/groovy}}
213 This text will not appear in the result.
Manuel Smeria 85.1 214 {{/code}}
Manuel Smeria 85.2 215 )))
Michael Hamann 121.1 216 * If you need to directly access the parsed XDOM of the content you may do the parsing yourself using the rendering service. Here is a small sample:(((
Thomas Mortagne 118.1 217 {{code language="velocity"}}
Denis Gervalle 81.1 218 {{velocity output="no"}}
Denis Gervalle 81.3 219 ## get the macro content in a velocity string
Simon Urli 111.1 220 #set($wikiresult = $wikimacro.content)
Denis Gervalle 81.2 221 ## Add a wrapping div as a sample of the action of this macro
222 #set($wikiresult = "(% class='newstyle' %)((($wikiresult)))")
223 ## parse the string and return the resulting blocks
Simon Urli 111.1 224 #set($wikimacro.result = $services.rendering.parse($wikiresult, $xwiki.getCurrentContentSyntaxId()).getChildren())
Denis Gervalle 81.1 225 {{/velocity}}
Manuel Smeria 85.1 226 {{/code}}
Manuel Smeria 85.2 227 )))
Valdis Vitolins 86.1 228
Manuel Smeria 85.2 229 = Troubleshooting =
Denis Gervalle 81.3 230
Manuel Smeria 85.2 231 == A Pitfall of Optional Parameters ==
Vincent Massol 72.1 232
Manuel Smeria 85.2 233 {{info}}
234 This pitfall has been fixed in XWiki 2.2
235 {{/info}}
Vincent Massol 72.1 236
Manuel Leduc 125.1 237 There is a common pitfall for using optional parameters. The following macro code contains a not so obvious bug:
Vincent Massol 72.1 238
Thomas Mortagne 118.1 239 {{code languege="velocity"}}
Vincent Massol 72.1 240 {{velocity}}
Vincent Massol 77.1 241 #set($greetUser=$xcontext.macro.params.greetUser)
Vincent Massol 72.1 242 #if ("true" == $greetUser && "XWiki.XWikiGuest" != "$xcontext.user" )
Michael Hamann 121.1 243 Hello $services.rendering.escape($xwiki.user.email, 'xwiki/2.1')!
Vincent Massol 72.1 244 #else
245 Hello world!
246 #end
Michael Hamann 122.2 247 {{/velocity}}
Manuel Smeria 85.1 248 {{/code}}
Vincent Massol 72.1 249
250 If we invoke it twice in a row:
Thomas Mortagne 118.1 252 {{code language="none"}}
Vincent Massol 72.1 253 {{hello greetUser="true" /}}
254 {{hello /}}
Manuel Smeria 85.1 255 {{/code}}
Vincent Massol 72.1 256
257 The second invocation will not print "Hello World!" as we'd expect. But it will print the same result as the first invocation. The reasons are:
Manuel Smeria 85.1 258
Manuel Smeria 85.2 259 * Macro parameters are implemented as global parameters. So, they remain the same across multiple macro invocations.
260 * If ##$xcontext.macro.params.greetUser## contains "null", it will not be assigned to ##$greetUser##. This is different from C/C++ or Java.
Vincent Massol 72.1 261
262 So in order to get around it, you can use:
Thomas Mortagne 118.1 264 {{code language="none"}}
Manuel Smeria 85.2 265 #set($greetUser="$!xcontext.macro.params.greetUser")
266 {{/code}}

Get Connected