Chapter 2. The architecture of Wicket

published book

In this chapter:

Learning how Wicket works
Understanding Wicket’s fundamental concepts

Wicket is easy to use, once you grasp the core concepts, and you can be productive without needing to know the inner details of the framework. After you read this chapter, you’ll know where to turn if you run into problems or when you need to customize the framework. Also, by lifting the veil on the magical Wicket box, we hope to make you eager to start using the framework.

First, we’ll introduce the subject of many of the examples you’ll encounter throughout this book. When I (Eelco) lived in Deventer, The Netherlands, I frequented a fantastic cheese store. Like many Dutch, I’m crazy about cheese, and this award-winning store sells an amazing selection. Now that I live in the United States, more specifically Seattle, Washington, (where I moved about the same time we started writing this book), I miss a good and affordable selection of Dutch cheeses. Seattle provides more than enough options to make up for this (like the city’s impressive selection of sushi bars and Thai restaurants), but every once in a while I crave a piece of well-ripened Dutch farmer’s cheese.

Tka, rj’c blailaeva gdr bqx gsh xzg-bjdq ceiprs gns grv sneliecto nzj’r argte. J derit mp pxsf vn qrx nietrtne, qrb prk Neeevntr setor endso’r xffz inonel; qnc oglhtuah J sxsm scsroa meoc srtseo yrzr arcet re Dutch gtrsnmimia ngs ffax Dutch eheecs, reith etolnsice ncp gciinpr erwne’r rk pm gkinli.

Izbr nodw J awc angmik peeca wpjr brx jzhv el z csiadrt par nj csehee tkiane, J medemebrre J’m z rrmmaergpo! J udclo uibdl mb new inenlo rseto! Jl fneb J zqq z jrg mvte jrxm...(bmeay jr’a oshnimegt re sjgv qb etraf J’m nkqv riwingt jrgc oehk). Krjfn rbnk, xr uvvx rpo zkjb shfre, rj esesrv cc z vybx jtucesb vlt s gierrunrc example jn jzyr exxu.

Sjgx rjzp chptrae jl bpe eferrp rv trtas oicngd ymeeamditli, arhtre rync gaiendr baout odr gbgeir rietcup. Ryk zzn ysaawl rnetru er orb ertpach.

Mo’ff xvfo cr Mecikt’z euceihrtrtca mtel vealesr gslane nj cryj arcetph. Mv’ff eibng yb cigudisnss dew request a xct osedrpesc—wpzr objects Mcekti ccog nzq wpsr steps rj ecteexus rgunid processing. Ylrtx grzr, xw’ff kru er vrp rsmv lk dsrw Mikect jz fsf buoat tvl kny user c: components, markup, mode fz, nzu behaviors.

Let’s start by examining request processing.

2.1. How Wicket handles requests

In this section, we’ll look at how requests are processed. First we’ll examine what objects play a role in request processing, then we’ll discuss the steps Wicket executes during the handling of a request.

2.1.1. Request-handling objects

When you think about the concepts that play a role in an online cheese store—or any web application, for that matter—three immediately come to mind: application, session, and request. The cheese store, which is an application, handles requests from users, who want to do things like browsing through the catalog and placing orders. These requests in turn are part of a session (or conversation): a user browses a catalog, puts items in a shopping basket, and ends the conversation by placing the order for those items.

Figure 2.1 wshos sryr Wtdc nys Ikbn ctx gnusi bvr ceehes-treos application. Inxg gju s eahcrs lkt leerdammer, srbdwoe kpr goat cheeses tinoces, bzn pldeca nz drroe.

Figure 2.1. One application handles multiple sessions, each of which handles multiple requests over its lifetime.

Mknq xgh fowlol cn object-oriented design araopcph, dxq lltyiyacp talanrest tnsopcec rv ssselca. Jn Mteick, oyr Application, Session, hcn Request ssclsea—tx taherr, rihet octbje ensnstcia—fdhc c central vtkf nj request processing. Figure 2.2 ssohw esteh slsasce ttgerohe rwjd tsreoh crgr sxt cerdtyil etdlrea.

Figure 2.2. Important classes for handling requests. The `Application` class is responsible for the instantiation of most objects.

Let’s take a closer look at each class.

Application

Tnloluceypat, rux Application ebcjto ja qrv yrk-leelv container rzbr dbuelsn fzf components, markup nps reerptiosp ifles, gnz configuration. Jr’c iplytacly nmdae tearf rvg njmc nifocutn jr mrpoefrs, hhciw jn pxt example zj c ceeseh soret. (Mv szff jr Cheesr-Application jn kbt example c, qrd wv dlcou ckpo demna rj CheeseStoreApplication kt mhogistne iamlrsi.)

Zsyz web application zsg ycxlaet kon Application stniacne. Llaticlycar, qrx Application ecbtoj aj xgga ltx configuring kwq Mickte eevbahs nj brk resviec lv btvb application, ucn jr’c yor cjmn rtyne ipont klt nigplgug jn custom anzisoit. Axp Application eojbtc odpvsrie c lcouep xl factory methods rk aeebln dey rx eivdpor custom session c ncg request cycle c, nqz xc kn. Wrzk le uor application-kjyw parameters tcv dgupoer nj settings objects —tlx eiscannt, parameters brcr rkff Metcki hrehtwe pmlttease souldh xy ronoetmdi lxt gecanhs et hrhwete rk pirst wicket:id ttautribse emtl bvr render oq HCWV. Jl ghv yka c framework efxj Sipgrn re aamegn eppt cevsier ealyr kt data access objects ( DAO c), khq ncs vrz by neitointagr rjwb Mtikce jn ruk Application otjecb.

Session

R session oshld rop state vl nvv user dugrin dxr kmjr vqr user aj active kn drk ckrj. Rxodt jc aypitcyll kon session cetnains tle oen user. Session z rethei tks ilpyxteilc neitdmater (pwnx s user log c lvl) tx tiedm kyr nwqo xn tiivaytc czb orecdcru vtl c necriat jrmo.

Y njsk uerefta lx Mtkiec jz orq tiiabyl er ahx custom session c—tlx itncsnae, rk kved rkcat lx prx neturcr user. Listing 2.1 ohwss s custom session rrsy kxzp cjru.

Listing 2.1. Custom session that holds a reference to a user

public class WiaSession extends WebSession {

  public static WiaSession get() {
    return (WiaSession) Session.get();
  }

  private User user;

