IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Ext JS / Sencha Discussion :

MVC et App multi-modules


Sujet :

Ext JS / Sencha

  1. #1
    Expert confirmé
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    Juillet 2004
    Messages
    4 205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : Juillet 2004
    Messages : 4 205
    Par défaut MVC et App multi-modules
    Bonjour.

    cela fait quelques temps que je me pose une question sur MVC dans Sencha.

    Comment définir une appli MVC qui comporte un grand nombre de controlleur sans tout charger au lancement de l'appli ?

    telque sencha l'a défini une Appli MVC déclare ses controlleurs qui eux même déclarent les vues, les modèles et les datastores qu'ils utilisent.

    du coup lorsqu'on lance l'appli les requires en cascade chargent tout le code.
    sur une petite appli ou sur une appli sur internet c'est peut être mieux ainsi.

    mais sur une grosse appli sur un intranet on a plus intérêt à ne charger que le necéssaire et le reste venant en fonction des besoins.

    le problème est alors le suivant.
    ne pas déclarer les controlleurs systématiquement et permettre de les charger au besoin.

    pour résoudre ce pb de façon cohérente et sans avoir trop de boulot à faire je suis partit de l'exemple descktop fourni par sencha.

    c'est typiquement le genre de chose ou on n'a pas envie que toutes les "application" présente sur le bureau virtuel soient chargé au démarrage.

    le bureau est fait de modules, chaque module est en soit une mini appli. j'ai d'abord pensé en faire de vrais applies MVC sandboxé. mais cette approche n'était pas généralisable à autre chose qu'un bureau.
    de plus le bureau lui-même n'était pas MVC.

    j'ai donc regardé comment il fonctionnait et je suis partie de l'idée d'avoir une appli MVC qui suporte la notion de module comme le bureau. au démarrage l'appli charge les modules mais ne les exécute pas.
    les controlleurs des modules étant chargé lors de leur première exécution.

    la methode Ext.Application est particulièrement hermétique et je suis partie de la classe qu'elle instancie. pour définir ce qui serait le ceur de mon système.
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
     
    Ext.define('Ext.ux.desktop.System', {
        extend: 'Ext.app.Application',
     
        constructor: function() {
        	var config = arguments[0]||{name: 'MySys'};
        	var modules = Ext.Array.from(config.modules) || [];
        	config.requires = Ext.Array.from(config.requires) || [];
     
        	config.modFolder = config.modFolder || 'modules';
        	config.desktopClass = config.name + '.module.' + config.desktopClass || config.name + '.module.Desktop';
     
        	Ext.Loader.setPath(config.name + '.module', config.modFolder);
     
        	config.requires.push(config.desktopClass);
     
        	Ext.Array.each(modules, function(module) {
        		this.requires.push( this.name + '.module.' + module);
     
        	},config);
        	this.callParent(arguments);
        },
     
        getDesktopModuleClassName: function(name){
            return this.name + '.module.' + name;
        },
     
        launch : function() {
            Ext.create(this.desktopClass, this);
        }
    });
    sont fonctionnement est semblable à Application. pour tout les nom de modules présent dans le Système il définit un nom de classe et l'ajoute au requires.

    l'usage est le suivant
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    Ext.onReady(function() {
    	new Ext.ux.desktop.System({
            name : 'MyDesktop',
     
            modules:[
               'SystemStatus',
               'VideoWindow',
               'Grid',
               'Tab',
               'Users',
               'Notepad',
               'BogusMenuModule',
               'BogusModule'
            ],
     
            desktopClass: 'Desktop'
     
        });
    });
    vous reconnaitrez les modules de l'exemple desktop.
    dans Application il faut définir une méthode launch qui desfini le viewport de l'appli et assure le démarrage.
    tel que je l'ai défini cette possibilité reste possible mais l'attribut desktopClass permet d'instancier un module qui assurera le démarage de l'application (du bureau dans mon exemple)

    ce premier module définit l'IHM de l'application et propose à l'utilisateur divers moyen de lancer un module. les modules ne font que définir des éléments d'IHM permettant leur lancement.
    ils référence comme une Application un ou des controlleurs et proposent une méthode run
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    /*!
     * Ext JS Library 4.0
     * Copyright(c) 2006-2011 Sencha Inc.
     * licensing@sencha.com
     * http://www.sencha.com/license
     */
     
    Ext.define('MyDesktop.module.Users', {
        extend: 'Ext.ux.desktop.Application',
     
        controllers: ['Users'],
     
        id:'users-win',
        name: 'Users Manager',
        smallIcon: 'user-kid',
        largIcon:'accordion-shortcut',
     
        launcher: true,
        shortcut: true,
        quickStart: true,
     
     
        windowCfg: {
            id: 'user-win',
            width: 500,
            height: 300,
            animCollapse: false,
            constrainHeader: true,
            bodyBorder: true,
            border: false,
            layout: 'fit',
     
            items: [{
                xtype: 'userlist'
            }]
       }
    });
    il s'agit ici de l'intégration du tutoriel MVC UsersManager de Sencha, dans une fenêtre du bureau.
    la partit intérésante est dans la méthode run de Ext.ux.desktop.Application (classe crée pour la circonstance). elle contient un appel à loadControllers
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
        loadControlers: function() {
        	if (!this.controllersOk) {
            	Ext.Array.each(this.controllers, function(controller) {
                    controllerName=this.app.system.getModuleClassName(controller, 'controller');
                    var controller = this.app.system.getController(controllerName);
                        controller.init(this.app);
            	}, this);
            	this.controllersOk = true;
        	}
     
        },
    la solution à mon problème se trouve dans ces trois lignes
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    var controller = this.app.system.getController(controllerName);
        controller.init(this.app);
    }, this);
    je récupère une référence au système et je lui demande le controlleur Ext va alors charger les vues, stores et modèles associés. l'application pour le reste est exactement comme tout autre appli MVC.

    faire un cas particulier c'est bien en faire plusieurs ça permet de voir les difficultes.
    l'exemple Dsktop de sencha n'est pas toujours bien structuré. ainsi il définit un membre launcher dans dans le module qui est utilisé par le startMenu et qui appelle la création de la fenêtre en passant en parametre le launcher. pour les quickStart et shortcut les techniques sont différentes du coup impossible de faire comme le BogusMenuModule pour pur produire plusieurs shortcut le desktop ne sait pas les différencier. j'ai donc corrigé ce petit problème et j'ai entrepris de passer les modules défini par l'exemple en MVC. chose qui ses fait en quelques heures. (principalement pour corriger ces incohérences) J'ai tout de même voulu conserver la possibiliter de mixer des modules MVC avec d'autre qui ne le sont pas.

    cela faisait longtemps que je pensais à ce problème et j'avais envisagé diverses voies, sans jamais asser à l'acte. trops de chose à produire et trop éloigné de la solution MVC de Sencha.

    lorsque cette idée à germé hier je m'y suis mis et en 5 heures j'avais un bureau MVC fonctionnel contenant le tuto UserManager. 5 heures plus trad les modules de l'exemple sont passé en MVC et le fonctionnement du bureau à été rendu plus cohérent. le code de l'exemple Sencha très peut modifié : les modules on un launcher un shortcut et un quickStart qui fonctionne comme pour le launcher d'origine avec un handler fourni par le module (run) les code fignolé (pas assez commenté) et j'ai simulé un login et une gestion de session.

    pour ajouter un module au bureau:
    1. Developper une Appli MVC comme dans le tuto Sencha.
    2. Créer un module sur le modèle de Users
    3. Relancer le bureau


    A+JYT
    Ps: je vais documenter mon code et je vous le proposerais.

  2. #2
    Membre émérite Avatar de kenny.kev
    Homme Profil pro
    Inscrit en
    Janvier 2007
    Messages
    646
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Janvier 2007
    Messages : 646
    Par défaut
    J'avais rencontré ce problème il y a un an avec une application que j'avais développé.

    Malheureusement je n'ai pas réussi à résoudre ce problème. A ce moment, la j'ai dut rétrograder de version de Extjs pour réussir à rendre le projet en temps et en heure.

    J'ai actuellement 2 projets en cours et 1 qui va commencer dans quelques semaines. Je serais donc ravis de pouvoir tester ta solution et si tu le souhaite de faire un retour d'expérience dessus.

  3. #3
    Expert confirmé
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    Juillet 2004
    Messages
    4 205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : Juillet 2004
    Messages : 4 205
    Par défaut
    pas de pb
    je suis en train de chercher à résoudre un autre problème

    comment utiliser les associations dans les modèles (voir la doc Data Package)
    dans un contexte MVC en utilisant des Data Store.

    pour le moment si je ne mets pas de datastore et que je mets des proxy dans les modèles j'arrive à faire fonctionner la chose sous MVC mais dès que je mets des stores ça ne fonctionne plus.

    A+JYT

  4. #4
    Expert confirmé
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    Juillet 2004
    Messages
    4 205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : Juillet 2004
    Messages : 4 205
    Par défaut
    Bonjour.

    j'ai ajouté quelque commentaires, retouché un peut le code

    le but de ce developpement est d'expérimenter le lancement diféré de module MVC avec ExtJS.

    je suis parti de l'exemple desktop avec comme première idée de ne pas le retoucher ou peut. en avançant j'ai changé d'avis et j'ai arrangé quelques petits éléments.

    fondamentalement l'exemple dscktop est très loint de de la structure MVC.
    je n'ai pas cherché à le remettre en cause. ce développement montre donc quelques limites. mais il m'a permis de trouvers une approche efficace pour intégrer des modules MVC dont le chargement est différé.

    je pris donc le lecteur de ne pas se concentrer sur le code en lui même mais sur les principes. pour un lancement MVC différé il faut une structure capable de l'acceuillir.
    la classe Ext.app.Application est là pour ça.
    il faut un lanceur. j'ai réutilisé le bureau de l'exemple sans trop le remettre en cause.
    typiquement je pense qu'un ensemble MCV standard démarant avec l'application peut très bien assurer ce rôle.
    Reste un le lancement proprement dit. pour lancer un module MVC faut-il le connaitre. c'est donc sur cette partit que porte l'idée de base.

    une classe dérivée de Ext.app.Application référence les modules de l'application et démarre les contrôleur de base (l'interface principale de l'application) le contrôleur lanceur de module réagit au demande de l'utilisateur et si besoin charge les contrôleurs MCV et ouvre la vue adéquate.

    les partie de code intérésantes se trouvent dans
    ux/js/System.js => dérivée de Ext.app.Application
    ux/js/App.js => ajoute getModules par rapport à la version sencha
    ux/js/Application.js => dérive de ux.Module.js et prends en charge le lancement du module MVC

    A+JYT
    Ps: j'ai denouveau un pb avec le bouton Gérer le spicèes jointes qui ne marche pas sur ma machine.
    Je vais changer de conf et poster le zip

  5. #5
    Expert confirmé
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    Juillet 2004
    Messages
    4 205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : Juillet 2004
    Messages : 4 205
    Par défaut
    ajout du zip
    Fichiers attachés Fichiers attachés

  6. #6
    Expert confirmé
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    Juillet 2004
    Messages
    4 205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : Juillet 2004
    Messages : 4 205
    Par défaut
    Bonjour.

    je suis repartis de mes idées, développées sur l'exemple Desktop

    et je l'ai appliqué au tutoriel MVC (légèrement amélioré)
    tout d'abord comme dans mes essais précédent j'ai dérivé Application
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    Ext.define('Ext.ux.desktop.System', {
        extend: 'Ext.app.Application',
     
        constructor: function() {
            var config = Ext.applyIf(arguments[0] || {}, {
                name: 'MySys',
                modules: [],
                requires: [],
                appFolder: 'app',
                modFolder: 'modules',
                desktopClass: 'Desktop'
            });
     
            //accepte modules: "monModule"
            var modules = Ext.Array.from(config.modules);
     
            //défini le dossier où se trouves les modules
            config.modFolder = config.appFolder + '/' + config.modFolder;
     
            //ajoute le dossier module au class path
            Ext.Loader.setPath(config.name + '.module', config.modFolder);
     
            //ajoute toutes les classe de modules à l'application
            Ext.Array.each(modules, function(module) {
                this.requires.push( this.name + '.module.' + module);
     
            },config);
            //appel du constructeur parent
            this.callParent(arguments);
     
            //charger tous les modules au démarage
            this.on('launch', function() {
                this.getModules();
            });
        },
     
        //executer un module à la demande
        runModule: function(name) {
            this.loadControlers(this.modules[name]);
        },
     
        //charge tous les modules
        getModules : function(){
            var ms = {};
            var me = this;
            Ext.Array.each(this.modules, function(module) {
                ms[module] = Ext.create(this.getModuleClassName(module, 'module'), {app: me});
            }, this);
            this.modules = ms;
            return ms;
        },
     
        //charge tous les controleurs (et donc views, stores et models) d'un module
        loadControlers: function(module) {
            if (!module.controllersOk) {
                Ext.Array.each(module.controllers, function(controller) {
                    controllerName=this.getModuleClassName(controller, 'controller');
                    var controller = this.getController(controllerName);
                    controller.init();
                    controller.application = this;
                }, this);
                module.controllersOk = true;
            }
     
        }
     
    });
    Comme on peut le constater j'ai rapatrié toute la gestion des module dans cette classe.
    l'application:
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    Ext.Loader.setPath('Ext.ux.desktop', 'ux/js');
    Ext.Loader.setPath('Ext.ux.grid', 'ux/grid');
    Ext.require('Ext.ux.desktop.System');
     
    var MySystem;
    Ext.onReady(function() {
        MySystem = new Ext.ux.desktop.System({
            name : 'Hermes',
            appFolder : 'app',
            title : "Hermes",
     
            // Controleurs de l'application. permets de découper l'appli en module
            // indépendants.
            controllers : ['Main', 'Notification', 'Entete'],
     
            modules:['Users'],
     
            // démarage de l'application (après le onReady)
            launch : function() {
                Ext.widget('main');
                document.title = this.title;
            }
     
        });
    });
    On retrouve ici les mêmes élément que dans le tutoriel. le fonctionnement est en tout point identique à ce que propose Ext MVC.
    la présent de modules:['Users'], est légèrement différente. les classes modules seront chargé au démarage elles contiennent une liste de contrôleur.

    contrairement à ce que propose le tutoriel sencha j'ai défini un controleur main et une vue main qui gère la vue principale. l'application se contente donc de créer la vue Ext.widget('main');
    la vue main qui utilise un layout border avec un tabpanel
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    Ext.define('Hermes.view.Main' ,{
        extend: 'Ext.container.Viewport',
        alias : 'widget.main',
     
    	layout : {
    		type : 'border',
    		// gère l'espace avec le bord du navigateur
    		padding : 5
    	},
    	defaults : {
    		split : true
    	},
    	items : [{
    		region : 'north',
            tbar: [
                   { xtype: 'button', text: 'users', action: 'show' }
               ],
    		xtype : 'entete'
    	}, {
    		region : 'center',
    		xtype : 'tabpanel',
    		items : [/*{
    			xtype : 'userlistdetail'
    		}, {
    			title : 'details',
    			id : 'userdetail',
    			xtype : 'useredit'
    		}*/]
    	}]
     
    });
    controleur main gère le bouton "Users" qui lencera le module du même nom
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    Ext.define('Hermes.controller.Main', {
        extend: 'Ext.app.Controller',
     
        views: ['Main'],
     
        init: function() {
            //on défini les actions associés au événements.
            this.control({
                'main button[action=show]': {
                    click: this.showUser
                }
            });
        },
     
        showUser: function(buton, event) {
            this.application.runModule('Users');
            buton.up('main').down('tabpanel').add({
                xtype : 'userlistdetail'
            });
            buton.up('main').down('tabpanel').add({
                title : 'details',
                id : 'userdetail',
                xtype : 'useredit'
            });
        }
    });
    lors d'un click sur le bouton on appelle this.application.runModule('Users'); qui va charger les controleurs du module users ainsi que les vue associées.

    le module users
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    Ext.define('Hermes.module.Users', {
        controllers: ['Users']
    });

    je vous laisse découvrir le reste du code dans le ZIP
    A+JYT
    Fichiers attachés Fichiers attachés

  7. #7
    Expert éminent

    Avatar de vermine
    Profil pro
    Inscrit en
    Mars 2008
    Messages
    6 582
    Détails du profil
    Informations personnelles :
    Âge : 40
    Localisation : Belgique

    Informations forums :
    Inscription : Mars 2008
    Messages : 6 582
    Par défaut
    Salut. Bon travail !

    Pourquoi ne transformerais-tu pas cela en article ou bien en composant pour l'application Téléchargez ?

  8. #8
    Expert confirmé
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    Juillet 2004
    Messages
    4 205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : Juillet 2004
    Messages : 4 205
    Par défaut
    c'est une idée
    mais j'ai déjà un article pour java sur le feux et je n'arrive pas à m'y mettre.

    A+JYT

  9. #9
    Invité de passage
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2012
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Avril 2012
    Messages : 1
    Par défaut archimed06
    Citation Envoyé par sekaijin Voir le message
    c'est une idée
    mais j'ai déjà un article pour java sur le feux et je n'arrive pas à m'y mettre.

    A+JYT
    Merci beacoup
    les tutoriels en francais dans cette technologie sont tres rares

    on aimerait bien s'il y a des exemples avec le framework sencha

    merci

  10. #10
    Futur Membre du Club
    Profil pro
    Inscrit en
    Juillet 2009
    Messages
    4
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2009
    Messages : 4
    Par défaut
    Salut,
    Ne peut on pas se contener de uses[] qui charge de façon asynchrone ?

  11. #11
    Expert confirmé
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    Juillet 2004
    Messages
    4 205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : Juillet 2004
    Messages : 4 205
    Par défaut
    Pour que le pattern MVC de sencha fonctionne il faut que les controlleur soit déclarés dans le tableau controllers
    or dans Sencha il n'en existe qu'une seul dans l'objet applcation.
    qui est obligatoirment chargé au démarage.

    si tu utilise un simple use ta classe contrplleur sera chargé par le classloader mais elle ne sera pas traité par le controllers manager car ce traitement ne se fait qu'au démarage de l'application.

    mon idée était donc de définir un module qui est un objet dérivé de Application mais qui ne se charge pas nécéssairement au démarage.

    A+JYT

  12. #12
    Futur Membre du Club
    Profil pro
    Inscrit en
    Juillet 2009
    Messages
    4
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2009
    Messages : 4
    Par défaut exemple app multi modules
    Bonjour,
    mon besoin était un peu différent, je voulais :
    - utiliser un seul répertoire qui contienne tous mes répertoires modules et applications
    - que mes 'répertoires modules' fonctionnent comme toutes les applications EXTJS i.e. avec un dossier controller, model, store ....
    - je voulais que mes modules ne soient pas écrit en dur dans mon fichier application.js mais que ces informations soient évolutives, je les ai donc lié à un store (fichier json)
    j'ai donc créé :
    - l'objet Module dérivé de Application,
    - le controller qui me permet d'associer les controllers du module à l'application maître
    - les store et model associés

    hope it can help
    Fichiers attachés Fichiers attachés

  13. #13
    Expert confirmé
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    Juillet 2004
    Messages
    4 205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : Juillet 2004
    Messages : 4 205
    Par défaut
    j'ai lu un post sur les forum de sencha ou un gars lui aussi cherchait à faire une appli modulaire

    A+JYT

  14. #14
    Nouveau candidat au Club
    Homme Profil pro
    Développeur Java
    Inscrit en
    Août 2013
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Algérie

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2013
    Messages : 2
    Par défaut iframe & extjs
    iframe a pour avantage de constituer un contenu séparé.

  15. #15
    Expert confirmé
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    Juillet 2004
    Messages
    4 205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : Juillet 2004
    Messages : 4 205
    Par défaut
    avec un iframe tu quitte l'application courante
    le contenu de l'iframe est une autre page donc les objets des deux pages sont dans des contexte JS séparés même si tu reste sur le même serveur il te faut faire communiquer les deux applis. si tu n'est pas sur le même domaine tu vas avoir des pb de cross domain.

    une appli modulaire c'est ms word avec son outil dico son correcteur grammatical son gestionnaire de plan etc.
    utiliser un iframe c'est comme comme avoir un document word qui inclus un morceau d'excel c'est possible mais ce sont deux appli qui doivent communiquer.

    A+JYT

  16. #16
    Membre éclairé
    Homme Profil pro
    Directeur technique
    Inscrit en
    Mars 2005
    Messages
    251
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Directeur technique
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Mars 2005
    Messages : 251
    Par défaut
    Très intéressant ! Du nouveau depuis Décembre ?

    J'ai un challenge en ce moment concernant la modularisation d'une grosse application pour l'ouvrir à d'autres équipes de développeurs/intégrateurs.
    Je m'en vais regarder cela rapidement.

  17. #17
    Nouveau candidat au Club
    Homme Profil pro
    Développeur Java
    Inscrit en
    Août 2013
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Algérie

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2013
    Messages : 2
    Par défaut Application modulaire avec Extjs MVC.
    Azul ,
    Voici les étapes à suivre:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    /*-------------------- Store: Contacts------------------------*/
    Ext.define('app.store.S_Contacts', {
        extend: 'Ext.data.Store',
        storeId: 'S_Contacts',
        fields: ['nom','telephone'],
        data: [
            {nom: "TANINA", telephone: "0765777777"},
            {nom: "Juba",telephone: "6045551213"}
        ],
        autoLoad: true
    }); 
     
    /*--------------------Store: Commandes -------------------------*/
    Ext.define('app.store.S_Commandes', {
        extend: 'Ext.data.Store',
        storeId: 'S_Commandes',
        fields: [ 'produit',{ name: 'quantite',type: 'int'}],
        data: [
            { produit: "produit 1",quantite: 13},
            { produit: "produit 2",quantite: 11}
        ],
        autoLoad: true
    });
    /*--------------------------- Grid: Contacts -------------------------------*/
    Ext.define('app.view.ContactsGrid', {
        extend: 'Ext.grid.Panel',
        alias:'widget.contacts-grid',
     
        height: 250,
        width: 400,
        title: 'Liste des contacts',
        store: 'S_Contacts',
     
        initComponent: function() {
            var me = this;
     
            Ext.applyIf(me, {
                columns: [
                    {
                        xtype: 'gridcolumn',
                        dataIndex: 'nom',
                        text: 'Nom'
                    },{
                        xtype: 'gridcolumn',
                        dataIndex: 'telephone',
                        text: 'Tel'
                    }
                ],
                viewConfig: {
     
                }
            });
     
            me.callParent(arguments);
        }
    });
     
    /*---------------------- Grid: Commandes------------------------------*/
    Ext.define('app.view.CommandesGrid', {
        extend: 'Ext.grid.Panel',
        alias:'widget.commandes-grid',
     
        height: 250,
        width: 400,
        title: 'Liste des commandes',
        store: 'S_Commandes',
     
        initComponent: function() {
            var me = this;
     
            Ext.applyIf(me, {
                columns: [
                    {
                        xtype: 'gridcolumn',
                        dataIndex: 'produit',
                        text: 'Désignation produit'
                    },{
                        xtype: 'numbercolumn',
                        dataIndex: 'quantite',
                        text: 'Quantité'
                    }
                ],
                viewConfig: {
     
                }
            });
     
            me.callParent(arguments);
        }
    });
    /*----------------------- controller :C_Contacts -----------------------------*/
    Ext.define('app.controller.C_Contacts', {
        extend: 'Ext.app.Controller',
     
        stores: ['S_Contacts'],
        views: ['ContactsGrid'],
     
        refs: [
            {
                ref: 'gridContacts',
                selector: '',
                xtype: 'contacts-grid',
                autoCreate: true
            }
        ],
     
        init: function(application) {
            if (this.inited) {
                return;
            }
            this.inited = true;
     
            this.control({
                'contacts-grid': {
                    itemdblclick: function() {
                        alert('double cliqué sur la grille des contacts');
                    }
                }
            });
        },
     
        actionIndex: function() {
            this.application.setMainView(this.getGridContacts());
        }
    });
    /*------------------ --------------------*/
    Ext.define('app.controller.C_Commandes', {
        extend: 'Ext.app.Controller',
     
        stores: ['S_Commandes'],
        views: ['CommandesGrid'],
     
        refs: [
            {
               ref: 'gridCommandes',
               selector: '',
               xtype: 'commandes-grid',
               autoCreate: true
          }
        ],
     
        init: function(application) {
            if (this.inited) {
                return;
            }
            this.inited = true;
     
            this.control({
                'commandes-grid': {
                    itemdblclick: function() {
                        alert('double cliqué sur la grille des commandes');
                    }
                }
            });
        },
     
        actionIndex: function() {
            this.application.setMainView(this.getGridCommandes());
        }
    });
    /*---------------------controller: Viewport---------------------------*/
    Ext.define('app.controller.Viewport', {
        extend: 'Ext.app.Controller',
     
        init: function(application) {
            if (this.inited) {
                return;
            }
            this.inited = true;
     
            this.control({
                'viewport #contacts': {
                    click: function() {
                        this.application.runAction('C_Contacts', 'Index');
                    }
                },
                'viewport #commandes':{
                    click:function(){
                        this.application.runAction('C_Commandes', 'Index');
                    }
                }
            });
        }
    });
    /*------------------- view: Viewport--------------------------*/
    Ext.define('app.view.Viewport', {
        extend: 'Ext.container.Viewport',
     
        layout: {
            type: 'border'
        },
     
        initComponent: function() {
            var me = this;
     
            Ext.applyIf(me, {
                items: [
                    {
                        xtype: 'tabpanel',
                        region: 'center'
                    },{
                        xtype: 'container',
                        style: 'background-color:cornflowerblue',
                        region: 'north',
                        items: [
                            {
                                xtype: 'label',
                                style: 'color:white;font-size:20px',
                                text: 'Extjs MVC modulaire'
                            },
                            {
                                xtype: 'toolbar',
                                items: [
                                    {
                                        xtype: 'button',
                                        itemId: 'contacts',
                                        text: 'Liste des contacts'
                                    },{
                                        xtype: 'button',
                                        itemId: 'commandes',
                                        text: 'Liste des commandes'
                                    }
                                ]
                            }
                        ]
                    }
                ]
            });
     
            me.callParent(arguments);
        }
    });
    /*--------------------- entryPoint ------------------------------*/
    Ext.application({
        autoCreateViewport: true,
        name: 'app',
     
        launch: function() {
            this.viewport = Ext.ComponentQuery.query('viewport')[0];
     
            var c = this.getController('Viewport');
            c.init();
        },
     
        runAction:function(controllerName, actionName){
            var controller = this.getController(controllerName);
            controller.init(this);
            controller['action'+actionName]();
        },
     
        setMainView: function(view){
            var center = this.viewport.layout.regions.center;
     
            if(center.items.indexOf(view)===-1){
                center.add(view);
            }
     
            center.setActiveTab(view);
        }
    });
     
    /*---------------------- Fin et bonne continuation --------------------------*/

Discussions similaires

  1. Réponses: 4
    Dernier message: 17/04/2013, 20h25
  2. Réponses: 11
    Dernier message: 01/04/2008, 14h42
  3. [SITE] Conceptualiser un site multi modules.
    Par proner dans le forum Maven
    Réponses: 7
    Dernier message: 29/10/2007, 14h14
  4. [Reporting] Récursivité multi-modules
    Par elitost dans le forum Maven
    Réponses: 4
    Dernier message: 08/09/2006, 08h27
  5. BUILD ERROR sur création d'un projet multi-modules
    Par elitost dans le forum Maven
    Réponses: 1
    Dernier message: 28/08/2006, 15h23

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo