I see how this whole push on/pull off environment will solve the issue,
but it just seems so nasty. I mean really, how is that any simpler than
dealing directly with query parameters? I point at this only to
highlight that perhaps Janos has brought to light a legitimately rough
edge in T5, or else there's a cleaner way to do it and we're all just
missing it. I'm convinced that the event system is the way to go as it
seems a natural fit, but the redirect-after-action part is rendering it
useless without using @Persist! Let me share what I've put together, and
maybe someone will find the missing piece. I have a working test and
I'll abbreviate the code here and assume a few things:

(coming in another message - i tripped the spam filter :-| )

Josh Canfield wrote:
> Are you trying to keep the news id out of the url? Doesn't sound like
> it from your response to not doing the redirect. Since that's the
> case, why not add it to the page context?
>
> I suppose if you were building a portal with several components then
> keeping track of component parameters could get unwieldy. If you were
> showing a news article from the news portlet, and a stock highlight
> from the stock portlet... At that point you're sort of building a
> framework on a framework.
>
> You could build your page such that it accumulated context from it's
> components. Push a ComponentContext object into the Environment
> onActivate, and setupRender in your page (env gets cleared before
> render phase, not sure if there is a better way than doing it in
> both.) Then collect component parameter mappings. onPassivate for your
> page would organize and return these as it's context (you might want
> to sort them to get consistent results)
>
> Your url might look like this:
>
> http://localhost/context/mypage/cc/news/4527/stock/MCD
>
> Then onactivate you init the ComponentContext from the url keying off
> the "cc" to grab the remaining parameters and use them as key/value
> for the components. The your components do something like:
>
> @Environmental
> private ComponentContext _compContext;
>
> void setupRender() {
>   Long newsId = _compContext.getLong(_resources.getId());
> }
>
> void onPickNewsItem(Long id) {
>   _compContext.put(_resources.getId(), id);
> }
>
>
> Josh
>
> On Wed, Apr 30, 2008 at 5:23 AM, János Jarecsni
> <[EMAIL PROTECTED]> wrote:
>   
>> Hi Chris,
>>
>> I try to explain :)
>> Say, you have a "NewsQuote" component, which shows a few lines from the 5
>> latest news. At the and of each quotations, there a "More" link. Now, when
>> the user clicks on this link (an action link, for that matter), the
>> NewsQuote component will set a request scope info saying that the news with
>> ID=4527 is requested. And when it comes to the "News" component (it is able
>> to show the text of a given news in full), it simply looks at this piece of
>> info, and loads the news with id 4527 (or gets it from an app level cache
>> :)) and renders it.
>>
>> Hope it tells something about what I am up to :)
>>
>> thx
>> Janos
>>
>> 2008/4/30 Chris Lewis <[EMAIL PROTECTED]>:
>>
>>
>>     
>>> Honestly it's difficult for me to imagine a situation where I'd do that
>>> because it seems to violate a degree of encapsulation that tapestry
>>> imposes as a "freeing law" of the framework. The epicenter of that being
>>> that one should not think in terms of low-level idioms such as request
>>> parameters, and instead replace those with a higher level of application
>>> logic that eclipses them entirely (when possible). That's not to say
>>> that your perspective is flawed, but from the small bit of understanding
>>> I've taken from your posts I can't see why one would do what you want.
>>> The thing that I've been saying is missing here is, what are you trying
>>> to do? I don't mean technically, I mean what is the end result for the
>>> user? Understanding this is critical, but even if I don't your problem
>>> can still be solved by using a session to serve as an arbitrary holder.
>>> If you've settled on this architecture, why not write such a generic
>>> service and move on?
>>>
>>> János Jarecsni wrote:
>>>       
>>>> Hi,
>>>>
>>>> I looked everywhere for usage of request scope variables, but found
>>>>         
>>> nothing
>>>       
>>>> (maybe I'm impatient a bit :)...
>>>> Is it really that unrealistic to have two components in a page, one (A)
>>>> having an action link eventhandler where it would set some attribute for
>>>>         
>>> the
>>>       
>>>> request only (not the session!) and then component B could render itself
>>>> according to the attribute set by component A?
>>>>
>>>> I think it should be a piece of cake :)
>>>>
>>>> thx
>>>> Janos
>>>>
>>>> 2008/4/30 Filip S. Adamsen <[EMAIL PROTECTED]>:
>>>>
>>>>
>>>>         
>>>>> Nope, you're exactly right.
>>>>>
>>>>> -Filip
>>>>>
>>>>> Blower, Andy skrev:
>>>>>
>>>>>  This is not what I understood 'perthread' scope to be. I thought that
>>>>>           
>>> it
>>>       
>>>>>> meant that each thread using a service gets its own instance of the
>>>>>>             
>>> service
>>>       
>>>>>> to use, even though that instance may not be the same as any previous
>>>>>> instance it used. In other words, nothing to do with user sessions,
>>>>>>             
>>> it's
>>>       
>>>>>> just for services that are not thread safe and cannot be singletons.
>>>>>>
>>>>>> Have I got the wrong end of the stick here?
>>>>>>
>>>>>>  -----Original Message-----
>>>>>>
>>>>>>             
>>>>>>> From: Andy Huhn [mailto:[EMAIL PROTECTED]
>>>>>>> Sent: 29 April 2008 17:34
>>>>>>> To: Tapestry users
>>>>>>> Subject: Re: page activation + components
>>>>>>>
>>>>>>>
>>>>>>> Hello,
>>>>>>>
>>>>>>> You can define the scope of each service...you can set that
>>>>>>>               
>>> particular
>>>       
>>>>>>> service to be tied to only one session.
>>>>>>>
>>>>>>> See http://tapestry.apache.org/tapestry5/tapestry-ioc/service.html,
>>>>>>> and
>>>>>>> search for "perthread".
>>>>>>>
>>>>>>> Thanks,
>>>>>>> Andy
>>>>>>>
>>>>>>> On Tue, 29 Apr 2008 18:02:52 +0200, "János Jarecsni"
>>>>>>> <[EMAIL PROTECTED]> wrote:
>>>>>>>
>>>>>>>
>>>>>>>               
>>>>>>>> Hi there,
>>>>>>>>
>>>>>>>> the service approach (as I expected) is session-agnostic (and is
>>>>>>>> page-independent so concurrent users would interfere badly),
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>> therefore is
>>>>>>>
>>>>>>>
>>>>>>>               
>>>>>>>> not ok.
>>>>>>>>
>>>>>>>> I will now try the Environment approach... if that is session-aware
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>> :)
>>>>>>>
>>>>>>>
>>>>>>>               
>>>>>>>> thx again
>>>>>>>> janos
>>>>>>>>
>>>>>>>> 2008/4/29 János Jarecsni <[EMAIL PROTECTED]>:
>>>>>>>>
>>>>>>>>  Hi Chris,
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> even so you could help :) I want this kind of generic way of
>>>>>>>>> passing
>>>>>>>>> around information (component to component communication :)) so
>>>>>>>>> I'll
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>> look
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> for the solutions Kristian and you outlined.
>>>>>>>>>
>>>>>>>>> thanks!
>>>>>>>>>
>>>>>>>>> cheers,
>>>>>>>>> janos
>>>>>>>>>
>>>>>>>>> 2008/4/29 Chris Lewis <[EMAIL PROTECTED]>:
>>>>>>>>>
>>>>>>>>>  Janos,
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>> Without code or a description of your actual goal, I'm finding
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>                     
>>>>>>>>> your
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>> situation too hypothetical to really digest. The one thing I can
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> point
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>> out is what you said about wanting a component to set a property
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> in
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>> the
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> page. If you want to do that, then you have to know the class of
>>>>>>>>>
>>>>>>>>> the
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>> page and so injecting a page would make sense. Of course that
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> means
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>> tightly coupling a component to a page, which to me doesn't make
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> sense.
>>>>>>>>>
>>>>>>>>> If you simply need a generic way of passing data between pages and
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>> components, consider using a service that provides an untyped
>>>>>>>>>> list
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>                     
>>>>>>>>> or
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>> putting something in the environment as Kristian suggested. I'm
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> sorry
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>> I
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> can't be more helpful but as I said I'm not clear on what you're
>>>>>>>>>
>>>>>>>>> really
>>>>>>>>>
>>>>>>>>> trying to do.
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>> good luck
>>>>>>>>>> chris
>>>>>>>>>>
>>>>>>>>>> János Jarecsni wrote:
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>                     
>>>>>>>>>>> Hi Chris,
>>>>>>>>>>>
>>>>>>>>>>> I thought of pages as "contexts" for the components embedded
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>> within
>>>>>>>>>>
>>>>>>>>>>                     
>>>>>>>> them.
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>> So, in one event handler of a component I would like to set
>>>>>>>>>>> some
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>> property or
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>                     
>>>>>>>>>>> another (in the page object), and the other components in the
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>> page,
>>>>>>>>>>
>>>>>>>>>>                     
>>>>>>>> which
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>> are also able to access this property may change their
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>> appearance
>>>>>>>>>>
>>>>>>>>>>                     
>>>>>>>> (say, the
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>> .TML would test the property). Maybe I'm on a wrong track,
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>> please
>>>>>>>>>>
>>>>>>>>>>                     
>>>>>>>> let
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> me
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>>> know :)
>>>>>>>>>>>
>>>>>>>>>>> thx
>>>>>>>>>>> Cheers,
>>>>>>>>>>> janos
>>>>>>>>>>>
>>>>>>>>>>> 2008/4/29 Chris Lewis <[EMAIL PROTECTED]>:
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>  Janos,
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>>>> I'm having a hard time understanding a case that a component
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>>>>>>>>>> should
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>> know
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>> in which page it is embedded, so my suggestion probably wasn't
>>>>>>>>>>>
>>>>>>>>>>> a
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>> good
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> one. Activation contexts aren't meant for components but for
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>>> pages
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>> -
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> you
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>>> should be using component parameters to configure them, and if
>>>>>>>>>>>
>>>>>>>>>>> it's
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>> a
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> more sophisticated component, probably a service.
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>>>> chris
>>>>>>>>>>>>
>>>>>>>>>>>> János Jarecsni wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>  and how a component can get to know the page in which it is
>>>>>>>>>>>>
>>>>>>>>>>>> included? I
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>>>>>>>>>> mean, I can't @InjectPage, as the component will be included
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>>>> in
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>>>>>>> many
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> kinds
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>>>>  of pages.
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>>>>>>>>>>>> @Kristian: thx for the many ways :) I'll try these, hope
>>>>>>>>>>>>> that
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>                           
>>>>>>>>>>>> the
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>>>>>>> @Environmental stuff is scalable (I'm trying to bypass session
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>>> creation
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>>>>>>>>>> as
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>>>>  much as possible)
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>>>>>>>>>>>> Is there a doc on the various annotations available?
>>>>>>>>>>>>>
>>>>>>>>>>>>> @Michael:
>>>>>>>>>>>>> Could you include a tiny bit of example? THX!
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thx to you all
>>>>>>>>>>>>> cheers
>>>>>>>>>>>>> janos
>>>>>>>>>>>>>
>>>>>>>>>>>>> 2008/4/29 Chris Lewis <[EMAIL PROTECTED]>:
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>  5) @InjectPage the page and call the getter
>>>>>>>>>>>>>
>>>>>>>>>>>>>                           
>>>>>>>>>>>>>> Kristian Marinkovic wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>  hi janos,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>>>>>>>>> there are several possibilities:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 1) declare a component parameter and pass in the
>>>>>>>>>>>>>>> variable
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 2) put it in a ASO and inject the ASO in all your
>>>>>>>>>>>>>>> components
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> (using
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>>>>> @ApplicationState)
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>>>>>>> the drawback is that any other page or component will
>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> able to
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>> access
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>>>  the ASO
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>>>>>>>>>>>>>> 3) put it into the Environment and read it whereever
>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> need it
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>> in
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>> your
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>>>>  nested components.
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>>>>>>>>>>>>>> be careful when you put your object in your
>>>>>>>>>>>>>>> environment. if
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>> put it
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>>>>>>  in
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>>  during the action
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>>>>>>>>> request it will not be able in the render request
>>>>>>>>>>>>>>> (because
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> of
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>> the
>>>>>>>>
>>>>>>>>
>>>>>>>>                 
>>>>>>>>> page
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>>> redirect).
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>>>>>>> page:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> @Inject Environment env;
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> @Persist("flash") whateverclass w;
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> onActivate(w) {  this.w= w }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> setupRender() { env.push(whateverclass.class,w);}
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> components:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> @Environmental Whateverclass var;
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 4) define a service that can take this variable (and
>>>>>>>>>>>>>>> saves
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> it
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>>>>>>>>>  appropriatly
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>>  so it is not
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>>>>>>>>> lost on a redirect:)) and inject your service in the
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> components
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>> where
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>> needed
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>>>>>>> to retrieve the value.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> maybe there are some more possibilities :)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> g,
>>>>>>>>>>>>>>> kris
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> "János Jarecsni" <[EMAIL PROTECTED]>
>>>>>>>>>>>>>>> 29.04.2008 08:15
>>>>>>>>>>>>>>> Bitte antworten an
>>>>>>>>>>>>>>> "Tapestry users" <users@tapestry.apache.org>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> An
>>>>>>>>>>>>>>> "Tapestry users" <users@tapestry.apache.org>
>>>>>>>>>>>>>>> Kopie
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thema
>>>>>>>>>>>>>>> page activation + components
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Hi there,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have an activatable page, in its onActivate(String
>>>>>>>>>>>>>>> param)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> method
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>>> I
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>>>>>>>  save
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>>  the param to a normal instance variable of the page
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> (no
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>> persistence!).
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>>>>>> How can any component embedded within this page access
>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> variable?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>>>>> the page class:
>>>>>>>>>>>
>>>>>>>>>>>                       
>>>>>>>>>>>>>>> //...
>>>>>>>>>>>>>>> private String param;
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> public void onActivate(String param) {
>>>>>>>>>>>>>>>   this.param = param;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> public String getParam() {...}
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thx in advance!
>>>>>>>>>>>>>>> Janos
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>  --
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>                               
>>>>>>>>>>>>>> http://thegodcode.net
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>> ------------------------------------------------------------------
>>>       
>>>>>>>>> ---
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>> To unsubscribe, e-mail: [EMAIL PROTECTED]
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>>>>>> For additional commands, e-mail: users-
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>>>>>>> [EMAIL PROTECTED]
>>>>>>>>>>>>>
>>>>>>>>>>>>>                           
>>>>>>>>>>>>>>  --
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>                             
>>>>>>>>>>>> http://thegodcode.net
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>> ---------------------------------------------------------------------
>>>       
>>>>>>>>> To unsubscribe, e-mail: [EMAIL PROTECTED]
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>>>>>> For additional commands, e-mail:
>>>>>>>>>>>> [EMAIL PROTECTED]
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>  --
>>>>>>>>>>>>
>>>>>>>>>>>>                         
>>>>>>>>>> http://thegodcode.net
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> ------------------------------------------------------------------
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>                     
>>>>>>>>> ---
>>>>>>>>>
>>>>>>>>>                   
>>>>>>>> To unsubscribe, e-mail: [EMAIL PROTECTED]
>>>>>>>>
>>>>>>>>                 
>>>>>>>>>> For additional commands, e-mail: [EMAIL PROTECTED]
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>                     
>>>>>>> ---------------------------------------------------------------------
>>>>>>> To unsubscribe, e-mail: [EMAIL PROTECTED]
>>>>>>> For additional commands, e-mail: [EMAIL PROTECTED]
>>>>>>>
>>>>>>>
>>>>>>>               
>>>>> ---------------------------------------------------------------------
>>>>>
>>>>> To unsubscribe, e-mail: [EMAIL PROTECTED]
>>>>> For additional commands, e-mail: [EMAIL PROTECTED]
>>>>>
>>>>>
>>>>>
>>>>>           
>>> --
>>> http://thegodcode.net
>>>
>>>
>>> ---------------------------------------------------------------------
>>> To unsubscribe, e-mail: [EMAIL PROTECTED]
>>> For additional commands, e-mail: [EMAIL PROTECTED]
>>>
>>>
>>>       
>
>
>
>   

-- 
http://thegodcode.net

Reply via email to