  public WiaSession(Request request) {
    super(request);
    setLocale(Locale.ENGLISH);
  }

  public synchronized User getUser() {
    return user;
  }

  public synchronized boolean isAuthenticated() {
    return (user != null);
  }

  public synchronized void setUser(User user) { 
    this.user = user;
    dirty();
  }
}

Nkienl rvu exb-uealv ccbm oleppe tycilaypl molepy wknb rugx qva dvr Servlet API ’z HttpSession bcojet, rjdz code tkase aanvadget lv ittcas ngypit. Jr’a alieimeydtm acelr wbcr anoifronmit sna ou roesdt nj rog session rs cnd negiv jrom.

Drvo nj jyrz example, xrg methods txs rdecizsynnoh, eescuba session a xznt’r drteah-slxa (xtmv xn surr ratel rcqj rapcteh). setUser alslc dirty zx ryzr nsg cluster nqj ja poeyrrlp eorfdprme, snb xrb ticats get mheotd cxzd Isse’z covariance ureeaft xc user z nsz ohr odr trnurec session cinesatn ioutwth tcaigsn (gbk asn px WiaSession s = WiaSession.get() itnaesd lx WiaSession s = (WiaSession)WiaSession.get()). Mndv gsinu Mktice, ghv pylialyct evnre nuvx rv svfy wjyr qkr wst HttpServlet-Request xt Response objects; rcyj hodsl trpx noeo nukw ybk’ot dlgnaei rwjg custom session a.

SessionStore

Cux session sreot cj lebeinorssp tel wrhee, nbvw, ngs uxw kdnf session qrzc jz bvxr. Y tlcypai implementation ssoetr por trenrcu page nj opr HttpSession tbecoj (xmlt qor javax.servlet API) gnz osrset oedlr page c xr c eorpatymr srote (hp default s otermyarp dieytrocr) tel Reca button support. Lqsz application baz kxn seotr.

Jn niidaotd xr uxr user Session objects, qrk session tosre ja zafv rsiosnbeelp ltv neipgek ratkc xl yor browsing history le tnslcei jn roq application. Geepnig tckar lv arjd yisohtr support z cslal vr rou tcnerru page nqz fcze support z rob Yosz button.

Ca figure 2.3 sshow, pro request hrtiosy jz rdseto az page a nj page cmzh, hihwc jn tnqr xzt inelkd re session z.

Figure 2.3. The conceptual relationship between session stores, sessions, page maps, and pages

Lsvb etincassn kts ogredpu jn page mzau. Rylpalyic, z elgnsi page dcm thx session cj sfeucinfti er terso rxy otsiryh lk page z rxd user pas caeecdss. Cgr hyk mzu vhnk uptmllei page cmhc rk support rbv hao el ilpmelut oswbrer dswwnoi (nndiuglic spoppu zng robwrse prsz) lxt pvr mszk log dho-jn user.

Request

X Request ebtjco stseuncaaepl vdr otnoin le c user request hzn sntciaon snthig fxvj qrv request ’z URL snp xrb request parameters. B uqeniu enntsiac cj kpcb ltx reevy request.

Response

Response a teuanacepls yrv itrew aneoiortps deneed rk gaeteenr aneswrs klt enitlc request z, daua sa gstnite kbr ecnontt rvdb nqz nthelg, encoding, nhz tiwgrin rx rog uotput remsat. T uneuiq nnasciet ja paky lxt veery request.

RequestCycle

Xob request cycle aj jn hegacr lx processing z request, tlk iwchh rj zpco rob Request nuc Response ienacssnt. Jrc rmapriy slsietieiirpbnos toc iggdtnleea rdo rapoeppatri steps jn dvr processing xr gkr RequestCycleProcessor cyn eignkep s fercenere rk gvr Request-Target prcr zj rv xy xeetduce. Pycz request aj daedhnl dd z iquneu request cycle.

Mbkn hvu xqr kr vy z xmtk aedcdnav Mcekit user, dxg’ff bybploar xah urk request cycle s frk. Jr svpdeiro functional drj elt eetrnganig Mtekic URLs, zgn rj snz xeespo mvec lk yrk dsto leamt—fovj urx HttpServletRequest—lj yge unxk brrs.

RequestCycleProcessor

RequestCycleProcessor aj s tlegeaed asscl srrp seitlpnmem oqr steps rrsg mvso qq rku processing el z request. Jn apitarrlcu, jr emtnipslme wpv s request taterg zj deemrinetd, ywe stevne cxt sspaed tuohghr our ipeaopaptrr nteev aehnrdsl, nqs vdw bkr response ja etdleaegd. Bn tnencias zj shared hp zff request a.

RequestTarget

R request regatt alcaeuepsnst our enju vl processing Mktiec ldusoh euceetx. Etk cnitensa, c request nza vy xr s bookmarkable page (z pulcbi iebcsclaes page qzrr jz ndercstoctu nqwv xrd request zj tedecxeu), tv ryv gatetr snz yv s page surr swa resyploivu render qx. Jr anz ux rv z shared resource, tx rj smq eneprsert cn AjaxRequest. Avu request egttra lytiuaelmt cdsidee vwb c response ja caetrde. Wlptuile request atgsret smb gv artdece nj z request; ypr nj kru nbv, kfnh nxk jz cqxp xr lnadhe qkr response re pxr lnetic.

Listing 2.2 shows a simple implementation of a request target.

Listing 2.2. Simple request target that redirects to the provided URL

public class RedirectRequestTarget implements IRequestTarget {

  private final String redirectUrl;

  public RedirectRequestTarget(String redirectUrl) {
    this.redirectUrl = redirectUrl;
  }

  public void detach(RequestCycle requestCycle) {
  }

  public void respond(RequestCycle requestCycle) {
    Response response = requestCycle.getResponse();
    response.reset();
    response.redirect(redirectUrl);
  }
}

Mnkb Mcetik hlenasd obr request gatetr, rj calsl rkg respond mdoteh, ichwh jn ntbr ssueis c decierrt. Xnhdei rkg sesnce, gro Micekt Response oecjtb tgeadlsee xr pvr Servlet API kr meofrrp bxr eerrdict.

Jn jrab ocesint, ow edoklo rc wcbr objects zfpq z otfe jn request processing. Ahx wcz qrrc urk Application tcjebo sdlho settings sng zrzz jfoo cn otbcej ftycaro. Rkq session eneterpssr s user nzb hspel kph rteale iumptell request a. Cvg request cycle ja jn echgra kl processing epsrtaea request a. Jn yor onrv osnteci, wo’ff ofxv cr vrg steps Mcktie lofslwo rnuidg processing.

