Magnolia CMS

In the past three months, the noise around Magnolia’s workflow module has gotten louder and louder. That’s a good thing – it means that people are using the workflow. On the other hand, we also know that they have found … Continue reading →

Blog post edited by Gavan Stockdale As usual, some questions and answers. Today's motion is: Knowing how to work with Magnolia is a big + on the CV of anyone in the Java ... [More] sphere looking to add a skill that will travel far and pay its way.You really seem to push this Academy thing. I get all the promotion, but what's in it for me?Good question. I am responsible for an online training portal called Magnolia Academy. Obviously I am keen to see the company I work for do well - and as part of that process I actively promote my own work. Right now Magnolia Int. is expanding, our client base increasing and our product becoming ever more sophisticated and appealing. All of which means that I can add some delicately balanced quid pro quo to the equation. And here it is - In the short to mid term, us getting you to learn about Magnolia CMS serves YOU a lot more than it serves us. You benefit now, but we will benefit down the line.Hopefully we all benefit. Eventually.How so?The primary goal of Magnolia Academy is to lower the barrier of entry. Along the way it is nice to be able to assist sales and marketing to chase up commercial leads. The ultimate the goal of the Academy is train people as quickly as possible how to work with Magnolia CMS - whatever their role might be. Be it a front or back end dev - or a system administrator.But here's the thing - it is only free for you. We are paying. We even carry a marginal risk of losing training revenue. I won't go into the details here - but we are not service driven company. We build and sell Magnolia CMS. Even if a company buys Magnolia, it's not a great situation for us if not a single dev. in the company can work with our product. That just means another client in need of extra love and care.Ok, so the Academy is free. What's the hard evidence that it makes sense for me to take the time to learn to work with Magnolia CMS - even if I can do it free?If you want hard evidence, go look for it. It's called 'job hunting'. Firstly, it is not just the Academy that is fee. You can have our software too. (Strange and all as that may seem.) At Magnolia Int. we have a strong community ethos and fully respect that many Magnolia users will opt for the free edition. That is totally cool with us - and we don't go cold calling free edition users. In fact, we don't usually cold call anyone. That's just not our style. And we don't share commercial information. That said, we don't object to anyone using Google search and some key words such as Java developer, Magnolia, CMS etc.What you are saying is that companies are looking for people that work with Magnolia CMS, right?Yes. I am not saying that on any given day there are a gazillion adverts out there offering a world of riches to Magnolia CMS developers, but...So how often do jobs come up?Frequently enough for me to see them. Generally what happens is this - the companies are either already in Javaworld - or they suddenly need to be. Either way, once they opt for Magnolia CMS there is a localized flourish of job adverts with keywords such as 'Java skills' and 'Magnolia CMS' - even if the company is using the Community Edition (i.e  - the free edition). Our free software, combined with free training can help you get you a well paid job.OK. So what advice would you have for a young Java dev looking to upskill and get into a cool line of work?I know if I were a keen Java developer looking for a marketable skill and attracted to figures such as 350 sterling a day, I would be adding Magnolia CMS to my belt. And I would be very grateful of any training material I could get my hands on. From there I would learn the ropes by doing my own projects with Magnolia CMS Community Edition and learning all the basics of templating, working with the STK etc.And the Academy covers this?Yes. But the Academy will only bring you so far. If you are good, once you have been a given hand up, you will make massive strides on your own. And there's nothing shows that you have a tangible skill than tangible evidence. If I were recruiting a new Magnolia CMS dev. the first thing I would ask is 'Can you show me a Magnolia CMS project you have created?"I already have a job and I already work with a CMS. What's in it for me? Consider this; maybe YOU can help your company make a decision. Adding Magnolia to your skillset means that you can put forward solid arguments why your company should be using it or at least could benefit from a switch. It's hard to argue when you don't know what you are arguing for. Knowing how to work with Magnolia CMS means that you can make informed and informative decisions about the potential payoff.I'm in. How do I get involved?Read the dev blog and then download Magnolia CMS today. Join our Forum and subscribe to the newsletter. Oh, and check out the Academy: http://academy.magnolia-cms.com/display/MAJust one more question!Sorry, out of time.   I hope you find the answer here: http://academy.magnolia-cms.com/display/MA/Questions+you+should+ask If not, please email me at [email protected]!Gavan Stockdale View Online [Less]

