Added: wicket/common/site/branches/meet/buzz.md URL: http://svn.apache.org/viewvc/wicket/common/site/branches/meet/buzz.md?rev=966008&view=auto ============================================================================== --- wicket/common/site/branches/meet/buzz.md (added) +++ wicket/common/site/branches/meet/buzz.md Tue Jul 20 20:57:09 2010 @@ -0,0 +1,154 @@ +--- +layout: default +title: Wicket Buzz +--- + +Wicket has appeared in the press in a variety of industry trade magazines, +including Network World, ComputerWorld, IT World and Information Week. +Presentations on Wicket have been delivered by Wicket team members at JavaOne +in San Francisco, Javapolis and TheServerSide Java Symposium in Europe. The +following are quotes from reviewers and users of Wicket: + +> After working with JSF for almost a year, trying Wicket was like that +> movie scene where the clouds part and this big ray of light hits you +> in the face. I just had this feeling while JSF'ing that certain things +> were harder than they needed to be. Well, I was right, and the Wicket +> people figured it out. +> +> [Kevin Galligan](http://bigheadco.blogspot.com/2007/03/groovy-wicket.html) + +> Wicket (currently undergoing incubation with Apache) is a good +> example of a web framework which throws caution to the wind, and has +> absolutely no XML needed. We here at Mystic have a lot of love for +> Wicket and are actively developing several projects with it currently. +> +> [Mystic Coders](http://www.mysticcoders.com/blog/2007/03/13/the-rise-of-the-xml-backlash/) + + +> Writing a Wicket app is rather more like writing an event-based +> desktop application than a web application. +> +> [LShift](http://www.lshift.net/blog/2006/07/06/wicket) + +> "Wickedly Cool" - I actually managed to whip together a Wicket +> Application in a few days. It is entertaining to work with, adding +> shiny stuff is really easy while you can develop Java code and keep +> those last bits of hair you have saved for ripping out in a CSS +> nightmare that you hopefully after finding Wicket will not have to +> deal with. So I'd go out on a limb and say that Wicket == Rogaine for +> developers. +> +> [Joed](http://blogs.opennms.org/joed/?p=3) + +> "So is Wicket the one true MVC framework that a lot of us have been +> hunting for? At the moment, I tend to think so. [...] If you like Java +> you will really like Wicket." +> +> [Peter Thomas](http://ptrthomas.wordpress.com/2007/03/02/wicket-impressions-moving-from-spring-mvc-webflow/) + +> "I think its an awesome way to deal with this whole web UI framework +> mess. I am happy to see someone take a simple and clean approach to +> the whole problem, and come up with a transparent POJO solution. I +> like the direction the framework is going... Wicket is clean, simple +> and elegant." +> +> Comment on TheServerSide.com + +> "Last week I wrote an article about Wicket and I spent some time +> discovering and taming it. And I have to confess this: I love it. ... +> snip ... Wicket is not a framework, it's a candy bar. And everybody +> loves candy bars..." +> +> Comment made by Romain Guy + +> The issue that impressed me in the Wicket model is that "Wicket does +> not mix markup with Java code and adds no special syntax to your +> markup files." You reference Wicket identities as HTML attributes +> and define component properties in Java, which allows designers and +> programmers to work independently (within the obvious constraint of +> having common goals). There is no need for special tools. +> +> From a Network World editorial entitled "Nothing Sticky about Wicket" + +> In a recent blog post I asked for feedback on what Web frameworks +> folks are using. Well, I got quite a surprise: Wicket was the most +> often recommended framework in reader emails! +> +> From an About.com article entitled And the Winner is...Wicket + +> "I have used Wicket since last Fall for personal projects. I have 3 +> kids and a wife so my free-time is very limited. Given that, I had to +> be very picky about which framework I chose. I've been very impressed +> with how little hassle it has been to start creating powerful, +> reusable components and pages with Wicket even under rather severe +> time constraints." +> +> Comment on TheServerSide.com + +> "...after using web MVC frameworks for a couple of years, building +> ever more complex web applications, I moved to component based +> frameworks. Of these, I think Wicket is by far the best..." +> +> Comment on Manageability.org + +> "... Talk about a mind blowing experience, it literally took me ten +> minutes to have a sample application up and running! The Wicket API is +> very Swing like, which was a welcome change for me, and allowed for a +> very familiar development experience. There is even an extension that +> allows for direct use of a Swing TreeModel. There are so many things +> that I like about this framework ..." +> +> From a blog item by the Code Poet + +> "Wicket has a learning flat." +> +> Al Maw + +> JSF is Cool and young but Wicket is younger and even cooler. Have +> you tried wicket?. I am also building a large CRUD application for +> Job Exchange System in my country using Wicket + JPA + Stateless +> EJB3 + Glassfish (the latest promoted build of glassfish) and we are +> currently in testing phase and I am not having any serious headaches +> as things seems to be under control. All our forms are Ajax. We have +> several concurrent accesses and system is stable. I believe greatly in +> the Wicket Project especially for CRUD cases. +> +> [Dabar Aladejebi](http://www.javalobby.org/java/forums/t90719.html#92132195) + +> "focuses the development efforts in the right place, inside plain Java +> code" !! This was the winning ticket for me. The framework is truly +> amazing. I used ever dang framework in the book and can say that I'm +> most impressed with this one. +> +> [Anonymous on JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html)-- [Anonymous on JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html) + +> Shocking simplicity. Back to the roots. Thanks. +> +> [joozsa on JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html) + +> Wicket as far as I am concerned is the way forward for web development +> in Java. A lot of creativity involved though especially with the loops +> but It makes Web Development so much fun. +> +> [Anonymous on JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html) + +> "Wicket became my favorite framework in about a 24-hour period, and +> I think it has a very bright future. With most frameworks I see +> limitations, with Wicket I see possibilities. There's your platitude +> for the day :)" +> +> wicket-user mailing list + +> "Count me in... I've only been using Wicket for maybe 2 weeks or so, +> and I'm sold." +> +> Phillip Rhodes + +> Once I grasped the essence of Wicket, everything just started working +> so well. Damn you, Wicket, I said under my breath. I was really +> disappointed that I liked it so much. Damn you Wicket! Suddenly I +> loved all those Wicket developers, because I understood what they +> were trying to say. Web development can be simple, yet have unlimited +> power. +> +> Closet Wicket lover
Added: wicket/common/site/branches/meet/features.md URL: http://svn.apache.org/viewvc/wicket/common/site/branches/meet/features.md?rev=966008&view=auto ============================================================================== --- wicket/common/site/branches/meet/features.md (added) +++ wicket/common/site/branches/meet/features.md Tue Jul 20 20:57:09 2010 @@ -0,0 +1,119 @@ +--- +layout: default +title: Features +--- +## Swing-like OO Component Model + +Pages and Components in Wicket are real Java objects that support +encapsulation, inheritance and events. + +## Ease of Development + +Because Wicket is Java and HTML, you can leverage what you know about Java or +your favorite HTML editor to write Wicket applications. + +## Separation of Concerns + +Wicket does not mix markup with Java code and adds no special syntax to your +markup files. The worlds of HTML and Java are parallel and associated only by +Wicket ids, which are attributes in HTML and Component properties in Java. +Since Wicket HTML is just HTML and Wicket Java is just Java, coders and +designers can work independently to a large degree and without relying on any +special tools. + +## Secure + +Wicket is secure by default. URLs do not expose sensitive information and all +component paths are session-relative. Explicit steps must be taken to share +information between sessions. There are plans for the next version of Wicket +to add URL encryption to support highly secure web sites. + +## Transparent, Scalable Clustering Support + +All Wicket applications will work on a cluster automatically and without +additional work. Once bottlenecks are understood, Wicket enables tuning of +page state replication. The next version of Wicket will support client-side +models for zero-state scalability. + +## Transparent Back Button Support + +Wicket supports configurable page version management. When users submit a +form or follow a link from a page they accessed with the back button in their +browser, Wicket is able to revert the page object to the state it was in when +the page was originally rendered. This means you can write web applications +that support the back button with very little work. + +## Reusable Components + +Reusable components in Wicket are particularly easy to create. Not only can +you extend existing components with the Java extends keyword, but you can +also create Panel components which associate a group of components as a +reusable unit. + +## Simple, Flexible, Localizable Form Validation + +It is trivial to write and use validators in Wicket. It is also quite easy to +customize and localize the display and content of validation error messages. + +## Typesafe Sessions + +Wicket eliminates the need to manage HttpSession attributes by hand. Page and +component objects are transparently stored in the session and your +application can create a custom session subclass with typesafe properties as +well. All objects stored in the session can automatically participate in +clustering replication. + +## Factory Customizable + +Wicket is very extensible. Most operations are customizable through factories +or factory methods. + +## Detachable Models + +Model objects in Wicket can be very lightweight in terms of memory and +network use in a cluster. When a model is used, it can "attach", populating +itself with information from persistent storage. When the model is no longer +in use, transient information can be reset, reducing the size of the object. + +## Border Components + +Wicket Border components enable the decoration of pages in a reusable +fashion. This is especially useful for inheritance of common navigational +structures or layout. + +## Support for All Basic HTML Features + +Wicket supports image tags, links, forms and everything else that you're used +to using in your web application development. + +## Programmatic Manipulation of Attributes + +Wicket Components can programmatically change any HTML tag attribute. + +## Automatic Conversions + +Once a Form validates, the model can be updated using Wicket converters. Most +ordinary conversions are built-in and it is easy to write new converters. + +## Dynamic Images + +Wicket makes image use, sharing and generation very easy. Dynamic images can +be created by simply implementing a paint method. + +## Pageable ListView + +ListViews in Wicket are extremely powerful. You can nest any kind of +component in a ListView row, even other ListViews. PageableListView supports +navigation links for large lists. + +## Tree Component + +Out of the box tree component for navigating and selecting nodes. + +## Localization + +HTML pages, images and resource strings can all be localized. + +## Examples + +Wicket has numerous examples showcasing all of the above features. Added: wicket/common/site/branches/meet/index.md URL: http://svn.apache.org/viewvc/wicket/common/site/branches/meet/index.md?rev=966008&view=auto ============================================================================== --- wicket/common/site/branches/meet/index.md (added) +++ wicket/common/site/branches/meet/index.md Tue Jul 20 20:57:09 2010 @@ -0,0 +1,4 @@ +--- +layout: default +title: Meet Apache Wicket +--- Added: wicket/common/site/branches/meet/introduction.md URL: http://svn.apache.org/viewvc/wicket/common/site/branches/meet/introduction.md?rev=966008&view=auto ============================================================================== --- wicket/common/site/branches/meet/introduction.md (added) +++ wicket/common/site/branches/meet/introduction.md Tue Jul 20 20:57:09 2010 @@ -0,0 +1,296 @@ +--- +layout: default +title: Meet Apache Wicket +--- +By Jonathan Locke, original author of Wicket + +## Why Wicket? + +If you are looking to do web application programming in Java, you have a very +large number of choices these days. In fact, there are so many web +application frameworks now that it has become somewhat of a joke. One blog +site on the Internet poses the question: How many Java web frameworks can you +name? The answer they show looks like this: + +## Frameworks, Frameworks Everywhere + +<TABLE class="confluenceTable"><TBODY> +<TR> +<TD class="confluenceTd">Echo</TD> +<TD class="confluenceTd">Cocoon</TD> +<TD class="confluenceTd">Millstone</TD> +<TD class="confluenceTd">OXF</TD> +</TR> +<TR> +<TD class="confluenceTd">Struts</TD> +<TD class="confluenceTd">SOFIA</TD> +<TD class="confluenceTd">Tapestry</TD> +<TD class="confluenceTd">WebWork</TD> +</TR> +<TR> +<TD class="confluenceTd">RIFE</TD> +<TD class="confluenceTd">Spring MVC</TD> +<TD class="confluenceTd">Canyamo</TD> +<TD class="confluenceTd">Maverick</TD> +</TR> +<TR> +<TD class="confluenceTd">JPublish</TD> +<TD class="confluenceTd">JATO</TD> +<TD class="confluenceTd">Folium</TD> +<TD class="confluenceTd">Jucas</TD> +</TR> +<TR> +<TD class="confluenceTd">Verge</TD> +<TD class="confluenceTd">Niggle</TD> +<TD class="confluenceTd">Bishop</TD> +<TD class="confluenceTd">Barracuda</TD> +</TR> +<TR> +<TD class="confluenceTd">Action Framework</TD> +<TD class="confluenceTd">Shocks</TD> +<TD class="confluenceTd">TeaServlet</TD> +<TD class="confluenceTd">wingS</TD> +</TR> +<TR> +<TD class="confluenceTd">Expresso</TD> +<TD class="confluenceTd">Bento</TD> +<TD class="confluenceTd">jStatemachine</TD> +<TD class="confluenceTd">jZonic</TD> +</TR> +<TR> +<TD class="confluenceTd">OpenEmcee</TD> +<TD class="confluenceTd">Turbine</TD> +<TD class="confluenceTd">Scope</TD> +<TD class="confluenceTd">Warfare</TD> +</TR> +<TR> +<TD class="confluenceTd">JWAA</TD> +<TD class="confluenceTd">Jaffa</TD> +<TD class="confluenceTd">Jacquard</TD> +<TD class="confluenceTd">Macaw</TD> +</TR> +<TR> +<TD class="confluenceTd">Smile</TD> +<TD class="confluenceTd">MyFaces</TD> +<TD class="confluenceTd">Chiba</TD> +<TD class="confluenceTd">JBanana</TD> +</TR> +<TR> +<TD class="confluenceTd">Jeenius</TD> +<TD class="confluenceTd">JWarp</TD> +<TD class="confluenceTd">Genie</TD> +<TD class="confluenceTd">Melati</TD> +</TR> +<TR> +<TD class="confluenceTd">Dovetail</TD> +<TD class="confluenceTd">Cameleon</TD> +<TD class="confluenceTd">JFormular</TD> +<TD class="confluenceTd">Xoplon</TD> +</TR> +<TR> +<TD class="confluenceTd">Japple</TD> +<TD class="confluenceTd">Helma</TD> +<TD class="confluenceTd">Dinamica</TD> +<TD class="confluenceTd">WebOnSwing</TD> +</TR> +<TR> +<TD class="confluenceTd">Nacho</TD> +<TD class="confluenceTd">Cassandra</TD> +<TD class="confluenceTd">Baritus</TD> +<TD class="confluenceTd">Stripes</TD> +</TR> +<TR> +<TD class="confluenceTd">Click</TD> +<TD class="confluenceTd">GWT</TD> +<TD class="confluenceTd"> </TD> +<TD class="confluenceTd"> </TD> +</TR> +</TBODY></TABLE> + + +## Why "Reinvent the Wheel"? + +In light of this, you may be wondering "What good is another web application +framework?" Indeed. Why "re-invent the wheel?" One snappy comeback to that +old saw is: because this time we could make it rounder! + +But it was not simply a desire for higher quality that drove the creation of +Wicket. Even with so many options, there really is no web toolkit which fills +exactly the niche that Wicket fills. In fact, Wicket is quite unlike each of +the frameworks above. + +Wicket's closest cousins are probably Tapestry and Echo, but even there the +likeness is very shallow. Like Tapestry, Wicket uses a special HTML attribute +to denote components, enabling easy editing with ordinary HTML editors. Like +Echo, Wicket has a first-class component model. But Wicket applications are +not like applications written in either Tapestry or Echo, because in Wicket +you get the best of both worlds. You get the benefits of a first-class +component model and a non-intrusive approach to HTML. In many situations, +this combination may prove to be a significant development advantage. + +To understand why Wicket is so different, it may help to understand the +motivations that created it. + +## Motivations + +### Most existing web frameworks provide weak to non-existent support in managing server-side state ### + +This normally means lots of ad-hoc code in web applications dealing with the +gory mechanics of state management. While Wicket will not allow you to stop +thinking about server state, it goes a long ways towards making it easy and +often transparent to manage that state. + +In Wicket, all server side state is automatically managed. You will never +directly use an HttpSession object or similar wrapper to store state. +Instead, state is associated with components. Each server-side page component +holds a nested hierarchy of stateful components, where each component's model +is, in the end, a POJO (Plain Old Java Object). Wicket maintains a map of +these pages in each user's session. One purpose of this page map (and the +component hierarchy on each page) is to allow the framework to hide all +details of how your components and models are accessed. You deal with simple, +familiar Java objects and Wicket deals with things like URLs, session ids and +GET/POST requests. + +You will also find that this well-structured server state makes it very easy +to deal with the dreaded "back button problem". In fact, Wicket has a generic +and robust solution which can identify and expire browser-cached pages that +have become stale due to structural changes to the model of a component on +the page. + +Finally, Wicket has been designed to work with POJO persistence frameworks +such as JDO or Hibernate. This can make database driven web applications +quite easy to write. + +For many applications, it will be worth trading off the increased server load +of extra server-side state for decreased development costs, lower maintenance +costs, quicker time-to-market and generally higher quality software. The +basic observation here is that software is expensive and complex while +servers from companies like E-machines and Dell are relatively dirt cheap. + +In terms of efficiency versus productivity, perhaps Wicket is to JSP as Java +is to C. You can accomplish anything in Wicket in JSP. You may even do it +more efficiently in terms of memory or processor consumption. But it may take +you weeks or months longer to develop your application. And in the end, since +state management in JSP is ad-hoc, you are likely find security problems and +bugs popping up everywhere. Most of the other frameworks above will do only a +little more to help you. + +### Most existing frameworks require special HTML code + +JSP is by far the worst offender, allowing the embedding of Java code +directly in web pages, but to some degree almost all of the frameworks from +the list (except Tapestry) above introduce some kind of special syntax to +your HTML code. + +Special syntax is highly undesirable because it changes the nature of HTML +from the kind of pure-and-simple HTML markup that web designers are familiar +with, to some kind of special HTML. This special HTML can be more difficult +to preview, edit and understand. + +Wicket does not introduce any special syntax to HTML. Instead, it extends +HTML in a standards-compliant way via a Wicket namespace that is fully +compliant with the XHTML standard. This means that you can use Macromedia +Dreamweaver, Microsoft Front Page, Word, Adobe Go Live, or any other existing +HTML editor to work on your web pages and Wicket components. To accomplish +this, Wicket consistently uses a single id attribute in the Wicket namespace +("wicket:id") to mark HTML tags that should receive special treatment by the +toolkit. If you prefer not to render Wicket namespaced tags and attributes to +your end-users, Wicket has a simple setting to strip them all out, resulting +in ordinary, standards-compliant HTML. + +No "special sauce" in your HTML means designers can mock up pages that you +can use directly in development. Adding Java components to the HTML is as +simple as setting the component name attribute. And you can then give the +HTML back to your web designers knowing that they can change it with +confidence. + +Wicket, more than any other framework gives you a separation of concerns. Web +designers can work on the HTML with very little knowledge of the application +code (they cannot remove the component name tags and they cannot arbitrarily +change the nesting of components, but anything else goes). Likewise, coders +can work on the Java components that attach to the HTML without concerning +themselves with what a given page looks like. By not stepping on each other's +toes, everyone can get more work done. + +### Existing frameworks are not easy + +Most of the existing toolkits have poorly defined or non-existent object +models. In some cases, the model is defined using special XML syntaxes. The +syntaxes may be so cumbersome that special tools are required to manipulate +all the configuration information. Since these toolkits are not simple Java +libraries you may or may not be able to use your favorite IDE tools such as +editors, debuggers and compilers. + +Wicket is all about simplicity. There are no configuration files to learn in +Wicket. Wicket is a simple class library with a consistent approach to +component structure. In Wicket, your web applications will more closely +resemble a Swing application than a JSP application. If you know Java (and +especially if you know Swing), you already know a lot about Wicket. + +### Existing frameworks inhibit reusability + +Tapestry and JSF at least have component models that allow reuse, but you are +likely to find that it is not particularly trivial to do, at least when +compared with Wicket. Wicket has been explicitly designed to make it very, +very easy to create reusable components. It's surprisingly simple to extend +existing components and to make compound components such as a SignInPanel or +AddressForm. It is also relatively easy to create components that exploit new +features of browsers. Components in Wicket can be packaged up in JAR files +and reused by simply dropping them in your lib folder - no configuration +necessary! + +### Web programming should be fun! + +This is my most personal goal for writing Wicket . None of the existing +frameworks are appealing to me in terms of intuitiveness, quickness, ease of +development, etc. It is my hope that Wicket represents a significant step in +the direction of making web applications easy and fun to write. + +## Goals + +Coming from these motivations, the following goals for Wicket emerged: + +* EASY (SIMPLE / CONSISTENT / OBVIOUS) + * POJO-centric + * All code written in Java ala Swing + * Minimize "conceptual surface area" + * Avoid overuse of XML configuration files + * Fully solve back button problem + * Easy to create bookmarkable pages + * Maximum type safety and compile-time problem diagnosis + * Maximum diagnosis of run-time problems + * Minimum reliance on special tools + * Components, containers and conventions should be consistent + +* REUSABLE + * Components written in Wicket should be fully reusable + * Reusable components should be easily distributed in ordinary JAR files + +* NON-INTRUSIVE + * HTML or other markup not polluted with programming semantics + * Only one simple tagging construct in markup + * Compatible with any ordinary HTML editor + * Easy for graphics designers to recognize and avoid framework tagging + * Easy to add tagging back to HTML if designers accidentally remove it + +* SAFE + * Code is secure by default + * Only explicitly bookmarkable links can expose state in the page or URL + * All logic in Java with maximum type safety + * Easy to integrate with Java security + +* EFFICIENT / SCALABLE + * Efficient and lightweight, but not at the expense of other goals + * Clustering through sticky sessions preferred + * Clustering via session replication is easy to accomplish and easy to tune by working with detachable models. + +* COMPLETE + + * The Wicket team is committed to deliver a feature complete, ready-to-use + framework for developing Java web applications. The core framework was + written and contributed by the author of this introduction, Jonathan + Locke. The current team consists of a group of experienced programmers, + some of which were active on some of the other frameworks stated above, + and all of which have extensive experience building large scale Java web + applications. We eat our own dogfood, and will thus work on Wicket from a + framework user's perspective. Added: wicket/common/site/branches/meet/vision.md URL: http://svn.apache.org/viewvc/wicket/common/site/branches/meet/vision.md?rev=966008&view=auto ============================================================================== --- wicket/common/site/branches/meet/vision.md (added) +++ wicket/common/site/branches/meet/vision.md Tue Jul 20 20:57:09 2010 @@ -0,0 +1,60 @@ +--- +layout: default +title: The Wicket Vision +--- + +Designing and implementing any framework for use in the real world inevitably +involves compromises and some degree of complexity, and Wicket is no +exception. However, I believe you will find that Wicket is quite compact, +focused and powerful as a framework. If Wicket has these characteristics, it +is because it was designed to solve one very specific problem well: + +> enabling component-oriented, programmatic manipulation of markup + +Wicket does this and very little else, and that is a good thing. + +I once heard Josh Bloch talk about the power to weight ratio of an API. The +highest compliment anyone could make of Wicket would be to suggest that +Wicket has a lot of power and not much conceptual surface area. + +In art, negative space is the part that's not the subject. In music, negative +space is the rest. In software, negative space is all the code that you +managed to avoid writing. In all three disciplines, it's what separates what +is truly excellent from what is merely good. + +Following this metaphor, if Wicket is our foreground object, it is defined in +a negative sense by all the things that it is not (by the background). + +In other words, ideally, Wicket is a web UI framework that delegates as many +areas of responsibility as possible to other, more focused tools and +techniques. It recognizes that Hibernate is good at persistence; that OGNL is +good at string formatting; that Java properties files are good for +localization; that sub-classing is good for creating component types; that +Dreamweaver is good at doing HTML layout; that Beans are good for structuring +properties; and so on. + +The more ways that Wicket can find to offload responsibilities (both now and +in the future), the less it will be. And thus, the more it will be. + +The difficulty moving forward with Wicket will be balancing all the +day-to-day needs people are going to be bringing up with this overall vision +of minimalism. There ultimately will be compromises, and the "trick" to +making the right compromises is simply to agonize over all the options for a +long time and then to only make the compromises that everyone agrees are +really essential to what Wicket needs to be and do. + +A big part of this process of agonizing is to act like doctors and "first, do +no harm". If some issue isn't sitting well with everyone yet, there's +probably a reason for that. So, maybe the near-term solution is to simply do +nothing and let people use the existing functionality until the limits to +that approach (as well as competing ideas) are better understood. + +It's easy to add features. It's often impossible to change or remove them. + +Given this, the Wicket approach to the overall problem of evolving while +keeping a high power to weight ratio will be partitioning off all +controversial new ideas in a "contrib" package until they are broadly +accepted. This way people can experiment and code away and check in lots of +stuff without affecting the main codebase with untested ideas. Then, when +ideas in contrib pan out to everyone's satisfaction, the lead(s) of the +project will move them into the core. \ No newline at end of file Added: wicket/common/site/branches/readme.md URL: http://svn.apache.org/viewvc/wicket/common/site/branches/readme.md?rev=966008&view=auto ============================================================================== --- wicket/common/site/branches/readme.md (added) +++ wicket/common/site/branches/readme.md Tue Jul 20 20:57:09 2010 @@ -0,0 +1,24 @@ +Wicket Site +=========== + +This is a project for tracking a new design for the Apache Wicket website. The +site is generated to static html using +[jekyll](http://github.com/mojombo/jekyll). + +If you want to see how it might look in the future, see the file +[wicketsite5.pdf](http://github.com/dashorst/wicket-site/raw/master/_design/wicketsite5.pdf +"Design document") + +If you want to see how it looks now, see the [generated +markup](http://github.com/dashorst/wicket-site/raw/master/_site/index.html). + +Running the site +---------------- + +Use (after installing jekyll) the following command to run jekyll in a server +mode: + + $ jekyll --auto --server + +This instructs jekyll to generate new output whenever something changes on +the filesystem, and serve those files to the default port (4000) on your box. Added: wicket/common/site/branches/start/download.md URL: http://svn.apache.org/viewvc/wicket/common/site/branches/start/download.md?rev=966008&view=auto ============================================================================== --- wicket/common/site/branches/start/download.md (added) +++ wicket/common/site/branches/start/download.md Tue Jul 20 20:57:09 2010 @@ -0,0 +1,83 @@ +--- +layout: default +title: Download Wicket releases +--- + +Apache Wicket {{site.wicket.version}} is the current stable release. + +## Download + +New projects should use [Wicket {{site.wicket.version}}](http://www.apache.org/dyn/closer.cgi/wicket/{{site.wicket.version}}) as their base. + +* **Latest stable release**: [{{site.wicket.version}}](http://www.apache.org/dyn/closer.cgi/wicket/{{site.wicket.version}}) +* **Last 1.3.x release**: [1.3.7](http://archive.apache.org/dist/wicket/1.3.7) +* **Archived releases**: <http://archive.apache.org/dist/wicket> + +We recommend you [start](quickstart.html) with our latest 1.4 release. If you +are migrating an existing application from Wicket 1.3 to 1.4, you may find +the [migration guide|http://cwiki.apache.org/WICKET/migrate-14.html] +invaluable. + +**Apache Wicket 1.4.x lines require JDK 1.5 or newer** + +**Apache Wicket 1.3.x lines require JDK 1.4 or newer**, although there are +some non-core modules which take advantage of JDK 5 features. + +## Important note about logging dependencies for 1.3.0 and later. + +As of Wicket 1.3.0, Wicket uses the [SLF4J](http://www.slf4j.org) project for +logging. SLF4J is similar to +[commons-logging](http://jakarta.apache.org/commons/logging), in that it +allows libraries/frameworks like Wicket to avoid forcing a choice of logging +framework on their users. + +**You cannot use Wicket without adding an SLF4J logging implementation to +your classpath**. Most people use [log4j](http://logging.apache.org/log4j). +If you do, just include **slf4j-log4j12.jar** on your classpath to get Wicket +to use log4j too. If you want to use commons-logging or JDK14 logging or +something else, please see the [SLF4J site](http://www.slf4j.org/faq.html) +for more information. + +## Maven 2 + +Add the following snippet to your Maven project descriptor (`pom.xml`): + +{% highlight xml %} +<dependency> + <groupId>org.apache.wicket</groupId> + <artifactId>wicket</artifactId> + <version>{{site.wicket.version}}</version> +</dependency> +{% endhighlight %} + +For the SLF4J log4j binding: + +{% highlight xml %} +<dependency> + <groupId>org.slf4j</groupId> + <artifactId>slf4j-log4j12</artifactId> + <version>1.5.6</version> +</dependency> +{% endhighlight %} + +## SNAPSHOTs and latest bleeding-edge code ## + +If you wish to build the latest code from scratch, the two branches live in +the following places in Subversion: + +* **1.5.x**: <http://svn.apache.org/repos/asf/wicket/trunk> +* **1.4.x**: <http://svn.apache.org/repos/asf/wicket/branches/wicket-1.4.x> +* **1.3.x**: <http://svn.apache.org/repos/asf/wicket/branches/wicket-1.3.x> +* **1.2.x**: <http://svn.apache.org/repos/asf/wicket/branches/wicket-1.2.x> + +There's also a Maven 2 repository providing SNAPSHOTs available here: + +{% highlight xml %} +<repositories> + <repository> + <id>org.wicketstuff</id> + <name>Wicket Stuff Repository</name> + <url>http://wicketstuff.org/maven/repository</url> + </repository> +</repositories> +{% endhighlight %} Added: wicket/common/site/branches/start/index.md URL: http://svn.apache.org/viewvc/wicket/common/site/branches/start/index.md?rev=966008&view=auto ============================================================================== --- wicket/common/site/branches/start/index.md (added) +++ wicket/common/site/branches/start/index.md Tue Jul 20 20:57:09 2010 @@ -0,0 +1,8 @@ +--- +layout: default +title: Get Started +--- + +* Start with Apache Wicket using the [quickstart](quickstart.html) +* [Download](download.html) the latest and greatest Wicket release +* Or use one of the available third party <a href="http://www.jweekend.com/dev/LegUp"; rel="nofollow">Maven archetypes</a> \ No newline at end of file Added: wicket/common/site/branches/start/installing.md URL: http://svn.apache.org/viewvc/wicket/common/site/branches/start/installing.md?rev=966008&view=auto ============================================================================== --- wicket/common/site/branches/start/installing.md (added) +++ wicket/common/site/branches/start/installing.md Tue Jul 20 20:57:09 2010 @@ -0,0 +1,57 @@ +--- +layout: default +title: Installing Wicket +--- + +So you chose not to use one of the ready to use Maven archetypes, but rather +roll things on your own. While possible, it needs some close attention to +make things work properly. Most notable things you need to take care of are: + +* dependencies +* logging + +## Required dependencies to use Wicket + +While we are adamant users of Apache Maven and its build infrastructure, this +may not be to everyone's liking. However, if you wish to learn all about +which dependencies you need for your Wicket project, we ask you to learn to +read the POM file format and retrieve the required versions stated there. We +take great care to keep the POM files up to date with the latest and greatest +of each dependency. + +### Compilation & Testing ### + +At a minimum a vanilla Wicket application requires for compilation: + +* Java SDK 1.5 or newer +* servlet-api +* slf4j-api +* any slf4j implementation and dependencies necessary for that logging + provider +* junit if you build Wicket from source or want to use `WicketTester` to test + your pages and components + +### Runtime dependencies ### + +At a minimum a barebones Wicket application requires the following at runtime: + +* a servlet container (Apache Tomcat, Jetty) or any JEE container +* Java 5 runtime or newer +* slf4j-api and your slf4j implementation and required logging provider + dependencies. + +## Logging + +As of Wicket 1.3.0, Wicket uses the [SLF4J](http://www.slf4j.org/) project +for logging. SLF4J is similar to +[commons-logging](http://jakarta.apache.org/commons/logging/), in that it +allows libraries/frameworks like Wicket to avoid forcing a choice of logging +framework on their users. + +**You cannot use Wicket without adding an SLF4J logging implementation to +your classpath**. Most people use [log4j](http://logging.apache.org/log4j). +If you do, just include `slf4j-log4j12.jar` on your classpath to get Wicket +to use log4j too. If you want to use commons-logging or JDK14 logging or +something else, please see the [SLF4J site](http://www.slf4j.org/faq.html) +for more information. + Added: wicket/common/site/branches/start/quickstart.md URL: http://svn.apache.org/viewvc/wicket/common/site/branches/start/quickstart.md?rev=966008&view=auto ============================================================================== --- wicket/common/site/branches/start/quickstart.md (added) +++ wicket/common/site/branches/start/quickstart.md Tue Jul 20 20:57:09 2010 @@ -0,0 +1,137 @@ +--- +layout: default +title: Get Started +--- + +This guide is intended to get you up and running & using Wicket within +minutes. + +It uses a Maven Archetype to create a Wicket QuickStart project, so requires +that [Maven 2](http://maven.apache.org) be installed & configured beforehand. + +This project provides a starting point for your Wicket project. If you are +looking for examples, please refer to the *wicket-example* projects instead! + +## Creating the project ## + +To create your project, copy and paste the command line generated after +typing in the groupId, artifactId and version. + +<style> + #mvncmd label { + text-align: right; + font-weight: bold; + width: 100px; + float: left; + margin: 0px 5px; + } + #mvncmd input, #mvncmd select, #mvncm span { width: 180px; margin-bottom: 5px; float: left;} + #mvncmd textarea { width: 400px; height: 100px; } + #mvncmd br { clear: left; } + #mvncmd div { float: left; } +</style> +<script type="text/javascript"> + function changeIt() + { + var groupId = document.getElementById("groupId").value; + var artifactId = document.getElementById("artifactId").value; + var version = document.getElementById("version").value; + var cmd = 'mvn archetype:create -DarchetypeGroupId=org.apache.wicket -DarchetypeArtifactId=wicket-archetype-quickstart -DarchetypeVersion=' + version + ' -DgroupId=' + groupId + ' -DartifactId=' + artifactId; + if (version.match(/.*SNAPSHOT/)) cmd += ' -DremoteRepositories=http://wicketstuff.org/maven/repository/'; + document.getElementById("cmdLine").value = cmd; + } +</script> +<div id="mvncmd"> + <div> + <label for="groupId" title="Base Package">GroupId:</label> + <input type="text" id="groupId" value="com.mycompany" onkeyup="changeIt();" /><span title="Base Package"> (?)</span><br/> + <label for="artifactId" title="Project Name">ArtifactId:</label> + <input type="text" id="artifactId" value="myproject" onkeyup="changeIt();" /><span title="Project Name"> (?)</span><br/> + <label for="version" title="Wicket Version">Version:</label> + <select id="version" onchange="changeIt();"> +{% for version in site.wicket.versions reversed %} + {% if version == site.wicket.version %} + <option value="{{version}}" selected="selected">{{version}}</option> + {% else %} + <option value="{{version}}">{{version}}</option> + {% endif %} +{% endfor %} + </select><span title="Wicket Version"> (?)</span> + </div> + <div> + <label for="cmdLine" id="cmdLabel">Command Line:</label> + <textarea id="cmdLine" onfocus="this.select();"> + </textarea> + <script>changeIt();</script> + </div> + <br /> +</div> + +### Results + +This will produce the following project structure/files + + .\myproject + | pom.xml + | + \---src + +---main + | +---java + | | \---com + | | \---mycompany + | | HomePage.html + | | HomePage.java + | | WicketApplication.java + | | + | +---resources + | | log4j.properties + | | + | \---webapp + | \---WEB-INF + | web.xml + | + \---test + \---java + \---com + \---mycompany + Start.java + +## Use + +Change into the project directory, then create a WAR file via `mvn package` +or build the project and run it under Jetty via `mvn jetty:run`. + +### Using the Jetty Plugin + +This will compile the project then deploy it to an embeded instance of the +Jetty servlet engine, which will be use on port 8080, by default. As a +result, once running, your application will be available at +<http:localhost:8080/myproject>. + +See the [Jetty plugin](http://www.mortbay.org/maven-plugin/index.html) +documentation for configuration options, etc. + +### Using with a specific IDE + +#### Eclipse + +To create an Eclipse project, use `mvn eclipse:eclipse` inside the project +directory and import the project in your workspace (File -> Import). + +Or alternatively install the [m2eclipse](http://m2eclipse.codehaus.org/) or +[Eclipse IAM](http://www.eclipse.org/iam/) plugin and add the project +directly. + +#### IDEA #### + +From within IDEA, just use "File/New Project/Import from external +model/Maven", choose the project directory and select the generated pom.xml. + +#### NetBeans #### + +To create a NetBeans project, just open the pom.xml directly. + +### More examples + +Many more information and examples can be found on our Wiki or +[here](http://www.ralfebert.de/blog/wicket/wicket_eclipse_setup/)
