Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des exemples
de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à l'aides
des sinus / cosinus :)
Bon dev quand même
Fred
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des exemples
de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à l'aides
des sinus / cosinus :)
Bon dev quand même
Fred
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des exemples
de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à l'aides
des sinus / cosinus :)
Bon dev quand même
Fred
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à l'aides
des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version de
WD ou autre, oui, bien sûr ça m'interresse...
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à l'aides
des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version de
WD ou autre, oui, bien sûr ça m'interresse...
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à l'aides
des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version de
WD ou autre, oui, bien sûr ça m'interresse...
André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX - (lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
André STASZEWSKI a présenté l'énoncé suivant :
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX - (lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX - (lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
André STASZEWSKI a présenté l'énoncé suivant :
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
André STASZEWSKI a présenté l'énoncé suivant :
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
André STASZEWSKI a présenté l'énoncé suivant :
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne version
de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY - (lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
André STASZEWSKI a écrit :André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne
version de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY -
(lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa
politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
je m'en souviens plus ca doit daté de 2008 ou 2009 (date à laquelle j'ai
commencer à faire le prog en WD12 qui contient ce code)
il manque qq ch ?
André STASZEWSKI a écrit :
André STASZEWSKI a présenté l'énoncé suivant :
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne
version de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY -
(lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa
politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
je m'en souviens plus ca doit daté de 2008 ou 2009 (date à laquelle j'ai
commencer à faire le prog en WD12 qui contient ce code)
il manque qq ch ?
André STASZEWSKI a écrit :André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne
version de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX - (lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX - (lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY -
(lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux réaliser
mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa
politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
je m'en souviens plus ca doit daté de 2008 ou 2009 (date à laquelle j'ai
commencer à faire le prog en WD12 qui contient ce code)
il manque qq ch ?
André STASZEWSKI a écrit :André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes
par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne
version de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX -
(lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX -
(lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY -
(lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux
réaliser mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa
politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
je m'en souviens plus ca doit daté de 2008 ou 2009 (date à laquelle j'ai
commencer à faire le prog en WD12 qui contient ce code)
il manque qq ch ?
Bonjour,
Je n'ai pas encore testé car je dois dabord finir le projet en question et si
je peux, j'incluerai cette horloge à la place de la saisie conventionnelle.
C'était juste pour savoir si ça venait d'un exemple ou d'une LST de l'époque.
Mais à priori non.
André STASZEWSKI a écrit :
André STASZEWSKI a présenté l'énoncé suivant :
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes
par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne
version de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX -
(lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX -
(lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY -
(lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux
réaliser mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa
politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
je m'en souviens plus ca doit daté de 2008 ou 2009 (date à laquelle j'ai
commencer à faire le prog en WD12 qui contient ce code)
il manque qq ch ?
Bonjour,
Je n'ai pas encore testé car je dois dabord finir le projet en question et si
je peux, j'incluerai cette horloge à la place de la saisie conventionnelle.
C'était juste pour savoir si ça venait d'un exemple ou d'une LST de l'époque.
Mais à priori non.
André STASZEWSKI a écrit :André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes
par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne
version de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX -
(lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX -
(lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY -
(lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux
réaliser mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa
politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
je m'en souviens plus ca doit daté de 2008 ou 2009 (date à laquelle j'ai
commencer à faire le prog en WD12 qui contient ce code)
il manque qq ch ?
Bonjour,
Je n'ai pas encore testé car je dois dabord finir le projet en question et si
je peux, j'incluerai cette horloge à la place de la saisie conventionnelle.
C'était juste pour savoir si ça venait d'un exemple ou d'une LST de l'époque.
Mais à priori non.
André STASZEWSKI a écrit :André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes
par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne
version de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX -
(lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX -
(lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY -
(lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux
réaliser mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa
politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
je m'en souviens plus ca doit daté de 2008 ou 2009 (date à laquelle j'ai
commencer à faire le prog en WD12 qui contient ce code)
il manque qq ch ?
Bonjour,
Je n'ai pas encore testé car je dois dabord finir le projet en question et si
je peux, j'incluerai cette horloge à la place de la saisie conventionnelle.
C'était juste pour savoir si ça venait d'un exemple ou d'une LST de l'époque.
Mais à priori non.
André STASZEWSKI a écrit :
André STASZEWSKI a présenté l'énoncé suivant :
Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :
Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes
par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne
version de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX -
(lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX -
(lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY -
(lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux
réaliser mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa
politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
je m'en souviens plus ca doit daté de 2008 ou 2009 (date à laquelle j'ai
commencer à faire le prog en WD12 qui contient ce code)
il manque qq ch ?
Bonjour,
Je n'ai pas encore testé car je dois dabord finir le projet en question et si
je peux, j'incluerai cette horloge à la place de la saisie conventionnelle.
C'était juste pour savoir si ça venait d'un exemple ou d'une LST de l'époque.
Mais à priori non.
André STASZEWSKI a écrit :André STASZEWSKI a présenté l'énoncé suivant :Le 18/06/2016 à 17:24, André STASZEWSKI a écrit :Bonjour,
J'aimerai savoir si quelqu'un a déjà reproduit sous WD une horloge
graphique destiné à saisir l'heure avec la souris en quelques clics
comme on le fait maintenant de manière tactile sur de nombreux
téléphones lorsqu'on ajoute une alarme.
On affiche une horloge ronde qui indique les heures et les minutes
par
pas de 5mn dont les aiguilles sont positionnées sur l'heure courante.
Un premier touché positionne la petite aiguille sur l'heure touchée.
Un deuxième touché positionne la grande aiguille sur les minutes
touchées.
Un bouton "OK" permet de valider la saisie.
J'aimerai bien utiliser cette méthode dans un programme...
Il existait pas le passé un exemple d'horloge graphique dans un des
exemples de windev (ou une LST)
Je ne l'ai malheureusement pas conservé. Si quelqu'un à ça dans ses
archives.
Sinon il reste la solution du champs dessin et un calcul d'angles à
l'aides des sinus / cosinus :)
Bon dev quand même
Fred
Salut Fredo,
Si c'est l'exemple Horloge graphique de la LST 97 alors 'non' ça ne
correspond pas à ce que je recherche (j'ai vu une illustration sur la
présentation de cette LST), mais si ça a existé dans une ancienne
version de WD ou autre, oui, bien sûr ça m'interresse...
bonjour,
j'ai ca sous la main avec une image d'horloge ronde (à adapter)
GLOBAL
gf_szNomChampImage est une chaîne = IMG_HORLOGE..NomComplet
******* mettre en proc auto thread *******
PROCEDURE PRIVÉE afficheHeure()
hHeure est une Heure
lHeure est un entier
lMinute est un entier
lSeconde est un entier
lAngleHeure est un entier
lAngleMinute est un entier
lAngleSeconde est un entier
lLargeur est un entier
lHauteur est un entier
// Calcule le décalage
hHeure = Maintenant()
// Récupère les heure et minute
lHeure = hHeure..Heure
lMinute = hHeure..Minute
lSeconde = hHeure..Seconde
// Récupère les dimensions du champ
lLargeur = {gf_szNomChampImage, indChamp}..Largeur
lHauteur = {gf_szNomChampImage, indChamp}..Hauteur
SI lLargeur < lHauteur ALORS lHauteur = lLargeur
SI lHauteur < lLargeur ALORS lLargeur = lHauteur
// Démarre le dessin
dFinDessin(gf_szNomChampImage)
dChangeMode(dessinAntiAliasing)
dDébutDessin(gf_szNomChampImage, dEffacer)
nCouleur est un entier = RVB(127,127,127)
//nCouleur est un entier = rvb(14,47,118)
// L'heure doit être passée en format 12:00
SI lHeure > 12 ALORS lHeure -= 12
// Calcule l'angle
lAngleHeure = lHeure * (360 / 12) - 90 + lMinute / 2
lAngleMinute = lMinute * (360 / 60) - 90
//lAngleSeconde = lSeconde * (360 / 60) - 90
// Calcule le point central
nX est un entier = lLargeur / 2
nY est un entier = lHauteur / 2
// Calcule le point X,Y de l'heure
nHX est un entier = nX + 2 + (Cosinus(lAngleHeure) * (nX -
(lLargeur/4)))
nHY est un entier = nY + 2 +(Sinus(lAngleHeure) * (nY - (lLargeur/4)))
// Calcule le point X,Y de la minute
nMX est un entier = nX + 2 +(Cosinus(lAngleMinute) * (nX -
(lLargeur/5)))
nMY est un entier = nY + 2 +(Sinus(lAngleMinute) * (nY - (lLargeur/5)))
// Calcule le point X,Y de la seconde
//nSX est un entier = nX + 2 +(Cosinus(lAngleSeconde) * (nX -
(lLargeur/6)))
//nSY est un entier = nY + 2 +(sinus(lAngleSeconde) * (nY -
(lLargeur/6)))
// Dessine l'aiguille des secondes
//dLigne(nX, nY, nSX, nSY, iGrisFonce, (lLargeur/50))
// Dessine l'aiguille des minutes
//dLigne(nX, nY, nMX, nMY, iGrisFonce, (lLargeur/30))
//dLigne(nX, nY, nMX, nMY, rvb(216,216,216), (lLargeur/50))
dLigne(nX, nY, nMX, nMY, iBlanc, (lLargeur/50))
// Dessine l'aiguille de l'heure
dLigne(nX, nY, nHX, nHY, nCouleur, (lLargeur/30))
// Dessine le centre de l'horloge
dCercle(nX - 2, nY - 2, nX + 2, nY + 2, iNoir, nCouleur)
{gf_szNomChampImage, indChamp}..Bulle = HeureVersChaîne(hHeure)[[A 5]]
Excellent Jean-Phi !
Je vais m'inspirer de ce code dès que possible et voir si je peux
réaliser mon projet.
Au fait, j'ai une appli qui utilise ton composant "EasyGoogleMapsAPI".
Mais depuis le 22 juin il ne marche plus car Google a modifié sa
politique.
Voir ces liens pour plus d'info.
http://blogs.pcsoft.fr/post.awp?title=champ-carte-oops-something-went-wrong,2,577
http://faq.pcsoft.fr/read.awp?id033
http://faq.pcsoft.fr/read.awp?id035
Est-ce que tu comptes mettre à jour le composant rapidement ?
Oups ! Désolé (j'ai confondu...)
Au fait, le code de l'horloge, vous l'avez eu où ?
je m'en souviens plus ca doit daté de 2008 ou 2009 (date à laquelle j'ai
commencer à faire le prog en WD12 qui contient ce code)
il manque qq ch ?
Bonjour,
Je n'ai pas encore testé car je dois dabord finir le projet en question et si
je peux, j'incluerai cette horloge à la place de la saisie conventionnelle.
C'était juste pour savoir si ça venait d'un exemple ou d'une LST de l'époque.
Mais à priori non.