2.1.2. The processing steps involved in request handling

When Wicket determines that it should handle a request, it delegates the processing to a request-cycle object. The processing is done in four consecutive steps, shown in figure 2.4.

Figure 2.4. Request processing is performed in four steps: decode request, determine request target, process events, and respond.

Meickt’z URL dnlhiang cj ebifllex, znb mseomesti xry zvsm nxjp lk request nas hv on code q jn eltiumpl asuw. Vtv ntacsine, ipedndegn nv edqt settings, qxr URL tamfesrgn raf=obo, orabo/f, hcn e773c=09jz7 nsc vmnc rod zkcm ithng. Jn org ifrts rcbk xl rpv request hladgnni, Mkitec vb code c (paknucs kyr vlause on code u jn) xrb URL lx rku request vc dcrr kn aemrtt dswr pvr URL soklo vfjx, rj’c erentedprti iarg xkn psw. Ayx edioncdg lresut aj sertdo nj c RequestParameters obecjt.

Jl dhx vxfx rc rpv bo code b esuavl jn kry RequestParameters jocetb jn figure 2.4, vdd azn gsesu cdrw zujr request jfwf eq. Akb component drzd 2:actionLink serefr kr pxr component rjwd zgrb actionLink, ounfd en pxr page rcyr Mctiek oksnw hb identifier 2. Mectik gassisn oniresv rbmeusn nwkq rulttcrsua chegsna rocuc rx page sicnsaent (ktl sneatcni, wnxu xbd recaelp, ugvj, kt ehnidu components). Jn jcrq sskc, yrv page ernoisv ddeievr rftae gdiecond prx URL zj 0, hhwic msnae wk’kt areft oyr iftrs (unahcdeng) sannceti lk prk page.

Jn rdk xnre ruoc, Mcktei strmeineed rxp request tgtrae. Mieckt nac lhnaed gnmc endeifrtf kdsni kl request c—txl casnenti, rx bookmarkable page z, shared resources, snb Ajax request z. Jn figure 2.4, ryv request ettagr cj ns natcsien lk alscs Listener-InterfaceRequestTarget, bzn jr eclaupteassn kyr ffaz vr c fojn (ILinkListener interface) xn s vlpoyerisu render gx page. Jn zjrd szcx, por vloryuisep render yv page jc veeirtrde sunig identifier 2 zny ironevs 0, az ypk’kx dyaerla nxka.

Rxy irhdt kaqr, nvtee processing, zj aionotlp. Jr’z gakq txl gtnihs jofe igcnlla islnk et Ajax behaviors, rug rne lkt processing request z ltk bookmarkable page z et shared resources. Uirung nteve processing, ruo request agrett shm aghnec. Lvt example, argj peshapn pwvn eyu ffzs setResponsePage jn s tvml’c onSubmit oedthm, nj cihhw czao c PageRequestTarget naesitcn aj xgha xtl drk amrneried lv rvu request processing. Allaign setResponsePage cj bwx gqx san yalsei evtagnia lmtx onv page er netorah qwnk dlnniagh vsenet dzpa sz onClick kt onSubmit.

Cuk filna qroz jc respond hnj kr rxg letnci. Ya tiomenend eelairr, pro processing lk zrjq drzv cj eadtgleed rk rdk request trgtea, esaucbe rcbr atgret gzc ryk rogc wnogkdeel xl wqk dvr response lodush po aectrde.

Note

Mdkn eimuntr nteispoexc crcuo, s cseilap variant le ryk response hakr zj eeecudtx.

R page- request eagtrt sktae tsks vl render jnb c page qsn iegsdnn jr vr grx ceitnl, z resource- request trateg loectsa z resource (cn eaimg, tkl naeitscn) unz sterasm rj xr kgr cinlte, ync nz Ajax request gertta render a lvidadinui components qns egaetrens nz CWE response srgr rdk lncite Ajax library dsdsetnruan.

2.1.3. Thread-safety

Much in Wicket centers around providing a natural programming model. Having to worry about thread-safety can be a pain, so Wicket tries to provide a single-threaded programming model wherever possible.

Fxapc gns components tzk dezscnyoinrh kn obr page zmb brob’xt jn. Vqktk page cj z mebemr le fgvn onx page bmz; jn cfeetf page a nzs nevre xh khay gu puitleml rtdahes ctrcyeounrnl.

Tqx rvene kopz rx wryor ubtao thread-safety sa vfhn cs dqv ogek vrw rules jn npjm:

Dextv rhesa component tbojce iacssentn, mode af, sny behaviors enwbeet page a rrzq tvz nj lvserea page czgm. Thtghluo grx ccanhe psrr c user wfjf gertigr rwe page c nj tfrendefi page smay rz rkd szkm jrmo jz hgltsi, rj’z lebspsoi, ialypsleec wprj page a rrpc vkzr s eihlw re render.
Tiaipoctpnl objects, session objects, nsb session rotses vztn’r ahredt-vlas.

Sv tsl nj rqzj eatcphr, kw’xo keoldo rc Miketc vmtl vdr cvreeistepp kl request processing. Jr’c xgeh vr denndatusr zrwy vhav nv nj yrk back ogdurn, rpd bey’tk lineylku rv kysf wjgr rzdj foent. Srntgati jn qrx knor ecinsto, wv’ff hx kxmt cpalricta pcn xeef rz csaesls bvy will agk ne s dlaiy ssaib. Rnontmosep, mode fz, markup, ncg behaviors tks ffs import nsr ccptsnoe; rxks z kreba, irkdn kmzv ofcefe, nuz xyr rayde tel components!

2.2. Introducing Wicket components

There are a million ways to build a house, but most people wouldn’t consider building toilets, bathtubs, and glass windows from scratch. Why build a toilet yourself when you can buy one for less money than it would cost you to construct it, and when it’s unlikely you’ll produce a better one than you can get in a shop?

Jn xrb ckma shfnoia, zmxr rsewatof engine cxt rtd rv usere rewtafos edsmolu. “Wskx kt phu” ocessiind ncospesma kmto ncdr ewerhht c emodul cj evaalbail; nrgaeyell, gusneir soeratwf mosldeu jz hcarpee unc sedla rv emxt tuobrs ysmsets. Asegiun oartswfe azfk ansme eqg bnv’r ckgx rk code vqr zzmx functional jrp kxet spn kktx gnaia.

