Yahoo! User Interface Blog (YUIBlog)

Atjaunots: "MakeNode" logrīku Extension

Redaktora piezīme: Šis raksts tika sākotnēji publicēts šī gada sākumā . Kopš tā laika MakeNode modulis ir publicēts Yui Gallery un saņēma dažus uzlabojumus. Šodienas raksts atspoguļo visas jaunākās izmaiņas MakeNode.

Manā iepriekšējā rakstā par 3 Yui Application Recipe , es parādīja veids, kā izmantot Y.substitute kā ļoti pamata veidni procesoru. Ideja bija dzīvi no turienes, ar ieteikumiem no datiem # Yui IRC kanāls folks, un es to Widget paplašinājums, kas ir pieejama Yui Gallery, ko sauc MakeNode . MakeNode nav sugas veidni procesoru un tas nav domāts kā viens. No otras puses, tā ir cieši integrēta ar Yui logrīku fonds klasē, tostarp klases nosaukums un notikumu palīgi un internacionalizāciju. Šajā rakstā es būs veikt Spinner piemēram un pārveidot to, ievērojiet šīs vadlīnijas no mana iepriekšējā rakstā un lietot MakeNode. MakeNode ir pieejams kā galeriju sastāvdaļa, kā arī modificētu Spinner komponentu un piemērs , kas tiks izmantoti šo rakstu .

Paplašinot savu sastāvdaļa

Lai ielādētu MakeNode jums nepieciešams iekļaut moduli jūsu YUI().use() pārskats, izmantojot nosaukumu 'gallery-makenode' vai, ja definējot moduli caur YUI.add() , sarakstu tā kā requires masīvs. Tad, lai paplašinātu savu widget, varat uzskaitīt to trešo argumentu, lai Y.Base.create() , piemēram:

  Y. Spinner = Y.Base.create (
      "Spinner"
      Y. logrīku,
      [Y. MakeNode],
      {
         / / Instances tiesas locekļi ...
      },
      {
          / / Static locekļus
      }
 ); 

Jūs varat pievienot MakeNode pa jebkuru skaitu piemērotu paplašinājumus logrīku, piemēram, WidgetParent, WidgetChild, WidgetStdMode utt MakeNode pievienoti divi aizsargātas metodes, ko izmanto attīstītājs, _makeNode un _locateNodes, un tas būs redzams no vairākiem statiskās īpašības, ja atrasts .

Visas šī pagarinājuma locekļi ir vai nu aizsargāti vai privāta, jo tie ir domāti, kas jāizmanto komponentu izstrādātāja un nevis ar īstenotājs izmantojot šīs sastāvdaļas, kuriem nevajadzētu būt bothered ar tiem. Neaizmirstiet pārbaudīt "Show Protected" variantu, skatot API docs .

Definēšana veidni

Pirmā lieta, jūs parasti darīt, ir noteikt veidni jūsu sastāvdaļu. Par Spinner, mūsu veidne tiks:

  _TEMPLATE: [
     "<input Type="text" title="{s input}" class="{c input}">",
     "<button Type="button" title="{s up}" class="{c up}"> </ pogu>",
     "<button Type="button" title="{s down}" class="{c down}"> </ poga> '
 ] Pievienoties ("\ n")., 

Noklusējuma veidne parasti tiks nosaukts _TEMPLATE un paziņoja gar citas stacionāras īpašības no klases, piemēram, ATTRS . MakeNode izmantos šo veidni, ja neviens cits, ir skaidri paredzēts. Veidne ir izgatavota no plain HTML plus vietturi liek figūriekavās, katra no viena rakstzīme (apstrādes kodu), un kam seko viens vai vairāki argumenti sērijas. Vietturi un ko tie ražo, ir:

• {@ attributeName} konfigurācija atribūta vērtību

• {p propertyName} piemēram īpašuma vērtība

• {m methodName arg1 arg2 ….} atgriešanās vērtību minētās metodes. Apstrādes kodu seko metodes vārds un jebkuru argumentu atdalīti ar atstarpēm numuru.