Magnolia 5.2.2 is out. It’s our first so called “extended maintenance” release. This means that we didn’t only focus on bug fixes but added some new features as well. Compared to our normal maintenance releases, we put a lot more … Continue reading →

We just published the first batch of app design guidelines for Magnolia CMS. Here is what I learned about documenting UI design.Few people like reading long design theory. We thought about how to get the message across and chose a radically different ... [More] approach. Each design guideline is a short recipe card that is highly focused and visual. One card is one solution. A deck of cards is a better user experience.Card anatomy:Title tells you what to do. The imperative verb is familiar from recipes: Be a good tablet citizenTweet motivates the reader and lets me promote the guideline.The "Why" explains why this topic is important. There has to be a reason for the card. Concrete examples relate to real-world usability issues.Visual interest makes the card a delight to read. Screenshots are crucial.I organized the card text as if it was a news story. This style is known as inverted pyramid. Important information is at the top. Details follow in order of diminishing importance towards the bottom.The pyramid format works great for two reasons:Developers can leave the card at any point and still understand it.For those developers who wish to proceed, the pyramid gives more details.The inverted pyramid is an unusual choice in technical documentation. Tech docs are typically comprehensive – all features are given equal importance. Everything has to be covered because you don't know what the reader is looking for.However, design guidelines are really more like persuasive text. Strictly speaking, you don't need to read them. You can build a perfectly functional Magnolia app without reading a single guideline. With the card format I try to persuade developers to adopt a few sound design principles to make apps better. The inverted pyramid information structure that has the best chance of getting at least the key message across. [Less]

Today, we're launching the Magnolia app design guidelines.This is an important moment for everybody involved in designing and crafting the new UI, as it represents the first time that we're releasing official documentation that gives best practice ... [More] advice on how to build good UIs for your Magnolia apps and also exposes some of the underlying principles of Magnolia's new user interface.We've thought about a good format for our guidelines for a long time. I typically lean towards explaining everything in great detail, as I have to in the UX wiki space, in the hope that someone would actually go and read and understand it all and, from then on, apply and use all those ideas and UI elements as originally intended.But that's not how it works: it's next to impossible to precisely capture every aspect of an interface and still come up with a document worth reading. And it's quick, simple, easy-to-read, easy-to-apply advice that makes a difference in the heat of a coding or design battle, not long texts.So we're trying a different approach. Do you remember those print magazines in the 80s, 90s, which came with collectible recipe cards, maybe three or five cards per issue?  Every card was explaining how to cook a particular dish and was properly laminated so you could use it in the kitchen with wet hands without ruining it. And you could order a handy (and horrendously pricey) plastic box to store them in. We've not copied the dark side of that business model, no, but we've applied the card model to our guidelines: the concise writing style and to-the-point character of every card; the consistent layout across all cards; and a layout that supports browsing for new recipes by just flipping through the set of cards.We're launching with eight cards covering the most burning, most asked for UI topics that surfaced during reviews. Each card starts with a short summary of the issue, followed by one, two images of good and bad examples. The card is completed by some additional details in the bottom area. All text is typically linked to more comprehensive pages in the documentation wiki.We've taken great care to pick titles that tell you enough about the topic of a card to help you in quickly finding what you're looking for by just glancing at the stack of cards. This should also give you additional ideas of what to look out for when designing an app. And you might actually want to consider using the entire card deck as a series of smoke tests for your new UI. Obviously, eight cards are not enough to cover it all. Additional cards will be added over time. We've already written some cards to cover future, still unreleased UI features. This is an ongoing effort, and it greatly depends on your feedback - so tell us what you want and need to know. And let us know if our guidelines actually helped you in cooking better tasting, better looking dishes by leaving a comment on the corresponding card. [Less]

