Hi devs,
We need to define a strategy for better handling translations. I've
had a call with Guillaume and Jean-Vincent and here's the process we'd
like to propose:
* One person is in charge of http://l10n.xwiki.org/. This means
monitoring the work there, coordinating validation of key values and
ensuring validated translations are incorporated in the source tree.
Guillaume is willing to take that role for now.
* The XE release manager has the responsibility of taking the
validated keys on l10n.xwiki.org and committing them during the
Milestone 2 dev (before the RC1).
* The l10n manager should ping the release manager whenever there are
translated and validated keys ready to be incorporated or if there
have been important changes to be included in the release after M2 has
been released.
* The l10n manager should test XE and the applications after the keys
have been applied to ensure quality. Basically the l10n manager is
responsible for the quality of translations in general.
Here's my +1
Thanks
-Vincent
Hi devs,
We need to decide what to do with html macro content (or any other
RawBlock content) in plain text renderer.
For me the rule of plain text renderer should be to print anything we
are able to print which mean printing any pure text content and skip
styles for which obviously we don't have syntax. RawBlock content is
pure text so we should print it.
Note that first version of plain text renderer was printing html
content and it was lost when introducing RawBlock.
Here is my +1 for printing RawBlock content in plain text renderer.
WDYT ?
--
Thomas Mortagne
Hello,
I am working on creating blog entries using xwiki. I was wondering if it would be possible to create a template for the blog entries so that they will be more structured?
Thank you for your time and help!
Hande Aksac
Hi,
Since I'm rewriting the new Rendering component
(see http://dev.xwiki.org/xwiki/bin/view/Design/NewRenderingArchitecture)
, we need to finalize the new syntax we want to have.
Right now I'v planned to use the same wiki syntax as now
(http://platform.xwiki.org/xwiki/bin/view/Main/
XWikiSyntax#HTextStyles) with only one change: all macros now need to
be closed.
For example: {macro}...{/macro} and {macro:text|param=value|.../}
Is that ok with everyone or do we want to make changes?
Thanks
-Vincent
Hello XWiki developers,
can someone explain me what is the strategy to define the mime-type of
an attachment?
I see not configurable map nor any setter on the attachment types.
Is there any way I can enrich this or is it simply taking over the
mime-type provided the browser (which, too often, ends up being
application/octet-stream) ?
thanks in advance
paul
In
http://code.xwiki.org/xwiki/bin/view/Snippets/DisplayFormatedCodeAttachment…
> VincentMassol | 2009/05/05 20:03
>
>> Niels, no there's no plan but we can now support any language using macros
> so feel free to provide a clojure macro if you're interested. Shouldn't be
> too hard to do, especially if there's a JSR-223 implementation (in which
> case simply dropping the jar in WEB-INF/lib should be enough - you'd then
> use it using the script macro).
Clojure <http://groups.google.com/group/clojure> has aJSR-223 implementation
according to:
http://github.com/pmf/clojure-jsr223/tree/masterhttp://groovy.codehaus.org/JSR-223+access+to+other+JVM+languageshttp://sayspy.blogspot.com/2009/03/interacting-between-jvm-lang-here-and.ht…
Are there any examples, documentation, or suggestions of writing a "script
macro" to call a new jar in WEB-INF/lib ?
Any other special magic I should know? Does anything from the above suggest
that Clojure couldn't be used as an Xwiki scripting language, replacing
cases where Groovy scripting might normally be employed?
Niels
http://nielsmayer.com
PS: Here's examples of easy "scripted java" programming you can do in
Clojure (note the helpful parallelism constructs):
http://travis-whitton.blogspot.com/2009/07/network-sweeping-with-clojure.ht…http://travis-whitton.blogspot.com/2009/06/clojures-agents-scientists-monke…
It could be very useful to employ massive parallelism via such Clojure
scripts, which could achieve a xwiki-based web portal performance akin to
Yahoo's, Google's, etc. For example, the following describes how Yahoo works
-- and would be quite easy to implement this kind of processing "for free"
in Clojure with very little code:
http://research.yahoo.com/files/pnuts.pdf
The component responsible for multi-record requests is called the
> scatter-gather engine, and is a component of the router.
> The scatter-gather engine receives a multi-record request,
> splits it into multiple individual requests for single records
> or single tablet scans, and initiates those requests in parallel.
> As the requests return success or failure, the scatter-gather
> engine assembles the results and then passes them to the
> client. In our implementation, the engine can begin streaming
> some results back to the client as soon as they appear.
> We chose a server-side approach instead of having the client
> initiate multiple parallel requests for several reasons. First,
> at the TCP/IP layer, it is preferable to have one connection
> per client to the PNUTS service; since there are many clients
> (and many concurrent processes per client machine) opening
> one connection to PNUTS for each record being requested
> in parallel overloads the network stack. Second, placing this
> functionality on the server side allows us to optimize, for
> example by grouping multiple requests to the same storage
> server in the same web service call.
>
> Range queries and table scans are also handled by the
> scatter gather engine. Typically there is only a single client
> process retrieving the results for a query. The scatter gather
> engine will scan only one tablet at a time and return results
> to the client; this is about as fast as a typical client can
> process results. In the case of a range scan, this mecha-
> nism simplifies the process of returning the top-K results
> (a frequently requested feature), since we only need to scan
> enough tablets to provide K results. After returning the
> first set of results, the scatter-gather engine constructs and
> returns a continuation object, which allows the client to re-
> trieve the next set of results. The continuation object con-
> tains a modified range query, which, when executed, restarts
> the range scan at the point the previous results left off. Con-
> tinuation objects allow us to have cursor state on the client
> side rather than the server. In a shared service such as
> PNUTS, it is essential to minimize the amount of server-
> side state we have to manage on behalf of clients.
>
On Thu, Jun 25, 2009 at 9:44 PM, Asiri Rathnayake <
asiri.rathnayake(a)gmail.com> wrote:
> Hi,
>
> On Thu, Jun 25, 2009 at 11:53 PM, Niels Mayer <nielsmayer(a)gmail.com>
> wrote:
>
> > Another interesting advanced JS data-visualization toolkit that would be
> > useful to integrate in Xwiki.
> >
> > http://vis.stanford.edu/protovis/
> > http://www.technologyreview.com/computing/22927/?nlid=2130
> > http://flare.prefuse.org/launch/apps/job_voyager
>
> Protovis sounds cool, but the way xwiki macros work will make it difficult
> (or messy) to implement a macro that will have to depend on a JS library.
> What we can do is this:
>
> * Implement the wiki-macro bridge:
> http://jira.xwiki.org/jira/browse/XWIKI-3213 (Basically this will allow
> you
> to convert any wiki content into your personal macro) - I'll finish this in
> a week or so.
>
> * We use a JSX (?) to get protovis support.
>
> * Neils can implement a js charting wiki-macro using protovis ;)
>
> I want to ask other developers, Is this possible? (I have a confusion about
> macros + js working together)
I have Macros/JS working together all the time, using JSX. I'm certain it's
possible, given the kinds of integration I've been able to do in
Exhibit&Xwiki, e.g. http://nielsmayer.com/xwiki/bin/view/Exhibit/NPRpods3
...
Here's a simple example, which are tests for my Xwiki integration of
http://www.longtailvideo.com/players/jw-flv-player/ which is the media
player used in the NPRpods3 application above:
http://nielsmayer.com/xwiki/bin/view/Macros/JWPlayer?viewer=codehttp://nielsmayer.com/xwiki/bin/view/Macros/JWPlayerJSPL_Test
(xwiki integration of
http://home5.inet.tele.dk/nyboe/flash/mediaplayer4/JW_API_xmpl_5-2-4-0.html
with an improvement, the JWplayer example doesn't work on Linux/Firefox,
mine does!)
http://nielsmayer.com/xwiki/bin/view/Macros/JWPlayerJSPL_Test?viewer=code
(wiki-code for above)
http://nielsmayer.com/xwiki/bin/jsx/Macros/JWPlayerJSPL_Test
(the javascript playlist from XWiki.JavaScriptExtension[0])
##
## Load and initialize LoadJS: defines injectJS(url) required by JWPlayer
##
#includeMacros("Macros.LoadJS")##
#loadjs_xwiki_init()##
##
## Load and initialize JWPlayer after LoadJS.
##
#includeMacros("Macros.JWPlayer")##
#jwplayer_xwiki_init()##
##
## Load JavaScript playlist from object XWiki.JavaScriptExtension[0] into
## js variable jwplayer_jspl, used below in parameter to
jwplayer_embed_generic()
## function(jwpl){jwpl.sendEvent(’LOAD’, jwplayer_jspl);}. This function
called
## by jwplayer’s playerReady() calback when player has been instantiated,
and
## causes the javascript-based playlist to get loaded.
##
$xwiki.jsx.use("$doc.fullName")##
...
#set( $jw_name = "$doc.name" )##
#set( $jw_player = "jwplayer_embed_generic(’$jw_name’, ’mpl’,
’&autostart=false&playlist=right&playlistsize=250&shuffle=false&repeat=always’,
function(jwpl){jwpl.sendEvent(’LOAD’, jwplayer_jspl);}, ’100%’, ’385px’);"
)##
#jwplayer_create("$jw_name", "$jw_player")##
http://nielsmayer.com/xwiki/bin/view/Macros/JWPlayerPL_Test is another test
using playlists.
This also calls JS jwplayer_embed_generic(), but with an external file,
passed as URL/string, instead of creating the playlist in lambda-function as
above. (
http://nielsmayer.com/xwiki/bin/view/Macros/JWPlayerPL_Test?viewer=code ):
#set( $jw_player = "jwplayer_embed_generic(’$jw_name’, ’mpl’,
’&autostart=false&playlist=right&playlistsize=250&shuffle=false&repeat=always’,
’/xwiki/bin/view/Macros/JWPlayer_PlayList?xpage=plain’, ’100%’, ’385px’);"
)##
JS functions jwplayer_embed(), jwplayer_embed_generic() and macros
#jwplayer_xwiki_init(), #jwplayer_create() are from
http://nielsmayer.com/xwiki/bin/view/Macros/JWPlayer?viewer=code
---
Going in "the other direction", here's an example of using velocity to
compute results returned by Javascript:
http://svn.xwiki.org/svnroot/xwiki/curriki/branches/curriki-1.8/web/src/mai…
#set( $total_attachments_size = 0 ) ## javascript:getAttachmentsSize()
#set( $total_attachments_names = [] ) ## javascript:getAttachmentsNames()
#foreach ($attach in $doc.attachmentList) ## {
#set( $ok = $total_attachments_names.add("'${attach.filename}'") )
## append attachment filename to ArrayList
#set( $total_attachments_size = ${total_attachments_size} +
${attach.getFilesize()} ) ## compute total size of atttachments
#end ## } -- foreach
...
function getAttachmentsNames() { return (${total_attachments_names}); }
function getAttachmentsSize() { return (${total_attachments_size}); }
...
lpattachments is called from an iframe. The parent document accesses the
iframe'd document's javascript functions like this: (
http://svn.xwiki.org/svnroot/xwiki/curriki/branches/curriki-1.8/wiki/src/ma…
)
//
// get size of files in attachments iframe
//
function getAttachmentsSize() {
return (window.frames['attachment_iframe'].getAttachmentsSize());
}
//
// retrieve ArrayList of filenames contained in attachment
//
function getAttachmentsNames() {
return (window.frames['attachment_iframe'].getAttachmentsNames());
}
-- Niels
http://nielsmayer.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