• {c classNameKey} CSS klases nosaukums, kas iegūti no _CLASS_NAMES statiskā īpašumu (sk. The _CLASS_NAMES īpašumu tālāk)

• {s key} virknes no strings atribūtu, izmantojot key , kā sub-atribūtu.

• {? condition valueIfTrue valueIfFalse } līdzīgi ?: operators JavaScript, novērtē uz valueIfTrue , ja nosacījums ir truish, valueIfFalse citādi.

• {1 condition valueIfOne valueIfMore } izmanto, lai ražotu vienskaitļa / daudzskaitļa vārdus, balstoties uz vērtību stāvoklī.

• {} jebkura cita vērtība tiks apstrādāti tāpat kā Y.substitute nav.

Piemēram, {@ value} tulkos uz this.get('value') bet {p value} pārveido uz this['value'] .

Kad vietturi ir argumenti, piemēram, {m} , {?} un {1} , stīgas ir ielikts pēdiņās. Cipari, booleans un null (visi nekotētas) tiks parsēt, lai to pareizu datu tipu. Vietturus var ligzdot. The {?} un {1} vietturi parasti ietver ligzdotu viettura stāvoklī un ļoti iespējams, to vērtībām, piemēram:

  {P Daudzums} {1 {p Daudzums} "vienība" "vienības"} 

Ja īpašums qty ir 1, tā novērtēs, lai "1 unit" , 2 vai vairāk tā atgriezīsies "2 units" un tā tālāk. Padziļinātai versija, kas nodarbojas ar nulli būtu:

  {?  {P Daudzums} "{p Daudzums} {1 {p Daudzums}" vienība "" vienības "}" "none"} 

Ņemiet vērā, ka datu apstrādes iekšējo vietturi, ja virkne rezultātu, ir liktas savu kopumu pēdiņas.

Lai iekļautu dubultu quote iekšā pēdiņās, izmantojiet \\" , dubultā slīpsvītra ir nepieciešama tādēļ, ka JavaScript interpretēs viens un izmet tos, pirms tā kļūst MakeNode Tikai pēdiņas ir atļautas;. MakeNode neizmanto eval() tā, Sadalīšana ir ierobežots, bet droši kaut kas, bet numurus. null , booleans un dubultā citēto virknes tiks ignorētas.

The {?} vietturi ir ērti izmantot ar izvēles rūtiņas un radio pogas. To var izmantot, lai ražotu virkni "checked" atkarībā no patiesības vērtību apstrādes instrukciju kods, kas seko. Tādējādi <input type="checkbox" {? {m getLength} "checked" ""}/> <input type="checkbox" {? {m getLength} "checked" ""}/> ražos atzīmēta izvēles rūtiņu, ja getLength metode atgriež neko, bet nulle.

Attiecībā {c} vietturi, mums ir _CLASS_NAMES īpašums definēts.

Papildu vietturus var pievienot MakeNode, pievienojot tos _templateHandlers hash.

_CLASS_NAMES Īpašumu

Kopā ar ATTRS un _TEMPLATE statiskās īpašības, mēs varam definēt _CLASS_NAMES statisko īpašums, kas norāda uz masīva stīgas. Katra no šīm virknes, tiks izmantoti, lai radītu klases nosaukums. Tādējādi _CLASS_NAMES: ['input'] ražos klases nosaukums "yui3-spinner-input" . Šie classNames tiek saglabāti instancē īpašuma this._classNames . The {c input} vietturis veidnē iepriekš tiks aizstāts ar "yui3-spinner-input" . Es aicinu stīgas uzskaitīti _CLASS_NAMES , piemēram, 'input' , tad "klases nosaukums atslēgas", jo tās var izmantot kā atslēgu attiecas uz faktiskajiem klases nosaukums vai elementus, kas satur šīs classNames, kā mēs redzēsim vēlāk.