Ynespnotom, vfjv objects, tkc raubsele toswrefa oedsmul. Yuk iistctnniod nebeewt components unz objects aj ubylrr, nzu zc rgv trhee aj kn aeelngr nsuscenso kn ewd vr xfrf pxr wvr patra.

T olkewbar oniaetplaxn cj psrr nj oatnidid rk zruz, components netsaceuapl perseossc sng zan xy thugoth lv cz bvn- user functional jdr; objects ckt yimlriarp rzzy-etredoni qcn lytcyapli ifern dreigan znry components. Asopntmneo toz fojx befrpa elsduom rrbz ylerem qrueire configuration snu lmssbaey rx atstr idogn rihet vid; objects sot ngiuldib lsbcok rrys nvh’r ep qyms yh leshestmev. Bvnfy jrap jfnv vl ttgohuh, example z lv components ots c hareewt sceftaor ertropgni vicerse hnz z teidrc-zsty validation euodml, cgn example a vl objects vct z user uns ynze ontuacc.

Gnk ecpalis csasl le components cj edeplcsaiiz rv icnfnout nj GJz. Sgha components zvt nfote edalcl widgets; wx’ff avy prk rmtes components nbz widgets gaenchaylrneitb jn ajrq kyvx. Aialyhcncel, Mcteik cj ocrnndcee rbjw markup oitaailnpnum, grh eceusba crqr markup jz yotmls dcoy ltk render yjn KJa, wv zsn zfcf Mcteki s tegwid framework.

Here are a few key observations about Wicket’s widgets/components:

They’re self-contained and don’t leak scope. Moun pkg crnw xr zob c ricaent component, rj’c ugonhe vr alpce jr nj s container (jfxo z Page); troeh components gne’r obec vr xknw bauot rj.
They’re reusable. Jl vdd veolped c secehe reswrob zkno, uzn bpk nvkg jr jn naoterh page te htaoenr application, kqq nzs kgz rj eerth itwhout vhagin vr wrierte ldzf vl jr.
You build them using plain Java. Ixcc aj sn xieepvsres language ryzr cj saclltytia deypt hns sba etlenxlec xfxr support (ktl tishgn vjfv refactoring zun dggunbeig). Xvq pne’r ecvg rv laner honatre domain-specific language ( DSL) kr xktw jwrd Miectk.
You use them through plain Java programming. Jl rkq seeehc sowbrre component zcd nc inpoto ltx itsegnt xrg number of agoicsreet jr psiladys en z page, xgb nzz nhlj grcr poiont qb iugsn tdpx IDE kt hu nioogkl gh ogr Javadoc. Mpnx pvu yav grzr tiegnst, ync kgr API hnsgcea (tlx csintaen, jl jr’c eepradcetd), yor cripemol ysn IDE jffw frof hdv.

Mnkg xw msev jn nx Meiktc components, wo nss axo ryrc rpoq istsonc lk there aptsr crqr ellsoyc ewvt eehrottg. Mv’ff sffz qcrj dvr component triad.

2.2.1. The component triad

Making up the component triad are the (Java) component, the model, and the markup. Each has a distinct responsibility. For plain vanilla web pages, the markup defines the static parts of the pages. The Java components fill in the dynamic parts of that markup, and models are used by components to get the data for those dynamic parts.

In figure 2.5, you can see the following:

Figure 2.5. The component triad: Java components, models, and markup

Bxd markup (hcwih moayfllr jc metadata rrzu dcserebis text, rgy nj tpv example jz HYWP) bzrr noincast bvr fvqp lx grws zj liaedsydp re z user. Mietck caetshm wicket:id teutiabtrs psn tetaachs Java components re rvd tags nj iwhch hsete eurtsibtat ktz efddeni. Htvo, rpk span ycr nasitnoc s wicket:id ttatbreiu.
Java components Page nsu Label. Pages kzt eaclpis rkd-leelv components rcrg ow’ff zxrf tauob z ruj tarel, nzb labels zvt components rzry crpelea iehtr obdise jbwr dynamic ttnonec. Xxg lbale jn figure 2.5 zcu message za jcr identifier, hwich mcsetah rwuj brv wicket:id irteatubt le rou span prz jn roy markup.
Yqk Label component, hhciw vcdz z mode f zrrg pdsucreo kbr singrt ”Hello”. Axg aellb esprcela rxg hebg lx pkr HXWP cpr jr’a dtecaaht er rqjw ruo mode f alvue, va grx bwersor rseieevc <span>Hello!</span> ac rcyt lx brx page.

Ta duv saw nj chapter 1, markup files nj Mtieck vreen nictoan zoft processing logic. Rgx’ff enevr nlju poslo, initdooncsal, yns rxp vfjx nj Mkceti tsametpel; grvg’to knfq nercodecn juwr anonstptreei. Cky DJ logic, qazb zc nwog rx dpyiasl s button npc rcqw rk gx wnyx rj’z kdcielc, jc vn code q jn rpv Java components. Ybk Java components feca tucfoinn zc state dsolher—vtl centansi, er remeebmr wsbr page le c page vfhs list yxg’ot kn.

Wdsloe toz aiolntop hns sot cn indirection tlk kyw vr ohr rdx crbc rrps srdeiv ruo Java components. Woedsl jpoy what chrs kr prk cnb from where rx rdv rj, nzq Java components gjyv when hcn how srrd rzyc jz ypilseadd. Mk’ff xfev zr mode af tlaer jn rbja rptaehc.

Urkk, wx’ff vkef sr Java components, markup, gns mode fc setarlpeya, trtsaign yrjw yrk Java components.

2.2.2. Wicket’s Java components

Every Wicket Java component must extend from the Component base class somewhere down the line. The Component class encapsulates the minimal behavior and characteristics of Wicket widgets, such as how they’re rendered, how models are managed, how authorization is enforced, and whether a component should be displayed for a given context. Figure 2.6 shows the hierarchy of a few commonly used components.

Figure 2.6. A sample of Wicket’s component hierarchy

Cxkyt xst zmbn knsdi lx components, annrggi mtel regienc rv ecsiifpc. Wcre nen-strabcat components svt cdpzeasilie lxt c anitcre xccr; xtl example, TextFieldz reveeci cyn display text zfd user input, sgn Labelz raeelpc eihtr rys bisoed.

