FORUM DE DISCUSSION SUR LE LANGAGE PANORAMIC

Développement d'applications avec le langage Panoramic
 
AccueilAccueil  FAQFAQ  RechercherRechercher  S'enregistrerS'enregistrer  MembresMembres  GroupesGroupes  Connexion  
Derniers sujets
» Demande urgente en maths.
par JL35 Aujourd'hui à 22:26

» Compilateur FBPano
par jean_debord Aujourd'hui à 11:24

» Problème de math
par braveen Aujourd'hui à 10:53

» A propos des attributs de fichier
par papydall Hier à 14:33

» Problème de math
par Marc37 Sam 21 Oct 2017 - 23:04

» I Love You
par papydall Sam 21 Oct 2017 - 19:22

» Un petit "coucou" à tous les Panoramiciens !
par mindstorm Sam 21 Oct 2017 - 17:06

» MARK_ON déclenche un événement ON_CLICK à la place de ...
par Jean Claude Mer 18 Oct 2017 - 18:08

» mise a jour calculatrice
par joeeee2017 Mer 18 Oct 2017 - 15:57

» [solved] 3D_LINE How to ?
par Jicehel Mer 18 Oct 2017 - 11:01

» Convertisseur de base 10 de 2 à 36
par gigi75 Mar 17 Oct 2017 - 18:49

» calculatrice avec touches movibles
par joeeee2017 Dim 15 Oct 2017 - 1:11

» CORTANA
par gigi75 Sam 14 Oct 2017 - 16:32

» Calculatrice
par Jean Claude Sam 14 Oct 2017 - 12:30

» KGF_dll - nouvelles versions
par Klaus Mar 10 Oct 2017 - 18:49

Navigation
 Portail
 Index
 Membres
 Profil
 FAQ
 Rechercher
Rechercher
 
 

Résultats par :
 
Rechercher Recherche avancée
Octobre 2017
LunMarMerJeuVenSamDim
      1
2345678
9101112131415
16171819202122
23242526272829
3031     
CalendrierCalendrier

Partagez | 
 

 Nouvelle version de mon pseudo-objet GLIST

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
Klaus

avatar

Nombre de messages : 10075
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Nouvelle version de mon pseudo-objet GLIST   Mar 25 Sep 2012 - 12:38

J'ai adapté mon pseudo-objet GLIST à la version V0.24i2 de Panoramic, en utilisant les procédures comme interface utilisateur. Cela devient beaucoup plus facile d'utilisation et beaucoup plus lisible. Les procédures avec passage de paramètres, c'est vraiment un grand progrès !

Pour le moment, je publie de module GLIST_SUB.bas, et dans le post suivant, mon programme de gestion de contacts qui utilise 3 listes synchronisées.

GLIST_SUB.bas:
Code:
' GLIST_SUB.bas

' Ce fichier implémente les GLIST sous forme de procédures.
' Il n'y a rien d'autre à insérer dans le programme.

' ############# ici, le #INCLUDE GLIST.bas contenant tout ce qui suit #########
' =============================================================================
' Gestion de pseudo-listes synchronisables avec attributs grahiques (GLIST)
' Auteur: Klaus
' Idée originale: Nardo26
' Développé à l'aides des critiques constructives et précieuses de Cosmos70 et Nardo26

' =============== initialisation du système GLIST
' sub GLIST_initialize()
' =============== création des objets
' sub GLIST_create(n%,aff%,W%,T%,L%)
' =============== création des attributs
' sub GLIST_attributs(n%,att$)
' =============== chargement d'un fichier
' sub GLIST_file_load(fil$)
' =============== sauvegarde d'un fichier
' sub GLIST_file_save(txt$)
' =============== choix de la méthode de révélation
' sub GLIST_revelation(R%)
' =============== effacement de toute la liste
' sub GLIST_clear()
' =============== ajouter un enregistrement
' sub GLIST_item_add(txt$)
' =============== supprimer un enregistrement
' sub GLIST_item_delete(n%)
' =============== insérer un enregistrement
' sub GLIST_item_insert(n%,txt$)
' =============== mise à jour d'un enregistrement
' sub GLIST_item_modify(n%,txt$)
' =============== retourner le numéro d'enregistrement sélectionné
' sub GLIST_selected%()
' =============== retourner le nombre d'enregistrements au total
' sub GLIST_total%()
' =============== lire un enregistrement
' sub GLIST_item_read$(n%)
' =============== libérer la sélection d'un enregistrement
' sub GLIST_item_free()
' =============== cibler une autre GLIST
' sub GLIST_target_is(T%)
' =============== selectionner un enregistrement
' sub GLIST_item_select(n%)
' =============== afficher à partir d'un enregistrement
' sub GLIST_item_display(n%)
' =============== synchronisezr avec une autre GLIST
' sub GLIST_synchronize_on(n%)
' =============== désynchroniser avec une autre GLIST
' sub GLIST_synchronize_off(n%)
' =============== configurer le mode de fonctionnement
' sub GLIST_mode(md$)
' =============== chercher un enregistrement contenant une chaîne
' sub GLIST_item_search%(dir%,start%,crit$)
' =============== déplacer la ligne choisie vers le haut ou vers le bas
' sub GLIST_item_move(dir%)
' =============== retourner le numéro de la première ligne d'affichage
' sub GLIST_first_line%()

' =============== dipatching des fonctions ====================================
top 0,message_error_OK("GLIST: on ne peut pas executer ce module directement !")
terminate

' =============== initialisation du système GLIST ==============================================
sub GLIST_initialize()
  if variable("GLIST_initialize_result")=0 then dim GLIST_initialize_result
  if label("GLIST_attributs")=0
    label GLIST_synchronize
    label GLIST_create_err1, GLIST_change, GLIST_changeb, GLIST_click_liste
    label GLIST_fin2, GLIST_print_line, GLIST_select_on
    label GLIST_select_off, GLIST_attrib_on
    label GLIST_attrib_off, GLIST_do_synchro
    label GLIST_SB_Evenement, GLIST_change_bis
    label GLIST_init_exit, GLIST_create_exit, GLIST_ATTRIB_exit, GLIST_revelation_exit
    label GLIST_file_load_exit, GLIST_target_exit, GLIST_synchronize_on_exit
    label GLIST_item_add_exit, GLIST_item_delete_exit, GLIST_item_insert_exit
    label GLIST_item_modify_exit, GLIST_item_read_exit, GLIST_item_select_exit
    label GLIST_item_display_exit, GLIST_synchronize_off_exit, GLIST_item_search_exit
    label GLIST_item_move_exit, GLIST_first_line_exit

    dim GLIST_numero_objet%, GLIST_lignes_affichage%(20), GLIST_largeur_affichage%(20)
    dim GLIST_top_affichage%(20), GLIST_left_affichage%(20), GLIST_hauteur_affichage%(20)
    dim GLIST_ligne_selection%(20), GLIST_mode_selection%(20), GLIST_ligne_choisie%(20)
    dim GLIST_nombre_dans_liste%(20), GLIST_n_synchro%(20), GLIST_synchros%(20,20)
    dim GLIST_font_attributs%(200,3)    : ' 200=10*20 (,0)=flag "gras"  (,1)=R (,2)=G, (,3)=B
    dim GLIST_font_attributs_n%(20)
    dim GLIST_i%, GLIST_n%, GLIST_s$, GLIST_v%, GLIST_v$, GLIST_j%, GLIST_nr%(20), GLIST_code%
    dim GLIST_k%, GLIST_syn%, GLIST_debug%, GLIST_synchro_temp%, GLIST_synchro_s$
    dim GLIST_xx%, GLIST_yy%, GLIST_x1%, GLIST_y1%, GLIST_max%, GLIST_synchro_master%
    dim GLIST_synchro_slave%, GLIST_error_mode%, GLIST_err%, GLIST_synchro_choisie%
    dim GLIST_sens%, GLIST_org%
    dim GLIST_n_listes%, GLIST_liste_listes%(20), GLIST_index%, GLIST_scroll%(20)
    dim GLIST_SB_Evenement%,GLIST_SB_mouse_left%,GLIST_SB_mouse_right%
    dim GLIST_SB_start_x%, GLIST_SB_start_y%, GLIST_SB_x%, GLIST_SB_y%
    dim GLIST_SB_position%, GLIST_aff_ligne%, GLIST_SB_delta%
    dim GLIST_SB_max_y%(20), GLIST_SB_min_y%(20), GLIST_SB_buttonsize%, GLIST_SB_numero_objet%
    dim GLIST_SB_mouse_y%, GLIST_params$
    dim GLIST_erreur% : GLIST_erreur% = 0 - 1

    GLIST_n_listes% = 0 : GLIST_index% = 0 : GLIST_debug% = 0 : GLIST_error_mode% = 1
    GLIST_synchro_choisie% = 0
    GLIST_initialize_result = 0
    goto GLIST_init_exit
  end_if
  GLIST_initialize_result = GLIST_erreur%
  GLIST_params$ = "GLIST: Initialize - problème avec numéro d'objet " + str$(GLIST_n%)
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
GLIST_init_exit:
end_sub

