Interfaz de usuario de Yahoo! Blog (YUIBlog)

Actualización: El "MakeNode" Widget de Extensión

Nota del Editor: Este artículo fue publicado originalmente a principios de este año . Desde entonces, el módulo de MakeNode se ha publicado en la galería de YUI y recibió algunas mejoras. El artículo de hoy refleja los últimos cambios en MakeNode.

En mi artículo anterior, una receta para un YUI 3 Aplicación , me mostró una manera de utilizar Y.substitute como un procesador de plantilla muy básica. La idea le quitó la vida a partir de ahí, con las sugerencias de la gente en el canal de IRC # yui, y me hizo una extensión Widget que está disponible en la galería de YUI, llamado MakeNode . MakeNode no es un procesador de plantilla genérica y no se entiende como una. Por otro lado, que está estrechamente integrado con el YUI Widget clase de fundación, incluyendo ayudantes de nombre de clase y de eventos y la internacionalización. En este artículo, voy a tomar el Spinner ejemplo y modificarlo para que siga las directrices de mi artículo anterior y de utilizar MakeNode. MakeNode está disponible como un componente de la galería, así como la modificación Spinner componente y el ejemplo que se utiliza en este artículo .

Ampliación de su componente

Para cargar MakeNode es necesario incluir el módulo en su YUI().use() comunicado con el nombre de 'gallery-makenode' o, si se define un módulo a través de YUI.add() , en la siguiente lista como la requires arreglo. Luego, para ampliar su widget, en la siguiente lista en el tercer argumento de Y.Base.create() , de esta manera:

  Y.Spinner Y.Base.create = (
      'Spinner',
      Y.Widget,
      [Y.MakeNode],
      {
         / / Instancia de los miembros ...
      },
      {
          / / Los miembros estáticos
      }
 ); 

Usted puede agregar MakeNode lo largo de cualquier número de extensiones adecuadas para Widget, como WidgetParent, WidgetChild, WidgetStdMode, etc MakeNode añade dos métodos protegidos para ser utilizados por el desarrollador, _makeNode y _locateNodes, y se lee de varias propiedades estáticas, si se encuentra .

Todos los miembros de esta extensión son bien protegido o privado, ya que están destinados a ser utilizados por el desarrollador de componentes y no por el implementador utilizando esos componentes, que no debe ser molestado con ellos. Recuerde que debe marcar la casilla "Mostrar Protegida" la opción al ver la documentación de la API .

Definición de la plantilla

La primera cosa que normalmente se va a hacer es definir la plantilla para su componente. Para el Spinner, nuestra plantilla será:

  _Template: [
     '<input Type="text" title="{s input}" class="{c input}">',
     '<button Type="button" title="{s up}" class="{c up}"> botón </>',
     '<button Type="button" title="{s down}" class="{c down}"> botón </>'
 ]. Join ('\ n'), 

La plantilla por defecto por lo general será nombrado _TEMPLATE y declaró a lo largo de las otras propiedades estáticas de la clase, como ATTRS . MakeNode usará esta plantilla si nada se prevé explícitamente. La plantilla está hecha de la versión HTML y una serie de marcadores de posición encerrados en llaves, cada una compuesta de un solo personaje (el código de procesamiento) y seguido por uno o más argumentos. Los marcadores de posición y lo que producen son:

• {@ attributeName} configuración de valor del atributo

• {p propertyName} valor de instancia de la propiedad

• {m methodName arg1 arg2 ….} valor de retorno del método dado. El código de procesamiento es seguido por el nombre del método y de cualquier número de argumentos separados por espacios en blanco.

• {c classNameKey} CSS className generada a partir del _CLASS_NAMES propiedad estática (ver La propiedad _CLASS_NAMES sección de abajo)

• {s key} de la cadena de strings atributo, utilizando key como el atributo sub-.

• {? condition valueIfTrue valueIfFalse } al igual que el ?: operador de JavaScript, se evalúa a valueIfTrue si la condición es truish, valueIfFalse lo contrario.