We're testing opening up parts of our content creation process. To do this, we're posting a draft of an upcoming technical brief on my blog and asking people to review and comment.For more background information and the beginning of the "Why Magnolia ... [More] Rocks for Java Developers" technical brief, read part 1.... continued from part 2 ...DevelopmentOnce you’re into heavy development of a project, we think that there are a lot of things that you’ll like about Magnolia. Here are a few highlights.Use the Languages, Services and Tools You Love (and Hate)New skills and new infrastructure can be hard to acquire. Magnolia is designed to help you make the most of what you love to use and have to use.Magnolia is built with a strong focus on integration and interoperability. At most layers of the system there are multiple sensible options for integrating or interfacing with other software.For example, you can hook into Magnolia’s data layer using the JCR observation API, treat resources as files via WebDAV or manage Magnolia content via REST.This flexibility is particularly useful when integrating in-house legacy applications that weren’t designed with web integration in mind, as you can choose the most appropriate method and layer for your integration.There are also many small and large pieces of tooling in place to help you use common Java tools with Magnolia.Examples of this include a Groovy console (that’s also pretty groovy) and our Blossom module for the Spring Framework. Blossom makes it easy for Spring developers to add Magnolia’s feature set to new and existing Spring apps (and vice versa.)[Add link to docs or features overview]What development-related topic(s) would you want here?Hello dear reader,What part of Magnolia matters most to your daily development work? What features are you most excited about? We've got strong ideas on what to put here, but we'd like to hear about what you think we should cover.Thanks! We'll now return you to your regularly scheduled draft technical brief.There’s Help When You Need ItThere are many different resources to help you work with Magnolia, both paid and free, including:Official Magnolia Documentation – Detailed technical documentation that’s continuously updated and improved by our documentation team with support from our development team. The Magnolia Forums – …Magnolia Developer Training – four days of intense, hands-on training with Magnolia, available at one of the Magnolia offices or at your site.Official Magnolia 24x7 Support – ...## (End of Part 3 / To be continued on 2014-02-04 ) ## [Less]

We're testing opening up parts of our content creation process. To do this, we're posting a draft of an upcoming technical brief on my blog and asking people to review.For more background information and the beginning of the "Why Magnolia Rocks for ... [More] Java Developers" technical brief, read part 1.Per-Project: Getting a Feel for Magnolia CMSWhether learning Magnolia for a project or your own interest, you’ll typically start by downloading a copy and seeing what it does. Here are a few things we’ve done to make it easier to check Magnolia out.Up and Running in ~15 Minutes… and you won’t find yourself trapped in dependency heck. The install process is fast and easy.  Download and extract single archive, run a shell command, open a web browser and click a few buttons.The only real requirement is that you have a functional Java environment configured where you install Magnolia; everything else is included in the archive.For more complete instructions, including troubleshooting notes, read our installation guides for Linux, Mac OS X, Solaris and Windows.Alternately, go to your *nix shell and run:curl -L \  http://sourceforge.net/projects/magnolia/files/latest/download \  | tar xzcd magnolia-5*/apache* bin/magnolia_control.sh start && tail -f logs/catalina.outxdg-open http://localhost:8080 # Use the open command on Mac OS X # ... then follow the instructions on the opened web pageBy Java Developers for Java DevelopersMagnolia uses familiar tools and best practices to make your life easier.This sounds obvious – who, other than Java developers, would be writing Java software – but it's still tremendously important.Software for enterprise-scale problems tends to be enterprise-scale complex. We help manage that complexity by using best practices, conventions, coding idioms and tool stacks that are familiar to working Java developers.Requirements and Other StoriesModern mission-critical enterprise websites are studies in intersecting complexity. Each story or functional requirement is bound to a host of technical, strategic, legal and logistical requirements from large numbers of stakeholders and user personas. In competitive service-oriented markets, all of this complexity needs to be built and operated at high speed.The requirements stage may also be the point where your favorite software is pulled from the running because it doesn’t meet the full set of stakeholder needs. Here are a few key points about how Magnolia fits into the larger organizational picture.Component-based and Batteries IncludedMagnolia has a rich default feature set that meets common enterprise website requirements, while having an architecture that makes new features easy to develop.Generally speaking, proprietary software requires you to work with or work around their way of doing things, while Open Source software often has multiple independent implementations for every common need. With the typical proprietary approach, you gain cohesiveness at the cost of losing flexibility. With the typical open approach, you gain flexibility at the cost of having to evaluate many choices (and once you’ve made your choices, you still need to integrate them.)Magnolia CMS attempts to combine the best features of these approaches. We integrate many high-quality open source components using open standards and have an architecture that makes it easy to change to swap components in and out. Don’t like Tomcat? Well, you can use Jetty, Wildfly or other servlet containers. You get a CMS with a rich feature set that handles most CMS use cases, but that also gives you the flexibility to integrate anything else that you need, be it custom, proprietary or open.[Add link to upcoming Open Suite white paper]Untangling the Complex, Intersecting Requirements of the Modern, Mobile WebAt enterprise-scale, the modern website is all about complexity: rich content assembled from multiple internal and external services hosted in multiple data centers in multiple legal jurisdictions needs to be delivered in multiple formats and multiple languages to multiple platforms running on multiple devices. If this weren’t enough, all of these things need to happen in a secure, reliable and high-performance fashion.We design and build Magnolia to deal with this horror. Each feature takes into account how it’ll interact with other features, with our development team thinking about how issues like interoperability, localization, scalability and user experience will shape design, implementation and testing. Our work is also informed by our experience with large Magnolia CMS in the wild, such as Al Arabiya’s deployment that serves peak volumes of 20 000 users per second. [Add relevant link when upcoming paper is published]Strategically Sound: Built for the Future with No Lock-in by a Proven VendorTechnology adoption is as strategic as it is technical. We’re a stable vendor with a proven product and a business model that’s focused on giving our customers real value.With Magnolia as a product, you get the strategic benefits of open source and open standards, such as easier software audits, increased flexibility, no vendor lock-in and increased choice of service providers.We offer an enterprise edition of Magnolia CMS that meets common enterprise business needs around issues like indemnification, SLAs and 24x7 support.With Magnolia as a company, you get to work with a friendly, stable vendor who’s focused on providing excellent value and service. We’ve been in business for over a decade and have grown without taking venture capital or giving up control of our vision.Learn more about us on our website, particularly our about us, partner, case study and customer pages.[Place a Magnolia Intl. sidebar near here]As Easy to Use as a SmartphoneThousands of hours have gone into making Magnolia’s power usable by non-developers.When you have to manage many complex requirements, it can be hard to keep software easy to use.Magnolia’s interface is unique among content management systems. At the start of the smartphone revolution, we began redesigning Magnolia’s administration interface to work with touch devices.Tablet support: Magnolia’s administration interface was redesigned from the ground-up to support touch devices. Editors can author and manage content on tablets using a fluid administration interface localized into many different languages. Even traditionally complex tasks like changing page layouts and editing image resources are easy. Visit http://demo.magnolia-cms.com with an iPad to experience this for yourself.[Add screenshot of choosing different components for a page in the Magnolia shell]Content on Mobile Devices: We also have spent a lot of time building tools for great experiences on mobile devices. Mobile users get content that’s mobile-optimized. Images are scaled to appropriate sizes, layouts are optimized for small screens, and so on, while supporting features like caching are appropriately adapted. See the Mobile page of our documentation for additional details.[Add annotated, side-by-side comparison of desktop and mobile output]## (End of Part 2 / To be continued on 2014-01-31 ) ## [Less]