' =============== création des objets ==========================================================
sub GLIST_create(n%,aff%,W%,T%,L%)
  if variable("GLIST_create_result")=0 then dim GLIST_create_result
  if GLIST_n_listes%=20
    GLIST_params$ = "GLIST: trop d'objets GLIST"
    if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
    GLIST_create_result = 1
    goto GLIST_create_exit
  end_if
  GLIST_n% = n%
  on_error_goto GLIST_create_err1
  dlist GLIST_n%
  dlist GLIST_n% + 1
  dlist GLIST_n% + 2
  off_error_goto
  GLIST_create_result = 0
  GLIST_numero_objet% = GLIST_n%
  delete GLIST_numero_objet% + 2
  delete GLIST_numero_objet% + 1
  picture GLIST_numero_objet% + 1
  scroll_bar GLIST_numero_objet% + 2
    vertical GLIST_numero_objet% + 2
    on_change GLIST_numero_objet%+2,GLIST_change
  print_target_is GLIST_numero_objet%+1
  2d_target_is GLIST_numero_objet%+1
  on_click GLIST_numero_objet%+1,GLIST_click_liste
  GLIST_n_listes% = GLIST_n_listes% + 1
  GLIST_index% = GLIST_n_listes%
  GLIST_liste_listes%(GLIST_n_listes%) = GLIST_numero_objet%
  GLIST_scroll%(GLIST_n_listes%) = 1
  GLIST_n_synchro%(GLIST_n_listes%) = 0
  GLIST_SB_delta% = GLIST_lignes_affichage%(GLIST_index%)      : ' pour déplacement rapide
  GLIST_n% = aff%
  if GLIST_n%>0 then GLIST_lignes_affichage%(GLIST_index%) = GLIST_n%
  GLIST_hauteur_affichage%(GLIST_index%) = GLIST_lignes_affichage%(GLIST_index%)*14  : ' hauteur de l'affichage du picture et de la scroll_bar
  height GLIST_numero_objet%+1,GLIST_hauteur_affichage%(GLIST_index%)
  height GLIST_numero_objet%+2,GLIST_hauteur_affichage%(GLIST_index%)
  GLIST_n% = L%
  if GLIST_n%>0 then GLIST_left_affichage%(GLIST_index%) = GLIST_n%
  GLIST_n% = T%
  if GLIST_n%>0 then GLIST_top_affichage%(GLIST_index%) = GLIST_n%
  top GLIST_numero_objet%+1,GLIST_top_affichage%(GLIST_index%)
  top GLIST_numero_objet%+2,GLIST_top_affichage%(GLIST_index%)
  GLIST_n% = W%
  if GLIST_n%>0 then GLIST_largeur_affichage%(GLIST_index%) = GLIST_n%
  width GLIST_numero_objet%+1,GLIST_largeur_affichage%(GLIST_index%)
  left GLIST_numero_objet%+1,GLIST_left_affichage%(GLIST_index%)
  left GLIST_numero_objet%+2,GLIST_left_affichage%(GLIST_index%) + GLIST_largeur_affichage%(GLIST_index%) + 4
  GLIST_SB_buttonsize% = 18          : ' taille des boutons carrés
  GLIST_SB_position% = 1              : ' position initiale du curseur
  GLIST_SB_max_y%(GLIST_index%) = GLIST_hauteur_affichage%(GLIST_index%)-3*GLIST_SB_buttonsize%    : ' hauteur - bouton up - bouton down - curseur
  GLIST_SB_min_y%(GLIST_index%) = GLIST_SB_buttonsize%                      : ' 0 + bouton up
  GLIST_create_result = 0
  goto GLIST_create_exit

GLIST_create_err1:
  off_error_goto
  GLIST_create_result = GLIST_erreur%
  GLIST_params$ = "GLIST: Create - problème avec numéro d'objet " + str$(GLIST_numero_objet%)
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
GLIST_CREATE_exit:
end_sub

' =============== création des attributs ==========================================================
sub GLIST_attributs(n%,att$)
  if variable("GLIST_attributs_result")=0 then dim GLIST_attributs_result
  GLIST_attributs_result = 0
  GLIST_n% = n%
  GLIST_s$ = att$ + ","
  if GLIST_n%>GLIST_font_attributs_n%(GLIST_index%) then GLIST_font_attributs_n%(GLIST_index%) = GLIST_n%
  if left$(GLIST_s$,1)="G"
    GLIST_font_attributs%((GLIST_index%-1)*10+GLIST_n%,0) = 1
    GLIST_s$ = right$(GLIST_s$,len(GLIST_s$)-1)
  else
    GLIST_font_attributs%((GLIST_index%-1)*10+GLIST_n%,0) = 0
  end_if
  for GLIST_j%=1 to 3
    GLIST_i% = instr(GLIST_s$,",")
    if GLIST_i%>0
      GLIST_v$ = left$(GLIST_s$,GLIST_i%-1)
      GLIST_s$ = right$(GLIST_s$,len(GLIST_s$)-GLIST_i%)
      if numeric(GLIST_v$)=1
        GLIST_v% = val(GLIST_v$)
        if (GLIST_v%<0) or (GLIST_v%>255)
          GLIST_params$ = "GLIST: parametres Attributs invalides"
          if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
          GLIST_attributs_result = GLIST_erreur%
          goto GLIST_attrib_exit
        end_if
        GLIST_font_attributs%((GLIST_index%-1)*10+GLIST_n%,GLIST_j%) = GLIST_v%
      end_if
    end_if
  next GLIST_j%
  GLIST_attributs_result = 0
GLIST_attrib_exit:
end_sub

' =============== chargement d'un fichier =================================================
sub GLIST_file_load(fil$)
  if variable("GLIST_file_load_result")=0 then dim GLIST_file_load_result
  GLIST_s$ = fil$
  if file_exists(GLIST_s$)=0
    GLIST_params$ = "GLIST: fichier Load introuvable: "+GLIST_s$
    if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
    GLIST_file_load_result = GLIST_erreur%
    goto GLIST_file_load_exit
  end_if
  GLIST_file_load_result = 0
  clear GLIST_numero_objet%
  file_load GLIST_numero_objet%,GLIST_s$
  GLIST_nombre_dans_liste%(GLIST_index%) = count(GLIST_numero_objet%)
  GLIST_n% = GLIST_nombre_dans_liste%(GLIST_index%) - GLIST_lignes_affichage%(GLIST_index%)+1
  if GLIST_nombre_dans_liste%(GLIST_index%)<GLIST_lignes_affichage%(GLIST_index%) then GLIST_n% = 1
'  max GLIST_numero_objet%+2,GLIST_n%
  GLIST_nr%(GLIST_index%) = 1
  gosub GLIST_changeb
GLIST_file_load_exit:
end_sub

' =============== sauvegarde d'un fichier =================================================
sub GLIST_file_save(txt$)
  file_save GLIST_numero_objet%,txt$
end_sub

' =============== choix de la méthode de révélation ==============================================
sub GLIST_revelation(R%)
  if variable("GLIST_revelation_result")=0 then dim GLIST_revelation_result
  GLIST_v% = R%
  if (GLIST_v%>=0) and GLIST_v%<=4
    GLIST_mode_selection%(GLIST_index%) = R%
    GLIST_revelation_result  = 0
    goto GLIST_revelation_exit
  end_if
GLIST_params$ = "GLIST: parametres Revelation invalides"
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
  GLIST_revelation_result = GLIST_erreur%
  GLIST_revelation_exit:
end_sub

' =============== effacement de toute la liste =====================================================
sub GLIST_clear()
  clear GLIST_numero_objet%
  2d_clear
  GLIST_scroll%(GLIST_index%) = 1
  GLIST_nr%(GLIST_index%) = 1
  off_change GLIST_numero_objet%+2
  position GLIST_numero_objet%+2,1
  on_change GLIST_numero_objet%+2,GLIST_change
  max GLIST_numero_objet%+2,1
  GLIST_nombre_dans_liste%(GLIST_index%) = 0
  GLIST_ligne_selection%(GLIST_index%) = 0
end_sub

' =============== ajouter un enregistrement =====================================================
sub GLIST_item_add(txt$)
  if variable("GLIST_item_add_result")=0 then dim GLIST_item_add_result
  GLIST_s$ = txt$
  GLIST_synchro_s$ = GLIST_s$                        : ' sauvegarder car modifié dans GLIST_changeb
  item_add GLIST_numero_objet%,GLIST_s$
  GLIST_nombre_dans_liste%(GLIST_index%) = count(GLIST_numero_objet%)
  GLIST_n% = GLIST_nombre_dans_liste%(GLIST_index%) - GLIST_lignes_affichage%(GLIST_index%)+1
  if GLIST_nombre_dans_liste%(GLIST_index%)<GLIST_lignes_affichage%(GLIST_index%) then GLIST_n% = 1
  max GLIST_numero_objet%+2,GLIST_n%
  if GLIST_nr%(GLIST_index%)=0 then GLIST_nr%(GLIST_index%) = 1
  if (GLIST_nombre_dans_liste%(GLIST_index%)-GLIST_nr%(GLIST_index%))<GLIST_lignes_affichage%(GLIST_index%) then gosub GLIST_changeb
  if GLIST_n_synchro%(GLIST_index%)>0                    : ' la liste a des esclaves ?
    GLIST_synchro_master% = GLIST_index%              : ' se rappeler le maître
    GLIST_synchro_temp% = GLIST_index%
    for GLIST_k%=1 to GLIST_n_synchro%(GLIST_synchro_temp%)
        GLIST_numero_objet% = GLIST_synchros%(GLIST_synchro_temp%,GLIST_k%)    : ' simuler un target_is sur l'esclave
        for GLIST_j%=1 to GLIST_n_listes%
            if GLIST_liste_listes%(GLIST_j%)=GLIST_numero_objet%
                GLIST_index% = GLIST_j%
                exit_for
            end_if
        next GLIST_j%
        2d_target_is GLIST_numero_objet% + 1
        print_target_is GLIST_numero_objet% + 1
        item_add GLIST_numero_objet%,"* "+GLIST_synchro_s$
        GLIST_nombre_dans_liste%(GLIST_index%) = count(GLIST_numero_objet%)
        GLIST_n% = GLIST_nombre_dans_liste%(GLIST_index%) - GLIST_lignes_affichage%(GLIST_index%)+1
        if GLIST_nombre_dans_liste%(GLIST_index%)<GLIST_lignes_affichage%(GLIST_index%) then GLIST_n% = 1
        max GLIST_numero_objet%+2,GLIST_n%
        if (GLIST_nombre_dans_liste%(GLIST_index%)-GLIST_nr%(GLIST_index%))<GLIST_lignes_affichage%(GLIST_index%) then gosub GLIST_changeb
    next GLIST_k%
    GLIST_index% = GLIST_synchro_master%              : ' récupérer le maître
    GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)    : ' simuler un target_is sur le maître
    2d_target_is GLIST_numero_objet% + 1
    print_target_is GLIST_numero_objet% + 1
  end_if