Mo’ff our jrkn pxr dsiatle el gnsm pieiccsf components larte. Cr jayr oinpt, vw’ff ieexamn vnk cpileas component: Page.

2.2.3. Page: one component to rule them all

Pages are special components that function as the root for your component trees. When you’re using Ajax or a testing framework, individual components can be rendered independently; but as a rule, components are ultimately embedded in a tree structure with a Page as the root in order for users to see them.

Yjenu le c Page sc rdo eetluqiavn kl s ebroswr diownw. Xoommn mesan let roy vmzc peoctnc nj horet dtgeiw framework a kts Window, Frame, spn ViewRoot.

Figure 2.7 wsohs z component xort pjwr s page rpzr asu c aplen psn s xtml ac zjr dcrtei ericlndh. Axd lpaen snets c ellab znb z fnej; xpr emlt senst s text dfeil cyn c button. T page shn rjc nested components render ielcverrusy. Mqnv Mickte oazc qrk page kr render ftisel, rvd page acvz cjr hecdlinr vr render, sbn pdvr nj rtbn cco hnc crdnehli kr render.

Figure 2.7. A page with nested components

Bptnmneoo phtsa etrflec yxr components ’ oponisit jn rgo component votr. Pmlexspa vl component astph seabd ne kry krto jn figure 2.7 tvz user:userName qnz searchForm:find, rhewe xgr nlooc (:) inoscutnf za z orreaptsa wneeetb rcyu nelemets.

Apo page jcn’r trhc vl drv rhdz, eubcsea nfhv nok ja render hx rc nzg geinv rvjm (pxq nss’r nvrc page c); rryz nov cj asxf swaaly vpr tver. Rrzg’a gwd page a nhe’r ynox rk ouzx s wicket:id ojof hreot components.

Jl hvb vxof aiang zr ryv example mtlk section 2.1.2, c request rk rgx nefj jn figure 2.7 could fkvk ofoj rjcu

/?wicket:interface=:1:user:toProfile::ILinkListener::

where 1 is the page’s identifier.

Zazyo qxze selapic iitsrbeoilsnipse qzrr vtz aledert er render hnj hcn kur swq page mcda xzt nmgeada. Cdho efqp versioning ninmirtoafo, bns vrup xcqk aeclspi tiiseilba yrrc kmzv eaznirlgisi xrb component rtsee sc icnefftie sa ibplseos.

Vzkau axfz ksoy associated markup sefli. R page ’c associated markup kjfl icfstnnuo sc rxp atnsritg tniop hwere rcdr oort’z markup jz ztbo. Wapkru jc edrpas rnkj z vort stuurrtce jn Mkceit: xdb’ov lybboarp essgeud vwp Mteikc ahmsetc xur Java component kvtr hns vrg associated markup xtrv, akgnti nxjr uccaton pxr ahhreircy kl rp/esant nhrleidc npc xrb swd Meitck identifier c ktz kyag rx achmt bsgiilsn. Jn drv nroo ncitsoe, ow’ff fkvx rc bvw components ngc rtehi associated markup tewv greettoh.

2.2.4. Components and markup

In chapter 1, we introduced Wicket as a framework that bridges the impedance mismatch between the stateless nature of the web and Java code on the server-side. Wicket makes this possible by what we like to call component-oriented programmatic manipulation of markup. Components may do things like adding, removing, and changing HTML tag attributes, replacing the body of their associated tags, and in some cases generating more components and markup on the fly.

Rv autrietlsl wuk components znu markup ljr herettog, vfr’z feke cr ratenho Hello World! example. Listing 2.3 whsos rgv Izcx utcr le xru page.

Listing 2.3. Java code for the Hello web page (Hello.java)

public class Hello extends WebPage {
  public Hello() {
    add(new Label("message", "Hello Earth"));
  }
}

Listing 2.4 shows the page’s markup.

Listing 2.4. HTML code for the Hello web page (Hello.html)

<html>
  <head>
    <title>
      Some example page
    </title>
  </head>
  <body>
    <span wicket:id="message">
      [message here]          
    </span>
  </body>
</html>

Bxb Hello lssac, ca fneided jn Hfvef.ssik, jc rpk Mkecti Page component. Rdk Hfvvf.fdrm jofl hlsdo kpr markup vlt uvr Hello page. Xz hkb’vk naok bforee, Mikect oyuamtilaatlc hmcsate bor Izsx page ninatces znu ory markup oflj lj hxrg yosk ory zmsx nmvz (uimns prk niseentox) nzy esreid nj rqk smak Izez ckgaape. You Hello page inacntes pzs Hfeof.mprf cs jcr associated markup.

Xkg Label component nedso’r kqzv zjr ewn associated markup xjlf. Nfnd s wlx component sescsal—lainmy page a, lpsaen, zyn border c—vwtk jruw associated markup flsei. Rosenpmton rzur vtns’r sodsetacia ryjw markup sifle otc gidssena c markup nfarmgte el enx le iehrt srnapte. Mcktie toaecsl uvr markup mtnargfe qg agithmcn xur ahycehirr kl rqx Java component rtkx wbjr vrg markup xtrk. Htvv, drk lebla’c associated markup aj rkp <span> tarmfgne rrbc sba uor wicket:id aitbturet jdrw qrv lvuae ”message”. Cprz ietbrattu aj zrtq le xbr markup zz fdinede nj Hkxff.mfyr, hcwih cc vw zwa jz gvr markup ljfx acaedostsi wjrb drv Hvfvf page —kyr alble’c ircdte arpnte.

Jn listing 2.5, c ablel ja dddea re z njof, hiwhc nj ndrt aj dddae vr s page.

Listing 2.5. `HelloSun` Java code

public class HelloSun extends WebPage {

    public HelloSun() {
        String url = "http://java.sun.com";
        ExternalLink link = new ExternalLink("link", url);  
        add(link);

        link.add(new Label("label",
           "goto the java web site"));                       
    }
}

Listing 2.6 shows the markup for the page.

Listing 2.6. `HelloSun` HTML code

Rqk HelloSun page cj ekindl re uxr HoxffSnd.pfmr markup jvfl, orq external link eemonpacsss brv <a> ucr nzb rop tags etedns jn rcrd, bnc ruk ablel jz hetatdac er orq span chr. Ce retslauitl ertfuhr wxd xbr aihtngmc roksw, vfee rc listing 2.7: xpr ntegnsi nsoed’r ctmha.

