Hi Devs,
here's a quick update on the current work being undertaken to bring a new
skin to life for XWiki 2.0. The aim of this new skin is to provide XE with a
fresh / new look & feel for the 2.0 release. The main items, ordered by
their priority, are listed here:
http://incubator.myxwiki.org/xwiki/bin/view/Improvements/NewSkin
It's broken down into 2 sets: hard requirements (XE 2.0 can't ship without
meeting them) and soft requirements (we can do them later if needed). Its
main aims are:
- make it easier for a new wiki user to change the look & feel of the
wiki using its own color set
- move the action bar closer to the content area and make it scroll with
the page (removing the flickering issue in linux)
- make it possible to automatically display a page's title when its
title field is filled
(configuration option)
- replace the stripped background images with a plain color background
Those items are those that we run into when trying to customize skins and
should help users make their wiki look nice more easily.
Cati & I will keep you posted about the skin's progress.
Guillaume
--
Guillaume Lerouge
Product Manager - XWiki
Skype: wikibc
Twitter: glerouge
http://guillaumelerouge.com/
Hi all,
Since almost two years ago you has done a lot of work to develop the new
rendering system based on components. I can found two documents I'd been
following to understand how this work has been done and what was its
development state. Those are:
http://dev.xwiki.org/xwiki/bin/view/Design/NewRenderingArchitecture
and
http://platform.xwiki.org/xwiki/bin/view/AdminGuide/Configuration#HCustomiz…
I am trying now to catch up with this thread due mainly to two reasons:
* At least a couple of new XWiki installations will be made public in
the following weeks. It seems logical to use the last available version
and take profit of all the new features. We do need to serve XWiki pages
rendered as plain text. This was simple done working with XWiki 1.0
syntax. It seems to work the same way while working with XE 2.0m1 when
using XWiki 1.0 syntax, but xpage=plain it is not enough when working
with XWiki 2.0 syntax. I've read a number of thread related with issue
in the devs list and, if I've well understood, there will be new
parameters introduced in 2.0m2 to
* We do need to control at least rtf and pdf outputs.
So, please, are these two links still valid to follow the development of
the new rendering architecture and how it affects/will affect the
production of rtf and/or pdf files? What other locations I must follow,
if any, to follow this development?
I hope I've been able to explain what I am trying to do!
All the best!
Ricardo
--
Ricardo RodrÃguez
Your EPEC Network ICT Team
Hi devs,
When we have farm like xwiki.org or myxwiki.org stuck we usually kill
the jvm and look at its last state to see if we can find some lock
etc...
Most of the time if the issue is in a specific script and not a
platform bug it's unreadable. To make it more easy I propose to rename
thread created by the application server based on the URL.
Basically it means something like adding:
Thread.currentThread().setName(request.getRequestURL() + "?" +
request.getQueryString());
in XWikiAction#initializeXWikiContext.
I tested it on tomcat and it works well.
WDYT ?
Here is my +1 for this
--
Thomas Mortagne
Hi all,
While working on macro categories implementation I came across a small
problem that made me little uncomfortable with AbstractMacro API. I'm
writing this email just to make sure that I'm not making things worse in the
public API.
Currently AbstractMacro has 4 constructors:
* public AbstractMacro(String description);
* public AbstractMacro(String description, ContentDescriptor
contentDescriptor)
* public AbstractMacro(String description, Class< ? > parametersBeanClass)
* public AbstractMacro(String description, ContentDescriptor
contentDescriptor, Class< ? > parametersBeanClass)
Now, I wanted to introduce a MacroDescriptor::getDefaultCategory() method
and I also wanted to make this new parameter available in AbstractMacro
constructors (makes sense). Now the problem with this is, If I introduce an
optional 'defaultCategory' parameter into AbstractMacro, this will make the
total number of constructors 8. What will happen if someone wants to
introduce a MacroDescriptor::getIcon() method some time later?
One solution is to have setXXXX methods for those parameters instead. But
then a slight problem occurs where AbstractMacro needs to somehow call
setXXX methods on it's internal MacroDescriptor instance. It's not that we
can't cook comething up, but it's going to look hackish.
My question is, why do we have to make AbstractMacro constructors so simple?
Can't we have these two constructors only?
* public AbstractMacro();
* public AbstractMacro(MacroDescriptor);
The problem with this approach is that a client will have to do little more
work like;
ContentDescriptor myContentDescriptor = new DefaultContentDescriptor("This
is my content", true);
MacroDescriptor myMacroDescriptor = new DefaultMacroDescriptor("This is my
macro", myContentDescriptor,
beanManager.getBeanDescriptor(MyParametersClass.Class))
super(myMacroDescriptor);
Even though this is too much of work, I think it will make the API more
extensible an clean.
This is only my opinion. I didn't want to drag this issue this far but I
just couldn't feel myself comfortable with the way I'm going to implement
the macro categories support.
Up to you.
Thanks.
- Asiri
Hi,
I would like to introduce a MacroCategoriesManager component for managing
macro categories. We already have a MacroManager component in place but I
think seperating out the concern of macro categories management into a
seperate component creates a more extensible design. Following is a basic
outline for implementing MacroCategoriesManager component:
* Introduce MacroDescriptor::getDefaultCategory() method which returns a
String. The purpose of this method is to allow macro author to supply a
default category under which his macro should be listed. This method can
virtually return any string.
Following three steps I'm not very confident about:
* Duplicate each existing constructor in AbstractMacro and add a 'category'
parameter.
* Make AbstractMacroDescriptor constructor accept a 'category' parameter.
* Duplicate each existing constructor in DefaultMacroDescriptor and add a
'category' parameter.
If a macro author does not specify a default category, the "Other" category
will be used.
* Introduce the MacroCategoriesManager component with following methods:
List<String> getMacroCategories()
List<String> getMacroNames(String category)
List<String> getMacroNames(String category, Syntax syntax)
Each of these methods will give priority to admin configured macro
categories. That is they will discard MacroDescriptor::getDefaultCategory()
return value if the wiki admin has configured a different category for a
given macro.
* A macro category can be overwritten by specifying the configuration
parameter "org.xwiki.rendering.macro.<macro_name>.category" using xwiki's
configuration mechanism (Ex. xwiki.properties).
This is my initial design idea, please let me know what you think.
Thanks.
- Asiri
Hi all,
This is about implementing back-end support for macro categories. My
understanding of macro categories and it's implementation is bit vague at
this point, hopefully this email will set things straight.
To understand the usefulness of macro categories, have a look at confluence
macro browser:
http://confluence.atlassian.com/display/DOC/Working+with+the+Macro+Browser
We can identify several categories by looking at confluence but XWiki will
need several other categories as well. I can think of few XWiki macro
categories:
* Presentation - Macros that allow presenting document content with various
styles. Like box & code macros
* Document content - Macros that add stuff into a wiki page, like image,
video & office macros.
* Scripting - HTML, Velocity, Groovy, Ruby etc.
* Visualization / Reporting - Chart macro and the like.
* External content - Macros that fetch content from external sources. Like
Rss macro.
* Development - Macros in development / introductory stage.
I'm pretty sure there are more categories to consider (please list them).
Now for the real questions that are troubling me:
* Should these categories be statically defined inside the rendering module?
This would mean that the macro author gets to select which category his
macro belogs to, which in turn means we should have a method like:
MacroCategory getCategory() inside the Macro interface. Using this
information MacroManager will present different macro categories to the
outside world.
* The other approach is to keep this categorization inside some wiki pages
and allow administrators to manipulate it: Create / Edit categories, assign
macros to categories etc. I'm not sure what problems this would create when
implementing macro browser though.
* Another (very hackish) approach would be to use the component role hint in
the same fashion it is used to specify macros for different syntaxes.
I think this is enough to get the discussion started.
Thank you very much for your input.
- Asiri