GLIST_item_add_exit:
GLIST_item_add_result = 0
end_sub

' =============== supprimer un enregistrement =====================================================
sub GLIST_item_delete(n%)
  if variable("GLIST_item_delete_result")=0 then dim GLIST_item_delete_result
' supprimer la ligne du maître
    GLIST_v% = n%
    if (GLIST_v%>0) and (GLIST_v%<=count(GLIST_numero_objet%))
        item_delete GLIST_numero_objet%,GLIST_v%
        GLIST_nombre_dans_liste%(GLIST_index%) = count(GLIST_numero_objet%)
        if GLIST_nombre_dans_liste%(GLIST_index%)=0              : ' liste maître vide ?
            2d_clear
            GLIST_ligne_choisie%(GLIST_index%) = 0
            max GLIST_numero_objet%+2,1
            if GLIST_n_synchro%(GLIST_index%)>0                    : ' la liste a des esclaves ?
                GLIST_synchro_master% = GLIST_index%              : ' se rappeler le maître
                GLIST_synchro_temp% = GLIST_index%
                for GLIST_k%=1 to GLIST_n_synchro%(GLIST_synchro_temp%)
                    GLIST_numero_objet% = GLIST_synchros%(GLIST_synchro_temp%,GLIST_k%)    : ' simuler un target_is sur l'esclave
                    for GLIST_j%=1 to GLIST_n_listes%
                        if GLIST_liste_listes%(GLIST_j%)=GLIST_numero_objet%
                            GLIST_index% = GLIST_j%
                            exit_for
                        end_if
                    next GLIST_j%
                    2d_target_is GLIST_numero_objet% + 1
                    print_target_is GLIST_numero_objet% + 1
                    clear GLIST_numero_objet%          : ' il ne restait plus qu'un seul enregistrement
                    2d_clear
                    GLIST_nombre_dans_liste%(GLIST_index%) = 0
                    GLIST_ligne_choisie%(GLIST_index%) = 0
                    max GLIST_numero_objet%+2,1
                    GLIST_index% = GLIST_synchro_master%              : ' récupérer le maître
                    GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)    : ' simuler un target_is sur le maître
                    2d_target_is GLIST_numero_objet% + 1
                    print_target_is GLIST_numero_objet% + 1
                next GLIST_k%
            end_if
        end_if
' réactiver la ligne suivante si la suppression de la ligne sélectionnée doit annuler la sélection !
'        if GLIST_v%=GLIST_ligne_choisie%(GLIST_index%) then GLIST_ligne_choisie%(GLIST_index%) = 0
        if GLIST_v%<GLIST_ligne_choisie%(GLIST_index%) then GLIST_ligne_choisie%(GLIST_index%) = GLIST_ligne_choisie%(GLIST_index%) - 1
        if GLIST_v%<GLIST_nr%(GLIST_index%)+GLIST_lignes_affichage%(GLIST_index%)
            if GLIST_v%>=GLIST_nr%(GLIST_index%)
                if GLIST_nr%(GLIST_index%)>0
                    gosub GLIST_changeb
                else
                    2d_clear
                end_if
            end_if
        end_if
        GLIST_n% = GLIST_nombre_dans_liste%(GLIST_index%) - GLIST_lignes_affichage%(GLIST_index%)+1
        if GLIST_nombre_dans_liste%(GLIST_index%)<GLIST_lignes_affichage%(GLIST_index%) then GLIST_n% = 1
        max GLIST_numero_objet%+2,GLIST_n%
' supprimer la ligne de l'esclave
        if GLIST_n_synchro%(GLIST_index%)>0                    : ' la liste a des esclaves ?
            GLIST_synchro_master% = GLIST_index%              : ' se rappeler le maître
            GLIST_synchro_temp% = GLIST_index%
            for GLIST_k%=1 to GLIST_n_synchro%(GLIST_synchro_temp%)
                GLIST_numero_objet% = GLIST_synchros%(GLIST_synchro_temp%,GLIST_k%)    : ' simuler un target_is sur l'esclave
                for GLIST_j%=1 to GLIST_n_listes%
                    if GLIST_liste_listes%(GLIST_j%)=GLIST_numero_objet%
                        GLIST_index% = GLIST_j%
                        exit_for
                    end_if
                next GLIST_j%
                2d_target_is GLIST_numero_objet% + 1
                print_target_is GLIST_numero_objet% + 1
                item_delete GLIST_numero_objet%,GLIST_v%
                GLIST_nombre_dans_liste%(GLIST_index%) = count(GLIST_numero_objet%)
' réactiver la ligne suivante si la suppression de la ligne sélectionnée doit annuler la sélection !
'                if GLIST_v%=GLIST_ligne_choisie%(GLIST_index%) then GLIST_ligne_choisie%(GLIST_index%) = 0
                if GLIST_v%<GLIST_ligne_choisie%(GLIST_index%) then GLIST_ligne_choisie%(GLIST_index%) = GLIST_ligne_choisie%(GLIST_index%) - 1
                if GLIST_v%<GLIST_nr%(GLIST_index%)+GLIST_lignes_affichage%(GLIST_index%)
                    if GLIST_v%>=GLIST_nr%(GLIST_index%)
                        if GLIST_nr%(GLIST_index%)>0
                            gosub GLIST_changeb
                        else
                            2d_clear
                        end_if
                    end_if
                end_if
                GLIST_n% = GLIST_nombre_dans_liste%(GLIST_index%) - GLIST_lignes_affichage%(GLIST_index%)+1
                if GLIST_nombre_dans_liste%(GLIST_index%)<GLIST_lignes_affichage%(GLIST_index%) then GLIST_n% = 1
                max GLIST_numero_objet%+2,GLIST_n%
            next GLIST_k%
        end_if
        GLIST_index% = GLIST_synchro_master%              : ' récupérer le maître
        GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)    : ' simuler un target_is sur le maître
        2d_target_is GLIST_numero_objet% + 1
        print_target_is GLIST_numero_objet% + 1
        GLIST_item_delete_result = 0
        goto GLIST_item_delete_exit
    end_if
    GLIST_item_delete_result = GLIST_erreur%
    GLIST_params$ = "GLIST: parametres Item_delete invalides"
    if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
GLIST_item_delete_exit:
end_sub

' =============== insérer un enregistrement =====================================================
sub GLIST_item_insert(n%,txt$)
  if variable("GLIST_item_insert_result")=0 then dim GLIST_item_insert_result
  GLIST_v% = n%
  if GLIST_v%<1 or GLIST_v%>GLIST_nombre_dans_liste%(GLIST_index%)
    GLIST_params$ = "GLIST: parametres Item_insert invalides"
    if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
    GLIST_item_inseert_result = GLIST_erreur%
    goto GLIST_item_insert_exit
  end_if
  GLIST_s$ = txt$
  GLIST_synchro_s$ = GLIST_s$                        : ' sauvegarder car modifié dans GLIST_changeb
  item_insert GLIST_numero_objet%,GLIST_v%,GLIST_s$
  GLIST_nombre_dans_liste%(GLIST_index%) = GLIST_nombre_dans_liste%(GLIST_index%) + 1
  if GLIST_v%<=GLIST_ligne_choisie%(GLIST_index%) then GLIST_ligne_choisie%(GLIST_index%) = GLIST_ligne_choisie%(GLIST_index%) + 1
  GLIST_n% = GLIST_nombre_dans_liste%(GLIST_index%) - GLIST_lignes_affichage%(GLIST_index%)+1
  if GLIST_nombre_dans_liste%(GLIST_index%)<GLIST_lignes_affichage%(GLIST_index%) then GLIST_n% = 1
  max GLIST_numero_objet%+2,GLIST_n%
  if GLIST_v%<GLIST_nr%(GLIST_index%)+GLIST_lignes_affichage%(GLIST_index%) then gosub GLIST_changeb
  if GLIST_n_synchro%(GLIST_index%)>0                    : ' la liste a des esclaves ?
    GLIST_synchro_master% = GLIST_index%              : ' se rappeler le maître
    GLIST_synchro_temp% = GLIST_index%
    for GLIST_k%=1 to GLIST_n_synchro%(GLIST_synchro_temp%)
        GLIST_numero_objet% = GLIST_synchros%(GLIST_synchro_temp%,GLIST_k%)    : ' simuler un target_is sur l'esclave
        for GLIST_j%=1 to GLIST_n_listes%
            if GLIST_liste_listes%(GLIST_j%)=GLIST_numero_objet%
                GLIST_index% = GLIST_j%
                exit_for
            end_if
        next GLIST_j%
        2d_target_is GLIST_numero_objet% + 1
        print_target_is GLIST_numero_objet% + 1
        item_insert GLIST_numero_objet%,GLIST_v%,"* "+GLIST_synchro_s$
        GLIST_nombre_dans_liste%(GLIST_index%) = count(GLIST_numero_objet%)
        if GLIST_v%<=GLIST_ligne_choisie%(GLIST_index%) then GLIST_ligne_choisie%(GLIST_index%) = GLIST_ligne_choisie%(GLIST_index%) + 1
        GLIST_n% = GLIST_nombre_dans_liste%(GLIST_index%) - GLIST_lignes_affichage%(GLIST_index%)+1
        if GLIST_nombre_dans_liste%(GLIST_index%)<GLIST_lignes_affichage%(GLIST_index%) then GLIST_n% = 1
        max GLIST_numero_objet%+2,GLIST_n%
        if GLIST_v%<GLIST_nr%(GLIST_index%)+GLIST_lignes_affichage%(GLIST_index%) then gosub GLIST_changeb
    next GLIST_k%
    GLIST_index% = GLIST_synchro_master%              : ' récupérer le maître
    GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)    : ' simuler un target_is sur le maître
    2d_target_is GLIST_numero_objet% + 1
    print_target_is GLIST_numero_objet% + 1
  end_if
  GLIST_item_insert_result = 0
GLIST_item_insert_exit:
end_sub

' =============== mise à jour d'un enregistrement =====================================================
sub GLIST_item_modify(n%,txt$)
  if variable("GLIST_item_modify_result")=0 then dim GLIST_item_modify_result
  GLIST_v% = n%
  if GLIST_v%<1 or GLIST_v%>GLIST_nombre_dans_liste%(GLIST_index%)
    GLIST_params$ = "GLIST: parametres Item_write invalides"
    if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
    GLIST_item_modify_result = GLIST_erreur%
    goto GLIST_item_modify_exit
  end_if
  GLIST_s$ = txt$
  item_delete GLIST_numero_objet%, GLIST_v%                      : ' supprimer, puis
  item_insert GLIST_numero_objet%,GLIST_v%,GLIST_s$              : ' insérer à nouveau !
  if GLIST_v%<GLIST_nr%(GLIST_index%)+GLIST_lignes_affichage%(GLIST_index%) then gosub GLIST_changeb
  GLIST_item_modify_result = 0
GLIST_item_modify_exit:
end_sub

' =============== retourner le numéro d'enregistrement sélectionné =============
sub GLIST_selected%()
  if variable("GLIST_selected_result%")=0 then dim GLIST_selected_result%
  GLIST_selected_result% = GLIST_ligne_choisie%(GLIST_index%)
end_sub

' =============== retourner le nombre d'enregistrements au total ===============
sub GLIST_total%()
  if variable("GLIST_total_result%")=0 then dim GLIST_total_result%
  GLIST_total_result% = GLIST_nombre_dans_liste%(GLIST_index%)
end_sub

' =============== lire un enregistrement =======================================
sub GLIST_item_read$(n%)
  if variable("GLIST_item_read_result$")=0 then dim GLIST_item_read_result$
  if variable("GLIST_item_read_result")=0 then dim GLIST_item_read_result
  GLIST_v% = n%
  if (GLIST_v%>0) and (GLIST_v%<=count(GLIST_numero_objet%))
    GLIST_item_read_result$ = item_read$(GLIST_numero_objet%,GLIST_v%)
    GLIST_item_read_result = 0
    goto GLIST_item_read_exit
  end_if
  GLIST_params$ = "GLIST: parametres Item_read invalides"
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
  GLIST_item_read_result = GLIST_erreur%
GLIST_item_read_exit:
end_sub

' =============== libérer la sélection d'un enregistrement =====================
sub GLIST_item_free()
  if variable("GLIST_item_free_result")=0 then dim GLIST_item_free_result
    GLIST_ligne_choisie%(GLIST_index%) = 0
    gosub GLIST_changeb
' ici synchroniser s'il le faut
    if GLIST_n_synchro%(GLIST_index%)>0                    : ' la liste a des esclaves ?
        GLIST_synchro_master% = GLIST_index%              : ' se rappeler le maître
        GLIST_synchro_temp% = GLIST_index%
        for GLIST_k%=1 to GLIST_n_synchro%(GLIST_synchro_temp%)
            GLIST_numero_objet% = GLIST_synchros%(GLIST_synchro_temp%,GLIST_k%)    : ' simuler un target_is sur l'esclave
            for GLIST_j%=1 to GLIST_n_listes%
                if GLIST_liste_listes%(GLIST_j%)=GLIST_numero_objet%
                    GLIST_index% = GLIST_j%
                    exit_for
                end_if
            next GLIST_j%
            2d_target_is GLIST_numero_objet% + 1
            print_target_is GLIST_numero_objet% + 1
            GLIST_ligne_choisie%(GLIST_index%) = 0
            gosub GLIST_changeb
            GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)    : ' simuler un target_is sur le maître
            2d_target_is GLIST_numero_objet% + 1
            print_target_is GLIST_numero_objet% + 1
        next GLIST_k%
    end_if
    GLIST_item_free_result = 0
end_sub

' =============== cibler une autre GLIST =======================================
sub GLIST_target_is(T%)
  if variable("GLIST_target_is_result")=0 then dim GLIST_target_is_result
  GLIST_v% = T%
  for GLIST_i%=1 to GLIST_n_listes%
    if GLIST_liste_listes%(GLIST_i%)=GLIST_v%
      GLIST_index% = GLIST_i%
      GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)
      2d_target_is GLIST_numero_objet% + 1
      print_target_is GLIST_numero_objet% + 1
      GLIST_target_is_result = 0
      goto GLIST_target_exit
    end_if
  next GLIST_i%
  GLIST_params$ = "GLIST: parametres target_is invalides"
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
  GLIST_target_is_result = GLIST_erreur%
GLIST_target_exit:
end_sub

' =============== selectionner un enregistrement ==============================
sub GLIST_item_select(n%)
  if variable("GLIST_item_select_result")=0 then dim GLIST_item_select_result
  GLIST_v% = n%
  if (GLIST_v%>0) and (GLIST_v%<=count(GLIST_numero_objet%))
    GLIST_ligne_choisie%(GLIST_index%) = GLIST_v%
'    if GLIST_v%>GLIST_nr%(GLIST_index%) then gosub GLIST_changeb
    gosub GLIST_changeb
    GLIST_synchro_choisie% = GLIST_ligne_choisie%(GLIST_index%)
    gosub GLIST_do_synchro
    GLIST_item_select_result = 0
    goto GLIST_item_select_exit
  end_if
  GLIST_params$ = "GLIST: parametres Item_select invalides"
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
  GLISTi_tem_select_result = GLIST_erreur%
GLIST_item_select_exit:
end_sub

' =============== afficher à partir d'un enregistrement ====================
sub GLIST_item_display(n%)
  if variable("GLIST_item_display_result")=0 then dim GLIST_item_display_result
  GLIST_v% = n%
  if (GLIST_v%>0) and (GLIST_v%<=count(GLIST_numero_objet%))
    GLIST_nr%(GLIST_index%) = GLIST_v%
    off_change GLIST_numero_objet%+2
    position GLIST_numero_objet%+2,GLIST_v%
    on_change GLIST_numero_objet%+2,GLIST_change
    gosub GLIST_changeb
    gosub GLIST_do_synchro
    GLIST_item_display_result = 0
    goto GLIST_item_display_exit
  end_if
  GLIST_item_display_result = GLIST_erreur%
  GLIST_params$ = "GLIST: parametres Item_display invalides"
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
GLIST_item_display_exit:
end_sub

' =============== synchronisezr avec une autre GLIST ================================================
sub GLIST_synchronize_on(n%)
  if variable("GLIST_synchronize_on_result")=0 then dim GLIST_synchronize_on_result
  GLIST_v% = n%
  if GLIST_v%<>GLIST_numero_objet%
    for GLIST_i%=1 to GLIST_n_listes%
      if GLIST_liste_listes%(GLIST_i%)=GLIST_v%
' ici, GLIST_i% pointe sur l'esclave
        if GLIST_n_synchro%(GLIST_i%)>0
          for GLIST_j%=1 to GLIST_n_synchro%(GLIST_i%)
            if GLIST_synchros%(GLIST_i%,GLIST_j%)=GLIST_numero_objet% then goto GLIST_synchronize_on_exit  : ' déja synchronisé
          next GLIST_j%
        end_if
        if GLIST_nombre_dans_liste%(GLIST_index%)=GLIST_nombre_dans_liste%(GLIST_i%)    : ' on doit avoir le même nombre de lignes !
          GLIST_n_synchro%(GLIST_i%) = GLIST_n_synchro%(GLIST_i%) + 1
          GLIST_synchros%(GLIST_i%,GLIST_n_synchro%(GLIST_i%)) = GLIST_numero_objet% : ' mémoriser Glist actuelle dans cible synchro
          GLIST_n_synchro%(GLIST_index%) = GLIST_n_synchro%(GLIST_index%) + 1
          GLIST_synchros%(GLIST_index%,GLIST_n_synchro%(GLIST_index%)) = GLIST_v%    : ' mémoriser cible synchro dans GLIST actuelle
          GLIST_synchro_master% = GLIST_index% : GLIST_synchro_slave% = GLIST_i%
          gosub GLIST_synchronize  : ' synchronier l'esclave par rapport au maître
          GLIST_synchronize_on_result = 0
          goto GLIST_synchronize_on_exit
        end_if
      end_if
    next GLIST_i%
  end_if
  GLIST_synchronize_on_result = GLIST_erreur%
  GLIST_params$ = "GLIST: parametres Synchronize_on invalides"
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
GLIST_synchronize_on_exit:
end_sub