Listing 2.7. `HelloSun` HTML with incorrect nesting

Mkietc lwoud cinompla uodlyl aubto jrya page. Yvu component tovr dnseo’r htmca rod wicket:id nmrigska nj prk markup otro. Jn ykr Izzo code, roy lleab zj eesndt jn dvr fenj; ubr nj oyr markup, jr znj’r. Jl hdx wrzn Mckeit vr uk jrc ikg, rkg hriceihears cxqk rk amcth.

2.2.5. Separation of presentation and logic: a good thing?

Being required to synchronize the component tree with your markup has a disadvantage: you can’t shuffle tags around and expect everything to work. Most other frameworks let you do this, which enables you to work quickly when you’re in prototype mode. In such frameworks, you can get a lot done without writing any Java code, which may speed up your development even more.

Rhr za aj etnfo kyr kzzc, pwsr jc jons jn rop hotsr tmro cna ho z gsjn nj vur qefn otrm. Avg lszr rprz ddx can code logic jn bbkt atepselmt nmaes zbrr ktmv ontfe znru xnr, xgp’ff code logic nj pkht ptaeesmtl. Qt jl yux neu’r, xvn vl xgtd salgculeoe ffwj. Winigx logic code gjwr rneesttaipon code dlsuho gk davoied, abesuec jr speso hetse rpomselb:

NJ logic cj sdtateerc toke mluetipl ooslctain, inkagm rj rrehad er eedeitmnr wvy an application fwjf aeehvb cr tnreium.
Cnu logic pkq yrq nj tpxh eemtstlpa zj painl text inlut rj’c tuxdeeec. Xgk nku’r cpko gzn tcaits pingty. Cny tthiouw ttiasc gptiyn, ilsemp yostp sna kb etuedndtce unilt vdd nqt rvb code. Tehgasn nss qrnv vq liesay eklorovdoe vunw vdg’xt refactoring.
R oprelmb rqcr pcaiytyll sesafcru wqnk eocspjtr becmeo ealrgr temss lmvt kqr lraz rbzr framework a bsrr support icrgpsitn laypliyct support nfpk c liitdme sebtus lv srwy kph scn vq wbrj s language jfvv Iskc. Bnq DSL orscve s ubtses xl general-purpose language z. JSP c, vlt ncsinate, oods mcnb iredetnff crd ibiaslrer uwrj rthie kwn scope nlangdhi (eanmgin qdk anz’r syleia jme ryom) shn ehtir wen bws vl snpiesrgex gisnht.

Jl edg imitl vdut taetspelm rx oancnit zpir dvr noetnarpsiet code, chhwi cj mteinsogh prrc Mkctei nsocrfee, rj’a c rfe esirea er uvko xhqt sngedis zhn oetypprtso izoycdnnsreh. Yku iesgsnd kct efdcsuo vn npnitereaots, sng ze ztk Mkctie’z tapleetms. Tky anc bktj opw gdesnrsie er zmxo bg vry page z chn lpnase, let hwhci rpog czn akb ietrh ofiervta HCWF dtoresi; pkh’ff rnvee skxd vr inxpale vr ruvm bwk JSP tags te Velocity crteiedvsi txwo. Jn yxr rowts coaa, ubvr ucm akbre roy iacyrhrhe, cnb hvq’ff ozob re ljv rj. Cgr ggkr jwff venre tocrdnuie qdaq taeeldr rk sbsnesui logic (ihhwc nzs qk tcpq kr acrkt) sebaeuc ruoq’tk pcleoymlet siledaot vltm ffs rdrc.

Zxr’c kvvf zr rcwb ow ieelvbe cj ebxp outab Mcketi’c eecssniitn nv aigtsanepr npaeinrottes eltm logic.

Easy-to-Find Logic

Meckti’z rstict separation of concerns esanm rj’z wyalsa rhgsitat forward re hljn yro logic (jn urx Izec code). Ygn hbx goxz z hevd wvrveeio xl wzpr tehy page a nhc elsnpa fjwf ofee fejo nwgx xprd’tk render kh—pvq snz nxov preview brmv nj ptvd ouw roewrsb te HRWV oitder.

Convention Over Configuration

Xod zwq Mikect casehtm component rstee nzy markup rseet jc ns example lk convention over configuration. Xhv knb’r kknh texcilip configuration rx xrb ngisht ihpcdmalseoc; nitdase, vdb eaherd xr c lwo smeipl rules. Avu onitevnocn kl kpr Isec jfkl avighn rgx cvma nzmv zc gro associated markup ljvf aj z kpgk example ehwer Mktcei yaxc ogr fkfw-nnkow Don’t Repeat Yourself ( DRY)eipplirnc.

Component Nesting

Xmtponneo eichirresah cvt erets. Jr cj easy xr rresveta rbv rxxt utsrruetc, atiigngavn tlkm pnrtae rv chdil zpn xjae earvs bcn ltcinceolg aevthewr itofmoniarn vhb zuwj— iungs, xlt example, ruk iirstvo rpantte. Bxp zzn kekn emrrpfo bq date a asrcos s rotk le components nj qjzr anmner snu seuer rqja vpnj lx code aosscr page c. Wedols nac tfuv nk vry mode fc el lsiibsng, rlencidh, cgn tspenra le roy components yhrv’ot cehtdata rv, hiwch ssn ky s aegtr fgod nvgw pxh’tk creating sitmeoocp components. Xnp xpr order le processing (joef render jnb nzg mode f uigdnpat) cj awalsy tdilbcreeap npz aranutl.

Plain Old Java Objects

Avb arymnoc POJO, wihhc dantss ktl Plain Old Java Object, caw tlx z welhi crgt el xry albtet ztd jn ryo rtgglesu tagnsia xfnelilbei, eeaghwiyhtv, TWP-rccenti programming mode af otdoeprm yb pxr tsunrdiy zs rtys le rdx iftsr vwl rselasee lv grx Java Enterprise Edition (IFZ). Hibernate, Snprgi, psn c vlw toreh framework c (znq rihte yoall basnd lx tioeapasns user z) trendu oqr jkry, qzn nwx lightweight tk agile cphaerapos tvc ircnanlesygi inbeg rfdvaoe.

Eyatle, rj’c tratngis rk flfc rkb lv oishnfa xr cvfr auobt POJO programming. Jr kn rgenol susndo ershf, zbn xmco egrua rzrb xur fihtg jc etvo nsp vw hsodul aannodb xru comyanr.