• {1 condition valueIfOne valueIfMore } utilizada para producir singular / plural palabras basándose en el valor de la condición.

• {} cualquier otro valor se tratará como Y.substitute hace.

Por ejemplo, {@ value} se traducirá en this.get('value') , mientras que {p value} se traduce en this['value'] .

Cuando los marcadores de posición tiene argumentos, al igual que {m} , {?} y {1} , las cadenas deben ir entre comillas dobles. Los números, booleanos y null (todo sin comillas) se va a analizar a sus tipos de datos propios. Los marcadores de posición se pueden anidar. El {?} y {1} marcadores de posición por lo general contienen un marcador de posición anidada para el estado y, posiblemente, por sus valores, por ejemplo:

  {P} {Cantidad 1 {p} Cantidad "unidad", "unidades"} 

Si la propiedad qty es 1, se evaluará como "1 unit" , por dos o más va a volver "2 units" y así sucesivamente. Una versión más elaborada tratar con cero sería:

  {?  {P} Cantidad "{p} {Cantidad 1 {p} Cantidad" unidad "," unidades "}" "ninguno"} 

Tenga en cuenta que el resultado de procesar los marcadores de posición de interior, si es una cadena, debe estar encerrado en su propio conjunto de citas.

Para incluir una cita doble en una cadena entre comillas, use \\" , la doble barra invertida que se requiera debido a que JavaScript va a interpretar una sola y descarta que antes de llegar a MakeNode Sólo se permiten comillas dobles;. MakeNode no utiliza eval() para el analizador es limitado, pero seguro. Cualquier cosa, pero los números, null , booleanos y cadenas entre comillas dobles será ignorado.

El {?} marcador de posición también es útil para usar con casillas de verificación y botones de radio. Se puede utilizar para producir la cadena "checked" en función del valor de verdad del código de instrucción de procesamiento que sigue. Por lo tanto, <input type="checkbox" {? {m getLength} "checked" ""}/> <input type="checkbox" {? {m getLength} "checked" ""}/> producirá una casilla marcada si el getLength método de nada, pero vuelve a cero.

Para el {c} marcador de posición, tenemos que tener un _CLASS_NAMES propiedad definida.

Otros marcadores de posición se puede añadir a MakeNode mediante la adición de ellos en la _templateHandlers hash.

El _CLASS_NAMES la propiedad

Junto con el ATTRS y _TEMPLATE propiedades estáticas, podemos definir una _CLASS_NAMES propiedad estática que apunta a una matriz de cadenas. Cada una de esas cadenas se utiliza para generar un className. Así _CLASS_NAMES: ['input'] se producen el className "yui3-spinner-input" . Esos nombres de las clases se almacenan en una instancia de propiedad this._classNames . La {c input} marcador de posición en la plantilla anterior será reemplazada por "yui3-spinner-input" . Que yo llamo las cadenas enumeradas en _CLASS_NAMES , tales como 'input' , las "claves className", ya que puede ser utilizado como una clave para referirse a la className real o los elementos que contienen los nombres de las clases, como veremos más adelante.

Usted puede utilizar el _CLASS_NAMES la propiedad de generar cualquier cantidad de nombres de las clases, ya sea que los use en la plantilla o no. Usted todavía puede llegar a los nombres de las clases adicionales desde dentro this._classNames . El nombre de clase se genera utilizando el yui3 prefijo seguido por el valor de la NAME propiedad estática convirtió en minúsculas, a continuación, la cadena dada en _CLASS_NAMES (este último no se convertirá en minúsculas), todos separados por guiones. El _classNames hash también contendrá los nombres de las clases para el boundingBox y el contentBox , el primero bajo el "boundingBox" clave y el segundo bajo el "content" fundamental. Widget asigna a la boundingBox los nombres de las clases derivadas de los valores de la NAME propiedad de cada una de las clases en la cadena de herencia, a partir de yui3-widget . Tiendas MakeNode en this._classNames sólo el className de más arriba para el boundingBox .