' =============== désynchroniser avec une autre GLIST ================================================
sub GLIST_synchronize_off(n%)
  if variable("GLIST_synchronize_off_result")=0 then dim GLIST_synchronize_off_result
  GLIST_v% = n%
  if GLIST_v%<>GLIST_numero_objet%
    for GLIST_i%=1 to GLIST_n_listes%
      if GLIST_liste_listes%(GLIST_i%)=GLIST_v%
        if GLIST_n_synchro%(GLIST_i%)>0            : ' est-ce que l'esclave a un maître ?
          for GLIST_j%=1 to GLIST_n_synchro%(GLIST_i%)      : ' chercher le maître chez l'esclave
            if GLIST_synchros%(GLIST_i%,GLIST_j%)=GLIST_numero_objet%
              if GLIST_j%<GLIST_n_synchro%(GLIST_i%) : ' faut-il tasser la liste de l'esclave
                for GLIST_k%=GLIST_j% to GLIST_n_synchro%(GLIST_i%)-1
                  GLIST_synchros%(GLIST_i%,GLIST_k%) = GLIST_synchros%(GLIST_i%,GLIST_k%+1)
                next GLIST_k%
              end_if
              GLIST_n_synchro%(GLIST_i%) = GLIST_n_synchro%(GLIST_i%) - 1  : ' oublier le maître de l'esclave
            end_if
          next GLIST_j%
        end_if
        if GLIST_n_synchro%(GLIST_index%)>0        : ' est-ce que le mâitre a un esclave ?
          for GLIST_j%=1 to GLIST_n_synchro%(GLIST_index%)  : ' chercher l'esclave chez le maître
            if GLIST_synchros%(GLIST_index%,GLIST_j%)=GLIST_v%
              if GLIST_j%<GLIST_n_synchro%(GLIST_index%) : ' faut-il tasser la liste du maître ?
                for GLIST_k%=GLIST_j% to GLIST_n_synchro%(GLIST_index%)-1
                  GLIST_synchros%(GLIST_index%,GLIST_k%) = GLIST_synchros%(GLIST_index%,GLIST_k%+1)
                next GLIST_k%
              end_if
              GLIST_n_synchro%(GLIST_index%) = GLIST_n_synchro%(GLIST_index%) - 1  : ' oublier l'esclave
            end_if
          next GLIST_j%
        end_if
        GLIST_synchronize_off_result = GLIST_erreur%
        goto GLIST_synchronize_off_exit
      end_if
    next GLIST_i%
  end_if
  GLIST_synchronize_off_result = GLIST_erreur%
  GLIST_params$ = "GLIST: parametres Synchronize_on invalides"
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
GLIST_synchronize_off_exit:
end_sub

' =============== configurer le mode de fonctionnement =========================
'        options: silent  verbose
sub GLIST_mode(md$)
  if variable("GLIST_error_mode_result")=0 then dim GLIST_error_mode_result
  GLIST_error_mode% = 2
  GLIST_error_mode_result = 0
  if md$="silent" then GLIST_error_mode% = 0
  if md$="verbose" then GLIST_error_mode% = 1
  if GLIST_error_mode%=2
    GLIST_error_mode% = 1
    GLIST_error_mode_result = GLIST_erreur%
  end_if
end_sub

' =============== chercher un enregistrement contenant une chaîne ==============
sub GLIST_item_search%(dir%,start%,crit$)
  if variable("GLIST_item_search_result%")=0 then dim GLIST_item_search_result%
    if GLIST_nombre_dans_liste%(GLIST_index%)>0
      GLIST_s$ = crit$
      if (dir%=0) or (dir%=1) or (start%=0) or (start%=1)
        GLIST_v% = dir%*2 + start%
        select GLIST_v%
                case 2:                                                  ' en arrière à partir de la fin
                    GLIST_i% = 1
                    GLIST_x1% = GLIST_nombre_dans_liste%(GLIST_index%)
                    GLIST_y1% = 1
                    GLIST_yy% = -1
                case 3:                                                  ' en arrière à partir de la sélection
                    GLIST_i% = 1
                    GLIST_x1% = GLIST_ligne_choisie%(GLIST_index%) - 1
                    GLIST_y1% = 1
                    GLIST_yy% = -1
                case 1:                                                  ' en avant à partir de la sélection
                    GLIST_i% = 0
                    GLIST_x1% = GLIST_ligne_choisie%(GLIST_index%) + 1
                    GLIST_y1% = GLIST_nombre_dans_liste%(GLIST_index%)
                    GLIST_yy% = 1
                case 0:                                                  ' en avant à partir du début
                    GLIST_i% = 0
                    GLIST_x1% = 1
                    GLIST_y1% = GLIST_nombre_dans_liste%(GLIST_index%)
                    GLIST_yy% = 1
        end_select
        if GLIST_x1%>GLIST_nombre_dans_liste%(GLIST_index%) or GLIST_x1%=0
          GLIST_params$ = "GLIST: Item_search non trouvé"
          if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
          GLIST_item_search_result% = GLIST_erreur%
          goto GLIST_item_search_exit
        end_if
        if len(GLIST_s$)>1                                    : ' critère non vide ?
          GLIST_v$ = left$(GLIST_s$,len(GLIST_s$)-1)    : ' critère de recherche
          for GLIST_n%=GLIST_x1% to GLIST_y1% step GLIST_yy%
            GLIST_s$ = item_read$(GLIST_liste_listes%(GLIST_index%),GLIST_n%)
            if instr(GLIST_s$,GLIST_v$)>0
              GLIST_item_search_result% = GLIST_n%
              GLIST_ligne_choisie%(GLIST_index%) = GLIST_n%
              GLIST_synchro_choisie% = GLIST_n%
              GLIST_j% = GLIST_n% - 3
              if GLIST_j%<1 then GLIST_j% = 1
              GLIST_nr%(GLIST_index%) = GLIST_j%
              off_change GLIST_numero_objet%+2
              position GLIST_numero_objet%+2,GLIST_nr%(GLIST_index%)
              on_change GLIST_numero_objet%+2,GLIST_change
              gosub GLIST_changeb
              gosub GLIST_do_synchro
              goto GLIST_item_search_exit
            end_if
          next GLIST_n%
          GLIST_params$ = "GLIST: Item_search non trouvé"
          if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
          GLIST_item_search_result% = GLIST_erreur%
          goto GLIST_item_search_exit
        end_if
      end_if
    end_if
    GLIST_params$ = "GLIST: paramètres Item_search invalides"
    if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
    GLIST_item_search_result% = GLIST_erreur%
GLIST_item_search_exit:
end_sub

' =============== déplacer la ligne choisie vers le haut ou vers le bas ========
sub GLIST_item_move(dir%)
  if variable("GLIST_item_move_result")=0 then dim GLIST_item_move_result
  GLIST_sens% = dir%
  if GLIST_sens%=0 or GLIST_sens%=1
    GLIST_org% = GLIST_ligne_choisie%(GLIST_index%)
    if GLIST_org%>0
      if GLIST_sens%=1      : ' vers le haut
        if GLIST_org%>1
          GLIST_s$ = item_read$(GLIST_numero_objet%,GLIST_org%)
          ITEM_delete GLIST_numero_objet%,GLIST_org%
          GLIST_ligne_choisie%(GLIST_index%) = GLIST_org% - 1
          item_insert GLIST_numero_objet%,GLIST_org%-1,GLIST_s$
          if GLIST_nr%(GLIST_index%)>1
            GLIST_nr%(GLIST_index%)= GLIST_nr%(GLIST_index%) - 1
            GLIST_scroll%(GLIST_index%) = GLIST_scroll%(GLIST_index%) - 1
          end_if
          off_change GLIST_numero_objet%+2
          position GLIST_numero_objet%+2,GLIST_org%-1
          on_change GLIST_numero_objet%+2,GLIST_change
          gosub GLIST_changeb
          ' ici synchroniser s'il le faut
          if GLIST_n_synchro%(GLIST_index%)>0                    : ' la liste a des esclaves ?
          GLIST_synchro_master% = GLIST_index%              : ' se rappeler le maître
          GLIST_synchro_temp% = GLIST_index%
          for GLIST_k%=1 to GLIST_n_synchro%(GLIST_synchro_temp%)
            GLIST_numero_objet% = GLIST_synchros%(GLIST_synchro_temp%,GLIST_k%)    : ' simuler un target_is sur l'esclave
            for GLIST_j%=1 to GLIST_n_listes%
              if GLIST_liste_listes%(GLIST_j%)=GLIST_numero_objet%
                GLIST_index% = GLIST_j%
                exit_for
              end_if
            next GLIST_j%
            2d_target_is GLIST_numero_objet% + 1
            print_target_is GLIST_numero_objet% + 1
            GLIST_s$ = item_read$(GLIST_numero_objet%,GLIST_org%)
            ITEM_delete GLIST_numero_objet%,GLIST_org%
            GLIST_ligne_choisie%(GLIST_index%) = GLIST_org% - 1
            item_insert GLIST_numero_objet%,GLIST_org%-1,GLIST_s$
            if GLIST_nr%(GLIST_index%)>1
              GLIST_nr%(GLIST_index%)= GLIST_nr%(GLIST_index%) - 1
              GLIST_scroll%(GLIST_index%) = GLIST_scroll%(GLIST_index%) - 1
            end_if
            off_change GLIST_numero_objet%+2
            position GLIST_numero_objet%+2,GLIST_org%-1
            on_change GLIST_numero_objet%+2,GLIST_change
            gosub GLIST_changeb
            next GLIST_k%
            GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)    : ' simuler un target_is sur le maître
            2d_target_is GLIST_numero_objet% + 1
            print_target_is GLIST_numero_objet% + 1
          end_if
          GLIST_item_move_result = 0
          goto GLIST_item_move_exit
        end_if
      else                : ' vers le bas
        if GLIST_org%<GLIST_nombre_dans_liste%(GLIST_index%)
          GLIST_s$ = item_read$(GLIST_numero_objet%,GLIST_org%)
          ITEM_delete GLIST_numero_objet%,GLIST_org%
          GLIST_ligne_choisie%(GLIST_index%) = GLIST_org% + 1
          item_insert GLIST_numero_objet%,GLIST_org%+1,GLIST_s$
          if GLIST_nr%(GLIST_index%)<(GLIST_nombre_dans_liste%(GLIST_index%)-GLIST_lignes_affichage%(GLIST_index%)+1)
            GLIST_nr%(GLIST_index%)= GLIST_nr%(GLIST_index%) + 1
            GLIST_scroll%(GLIST_index%) = GLIST_scroll%(GLIST_index%) + 1
          end_if
          off_change GLIST_numero_objet%+2
          position GLIST_numero_objet%+2,GLIST_org%+1
          on_change GLIST_numero_objet%+2,GLIST_change
          gosub GLIST_changeb
          ' ici synchroniser s'il le faut
          if GLIST_n_synchro%(GLIST_index%)>0                    : ' la liste a des esclaves ?
            GLIST_synchro_master% = GLIST_index%              : ' se rappeler le maître
            GLIST_synchro_temp% = GLIST_index%
            for GLIST_k%=1 to GLIST_n_synchro%(GLIST_synchro_temp%)
              GLIST_numero_objet% = GLIST_synchros%(GLIST_synchro_temp%,GLIST_k%)    : ' simuler un target_is sur l'esclave
              for GLIST_j%=1 to GLIST_n_listes%
                if GLIST_liste_listes%(GLIST_j%)=GLIST_numero_objet%
                  GLIST_index% = GLIST_j%
                  exit_for
                end_if
              next GLIST_j%
              2d_target_is GLIST_numero_objet% + 1
              print_target_is GLIST_numero_objet% + 1
              GLIST_s$ = item_read$(GLIST_numero_objet%,GLIST_org%)
              ITEM_delete GLIST_numero_objet%,GLIST_org%
              GLIST_ligne_choisie%(GLIST_index%) = GLIST_org% + 1
              item_insert GLIST_numero_objet%,GLIST_org%+1,GLIST_s$
              if GLIST_nr%(GLIST_index%)<(GLIST_nombre_dans_liste%(GLIST_index%)-GLIST_lignes_affichage%(GLIST_index%)+1)
                GLIST_nr%(GLIST_index%)= GLIST_nr%(GLIST_index%) + 1
                GLIST_scroll%(GLIST_index%) = GLIST_scroll%(GLIST_index%) + 1
              end_if
              off_change GLIST_numero_objet%+2
              position GLIST_numero_objet%+2,GLIST_org%-1
              on_change GLIST_numero_objet%+2,GLIST_change
              gosub GLIST_changeb
            next GLIST_k%
            GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)    : ' simuler un target_is sur le maître
            2d_target_is GLIST_numero_objet% + 1
            print_target_is GLIST_numero_objet% + 1
          end_if
          GLIST_item_move_result = 0
          goto GLIST_item_move_exit
        end_if
      end_if
    end_if
  end_if
  GLIST_item_move_result = GLIST_erreur%
  GLIST_params$ = "GLIST: paramètres Item_move invalides"
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
GLIST_item_move_exit:
end_sub