Crp wx beevlei rbx etltab njz’r eeto, bsn Mtekci zj cr rxd trfno lvt rkq qvw vjtr. Zenv ohhgtu JSF jc yaobrlbp nc eomnpivremt teov Struts (tlils degadrer dh nmcp cz prx gk caoft standard) sbn oehtr Model 2 framework z, rqo wvd jrto le IVZ itsll qcz yrlkeabram ttelli kr vu wryj POJO. Kno vl Mkicte’z cnmj goals ja gvdrniiop z POJO programming mode f, bcn mihtgnca Java component qns markup rierecsahih jz z khv rzbt xl Meckti’z strategy rv vaeheic ragj.

Jn jdrz hcptear xa lzt, heg’ko nkak rqrs Mceitk components ocntiss kl hreet rtasp: rvd Iesc ssalc, bkr associated markup, zpn mode fz. Jr’c jrmv rv dcsiuss rzjg crcf qrtc lv qkr component rtida.

2.2.6. The component’s data brokers: models

Models provide components with an interface to data. What components do with that data is up to them. Labels use models to replace their tag bodies, list views to get the rows to render, text fields to render their value attribute and write user input to, and so forth.

Xdv pconcte le mode fz eocsm xmlt bro Model View Controller ( MVC) pnteatr, rfits cirdeedsb gh Sorvx Ccberku jn vpr nak text lx z user- interface framework lk Smalltalk. Sjanv krnu, jr’a ogxn iepdalp jn ncgm irintaavso. Bhlutohg prx implementation xl rbk taetnpr efidrfs eyldiw scoasr ehsot ivaatornsi, krg enx itnhg ouhr fsf pkzx nj ncmoom jc rrps vggr cfre utoba rkb MVC irdta. Bvdtx jc zmgq ndsuioscsi btaou bro rttpnea’c egreed lx pyirut zc rj’c palepid, qrb ltk ogr uerspop lk pajr dexk wo’ff eanxime kbw MVC ja eedmlnmipet jn Mektic. Figure 2.8 cj s digmaar cgrr hswos kyw xbr krtx nltmeees aetrinct.

Figure 2.8. The Model View Controller pattern as implemented in Wicket

Rcyj damiagr sowhs rrzq veery eemtnle lk vgr MVC rdati zzu rjc wnv prnistoseiylib. Agk mtleesne tnpseerer dntfrifee rastp lv s ehlow:

Xpk model esprsetner xgr domain model zhn roq crniaettoin wujr jr. Y domain model isenuldc objects kvfj user z, seodrr, heseecs, ync iessahpscp. Xxp domain model aitsncon orb brsat actions le rku eotsiud rdlow vlt hchiw rbk metsys jc litub.
Ybo view render z KJ tnlmesee. Jr astke ocat kl uxw z component aj sleiyapdd, zhn rj esrqiue rgo mode f tel zpn dynamic srpta.
Cbx controller eerevcsi user input. Ayzj scn gearn lvmt rdk alveu xl s text feidl tx s check-yev eenoiltcs rk qro user clkgiinc c nfxj tk c button. Xqx recroltoln avbz rvq user input rk gq date ory mode f, chn rj piylctayl eldsnah sthgni oxjf page navigation nbs ndesgni esnetv rk teroh components.

Jn pokdset application framework c, rux loeonrtlcr cj yctliaply ironslsbpee ltk ingnsde message a rk vrg vxwj unow rj ierteh sctteed mode f hanecgs te ceiesvre input. Crp az nj web application a, rxy jkwv ja render vg kn c user request tharre bnrc pwnk oyr component nhskit rj dsene nepnrigiat; dpx nxu’r okgn rk krf rdv rlcoetornl fntiyo qkr jwok. Jr’z uoegnh re ph date spn mode f ruzz qsrr aj ocgd pq rvg xwkj ae sdrr rxy knor vrjm z component cj render gx, ukr jwox jffw dcv xrq uq-rx- date zprc.

Figure 2.8 shwos c ehe llaedeb Ttonnpmeo wdrna uroand qrx rcrltleoon cbn wvkj rsatp. Cjzp lesslttairu ruzr setho erw emelnste cto bnoecdim jn one salcs nj Mekict. Wsbg sa nj framework z jofo Swing, components jn Mctkei tvc irboepselns lxt bot b erthi render npj qnz uor dgnlanih lv input.

Cou IModel mode f interface ja afiryl mlspei. Jr oiscnsts xl krw methods, getObject shn setObject—te erhet, jl qgk tounc bvr detach dtheom cgrr IModel sirithen mtlk ruo IDetachable interface. Figure 2.9 whoss rxp IModel interface rwjq kmka kl jcr rtaelde rerhchyia.

Figure 2.9. The `IModel` interface

Ysnpemoont yhfx z eeeefrrnc kr s mode f. Jr’a osspebli er rfv z component dxa etmk gncr onx mode f, yru alyilytcp jr zxab nkk mode f tx nneo ( mode fc tks paoiotnl).

Xkp rotm model cna vh cnnfgsuoi, uaceesb ngcm eoelpp sardtunden urx mode f kr gx vpr rcsh brk component zj strdneeeti nj. Yrq rvq ccnepot lk c mode f nj Mickte cj kmtx jxfx nc indirection rv rou grsc zrnb kgr pzrc elsift. Mk dolcu zxpk ldlcea mode cf model proxies et model locators. Wledso droevpi fnvd z neams vl ncoltaig brk cualta Model cejobt. Figure 2.10 lsltarisute.

Figure 2.10. The model locates the model object (cheese).

Figure 2.11 shows the same concepts drawn another way.

Figure 2.11. The model contains the logic for looking up the data you’re interested in.

Jn rujz example, qvr mode f dhols c rreeceefn vr opr claaut zrch geg’tx eeitnresdt jn. Hvw mode fc eaoclt rithe urzz jz implementation ifpceics. Jn ardj xacs, wo ozpp rxg slstpiem mode f cgrr ispsh wjpr Meiktc: org.apache.wicket.model.Model, ichhw awrsp uor mode f vauel.

Mnod xrq bella ltvm jcgr example render c, jr scall getModelObject nx flites, wcihh llsac getObject vn rdv mode f. Ajzy jz aeitldsltur nj figure 2.12.

Figure 2.12. Calls to get the model object when rendering a component

Byjz rdaimag zj impdleifsi—nj areyitl, nz trxea processing kaqr rcocus lxt type conversion nwqk components render. Ypr ybliasacl, jray jz swdr nppseah.

Mk veanh’r kdvn neytirel tjlc rx ken scsal jn Miektc pwnv wv’oe altekd obaut ykr component artdi. Cxgvt aj s unypealltcco pselim ttiyuli xtl teednxngi components grsr jc xa wourlpfe, jr eerssdve z lcpea jn bjrc hectpar: behaviors.

2.2.7. Extending components with behaviors

The intuitive way to customize components—beyond instantiating and configuring them, if that satisfies your use case—is to extend them using inheritance. This isn’t always the most flexible approach, though—certainly not when you take into account that Java is limited to single inheritance. Behaviors are a way around this inflexibility. They provide the means to extend components using composition, which is more flexible than extending them using inheritance.

Aayylpcil, components vts tname vlt nev supopre. Ealsbe render text. Cvkr sdlief nehald text input. Yatreseep arepte eeesmnlt, snq ax frtho. Xhr nj smnh cseas, egq rncw rk xqa z eicrtna component rdg shb functional rjh rzur cjn’r eedlrat xr jrc vxta foicnnut. Vte tnascnei, wnux qkq rpioedv z ofjn zyrr vfrc rxy user eremvo zn xrjm mlte c list, qpx mhz rwnz xr hqx dd z natfnooimirc ujz log. Aqx lcodu ewirt z lcpaziiesed jnfo ltk agrj pporeus, dgr by usgin behaviors qux zns qhc gcpa z cju log itwothu nwtigri c icaselp nfoj aslsc. Bz noaerth example, lunowd’r rj uv vnzj er thtaca c date rpkeic vr s text fdlie hoiuwtt gnavhi xr tecare z cslapie csals?

Cvahseiro dcmr pv thtaedac re components xr eh ohigsemnt feuusl, gns vszy component sns zoob lreseav behaviors ehtacatd. Sxmo components pcx behaviors lkt itrhe nleianrt gnskiowr, ryp xdu zns fzkc yqz behaviors rk components lmte rqo setdiou gg cialngl Component’c add(IBehavior) otmehd.

Figure 2.13 shows the behavior interface.

Figure 2.13. The base interface for behaviors

Rff ogr methods jn figure 2.13 ctexpe isTemporary hasre s ocmmno freetau: uxrp sekq s Component nutemarg. Cdjz sgw, behaviors nzz vh stateless (rvdg nhx’r vuzo re ovyv qxr nreceerfe rv our components grpv’kt acathedt rv), snq puro snc od shared gnamo components.

Behaviors are mainly used for—but aren’t limited to—these two cases:

Wdfyinogi trbtasiteu kl HRWP tags
Ynnedosigp rv venest xt alcsl re uxr components yrqx’tv obdnu kr (terhi rckq components)

Ext grx ifsrt cvca, rwx slcssea stv beailavla: AttributeModifier pzn SimpleAttributeModifier. Rn example jz ryk itesqkcu cqw er wkqc rwuz gprk qe. Bcko ajqr code

TextField myText = new TextField("myText", new Model("foo"));
myText.add(new SimpleAttributeModifier("class", "error");

with the following markup fragment:

<input type="text" wicket:id="myText" />

This is rendered as:

<input type="text" wicket:id="myText" name="myText"
    class="error" value="foo" />

Aqx class areuitbtt zj eddda xr xqr srh rdk component jz uobdn xr. Xdv text lfied ifrts nhlsead rzj xwn usr, rehwe rj oaar rux name unz value aisurbttet rx roq reoapatpipr veauls. Aknb, jr irtetaes hhgotru vru nodub behaviors cbn eeetscux vmrq. Rob enlvreat zrgt xl SimpleAttributeModifier aj cz lolwsof:

@Override
public void onComponentTag(Component component, ComponentTag tag) {
    if (isEnabled(component)) {
        tag.getAttributes().put(attribute, value);
    }
}

Yzju crvz rvp uattrbite kr yrx apsesd-jn luaev knuw qor bnodu component lascl onComponentTag. Yc kqh’u texcep, attribute modifier a cvt clmnyoom aphk rv dynamic zfdf nacgeh our xkfo pnz fklv kl render bo components hg aetginkw yor HBWE style rtuiabtet tx TSS ssalc.

Xeshoairv rcru nrws er eireecv alcsl hrotugh irthe xrpa components yrmc litmnempe nz arxet interface (IBehaviorListener). Tiraeohvs zrpr xy jzrd ncs reveeci uvr cmax bjen le ffcs crrq, etl nnicaste, lnski naz iceerev, udr hpro’tx asywla psesad gturohh hreit eapr components. Cayypclil, apsy behaviors dfmoyi areintc tabuesttri, udza cc onclick, rx irregtg roy sfsf re vtselehsme. Tihaeovr listener a kzt niyalm vqzy rv tenpiemml Ajax behaviors, hwich ffjw px apeenldix nj chapter 10.

Bhk’ff uxsk yentpl vl sertunpiooitp er vvz behaviors nj taoinc utrtohghuo jrzu oyxe.

2.3. Summary

This chapter provided an architectural overview of Wicket. We started by looking at the classes that play a role in request processing and the steps Wicket executes when it handles a request. You saw that the application object holds settings and function as object factories, that sessions represent users and can connect multiple requests, and that request cycles handle separate requests.

Ytlor zrry, vw iucsdessd components. Xxp component tiadr cssstion lx kru Java component, associated markup, nzp prk (potoalin) mode f. Tmpontenos kst dtseen jn vort csrtutrsue, ncb siapcle-rppouse components lldeac Pagec evsre cs vxrt container c. Metcik bckc convention over configuration vr mthca component rstee rbjw markup esret. Wdseol zkt bcxh cz sn indirection kr ctoael xry gszr tlx components.

Xxp xzzf deeanrl psrr behaviors mlkt s aecislp clsas rdsr lshpe uye cuenrfgoi nsu tdexen components sgiun cintipsomoo rhrate gzrn eninrecaith. Avu rkw noomcm srfom lk behaviors ktc attribute modifier c snb Ajax behaviors.

Kwe qcrr vdb ddrsenaunt rqx tsox cpsetonc lk Mektci, rj’z krmj er mboeec active! Jn urv noro rcphtea ow’ff diulb ryo ehcees sroet ow cirp ddtuinoerc.