Si el módulo está cargado WidgetStdMod, MakeNode también generará entradas para su HEADER , BODY y FOOTER secciones con las mismas claves, que son también las constantes definidas en ese mismo módulo.

Si un componente es de varios niveles de distancia de Widget, como SuperSpecialSpinner heredera de SuperSpinner que hereda de Spinner que hereda de Widget, y si alguno o todos de ellos tienen _CLASS_NAMES propiedades definidas, MakeNode producirá nombres de las clases para todos ellos y guardarlos en this._classNames . No es necesario incluir en cada nivel de los nombres ya han declarado en los niveles anteriores. De hecho, es mejor que no ya que los nombres de las clases producidas en cada nivel se utilizará el valor de la NAME propiedad de ese nivel. Así, en SuperSpecialSpinner , {c input} aún resultará en "yui3-spinner-input" y no "yui3-superspecialspinner-input" y por lo tanto mantendrá su archivo CSS sigue siendo válida.

El marcador de posición {s}

Widget tiene una strings atributo de configuración definida, aunque no se inicializa con ningún valor. Este atributo tiene la intención de mantener las cadenas que son visibles (o, a través de lectores de pantalla, leer) el usuario. Es importante que nunca se incluyen cadenas visibles directamente en la plantilla. Esto no es un requisito de MakeNode - nunca ha sido una buena idea en absoluto. Todas las cadenas que se van a ver o leer por el usuario siempre debe ser colocado en la strings atributo. La strings atributo contiene un valor hash donde se ubica cada texto individual por su clave. El componente de Spinner tiene las siguientes cadenas de texto, que se puede ver que se usan en la plantilla anterior.

  cuerdas: {
     valor: {
         de entrada: "Pulse la flecha arriba / abajo para incrementos menores, en la página arriba / abajo para mayores incrementos."
         así: "Incremento",
         abajo: "Disminuir"
     }
 }, 

La mejor parte de hacer esto es que el componente se puede localizar a otros idiomas muy fácilmente por los desarrolladores que utilizan el componente. Cuando se crea una instancia de Spinner, puede hacer:

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

Configuración de los atributos de configuración de strings de esta manera reemplaza la configuración predeterminada de strings valores con los del archivo de recursos de idiomas utilizando el lenguaje se ha definido previamente. La {s} marcador de posición tiene acceso a las cadenas almacenadas en la strings atributo, ya sea la falta de pago o los más traducidos, si está configurado. La {s xxxx} marcador de posición es casi como el uso de {@ strings.xxxx} la excepción de que las cadenas de reemplazo localizados pueden tener marcadores de posición que será objeto de transformación. Esto es importante para las traducciones desde el orden sintáctico varía de un idioma a otro y esto permite reformular el texto, incluyendo sus marcadores de posición para adaptarse a cualquier idioma. Cadenas también se puede acceder usando {@ strings.xxxx.yyyy.zzzz} , lo que permitirá el acceso a las cadenas anidadas a mayor profundidad y evitar que otras sustituciones. Las llaves se pueden incluir en un texto mediante el uso de {LBRACE} y {RBRACE} como marcadores de posición.

Usando _makeNode en renderUI

Usamos la plantilla para crear el marcado en el componente. Para ello, podemos llamar a MakeNode de _makeNode método, de esta manera:

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

Esto llenará en el contentBox de nuestro widget con el marcado de la transformación de la plantilla. El _makeNode método devuelve una instancia de Y.Node que pueda ser añadido o insertado en cualquier lugar o que acaba de celebrarse para su uso posterior. No devolver una cadena, se produce un Node la instancia. (Si usted necesita una cadena y no un nodo, se puede utilizar el _substitute método, que requiere que se pase en una plantilla.)