' =============== retourner le numéro de la première ligne d'affichage
sub GLIST_first_line%()
  if variable("GLIST_first_line_result%")=0 then dim GLIST_first_line_result%
  if GLIST_index%>0
    GLIST_first_line_result% = GLIST_nr%(GLIST_index%)
    goto GLIST_first_line_exit
  end_if
  GLIST_first_line_result% = GLIST_erreur%
  GLIST_params$ = "GLIST: aucune GLIST active"
  if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
GLIST_first_line_exit:
end_sub

' =============== routines internes de service =================================

' ============== synchroniser une liste esclave par rapport à une liste maître
GLIST_synchronize:
    GLIST_n% = GLIST_nr%(GLIST_synchro_master%)
    if GLIST_nombre_dans_liste%(GLIST_synchro_slave%)<GLIST_n% then return  : ' pas assez de lignes ?
    GLIST_nr%(GLIST_synchro_slave%) = GLIST_n%                  : ' forcer le positionnement
    GLIST_index% = GLIST_synchro_slave%                          : ' simuler un target_is sur l'esclave
    GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)
    2d_target_is GLIST_numero_objet% + 1
    print_target_is GLIST_numero_objet% + 1
    gosub GLIST_changeb                                          : ' et afficher l'esclave
    GLIST_index% = GLIST_synchro_master%                          : ' simuler un target_is sur le maître
    GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)
    2d_target_is GLIST_numero_objet% + 1
    print_target_is GLIST_numero_objet% + 1
    return

' ============== synchroniser tous les esclaves pour le maître actuel
GLIST_do_synchro:
    if GLIST_n_synchro%(GLIST_index%)>0
        GLIST_synchro_master% = GLIST_index%                  : ' se rappeler le maître
        for GLIST_syn%=1 to GLIST_n_synchro%(GLIST_synchro_master%)    : ' pour tous les esclaves
            GLIST_numero_objet% = GLIST_synchros%(GLIST_synchro_master%,GLIST_syn%) : ' simuler un target_is sur l'esclave
            for GLIST_j%=1 to GLIST_n_listes%
                if GLIST_liste_listes%(GLIST_j%)=GLIST_numero_objet%
                    GLIST_index% = GLIST_j%
                    exit_for
                end_if
            next GLIST_j%
            2d_target_is GLIST_numero_objet% + 1
            print_target_is GLIST_numero_objet% + 1
            GLIST_nr%(GLIST_index%) = GLIST_nr%(GLIST_synchro_master%)
            GLIST_scroll%(GLIST_index%) = GLIST_nr%(GLIST_index%)
            off_change GLIST_numero_objet%+2
            position GLIST_numero_objet%+2,GLIST_nr%(GLIST_index%)
            on_change GLIST_numero_objet%+2,GLIST_change
            if GLIST_synchro_choisie%>0 then GLIST_ligne_choisie%(GLIST_index%) = GLIST_synchro_choisie%
            gosub GLIST_changeb                                : ' et afficher l'esclave
        next GLIST_syn%
        GLIST_index% = GLIST_synchro_master%                  : ' simuler un target_is sur le maître
        GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)
        2d_target_is GLIST_numero_objet% + 1
        print_target_is GLIST_numero_objet% + 1
    end_if
    GLIST_synchro_choisie% = 0
    return

GLIST_print_line:
    if GLIST_ligne_selection%(GLIST_index%)=1 then gosub GLIST_select_on
    GLIST_n% = instr(GLIST_s$,"|")
    GLIST_code% = 0
    if GLIST_n%>0
        if numeric(left$(GLIST_s$,GLIST_n%-1))=1 then GLIST_code% = val(left$(GLIST_s$,GLIST_n%-1))
    end_if
    GLIST_s$ = right$(GLIST_s$,len(GLIST_s$)-GLIST_n%) : GLIST_n% = instr(GLIST_s$,"[")
    if GLIST_n%=0
        gosub GLIST_attrib_on : print GLIST_s$ : gosub GLIST_attrib_off : gosub GLIST_select_off
        return
    end_if
    if GLIST_n%>1
        print left$(GLIST_s$,GLIST_n%-1); : GLIST_s$ = right$(GLIST_s$,len(GLIST_s$)-GLIST_n%)
    else
        GLIST_s$ = right$(GLIST_s$,len(GLIST_s$)-1)
    end_if
    gosub GLIST_attrib_on : GLIST_n% = instr(GLIST_s$,"]") : print left$(GLIST_s$,GLIST_n%-1); : gosub GLIST_attrib_off : if GLIST_n%<len(GLIST_s$) then print right$(GLIST_s$,len(GLIST_s$)-GLIST_n%-1);
    gosub GLIST_select_off : print
    return

GLIST_select_on:
    select GLIST_mode_selection%(GLIST_index%)
        case 0                                          : ' rien à faire dans ce cas
        case 1: print "=> ";                            : ' révéler par une flèche
        case 2: font_bold GLIST_numero_objet%+1          : ' révéler par le gras
        case 3: font_underline GLIST_numero_objet%+1    : ' révéler par le sousligné
        case 4                                          : ' révélation par écriture blanche sur fond bleu
            GLIST_x1% = 0 : GLIST_y1% = (GLIST_i%-1)*14 : 2d_fill_color 0,0,255 : 2d_pen_color 0,0,255
            2d_rectangle GLIST_x1%,GLIST_y1%,GLIST_x1%+GLIST_largeur_affichage%(GLIST_index%),GLIST_y1%+14 : font_color GLIST_numero_objet%+1,255,255,255
' *** ici, d'autres modes de révélation de la ligne sélectionnée peuvent être définis
    end_select
    return

GLIST_select_off:
    select GLIST_mode_selection%(GLIST_index%)
        case 0                                            : ' rien à faire dans ce cas
        case 1                                            : ' rien à faire dans ce cas
        case 2: font_bold_off GLIST_numero_objet%+1      : ' enlever le gras
        case 3: font_underline_off GLIST_numero_objet%+1  : ' enlever le sousligné
        case 4                                            : ' enlever écriture blanche sur fond bleu
            2d_fill_color 255,255,255 : 2d_pen_color 255,255,255 : font_color GLIST_numero_objet%+1,0,0,0
' *** ici, d'autres modes de révélation de la ligne sélectionnée peuvent être définis
    end_select
    return

' ************* forcer les attributs
GLIST_attrib_on:
    if GLIST_ligne_selection%(GLIST_index%)=0
        font_color GLIST_numero_objet%+1,GLIST_font_attributs%((GLIST_index%-1)*10+GLIST_code%,1),GLIST_font_attributs%((GLIST_index%-1)*10+GLIST_code%,2),GLIST_font_attributs%((GLIST_index%-1)*10+GLIST_code%,3)
        if GLIST_font_attributs%((GLIST_index%-1)*10+GLIST_code%,0)=1 then font_bold GLIST_numero_objet%+1
    end_if
    return

' annuler tous les attributs
' ************* annuler ici tous les nouveaux attributs créés
GLIST_attrib_off:
    if GLIST_ligne_selection%(GLIST_index%)=0
        font_color GLIST_numero_objet%+1,0,0,0
        font_bold_off GLIST_numero_objet%+1
    end_if
    return

' ************* évènement timer
GLIST_SB_Evenement:
return
  timer_off GLIST_SB_Evenement%
