131 votes

extjs 4 tutoriels de gestion d'événements

J'ai récemment commencé à apprendre ExtJS, je suis à la recherche d'un bon ExtJS 4 la gestion des événements tutoriel. Je n'ai aucune expérience de toutes les versions antérieures de ExtJS.

À la lecture de différents manuels, des guides et des pages de documentation, j'ai compris comment l'utiliser, mais je ne suis pas clair sur la façon dont il fonctionne. J'ai trouvé plusieurs tutos pour les anciennes versions de ExtJS, mais je ne suis pas sûr de savoir comment applicables, ils sont dans ExtJS 4.

Je suis à la recherche précisément sur le "dernier mot" sur des choses comme

  • quels sont les arguments ne un événement la gestion des fonction de se passer? Est-il d'une série d'arguments qui sont toujours passés?
  • comment définir des événements personnalisés pour les composants personnalisés nous écrire? comment pouvons-nous le feu de ces événements personnalisés?
  • la valeur de retour (vrai/faux) affectent la façon dont l'événement bulles? Si non, comment pouvons-nous contrôler la remontée d'événements à partir de l'intérieur ou de l'extérieur du gestionnaire d'événement?
  • est-il un moyen standard pour enregistrer des écouteurs d'événement? (Je suis venu à travers de deux manières différentes, jusqu'à maintenant, et je ne suis pas sûr pourquoi, chaque méthode a été utilisée).

Par exemple, cette question m'amène à croire qu'un gestionnaire d'événement peut recevoir tout à fait un peu d'arguments. J'ai vu d'autres tutoriels où il y a juste deux arguments pour le gestionnaire. Quels sont les changements?

Merci

222voto

Molecular Man Points 15187

Nous allons commencer par décrire les éléments du DOM' la gestion des événements.

Nœud DOM la gestion des événements

Tout d'abord, vous ne voulez pas travailler avec nœud DOM directement. Au lieu de cela, vous allez probablement vouloir utiliser Ext.Element interface. Pour les fins de l'attribution des gestionnaires d'événements, Element.addListener et Element.on (ils sont équivalents) ont été créés. Ainsi, par exemple, si nous avons le html:

<div id="test_node"></div>

et nous voulons ajouter click de gestionnaire d'événements.
Nous allons récupérer Element:

var el = Ext.get('test_node');

Maintenant, nous allons vérifier les docs pour click événement. Il est gestionnaire peut avoir trois paramètres:

cliquez sur( Ext.EventObject e, La t, Objet eOpts )

Sachant tout cela, des choses qu'on peut attribuer gestionnaire:

//       event name      event handler
el.on(    'click'        , function(e, t, eOpts){
  // handling event here
});

Les Widgets de la gestion des événements

Les Widgets de la gestion des événements est à peu près similaire pour les nœuds DOM la gestion des événements.

Tout d'abord, les widgets de la gestion des événements est réalisé par l'utilisation de l' Ext.util.Observable mixin. Afin de gérer les événements correctement votre widget doivent contenant Ext.util.Observable comme un mixin. Le tout intégré dans les widgets (comme le Panneau, la Forme, l'Arbre, Grille, ...) Ext.util.Observable comme un mixin par défaut.

Pour les widgets, il y a deux façons de l'attribution des gestionnaires. La première est à utiliser sur la méthode (ou addListener). Nous allons par exemple créer Button widget et attribuer click événement. Tout d'abord, vous devez vérifier événement docs pour le gestionnaire d'arguments:

cliquez sur( Ext.bouton.Ce bouton, l'Événement e, Objet eOpts )

Maintenant, nous allons utiliser on:

var myButton = Ext.create('Ext.button.Button', {
  text: 'Test button'
});
myButton.on('click', function(btn, e, eOpts) {
  // event handling here
  console.log(btn, e, eOpts);
});

La deuxième façon est d'utiliser du widget auditeurs config:

var myButton = Ext.create('Ext.button.Button', {
  text: 'Test button',
  listeners : {
    click: function(btn, e, eOpts) {
      // event handling here
      console.log(btn, e, eOpts);
    }
  }
});

Notez que Button widget est un type spécial de widgets. Cliquez sur l'événement peut être attribuée à ce widget à l'aide de handler config:

var myButton = Ext.create('Ext.button.Button', {
  text: 'Test button',
  handler : function(btn, e, eOpts) {
    // event handling here
    console.log(btn, e, eOpts);
  }
});

Les événements personnalisés de tir

Tout d'abord vous devez vous inscrire à un événement à l'aide addEvents méthode:

myButton.addEvents('myspecialevent1', 'myspecialevent2', 'myspecialevent3', /* ... */);

À l'aide de l' addEvents méthode est facultative. Comme des commentaires de cette méthode de dire qu'il n'est pas nécessaire d'utiliser cette méthode, mais elle fournit un lieu pour les événements de la documentation.

Mettre le feu à votre cas d'utilisation fireEvent méthode:

myButton.fireEvent('myspecialevent1', arg1, arg2, arg3, /* ... */);

arg1, arg2, arg3, /* ... */ sera passé dans gestionnaire. Maintenant, nous pouvons nous occuper de votre événement:

myButton.on('myspecialevent1', function(arg1, arg2, arg3, /* ... */) {
  // event handling here
  console.log(arg1, arg2, arg3, /* ... */);
});

Il est important de mentionner que le meilleur endroit pour l'insertion addEvents appel de la méthode du widget initComponent méthode lorsque vous définissez un nouveau widget:

Ext.define('MyCustomButton', {
  extend: 'Ext.button.Button',
  // ... other configs,
  initComponent: function(){
    this.addEvents('myspecialevent1', 'myspecialevent2', 'myspecialevent3', /* ... */);
    // ...
    this.callParent(arguments);
  }
});
var myButton = Ext.create('MyCustomButton', { /* configs */ });

La prévention de remontée d'événements

Pour éviter le bouillonnement vous pouvez return false ou utiliser Ext.EventObject.preventDefault(). Afin d'empêcher le navigateur par défaut de l'action de Ext.EventObject.stopPropagation().

Pour exemple, nous allons attribuer cliquez sur gestionnaire d'événement pour notre bouton. Et si ce n'est de gauche le bouton a été cliqué empêcher le navigateur par défaut de l'action:

myButton.on('click', function(btn, e){
  if (e.button !== 0)
    e.preventDefault();
});

44voto

mahatmanich Points 1812

La cuisson demande des événements à l'échelle

Comment faire de contrôleurs de parler les uns aux autres ...

En plus de la très grande réponse ci-dessus, je veux parler de l'application à l'échelle des événements qui peuvent être très utiles dans un MVC de configuration pour activer la communication entre les contrôleurs. (extjs4.1)

Disons que nous avons un contrôleur de Station (Sencha MVC exemples) avec une boîte de sélection:

Ext.define('Pandora.controller.Station', {
    extend: 'Ext.app.Controller',
    ...

    init: function() {
        this.control({
            'stationslist': {
                selectionchange: this.onStationSelect
            },
            ...
        });
    },

    ...

    onStationSelect: function(selModel, selection) {
        this.application.fireEvent('stationstart', selection[0]);
    },    
   ...
});

Lorsque la boîte de sélection déclenche un événement de changement, la fonction onStationSelect est déclenché.

Dans cette fonction, nous voyons:

this.application.fireEvent('stationstart', selection[0]);

Cela crée des incendies et d'une application à l'échelle de l'événement que l'on peut écouter à partir de n'importe quel autre contrôleur.

Ainsi, dans un autre contrôleur, nous pouvons maintenant savoir quand la station de sélectionner la zone a été changé. Ceci est fait à travers l'écoute de this.application.on comme suit:

Ext.define('Pandora.controller.Song', {
    extend: 'Ext.app.Controller', 
    ...
    init: function() {
        this.control({
            'recentlyplayedscroller': {
                selectionchange: this.onSongSelect
            }
        });

        // Listen for an application wide event
        this.application.on({
            stationstart: this.onStationStart, 
                scope: this
        });
    },
    ....
    onStationStart: function(station) {
        console.info('I called to inform you that the Station controller select box just have been changed');
        console.info('now what do you want to do next');
    },
}

Si la selectbox a été changé nous avons maintenant le feu de la fonction onStationStart dans le contrôleur Song aussi ...

À partir de la Sencha docs:

Événements d'Application sont extrêmement utiles pour les événements qui ont beaucoup de contrôleurs. Au lieu d'écouter le point de vue même de l'événement dans chacun de ces contrôleurs, un seul contrôleur écoute le point de vue de l'événement et les feux d'une application à l'échelle de l'événement que les autres peuvent écouter. Cela permet également de contrôleurs de communiquer les uns avec les autres sans le savoir ou en fonction les uns des autres de l'existence.

Dans mon cas: en Cliquant sur un nœud de l'arborescence de mettre à jour les données dans une grille de panneau.

Trouvé dans Sencha Docs: MVC Partie 2

15voto

dbrin Points 10155

Un tour de plus pour les auditeurs d'événements de contrôleur.

Vous pouvez utiliser des caractères génériques pour surveiller un événement de n'importe quel composant:

 this.control({
   '*':{ 
       myCustomEvent: this.doSomething
   }
});
 

12voto

Harel Points 471

Voulais juste ajouter quelques pence pour l'excellent réponses ci-dessus: Si vous travaillez sur la pré Extjs 4.1, et n'avez pas l'application des événements à l'échelle, mais ont besoin d'eux, j'ai été en utilisant une technique très simple qui pourrait vous aider: Créer un objet simple extension Observables, et de définir n'importe quelle application à l'échelle des événements que vous pourriez avoir besoin. Vous pouvez alors déclencher ces événements à partir de n'importe où dans votre application, y compris les dom html de l'élément et de les écouter sur n'importe quel composant en relayant les éléments de ce composant.

Ext.define('Lib.MessageBus', {
    extend: 'Ext.util.Observable',

    constructor: function() {
        this.addEvents(
            /*
             * describe the event
             */
                  "eventname"

            );
        this.callParent(arguments);
    }
});

Ensuite, vous pouvez, à partir de n'importe quel autre composant:

 this.relayEvents(MesageBus, ['event1', 'event2'])

Et le feu de tout composant ou élément du dom:

 MessageBus.fireEvent('event1', somearg);

 <input type="button onclick="MessageBus.fireEvent('event2', 'somearg')">

11voto

blahgonaut Points 81

Juste deux choses que j'ai trouvé utile de savoir, même si elles ne font pas partie de la question, vraiment.

Vous pouvez utiliser l' relayEvents méthode à dire d'un composant à écouter pour certains événements d'un autre composant, et alors le feu de nouveau, comme s'ils proviennent de la première composante. L'API docs donner l'exemple d'une grille relais de la stocker load événement. Il est assez pratique lors de l'écriture de composants personnalisés qui contiennent plusieurs sous-composants.

Dans l'autre sens, c'est à dire en passant sur les événements reçus par une encapsulation de composants mycmp pour l'un de ses sous-composants, subcmp, qui peut être fait comme ceci

mycmp.on('show' function (mycmp, eOpts)
{
   mycmp.subcmp.fireEvent('show', mycmp.subcmp, eOpts);
});

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X