Jūs varat izmantot _CLASS_NAMES īpašumu, lai radītu neierobežotu skaitu classNames, vai jūs tos izmantot veidni vai ne. Jūs joprojām varat sasniegt šos papildu classNames no iekšienes this._classNames . The klases nosaukums tiek ģenerēts, izmantojot yui3 prefikss seko vērtību NAME statisko īpašuma pagriezās mazo burtu, un tad string dots _CLASS_NAMES (šis pēdējais nebūs ieslēgta mazie burti), visi atdalītas ar defisēm. The _classNames hash būs arī ietver classNames par boundingBox un contentBox , pirmais zem "boundingBox" taustiņu un otro ar "content" taustiņu. Widget Priekšlikums uzliek boundingBox the classNames izriet no vērtību NAME īpašums katra no mantojuma ķēdē klasēs, sākot ar yui3-widget . MakeNode veikali vērā this._classNames tikai top-visvairāk klases nosaukums ar boundingBox .

Ja WidgetStdMod modulis ir piekrauts, MakeNode arī radīs pieteikšanu HEADER , BODY un FOOTER sekcijas ar tām pašām atslēgām, kas ir arī konstantes definētas šajā pašā modulī.

Ja sastāvdaļa ir vairāku līmeņu attālumā no logrīku, piemēram SuperSpecialSpinner pārmantotas no SuperSpinner kura manto no Spinner kurš pārmanto no Widget, un, ja kāds vai visi no tiem ir _CLASS_NAMES īpašības definētas, MakeNode ražos classNames viņiem visiem, un tos saglabāt this._classNames . Jums nav nepieciešams iekļaut katrā līmenī nosaukumus jau deklarēts iepriekšējos līmeņos. Faktiski, tas ir labāk, ka jums nav, jo classNames uzrāda katrā līmenī izmantos vērtību NAME īpašums, līmeni. Tādējādi SuperSpecialSpinner , {c input} joprojām rezultāts "yui3-spinner-input" un nevis "yui3-superspecialspinner-input" un tā tas saglabās jūsu CSS failu vēl ir derīga.

{S} vietturis

Widget ir strings konfigurācija noteikts atribūts, lai gan tas nav inicializēts ar jebkuru vērtību. Šis atribūts ir domāts turēt virknes, kas ir redzami (vai, izmantojot ekrāna lasītājus, nolasīja) lietotājam. Ir svarīgi, ka jūs nekad arī redzams stīgas tieši veidnē. Tas nav prasība MakeNode - tā nekad nav laba ideja vispār. Visas virknes, kas ir jāredz, vai lasīt uz lietotāju vienmēr novietot strings atribūtu. The strings raksturlielums satur hash kur katru atsevišķu tekstu atrodas tās atslēgu. The Spinner elements ir šādas stīgas, kuru jūs varat redzēt, ko izmanto veidņu iepriekš.

  virknes: {
     vērtība: {
         ieeja: ". Nospiediet bultiņu uz augšu / leju taustiņus nelielu pieaugumu, page up / lejup lielas pieaugumu",
         uz augšu: "Pieauguma",
         nosaka: "samazināšanās"
     }
 }, 