'  if MOUSE_RIGHT_DOWN(GLIST_SB_numero_objet%)=1
'    GLIST_SB_mouse_right%=1
'  else
'    if MOUSE_RIGHT_UP(GLIST_SB_numero_objet%)=1 then GLIST_SB_mouse_right%=0
'  end_if
'  if MOUSE_LEFT_DOWN(GLIST_SB_numero_objet%)=1
'    GLIST_SB_mouse_left% = 1
'  else
'    if MOUSE_LEFT_UP(GLIST_SB_numero_objet%)=1 then GLIST_SB_mouse_left%=0
'  end_if
  GLIST_SB_mouse_left% = mouse_left_down(GLIST_SB_numero_objet%)
  if GLIST_SB_mouse_left% = 1 then goto GLIST_change
  timer_on GLIST_SB_Evenement%
return


' ************* changement des ascenseurs
' gestion de la scroll_bar
GLIST_change_bis:
GLIST_SB_numero_objet% = number_click
' timer_on GLIST_SB_Evenement%
return

GLIST_change:
    for GLIST_i%=1 to GLIST_n_listes%
        if position(GLIST_liste_listes%(GLIST_i%)+2)<>GLIST_scroll%(GLIST_i%)
            GLIST_index% = GLIST_i%
            GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)
            GLIST_scroll%(GLIST_index%) = position(GLIST_numero_objet%+2)
            2d_target_is GLIST_numero_objet%+1
            print_target_is GLIST_numero_objet%+1
        off_change GLIST_numero_objet%+2
            GLIST_nr%(GLIST_index%) = position(GLIST_numero_objet%+2)
            GLIST_scroll%(GLIST_index%) = GLIST_nr%(GLIST_index%)
            gosub GLIST_do_synchro
            exit_for
        end_if
    next GLIST_i%
GLIST_changeb:
    hide GLIST_numero_objet%+1
    print_target_is GLIST_numero_objet%+1
    2d_target_is GLIST_numero_objet%+1
    print_locate 0,0
    2d_clear
    GLIST_max% = GLIST_lignes_affichage%(GLIST_index%)
    if GLIST_nombre_dans_liste%(GLIST_index%)<GLIST_max% then GLIST_max% = GLIST_nombre_dans_liste%(GLIST_index%)
    for GLIST_i%=1 to GLIST_max%
        if (GLIST_nr%(GLIST_index%)+GLIST_i%-1)>GLIST_nombre_dans_liste%(GLIST_index%) then exit_for
        GLIST_v% = GLIST_nr%(GLIST_index%)+GLIST_i%-1
        if GLIST_v%>0
          GLIST_s$ = item_read$(GLIST_numero_objet%,GLIST_v%)
          GLIST_ligne_selection%(GLIST_index%) = 0
          on_error_goto GLIST_fin2
          if GLIST_nr%(GLIST_index%)+GLIST_i%-1=GLIST_ligne_choisie%(GLIST_index%) then GLIST_ligne_selection%(GLIST_index%) = 1
          off_error_goto
          gosub GLIST_print_line
        end_if
    next GLIST_i%
GLIST_fin2:
    off_error_goto
    off_change GLIST_numero_objet%+2
    GLIST_v% = count(GLIST_numero_objet%) - GLIST_max%
    if GLIST_v%<1 then GLIST_v% = 1
    max GLIST_numero_objet%+2, GLIST_v%
    on_change GLIST_numero_objet%+2,GLIST_change
    show GLIST_numero_objet%+1
 on_change GLIST_numero_objet%+2,GLIST_change
'  timer_on GLIST_SB_Evenement%
    return

' ********** clic dans une des listes
GLIST_click_liste:
    for GLIST_i%=1 to GLIST_n_listes%
        if clicked(GLIST_liste_listes%(GLIST_i%)+1)=1
            GLIST_index% = GLIST_i%
            GLIST_numero_objet% = GLIST_liste_listes%(GLIST_index%)
            2d_target_is GLIST_numero_objet%+1
            print_target_is GLIST_numero_objet%+1
            GLIST_xx% = mouse_x_left_down(GLIST_numero_objet%+1)
            GLIST_yy% = mouse_y_left_down(GLIST_numero_objet%+1)
            GLIST_v% = GLIST_nr%(GLIST_index%) + int((GLIST_yy%+13)/14) - 1
            if GLIST_v%>GLIST_nombre_dans_liste%(GLIST_index%) then return
            GLIST_ligne_choisie%(GLIST_index%) = GLIST_v%
            GLIST_synchro_choisie% = GLIST_v%
            gosub GLIST_changeb
            gosub GLIST_do_synchro
            GLIST_params$ = "Liste "+str$(GLIST_index%)+"  ligne "+str$(GLIST_ligne_choisie%(GLIST_index%))
            if GLIST_error_mode%=1 then GLIST_err% = message_error_OK(GLIST_params$)
            return
        end_if
    next GLIST_i%
    return
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
Klaus

avatar

Nombre de messages : 10075
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Nouvelle version de mon pseudo-objet GLIST   Mar 25 Sep 2012 - 12:48

Et voici le programme de gestion de contacts. Suite au BUG concernant #INCLUDE avec des SUB, j'ai dû inclure physiquement GLIST_SUB.bas dans le programme, et j'ai mis la ligne #INCLUDE en commentaire. Dès que ce bug sera corrigé, je reviendrai bien sûr en arrière sur ce bricolage. Et comme cela fait trop de lignes pour un post, vous devez ajouter GLIST_SUB.bas du post précédent par copier/coller, à la fin du fichier.

contacts par GLIST_SUB.bas:
Code:
' contacts par GLIST_SUB.bas

' ************************************************************************
' *          Maintenance d'un fichier de contacts téléphoniques
' *
' * Ce programme utilise les GLIST pour gérer la liste de contacts
' * téléphoniques. Les noms sont présentés dans une liste, les téléphones
' * dans une autre. Les deux listes sont synchronisées: il ne peut donc
' * y avoir aucun décalage. Les listes sont alimentées par les fichiers
' * contact_noms.txt et contact_telephones.txt.
' *
' *************************************************************************

label click_21, click_22, click_23, click_24, click_25, click_26, click_27
label click_28, click_29, click_30, click_31

dim racine$, fichier_noms$, fichier_telephones$, fichier_adresses$
dim ligne$, ligne%, modif%, smode%

racine$ = "" : ' ou "C:\Mondossier\" etc
fichier_noms$ = "contact_noms.txt"
fichier_telephones$ = "contact_telephones.txt"
fichier_adresses$ = "contact_adresses.txt"

modif% = 0 : width 0,800 : height 0,600 : smode% = 0

if file_exists(racine$+fichier_noms$)=0
    file_open_write 2,racine$+fichier_noms$
    file_writeln 2,"Dupont, Charles"
    file_close 2
    file_open_write 2,racine$+fichier_telephones$
    file_writeln 2,"01.23.45.67.89"
    file_close 2
    file_open_write 2,racine$+fichier_adresses$
    file_writeln 2,"53 av du Faubourg ST. Antoine, 75011 Paris"
    file_close 2
end_if

alpha 11: top 11,20 : left 11,20 : caption 11,"Noms des contacts"
    font_bold 11 : font_size 11,12
alpha 12 : top 12,20 : left 12,250 : caption 12,"Téléphones"
    font_bold 12 : font_size 12,12
alpha 14 : top 14,20 : left 14,430 : caption 14,"Adresses"
    font_bold 14 : font_size 14,12

GLIST_initialize()

GLIST_create(101,20,200,40,20)
GLIST_file_load(racine$+fichier_noms$)
GLIST_Revelation(4)

GLIST_create(111,20,150,40,250)
GLIST_file_load(racine$+fichier_telephones$)
GLIST_Revelation(4)

GLIST_create(121,20,300,40,430)
GLIST_file_load(racine$+fichier_adresses$)
GLIST_Revelation(4)

GLIST_synchronize_on(101)
GLIST_synchronize_on(111)
GLIST_target_is(111)
GLIST_synchronize_on(101)

GLIST_mode("silent")

edit 1 : top 1,370 : left 1,20 : width 1,200    : ' zone de saisie nom
edit 2 : top 2,370 : left 2,250 : width 2,150  : ' zone de saisie téléphone
edit 3 : top 3,370 : left 3,430 : width 3,300  : ' zone de saisie adresse

button 21 : top 21,330 : left 21,10 : caption 21,"Modifier" : on_click 21,click_21
button 22 : top 22,330 : left 22,90 : caption 22,"Valider" : on_click 22,click_22
button 23 : top 23,330 : left 23,220 : caption 23,"Ajouter" : on_click 23,click_23
button 24 : top 24,330 : left 24,300 : caption 24,"Insérer" : on_click 24,click_24
button 25 : top 25,330 : left 25,380 : caption 25,"Supprimer" : on_click 25,click_25

button 28 : top 28,395 : left 28,50 : caption 28,"Chercher Nom" : on_click 28,click_28
button 29 : top 29,395 : left 29,290 : caption 29,"Chercher Tél" : on_click 29,click_29
button 30 : top 30,395 : left 30,470 : caption 30,"Chercher Adr" : on_click 30,click_30
check 31 : top 31,400 : left 31,600 : width 31,160 : caption 31,"Rechercher depuis le début" : on_click 31,click_31

button 26 : top 26,450 : left 26,10 : caption 26,"Sauvegarder" : on_click 26,click_26 : width 26,160
button 27 : top 27,450 : left 27,220 : caption 27,"Sortir" : on_click 27,click_27 : width 27,240
inactive 22 : inactive 26

end

' ------------ charger un contact dans le zones de saisie pour modif
click_21:
  GLIST_selected%()
  ligne% = GLIST_selected_result%
  if ligne%<>0
    GLIST_target_is(101)
    GLIST_item_read$(ligne%)
    text 1,GLIST_item_read_result$
    GLIST_target_is(111)
    GLIST_item_read$(ligne%)
    text 2,GLIST_item_read_result$
    GLIST_target_is(121)
    GLIST_item_read$(ligne%)
    text 3,GLIST_item_read_result$
    active 22
  end_if
  return
   