El _makeNode método toma dos argumentos opcionales: una referencia a una plantilla y un objeto para rellenar los marcadores de posición, como Y.substitute hace. En nuestro ejemplo Spinner simple no es una sola plantilla para el widget de conjunto, sino de otros controles podría requerir partes y piezas hechas de varias plantillas. En ese caso, que generalmente se llama _makeNode sin argumentos para la parte principal y lo llaman de nuevo con diferentes plantillas para rellenar las partes adicionales. El ejemplo contiene esta renderUI método:

  renderUI: function () {
     var fieldset = this._makeNode ();
     this.each (function (elemento) {
         fieldset.appendChild (this._makeNode (MultipleTemplates.RADIO_TEMPLATE, elemento));
     }, Este);
     this.get ('contentBox') append (fieldset).;
 } 

La primera llamada a _makeNode devuelve un Node instancia almacenada en la variable de fieldset . El componente de la muestra se extiende también a Y.ArrayList por lo que el RADIO_TEMPLATE se llenará con los valores tomados de los elementos almacenados en la lista de arreglo y los nodos resultantes anexos a la fieldset antes de que sea anexado al contentBox . Los marcadores de posición especiales como {@} o {p} todavía se refieren a los atributos o propiedades en el objeto principal. Los elementos anidados se procesan como Y.substitute haría.

El método _locateNodes

MakeNode proporciona además un _locateNodes método que tratará de localizar todos los elementos con los nombres de las clases declaradas en _CLASS_NAMES . Para localizar los elementos específicos que puede pasar cualquier número de teclas className, de lo contrario, _locateNodes trata de todos ellos. Para cada elemento que se encuentra de cada className, _locateNodes producirá una propiedad de instancia privada que utiliza el prefijo de subrayado seguido por el nombre de la clave y el "Node" sufijo. Por lo tanto, en nuestro ejemplo Spinner, _locateNodes generará las propiedades _inputNode , _upNode y _downNode . Si varios elementos tienen la misma className, _locateNodes devolverá una referencia a la primera de ellas. Si un elemento no se encuentra, no hay ninguna variable se creará.

En el componente de Spinner usamos _locateNodes después de crear el marcado:

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

La propiedad estática _EVENTS

Una de las propiedades más se puede definir a lo largo de las líneas de _TEMPLATE y _CLASS_NAMES y que es _EVENTS . _EVENTS contendrá un hash formado por teclas con nombre de la clase, cada uno con un valor hash de los tipos de eventos y los métodos para manejarlas. Se explica mejor con un ejemplo:

  _EVENTS: {
     de entrada: 'cambio', / / ​​llama a this._afterInputChange
     boundingBox: [
         {
             Tipo: 'clave',
             fn: '_onDirectionKey', / / ​​llamadas this._onDirectionKey
             args: ((Y.UA.opera) "hacia abajo":? "prensa") + "38, 40, 33, 34"
         },
         'MouseDown' / / llama a this._afterBoundingBoxMousedown
     ],
     documento: "mouseUp ', / / ​​llama a this._afterDocumentMouseup,
     Y: 'broadcastingObject: algunEvento' / / llama a esto ["_afterYBroadcastingObject: algunEvento"]
 }, 

_EVENTS es un objeto (un hash) con cualquier número de entradas. Los nombres de las propiedades, es decir, las llaves del hash, identificar los nodos cuyos acontecimientos nos va a escuchar. Son las claves className mismos se definen en el _CLASS_NAMES . Hay varias teclas especiales adicionales:

• "boundingBox" se refieren a la caja de delimitación en sí.

• "document" se refiere al documento que contiene este widget.

• "THIS" se refiere a la propia widget

• "Y" se refiere a la Y instancia.

Si el Widget se ha ampliado con WidgetStdMod así, los Cayos de la HEADER , BODY y el FOOTER se refieren a las secciones, ya que estará disponible en el _classNames hash. JavaScript no necesita las claves para ser citados si son identificadores válidos por lo que ninguno de los anteriores deben ponerse entre comillas.