The Magnolia marketing team is trying a simple experiment and we need your help. We want to see what happens when we share drafts of marketing materials (like technical briefs and white papers), and ask for community feedback. We hope it'll be a fun ... [More] way to better engage with Magnolia community members, partners and customers.This post is part of the experiment. I've taken the first few sections of a technical brief that I'm writing and posted them here on my personal blog. We could use a more official space (and might in the future), but for now our personal blogs are more than adequate.If you have five minutes to spare, please skim the rough draft and leave your comments. I'm particularly interested in answers to questions such as:Is the writing style easy-to-understand?Java developers: Does the article have the right kind of information for you? Please assume that you don't know Magnolia.Magnolia users: Does the article reflect your experience? Are there more important things to cover?Non-developers: Is this something that you'd want to share with developers you know?If you have anything else to share, just leave a comment below.Many thanks!On behalf of the Magnolia marketing team, Zak GreantWhy Magnolia Rocks for Java DevelopersIn 2012, the good folks at Atlassian rebuilt Atlassian.com on top of Magnolia CMS. Since then, they've also used Magnolia to build the Atlassian University, as well as popular spoof site Angry Nerds.Send in the Angry Nerds.Reflecting on their early use of Magnolia, Mark Halvorson, Atlassian’s Director of Interactive said:“The two pilot projects showed what could be done with an excellent CMS: serving high traffic, last minute changes even under heavy load, delegated authoring, easier translation, and a clear path from development to staging to production. This is when everyone at Atlassian realised that Magnolia was the perfect match.”(For more information, see our Atlassian case study.)The quote gets to the simple core of what makes Magnolia CMS rock for Java developers: the developer-only parts are crafted by Java developers for Java developers. With Magnolia, you get to use development skills you already have to build robust web CMS solutions in complex, risk-sensitive and heterogenous technical environments.(Note: We plan to put the "What is Magnolia CMS" and "When Magnolia CMS Doesn't Rock" near here. See the end of the post for the content of the sidebars.)A Project-wise View of Magnolia CMSThis brief is structured something like a web development project: each major section roughly matches a project stage. We chose this structure because it reflects common working environments where there is code to write, customers to serve, colleagues to collaborate with, service providers to manage and so on.To keep the document compact, we've only covered a selection of Magnolia's features and benefits. Links to more in-depth information are included throughout.Also, though this document focuses on mission-critical use of Magnolia CMS in enterprise settings, the information is broadly applicable to many different kinds of projects and deployments.## (End of Part 1 / To be continued on 2014-01-30 ) ### # #Sidebar: What is Magnolia CMS?Magnolia CMS is an open source web CMS written in Java and built on a best-of-breed open source stack using open standards. Our development team focuses on:Integration and interoperability – …Usability and ease of development – …High performance – …Mobile and touch – …Marketing automation – …# # #Sidebar: When Magnolia CMS Doesn’t RockMagnolia CMS isn’t the right solution for every content management problem. If you want to make heavy use of Magnolia in production, you should have Java experience and stable Java web hosting infrastructure.When You Don’t Have the Right Java ExpertiseThe developer-only parts of Magnolia CMS are designed for experienced Java developers working on complex projects in enterprise environments. Though Magnolia has many easy integration and extension points, heavy hacking directly on Magnolia CMS requires Java experience.When You Don’t Have the Right Java InfrastructureJava web hosting can be complex and expensive. If you don’t run your own Java web servers or have experience with Java web hosting services, you probably shouldn’t deploy Magnolia in heavy production without help. [Less]

Lately I had to quickly prepare a PoC for a prospect showing how Magnolia can easily integrate with pure client-side technologies. We know that Magnolia 5 new shiny UI is built on Vaadin and that apps use Vaadin components to make a Java developer's ... [More] life easier when it comes to build their UI. Still, if for whatever reason you need to work with pure Javascript, Magnolia won't let you down. The goal of the PoC was pretty simple - create an editor app which fetches the model (i.e. data from a JCR repository) and bind it to the view (a freemarker template in our case) by using an angularjs controller. The data can be edited inline, saved back to the JCR repository and finally published. As you may know, Magnolia recently released a pretty powerful REST API and, of course, in this scenario it was the best fit for the task of fetching and saving data. The REST API also allows to execute commands (once we explicitly allow this in the security app), so publishing wasn't a problem either. This is a screenshot showing the final result. Admittedly, it doesn't look fancy and it's far from being perfect but it will make our point.So, on to the code! When the app presenter starts it will pass our view the workspace and the path of the currently selected page (a JCR node). Workspace and path are the two basic info we need to use the REST API (authentication here is not a problem as, when using our PoC app, we'll be already logged in). That info will be in turn passed as request parameters to the iframe source, so that eventually we will be able to use it in our editor freemarker template (of course we could have also used JSP there).EditorViewImpl.javapublic void setParameters(String path, String workspace) { // Vaadin Iframe component BrowserFrame editor = new BrowserFrame(null, new ExternalResource("poc-editor?path=" + path + "&workspace=" + workspace)); editor.setSizeFull(); // clean previously set iframe root.removeAllComponents(); root.addComponent(editor); }The iframe source resolves to /.magnolia/poc-editor which is mapped to info.magnolia.poc.servlet.EditorServlet. This servlet will render our freemarker template. (As usual with Magnolia, the mapping is defined in the module descriptor at /src/main/resources/META-INF/magnolia/rest-ng-poc.xml [see the servlet tag]). EditorServlet.javaprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { HashMap map = new HashMap(); // expose the variables we need to use the REST API in the freemarker template. map.put("path", req.getParameter("path")); map.put("workspace", req.getParameter("workspace")); FreemarkerUtil.process("rest-ng-poc/pages/editor.ftl", map, resp.getWriter()); }editor.ftl injects the angularjs core lib and a controllers.js, that is a Javascript file holding all the ng controllers for our ng app. The ng app is called editorApp and in our case there's only one controller called PageCtrl. As we said above, an ng controller is the glue binding together the model and the view, so let's have a look at it. (Here I assume you have a very basic understanding of angularjs. Their tutorial is a great place to get started and, on the other hand, I am no angularjs expert - I actually knew nothing about it before starting this PoC - so following should not be that hard.)controllers.jsvar editorApp = angular.module('editorApp', []);editorApp.controller('PageCtrl', ['$scope', '$http', function ($scope, $http) { $scope.init = function(ctx, workspace, path) { $scope.path = path $scope.ctx = ctx $scope.workspace = workspace $scope.url = ctx + '/.rest/nodes/v1/'+ workspace + path $http.get($scope.url). success(function(data) { //console.log(data) $scope.page = data; }). error(function(data) { alert('ERROR: ' + data) }); }; $scope.save = function() { $http.post($scope.url, $scope.page). success(function(data) { alert('Page saved') }). error(function(data) { alert('ERROR: ' + data) }); } $scope.preview = function() { window.open($scope.ctx + $scope.path) } $scope.publish = function() { // In order for this to work you need to grant "rest" role get&post for "/.rest/commands*" $http.post($scope.ctx + '/.rest/commands/v1/website/activate', {"path":$scope.page.path, "uuid": $scope.page.identifier, "repository":$scope.workspace}). success(function(data) { alert('Publication workflow started') }). error(function(data) { alert('ERROR: ' + data) }); }}]);Our controller gets passed two services (in angularjs parlance) named $scope and $http. Those come of out-of-the-box with angularjs but you can write your own services if you need to. $http in particular will be used to call the REST API (for an alternative and "better" way of doing that, you can have a look at the $resource service).Our PageCtrl is basically attaching its functions and variables to the $scope service. This will ensure that they will remain scoped to the page portion delimited by the special attribute ng-controller="PageCtrl". The interesting functions exposed here are$scope.init Gets the model to initialise the view by calling the REST API and assigning the fetched data (the model) to the $scope.page variable. $scope.saveSaves the model, i.e. $scope.page via a REST call. That's one powerful feature of angularjs. We don't need to check ourselves for model changes, angular will do it for us through its internal observation mechanism. What we pass back to the rest API is actually only the REST url and $scope.page without worrying about anything else.$scope.publishHere we publish the current page via REST. The request body, i.e. the second argument to the $http.post function, will take an object with three parameters named "path", "uuid" and "repository". Such parameters are needed by the activation command to perform its duty. Be aware that by default commands are disabled, therefore we will need to grant them to the rest role in the security app, else we'll get a 403 error.And finally the freemarker template. Here we iterate over the model exposed in $scope.page (by filtering out everything but String properties) and assign the values to some html elements. The values we want to be able to change are bound to the model via the special attribute ng-model. This is doing the magic I was talking about a few lines above. It will basically observe the model for us and update it with any changes we'll make so that we won't need to worry about it when we'll want to persist it to JCR.The complete Maven project is available here https://github.com/fgrilli/mgnl-rest-ng-poc for you to explore and try out.To sum it up, Magnolia proved once again to be an exceptionally flexible CMS and in combination with its REST API making this PoC was indeed extremely easy, fast and fun. [Less]

There's a bug in Confluence 4.2 that generates identical IDs for same-name heading elements (CONF-17962). The issue is fixed in Confluence 4.3 but here is a workaround for those stuck with Confluence 4.2 or earlier.Multiple same-name headings on the ... [More] same page are OK. In fact, they are quite common. When I document objects that have similar properties I need to repeat headings. The problem in Confluence 4.2 is that you can't link to such headings (anchors). The link always points to the first occurrence of the heading.Example: I use the following heading structure in message types documentation:BannersBehaviorLevelsExamplesLooks likeHow to showAlertsBehaviorLevelsExamplesLooks likeHow to showNotificationsBehaviorLevelsExamplesLooks likeHow to showConfluence generates IDs using a pattern where page title and heading are concatenated with a hyphen in between:<page title>-<heading name>As a result, the IDs of all my "Behavior" headings are identical:<h3 id="Messagestypes-Behavior">Behavior</h3><h3 id="Messagestypes-Behavior">Behavior</h3><h3 id="Messagestypes-Behavior">Behavior</h3>Workaround. Add the Anchor macro in front of the lower level heading. Set the anchor name to the upper level heading followed by a hyphen.This creates unique IDs:<h3 id="Messagestypes-Banners-Behavior">Behavior</h3><h3 id="Messagestypes-Alerts-Behavior">Behavior</h3><h3 id="Messagestypes-Notifications-Behavior">Behavior</h3> [Less]