[CONF] Apache Wicket: Google Web Tools, A Starting Point (page edited)
Page Edited : WICKET : Google Web Tools, A Starting Point Google Web Tools, A Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: Introduction Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when effecting any significant changes to them. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widget as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would allow for further language consolidation by removing the need to write _javascript_ without sacrificing rich client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image. Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship that Java code and associated state to the client? Starting Point for Integration I began designing an integration between Wicket and GWT, but never followed through to implementation. I concluded that including GWT in some kind of cohesive development environment with Wicket was taking too much work. This may improve with an incremental Eclipse builder for GWT. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Google Web Tools, A Starting Point (page edited)
Page Edited : WICKET : Google Web Tools, A Starting Point Google Web Tools, A Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: GWT and Wicket Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when effecting any significant changes to them. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widget as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would allow for further language consolidation by removing the need to write _javascript_ without sacrificing rich client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image. Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship that Java code and associated state to the client? Starting Point for Integration I began designing an integration between Wicket and GWT, but never followed through to implementation. I concluded that including GWT in some kind of cohesive development environment with Wicket was taking too much work. This may improve with an incremental Eclipse builder for GWT. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Google Web Tools, A Starting Point (page edited)
Page Edited : WICKET : Google Web Tools, A Starting Point Google Web Tools, A Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: GWT and Wicket Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when reflecting any significant changes to them in the browser. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widget as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would allow for further language consolidation by removing the need to write _javascript_ without sacrificing rich client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image. Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship that Java code and associated state to the client? Starting Point for Integration I began designing an integration between Wicket and GWT, but never followed through to implementation. I concluded that including GWT in some kind of cohesive development environment with Wicket was taking too much work. This may improve with an incremental Eclipse builder for GWT. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Google Web Tools, A Starting Point (page edited)
Page Edited : WICKET : Google Web Tools, A Starting Point Google Web Tools, A Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: GWT and Wicket Introduction Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when reflecting any significant changes to them in the browser. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widget as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would allow for further language consolidation by removing the need to write _javascript_ without sacrificing rich client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image. Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship that Java code and associated state to the client? Starting Point for Integration I began designing an integration between Wicket and GWT, but never followed through to implementation. I concluded that including GWT in some kind of cohesive development environment with Wicket was taking too much work. This may improve with an incremental Eclipse builder for GWT. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Google Web Tools, A Starting Point (page edited)
Page Edited : WICKET : Google Web Tools, A Starting Point Google Web Tools, A Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: GWT and Wicket Introduction Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when reflecting any significant changes to them in the browser. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widget as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would allow for further language consolidation by removing the need to write _javascript_ without sacrificing rich client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image. Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship the Java code for those checks and their associated state to the client? Starting Point for Integration I began designing an integration between Wicket and GWT, but never followed through to implementation. I concluded that including GWT in some kind of cohesive development environment with Wicket was taking too much work. This may improve with an incremental Eclipse builder for GWT. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Google Web Tools, A Starting Point (page edited)
Page Edited : WICKET : Google Web Tools, A Starting Point Google Web Tools, A Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: GWT and Wicket Introduction Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when reflecting any significant changes to them in the browser. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widget as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would allow for further language consolidation by removing the need to write _javascript_ without sacrificing rich client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image. Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship the Java code for those checks and the associated state to the client? Starting Point for Integration I began designing an integration between Wicket and GWT, but never followed through to implementation. I concluded that including GWT in some kind of cohesive development environment with Wicket was taking too much work. This may improve with an incremental Eclipse builder for GWT. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Google Web Tools, A Starting Point (page edited)
Page Edited : WICKET : Google Web Tools, A Starting Point Google Web Tools, A Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: GWT and Wicket Introduction Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when reflecting any significant changes to them in the browser. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widget as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would allow for further language consolidation by removing the need to write _javascript_ without sacrificing rich client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image. Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship the Java code for those checks and the associated state to the client? Starting Point for Integration I began designing an integration between Wicket and GWT, but never followed through to implementation. I concluded that the work of massaging GWT into some kind of cohesive development environment with Wicket outweighed the benefit to my project at the time I write this. Improvements may come in the form of an incremental Eclipse builder for GWT, or other niftyness spawning from the Googleplex. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. FooComponent and FooService implement an example GWT-widget-as-wicket-component. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Google Web Tools, A Starting Point (page edited)
Page Edited : WICKET : Google Web Tools, A Starting Point Google Web Tools, A Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: GWT and Wicket Introduction Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when reflecting any significant changes to them in the browser. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widgets as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would allow for further language consolidation by removing the need to write _javascript_ without sacrificing rich client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image. Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship the Java code for those checks and the associated state to the client? Starting Point for Integration I began designing an integration between Wicket and GWT, but never followed through to implementation. I concluded that the work of massaging GWT into some kind of cohesive development environment with Wicket outweighed the benefit to my project at the time I write this. Improvements may come in the form of an incremental Eclipse builder for GWT, or other niftyness spawning from the Googleplex. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. FooComponent and FooService implement an example GWT-widget-as-wicket-component. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Google Web Tools, A Starting Point (page edited)
Page Edited : WICKET : Google Web Tools, A Starting Point Google Web Tools, A Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: GWT and Wicket Introduction Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when reflecting any significant changes to them in the browser. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widgets as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would further language consolidation by removing hand-authored _javascript_ from the picture without sacrificing intensive client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image? Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship the Java code for those checks and the associated state to the client? Starting Point for Integration I began designing an integration between Wicket and GWT, but never followed through to implementation. I concluded that the work of massaging GWT into some kind of cohesive development environment with Wicket outweighed the benefit to my project at the time I write this. Improvements come in the form of an incremental Eclipse builder for GWT, or other niftyness spawning from the Googleplex. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. FooComponent and FooService implement an example GWT-widget-as-wicket-component. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Google Web Tools - Starting Point (page edited)
Page Edited : WICKET : Google Web Tools - Starting Point Google Web Tools - Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: GWT and Wicket Introduction Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when reflecting any significant changes to them in the browser. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widgets as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would further language consolidation by removing hand-authored _javascript_ from the picture without sacrificing intensive client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image? Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship the Java code for those checks and the associated state to the client? Starting Point for Integration I began designing an integration between Wicket and GWT, but never followed through to implementation. I concluded that the work of massaging GWT into some kind of cohesive development environment with Wicket outweighed the benefit to my project at the time I write this. Improvements come in the form of an incremental Eclipse builder for GWT, or other niftyness spawning from the Googleplex. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. FooComponent and FooService implement an example GWT-widget-as-wicket-component. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Google Web Tools - Starting Point (page edited)
Page Edited : WICKET : Google Web Tools - Starting Point Google Web Tools - Starting Point has been edited by Daniel Carleton (May 20, 2007). (View changes) Content: GWT and Wicket Introduction Wicket and GWT are both component-oriented web application frameworks, but they take opposite approaches to state management. Wicket pages and sessions are composed and maintained entirely on the server, and a round trip takes place when reflecting any significant changes to them in the browser. GWT pages, on the other hand, are composed of _javascript_ widgets running on the client-side, where state is maintained and ongoing server communication occurs against a flat RPC layer. Motivation Why would you want to include GWT widgets as components in your Wicket pages? Language Consolidation A compelling aspect of Wicket its lack of any JSP _expression_ language equivalent. Page logic is instead implemented in Java code, allowing full use of standard development tools. GWT offers the same advantages with its Java - _javascript_ compiler. All widgets are implemented, tested, and debugged in Java code before being compiled to _javascript_ for deployment. Marrying GWT and Wicket would further language consolidation by removing hand-authored _javascript_ from the picture without sacrificing intensive client-side behavior. Client-side State Can be Nice Server round-trips can be heavy for implementing some types of client-side behavior. For example, what if you're tracking the coordinates of a mouse-over on an image? Doing a round-trip to check the mouse cursor location against some state on the server would be prohibitive. What if you could simply ship the Java code for those checks and the associated state to the client? Starting Point for Integration Here is a partial design for wrapping GWT widgets with Wicket components. Class Diagram This class diagram captures the design of a potential integration between Wicket and GWT. Discussion Create a central abstract class to represent your GWT widget as a Wicket component: GwtWicketComponent. This class implements a Wicket listener for RPC calls from the widget running on the client, and subtypes of GwtWidgetComponent like FooComponent provide and implementation of RemoteServiceServlet for fielding the calls. GwtWidgetComponent extends Panel, and should have some associated markup that includes the container for your GWT widget. GwtWidgetComponent will automatically add an appropriate callback URI to an attribute of this container, which the client-side code must use to invoke RPC calls. A special GwtRpcTarget implementation of IRequestTarget transports the RPC response payload back to the client via Wicket's standard RequestCycle. FooComponent and FooService implement an example GWT-widget-as-wicket-component. Obstacles I concluded that the work of massaging GWT into some kind of cohesive development environment with Wicket outweighed the benefit to my project at the time I write this. Getting the GWT development shell to render pages out of their servlet which were also passed through the Wicket servlet filter was trivial, but that's where I stopped. Rectifying the URI schemes for the two frameworks to get them to cooperatively render a page was the next step. A specialized Wicket URICodingStrategy might help here. Other improvements may come in the form of an incremental Eclipse builder for GWT, or other niftyness spawning from the Googleplex. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[jira] Created: (WICKET-582) Enhancement of exception message in WebExternalResourceStream
Enhancement of exception message in WebExternalResourceStream
-
Key: WICKET-582
URL: https://issues.apache.org/jira/browse/WICKET-582
Project: Wicket
Issue Type: Improvement
Components: wicket
Reporter: Martin Funk
Priority: Trivial
Enhancement of exception message in WebExternalResourceStream
Index:
wicket-1.x/jdk-1.4/wicket/src/main/java/org/apache/wicket/util/resource/WebExternalResourceStream.java
===
---
wicket-1.x/jdk-1.4/wicket/src/main/java/org/apache/wicket/util/resource/WebExternalResourceStream.java
(revision 540127)
+++
wicket-1.x/jdk-1.4/wicket/src/main/java/org/apache/wicket/util/resource/WebExternalResourceStream.java
(working copy)
@@ -96,7 +96,7 @@
in = context.getResourceAsStream(url);
if (in == null)
{
- throw new WicketRuntimeException(the requested
resource was not found);
+ throw new WicketRuntimeException(the requested
resource ' + url + ' was not found);
}
return in;
}
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
svn commit: r540183 - /incubator/wicket/trunk/jdk-1.4/wicket-extensions/src/main/java/org/apache/wicket/extensions/markup/html/repeater/data/table/NavigatorLabel.java
Author: ivaynberg
Date: Mon May 21 09:00:38 2007
New Revision: 540183
URL: http://svn.apache.org/viewvc?view=revrev=540183
Log:
make nav label serializable
Modified:
incubator/wicket/trunk/jdk-1.4/wicket-extensions/src/main/java/org/apache/wicket/extensions/markup/html/repeater/data/table/NavigatorLabel.java
Modified:
incubator/wicket/trunk/jdk-1.4/wicket-extensions/src/main/java/org/apache/wicket/extensions/markup/html/repeater/data/table/NavigatorLabel.java
URL:
http://svn.apache.org/viewvc/incubator/wicket/trunk/jdk-1.4/wicket-extensions/src/main/java/org/apache/wicket/extensions/markup/html/repeater/data/table/NavigatorLabel.java?view=diffrev=540183r1=540182r2=540183
==
---
incubator/wicket/trunk/jdk-1.4/wicket-extensions/src/main/java/org/apache/wicket/extensions/markup/html/repeater/data/table/NavigatorLabel.java
(original)
+++
incubator/wicket/trunk/jdk-1.4/wicket-extensions/src/main/java/org/apache/wicket/extensions/markup/html/repeater/data/table/NavigatorLabel.java
Mon May 21 09:00:38 2007
@@ -17,6 +17,8 @@
package org.apache.wicket.extensions.markup.html.repeater.data.table;
+import java.io.Serializable;
+
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.repeater.data.DataView;
import org.apache.wicket.model.AbstractReadOnlyModel;
@@ -33,7 +35,7 @@
private static final long serialVersionUID = 1L;
// TODO Factor this interface out and let dataview/datatable implement
it
- private static interface PageableComponent
+ private static interface PageableComponent extends Serializable
{
/**
* @return total number of rows across all pages
@@ -62,6 +64,11 @@
this(id, new PageableComponent()
{
+ /**
+*
+*/
+ private static final long serialVersionUID = 1L;
+
public int getCurrentPage()
{
return table.getCurrentPage();
@@ -91,6 +98,11 @@
{
this(id, new PageableComponent()
{
+
+ /**
+*
+*/
+ private static final long serialVersionUID = 1L;
public int getCurrentPage()
{
[CONF] Apache Wicket: Articles about Wicket (page edited)
Page Edited :
WICKET :
Articles about Wicket
Articles about Wicket
has been edited by Erik van Oosten
(May 21, 2007).
(View changes)
Content:
Bookmarkable link
Wicket in the News
Wicket has been featured in a number of on-line publications:
A Wicket user tries JSF Peter Thomas ~ May 14, 2007
Why Wicket? ZedroS ~ April 20, 2007
Wicket Impressions, moving from Spring MVC / WebFlow Peter Thomas ~ March 2, 2007
Wicket Tutorial Justin Spradlin ~ February 6, 2007
Wicket - (another) Java Web Framework: My First Impressions Timothy M. O'Brien ~ January 10, 2007
Backward compatible AJAX development with Wicket Erik van Oosten ~ January 7, 2007
Review: Wicket 1.1 "javaboutique", Drew Falkman
Wicket autocompletion improvements ~ Erik van Oosten ~ October 20, 2006
Comparing Web Frameworks: Wicket "javageek" An introduction to Wicket by Guillermo Castro based on a series of Web Framework comparisons. ~ March 8, 2006
A Little Bit About Wicket - R.J. Lorimer on Javalobby. January-August 2006
A Little Bit About Wicket
Reusable Panels
Let Components Contribute to the Header Section
Using Links - An Example of Session State
Server-Side State Revisited; Bookmarkable Links
Page Parameters
1.2: Control Wicket URLs with URL Mounting
Contributing Static CSS and JS
Loving web development using Wicket JavaPolis Javanews December 2, 2005
SDTimes JavaOne article Wicket is mentioned 2 paragraphs
Wicket overview Serbian JUG site (written in Serbian), November 14, 2005
A First Look at the Wicket Framework by David R. Heffelfinger on Ensode.net
Nothing sticky about Wicket Editorial in Network World on the release of Wicket 1.0 ~ July 7, 2005
Wicket 1.0, web framework, released the announcement of Wicket 1.0 ~ June 21, 2005
Wicket: Do we need yet another presentation layer framework? the first public appearance of Wicket ~ August 18, 2004
French
Ajax supportant les navigateurs sans _javascript_ ("Backward compatible") avec Wicket Erik van Oosten, ZedroS ~ April 26 , 2007
Pourquoi Wicket? ZedroS ~ April 20, 2007
Redécouvrez le web avec Wicket Par Romain Guy
Chinese
A book of "Wicket Development User Guide" is free to download(Wicket) wanglei ~ May 8, 2007
Many articles about wicket is on the website wanglei ~ May 8, 2007
Portuguese
Wicket! ... Hein? Bruno Borges ~ April 23, 2007
Dutch
Backward compatible AJAX ontwikkeling met Wicket Erik van Oosten ~ January 7, 2007
Powered by
Atlassian Confluence
(Version: 2.2.9 Build:#527 Sep 07, 2006)
-
Bug/feature request
Unsubscribe or edit your notifications preferences
[jira] Resolved: (WICKET-562) include SLF4J jar in the Wicket 1.3 zip distribution
[ https://issues.apache.org/jira/browse/WICKET-562?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] Martijn Dashorst resolved WICKET-562. - Resolution: Fixed Fix Version/s: (was: 1.3.0) 1.3.0-rc1 Should be fixed, at least I see them in my snapshot release. include SLF4J jar in the Wicket 1.3 zip distribution Key: WICKET-562 URL: https://issues.apache.org/jira/browse/WICKET-562 Project: Wicket Issue Type: Task Components: wicket Affects Versions: 1.3.0 Reporter: Sean Sullivan Assigned To: Martijn Dashorst Fix For: 1.3.0-rc1 I downloaded the Wicket 1.3 beta 1 zip file and I noticed that the SLF4J jar is not found in the lib folder apache-wicket-1.3.0-incubating-beta1/lib Please add the SLF4J jar to the lib folder. -- This message is automatically generated by JIRA. - You can reply to this email to add a comment to the issue online.
[jira] Closed: (WICKET-562) include SLF4J jar in the Wicket 1.3 zip distribution
[ https://issues.apache.org/jira/browse/WICKET-562?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] Martijn Dashorst closed WICKET-562. --- include SLF4J jar in the Wicket 1.3 zip distribution Key: WICKET-562 URL: https://issues.apache.org/jira/browse/WICKET-562 Project: Wicket Issue Type: Task Components: wicket Affects Versions: 1.3.0 Reporter: Sean Sullivan Assigned To: Martijn Dashorst Fix For: 1.3.0-rc1 I downloaded the Wicket 1.3 beta 1 zip file and I noticed that the SLF4J jar is not found in the lib folder apache-wicket-1.3.0-incubating-beta1/lib Please add the SLF4J jar to the lib folder. -- This message is automatically generated by JIRA. - You can reply to this email to add a comment to the issue online.
[jira] Resolved: (WICKET-543) need javadocs embedded in the Wicket 1.3 zip file
[ https://issues.apache.org/jira/browse/WICKET-543?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] Martijn Dashorst resolved WICKET-543. - Resolution: Won't Fix I don't agree to including the javadoc sources in the release. The zip is already large and contains all code. Using maven you can easily generate the docs yourself. Or even better: use the maven repository to automatically attach the sources-jar to your eclipse/idea/netbeans project. You can also download them by hand and attach them manually. The comparison with 1.2.6 is not valid as we use a different setup now and ship everyting in one zip instead of a zip per project.. need javadocs embedded in the Wicket 1.3 zip file - Key: WICKET-543 URL: https://issues.apache.org/jira/browse/WICKET-543 Project: Wicket Issue Type: Improvement Components: wicket, wicket-auth-roles, wicket-datetime, wicket-examples, wicket-extensions, wicket-jmx, wicket-spring Affects Versions: 1.3.0 Reporter: Sean Sullivan Assigned To: Martijn Dashorst Priority: Minor Fix For: 1.3.0 I downloaded apache-wicket-1.3.0-incubating-beta1.zip from http://people.apache.org/dist/incubator/wicket/apache-wicket-1.3.0-incubating-beta1/dist/ I unzipped the file and noticed that the zip does not contain any javadocs. Please embed the javadocs inside the zip file :-) (fyi, the Wicket 1.2.6. zip file has the javadocs embedded) -- This message is automatically generated by JIRA. - You can reply to this email to add a comment to the issue online.
[jira] Closed: (WICKET-430) Jira bug tracking link on the wicket site
[ https://issues.apache.org/jira/browse/WICKET-430?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] Martijn Dashorst closed WICKET-430. --- Resolution: Fixed See bottom of menu: Reporting bugs Jira bug tracking link on the wicket site - Key: WICKET-430 URL: https://issues.apache.org/jira/browse/WICKET-430 Project: Wicket Issue Type: Improvement Components: site Reporter: francisdb Priority: Trivial Fix For: 1.3.0 there is no direct link to the bug tracking system on the new site -- This message is automatically generated by JIRA. - You can reply to this email to add a comment to the issue online.
[jira] Closed: (WICKET-48) Change user info in wicket-parent/pom.xml for committers
[ https://issues.apache.org/jira/browse/WICKET-48?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] Martijn Dashorst closed WICKET-48. -- Resolution: Won't Fix Can't be updated anymore, we decided to remove the commiter/contributor info from the pom.xml in favor of listing them on the site Change user info in wicket-parent/pom.xml for committers Key: WICKET-48 URL: https://issues.apache.org/jira/browse/WICKET-48 Project: Wicket Issue Type: Task Affects Versions: 1.3.0, 2.0 Reporter: Martijn Dashorst Priority: Minor Fix For: 1.3.0, 2.0 Change your user information to show the apache mail address and ID. Also fill in the role: PMC member Comparable to: http://svn.apache.org/viewvc/maven/pom/trunk/maven/pom.xml?view=markup -- This message is automatically generated by JIRA. - You can reply to this email to add a comment to the issue online.
[jira] Commented: (WICKET-176) Introduce AjaxFormElementValidatingBehavior
[ https://issues.apache.org/jira/browse/WICKET-176?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12497592 ] Martijn Dashorst commented on WICKET-176: - I don't think I want this in core: we already have AjaxFormComponentUpdatingBehavior which already validates, and updates the models in one go. The default of adding all feedback panels to the ajax request target also seems a bit enthousiastic: this is better left to specific applications (it is easy to implement yourself). At best this belongs to extensions, or even better: wicketstuff-minis Introduce AjaxFormElementValidatingBehavior --- Key: WICKET-176 URL: https://issues.apache.org/jira/browse/WICKET-176 Project: Wicket Issue Type: New Feature Components: wicket Affects Versions: 1.2.3 Reporter: Erik van Oosten Assigned To: Eelco Hillenius Fix For: 1.3.0, 2.0 Attachments: AjaxFormComponentValidatingBehavior.java, AjaxFormComponentValidatingBehavior.java There is currently no easy way to validate a single form element using Ajax. Please add attached code to the Wicket-core. -- This message is automatically generated by JIRA. - You can reply to this email to add a comment to the issue online.
[CONF] Apache Wicket: Companies that provide services (page edited)
Page Edited : WICKET : Companies that provide services Companies that provide services has been edited by jWeekend (May 21, 2007). Change summary: added jWeekend (View changes) Content: List of companies that provide commercial services for Wicket. Wicket Support Services Wicket Support is a company that provides training, consultations and commercial support for Wicket. Jaywayis a premier Java consulting group that via its Malaysian subsidiary provides services for Wicket development, especially running Wicket in OSGi environments. Skillsmatteris a leading provider of training, mentoring and project based skills transfer. Amongst other things, they provide Wicket courses. Anyware Technologies is a french company that provides many training courses, including Wicket. jWeekend provides weekend expert training in java, OO wicket. London Brighton. Powered by Atlassian Confluence (Version: 2.2.9 Build:#527 Sep 07, 2006) - Bug/feature request Unsubscribe or edit your notifications preferences
[CONF] Apache Wicket: Index (page edited)
Page Edited : WICKET : Index Index has been edited by jWeekend (May 21, 2007). Change summary: added jWeekend to "Sites using Wicket" (View changes) Content: Bookmarkable URL Linking to the wikiTo help with the server loading, please only link to pages under the http://cwiki.apache.org/WICKET/ static root. I'll add Bookmarkable URL links to the pages to help as time allows, but they're not there yet. This wiki is dedicated to documenting the Wicket Java application framework. Wicket takes simplicity, separation of concerns and ease of development to a whole new level. The wiki is currently open to new users and contributors; see the contribution page for more information. To download Wicket, please visit the Wicket site. Table of contents Framework Documentation Migrations Sites using Wicket Wicket Press User Stories Framework Comparisons Commercial Services Other projects related to Wicket External Links IRC Framework Documentation Documentation Index An attempt to provide a one-page overview as to where to look for information. Getting started guide (A little dated/incomplete, so check the Reference library too) Reference library A selection of reference guides and how-tos. Best Practices and Gotchas Wicket FAQs Notes about the Wiki move Notes: See also the Labels page (via the Browse Space link above) for some indices into the content of this site, e.g. model, component, etc. Migrations Migration to Wicket 1.2 (1.2 is the current stable release) List of API changes from 1.1.1 to 1.2 (Updated to compare with the released 1.2 jar) Migration from Wicket 1.2 to Wicket 1.3 (1.3 is the current development release) Migration from 1.2 to Wicket 2.0 (2.0 as described here is discontinued) Sites using Wicket Coderspiel Blog of N8han written using Wicket and databinder Artifactory Artifactory is a maven2 proxy based on Wicket JTrac Trac is an open source and highly customizable issue-tracking web-application written in Java. morons.org Morons.org is a community website based on tally-ho tally-ho Forum/Community software powering morons.org XFX Team Soon to be community site for XFX's foray into building a gaming team, will have extended functionality, voting and posting videos, etc TexasHuntFish Community site for Texas sportsmen. Currently being converted from ColdFusion to Wicket - about half way there. MeetMoi Location based mobile dating on your cell phone. Teachscape A professional learning system. Servoy A RAD environment which uses Wicket for web interface generation Voicetribe Voicetribe adds online commentaries to your favorite DVDs. Eventful Eventful allows you to manage your event with simplicity and ease. Irrigator A simple web interface for controlling water taps in an irrigation system Burgerweeshuis An open source CMS for pop venues, currently only dutch Woogle Woogle is a Wicket based, Wicket search engine. Szeretgom.hu A Wicket based hungarian web portal Track Detective A site for GPS track analysis and manipulation Basisregister Bedrijven Amsterdam. An internal site to cross check company data over several databases for the municipality of Amsterdam. Papernapkin.org A code pastebin with syntax highlighting. Alliance Communications Managment Alliance uses wicket for internal sites which provide reporting and bug tracking for internal software systems. Vocus student information system Topicus created a web based student administration system for highschools. The application is not publicly available. Jobindsats.dk Danish government employment statistic report generator. WebiCal A Web application to view and edit multiple iCalendars [EMAIL PROTECTED] Is a web-based solution that helps to protect your gains and cut down your losses on stock trading. GenieTown GenieTown is building a unique online community of customers and service providers. The site is designed to restore the lost experience of Main Street, where business was conducted in a personal way, the resources were local, and reputation was paramount. Finan Finan is a financial analysis tool and now features a web based solution for their win32 deplhi client application built using Wicket Wansanity Game advertising project which utilizes Wicket for its web component. jWeekend is reconstructing its site using wicket. Wicket Press User Stories Articles about Wicket Wicket Blogs User stories Framework Comparisons Wicket and Struts Wicket and Tapestry Commercial Services Companies that provide services such as training, consultations and support Other projects related to Wicket Databinder project for building web applications quickly with Wicket and Hibernate Qwicket another quickstart project for building spring+hibernate+wicket applications.
[jira] Updated: (WICKET-583) Header Contribution in ModalWindow doesn't work properly
[ https://issues.apache.org/jira/browse/WICKET-583?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] OHKAWA Tomohisa updated WICKET-583: --- Attachment: wickettest.zip testcase for this issue Header Contribution in ModalWindow doesn't work properly Key: WICKET-583 URL: https://issues.apache.org/jira/browse/WICKET-583 Project: Wicket Issue Type: Bug Components: wicket Affects Versions: 1.3.0 Reporter: OHKAWA Tomohisa Attachments: wickettest.zip Defining some styles in ModalWIndow. The styles doesn't applied when I open the wIndow first time, but when I close and reopen it, it works. Please refer the testcase. -- This message is automatically generated by JIRA. - You can reply to this email to add a comment to the issue online.