El _EVENTS la propiedad se procesa después de que los renderUI , bindUI y syncUI métodos han sido llamados para que el widget se espera que ya se ha insertado en el cuerpo del documento, de lo contrario el "document" identificador de un error.

Para cada uno de esos elementos existe un identificador de evento o una matriz de identificadores de eventos. Un evento puede ser identificado por el tipo de eventos para escuchar o un objeto con más detalles. De forma predeterminada, MakeNode utilizará como oyente a un método denominado con el "_after" mayúscula seguida de prefijo seguido por el identificador del elemento, con su carácter por primera vez por el tipo de evento con su primer carácter en mayúscula. El bloque de código anterior muestra los métodos llamados para cada evento.

Un identificador de eventos también puede ser un objeto con propiedades type , fn y args . El type es obligatorio e indica el tipo de evento que se está escuchando. La fn propiedad le da el nombre del método que va a escuchar el evento evitando así el nombramiento automático. Desde _EVENTS es una propiedad estática, que no tiene acceso a this por lo que no puede tomar una referencia real a un método, sólo su nombre. El args argumento puede ser usado para pasar argumentos adicionales para la persona que llama, tales como con la key evento que requiere una especificación llaves.

MakeNode utilizará Node.delegate para escuchar a los eventos de los elementos dentro del boundingBox , mientras que se utilizará Node.after para escuchar a los eventos del boundingBox y el cuerpo del documento. Se utilizará this.after para escuchar a los eventos en el marco del THIS clave y Y.after para los oyentes que figuran en la Y clave. Todos los eventos se escuchó después de utilizar los detectores de eventos, ya que se pretende hacer que el widget de responder a los eventos, no para filtrar el comportamiento del objeto que dispara a lo que en ningún caso, estos eventos pueden prevenirse o detenerse. (Nota: la escucha de la key caso en cualquier elemento anidado sólo funciona con 3.4.0pr1 versión y anteriores, ya que la delegación de la key evento no estaba disponible antes de todas las funciones de los otros funcionan con las versiones anteriores también.).

Los _EVENTS declaraciones son acumulativos cuando los componentes de heredar el uno del otro. Cada clase en la cadena de herencia tendrá su propia _EVENTS declaración de procesados ​​por separado.

La propiedad estática _ATTRS_2_UI

Eventos en ambos sentidos, desde la interfaz de usuario con el componente y del componente de la interfaz de usuario. El primero son manejados por el _EVENTS propiedad. Luego están los eventos desencadenados por cambios de valor de los atributos que deben ser reflejados en la interfaz de usuario. Como ya he mencionado en el artículo anterior, cuando hay efectos secundarios de cambiar un atributo de configuración, que debe ser manejado por los detectores de eventos de cambio, no por el opcional de setter método del atributo, que sólo debería ocuparse de normalizar el valor que se establece. La interfaz de usuario debe reflejar el estado de los atributos de configuración, por primera vez en syncUI , cuando se inicializa y luego en cada evento de cambio de atributo. En este último caso, se deberá adjuntar un detector de eventos, que normalmente harían en bindUI . Widget ya proporciona un mecanismo para hacer así de simple, que se describe en los comentarios al artículo anterior.

Widget utiliza la propiedad de instancia _UI_ATTRS que contiene un objeto con dos propiedades más, SYNC y BIND . Cada una de ellas es una matriz con los nombres de los atributos de configuración que inicialmente sincronizada y luego escuchó el fin de mantener la interfaz de usuario que refleje los valores actuales. Widget espera que cada una de esas entradas de disponer de un método asociado a él, llamado así por el nombre del atributo con el prefijo _uiSet con el primer carácter del nombre del atributo convierte a mayúsculas a tener el nombre del método en el caso del camello adecuada. Por lo tanto, si "value" fue incluido en ninguno de los _UI_ATTRS matrices (en cualquiera de SYNC o BIND ), Widget esperaría encontrar un _uiSetValue método. Este método recibe dos argumentos, el value que se establece y el src del cambio. Este es el código para nuestro Spinner _uiSetValue método:

  _uiSetValue: function (valor, src) {
     si (src === IU) {
         regresar;
     }
     this._inputNode.set (VALOR, this.get (FORMATTER) (valor));
 }, 

