Un commentaire sur la création de multigroup dans cck

Yes, very good module, i use a version from 10 august, everything works except differents display, i search a solution…

So, i demand me too why multigroup use delta, all works fine with, but, isn’t it really possible to add another field named gid or groupe_delta?

***************************************************************************************************************

This solutions have advantage to :
- don’t touch the delta (one delta by record for one field),
- don’t serialized any data.

One multigroup with different quantification for each field

In the form :

In this, field pen is enabled for just one field, the field color for more one.

vid   delta    gid     pen      vid   delta   gid   color
---------------------------------------------------------
1       0       0      bic1      1      0      0    green
1       1       1      bic2      1      1      1    blue          I have unordered
1       2       2      stab      1      4      2    red           delta2 to see that's
1       3       3      4color    1      3      3    blue          not a problem.
1       4       4      pilot1    1      7      4    blue
                                 1      2      3    red
                                 1      5      3    black
                                 1      6      3    green

If the user destroy the group, a choice is done to clear or not the gid field. If he decide or not to guard gids, the field’s definition is transform to multivalues field (if more than one field).

If he construct another group, a demand from system if a reinit for each field integrated is necessary, if not he can find all the ancients groups (a possibility to rename group).

It can be an option in multigroup to have syncs groups (as now, pseudo unique field who redefine the hook to define the number of fields to one by group line) with advantages to have table style display.

For view to see all group, a join on the gid is necessary like with the delta actually.

***************************************************************************************************************

Multi Group recursivity

The last idea is to have reccursion, it’s more complicated but possible
—————————————————————————————–
So the mains ideas to have a recursion is to have :
- a parent groupe id
- all group have a different id
- all records for one field have a different delta

For the same example :

brand  brandAdresse---------------------------------------------------------Groupe branding information
                articles----------------------------------------------------Groupe articles's families
                     identities---------------------------------------------Groupe articles's identities
                           options------------------------------------------Groupe articles's options
                                             color              ref---------Groupe articles's specifications
bic    elsewhere
       another place
                pen
                     classic
                            with rubber
                                             blue               ref1016
                                             red                ref1013
                                             green              ref1017
                            without rubber
                                             blue               ref1018
                                             red                ref1019
                                             green              ref1015
pilot  elsewhere
                pen
                    smarty
...

We take as rules:
-the vid is identical for all
-the delta is different for all in same field
-the gid is one for one group
-the gpid (parentid refer gid parent)

i use the notation delta-gid-gpid

                          adresse
            brand       Location ref   article        option       colors              ref1            brandref

br_gr  0    bic 0-0-0     refa 0-0-0
br_gr  0                  refc 2-0-0----------------------------------------------------------------------------------------unordered
ar_gr  2                                pen 0-2-0
ar_gr  2                                pen 3-2-0---------------------------------------------------------------------------unordered
op_gr  5                                       with rubber    0-5-2
re_gr  8                                                           blue  0-8-5      ref1496 0-8-5    7zz54155   0-8-5
  idem 9                                                           red   1-9-5      ref1639 1-9-5    6zz78451   1-9-5
  idem 10                                                          green 2-10-5     ref1018 2-10-5   7aa87459  2-10-5
  idem 10                                                          green 8-10-5                      7aa87460 10-10-5-------unordered
op_gr  6                                       without rubber 1-6-2
re_gr  11                                                          blue  3-11-6    ref1012 3-11-6    6zz47854 3-11-6
  idem 12                                                          red   4-12-6    ref1020 4-12-6    7aa65231 4-12-6
  idem 12                                                                          ref1025 5-12-6    7aa65271 5-12-6
  idem 12                                                                          ref1028 6-12-6    7aa65241 6-12-6
  idem 13                                                          green 5-13-6    ref1023 7-13-6    7aa58549 7-13-6
ar_gr  3                                pen 2-3-0---------------------------------------------------------------------------unordered
br_gr  1    pilot 1-1-1   refb 1-1-1
ar_gr  4                                pen 1-4-1
op_gr  7                                       with top       2-7-4
re_gr  14                                                          red   6-14-7    ref1028 8-14-7    1526326 8-14-7
  idem 15                                                          blue  7-15-7    ref1024 9-15-7    1542632 9-15-7

The unordered values have been add after to watch if an add is possible.

Use Cases

Each groupe have an add option.

In the first step, before any data is included, just the higher group is visible, and two links, add “same group” and add “sub group”. In this case add Brand and add Article. The add sub is inactive if less than one field is populate by value in his parent.

If add sub is click, a sub group is populate in memory, a gid incremented and a gpid included : all fields in this group inherit of this values.

If default data for a field or data add by user to a field, a increment delta is create for the field, and the gid and the parent gid are remember (save in the group).

We can move a sub group and attach to another group, by changing any gpid for fields in it (no for fields in sub sub groups).

View Integration

To render in view, each field must have link with parents.

For the exemple of the pen from bic without rubber and green have this :

                                |-------- join-----------|
                                |                        |
bic 0-0-0    refa 0-0-0   pen 0-2-0   without rubber 1-6-2   green 5-13-6    ref1023 7-13-6    7aa58549 7-13-6
      |             |             |                    |                |                 |                  |
      |             |----join-----|                    |-------join-----|                 |                  |
      |----------join-------------|                    |--------------------join----------|                  |
                                                       |--------------------------------------join-----------|

A join is add when add a field to view
- if one of parent field is present.
- if one of children field is present.
- for all join (a child is join to all parents) <- for this i’m not sure, all join, or just one

Groups of multiples values are allowed as normal (with delta) with add a restriction on the gid.

User can filter by group_id each field.

***************************************************************************************************************

I imagine that’s not the first time, that a person propose one of this solutions, and i agree with the others than have this idea before, and support in this direction.

Best Regards,

Nicolas

Présentation

En Php, il existe une librairie majeure pour la manipulation d’un objet xml, celle-ci s’appelle le DOM (DOMxml en php4).

Cette libraire reprends les spécifications du DOM fourni par le W3C, en ajoutant différentes ressources intéressantes comme la classe DOMDocumentFragment qui permet d’ajouter une chaine de caractères directement dans un document, des extensions permettant d’importer et d’exporter un noeud ou un document entier vers d’autres librairies.
D’autres librairies existent nous nous intéresserons à simpleXML, qui permet de simplifier (;)) un certain nombre d’opérations.
Nous verrons dans cet article quelles relations peuvent être effectuées entre ces librairies et quels bénéfices elles apportent.

Avantage et inconvénient des DOMDocuments

Un DOMDocument est un objet complexe qui nécessite une utilisation très rigoureuse, il est par exemple très difficile de récupérer une page web sans générer avertissements et erreurs. La chaine importée pour le créer doit être absolument formater suivant les standards.
La manipulation est par contre aiser et toutes les fonctions habituelles de parcours (nextSibling, firstChild, parentNode…), de modification (insertBefore, insertAfter, removeChild,…) sont implantées.

Avantage et inconvénient de simpleXML

SimpleXML, quand à elle est une bibliothèque simplifiée, le nombre de fonction est restreint et clair, la création simplifié, l’export aussi. La chaine conserve un formatage même après manipulation. Et chose agréable les conventions php, parcours de tableau, impression temporaire à l’aide de print_r,… sont conservées.
A l’inverse du DOM, les fonctions de manipulations sont malheureusement absentes, les modifications difficiles.

Une utilisation conjointe

Dans un soucis de simplicité et d’efficacité nous pouvons donc utiliser simpleXML pour le chargement et l’export, les lectures, et les ajouts simples. Pour des manipulations plus précises nous utiliserons le DOM, les méthodes et propriétés qui y sont associés.
En voici un exemple sur une insertion d’un noeud :

$xml=simplexml_load_file ("fichier1.xml");
$xml2=simplexml_load_file ("fichier2.xml");
$items=$xml2->channel->item;
foreach($items as $item){
    //Importation, création de l'arbre de base et placement sur le noeud cible
    $nodeFirstItem = dom_import_simplexml($xml->channel->item[0]);
    //ownerDocument représente le document de type DOMDocument créé
    //à la ligne précédente. true spécifie que les fils sont eux aussi importés
    $importNode=$nodeFirstItem->
        ownerDocument->importNode(dom_import_simplexml($item),true);
    //Manipulation de l'arbre par insertion
    $nodeFirstItem->parentNode->insertBefore($importNode, $nodeFirstItem);
}

Dans cette exemple nous supposerons que les fichiers fichier1 et fichier2 contenaient respectivement

<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" version="2.0">
  <channel>
    <title>All About Everything</title>
    <link>http://www.example.com/podcasts/everything/index.html</link>
    <item>
      <title>Shake Shake Shake Your Spices</title>
      <guid>http://example.com/podcasts/archive/aae20050643.m4a</guid>
    </item>
  </channel>
</rss>

et

<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" version="2.0">
  <channel>
    <title>All About World</title>
    <item>
      <title>Your Spices</title>
      <guid>http://example.com/podcasts/archive/aae20050615.m4a</guid>
    </item>
    <item>
      <title>Another Shake</title>
      <guid>http://example.com/podcasts/archive/aae20050620.m4a</guid>
    </item>
    </channel>
</rss>

L’avantage de cette technique est que les modifications apporter au DOMDocument sont transmises sans aucune fonction supplémentaires à l’objet simpleXML.
Une exemple en suppression de noeud :

$xml=simplexml_load_file("fichier2.xml");
$delNode = dom_import_simplexml($xml->channel->item[1]);
$delNode->parentNode->removeChild($delNode);

Conclusion

De mon point de vue, la meilleure solution serait une création de classes enfants aux classes du dom, facilitant les manipulations les plus courantes. Cette solution bien que propre et certainement plus saine qu’une utilisation conjointe de deux classes demanderait un temps de développement important.
Ces bibliothèques étant standards, elles sont maintenus par le PHP Group. Cela garantit une évolution suivie et constante tant au niveau des performances que de l’interopérabilité. De plus le temps étant une variable inaltérable, du moins sur notre chère planète bleu, nombre de projet devront conserver une utilisation des bibliothèques standards et il sera souhaitable de recourir aux techniques énoncées plus haut.
Libre à vous de choisir, et bon développement

La richesse des interfaces de ce langage lui permettent aussi bien de fournir une page formaté html que des graphique ou des résultats à la ligne de commande. Les différentes techniques permettant de générer un résultat sont dépendant des classes chargées dès qu’il s’agit d’afficher des

Utilisation en mode console

Mode simple

Les entrées et sorties console sont intégrées sans ajout de classes externes obligatoires, néanmoins comme le montre l’exemple suivant il est utile de référencé certaines classes afin de permettre une saisie optimisé (en l’occurence buffurisation de l’entrée clavier). Les arguments qaund à eux peuvent être intégré en entrée de la méthode main de la classe principale.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class system {
	public static void main(String[] args) throws IOException {
		for (int i = 0; i < args.length; i++) {
			System.out.println(args[i]);
		}
		String saisie = "";
		BufferedReader entreeClavier = new BufferedReader(
				new InputStreamReader(System.in));
		System.out.println("Taper 'je sors du programme' pour sortir");
		while (true) {
			if (saisie.equals("je sors du programme"))break;
			if(saisie!="jesors")System.out.print(saisie);
			saisie = entreeClavier.readLine();
			System.out.println("'"+saisie+"'");			
		}
	}
}

L’applet

L’applet est géré dans une classe simple, l’ajout de graphisme est permis par la méthode paint qui affichera texte et images.
L’exemple suivant permet une initialisation de l’applet en ajout à la propriété msg la valeur “Bonjour de java!’. La méthode paint sera ensuite appelé de manière authomatique et affichera le message précédemment enregistré.

import java.applet.Applet;
import java.awt.Graphics;
 
public class bonjour extends Applet {
	String msg;
	public void init() {
		msg="Bonjour de java !";
	}
	public void paint(Graphics g) {
		g.drawString(msg, 20, 20);
	}
 }

Les interfaces de formulaire

AWT

AWT s’appuie sur des composant pendant de la plateforme d’affichage, il est donc os dépendant. Son successeur introdfuit en java 2 swing s’extrait de ce lien.

Swing

Swing est une bibliothèque graphique pour le langage de programmation Java, faisant partie du package Java Foundation Classes (JFC), inclus dans J2SE. Swing constitue l’une des principales évolutions apportées par Java 2 par rapport aux versions antérieures.

Swing offre la possibilité de créer des interfaces graphiques identiques quel que soit le système d’exploitation sous-jacent, au prix de performances moindres qu’en utilisant Abstract Window Toolkit (AWT). Il utilise le principe Modèle/Vue-Contrôleur (M/VC, les composants Swing jouent en fait le rôle de Contrôleur au sens du MVC) et dispose de plusieurs choix d’apparence (de vue) pour chacun des composants standard.

Un exemple d’utilisation simple

// classes importées
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.JLabel;
 
public class form1 extends JFrame {
	// le constructeur
	public form1() {
		// titre de la fenêtre
		this.setTitle("Mon premier formulaire");
		this.getContentPane().add((new JLabel("Ceci est un label de formulaire!")));
		// dimensions de la fenêtre
		this.setSize(new Dimension(300, 100));
	}
	// fonction de test
	public static void main(String[] args) {
		System.out.println("Début du thread main");
		// on affiche le formulaire
		new form1().setVisible(true);
		// suivi
		System.out.println("Fin du thread main");
	}
}

Comme on peut le remarquer dans l’exemple précédent l’utilisation de swing se fait en complément de AWT et non en remplacement.

Bibliographie

Serge Tahé APPRENTISSAGE DU LANGAGE JAVA - Université d’Angers - 09/1998 - Rév. 06/2002
Wikipedia

Appliquer les lois de la logique a été une des premières innovations lié à l’informatique. Des langages comme le prolog ont ainsi été inventé afin de maitriser la logique des assertions comme :

Aristote est un homme.
Tous les hommes sont mortels.
Résultat fourni par l’ordinateur : Aristote est mortel.

La physique n’est pas en reste et les gamers jouent depuis nombre d’années dans des environnements virtuels 3D dans lesquels la pesanteurs et la gestions des collisions est au rendez vous.

Une application en flash

Etant donné la facilité d’implémentation des intéraction utilisateurs, ainsi que la génération graphique, j’ai intégré cette lois simple x(t)=1/2*gt² dans un environnement flash :

Le code est simple et ne réprésente qu’une centaine de lignes.

Quelques explications

Le déplacement est gérer par des vecteurs vitesse vx et vy. La fonction de base utilisé pour le déplacement est :

	function calcPosition() {
		position_x = -v0_x*t*Math.sin(angle)+pos0_x;
		position_y = -1/2*g*t*t-v0_y*t*Math.sin(angle)+pos0_y;
	}

La vitesse est réorienté à chaque collision suivant la fonction suivante :

	function rebond() {
		t = 0;
		var pos0:Array;
		pos0_x = this._x;
		pos0_y = this._y;
		var v0x = (positionAnt_x-position_x)/tick;
		var v0y = (positionAnt_y-position_y)/tick;
		v0_x = Math.abs(v0x);
		v0_y = Math.abs(v0y);
		calculateAngle(v0x*inv_x, v0y*inv_y);
		collision = 'sans';
	}

Qui en fait se résume à une mise à jour de la valeur d’angle et des vecteurs v0x et v0y.

Le déplacement est mise à jour a chaque image suivant les principes énooncés précédemment (mouvement paramétré et détection de collision). Comme l’exemple le montre le mouvement est fluide et correspond assez bien à une balle rebondissante.

Pour aller plus loin

Un exemple plus abouti a été réalisé par generalrelativity.org.

Une étude complète sur la détection de collision : Détection de collision sur flashxpress

Voici l’ouverture de ce blog essentiellement dédié au développement informatique, à ses liens avec le domaine artistique.