Discussion :

[Caxton]

Bonjour tout le monde,

Je débute complètement dans le domaine du graphisme sous java et j'aimerais réaliser un programme pour gérer des maps.

Ma première difficulté est au niveau du cahier des charges qui m'impose d'avoir non seulement une image qui apparait (en fond) mais aussi des calques personnalisable en nom et en position. Un calque pouvant être visible ou non et bien entendu et verrouillé ou non. Il me sera nécessaire d'avoir des répertoires virtuels contenant certains calques déplaçable en drag and drop. (Le drag et drop peut aussi se faire via des boutons, peu importe).

Le comportement d'un calque devra être le suivant.

-Si la souris est sur une zone vide (sur le calque sélectionné), si on appuie sur le bouton gauche on pourra déplacer la carte de base ainsi que ses calques en même temps.

-Dans le cas ou on clique sur un bouton de création, lorsque on clique sur un endroit vide de la carte on fera apparaitre une popup disant création d'un point, création d'une note, création d'un groupe PJ, création d'un groupe PNJ, création d'un PJ, création d'un PNJ, création d'un village/ville, création d'un point particulier.

Une fos le clique fait, une boite apparaît pour saisir les donnés, lorsque on clique sur Ok, on enregistre le tout pour passé au second point etc..

-Si la souris est sur un point et que nous ne cliquons sur rien, il faudra donc
apparaitre une popup permettant de visualisé les données saisies.
-Si la souris est sur un point et que nous cliquons sur le buton gauche, à ce moment là apparit un menu disant modifier le point, déplacer le point, supprimer le point.

En outre il devra y avoir une multitude illimitée de points dans un calques et on autorisera bien entendu plusieurs calques.

Mon premier souci est de trouver un composant simple à placer dans un jScrollPane afin de permettre d'afficher les calques et de pouvoir les manipuler.
Mon second souci est liée à la map elle même. Doit-on avoir une carte mettons au format PNG avec un fichier properties par calque, ou un seul properties pour l'ensemble des points et des donnés et des calques ?

Enfin j'aimerais y arriver pas à pas, c'est à dire savoir quel composant, essayer de l'utilisé, trouvé des codes approchants et finir par arrivé à quelque-chose. Bien entendu le principal est de comprendre et de faire en sorte que ça soit instructif. J'entends par là aussi que j'aime bien quand un code est commenté et qu'il deviens du coup plus clair.

Sur ce, ne prenez pas ce post comme une demande de tout mâché ni de pensé de moi que j'aimerais tout savoir. Je cherche juste à apprendre et avancer dans mes idées d'applications. Celle-ci étant depuis plus d'un ans dans un dossier qui n'en fini pas de demander des contraintes.

Sur ce, je vous remercie pour votre compréhension et espère vraiment que tout ne sera pas mal pris.

[sinok]

Mon premier souci est de trouver un composant simple à placer dans un jScrollPane afin de permettre d'afficher les calques et de pouvoir les manipuler.

Tes besoins sont vraiment spécifiques, de fait je doute qu'il existe un composant qui convienne réellement à ce que tu attends. En fait il existe bien des composants de carte, mais ce sont plutôt des composant orienté tiles.

De fait il va te falloir mettre les mains dans le cambouis et créer ton composant à partir de rien.

Avant même de créer ton composant tu devrais plutôt faire une modélisation des classes correspondant à la logique de ton projet via UML, ainsi que la classe qui regroupera toutes tes informations qui servira de modèle à ton composant graphique (classe qui regroupera toutes les données nécessaires au composant, c'est à dire les divers éléments, genre point/pnj mais aussi l'organisation des calques et ainsi de suite). Donc commence par analyser tous les éléments devant intégrer ta carte, toutes les propriétés qui leur sont nécessaires et ainsi de suite pour réaliser à minima un diagramme de classe.

Puis une fois ceci modélisé correctement et codé, va falloir que tu plonges dans les joies de Java2D pour réaliser le composant en lui même. En effet tu ne trouveras pas de composant réalisant ce que tu cherches, donc ce sera à toi de développer ce composant. Autant dire qu'il y a du boulot, et que tu vas devoir augmenter ton niveau en java d'un bon niveau.

Les notions de Drag&Drop viendront à la fin, ce sera vraiment la dernière couche.

Mon second souci est liée à la map elle même. Doit-on avoir une carte mettons au format PNG avec un fichier properties par calque, ou un seul properties pour l'ensemble des points et des donnés et des calques ?