Todos los identificadores en mayúsculas que usted ve en esta pieza de código se corresponden con las constantes de cadena declarada en otro lugar, para permitir que el compresor de YUI para hacer su trabajo mejor. El método, básicamente, establece el value atributo HTML en el <input> caja para el nuevo valor, después de ser formateado. La referencia a la caja de texto fue proporcionado por _locateNodes . El src argumento es inicialmente revisado para ver si se define como el valor de cadena 'ui' . Si esto es así, no se tomarán medidas. Esto es para evitar bucles infinitos. Si el usuario escribe algo en el cuadro de entrada, su valor sería entrar en el value atributo de configuración que a su vez dispara un valueChange evento, que se _uiSetValue llamada, la cual, si no se controla, entonces iría a cambiar el valor del cuadro de entrada, que daría lugar a todo el proceso otra vez. Así, en _uiSetValue , si sabemos que el cambio viene de la interfaz de usuario, no hacemos nada y así romper el ciclo. Sin embargo, esto requiere otra pieza de código en otros lugares. En el detector para el evento DOM, cuando se establece el atributo de configuración, se utiliza el tercer argumento opcional para establecer, de esta manera:

  _afterValueChange: function (ev) {
     this.set (VALOR, ev.newVal, {src: la interfaz de usuario});
 } 

Depende de nosotros para asegurar que los cambios que vienen de la interfaz de usuario están marcados por lo tanto a continuación, compruebe que la misma bandera para evitar bucles. Utilice el identificador src cuando se ajusta el valor del atributo no, source que no será reconocido.

Con todo esto dicho, todavía no he hablado de la propiedad estática _ATTRS_2_UI mencionado en el encabezamiento de esta sección. Como los comentarios en mis shows artículo anterior (a través de los errores que hice en ellos), asegurándose de que todos los atributos que afectan a la interfaz de usuario están correctamente la lista es un poco desordenado. Nunca se debe iniciar _UI_ATTRS partir de cero desde Widget ya cuenta con una gran cantidad de atributos y los que se perdería. Usted tiene que concatenar los nombres de los nuevos atributos a través de los ya existentes, lo cual es algo difícil de recordar cómo hacerlo bien. Para hacerlo simple, MakeNode leerá de la propiedad estática _ATTRS_2_UI y hacer que la concatenación para usted. Se concatena todas las listas de este tipo de la clase de todos y cada uno en la cadena de herencia que en cada nivel de cada clase puede manejar sus propios atributos. En Spinner, tenemos:

  _ATTRS_2_UI: {
     BIND: VALOR,
     SYNC: VALOR
 }, 

MakeNode acepta tanto una matriz de nombres o un nombre de atributo, como en este caso.

La pregunta surge naturalmente, ¿por qué dos listas, una para obligar a la otra para la sincronización? SYNC se utiliza la primera vez, después de que los renderUI y bindUI métodos, si existen, se llaman y antes de syncUI , mientras que los que figuran en BIND estará obligado a los atributos correspondientes a los cambios posteriores. Muy a menudo el SYNC matriz tiene menos puntos que el BIND lista y esto se debe a la plantilla para el componente que ya tenga el valor predeterminado mismo como el atributo de configuración y no hay necesidad de hacer una primera sincronización. Por lo tanto, si el valor predeterminado para el value atributo de configuración es una cadena vacía y la <input> elemento en la plantilla no tiene ningún value atributo, entonces no hay necesidad de sincronizar en la inicialización.

Los atributos que figuran en el BIND tendrán sus _uiSet Xxxx métodos llamados en cualquier orden, como atributos se pueden establecer en cualquier orden. Los atributos que figuran en el SYNC se llamará una vez en el orden en que aparecen con los de los antepasados ​​antes de que sus herederos, así que si uno depende de otro (que no deberían hacerlo), el orden puede ser importante.