Labākā daļa no darot tas, ka jūsu komponents var būt lokalizēti uz citām valodām ir ļoti viegli, izstrādātājiem, izmantojot savu sastāvdaļu. Veidojot gadījums Spinner, jūs varētu darīt:

  var mySpinner = new Spinner ({virknes: Y.Intl.get ("spinner')}); 

Iestatīšana konfigurācija atribūts strings šādā veidā aizstāj noklusējuma strings vērtības, ar tiem no valodu resursu failu, izmantojot valodu, iepriekš definētām. The {s} vietturis piekļūst virknes glabājas strings atribūtu vai nu pēc noklusējuma piedāvātos vai tulkots tiem, ja kas. The {s xxxx} vietturi ir gandrīz kā lietojot {@ strings.xxxx} izņemot to, ka vienuviet rezerves virknes var būt vietturus, kas būs tālāk apstrādā. Tas ir svarīgi, tulkojumiem, jo ​​sintakses lai atšķiras no valodas uz valodu, un tas ļauj pārfrāzēt tekstu, tostarp tā vietturi, lai pielāgotos jebkurai valodai. Stīgas var arī piekļūt, izmantojot {@ strings.xxxx.yyyy.zzzz} , kas ļaus piekļūt stīgas Nested dziļāk uz leju, un novērstu turpmākas maiņas. Cirtaini bikšturi var iekļaut tekstu, izmantojot {LBRACE} un {RBRACE} kā vietturi.

Izmantojot _makeNode in renderUI

Mēs izmantojam veidni, lai izveidotu iezīmēšanas mūsu sastāvdaļu. Lai to paveiktu, mēs varam zvanīt MakeNode s _makeNode metodi, piemēram:

  renderUI: function () {
     . this.get (contentBox) pievienot (this._makeNode ());
 }, 

Tas aizpildīs contentBox mūsu widget ar atzīmes no pārstrādes veidni. The _makeNode metode atgriež gadījums Y.Node , kas var būt pievienota vai jāiekļauj nekur vai arī vienkārši tur vēlākai izmantošanai. Tas neatgriežas string, tā ražo Node instancē. (Ja jums nepieciešama stīgu un nevis Node, jūs varat izmantot _substitute metodi, kas paredz, ka jums iet ar veidni.)

The _makeNode metode ņem divas izvēles argumenti: atsauce uz veidni un objektu aizpildīt vietturi, kā Y.substitute dara. Mūsu vienkāršs Spinner piemērs ir viens veidne visam widget, bet citi widgets varētu prasīt bitiem un gabali izgatavoti no vairākiem veidnes. Tādā gadījumā jūs parasti zvanu _makeNode bez galvenokārt, paredzēts, argumentus un sauc to vēlreiz ar dažādām veidnēm, lai aizpildītu papildu daļām. Piemēram satur šo renderUI metodi:

  renderUI: function () {
     var fieldset = this._makeNode ();
     this.each (funkcija (vienība) {
         fieldset.appendChild (this._makeNode (MultipleTemplates.RADIO_TEMPLATE, postenis));
     }, Šis);
     . this.get (contentBox) pievienot (fieldset);
 } 

Pirmais zvans _makeNode atgriež Node piemēram noglabāts mainīgajā fieldset . Paraugu sastāvdaļa ir arī paplašināta ar Y.ArrayList lai RADIO_TEMPLATE tiks aizpildīti ar vērtībām ņemti no posteņiem, kas glabājas masīvs sarakstā, un no tā izrietošo Nodes pievienots fieldset pirms tā beidzot pievienots contentBox . Īpašā vietturi, piemēram, {@} vai {p} vēl aizvien norādīs uz atribūtus vai īpašības galvenais objekts. Ligzdotu posteņi tiks apstrādāti tāpat kā Y.substitute būtu.

_locateNodes Metode

MakeNode turklāt paredz _locateNodes metodi, kas mēģinās atrast visus elementus ar classNames deklarēto _CLASS_NAMES . Lai atrastu konkrētus elementus var nodot neierobežotu skaitu klases nosaukums atslēgas, pretējā gadījumā, _locateNodes mēģina tos visus. Katram, kas atrodams katras klases nosaukums, _locateNodes ražos privāts instances īpašumu, izmantojot pasvītrojuma prefikss seko galvenais vārds un "Node" piedēklis. Tādējādi, mūsu Spinner, piemēram, _locateNodes radīs īpašības _inputNode , _upNode un _downNode . Ja vairāki elementi ir vienādas klases nosaukums, _locateNodes atgriezīsies atsauci uz pirmo no tiem. Ja elements nav atrasts neviens mainīgais tiks izveidots.

Jo Spinner sastāvdaļa mēs izmantojam _locateNodes pēc rada atzīmes:

  renderUI: function () {
     this.get (CBX) pievienot (this._makeNode ()).;
     this._locateNodes ();
 }, 

_EVENTS Statiskā īpašumu

Vēl viens īpašums var definēt gar līniju _TEMPLATE un _CLASS_NAMES un tas ir _EVENTS . _EVENTS saturēs hash, kas sastāv no klases nosaukums atslēgas, katra satur hash notikumu veidiem un metodēm rīkoties ar tām. Labāk ir izskaidrojama ar piemēru:

  _EVENTS: {
     ieeja: "mainīt", / / ​​zvanu this._afterInputChange
     boundingBox: [
         {
             tips: "atslēga",
             fn: '_onDirectionKey', / / ​​zvanu this._onDirectionKey
             args: ((Y.UA.opera) "paredz:"!? "preses") + "38, 40, 33, 34"
         },
         "Mousedown" / / zvanu this._afterBoundingBoxMousedown
     ],
     dokumentā: "mouseup ', / / ​​zvanu this._afterDocumentMouseup,
     Y: "broadcastingObject: someEvent" / / sauc šo ["_afterYBroadcastingObject: someEvent"]
 }, 

_EVENTS ir objekts (hash) ar jebkuru ierakstu skaitu. No īpašības vārdiem, tas ir, atslēgas hash, noteikt mezglus, kuru notikumu, mēs klausīties. Tās ir tās pašas klases nosaukums atslēgas noteikts _CLASS_NAMES . Ir vairāki extra īpašu atslēgu:

• "boundingBox" attieksies uz izgriezums pati.

• "document" attiecas uz dokumentu, kas satur šo widget.

• "THIS" attiecas uz widget sevi

• "Y" norāda uz Y instancē.

Ja Widget ir pagarināta ar WidgetStdMod, kā arī, atslēgas HEADER , BODY un FOOTER attieksies uz tām sadaļām, jo tie būs pieejami _classNames hash. JavaScript nav nepieciešams atslēgas citēt, ja tie ir derīgi identifikatori, lai neviens no iepriekš minētajiem nepieciešams noteikts.

The _EVENTS īpašums apstrādā pēc tam, renderUI , bindUI un syncUI metodes ir sauc tā widget būs jau ievietota pašā dokumentā organismā, citādi "document" identifikators nebūs.

Par katru no šiem elementiem ir notikums identifikators vai notikumu identifikatoru masīvs. Ja var noteikt, pasākuma veidu, lai klausītos vai ar sīkāku informāciju objektu. Pēc noklusējuma MakeNode izmanto kā klausītājs metodi nosaukumu, izmantojot "_after" prefiksu seko elements identifikators ar pirmo rakstzīmi kapitalizē seko notikumu ar savu pirmo rakstura tips kapitalizētas. Koda bloks iepriekš tekstā redzami metodes aicināja katru notikumu.

Ja identifikators var būt objekts, kuru īpašības type , fn un args . The type ir obligāts, un norāda notikuma veidu uzklausīti. The fn īpašums dod nosaukumu, metode, kas klausās gadījumā, tādējādi novēršot automātiska nosaukumu. Tā _EVENTS ir statisks īpašuma drošību, tā nav piekļuves this , lai tas nevarētu faktisko atsauci uz metodi, tikai tā nosaukums. The args argumentu var izmantot, lai iet citus argumentus, lai zvanītāju, piemēram, ar key notikumu, kas prasa atslēgas specifikāciju.

MakeNode izmantos Node.delegate lai klausītos notikumiem elementiem ietvaros boundingBox , vienlaikus turpinot izmantot Node.after lai klausītos notikumus no boundingBox un dokumenta struktūra. Tā izmantos this.after lai klausītos notikumiem saskaņā ar THIS atslēgu un Y.after klausītājiem, kas uzskaitīti zem Y taustiņu. Visi notikumi tiek uzklausīti, izmantojot pēc pasākuma klausītājiem, jo tie ir domāti, lai widget reaģētu uz notikumiem, nevis filtrēt uzvedību, iebilst, ka ugunsgrēki viņiem, lai nekādā gadījumā šos pasākumus var novērst vai pārtraukta. (Piezīme: klausoties key notikumu jebkurā Nested elementu strādā tikai ar versiju 3.4.0pr1 un vairāk, jo delegācijas key notikumu nebija pieejami pirms visas citas funkcijas darbam ar iepriekšējām versijām, kā arī.).

_EVENTS deklarācijas ir kumulatīvi, kad sastāvdaļas mantot viena no otras. Katrs mantojuma ķēdē klasei būs savs _EVENTS deklarāciju apstrādā atsevišķi.

_ATTRS_2_UI Statiskā īpašumu

Events iet abos virzienos, no UI komponentam un no komponentu UI. Pirmie risināšanā, _EVENTS īpašumu. Tad vēl ir notikumi, kuros izmanto atribūtu vērtības izmaiņas, kas ir jāatspoguļo ar lietotāja interfeisu. Kā es minēts iepriekšējā pantā, ja pastāv sekundārais efekts maiņu konfigurācijas atribūts, tiem būtu jārīkojas pēc izmaiņu gadījumā klausītājiem, nevis izvēles setter metode atribūtu, kas nodarbojas tikai ar normalizētu vērtību, tiek noteikti. UI jāatspoguļo stāvokļa konfigurācija atribūtiem, vispirms syncUI , kad tiek inicializēts, un pēc tam par katru atribūtu maiņa notikumu. Attiecībā uz pēdējo mums ir nepieciešams pievienot notikumu klausītāju, ko mēs parasti darīt bindUI . Widget jau paredz mehānismu, lai tik vienkārši, ko es aprakstīts komentārus iepriekšējā pantā.

Widget izmanto, piemēram īpašums _UI_ATTRS , kurā objekts ar vēl divām īpašībām, SYNC un BIND . Katrs no tiem ir masīvs kur nosaukti konfigurācijas atribūtus sākotnēji synched un tad klausījās, lai saglabātu UI, kas atspoguļo pašreizējās vērtības. Widget sagaida, katrs no šiem ierakstiem, ir metode, kas saistīta ar to, nosaukts pēc atribūta nosaukums prefiksu _uiSet ar pirmo rakstzīmi atribūta nosaukums pārvērš par lielajiem burtiem, lai būtu metodes nosaukums pareizā kamieļu gadījumā. Tādējādi, ja "value" ir uzskaitītas nevienā no _UI_ATTRS masīvi (nu SYNC vai BIND ), Widget varētu atrast _uiSetValue metodi. Šī metode saņems divus argumentus, value tiek noteikti un src izmaiņām. Tas ir kods, mūsu Spinner _uiSetValue metodi:

  _uiSetValue: funkcija (vērtība, src) {
     if (SRC === UI) {
         atgriezties;
     }
     this._inputNode.set (vērtība, this.get (Formatter) (vērtība));
 }, 

Visas lielos identifikatorus, ko redzat šajā kodos atbilst string konstantes deklarēto citur, lai ļautu Yui kompresoru darīt savu darbu labāk. Metode, galvenokārt, nosaka value HTML atribūtu <input> lodziņā uz jauno vērtību, kas, pēc formatēta. Ar textbox atsauci tika sniegta _locateNodes . The src arguments sākotnēji pārbaudīts, lai redzētu, ja ir iestatīts uz virknes vērtību 'ui' . Ja tas tā ir, nekāda darbība tiks veikti. Tas jādara, lai izvairītos no bezgalīgas cilpas. Ja lietotājs ievada kaut ievades lodziņā, tās vērtība būtu iedziļināties value konfigurācija atribūts, kas pēc tam būtu uguns valueChange notikums, kas varētu saņemt _uiSetValue sauc, kas, ja netiks, tad iet un mainīt vērtību no ievades lodziņš, kas varētu izraisīt visu procesu no jauna. Tādējādi _uiSetValue , ja mēs zinām pārmaiņas nāk no UI, mēs neko nedarām un tādējādi izjauktu cilpa. Taču tas prasa vēl viens koda fragments citur. In klausītājs par DOM gadījumā, kad mēs noteikti konfigurācija atribūtu, mēs izmantot trešās izvēles arguments, lai noteiktu, piemēram:

  _afterValueChange: funkcija (EV) {
     this.set (VALUE, ev.newVal, {src: UI});
 } 

Tas ir atkarīgs no mums, lai nodrošinātu, ka izmaiņas, kas nāk no UI ir atzīmētas ar karodziņu, tādējādi, un pēc tam pārbaudīt to pašu karogu, lai izvairītos no cilpas. Vai izmantojat identifikators src nosakot vērtību atribūta, kas nav source , kas netiks atzīta.

Ar šo visu teica, man vēl nav runājuši par statisko īpašums _ATTRS_2_UI minēta šīs nomenklatūras pozīcijā. Tā kā manā iepriekšējā rakstā norāda komentārus (ar Blunders es viņos), pārliecinoties, ka visi atribūti, kas ietekmē UI ir pareizi uzskaitīti, ir mazliet netīrs. Jums nekad nevajadzētu inicializēt _UI_ATTRS no nulles, jo Widget jau uzskaitīti visai daudz īpašību, un tie tiks zaudētas. Jums ir saķēdēt jaunu atribūtu nosaukumi pār esošajām, kas ir nedaudz grūti atcerēties, kā to izdarīt pareizi. Lai padarītu to vienkāršu, MakeNode lasīs no statiskā īpašuma _ATTRS_2_UI un dariet to, konkatenāciju jums. Tas saķēdēt visus šos sarakstus katru klasi mantojuma ķēdē, lai katrā līmenī katrā klasē var rīkoties ar savu atribūtus. In Spinner, mums ir:

  _ATTRS_2_UI: {
     BIND: VALUE,
     SYNC: VALUE
 }, 

MakeNode būs jāpieņem gan nosaukumu masīva vai viena atribūta nosaukums, kā tas ir šajā gadījumā.

Jautājums, protams, rodas, kāpēc divi saraksti, viens saistošs citiem, lai sinhronizētu? SYNC tiek izmantota pirmo reizi apkārt, pēc renderUI un bindUI metodes, ja tādas pastāv, ir nosaukti, un pirms syncUI , bet tie, kas uzskaitīti BIND būs pienākums attiecīgo atribūti vēlākas izmaiņas. Diezgan bieži SYNC masīvs ir mazāk norāžu nekā BIND sarakstā un tas ir tāpēc, ka šo sastāvdaļu veidnes, iespējams, jau tajā pašā noklusējuma vērtība kā konfigurācijas atribūts, un nav nepieciešams, lai veiktu sākotnējo sinhronizāciju. Tātad, ja noklusējuma vērtību value konfigurācija atribūts ir tukša virkne, un <input> elements veidnē nav value atribūtu, tad nav nepieciešams sinhronizēt tos inicializācijas.

Pazīmes, kas uzskaitītas BIND būs viņu _uiSet Xxxx metodes sauc jebkādā secībā, kā atribūti var uzstādīt jebkurā secībā. Pazīmes, kas uzskaitītas SYNC sauksies vienreiz tādā secībā, kādā tie ir uzskaitīti ar tiem senči pirms to mantiniekiem, tādēļ, ja viens ir atkarīgs no citu (ko tās nedrīkst), tad rīkojuma starpniecību, var būt svarīgi.

MakeNode pārbaudīs dublikātu ieraksti kādu no šiem blokiem. Ja kāds parādās, tas nozīmē, ka klase mūsu komponents manto no jau rokturi šo atribūtu, un jebkuru jaunu deklarāciju, visticamāk pārkāpt _uiSet Xxxx apdarinātājs par to. Starp citu, MakeNode arī pārbaudes dublikātu ieraksti _CLASS_NAMES , kas arī var izraisīt konfliktu ar kādu, lai gan ne visi, apstākļi. MakeNode rakstīt ziņu žurnāls par jebkuru šādu kļūdu.

_PUBLISH Īpašumu

Visbeidzot, _PUBLISH statisko īpašums tiks uzskaitīti tie notikumi, kas ir jāpublicē. Tā satur hash, izmantojot nosaukumu pasākumu, kā tās atslēgas un objektu burtisku konfigurācija raksturlielumi savas vērtības. Tā publicē visus uzskaitītos notikumus, jebkurā šādu īpašumu visās mantojuma ķēdē. Šī paša pasākuma nosaukumu var publicēt klasē un jebkuru klasi pārmanto no tā, kas padarīs konfigurācija atribūti vēlāk tiem neievērot garāžu vecajās. Piemēram, jūs varētu vēlēties, lai esošo notikumu apraides visā pasaulē. Tāpat kā ar _EVENTS īpašumu, jo _PUBLISH ir statisks īpašums bez piekļuves this , precizējot funkcijas, tas ir nosaukums, veids, kā virkne, kas jāvelta.

Secinājums

MakeNode nodrošina ļoti vienkāršu veidni procesors ar funkcionalitāti, kas ir ļoti cieši integrēta ar Widget pamatu klasē. Tā arī nodrošina palīgs metodes, lai radītu classNames izmantot veidni un lietot tos vārdus, lai atrastu un attiecas uz izveidoto mezgliem. Tas arī nodrošina līdzekļus, lai āķis vērā notikumus rada gan UI un elements pats par sevi un katru ar metodi. Tā dara visas šīs lietas, cenšoties ievērot mantojuma ķēdē taisni līdz Widget un jebkuru klašu jūs varat noteikt līmeni.

Tajā nav paredzēts pilnīgi visas iespējas, bet gan labs klāsts no tiem. Tomēr tas neliedz jums pievienot papildus funkcionalitāti. Iespējams, reti ir uzrakstīt bindUI vai syncUI metode, ja jūs izmantot līmi, ko sniedz MakeNode, bet jūs varat darīt, jo MakeNode neizmanto tos.

Kā bonusu tiem, kas bija pacietība izlasīt šo tālu, esmu arī modificēti Anthony Pipkin s Button kopa galeriju sastāvdaļu un veic Akordeons un TimeSpinner komponenti, ir pieejamas visas šīs Galerija .

Par Autors: Daniel Barreiro (segvārdu Satyam) ir aptuveni par diezgan kādu laiku. ENIAC bija izslēgts dienu pirms viņš piedzima, tāpēc viņam garām, ka, bet viņš nav garām daudz, jo. Viņš bija iespēja perfokartes, programma 6502 mikroshēmas (atcerieties Apple II?), Pašu TRS-80 un redzēt dažas fantastisks gabalu ekspluatācijas iekārtas, savā dzimtajā Argentīnā, kas varētu būt muzejos citur. Kad globalizācija atvēra durvis pasaulei, viņa tad tikko lietojams angļu (plus Electrical Engineering grādu) ielika par karjeras ceļš, kas beidzās 5 gadu darbu Bay Area atpakaļ uz NCSA Mosaic dienas. Pilnīgi intrigued ar funny squiggles viņa draugs rakstīja savā teksta redaktoru, pilns <'s un>' s, viņš beidzās mācīšanās diezgan daudz par pasauli Frontend inženieriju. Tas ir bijis garš brauciens, jo COBOL un Fortran. Tagad viņš dzīvo diezgan laimīgi daļēji pensijā Vidusjūras krastu tuvumā Barcelona, ​​Spānija.

Atrast sarunas: Bloglines | technorati

Daļa, un pagarināt: Grāmatzīme ar Del.icio.us | digg tā! | Reddit!