En ce qui concerne le stockage de tes données, tu ferais mieux de définir quelque chose à base d'un fichier un poil plus structuré que du properties. En l'occurence du XML, ou alors une base de données embarquées. Tu stocke dedans les noms de tes fichiers images (voir même un format sprite, c'est à dire regrouper toutes les petites images en une grande, et de découper en suite ce qui a tendance à être plus rapide pour les charger de par la suite, donc dans ce cas ce sont les coordonnées de l'image qui sont stockées, enfin ça ce sont des détails d'implémentation). De fait le fichier XML reproduira les structures de données des classes que tu a modélisés ci dessus, a quelques aménagements près).

Enfin j'aimerais y arriver pas à pas, c'est à dire savoir quel composant, essayer de l'utilisé, trouvé des codes approchants et finir par arrivé à quelque-chose. Bien entendu le principal est de comprendre et de faire en sorte que ça soit instructif. J'entends par là aussi que j'aime bien quand un code est commenté et qu'il deviens du coup plus clair.

Malheureusement la théorie des bouts de codes piochés à gauche ou à droite, ça marche vaguemenent pour des petits sites perso bricolés à base de php et javascript. Mais pour des développements d'amplitude supérieure comme ce que tu cherches à faire, c'est l'autoroute pour la dérive, les bugs dont on ne comprend pas l'origine et ainsi de suite.


Dernier conseil, arme toi d'un dictionnaire et mets toi un tant soit peu à l'anglais. En effet, au final tu gagneras du temps à comprendre un peu mieux l'anglais, car un majeure partie des ressources java sont disponibles en anglais. Il existe de fait des ressources françaises (par exemple le livre suivant: http://java.developpez.com/livres/?p...op#L2212120192)

Toutefois, rien que pour une bonne compréhension de la javadoc un tant soit peu d'anglais est nécessaire.

Et surtout, ne te jette pas tête baissée dans le code, pense modélise, fait des retours sur ton code précédent, travaille par itérations et ainsi de suite.

[Caxton]

Et bien je suis en tout point d'accord avec ce que tu a mis Sinok.

Je ne comptais pas me lancé tête baisser. C'est aussi pour ça que j'ai fait ce post avec le lourd cahier des charges.

Monter le code d'un niveau ne me dérange pas tant qu'on m'explique un temps soit peu comment ça fonctionne. Je veux dire par là qu'autant il m'arrive de prendre tout prêt par manque de temps, autant là, je suis totalement à l' opposé.

Faire de l' UML, ou encore en bon français une représentation graphique de qui fait quoi. Avec la robotique j'en ai déjà fait beaucoup. Donc il ne sera pas gênant de regardé un modèle (oui par ce que si on va par là, on peut aussi faire dans les détails), puis ensuite créer chaque petit modules, les mettre en classe, comprendre par des algorithmes et enfin codé le soft.

Créer mon propre composant est bien sympathique et me convient parfaitement. Dans ces cas là, faut-il que ça soit dans une classe, et si oui à ce moment là, est-ce que ça le rends portable sur d'autres projets ? Dans ces cas là pourquoi ne pas le rendre dès le départ open-source afin que tout le monde puisse l'utilisé ?

Le XML ma beaucoup rebuté dans le c++ auparavant et je n'ai jamais vraiment réussi à m'en servir. Donc la il va falloir que j'apprenne et que je face comme les properties une classe de gestion. J'ai fait gestionProp pour les properties, je ferais GestionXML pour les XML. D'ailleurs si des je puis me permettre je fais toujours comme ceci concernant mes fichiers.

Méthodes
createPath() Créer un répertoire si nécessaire. Déjà fait et éprouvé ca sera facile ça.

createXML() créer un xml vide (vide mais avec juste l'entête et les balises <xml></xml> + type de codage, perso je reste UTF-8).

deleteXML() Vise à supprimer une ligne à partir d'un nom exact de valeur (la je ne suis pas sur que c'est vraiment faisable)

getSelectXML() cherche à retourné la valeur d'ont le nom est donné (genre <infos>toto</infos> affichera à partir du nom infos, toto)

updateXML() qui permettra de mette à jour une valeur dont le nom est donné (genre <infos>toto</infos> avant de changer la valeur pour <infos>tata et titi</infos> après en avoir fait la modif via updateXML())

validPath() qui renvoie false / true en fonction du chemin s'il est vrai ou faux.

En gros c'est ce que je compte faire dans ma classe XML. Je n'ai pas dit qu'elle était complète, il manque surement des choses à voir dans la section xml.

Je suppose sinok, quand tu me dis que le XML peut être la solution, c'est que nous aurions alors dedans ceci.

xml
entête
map -> chemin de la carte
calque 1
contenu du calque 1
calque 2
contenu du calque 2
points
point 1
info point 1

bon j'ai pas fermé volontairement juste pour l'idée mais je pense que tout le monde aura compris.

A partir de tout ça je me lancerais dans l'UML du projet

Un dernier point, faut-il que je laisse ce post pour l'intgralité du projet ou je suis vraiment obliger de faire plusieurs posts dans différentes sections ?

[bouye]

Concernant la vue de la map en elle-meme, deux pistes evidentes :

• Un JLayeredPane qui affiche un JComponent / JPanel par calque. Ici, afficher / cacher des calques signifie juste appeler setVisible() sur la couche appropriee.
• Un unique JComponent / JPanel qui affiche tous les calques (definir une entite Layer avec toutes les methodes de rendu appropries). Ca reste super rapide a implementer, un peu moins a optimiser (utiliser les methodes classique avec un champs dirty)

Dans tous les cas utiliser les optimisations habituelles de rendu sous Swing : images compatibles, rendu partiel par zone de clip, eviter de redessiner inutilement les calques non-modifies, si la memoire le permet cacher les calques vectoriels ou necessitant des calculs pour etre rendu en un calque bitmap quand ils ne sont pas modifies.

Il faudra implementer la recherche en profondeur pour gerer les clics et recuperer le calque actif, selectionner l'objet (si calque reactif contenant des objets selectionnables) et les actions applicables (pour construire le popup).

Concernant la gestion des calques, classique soit une JList soit un JTree comme dans n'importe quel logiciel de dessin, vectoriel, SIG.

[Caxton]

Concernant la vue de la map en elle-meme, deux pistes evidentes :

• Un JLayeredPane qui affiche un JComponent / JPanel par calque. Ici, afficher / cacher des calques signifie juste appeler setVisible() sur la couche appropriee.
• Un unique JComponent / JPanel qui affiche tous les calques (definir une entite Layer avec toutes les methodes de rendu appropries).

Effectivement, je ne voyais pas cela aussi simple.

Ca reste super rapide a implementer, un peu moins a optimiser (utiliser les methodes classique avec un champs dirty)

Par contre, rien que pour ça, je pense d'abord monter un diagramme UML, et voir la création à la main d'un composant graphique. On ne me retirera pas l'idée que si je fais à la main ce composant, ça sera plus long mais beaucoup plus efficace.

Libération de mémoire, c'est une des grosses parties. Au démarrage de l'application, on cherche le premier calque, on le place au fond, on cherche l'image, on la met dans le calque 1. On prends le calque 2, on cherche les points x, y, son nom et indice, on le place sur la carte, ainsi de suite. Pendant cette phase, peut-être que j'ajouterais une progress bar. Par contre, on a pas tout à passé en paramètres.

Effectivement on ne chargera les donnés du points qu'à partir de son identification et sur passage de la souris, si le calque autorise la popup.
Dans une map, je vais avoir certains calques avec que peu de points mais mobiles. Sur d'autres les points sont fixe. Donc je verrait avec le temps s'il faut que nous limitions le nombre de calques et de points.

Une chose qui m'inquiète, c'est que peut-il arrivé en cas de dépassement de mémoire sous java ?

[sinok]

Bah, ouais. De fait la JVM est lancée avec un montant maximum de mémoire qu'elle peut utiliser, spécifié par le paramètre -Xmx de l'exécutable java.

Ensuite dans ton cas les histoires de débordement mémoires, ne t'en préoccupe pas pour le moment, les optimisations viendront quand tu auras déjà quelque chose de fait. (premature optimisation is the root of all evil - désolé pour l'anglais, mais c'est un classique du genre)

[Caxton]

Effectivement c'est un classique. J'en avais entendu parlé un peu en C++ mais je n'avais pas trop mis le nez dedans.

A part ça, j'ai attaqué un pseudo UML (une version brouillon) sur un papier de ce que je voulais faire. J'ai donc un début de modélisation que je vais essayer de mettre en forme via BOUML. J'espère que j'arriverais à en tiré quelque chose de cohérent.

Quelques grosses parties en ressortent.

• Une classe nommé calc (pour gérer les calques)
• Une classe affichage (qui peut être un jScrollPane ou un extends de jScrollPane dans lequel on viens directement créer une zone géré par la classe calc)
• Une classe point (qui s'occupe de chaque point indépendamment qui serait doublé par une classe permettant de gérer une boite de dialogue appeler outilPlot qui serais dors et déjà capable seul de montrer une fenêtre en popup au dessus du logiciel permettant la saisie du point, sa forme sur le calque, sa couleur)
• Une classe refresh (qui gèrerais l'actualisation à la demande des calques par des méthodes accéssibles en configuration)

Tout ceci étant bien sûr pour le moment un axe général de travail. Une fois que j'aurais fait une modélisation, je vous la soumettrait pour rectifications.

[sinok]

Je serais plutôt parti dans l'idée que chaque élément a besoin d'une structure appropriée. A toi d'identifier les différents éléments de chaque objets, de procéder par interfaces/classes abstraites si certains objets on des traits communs et ainsi de suite. Pour moi ta décomposition à l'heure actuelle des données est un poil trop simpliste. Car des points tu vas en avoir de n types différents, chacuns ayant des rôles différents et des ressemblances et ainsi de suite.

Ensuite il va te falloir jouer au travers des mécanismes de composition et d'héritage, bref un petit tour du coté des design patterns te sera probablement utiles (Composition/Delegate, Factory, FlyWeight et autres).

Pour la gestion du XML java offre tout ce qui est nécessaire au travers de l'API DOM. (cf FAQ java XML)

Ta classe affichage devra être plutôt une classe héritant de JComponent et s'occupant de dessiner l'intégralité de ta carte. Ensuite tu placera celle ci dans un JScrollPane. En soit le JScrollPane ne devrait pas être subclassé.

A noter également que tu devrais vraiment de renseigner sur des choses telles que les concepts MVC (Model/View/Controler),MVP (Model, View, Presenter) afin de bien organiser tes développements sur le plan du composant.

[Caxton]

Et bien, je voie le topo !
je peux déjà vous montrer ce que j'ai fait en modélisation (ce n'est qu'un début) et je pense que je vais en avoir pour pas mal de temps.

Bon il y a des choses qui me gène dans boUML. Déjà l'exportation ne se fair correctement que sous la forme html. Un gros moins car je ne pourrais pas sortir le diagramme avec les valeurs. Deuxièmement, j'ai moins l'impression de comprendre quand je l'utilise. J'ai placé des champs et ils sont inutilisable, incomplets et permettent pas de comprendre comment va être codé le logiciel.

Je suis pourtant habituer à faire des schémas de ce que je veux faire mais il y a des choses que je n'arrivent pas à saisir. J'ai pas l'impression que je suis en train d'avoir une arborescence correct.
Voilà ce que ça me sort

package
package
class
class
class
champ
méthode

Il y a comme un problème !
Normalement ça devrais être

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
Logiciel
   package
      class
         champ
         méthode

Tout est doublé !
Ensuite, c'est comme si j'étais entrée dans un multi-niveau alors que la je met tout dans mon package. Don ça ne va pas !

J'ai une autre solution, moins agréable que boUML qui est de me servir de dia mais là je perd toute la puissance du logiciel les bugs en plus !

Alors que faire ?

[Caxton]

Bonjour,

Pardonnez-moi ce double post mais j'ai de nouveaux éléments à ajouter.

J'ai changer de logiciel, je suis passé à ArgoUML qui marche parfaitement
En commençant par imaginé comment je pourrait éventuellement gérer mes calques, je me suis rendu compte que si je supprimais un calque au milieu et que je devais en ajouter un, non seulement avec une classe simple d'affichage j'étais dans l'incapacité de trouvé son identifiant mais en plus le traitement serais sacrément long.

Alors je suis parti à étudier un petit algorithme permettant de calculer le nombre d'un calque supplémentaire sachant que le nouveau calque serais au dessus des autres. Et puis je me suis dit. Si je ne fais pas de tableau, il sera impossible de faire cette gérance.

Après avoir parcouru le net, on ne sait jamais si quelqu'un aurais eu à faire la même chose et avait publier son algo... Et bien j'ai trouvé des choses mais pas ce que je cherchais. Et comme je cherche avant tout à comprendre, plus que d'arrivé à coder à la lettre un algorithme, dans un premier temps, et bien je me pose des questions.

D'où mes questions de débutant et encore que ! Comme je ne pratique pas cette exercice tous les jours, je crois qu'il va me falloir un petit coup de pouce.

• Comment représenter mes calques ?
• Sous forme de tableau ?
• A partir d'un tableau gérer par la classe calque ?
• Un tableau contenant plusieurs éléments de la classe calc ?
• Comment parcourir un tableau quand il y a un trou ?
• Dans la pratique, si on fait une boucle, comment l'arrêter au dernier calque et non en cours de route par un trou ? (C'est quoi qui différencie un trou de la fin d'une liste ? (J'ai bien essayer de voir avec les "TANT QUE ()" mais sans succès)

Et bien oui personne n'est parfait, et il me semble qu'il est important de posé cette question niveau graphique, car au final, c'est un affichage graphique des calques dans le menu qui sera fait

Merci pour votre aide.
Je vous remercie pour votre aide.

[bouye]

List<Layer> (ou plutot ArrayList<Layer>) ou Layer[] c'est kifkif pareil sauf que la liste est plus sécure à parcourir (via des interrateurs).

C'est quoi un "trou" chez toi ? Un calque null ? Ben voilà faut tester la valeur null...

[sinok]

En même temps si tu utilises une List, plus de problème de gestion des trous. Tu ajoutes/supprime/réarrange les layers dans la liste et basta.

Le tableau ici est une solution vraiment suboptimale.

[Caxton]

Le tableau ici est une solution vraiment suboptimale.

Que veux tu dire par "suboptimale" ?

[sinok]

Bah on va dire qu'un tableau fini pour un nombre de calques illimités c'est pas vraiment l'idéal. De plus le tableau t'impose la gestion des trous à la main alors que d'en une liste c'est fait automatiquement.

[Caxton]

Oui effectivement. D'ailleurs là je viens de tester avec succès un ArrayList. C'est peut-être pas la même chose qu'une list. Je cherche :siffle:

Sinon c'est plutôt cool les array, on peut vraiment s'ouvrir à des cas moins facile à gérer avec des tableaux classiques

[sinok]

Une ArrayList est une List, par un Array. Regarde la javadoc pour t'en convaincre.

De fait tu devrais regarder de plus proche toutes les notions relatives au polymorphisme, en général on procède de la façon suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

List<Layer> list = new ArrayList<Layer>()

En effet dans le code on a juste besoin des méthodes qu'ArrayList implémente de l'interface List. Donc cela revient à manipuler une liste.

[Caxton]

Punaise mais ça ressemble pour beaucoup à mon exemple

Tien regarde

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
 
 private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
 
	//Crée un tableau illimitée
	//Nécessite import java.util.ArrayList;
	ArrayList<String> myArr = new ArrayList<String>();
 
	//Nombre d'éléments du tableau
	int nbrElements = 10;
	int nombre = 1;
 
	//Crée un tableau de n éléments
	for(int i = 0; i < nbrElements; i++) {
 
		myArr.add("Valeur" + nombre);
 
		nombre = nombre +1;
	}
 
	//Affiche chaque éléments
	for(int i = 0; i < myArr.size(); i++) {
		//Affiche le nomre d'éléments
		System.out.println(myArr.get(i));
	}
 
	System.out.println(" ");
	System.out.println("-----------------------------------");
	System.out.println(" ");
 
	//Supprime un élément au milieu
	myArr.remove(5);
 
	//Affiche chaque éléments
	for(int i = 0; i < myArr.size(); i++) {
		//Affiche le nomre d'éléments
		System.out.println(myArr.get(i));
	}
}

Ce n'est qu'un exemple.
A moi de comprendre maintenant comment marche les layer en mode list.

[sinok]

Sauf qu'ici tu n'utilises pas la notion de polymorphisme.

Re-regarde le code que j'ai mis en dessous et les types des deux cotés de l'affectation.

[Caxton]

D'un cotés tu a un List et de l'autre un ArrayList.
Le seul point commun est <Layer>.

Par contre j'ai peur de passé pour un noob, mais j'avoue ne pas saisir ce qu'est le polymorphisme (enfin je ne me fait peut être pas la bonne représentation de ce que c'est) et je ne voie pas comment un List peut aller avec un ArrayList.

Bah oui je débute quoi

[sinok]

ArrayList implémente l'interface List, donc ArrayList est une List.

Bref avant de modéliser va peut être falloir aller tâter de la conception objet de base (interfaces, implémentation, polymorphisme, encapsulation et tout ces petits trucs qui font que l'on programme correctement avec un langage de base).