MakeNode buscará entradas duplicadas en cualquiera de estos arreglos. Si aparecen estos problemas, que significa que un componente de nuestra clase hereda de la que ya se encarga de este atributo y toda nueva declaración, sobrepasaría probablemente el _uiSet Xxxx controlador para ello. Dicho sea de paso, MakeNode también comprueba las entradas duplicadas en _CLASS_NAMES , que también pueden causar conflictos en algunos, aunque no todas, las circunstancias. MakeNode a escribir un mensaje en el registro de cualquier error.

La propiedad _PUBLISH

Por último, el _PUBLISH propiedad estática mostrará una lista de los eventos que han de ser publicados. Contiene un hash utilizando el nombre del evento como sus claves y un objeto literal de los atributos de configuración como de sus valores. La Comisión publicará todos los hechos enumerados en dichos bienes en toda la cadena de herencia. El nombre mismo evento se pueden publicar en una clase y, en cualquier clase que hereda de ella, lo que hará que los atributos de configuración de las posteriores anulan a los de los antiguos. Por ejemplo, es posible que desee hacer una transmisión de eventos existente a nivel mundial. Al igual que con la _EVENTS propiedad, ya _PUBLISH es una propiedad estática sin acceso a this , cuando se especifica funciones, es el nombre del método, como una cadena, que necesita ser determinado.

Conclusión

MakeNode ofrece un procesador de plantilla muy simple, con una funcionalidad que está muy integrada con la clase Widget fundación. También proporciona métodos auxiliares para crear nombres de las clases para ser utilizado en la plantilla y para utilizar esos nombres para localizar y se refieren a los nodos creados. También proporciona los medios para enganchar a los eventos generados tanto por la interfaz de usuario y el componente en sí mismo y asociar cada uno con un método. Lo hace todas estas cosas, teniendo cuidado de respetar la cadena de herencia hacia arriba para Widget y cualquier nivel de las clases se pueden definir.

No da para absolutamente todas las posibilidades, sino que abarca una buena gama de ellos. Sin embargo, esto no le impide añadir funcionalidades extra. Rara vez se podría tener que escribir una bindUI o syncUI método si se utiliza el adhesivo proporcionado por MakeNode, pero usted puede hacerlo, ya que MakeNode no las utiliza.

Como un bono a aquellos que tuvieron la paciencia de leer hasta aquí conjunto, también he modificado Anthony Pipkin del botón de los componentes de la galería e hizo un acordeón y componentes TimeSpinner, todos ellos disponibles en la Galería .

Sobre el autor: Daniel Barreiro (nombre de pantalla de Satyam) ha sido de alrededor durante bastante tiempo. La ENIAC fue desactivada el día antes de que naciera, por lo que se perdió, pero no se ha perdido mucho ya. Ha tenido la oportunidad de tarjetas perforadas, el programa de 6502 fichas (recuerda el Apple II?), Dueño de una TRS-80 y ver algunas piezas fantásticas de los equipos de operación en su país natal, Argentina, que podrían haber sido en los museos de otros países. Cuando la globalización abrió las puertas al mundo, su entonces apenas utilizables Inglés (más un grado de Ingeniería Eléctrica) lo puso en la trayectoria de la carrera que terminó en un trabajo de 5 años en la zona de Back Bay en los días de NCSA Mosaic. Totalmente intrigado por los garabatos divertido a un amigo suyo escribió en su editor de texto plano, lleno de <'s, y>' s, que terminé aprendiendo mucho sobre el mundo de la ingeniería de la interfaz. Ha sido un largo viaje desde COBOL y Fortran. Ahora vive felizmente semi-retirado en la costa mediterránea cerca de Barcelona, ​​España.

Buscar conversaciones: Bloglines | technorati

Compartir y ampliar: Marcar página con del.icio.us | Digg It! | reddit!