' ------------ mettre à jour les listes à partir des zones de saisie
click_22:
  GLIST_selected%()
  ligne% = GLIST_selected_result%
  if ligne%<>0
    GLIST_target_is(101)
    GLIST_item_modify(ligne%,text$(1))
    GLIST_target_is(111)
    GLIST_item_modify(ligne%,text$(2))
    GLIST_target_is(121)
    GLIST_item_modify(ligne%,text$(3))
    modif% = 1
    inactive 22
    active 26
  end_if
  return

' ------------ ajouter le contact à la fin de la liste
click_23:
  if len(trim$(text$(1)))>0
    GLIST_target_is(101)
    GLIST_item_add(text$(1))
    GLIST_total%()
    ligne% = GLIST_total_result%
    GLIST_target_is(111)
    GLIST_item_modify(ligne%,text$(2))
    GLIST_target_is(121)
    GLIST_item_modify(ligne%,text$(3))
    modif% = 1
    active 26
  end_if
  return

' ------------ insérer le contact devant la lignes électionnée
click_24:
  GLIST_selected%()
  ligne% = GLIST_selected_result%
  if ligne%<>0
    GLIST_target_is(101)
    GLIST_item_insert(ligne%,text$(1))
    GLIST_target_is(111)
    GLIST_item_modify(ligne%,text$(2))
    GLIST_target_is(121)
    GLIST_item_modify(ligne%,text$(3))
    modif% = 1
    active 26
  end_if
  return

' ------------ supprimer la ligne sélectionnée
click_25:
  GLIST_selected%()
  ligne% = GLIST_selected_result%
  if ligne%<>0
    GLIST_target_is(101)
    GLIST_item_delete(ligne%)
'    GLIST_target_is(111)
'    GLIST_item_delete(ligne%)
'    GLIST_target_is(121)
'    GLIST_item_delete(ligne%)
    modif% = 1
  end_if
  return

' ------------ sauvegarder les listes dans les fichiers
click_26:
    GLIST_target_is(101)
    GLIST_file_save(racine$+fichier_noms$)
    GLIST_target_is(111)
    GLIST_file_save(racine$+fichier_telephones$)
    GLIST_target_is(121)
    GLIST_file_save(racine$+fichier_adresses$)
    modif% = 0
    inactive 26
    return
   
click_28:
    GLIST_target_is(101)
    GLIST_item_search%(smode%,1,text$(1))
    return
   
click_29:
    GLIST_target_is(111)
    GLIST_item_search%(smode%,1,text$(2))
    return

click_30:
    GLIST_target_is(121)
    GLIST_item_search%(smode%,1,text$(3))
    return

click_31:
  smode% = checked(31)
  return

' ------------ sortir du propramme
click_27:
    if modif%=1
        if message_warning_yes_no("ATTENTION ! Voulez-vous vraiment sortir sans sauvegarder ?")<>1 then return
    end_if
    terminate

' #INCLUDE "GLIST.bas"

Et voici les 3 fichiers de données nécessaires:

contact_noms.txt:
Citation :
Dupont, Charles
Porteur, Philippe
Dupont, Jaqueline
Martin, Jacques
Porteur, Gérard

contact_telephones.txt:
Citation :
01.23.45.67.89
06.11.22.33.44
06.07.08.09.01
01.22.33.44.55
06.11.22.33.44

contact_adresses.txt:
Citation :
Chemin de la Vallée, 89379 Les Mimosas
12 Place de la Libération, 72390 St. Vesque
4 chemin du Halage, 45110 Chateau-Neuf sur Loire
10 bld de la République, 72000 Le Mans
12 Place de la Libération, 72390 St. Vesque


Dernière édition par Klaus le Mar 25 Sep 2012 - 21:53, édité 1 fois
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
Nardo26

avatar

Nombre de messages : 2294
Age : 49
Localisation : Valence
Date d'inscription : 02/07/2010

MessageSujet: Re: Nouvelle version de mon pseudo-objet GLIST   Mar 25 Sep 2012 - 13:59

Bonjour Klaus,
C'est clair que c'est franchement plus agréable à lire et à utiliser!
les SUB apportent une souplesse que l'on avait pas avant... Smile

Je crois que je vais maintenant utiliser plus souvent les GLIST...
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://nardo26.lescigales.org
Jicehel

avatar

Nombre de messages : 5858
Age : 45
Localisation : 77500
Date d'inscription : 19/04/2011

MessageSujet: Re: Nouvelle version de mon pseudo-objet GLIST   Mar 25 Sep 2012 - 14:11

Je teste ça ce soir. Ca m'interesse.
Hum, si je pouvais faire un petit hors sujet et si ça t'interesse Klaus. Est-ce que tu crois que tu pourrais faire un petit programme qui permettrait de faire une MAJ sécurisée via le réseau ? (C'est à dire un module qui tourne sur une machine et plusieurs clients sur le réseau, authentification => utilisateur ou rédacteur. Utilisateur => accès en lecture seule, redacteur peut modifier les informations si personnes ne les mets déjà à jour ?). C'est en dehors de ce pourquoi tu as écrit ton programme, donc je te demande juste si ça tinteresse comme je ne crois pas que j'aurais le temps de faire ça...
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Nardo26

avatar

Nombre de messages : 2294
Age : 49
Localisation : Valence
Date d'inscription : 02/07/2010

MessageSujet: Re: Nouvelle version de mon pseudo-objet GLIST   Mar 25 Sep 2012 - 14:23

Jicehel a écrit:
Je teste ça ce soir. Ca m'interesse.
Hum, si je pouvais faire un petit hors sujet et si ça t'interesse Klaus. Est-ce que tu crois que tu pourrais faire un petit programme qui permettrait de faire une MAJ sécurisée via le réseau ? (C'est à dire un module qui tourne sur une machine et plusieurs clients sur le réseau, authentification => utilisateur ou rédacteur. Utilisateur => accès en lecture seule, redacteur peut modifier les informations si personnes ne les mets déjà à jour ?). C'est en dehors de ce pourquoi tu as écrit ton programme, donc je te demande juste si ça tinteresse comme je ne crois pas que j'aurais le temps de faire ça...
Faire un client/serveur ? en Pano ?...

Il y a logmein qui propose Hamachi, je ne sais pas si c'est toujours gratuit/bridé...
Sinon, faire un tour vers FileZilla server et utiliser la librairie FTP qui tourne sous Panoramic...
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://nardo26.lescigales.org
Klaus

avatar

Nombre de messages : 10075
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Nouvelle version de mon pseudo-objet GLIST   Mar 25 Sep 2012 - 14:45

Pour fermer cette parenthèse sur ce fil de discussion dédié en principe au pseudo-objet GLIST:

1. une mise à jour automatique et sécurisée peut être pensée de deux manières:

1.1. un serveur sur lequel tourne un programme dédié. Il recevra les identifications, peut être interrogé sur la dernière version disponible et peut sur demande mettre à disposition cette version au téléchargement. Ceci n'est pas réaliste avec Panoramic.

1.2. un site internet ou in stockage genre MyDrive qui contient la dernière version. il faut alors un fichier documentant la version disponible. Un programme Panoramic distant téléchargerait ce fichier et en déduirait s'il faut récupérer la version ou non, et téléchargerait la version si nécessaire. Cette manière de faire est réalisable à l'aide de l'info donnée par Nardo.

Je peux éventuellement regarder ce qu'il y a à faire, mais c'est du Pano pur (en utilisant la DLL mentionnée), et il n'y a rien de sorcier.

Pour des choses comme ça, je te suggère d'ouvrir un fil de discussion spécifique dans la rubrique "Le site de Klaus". Je pense que ce sera plus approprié.

Et maintenant, retour au GLIST.......;
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
Jicehel

avatar

Nombre de messages : 5858
Age : 45
Localisation : 77500
Date d'inscription : 19/04/2011

MessageSujet: Re: Nouvelle version de mon pseudo-objet GLIST   Mar 25 Sep 2012 - 14:57

Merci Klaus, je ne savais plus si dans ta DLL tu avais déjà les fonctions pour pouvoir le faire comme je suis au boulot et que je n'ais pas accès à la doc... mais bon, j'arrète la le hors sujet pour ne pas polluer en effet le GLIST
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Nardo26

avatar

Nombre de messages : 2294
Age : 49
Localisation : Valence
Date d'inscription : 02/07/2010

MessageSujet: Re: Nouvelle version de mon pseudo-objet GLIST   Mar 25 Sep 2012 - 19:03

Hello Klaus,
Une petite erreur s'est glissée dans ton code de contacts téléphoniques.

entre la ligne 32 et 33 il manque un file_close 2.... Wink

Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://nardo26.lescigales.org
Klaus

avatar

Nombre de messages : 10075
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Nouvelle version de mon pseudo-objet GLIST   Mar 25 Sep 2012 - 21:53

Exact ! Merci ! C'est corrigé dans le post concerné.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
Contenu sponsorisé




MessageSujet: Re: Nouvelle version de mon pseudo-objet GLIST   

Revenir en haut Aller en bas
 
Nouvelle version de mon pseudo-objet GLIST
Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 1 sur 1
 Sujets similaires
-
» Pseudo-objet - Générateur de code
» [résolu]Nouvelle version: fichier .bat
» Roboform, Nouvelle version
» Problème: pourquoi Base C. crée t-il une nouvelle version à chaque chargement de fichier .gpx
» Nouvelle version de Garmin Express (3.6.2 pour Mac)-Resolu

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
FORUM DE DISCUSSION SUR LE LANGAGE PANORAMIC :: PANORAMIC :: Vos sources, vos utilitaires à partager-
Sauter vers: