Changeset 62494 in spip-zone


Ignore:
Timestamp:
Jun 13, 2012, 6:10:49 PM (7 years ago)
Author:
fabrice.albert@…
Message:

Initialisation GMap 1.0 (sur SPIP 3)

Location:
_plugins_/gmap/trunk
Files:
185 added
45 deleted
12 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/gmap/trunk/balise/geomarkericons.php

    r55497 r62494  
    2525include_spip('inc/gmap_geoloc');
    2626include_spip('inc/gmap_config_utils');
     27include_spip('inc/gmap_spip_utils');
    2728
    2829// Globales
     
    9091                $contexte['id_point'] = $id_point;
    9192        $branches = (gmap_lire_config('gmap_optimisations', 'gerer_branches', 'oui') === 'oui') ? true : false;
    92         $icon = gmap_trouve_def_file($contexte, 'gmap-marker', 'gmd', $branches, gmap_theme_folder(), $GLOBALS['iconsAliases']);
     93        $icon = gmap_trouve_def_file($contexte, 'gmap-marker', 'gmd', array(
     94                                                                        'branches'=>$branches,
     95                                                                        'sous-dossier'=>gmap_theme_folder(),
     96                                                                        'buffer-aval'=>$GLOBALS['iconsAliases']));
    9397       
    9498        // Gérer le buffer
     
    151155               
    152156        $env = array('icons'=>$icons, 'name'=>$name, 'prefix'=>$prefix, 'folder'=>$folder);
    153         return recuperer_fond($fond, $env);
     157        return gmap_recuperer_fond($fond, $env);
    154158}
    155159
  • _plugins_/gmap/trunk/balise/geopopup.php

    r55497 r62494  
    2424include_spip('inc/gmap_geoloc');
    2525include_spip('gmap_filtres');
     26include_spip('inc/gmap_spip_utils');
    2627
    2728// Balise GEOPOPUP : renvoie les informations sur le marqueur associé à un point sur un objet
     
    7677                $contexte['id_point'] = $id_point;
    7778        $branches = (gmap_lire_config('gmap_optimisations', 'gerer_branches', 'oui') === 'oui') ? true : false;
    78         $fond = gmap_trouve_def_file($contexte, 'gmap-info', 'html', $branches, 'modeles');
     79        $fond = gmap_trouve_def_file($contexte, 'gmap-info', 'html', array(
     80                                                                        'branches'=>$branches,
     81                                                                        'sous-dossier'=>'modeles'));
    7982       
    8083        // Renvoyer vers la partie dynamique
     
    8891{
    8992        $env = array('objet'=>$objet, 'id_objet'=>$id_objet, 'type_point'=>$type, 'id_'.$objet=>$id_objet, 'objet_parent'=>$objet_parent, 'id_objet_parent'=>$id_objet_parent);
    90         $return = recuperer_fond($fond, $env);
     93        $return = gmap_recuperer_fond($fond, $env);
    9194        if ($contenu_seul || $json)
    9295        {
  • _plugins_/gmap/trunk/balise/gmap_balises.php

    r54597 r62494  
    3131 */
    3232
    33 $GLOBALS['context_query'] = array(
    34         'objet', 'id_objet',
    35         'id_document',
    36         'id_article',
    37         'id_breve',
    38         'id_rubrique',
    39         'id_secteur',
    40         'id_mot',
    41         'id_auteur',
    42         'type_point'
    43 );
     33// DEPRECATED
     34function _gmap_objet_englobant($p)
     35{
     36        $ret = array();
     37
     38        // on prend nom de la cle primaire de l'objet pour calculer sa valeur
     39        $_id_objet = $p->boucles[$p->id_boucle]->primary;
     40    $ret['id_objet'] = champ_sql($_id_objet, $p);
     41    $ret['objet'] = $p->boucles[$p->id_boucle]->id_table;
     42    $ret['objet_type'] = objet_type($ret['objet']);
     43       
     44        return $ret;
     45}
     46
     47function _gmap_objets_contexte($p) {
     48
     49        $contexte = array();
     50        $contexte['objet'] = false;
     51        $contexte['id_objet'] = false;
     52       
     53        $idb = $p->id_boucle;
     54        while (isset($p->boucles[$idb]) && !$contexte['id_objet']) {
     55                $objet = $p->boucles[$p->id_boucle]->id_table;
     56                $_id_objet = $p->boucles[$p->id_boucle]->primary;
     57                if ($objet !== 'geopoint') {
     58                        $contexte['objet'] = $objet;
     59                        $contexte['id_objet'] = champ_sql($_id_objet, $p);
     60                }
     61                $idb = $boucles[$idb]->id_parent;
     62        }
     63       
     64        return $contexte;
     65}
    4466
    4567// Au départ : lancer la balise dynamique
    4668function _gmap_calculer_balise($p, $nom)
    4769{
     70        // Calculer les paramètres dont on a besoin
     71        $args = array('objet', 'id_objet', 'id_geopoint', 'type_point');
     72        $contexte = _gmap_objets_contexte($p);
     73        $params = array($contexte['objet'], $contexte['id_objet']);
     74       
    4875        return calculer_balise_dynamique(
    49                         $p,             //  le nœud AST pour la balise
    50                         $nom,   //  le nom de la balise
    51                         $GLOBALS['context_query']); //  les éléments utilisables de l'environnement     
     76                        $p,                     // le nœud AST pour la balise
     77                        $nom,           // le nom de la balise
     78                        $args,          // les éléments utilisables de l'environnement 
     79                        $params);       // des paramètres supplémentaires passés
    5280}
    5381
     
    79107// Dans la partie statique, décoder les paramètres
    80108// Renvoie un tableau de paramètres nommés contenant :
    81 // - toujours "objet" et "id_objet"
     109// - toujours "objet", "id_objet" et "id_geopoint"
    82110// - "type_point", une chaine vide s'il n'est pas défini
    83111// - tous les autres paramètres passés à la balise
    84112function _gmap_calculer_balise_params($args, $bStrictParams = false)
    85113{
     114        // Redécomposer les arguments
     115        $dynargs = array_slice($args, 0, 4);    // objet, id_objet, id_geopoint, type_point
     116        $contexte = array_slice($args, 4, 2);   // objet, id_objet
     117        $options = array_slice($args, 6);               // les autres paramètres de la balise
     118       
    86119        // Commencer par décoder le paramètres explicites, donc ceux qui sont après ce
    87120        // qui a été demandé dans la pile
    88121        $params = array();
    89         for ($index = count($GLOBALS['context_query']); $index < count($args); $index++)
    90         {
    91                 list($key, $value) = _gmap_split_param($args[$index]);
     122        for ($index = 0; $index < count($options); $index++)
     123        {
     124                list($key, $value) = _gmap_split_param($options[$index]);
    92125                if (!$key)
    93126                        continue;
     
    100133        if (isset($params['query']))
    101134                $bStrictParams = true;
    102        
     135               
    103136        // Inialiser les paramètres implicites
    104137        $objet = null;
    105138        $id_objet = null;
     139        $id_geopoint = null;
    106140        $type_point = null;
    107141       
    108142        // Traiter le cas "type_point" en premier, il simplifiera la suite
    109         if (isset($params["type_point"]))
    110         {
     143        if (isset($params["type_point"])) {
     144       
    111145                if ($params["type_point"] === true)
    112                         $type_point = $args[array_search("type_point", $GLOBALS['context_query'], true)];
     146                        $type_point = $dynargs[3];
    113147                else
    114148                        $type_point = $params["type_point"];
     149                       
    115150                unset($params["type_point"]);
    116151        }
    117152       
     153        // Id_geopoint
     154        if (isset($params["id_geopoint"])) {
     155       
     156                if ($params["id_geopoint"] === true)
     157                        $id_geopoint = $dynargs[2];
     158                else
     159                        $id_geopoint = $params["id_geopoint"];
     160                       
     161                unset($params["id_geopoint"]);
     162        }
     163       
    118164        // Traiter le cas de "objet" dont peut dépendre le type d'objet choisit
    119         if (isset($params["objet"]))
    120         {
     165        if (isset($params["objet"])) {
     166       
    121167                if (is_string($params["objet"]))
    122168                        $objet = $params["objet"];
     169                       
    123170                unset($params["objet"]);
    124171        }
     
    126173        // Finalement, traiter le cas de id_objet qui est prioritaire, mais
    127174        // seulement si $objet est déjà défini
    128         if (isset($params["id_objet"]))
    129         {
     175        if (isset($params["id_objet"])) {
     176       
    130177                if ($objet && is_string($params["id_objet"]))
    131178                        $id_objet = $params["id_objet"];
     179                       
    132180                unset($params["id_objet"]);
    133181        }
    134182       
    135         // Là, on a nettoyé les paramètres passés manuellement ($params) de "objet", "id_objet" et
    136         // "type_point", si on n'a trouvé aucun objet, on va essayer d'en trouvé un dans la pile
    137        
    138         // Si on n'a pas de id_objet, mais un objet désigné, le chercher
    139         if (!$id_objet && is_string($objet))
    140         {
    141                 $idName = 'id_'.$objet;
    142                 if (isset($params[$idName]) && is_string($params[$idName]))
    143                         $id_objet = $params[$idName];
    144                 else if ($index = array_search($idName, $GLOBALS['context_query'], true))
    145                         $id_objet = $args[$index];
    146         }
    147        
    148         // Si on n'a pas de id_objet, parcourir les paramètres explicites pour voir si
    149         // un type d'objet est désigné (c'est le cas le plus courant : on a mis dans les
    150         // paramètre {id_rubrique} ou {id_rubrique=XX})
    151         if (!$id_objet)
    152         {
     183        // Chercher si on a un id_* en paramètre, s'il y en a un, il faut qu'il corresponde
     184        // à l'objet de la boucle englobante (en gros, il ne sert à rien...)
     185        if (!$id_objet) {
    153186                // Rechercher le premier paramètre qui correspond à un des paramètres implicites
    154                 foreach ($params as $key => $value)
    155                 {
    156                         if (($key === "objet") || ($key === "id_objet") || ($key === "type_point"))
     187                foreach ($params as $key => $value) {
     188               
     189                        if (($key === "objet") || ($key === "id_objet") || ($key === "id_geopoint") || ($key === "type_point"))
    157190                                continue;
    158                         if (in_array($key, $GLOBALS['context_query'], true))
     191                        if (preg_match("/^id_([a-z]*)$/i", $key, $matches))
    159192                        {
    160                                 if (preg_match("/^id_([a-z]*)$/i", $key, $matches))
    161                                 {
    162                                         $objet = $matches[1];
    163                                         if ($value === true)
    164                                                 $id_objet = $args[array_search($key, $GLOBALS['context_query'], true)];
    165                                         else
    166                                                 $id_objet = $value;
    167                                         break;
    168                                 }
     193                                if (($value === true) && ($contexte[0] === $matches[1]))
     194                                        $id_objet = $contexte[1];
     195                                else
     196                                        $id_objet = $value;
     197                                break;
    169198                        }
    170199                }
    171200        }
    172201       
    173         // Si on n'a toujours rien, parcourir les paramètres implicites dans l'ordre
    174         // de préférence
    175         // Ici, il serait mieux de prendre la boucle la plus proche, mais je ne sais pas
    176         // faire ça dans une balise dynamique : il faudrait décoder les codes PHP renvoyés
    177         // pour les valeurs afin de voir lequel a l'indice le plus proche
    178         if (!$id_objet && ($bStrictParams !== true))
    179         {
    180                 foreach ($GLOBALS['context_query'] as $index => $name)
    181                 {
    182                         if (($name === "objet") || ($name === "id_objet") || ($name === "type_point"))
    183                                 continue;
    184                         $value = $args[$index];
    185                         if (isset($value) && is_string($value) && strlen($value))
    186                         {
    187                                 if (preg_match("/^id_([a-z]*)$/i", $name, $matches))
    188                                 {
    189                                         $objet = $matches[1];
    190                                         $id_objet = $value;
    191                                         break;
    192                                 }
    193                         }
    194                 }
    195         }
    196        
    197         // Nettoyer de l'objet trouvé, puis rechercher dans la pile les autres
    198         foreach ($params as $name => $value)
    199         {
    200                 // Supprimer si c'est l'objet qu'on a trouvé
    201                 if ($name === 'id_'.$objet)
    202                         unset($params[$name]);
    203                        
    204                 // Si aucune valeur explicite n'est donnée, tenter de reprendre dans la
    205                 // pile
    206                 else if (!is_string($value))
    207                 {
    208                         if ($index = array_search($name, $GLOBALS['context_query'], true))
    209                                 $params[$name] = $args[$index];
    210                         if (!$params[$name] || !strlen($params[$name]))
    211                                 unset($params[$name]);
    212                 }
    213         }
     202        // Si le contexte dynamique contient explicitement objet et id_objet, les utiliser
     203        if (!$objet || !$id_objet) {
     204                if ($dynargs[0] && strlen($dynargs[0]) && $dynargs[1]) {
     205                        $objet = $dynargs[0];
     206                        $id_objet = $dynargs[1];
     207                }
     208        }
     209       
     210        // Sinon prendre l'objet de la boucle englobante, passé dans le contexte
     211        if ((!$objet || !$id_objet) && ($bStrictParams !== true)) {
     212                if ($contexte[0] && strlen($contexte[0]) && $contexte[1]) {
     213                        $objet = $contexte[0];
     214                        $id_objet = $contexte[1];
     215                }
     216        }
     217       
     218        // Nettoyer de l'objet trouvé
     219        if (isset($params['id_'.$objet]))
     220                unset($params['id_'.$objet]);
    214221               
    215         // Remettre l'objet et le type de point
     222        // Remettre les objets récupérés
    216223        if (isset($objet) && isset($id_objet) && is_string($objet) && strlen($objet))
    217224        {
     
    221228        if (isset($type_point) && is_string($type_point) && strlen($type_point))
    222229                $params['type_point'] = $type_point;
     230        if (isset($id_geopoint))
     231                $params['id_geopoint'] = $id_geopoint;
    223232       
    224233        return $params;
    225234}
     235
    226236
    227237
  • _plugins_/gmap/trunk/base/gmap_tables.php

    r52218 r62494  
    1313if (!defined("_ECRIRE_INC_VERSION")) return;
    1414
     15// Déclaration de la table principale (utilisée dans declarer_tables_objets_sql et
     16// declarar_tables_principales)
     17function _gmap_table_geopoints() {
     18        return array(
     19                'principale'                    => 'oui',
     20               
     21                'table_objet'                   => 'geopoints',
     22                'type'                                  => 'geopoint',
     23               
     24                'field'                                 => array(
     25                        "id_geopoint"                   => "bigint(21) NOT NULL AUTO_INCREMENT",
     26                        "id_parent"                             => "bigint(21) DEFAULT '0' NOT NULL",
     27                        "nom"                                   => "text NOT NULL",
     28                        "descriptif"                    => "text NOT NULL",
     29                        "date"                                  => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
     30                        "longitude"                     => "double DEFAULT '0.0' NOT NULL",
     31                        "latitude"                              => "double DEFAULT '0.0' NOT NULL",
     32                        "zoom"                                  => "tinyint(4) DEFAULT '0' NOT NULL",
     33                        "id_type_geopoint"              => "bigint(21) DEFAULT '0' NOT NULL",
     34                        "tile"                                  => "char(20) DEFAULT '' NOT NULL"
     35                ),
     36                'key'                                    => array(
     37                        "PRIMARY KEY"                   => "id_geopoint",
     38                        "KEY id_parent"                 => "id_parent",
     39                        "KEY tile"                              => "tile",
     40                ),
     41                'join'                                  => array(
     42                        "id_geopoint"                   => "id_geopoint",
     43                        "id_type_geopoint"              => "id_type_geopoint"
     44                ),
     45                'tables_jointures'              => array(
     46                        "id_geopoint"                   => "geopoints_liens",
     47                        "id_type_geopoint"              => "types_geopoints",
     48                ),
     49
     50                'titre'                                 => "nom AS titre, '' AS lang",
     51                'date'                                  => 'date',
     52                'champs_editables'              => array('nom', 'descriptif', 'date', 'longitude', 'latitude', 'zoom'),
     53               
     54                'rechercher_champs'     => array('nom' => 8, 'descriptif' => 5),
     55
     56                'url_voir'                              => 'geopoint',
     57                'url_edit'                              => 'geopoint_edit',
     58                'page'                                  => '',
     59               
     60                'icone_objet'                   => 'geopoint',
     61                'texte_retour'                  => 'icone_retour',
     62                'texte_objets'                  => 'gmap:geopoints',
     63                'texte_objet'                   => 'gmap:geopoint',
     64                'texte_modifier'                => 'gmap:icone_modifier_geopoint',
     65                'texte_creer'                   => 'gmap:icone_creer_geopoint',
     66                'texte_ajouter'                 => 'gmap:titre_ajouter_un_point',
     67                'texte_creer_associer'  => 'gmap:creer_et_associer_un_point',
     68                'info_aucun_objet'              => 'gmap:info_aucun_geopoint',
     69                'info_1_objet'                  => 'gmap:info_1_geopoint',
     70                'info_nb_objets'                => 'gmap:info_nb_geopoints',
     71                'texte_logo_objet'              => 'gmap:logo_geopoint',
     72               
     73        );
     74}
     75
     76
     77// Pipeline declarer_tables_objets_sql pour déclarer toutes les tables en SPIP 3
     78// Cf. http://www.spip.net/fr_article5525.html
     79// Cf. code SPIP : ecrire/base/objets.php
     80function gmap_declarer_tables_objets_sql($tables) {
     81
     82        //// La table principale des points
     83       
     84        $tables['spip_geopoints'] = _gmap_table_geopoints();
     85
     86
     87        // Les points peuvent se mettre sur tous les objets, donc tout le monde
     88        // peu faire une jointure sur geopoints_liens
     89    $tables[]['tables_jointures'][]= 'geopoints_liens';
     90       
     91        return $tables;
     92}
     93
    1594// Pipeline declarer_tables_principales
    16 function gmap_declarer_tables_principales($tables_principales)
    17 {
    18         // spip_gmap_points : points géographiques
    19     $gmap_points = array(
    20         "id_point" => "bigint(21) NOT NULL AUTO_INCREMENT",
    21                 "longitude" => "double DEFAULT '0.0' NOT NULL",
    22                 "latitude" => "double DEFAULT '0.0' NOT NULL",
    23         "zoom" => "tinyint(4) DEFAULT '0' NOT NULL",
    24         "id_type_point" => "bigint(21) DEFAULT '0' NOT NULL"
    25         );
    26     $gmap_points_key = array(
    27         "PRIMARY KEY" => "id_point"
    28         );
    29     $gmap_points_join = array(
    30         "id_point"=>"id_point",
    31         "id_type_point"=>"id_type_point"
    32         );
    33     $tables_principales['spip_gmap_points'] = array(
    34         'field' => &$gmap_points,
    35         'key' => &$gmap_points_key,
    36         'join' => &$gmap_points_join
    37         );
    38        
     95// On ne devrait plus en avoir besoin, mais il semble qu'il réclame tout de même...
     96function gmap_declarer_tables_principales($tables_principales) {
     97        $tables_principales['spip_geopoints'] = _gmap_table_geopoints();
    3998        return $tables_principales;
    4099}
    41100
    42101// Pipeline declarer_tables_auxiliaires
    43 function gmap_declarer_tables_auxiliaires($tables_auxiliaires)
    44 {
    45         // Lien entre les points et les autres entitiés SPIP
    46     $spip_gmap_points_liens = array(
    47         "id_point" => "bigint(21) DEFAULT '0' NOT NULL",
    48         "id_objet" => "bigint(21) DEFAULT '0' NOT NULL",
    49         "objet" => "VARCHAR (25) DEFAULT '' NOT NULL"
    50                 );
    51     $spip_gmap_points_liens_key = array(
    52         "PRIMARY KEY" => "id_point,id_objet,objet",
    53         "KEY id_point" => "id_point",
    54         "KEY id_objet" => "objet,id_objet"
    55                 );
    56     $tables_auxiliaires['spip_gmap_points_liens'] = array(
    57         'field' => &$spip_gmap_points_liens,
    58         'key' => &$spip_gmap_points_liens_key
    59                 );
    60 
    61         // spip_gmap_types : types prédéfinis
    62     $gmap_types = array(
    63         "id_type_point" => "bigint(21) NOT NULL AUTO_INCREMENT",
    64                 "objet" => "varchar(25) DEFAULT '' NOT NULL",
    65         "nom" => "varchar(50) NOT NULL",
    66         "descriptif" => "text DEFAULT '' NOT NULL",
    67                 "visible" => "varchar(3) DEFAULT 'oui' NOT NULL",
    68                 "priorite" => "tinyint(4) DEFAULT 99 NOT NULL",
    69         );
    70     $gmap_types_key = array(
    71         "PRIMARY KEY" => "id_type_point",
    72                 "KEY objet" => "objet"
    73         );
    74     $tables_auxiliaires['spip_gmap_types'] = array(
    75         'field' => &$gmap_types,
    76         'key' => &$gmap_types_key,
    77         );
    78        
    79         // spip_gmap_labels : données custom sur un point
    80     $gmap_labels = array(
    81         "id_point" => "bigint(21) NOT NULL",
    82         "descriptif" => "text NOT NULL"
    83         );
    84     $gmap_labels_key = array(
    85         "PRIMARY KEY" => "id_point",
    86         );
    87     $tables_auxiliaires['spip_gmap_labels'] = array(
    88         'field' => &$gmap_labels,
    89         'key' => &$gmap_labels_key,
    90         );
    91 
     102// Normalement, en SPIP 3, on pourrait passer la déclaration de toutes les
     103// tables dans
     104function gmap_declarer_tables_auxiliaires($tables_auxiliaires) {
     105
     106        //// La table de liaison, également utilisée seule dans la boucle GEOTEST
     107       
     108        $tables_auxiliaires['spip_geopoints_liens'] = array(
     109                'principale'                    => 'non',
     110               
     111                'table_objet'                   => 'geopoints_liens',
     112                'table_objet_surnom'    => 'geotest',
     113                'type'                                  => 'geotest',
     114               
     115                'field'                                 => array(
     116                        "id_geopoint"                   => "bigint(21) DEFAULT '0' NOT NULL",
     117                        "id_objet"                              => "bigint(21) DEFAULT '0' NOT NULL",
     118                        "objet"                                 => "VARCHAR (25) DEFAULT '' NOT NULL"
     119                ),
     120                'key'                                    => array(
     121                        "PRIMARY KEY"                   => "id_geopoint,id_objet,objet",
     122                        "KEY id_geopoint"               => "id_geopoint",
     123                        "KEY id_objet"                  => "objet,id_objet"
     124                ),
     125                'join'                                  => array(
     126                        "id_geopoint"                   => "id_geopoint",
     127                ),
     128                'tables_jointures'              => array(
     129                        "id_geopoint"                   => "geopoints",
     130                ),
     131               
     132        );
     133       
     134       
     135        //// La table des types de pointeurs
     136
     137        $tables_auxiliaires['spip_types_geopoints'] = array(
     138                'principale'                    => 'non',
     139               
     140                'table_objet'                   => 'types_geopoints',
     141                'type'                                  => 'type_geopoint',
     142               
     143                'field'                                 => array(
     144                        "id_type_geopoint"              => "bigint(21) NOT NULL AUTO_INCREMENT",
     145                        "objet"                                 => "varchar(25) DEFAULT '' NOT NULL",
     146                        "nom"                                   => "varchar(50) NOT NULL",
     147                        "descriptif"                    => "text DEFAULT '' NOT NULL",
     148                        "visible"                               => "varchar(3) DEFAULT 'oui' NOT NULL",
     149                        "priorite"                              => "tinyint(4) DEFAULT 99 NOT NULL",
     150                ),
     151                'key'                                   => array(
     152                        "PRIMARY KEY"                   => "id_type_geopoint",
     153                        "KEY objet"                             => "objet"
     154                ),
     155               
     156        );
     157       
    92158        return $tables_auxiliaires;
    93159}
    94160
    95161// Pipeline declarer_tables_interfaces
    96 function _declarer_interfaces_directes(&$interface) // accès direct à la table gmap_points
    97 {
     162// Cf. code SPIP :  ecrire/public/interfaces.php
     163function gmap_declarer_tables_interfaces($interface) {
     164
    98165    // Nommage de la table
    99         $interface['table_des_tables']['gmap_points'] = 'gmap_points';
    100         $interface['table_des_tables']['geopoints'] = 'gmap_points';
    101        
    102         // Ajout des possibilités de jointures avec les tables de base
    103     $interface['tables_jointures']['spip_gmap_points'][]= 'gmap_points_liens';
    104     $interface['tables_jointures']['spip_gmap_points'][]= 'gmap_types';
    105     $interface['tables_jointures']['spip_gmap_points'][]= 'gmap_labels';
    106     $interface['tables_jointures']['spip_rubriques'][]= 'gmap_points_liens';
    107     $interface['tables_jointures']['spip_articles'][]= 'gmap_points_liens';
    108     $interface['tables_jointures']['spip_breves'][]= 'gmap_points_liens';
    109     $interface['tables_jointures']['spip_documents'][]= 'gmap_points_liens';
    110     $interface['tables_jointures']['spip_mots'][]= 'gmap_points_liens';
    111     $interface['tables_jointures']['spip_auteurs'][]= 'gmap_points_liens';
    112        
    113         // Aliases
    114         $interface['exceptions_des_tables']['gmap_points']['objet'] = array('gmap_points_liens', 'objet');
    115         $interface['exceptions_des_tables']['gmap_points']['id_objet'] = array('gmap_points_liens', 'id_objet');
    116         $interface['exceptions_des_tables']['gmap_points']['type_point'] = array('gmap_types', 'nom');
    117         $interface['exceptions_des_tables']['gmap_points']['descriptif'] = array('gmap_types', 'descriptif');
    118         $interface['exceptions_des_tables']['gmap_points']['visible'] = array('gmap_types', 'visible');
    119         $interface['exceptions_des_tables']['gmap_points']['priorite'] = array('gmap_types', 'priorite');
    120         $interface['exceptions_des_tables']['geopoints']['objet'] = array('gmap_points_liens', 'objet');
    121         $interface['exceptions_des_tables']['geopoints']['id_objet'] = array('gmap_points_liens', 'id_objet');
    122         $interface['exceptions_des_tables']['geopoints']['type_point'] = array('gmap_types', 'nom');
    123         $interface['exceptions_des_tables']['geopoints']['descriptif'] = array('gmap_types', 'descriptif');
    124         $interface['exceptions_des_tables']['geopoints']['visible'] = array('gmap_types', 'visible');
    125         $interface['exceptions_des_tables']['geopoints']['priorite'] = array('gmap_types', 'priorite');
    126 }
    127 function _declarer_interfaces_liens(&$interface) // accès direct à la table gmap_points_liens
    128 {
    129     // Nommage de la table
    130         // ATTENTION : l'utilisation de ce tableau est à l'inverse de ce
    131         // qui est décrit dans doc.spip.org. On donne d'abord l'alias puis
    132         // à quoi il correspond.
    133         $interface['table_des_tables']['geotest'] = 'gmap_points_liens';
    134         // Ce lien sert à ce que la boucle GEOTEST accepte les critères habituels tels que id_article
    135 }
    136 function gmap_declarer_tables_interfaces($interface)
    137 {
    138         // Définitions pour l'accès direct à la table gmap_points
    139         _declarer_interfaces_directes($interface);
    140        
    141         // Définitions pour l'accès direct à la table gmap_points_liens
    142         _declarer_interfaces_liens($interface);
     166        $interface['table_des_tables']['geopoints'] = 'geopoints';
     167        $interface['table_des_tables']['geotest'] = 'geopoints_liens';
     168        $interface['table_des_tables']['types_geopoints'] = 'types_geopoints';
     169       
     170        // Aliases des champs obtenus par jointure
     171        $interface['exceptions_des_tables']['geopoints']['objet'] = array('geopoints_liens', 'objet');
     172        $interface['exceptions_des_tables']['geopoints']['id_objet'] = array('geopoints_liens', 'id_objet');
     173        $interface['exceptions_des_tables']['geopoints']['type_point'] = array('types_geopoints', 'nom');
     174        $interface['exceptions_des_tables']['geopoints']['descriptif_type'] = array('types_geopoints', 'descriptif');
     175        $interface['exceptions_des_tables']['geopoints']['visible'] = array('types_geopoints', 'visible');
     176        $interface['exceptions_des_tables']['geopoints']['priorite'] = array('types_geopoints', 'priorite');
    143177       
    144178        return $interface;
    145179}
    146180
     181// Pipeline declarer_tables_objets_surnoms pour bien singulariser les noms composés
     182function gmap_declarer_tables_objets_surnoms($surnoms) {
     183        $surnoms['type_geopoint'] = "types_geopoints";
     184        $surnoms['geopoint_lien'] = "geopoints_liens";
     185        $surnoms['geotest'] = "geopoints_liens";
     186        return $surnoms;
     187}
     188
     189// Initialisation de la configuration
     190function gmap_initialize_configuration() {
     191        include_spip('inc/gmap_config_utils');
     192       
     193        // API utilisée
     194        if ($initGis = charger_fonction("initialiser", "formulaires/configurer_gmap_gis", true))
     195                call_user_func($initGis);
     196        else
     197                gmap_init_config('gmap_api', 'api', 'gma3');
     198               
     199        // Paramétrage par défaut de l'API
     200        if ($iniAPI = charger_fonction("initialiser", "formulaires/configurer_gmap_api", true))
     201                call_user_func($initAPI);
     202       
     203        // Initialiser les zones autorisées
     204        $iniRUB = charger_fonction('init_rubgeo', 'configuration', true);
     205        if ($iniRUB)
     206                $iniRUB();
     207               
     208        // Initialiser l'interface dans toutes les APIs
     209        $iniUI = charger_fonction('init_map_defaults', 'configuration', true);
     210        if ($iniUI)
     211                $iniUI();
     212        $iniMarkersUI = charger_fonction('init_markers_behavior', 'configuration', true);
     213        if ($iniMarkersUI)
     214                $iniMarkersUI();
     215
     216    // Réécrire tous les paramètres
     217    ecrire_metas();
     218
     219}
     220
     221// Ajout des types de documents KML/KMZ s'il n'y sont pas déjà
     222function gmap_verif_types_documents() {
     223        include_spip('base/abstract_sql');
     224
     225    $rowset = sql_select("extension", "spip_types_documents", "extension='kml'");
     226    if (!$row = sql_fetch($rowset))
     227                sql_insertq("spip_types_documents", array(
     228                                'titre' => 'Google Earth Placemark',
     229                                'descriptif' => '',
     230                                'extension' => 'kml',
     231                                'mime_type' => 'application/vnd.google-earth.kml+xml',
     232                                'inclus' => 'non',
     233                                'upload' => 'oui',
     234                                'maj' => 'NOW()'));
     235        sql_free($rowset);
     236       
     237    $rowset = sql_select("extension", "spip_types_documents", "extension='kmz'");
     238    if (!$row = sql_fetch($rowset))
     239                sql_insertq("spip_types_documents", array(
     240                                'titre' => 'Google Earth Placemark',
     241                                'descriptif' => '',
     242                                'extension' => 'kmz',
     243                                'mime_type' => 'application/vnd.google-earth.kmz',
     244                                'inclus' => 'non',
     245                                'upload' => 'oui',
     246                                'maj' => 'NOW()'));
     247        sql_free($rowset);
     248       
     249}
     250
     251// Création des types de pointeur par défaut
     252function gmap_cree_types_defaut() {
     253        include_spip('inc/gmap_db_utils');
     254       
     255        gmap_cree_type("defaut", _T('gmap:marker_def_defaut'), "", "oui", 1);
     256        gmap_cree_type("centre", _T('gmap:marker_def_centre'), "", "non", 99);
     257        gmap_cree_type("etape", _T('gmap:marker_def_article_etape'), "article", "oui", 4);
     258        gmap_cree_type("prise", _T('gmap:marker_def_document_prise'), "document", "oui", 2);
     259        gmap_cree_type("visee", _T('gmap:marker_def_document_visee'), "document", "oui", 4);
     260       
     261}
     262
     263
    147264?>
  • _plugins_/gmap/trunk/gmap_administrations.php

    r53465 r62494  
    1010 */
    1111
    12 // Pour SPIP 3.0.* : la balises <install> du plugin.xml n'existent plus dans paquet.XML
    13 include_spip('base/gmap_install');
     12include_spip('inc/meta');
     13
     14include_spip('base/gmap_tables');
     15
     16
     17function gmap_upgrade($nom_meta_base_version, $version_cible) {
     18
     19        $maj = array();
     20       
     21        // Création "from scratch"
     22        $maj['create'] = array(
     23                array('maj_tables', array('spip_geopoints', 'spip_geopoints_liens', 'spip_types_geopoints')),
     24                array('gmap_cree_types_defaut'),
     25                array('gmap_verif_types_documents'),
     26                array('gmap_initialize_configuration'),
     27        );
     28       
     29        // Mise à jour pour version 1.0.1 (ajout du champs nom dans les libellés)
     30        $maj['1.0.1'] = array(
     31       
     32                array('sql_alter', "TABLE spip_gmap_points RENAME TO spip_geopoints"),
     33                array('sql_alter', "TABLE spip_gmap_points_liens RENAME TO spip_geopoints_liens"),
     34                array('sql_alter', "TABLE spip_gmap_types RENAME TO spip_types_geopoints"),
     35               
     36                array('sql_drop_table', "spip_gmap_labels"),
     37               
     38                array('sql_alter', "TABLE spip_geopoints CHANGE id_point id_geopoint bigint(21) NOT NULL AUTO_INCREMENT"),
     39                array('sql_alter', "TABLE spip_geopoints ADD id_parent bigint(21) DEFAULT '0' NOT NULL"),
     40                array('sql_alter', "TABLE spip_geopoints ADD nom text DEFAULT '' NOT NULL"),
     41                array('sql_alter', "TABLE spip_geopoints ADD descriptif text DEFAULT '' NOT NULL"),
     42                array('sql_alter', "TABLE spip_geopoints ADD date datetime DEFAULT '0000-00-00 00:00:00' NOT NULL"),
     43                array('sql_alter', "TABLE spip_geopoints CHANGE id_type_point id_type_geopoint bigint(21) DEFAULT '0' NOT NULL"),
     44                array('sql_alter', "TABLE spip_geopoints ADD tile char(20) DEFAULT '' NOT NULL"),
     45               
     46                array('sql_alter', "TABLE spip_geopoints_liens CHANGE id_point id_geopoint bigint(21) DEFAULT '0' NOT NULL"),
     47               
     48                array('sql_alter', "TABLE spip_types_geopoints CHANGE id_type_point id_type_geopoint bigint(21) NOT NULL AUTO_INCREMENT"),
     49               
     50        );
     51       
     52        include_spip('base/upgrade');
     53        maj_plugin($nom_meta_base_version, $version_cible, $maj);
     54       
     55}
     56
     57
     58function gmap_vider_tables($nom_meta_base_version) {
     59
     60        sql_drop_table("spip_geopoints");
     61        sql_drop_table("spip_geopoints_liens");
     62        sql_drop_table("spip_types_geopoints");
     63       
     64        effacer_meta($nom_meta_base_version);
     65       
     66}
    1467
    1568?>
  • _plugins_/gmap/trunk/gmap_autoriser.php

    r52218 r62494  
    1010 */
    1111
    12 // Autorisation du plugin
     12// Pour le chargement du fichier en pipeline
    1313function gmap_autoriser()
    1414{
     
    1616
    1717// Autorisation de la configuration de GMap, uniquement pour le webmestre
     18function autoriser_configurer_gmap_dist($faire, $type, $id, $qui, $opt)
     19{
     20        return autoriser('webmestre') || autoriser('0minirezo');
     21}
    1822function autoriser_configurer_gmap_bouton_dist($faire, $type, $id, $qui, $opt)
    1923{
    20         // Seulement si on est admin
    21         return (autoriser('webmestre'));
     24        return autoriser('webmestre') || autoriser('0minirezo');
    2225}
    2326
  • _plugins_/gmap/trunk/gmap_pipeline.php

    r55497 r62494  
    2323       
    2424        // Inclure le style
    25         $css_prive = _DIR_PLUGIN_GMAP . 'style/gmap_private.css';
     25        $css_prive = find_in_path('style/gmap_private.css');
    2626        $flux .= '<link rel="stylesheet" type="text/css" media="screen" href="'.$css_prive.'" />' . "\n";
    27         $css_balloon = _DIR_PLUGIN_GMAP . 'style/gmap-balloon.css';
     27        $css_balloon = find_in_path('style/gmap-balloon.css');
    2828        $flux .= '<link rel="stylesheet" type="text/css" media="screen" href="'.$css_balloon.'" />' . "\n";
    2929       
    3030        // Ajouter le style du picker de spip_bonux
     31        /* Plus nécessaire en SPIP 3 ?
    3132        $css_picker = find_in_path('formulaires/selecteur/picker.css');
    3233        if ($css_picker)
    3334                $flux .= '<link rel="stylesheet" type="text/css" media="screen" href="'.$css_picker.'" />' . "\n";
     35        */
    3436       
    3537        // On n'inclut pas les scripts si la clef Google Maps n'est pas définie
     38        include_spip('inc/gmap_config_utils'); // parfois le pipeline est appelé avant que les fichiers soient chargés
    3639        if (!gmap_est_actif())
    3740                return $flux;
    3841               
    3942        // Inclure les outils de base
    40         $js_utils = _DIR_PLUGIN_GMAP . 'javascript/gmap_js_utils.js';
     43        $js_utils = find_in_path('javascript/gmap_js_utils.js');
    4144        $flux .= '<script type="text/javascript" src="'.$js_utils.'"></script>' . "\n";
    4245       
     
    4649       
    4750        // Inclure les scripts supplémentaires et les styles pour la partie privée
    48         $js_prive = _DIR_PLUGIN_GMAP . 'javascript/gmap_private.js';
     51        $js_prive = find_in_path('javascript/gmap_private.js');
    4952        $flux .= '<script type="text/javascript" src="'.$js_prive.'"></script>' . "\n";
    5053       
     
    6568       
    6669        // Edition d'une rubrique
    67         if ($flux['args']['exec'] === 'naviguer')
     70        if ($flux['args']['exec'] === 'rubrique')
    6871        {
    6972                $id_rubrique = $flux['args']['id_rubrique'];
     
    7780       
    7881        // Edition d'un article
    79         else if ($flux['args']['exec'] === 'articles')
     82        else if ($flux['args']['exec'] === 'article')
    8083        {
    8184                $id_article = $flux['args']['id_article'];
     
    8992
    9093        // Edition d'un document
    91         // Avec le plugin médiathèque, deux éditions possibles :
    92         // - documents_edit : c'est la page à laquelle on accède depuis la médiathèque
    93         // - document_edit : c'est le popup qui s'affiche quand on fait "modifier" sur un doc depuis son article
    94         else if ($flux['args']['exec'] === 'documents_edit')
     94        else if ($flux['args']['exec'] === 'document_edit')
    9595        {
    9696                $id_document = $flux['args']['id_document'];
     
    101101                }
    102102        }
    103 /*      Comme dit plus haut, je n'arrive pas à faire marcher l'initialisation de la carte
    104         et la soumission du formulaire dans une modalbox, donc inutile d'ajouter le code.
    105         Si quelqu'un a une idée...
    106         else if ($flux['args']['exec'] === 'document_edit')
    107         {
    108                 $id_document = $flux['args']['id_document'];
    109                 if (gmap_est_geolocalisable('document', $id_document))
    110                 {
    111                         include_spip('inc/gmap_saisie_privee');
    112                         $flux['data'] .= gmap_saisie_privee($id_document, 'document', $flux['args']['exec']);
    113                 }
    114         }*/
    115103
    116104        // Edition d'une brève
    117         else if ($flux['args']['exec'] === 'breves_voir')
     105        else if ($flux['args']['exec'] === 'breve')
    118106        {
    119107                $id_breve = $flux['args']['id_breve'];
     
    168156        return $flux;
    169157}
     158// Maintenant passer par afficher_contenu_objet qui marche aussi bien en spip2 qu'en spip3
     159function gmap_afficher_contenu_objet($flux)
     160{
     161        // Si la carte n'est pas complètement fonctionelle, inutile de faire quoi que ce soit : il faut d'abord paramétrer
     162        if (!gmap_est_actif())
     163                return $flux;
     164               
     165        // Récupérer l'objet et tester s'il est geolocalisable
     166        $objet = $flux['args']['type'];
     167        $id_objet = $flux['args']['id_objet'];
     168        if (!$objet || !$id_objet ||
     169                !gmap_est_geolocalisable($objet, $id_objet))
     170                return $flux;
     171               
     172        // Ajouter la zone d'édition des points
     173        include_spip('inc/gmap_saisie_privee');
     174        $flux['data'] .= gmap_saisie_privee($id_objet, $objet, $flux['args']['exec']);
     175       
     176        // Désactivation du modal-box
     177        $bHackModalBox = (($objet === 'article') || ($objet === 'rubrique')) ? true : false;
     178        if ($bHackModalBox && (gmap_lire_config('gmap_objets_geo', 'hack_modalbox', 'oui') === "oui"))
     179                $flux['data'] .= '
     180<script type="text/javascript">
     181//<![CDATA[
     182// CONTOURNEMENT : je n\'arrive pas à faire fonctionner le formulaire en ajax
     183// dans modalbox qui est utilisé par le plugin médiathèque ! L\'évènement
     184// document.ready est envoyé avant que la div ne soit ajoutée au document.
     185// Et même en contournant ça avec un ajaxComplete, la soumission du formulaire
     186// en ajax ne marche pas non plus (je n\'ai pas eu le courage de chercher
     187// pourquoi.
     188// ==> Solution de base, je désactive ModalBox sur les liens "modifier"...
     189jQuery(document).ready(function()
     190{
     191        jQuery("#portfolios").find("a.editbox").removeClass("editbox").removeAttr("target");
     192});
     193//]]>
     194</script>'."\n";
     195       
     196        return $flux;
     197}
    170198
    171199// Insertion des styles et script dans le header
  • _plugins_/gmap/trunk/inc/gmap_config_utils.php

    r55497 r62494  
    2525{
    2626        // Spécificités de l'API
    27         $api = gmap_lire_config('gmap_api', 'api', 'gma3');
     27        $api = gmap_lire_api();
    2828        $capabilities = charger_fonction("capabilities", "mapimpl/".$api."/public", true);
    2929        if (!$capabilities)
     
    7171function gmap_est_actif()
    7272{
    73         $api = gmap_lire_config('gmap_api', 'api', 'gma3');
     73        $api = gmap_lire_api();
    7474        $test_actif = charger_fonction("test_actif", "mapimpl/".$api."/public", true);
    7575        if (!$test_actif)
    7676                return false;
    7777        return $test_actif();
     78}
     79
     80// Raccourci pour lire l'API
     81function gmap_lire_api() {
     82        return gmap_lire_config('gmap_api', 'api', 'gma3');
    7883}
    7984
  • _plugins_/gmap/trunk/inc/gmap_db_utils.php

    r59891 r62494  
    1414include_spip('base/abstract_sql');
    1515 
    16 // Ajout des types de documents KML/KMZ s'il n'y sont pas déjà
    17 function gmap_verif_types_documents()
    18 {
    19     $rowset = sql_select("extension", "spip_types_documents", "extension='kml'");
    20     if (!$row = sql_fetch($rowset))
    21                 sql_insertq("spip_types_documents", array(
    22                                 'titre' => 'Google Earth Placemark',
    23                                 'descriptif' => '',
    24                                 'extension' => 'kml',
    25                                 'mime_type' => 'application/vnd.google-earth.kml+xml',
    26                                 'inclus' => 'non',
    27                                 'upload' => 'oui',
    28                                 'maj' => 'NOW()'));
    29         sql_free($rowset);
    30     $rowset = sql_select("extension", "spip_types_documents", "extension='kmz'");
    31     if (!$row = sql_fetch($rowset))
    32                 sql_insertq("spip_types_documents", array(
    33                                 'titre' => 'Google Earth Placemark',
    34                                 'descriptif' => '',
    35                                 'extension' => 'kmz',
    36                                 'mime_type' => 'application/vnd.google-earth.kmz',
    37                                 'inclus' => 'non',
    38                                 'upload' => 'oui',
    39                                 'maj' => 'NOW()'));
    40         sql_free($rowset);
    41 }
    42 
    4316// Création d'un type de marqueur
    4417function gmap_cree_type($nom, $descriptif, $objet = "", $visible = "oui", $priorite = 2)
    4518{
    46         sql_insertq("spip_gmap_types", array(
     19        sql_insertq("spip_types_geopoints", array(
    4720                "objet" => $objet,
    4821        "nom" => $nom,
     
    5326function gmap_update_type($id, $nom, $descriptif, $objet = "", $visible = "oui", $priorite = 2)
    5427{
    55         sql_updateq("spip_gmap_types", array(
     28        sql_updateq("spip_types_geopoints", array(
    5629                "objet" => $objet,
    5730        "nom" => $nom,
     
    6235}
    6336
    64 // Création des types de pointeur par défaut
    65 function gmap_cree_types_defaut()
    66 {
    67         gmap_cree_type("defaut", _T('gmap:marker_def_defaut'), "", "oui", 1);
    68         gmap_cree_type("centre", _T('gmap:marker_def_centre'), "", "non", 99);
    69         gmap_cree_type("etape", _T('gmap:marker_def_article_etape'), "article", "oui", 4);
    70         gmap_cree_type("prise", _T('gmap:marker_def_document_prise'), "document", "oui", 2);
    71         gmap_cree_type("visee", _T('gmap:marker_def_document_visee'), "document", "oui", 4);
    72 }
    73 
    7437// Destruction d'un type
    7538function gmap_delete_type($id)
    7639{
    77         sql_delete('spip_gmap_types', 'id_type_point=' . intval($id));
     40        sql_delete('spip_types_geopoints', 'id_type_point=' . intval($id));
    7841}
    7942
     
    8346        $types = array();
    8447        /*
    85         SELECT spip_gmap_types.id_type_point AS id, spip_gmap_types.nom AS nom, count(*)
    86          FROM spip_gmap_types JOIN spip_gmap_points ON spip_gmap_types.id_type_point = spip_gmap_points.id_type_point
    87          GROUP BY spip_gmap_types.id_type_point
     48        SELECT spip_types_geopoints.id_type_point AS id, spip_types_geopoints.nom AS nom, count(*)
     49         FROM spip_types_geopoints JOIN spip_geopoints ON spip_types_geopoints.id_type_point = spip_geopoints.id_type_point
     50         GROUP BY spip_types_geopoints.id_type_point
    8851        */
    8952        $rowset = sql_select(
    9053                array(
    91                         "spip_gmap_types.id_type_point AS id",
    92                         "spip_gmap_types.objet AS objet",
    93                         "spip_gmap_types.nom AS nom",
    94                         "spip_gmap_types.descriptif AS descriptif",
    95                         "spip_gmap_types.visible AS visible",
    96                         "spip_gmap_types.priorite AS priorite",
     54                        "spip_types_geopoints.id_type_point AS id",
     55                        "spip_types_geopoints.objet AS objet",
     56                        "spip_types_geopoints.nom AS nom",
     57                        "spip_types_geopoints.descriptif AS descriptif",
     58                        "spip_types_geopoints.visible AS visible",
     59                        "spip_types_geopoints.priorite AS priorite",
    9760                        "count(points.id_point) AS nb_points"),
    98                 "spip_gmap_types".
    99                 " LEFT JOIN spip_gmap_points AS points ON spip_gmap_types.id_type_point = points.id_type_point",
    100                 "", "spip_gmap_types.id_type_point", "spip_gmap_types.id_type_point");
     61                "spip_types_geopoints".
     62                " LEFT JOIN spip_geopoints AS points ON spip_types_geopoints.id_type_point = points.id_type_point",
     63                "", "spip_types_geopoints.id_type_point", "spip_types_geopoints.id_type_point");
    10164        // L'alias sur les noms des tables est nécessaire parce que spip ne peut pas prendre en
    10265        // charge tous les cas dans la transposition des nom de tables : un nom de table précédé
     
    11881               
    11982        // Rechercher avec le nom de l'objet
    120         $rowsetType = sql_select("id_type_point", "spip_gmap_types", "nom = '".$type."' AND objet='".$objet."'");
     83        $rowsetType = sql_select("id_type_point", "spip_types_geopoints", "nom = '".$type."' AND objet='".$objet."'");
    12184        if ($rowType = sql_fetch($rowsetType))
    12285                $id_type = $rowType['id_type_point'];
     
    12689       
    12790        // Recherche sans le nom de l'objet
    128         $rowsetType = sql_select("id_type_point", "spip_gmap_types", "nom = '".$type."' AND objet=''");
     91        $rowsetType = sql_select("id_type_point", "spip_types_geopoints", "nom = '".$type."' AND objet=''");
    12992        if ($rowType = sql_fetch($rowsetType))
    13093                $id_type = $rowType['id_type_point'];
     
    144107{
    145108        $types = array();
    146         $rowset = sql_select("id_type_point AS id, nom", "spip_gmap_types", "objet='".$objet."' OR objet=''");
     109        $rowset = sql_select("id_type_point AS id, nom", "spip_types_geopoints", "objet='".$objet."' OR objet=''");
    147110        while ($row = sql_fetch($rowset))
    148111                $types[] = $row;
     
    159122                       
    160123        // Insérer dans la table
    161         $id = sql_insertq("spip_gmap_points", array(
     124        $id = sql_insertq("spip_geopoints", array(
    162125                "longitude" => $long,
    163126                "latitude" => $lat,
     
    168131        if ($id > 0)
    169132        {
    170                 sql_insertq("spip_gmap_points_liens", array(
     133                sql_insertq("spip_geopoints_liens", array(
    171134                        'id_point' => $id,
    172135                        'id_objet' => $id_objet,
     
    180143/*function gmap_reuse_point($id_point, $objet, $id_objet)
    181144{
    182         $row = sql_fetsel("objet, id_objet", "spip_gmap_points_liens", "id_point=".$id_point);
    183         sql_insertq("spip_gmap_points_liens", array(
     145        $row = sql_fetsel("objet, id_objet", "spip_geopoints_liens", "id_point=".$id_point);
     146        sql_insertq("spip_geopoints_liens", array(
    184147                'id_point' => $id_point,
    185148                'id_objet' => $id_objet,
     
    194157        if (!gmap_check_point_owner($id, $objet, $id_objet))
    195158        {
    196                 spip_log("Tentative de modification d'un point affecté à un autre objet", "gmap");
     159                spip_log("Tentative de modification d'un point affecté à un autre objet", "gmap"._LOG_AVERTISSEMENT);
    197160                return FALSE;
    198161        }
     
    202165       
    203166        // Faire la mise à jour
    204         $success = sql_updateq("spip_gmap_points",
     167        $success = sql_updateq("spip_geopoints",
    205168                array(
    206169                        "longitude" => $long,
     
    219182        if (!gmap_check_point_owner($id, $objet, $id_objet))
    220183        {
    221                 spip_log("Tentative de modification d'un point affecté à un autre objet", "gmap");
     184                spip_log("Tentative de modification d'un point affecté à un autre objet", "gmap"._LOG_AVERTISSEMENT);
    222185                return FALSE;
    223186        }
    224187       
    225188        // Suppression du point et des liens
    226         sql_delete("spip_gmap_labels", "id_point=".$id);
    227         sql_delete("spip_gmap_points_liens", "id_point=".$id);
    228         sql_delete("spip_gmap_points", "id_point=".$id);
     189        sql_delete("spip_geopoints_liens", "id_point=".$id);
     190        sql_delete("spip_geopoints", "id_point=".$id);
    229191       
    230192        return TRUE;
     
    234196function gmap_check_point_owner($id, $objet, $id_objet)
    235197{
    236         $row = sql_fetsel("objet, id_objet", "spip_gmap_points_liens", "id_point=".$id);
     198        $row = sql_fetsel("objet, id_objet", "spip_geopoints_liens", "id_point=".$id);
    237199        if (!$row)
    238200                return false;
     
    306268        $rowset = sql_select(
    307269                array("points.id_point AS id", "points.longitude AS longitude", "points.latitude AS latitude", "points.zoom AS zoom", "types.nom AS type", "types.visible AS visible", "types.priorite AS priorite"),
    308                 "spip_gmap_points_liens AS liens JOIN spip_gmap_points AS points ON liens.id_point=points.id_point JOIN spip_gmap_types AS types ON points.id_type_point = types.id_type_point",
     270                "spip_geopoints_liens AS liens JOIN spip_geopoints AS points ON liens.id_point=points.id_point JOIN spip_types_geopoints AS types ON points.id_type_point = types.id_type_point",
    309271                "liens.objet = '".$objet."' AND liens.id_objet = ".$id_objet);
    310272        while ($row = sql_fetch($rowset))
     
    478440                        $idWhere = "liens.objet='".$objet."' AND liens.id_objet=".$id_objet;
    479441                if (!strlen($joinLiens))
    480                         $joinLiens = " JOIN spip_gmap_points_liens AS liens ON liens.id_point = points.id_point";
     442                        $joinLiens = " JOIN spip_geopoints_liens AS liens ON liens.id_point = points.id_point";
    481443                $clauseWhere .= $idWhere;
    482444        }
     
    487449        {
    488450                if (!strlen($joinType))
    489                         $joinType = " JOIN spip_gmap_types AS types ON types.id_type_point = points.id_type_point";
     451                        $joinType = " JOIN spip_types_geopoints AS types ON types.id_type_point = points.id_type_point";
    490452                if (strlen($clauseWhere))
    491453                        $clauseWhere .= " AND ";
     
    522484                       
    523485                if (!strlen($joinType))
    524                         $joinType = " JOIN spip_gmap_types AS types ON types.id_type_point = points.id_type_point";
     486                        $joinType = " JOIN spip_types_geopoints AS types ON types.id_type_point = points.id_type_point";
    525487                if (strlen($clauseWhere))
    526488                        $clauseWhere .= " AND ";
     
    534496        $rowset = sql_select(
    535497                                "count(*) as count",
    536                                 "spip_gmap_points AS points".$joinLiens.$joinType,
     498                                "spip_geopoints AS points".$joinLiens.$joinType,
    537499                                $clauseWhere);
    538500        if ($row = sql_fetch($rowset))
  • _plugins_/gmap/trunk/inc/gmap_geoloc.php

    r55497 r62494  
    1616include_spip('inc/gmap_config_utils');
    1717include_spip('inc/gmap_db_utils');
     18include_spip('inc/gmap_spip_utils');
    1819include_spip('gmap_filtres');
    1920
     
    2425        if (!isset($profile))
    2526                $profile = 'interface';
    26         $api = gmap_lire_config('gmap_api', 'api', 'gma3');
     27        $api = gmap_lire_api();
    2728        $apiConfigKey = 'gmap_'.$api.'_'.$profile;
    2829       
     
    119120{
    120121        // Fonction spécifique à l'API
    121         $api = gmap_lire_config('gmap_api', 'api', 'gma3');
     122        $api = gmap_lire_api();
    122123        $parametre_carte = charger_fonction("parametre_carte", "mapimpl/".$api."/public");
    123124        if (!$parametre_carte)
     
    345346        //}
    346347}
    347 function gmap_trouve_def_file($contexte, $prefix, $ext, $branches = true, $folder = null, $buffer = null, $default = 'default')
    348 {
     348function gmap_trouve_def_file($contexte, $prefix, $ext, $params)
     349{
     350        /*
     351        Transformation pour le buffer général :
     352        - regrouper $branches, $folder (?), $buffer et $default (?) dans un $params
     353        - ajouter $bufferAmont
     354       
     355        Ce buffer contient des clefs par $prefix-$objet-$ext
     356        */
     357       
    349358        $result = NULL;
    350359        $file = FALSE;
     
    354363        $args = $branches ? array('contexte' => $contexte) : null;
    355364        $id_rubrique = 0;
     365
     366        // Données du contexte
     367        $objet = $contexte['objet'];
     368        $id_objet = $contexte['id_objet'];
     369        $type_point = $contexte['type_point'];
     370       
     371        // Paramètres du process
     372        $branches = (isset($params['branches'])) ? $params['branches'] : true;
     373        $folder = (isset($params['sous-dossier'])) ? $params['sous-dossier'] : null;
     374        $buffer = (isset($params['buffer-aval'])) ? $params['buffer-aval'] : null;
     375        $default = (isset($params['nom-defaut'])) ? $params['nom-defaut'] : 'default';
    356376       
    357377        // Si on cherche un fichier lié à un objet
    358         if ($contexte['objet'] &&  $contexte['id_objet'])
    359         {
     378        if ($objet &&  $id_objet)
     379        {
     380                // Rechercher dans le buffer général
     381               
    360382                // Rechercher d'abord s'il y a un fichier spécifique
    361                 $name = '='.$contexte['objet'].$contexte['id_objet'];
     383                $name = '='.$objet.$id_objet;
    362384                if ($file = _gmap_find_file($prefix, $name, $ext, $fond, $folder, $args))
    363385                {
     
    374396                if ($branches)
    375397                {
    376                         if ($contexte['objet'] === "rubrique")
    377                                 $id_rubrique = $contexte['id_objet'];
     398                        if ($objet === "rubrique")
     399                                $id_rubrique = $id_objet;
    378400                        else
    379                                 $id_rubrique = gmap_get_rubrique($contexte['objet'], $contexte['id_objet']);
     401                                $id_rubrique = gmap_get_rubrique($objet, $id_objet);
    380402                }
    381403        }
     
    397419        // Si on n'a pas d'objet, passer directement au défaut
    398420        $bufferEntry = false;
    399         if (!$contexte['objet'] || !$contexte['id_objet'])
     421        if (!$objet || !$id_objet)
    400422        {
    401423                $fond = $prefix;
     
    408430        {
    409431                // Rechercher dans le buffer (seulement pour les icones)
    410                 if (is_array($buffer) && $contexte['type_point'] && $id_rubrique)
    411                 {
    412                         $bufferEntry = $contexte['objet'].'-'.$contexte['type_point'].'-'.$id_rubrique;
     432                if (is_array($buffer) && $type_point && $id_rubrique)
     433                {
     434                        $bufferEntry = $objet.'-'.$type_point.'-'.$id_rubrique;
    413435                        if ($resultInBuffer = $buffer[$bufferEntry])
    414436                        {
     
    425447                        while ($id_rubrique = gmap_get_rubrique('rubrique', $id_rubrique))
    426448                                $args['ids_rubrique'][] = $id_rubrique;
    427                         // Ca fait beaucoup de requêtes, on pourrait optimiser en cachant cette
    428                         // liste : sur un même carte on va passer ici pour la requête, les définitions
     449                        // Ça fait beaucoup de requêtes, on pourrait optimiser en cachant cette
     450                        // liste : sur une même carte on va passer ici pour la requête, les définitions
    429451                        // de marqueurs et les images des marqueurs...
    430452                }
    431453               
    432454                // Recherche le marqueur selon le type
    433                 $name = $contexte['objet'].'-'.$contexte['type_point'];
     455                $name = $objet.'-'.$type_point;
    434456                if (!$type_point || (strlen($type_point) == 0) ||
    435457                        !($file = _gmap_find_file($prefix, $name, $ext, $fond, $folder, $args)))
    436458                {
    437459                        // sinon, rechercher seulement avec l'objet
    438                         $name = $contexte['objet'];
     460                        $name = $objet;
    439461                        if (!($file = _gmap_find_file($prefix, $name, $ext, $fond, $folder, $args)))
    440462                        {
     
    506528                {
    507529                        // Créer un parseur XML pour décoder la chaîne de requête
    508                         $parseurXML = xml_parser_create();
     530                        $parseurXML = xml_parser_create("UTF-8");
     531                        // ==> Les fichiers sont donc en utf-8 sans BOM.
     532                        // Il semble qu'en PHP >= 5.0 on puisse passer "" pour indiquer de rechercher le format
     533                        // à partir des trois premiers octets, dans ce cas, il faut le BOM.
     534                        // Bref, c'est un peu la merde en fonction des versions de PHP...
    509535                        if ($parseurXML == NULL)
    510536                                return FALSE;
     
    724750        $folder = gmap_theme_folder();
    725751        $branches = false; // fonction utilisée depuis la partie privée uniquement, il n'y a pas de variations
    726         if (!($icon = gmap_trouve_def_file(null, $name, 'gmd', $branches, $folder, null, '')) || !isset($icon['file']))
     752        if (!($icon = gmap_trouve_def_file(null, $name, 'gmd', array(
     753                                                                        'branches'=>$branches,
     754                                                                        'sous-dossier'=>$folder,
     755                                                                        'buffer-aval'=>null,
     756                                                                        'nom-defaut'=>''))) || !isset($icon['file']))
    727757                return 'null';
    728758       
     
    783813{
    784814        $branches = (gmap_lire_config('gmap_optimisations', 'gerer_branches', 'oui') === 'oui') ? true : false;
    785         $fond = gmap_trouve_def_file($contexte, 'gmap-info', 'html', $branches, 'modeles');
     815        $fond = gmap_trouve_def_file($contexte, 'gmap-info', 'html', array(
     816                                                                        'branches'=>$branches,
     817                                                                        'sous-dossier'=>'modeles'));
    786818        if (!$fond)
    787819                return "";
    788         $page = recuperer_fond($fond['spip-path'], $contexte);
     820        $page = gmap_recuperer_fond($fond['spip-path'], $contexte);
    789821        return $page;
    790822}
     
    830862                $GLOBALS['iconsDefs'.$mapId] = array();
    831863        $branches = (gmap_lire_config('gmap_optimisations', 'gerer_branches', 'oui') === 'oui') ? true : false;
    832         if (($icon = gmap_trouve_def_file($contexte, 'gmap-marker', 'gmd', $branches, gmap_theme_folder(), $GLOBALS['iconsAliases'.$mapId])) &&
     864        if (($icon = gmap_trouve_def_file($contexte, 'gmap-marker', 'gmd', array(
     865                                                                        'branches'=>$branches,
     866                                                                        'sous-dossier'=>gmap_theme_folder(),
     867                                                                        'buffer-aval'=>$GLOBALS['iconsAliases'.$mapId]))) &&
    833868                isset($icon['name']))
    834869        {
     
    10141049                        if (isset($params['query']))
    10151050                        {
    1016                                 if ($queryMatch = gmap_trouve_def_file($contexte, 'gmap-'.$format.'-'.$params['query'], 'html', $branches, 'modeles', null, ''))
     1051                                if ($queryMatch = gmap_trouve_def_file($contexte, 'gmap-'.$format.'-'.$params['query'], 'html', array(
     1052                                                                        'branches'=>$branches,
     1053                                                                        'sous-dossier'=>'modeles',
     1054                                                                        'nom-defaut'=>'')))
    10171055                                        $queryFile = $queryMatch['spip-path'];
    1018                                 else if ($queryMatch = gmap_trouve_def_file($contexte, $params['query'], 'html', $branches, 'modeles', null, ''))
     1056                                else if ($queryMatch = gmap_trouve_def_file($contexte, $params['query'], 'html', array(
     1057                                                                        'branches'=>$branches,
     1058                                                                        'sous-dossier'=>'modeles',
     1059                                                                        'nom-defaut'=>'')))
    10191060                                        $queryFile = $queryMatch['spip-path'];
    10201061                                else
    10211062                                        spip_log("Requete ".$params['query']." introuvable", "gmap");
    10221063                        }
    1023                         else if ($queryMatch = gmap_trouve_def_file($contexte, 'gmap-'.$format, 'html', $branches, 'modeles'))
     1064                        else if ($queryMatch = gmap_trouve_def_file($contexte, 'gmap-'.$format, 'html', array(
     1065                                                                        'branches'=>$branches,
     1066                                                                        'sous-dossier'=>'modeles')))
    10241067                                $queryFile = $queryMatch['spip-path'];
    10251068                        else
  • _plugins_/gmap/trunk/lang/gmap_fr.php

    r55497 r62494  
    1010        'address_explic' => "Tapez un nom ou une adresse compl&egrave;te",
    1111        'address_btn_find' => "Rechercher",
    12         'alerte_gmap_inactif' => "GMap n'est actuellement pas en mesure de fonctionner, v&eacute;rifier les param&eacute;trages Choix de l'API cartographique et Param&egrave;tres sp&eacute;cifiques de l'API.",
    13         'alerte_gmap_inactif_ui' => "En cons&eacute;quence, cette page ne peut repr&eacute;senter la carte et certains param&eacute;trages.",
     12        'alerte_gmap_inactif' => "GMap n'est actuellement pas en mesure de fonctionner parce que l'API cartographique n'est pas correctement initialis&eacute;e. Vous devez fournir les information n&eacute;cessaires &agrave; cette API ou en choisir une autre.",
    1413        'api_sub_version_gma2' => "Version secondaire (2.xxx)&nbsp;:",
    1514        'api_sub_version_gma3' => "Version secondaire (3.x)&nbsp;:",
     
    5958        'compacte' => "Compacte",
    6059        'config_titre_bouton' => "GMap",
     60        'config_titre_texte' => "G&eacute;olocalisation et cartographie",
    6161        'configuration' => "Configuration",
    6262        'configuration_import' => "Import des donn&eacute;es gis-escoitar/geomap et gis2",
     
    6969        'configuration_edit_params' => "Param&eacute;trage des outils",
    7070        'configuration_gis' => "Choix de l'API cartographique",
    71         'configuration_gis_explic' => "Le plugin peut se baser sur plusieurs API cartographiques, veuillez en choisir une.",
     71        'configuration_gis_label' => "API cartographique utilis&eacute;e",
     72        'configuration_gis_explic' => "L'API cartographique sert &agrave; afficher les cartes, les points et les bulles d'information, dans la partie priv&eacute;e comme dans la partie publique du site. Le choix n'a aucun impact sur les donn&eacute;es saisies, vous pouvez &agrave; tout moment changer l'API cartographique.",
    7273        'configuration_optimisations' => "Optimisations & performances",
    7374        'configuration_optimisations_explic' => "Si le site contient plus d'un millier de points, le calcul des requ&ecirc;tes sur les points peut &ecirc;tre assez long. Si vous rencontrez des probl&egrave;mes de performances sur le serveur et que vous n'utilisez pas toutes les possibilit&eacute;s de GMap, vous pouvez activer ou d&eacute;sactiver ici certaines fonctionnalit&eacute;s de GMap.",
     
    7576        'configuration_rubriques_liste' => "Restriction &agrave; une zone du site",
    7677        'configuration_rubriques_types' => "Objets g&eacute;olocalisables",
     78        'configuration_rubriques_types_explic' => "L'interface de g&eacute;olocalisation sera accessible sur :",
    7779        'configuration_titre' => "Configuration du plugin GMap",
    7880        'configuration_markers' => "Types de marqueurs",
     
    132134        'explication_info_width_zero' => " (0 pour pas de limite)",
    133135        'explication_liste_rubriques' => "Choisissez les rubriques dans lesquelles le plugin sera disponible.<br />Tous les &eacute;l&eacute;ments SPIP situ&eacute;s sous ces rubriques (sous-rubriques, articles) seront g&eacute;olocalisables",
    134         'explication_restriction' => "Pour les rubriques, les br&egrave;ves, les articles et les documents, vous pouvez limiter l'utilisation des cartes &agrave; certaines zones du site. Aucune restriction n'est applicable pour les auteurs et les mots-clefs.",
     136        'explication_restriction' => "Pour les rubriques, les br&egrave;ves, les articles et les documents, vous pouvez limiter l'utilisation des cartes &agrave; certaines zones du site. Aucune restriction n'est applicable pour les autres objets.",
    135137        'explication_types_cartes_visibles' => "Fonds utilisables&nbsp;:",
    136138        'explication_type_carte_defaut' => "Fond de carte par d&eacute;faut&nbsp;:",
     
    153155        'geocoder_no_results' => "Aucun r&eacute;sultat",
    154156        'geolocalisation_documents' => "G&eacute;olocalisation des documents",
     157        'geopoint' => "Point g&eacute;ographique",
     158        'geopoints' => "Points g&eacute;ographiques",
    155159        'gerer_branches' => "Sp&eacute;cialiser les icones et le contenu des info-bulles selon une branche",
    156160        'gerer_branches_explic' => "GMap cherche les fichiers de d&eacute;finition des icones ou de contenu des info-bulles en testant la pr&eacute;sence de suffixes &rsquo;=id_rubrique&rsquo; ou &rsquo;-id_rubrique&rsquo; (comme SPIP le fait pour les squelettes). Pour une requ&ecirc;te contenant de nombreux points, ce m&eacute;canisme alourdit le calcul du fichier. Si vous ne comptez pas utiliser des icones ou des contenus diff&eacute;rents selon les rubriques, il est inutile de l&rsquo;activer. Pour un grand nombre de points, la d&eacute;sactivation de cette fonctionalit&eacute; peut am&eacute;liorer le temps de calcul sur le serveur.",
     
    168172       
    169173        // I
     174        'icone_creer_geopoint' => "Nouveau point",
    170175        'import_button' => "Importer",
    171176        'import_choix_effacer' => "Supprimer tous les points d&eacute;j&agrave; d&eacute;finis.",
  • _plugins_/gmap/trunk/mapimpl/gma2/public/test_actif.php

    r52218 r62494  
    2121        // Il faut une clef
    2222        $key = gmap_lire_config('gmap_api_gma2', 'key');
    23         return ($key && ($key != "")) ? true : false;
     23        return ($key && strlen($key)) ? true : false;
    2424}
    2525
Note: See TracChangeset for help on using the changeset viewer.