PC SOFT

DOCUMENTATION EN LIGNE
DE WINDEV, WEBDEV ET WINDEV MOBILE

  • Présentation
  • Eléments de projets disponibles
  • Champs disponibles
  • Bases de données
  • Menus de l'application
  • Menus contextuels
  • Fenêtres modales
  • Gestion du bouton "Retour" et du bouton "Home"
  • Bouton Retour
  • Bouton Home/Accueil
  • Notification d'inactivité de l'application
  • Fonctionnement du focus et de la sélection
  • Zones répétées
  • Ascenseurs automatiques dans les fenêtres
  • Utilisation de code Java natif dans une application Android
  • Types des paramètres des fonctions
  • Gestion des répertoires
  • Changement d'orientation de l'écran
  • Divers
  • Gestion des threads
  • Opérateurs d'indirection
  • Utilisation des polices natives Android
  • Gestion des logs ADB
  • Débogage d'applications déployées via les logs ADB
  • Impression au format PDF
WINDEV
WindowsLinuxUniversal Windows 10 AppJavaEtats et RequêtesCode Utilisateur (MCU)
WEBDEV
WindowsLinuxPHPWEBDEV - Code Navigateur
WINDEV Mobile
AndroidWidget AndroidiPhone/iPadApple WatchUniversal Windows 10 AppWindows Mobile
Autres
Procédures stockées
Eléments de projets disponibles
Les éléments de projets suivants sont disponibles pour le développement Android :
  • Fenêtres.
  • Requêtes.
    Remarque : dans une requête paramétrée, tous les paramètres sont obligatoires.
  • Classes.
  • Collections de procédures.
  • Modèles de fenêtres.
Les éléments suivants ne sont pas disponibles pour le développement Android :
  • Composants externes.
    Remarque : Les composants internes sont disponibles pour le développement Android. Cependant, si le composant interne possède une analyse, cette analyse ne sera pas prise en compte lors de l'exécution.
  • Etats et modèles d'états.
  • Modèles de champs.
  • Fenêtres internes.

Champs disponibles

Les champs suivants sont disponibles pour le développement Android :
  • Bouton
  • Combo
    Remarque : Il n'est pas possible d'affecter une valeur négative ou nulle à une combo. Si la combo n'est pas vide, elle doit nécessairement avoir un élément sélectionné. Une erreur sera affichée si une valeur négative ou nulle est affectée à une combo.
  • Image
  • Interrupteur
  • Libellé
  • Liste
  • Onglet
  • Saisie
  • Sélecteur
  • Zone répétée
    Remarque : Les champs Zone répétée permettent de remplacer les champs Table dans une application Android. En effet, le concept de "champ Table" n'existe pas sous Android. Les champs Table ne sont pas utilisés sous Android en règle générale pour les raisons suivantes :
    • L'interface des champs Table n'est pas appropriée.
    • Problème d'espace dans les fenêtres : les colonnes et les entêtes de colonnes ne pourraient pas être affichées.
    • La hauteur des lignes serait trop petite pour être manipulée avec les doigts.
    • Les champs Table ne sont pas utilisés dans les normes d'interface de ce système.
Versions 18 et supérieures
Versions 19 et supérieures
Versions 20 et supérieures
Nouveauté 20
Versions 21 et supérieures
Nouveauté 21
Remarques :
  • Les propriétés de style des champs (onglet "Style" de la fenêtre de description des champs), bien que disponibles en édition, ne sont pas toutes supportées par les applications Android.
  • Versions 21 et supérieures
    Lors de la définition du la couleur de fond du cadre des champs, il est possible d'utiliser une couleur de fond dégradée.
    Nouveauté 21
    Lors de la définition du la couleur de fond du cadre des champs, il est possible d'utiliser une couleur de fond dégradée.
    Lors de la définition du la couleur de fond du cadre des champs, il est possible d'utiliser une couleur de fond dégradée.
Bases de données
Les bases de données des applications Android doivent être au format SQLite. SQLite est le système de base de données livré avec le système d'exploitation Android.
WINDEV Mobile inclut en standard un accès natif pour SQLite pour Android. Les principaux ordres Hxxx sont disponibles.
Pour les applications Android, les bases de données disponibles sont :
  • HFSQL (Classic et Client/Serveur),
  • SQLite.
    WINDEV Mobile inclut en standard un accès natif pour SQLite pour Android. Les principaux ordres Hxxx sont disponibles.
Remarques :
  • Base de données SQLite : Si votre projet Android partage son analyse avec un autre projet (non Android), vous pouvez utiliser la fonction HChangeConnexion pour associer les fichiers de données de l'application à une connexion de type SQLite. Pour plus de détails, consultez Application Android : Utilisation et partage de données.
  • Gestion des mémos avec SQLite : Le stockage d'informations sous forme de mémos est conseillé uniquement pour des données de taille peu volumineuse (inférieures à 1 Mo). Il est recommandé d'enregistrer directement les données sous forme de fichier externe sur la mémoire du téléphone (interne ou externe) et de mémoriser dans la base uniquement le chemin d'accès à ces données.
  • Versions 19 et supérieures
    Il est également possible d'accéder à une base de données tierce (Oracle, SQL Server, ...) via un Webservice. Pour plus de détails, consultez Accès à une base de données via un Webservice.
    Nouveauté 19
    Il est également possible d'accéder à une base de données tierce (Oracle, SQL Server, ...) via un Webservice. Pour plus de détails, consultez Accès à une base de données via un Webservice.
    Il est également possible d'accéder à une base de données tierce (Oracle, SQL Server, ...) via un Webservice. Pour plus de détails, consultez Accès à une base de données via un Webservice.
Menus de l'application
Dans une application Android, les options de l'application peuvent être proposées :
  • via le champ Action Bar. Cette solution est actuellement recommandée.
  • sous forme de menus (déconseillé).
Remarques sur les menus :
  • En édition, les menus des fenêtres Android sont présentés comme de simples menus déroulants.
  • A l'exécution, ces menus s'afficheront de façon différente en fonction du nombre d'options :
    • Si le menu comporte moins de 6 options, il s'affiche sous forme de gros boutons en bas de l'écran.
    • Si le menu comporte plus de 6 options, les 5 premières options s'affichent sous forme de gros boutons et un sixième bouton automatique "Plus" permet à l'utilisateur de voir la suite du menu sous forme d'un menu déroulant.
  • Les menus des applications Android ne supportent pas d'avoir plus d'un niveau de sous-menus. Au-delà, une erreur fatale se produit lors de l'exécution de l'application.

Menus contextuels

Les menus contextuels sont supportés par WINDEV Mobile pour les applications Android.
  • En édition, ils sont présentés comme les menus déroulants Windows mais ils adoptent l'apparence des menus Android à l'exécution.
  • Ils sont également limités à un seul niveau de sous-menu.
  • Sur les appareils ne disposant pas de "clic-droit" (les téléphones par exemple), les menus contextuels sont affichés après un "appui long" sur le champ auquel ils sont associés.
Fenêtres modales
Les fenêtres modales ne sont pas supportées par le système d'exploitation Android. La fonction Ouvre n'est pas autorisée.
Les fenêtres peuvent être ouvertes :
Pour passer une valeur de retour :
  • Lors de sa fermeture, une fenêtre (fille ou soeur) peut appeler une procédure locale de la fenêtre qui l'a ouverte afin de lui passer une valeur de retour. Il est également possible de renvoyer une valeur de retour via une variable globale.
  • Versions 18 et supérieures
    Il est possible de spécifier la valeur de retour grâce à la propriété ..ValeurRenvoyée de la fenêtre fille et de récupérer cette valeur via le traitement "Fermeture d'une fenêtre fille de la fenêtre" de la fenêtre mère.
    Nouveauté 18
    Il est possible de spécifier la valeur de retour grâce à la propriété ..ValeurRenvoyée de la fenêtre fille et de récupérer cette valeur via le traitement "Fermeture d'une fenêtre fille de la fenêtre" de la fenêtre mère.
    Il est possible de spécifier la valeur de retour grâce à la propriété ..ValeurRenvoyée de la fenêtre fille et de récupérer cette valeur via le traitement "Fermeture d'une fenêtre fille de la fenêtre" de la fenêtre mère.
Gestion du bouton "Retour" et du bouton "Home"

Bouton Retour

Tous les appareils sous Android disposent d'une touche spéciale "Retour" (symbolisée généralement par une petite flèche vers la gauche). Dans une application WINDEV Mobile, cette touche provoque la fermeture de la fenêtre en cours et l'exécution du traitement "Fermeture de la fenêtre". S'il s'agit de la premère fenêtre de l'application cela provoquera l'exécution du code de fermeture de l'application et donc la fermeture de l'application.
Une application doit être conçue de façon à se comporter convenablement si n'importe laquelle de ses fenêtres est fermée en utilisant la touche "Retour". En général, il suffit que chaque champ de la fenêtre soit initialisé avec une valeur par défaut ou que le bouton "Retour" soit considéré comme un bouton "Annuler".
Remarque : Il est possible de changer ce comportement et d'exécuter un traitement personnalisé (par exemple pour demander une confirmation à l'utilisateur et éventuellement ne pas fermer la fenêtre notamment s'il s'agit de la première fenêtre de l'application). Pour cela, la fenêtre doit posséder un bouton ayant la lettre d'appel "Bouton 'Back'" (onglet "IHM" de la fenêtre de description du champ).

Bouton Home/Accueil

L'appui sur le bouton "Accueil" (ou bouton "Home") ne ferme pas l'application en cours : l'application est mise en arrière-plan. Le traitement "Fermeture de la fenêtre" n'est donc pas exécuté.
Remarque : Même s'il y a dans la fenêtre un bouton avec comme lettre d'appel, définit dans l'onglet IHM, "Bouton 'Home' ", le code de ce bouton ne sera pas exécuté, contrairement au bouton Retour, il n'est pas possible de changer le comportement par défaut.
Un appui prolongé sur la touche "Home" permet de faire réapparaître la liste des applications lancées. L'utilisateur peut ainsi sélectionner son application lorsqu'il souhaite la remettre au premier-plan.
Remarque : Le système Android ne permet pas de proposer cette option par programmation.
Notification d'inactivité de l'application
Le système d'exploitation Android n'autorise pas une application à rester dans un traitement (sans rendre la main au système d'exploitation) pendant plus de quelques secondes. Si une application se trouve dans ce cas, Android affiche une boîte de dialogue proposant à l'utilisateur de fermer l'application ou d'attendre la fin du traitement :

Android : Application Non Responsive
Pour éviter le déclenchement de ce mécanisme, les phases de calcul ne doivent pas être placées dans le thread principal de l'application. Utilisez des procédures lancées dans des threads secondaires (consultez la fonction ThreadExécute pour plus de détails).
Remarque : Il est très fortement déconseillé de manipuler les éléments de l'IHM d'une application depuis un thread secondaire.
Les concepteurs d'Android recommandent qu'une action de l'utilisateur provoque une réaction perceptible de l'application en moins de 200 millisecondes pour donner une bonne impression de réactivité.
Fonctionnement du focus et de la sélection
Afin de gérer à la fois les IHM pilotées au doigt (ou à l'aide d'un stylet) et les IHM utilisables avec un clavier et un trackball, Android offre un système de gestion du focus et de la sélection différent des autres systèmes d'exploitation :
  • Le focus peut être déplacé uniquement avec une souris, un trackball ou un périphérique équivalent.
  • Lorsque le focus est déplacé, les traitements d'entrée et de sortie des champs sont exécutés.
  • Les champs cliquables mais non éditables (boutons, listes, etc.) se comportent comme des champs en interruption. Lorsqu'ils reçoivent un clic, ils ne prennent pas le focus.
  • Le traitement "Sélection d'une ligne" dans les listes et les zones répétées est exécuté uniquement lorsque la ligne est sélectionnée par un clic.
  • Le traitement "Sélection d'une ligne" dans les listes et les zones répétées n'est pas exécuté lorsque la ligne ayant le focus change.
Attention : Dans une liste ou une zone répétée, le bandeau affiché ne représente pas la sélection mais seulement le focus.
Zones répétées
Dans les applications Android, les champs Zone répétée sont toujours en mode "Affichage Seulement".Dans les applications Android, les champs Zone répétée peuvent être en saisie.
Remarque : Les champs Zone répétée permettent de remplacer les champs Table dans une application Android. En effet, le concept de "champ Table" n'existe pas sous Android. Les champs Table ne sont pas utilisés sous Android en règle générale pour les raisons suivantes :
  • L'interface des champs Table n'est pas appropriée.
  • Problème d'espace dans les fenêtres : les colonnes et les entêtes de colonnes ne pourraient pas être affichées.
  • La hauteur des lignes serait trop petite pour être manipulée avec les doigts.
  • Les champs Table ne sont pas utilisés dans les normes d'interface de ce système.
Ascenseurs automatiques dans les fenêtres
Si la hauteur d'une fenêtre est supérieure à la hauteur de l'écran et si la propriété "Ascenseurs Automatiques" est cochée dans la description d'une fenêtre, un ascenseur est automatiquement ajouté à droite de la fenêtre. Il est nécessaire de tenir compte de sa présence lors de la conception de la fenêtre afin que cet ascenseur ne recouvre pas les champs.
Utilisation de code Java natif dans une application Android
Il est possible d'utiliser du code Java natif dans une application Android.
La procédure à suivre est la suivante :
  1. Créer une procédure globale dans votre projet.
  2. Dans l'entête de la procédure, cliquez sur le logo "WL" pour changer le type de code de WLangage à Java :
    Java natif avant
  3. La procédure en code Java est affichée :
    Java natif après
  4. Saisissez le code Java directement dans l'éditeur de code de WINDEV Mobile.
Remarques :
  • Si le code Java natif ainsi saisi a besoin de permissions particulières pour être exécuté, vous devrez les définir explicitement lors de la génération de l'application. Pour plus d'information sur les permissions, consultez Génération d'une application pour Android.
  • Java est "case-sensitive" : veillez à respecter les minuscules et les majuscules dans les noms des fonctions.
  • Les classes et méthodes du SDK Android manipulent souvent une référence sur un objet de type "Context". Dans un projet Android, lors de la saisie de code natif, il est possible de récupérer un objet de type "Context" en obtenant une référence sur l'activité en cours ou sur le contexte de l'application grâce aux méthodes suivantes qui peuvent être appelées directement dans le code de la procédure en code natif :
    // Récupération de l'activité en cours
    getActiviteEnCours()

    // Récupération du "Context" en cours
    getContexteApplication()
  • Pour récupérer l'objet de type View correspondant au composant principal d'un champ, il faut utiliser la méthode getView en lui passant le nom du champ.
    Exemple : Le code suivant retourne l'instance de la classe "Button" utilisée par le champ :
    getView("BTN_Bouton1")
Types des paramètres des fonctions
Sous Android, les déclarations de type des paramètres des procédures et des méthodes de classes sont ignorées à la compilation de l'application.
En conséquence, il n'est pas possible :
  • de déclarer un paramètre d'un type avancé et d'utiliser directement ses propriétés.
  • de déclarer un paramètre d'un type et d'utiliser un autre type.
Une telle utilisation provoquera une erreur d'exécution. Il est nécessaire de passer par une variable locale intermédiaire.
Par exemple, dans le code suivant :
PROCEDURE MaProcédure(dhDateDebut est un DateHeure)
Info(DateVersChaîne(dhDateDebut..PartieDate))
la déclaration du type DateHeure est ignorée. Si le paramètre passé à la procédure n'est pas de type DateHeure, une erreur d'exécution sera affichée.
Il est conseillé d'écrire :
PROCEDURE MaProcedure(dhDateDebut)

// Code de déclaration des variables
// Permet de faire la conversion de type si nécessaire

dhDateHeureDebutLocal est un DateHeure
dhDateHeureDebutLocal = dhDateHeureDebut

Info(DateVersChaîne(dhDateHeureDebutLocal..PartieDate))
Gestion des répertoires
La gestion des répertoires sous Android présente les particularités suivantes :
  • Par défaut, le répertoire courant d'une application correspond au sous-répertoire "files" qui est automatiquement créé à la racine du répertoire d'installation de l'application.
  • Les chemins relatifs manipulés par l'application sont relatifs à ce répertoire.
  • Le chemin complet du répertoire en cours peut être connu avec la fonction fRepEnCours. Par défaut, il est possible de lire et écrire dans ce répertoire.
  • Le répertoire en cours peut être modifié par la fonction fRepEnCours.
  • Le répertoire d'exécution (retourné par la fonction fRepExe) correspond au répertoire d'installation de l'application. Par défaut les applications sont toujours installées dans le répertoire /data/data/<nom du package>.<nom de l'application>.
  • Sous Android, sur l'appareil comme sur l'émulateur, le système de fichiers est en lecture seule. Une application a uniquement le droit d'écrire dans son répertoire d'installation ou dans un de ses sous-répertoires, ainsi que sur la mémoire externe (SDCard).
  • Le répertoire "databases" est également automatiquement créé à la racine du répertoire d'installation de l'application pour stocker les bases de données SQLite manipulées par l'application (à moins qu'un chemin spécifique n'ait été spécifié au moment de la connexion). Le chemin du répertoire "databases" peut être connu grâce à la fonction fRepDonnées.
  • Pour avoir un emplacement de stockage commun à plusieurs applications, utilisez la mémoire externe (SDCard par exemple). Le chemin de la mémoire externe peut être connu grâce à la fonction SysRepCarteStockage. Pour avoir un emplacement de stockage commun à plusieurs applications, utilisez la mémoire externe (SDCard par exemple). Le chemin d’un répertoire pour le stockage de fichiers dans l'espace de stockage externe peut être connu grâce à la fonction SysRepStockageExterne.
  • Si l'utilisateur connecte son appareil au PC en mode “stockage de masse” (ou "lecteur de disque”), la SD Card est automatiquement démontée de l'appareil et n'est plus accessible depuis celui-ci. Toutes les applications installées sur la SD Card et en cours de fonctionnement sont alors tuées. Tant que la SD Card sera démontée, il ne sera pas possible de :
    • lancer les applications installées sur la SD Card.
    • accéder à la SDCard depuis les applications exécutées sur le téléphone.
Pour plus de détails sur la gestion des répertoires de l'application, consultez :
Changement d'orientation de l'écran
Pour détecter le changement d'orientation de l'écran, utilisez le traitement de changement de taille des fenêtres.
Versions 16 et supérieures
Il est également possible d'utiliser les fonctions CapteurXXXX pour détecter les mouvements du téléphone.
Nouveauté 16
Il est également possible d'utiliser les fonctions CapteurXXXX pour détecter les mouvements du téléphone.
Il est également possible d'utiliser les fonctions CapteurXXXX pour détecter les mouvements du téléphone.
Remarque : La famille de fonctions GPS permet de gérer la géolocalisation du téléphone.
Divers
  • Sous Android, pour des raisons de sécurité, les touches "Home" et "Fin d'appel" ne peuvent pas être utilisées comme lettres d'appel.
  • Versions 17 et supérieures
    Les gabarits "ActivAndroid 4-HoloDark" et "ActivAndroid 4-HoloLight" permettent d'utiliser les thèmes holographiques disponibles à partir d'Android 4. Si l'application est utilisée avec une version d'Android gérant les thèmes holographiques, le thème est utilisé nativement pour l'application. Dans le cas contraire, le gabarit WINDEV Mobile et les images du gabarit choisi seront utilisés.
    Nouveauté 17
    Les gabarits "ActivAndroid 4-HoloDark" et "ActivAndroid 4-HoloLight" permettent d'utiliser les thèmes holographiques disponibles à partir d'Android 4. Si l'application est utilisée avec une version d'Android gérant les thèmes holographiques, le thème est utilisé nativement pour l'application. Dans le cas contraire, le gabarit WINDEV Mobile et les images du gabarit choisi seront utilisés.
    Les gabarits "ActivAndroid 4-HoloDark" et "ActivAndroid 4-HoloLight" permettent d'utiliser les thèmes holographiques disponibles à partir d'Android 4. Si l'application est utilisée avec une version d'Android gérant les thèmes holographiques, le thème est utilisé nativement pour l'application. Dans le cas contraire, le gabarit WINDEV Mobile et les images du gabarit choisi seront utilisés.
    Tous les gabarits appliquent le thème holographique à partir de Android 5.
    Remarque : Pour utiliser le thème "Material Design", dans l'onglet "Général" de la description de la configuration Android, cochez l'option "Appliquer le thème Matérial Design aux champs natifs et aux fenêtres Info/Erreur/Dialogue (nécessite Android 5.0 ou supérieure)".
  • Versions 20 et supérieures
    Gestion des images selon le DPI : Selon le DPI de l'appareil, les images peuvent être pixelisées ou floues. Il est possible d'utiliser la gestion automatique des DPI. Pour plus de détails, consultez Android/iOS : Fournir une image par DPI.
    Nouveauté 20
    Gestion des images selon le DPI : Selon le DPI de l'appareil, les images peuvent être pixelisées ou floues. Il est possible d'utiliser la gestion automatique des DPI. Pour plus de détails, consultez Android/iOS : Fournir une image par DPI.
    Gestion des images selon le DPI : Selon le DPI de l'appareil, les images peuvent être pixelisées ou floues. Il est possible d'utiliser la gestion automatique des DPI. Pour plus de détails, consultez Android/iOS : Fournir une image par DPI.
Gestion des threads
La fonction ThreadArrête n'est pas disponible sous Android.
Seul le thread lui-même peut s'arrêter en sortant de la procédure WLangage appelée par la fonction ThreadExécute.
Exemple :
ThreadExécute("th", threadNormal, ProcThread)
PROCEDURE ProcThread

bThreadEnVie est un booléen = Vrai
TANTQUE bThreadEnVie

// ... Traitement

// Teste de la condition de fin du thread
SI <CONDITION FIN THREAD> ALORS
bThreadEnVie = Faux
FIN
FIN
Opérateurs d'indirection
Les indirections sont gérées uniquement sur les variables globales.
Une indirection sur une variable locale d'un traitement provoquera l'erreur "élément inconnu".
Utilisation des polices natives Android
Versions 19 et supérieures
Les polices suivantes peuvent être utilisées :
  • Droid Sans -> toutes versions d'Android
  • Droid Sans Mono-> toutes versions d'Android
  • Droid Serif -> toutes versions d'Android
  • Roboto -> à partir d'Android 4.0 (Ice Cream Sandwich, api level 14)
  • Roboto Condensed -> à partir d'Android 4.1 (Jelly Bean, api level 16)
  • Roboto Light -> à partir d'Android 4.1 (Jelly Bean, api level 16)
  • Roboto Thin -> à partir d'Android 4.2 (Jelly Bean MR1, api level 17)
Si la police spécifiée n'est pas supportée en exécution sur l'appareil, une police de substitution sera utilisée (Droid Sans ou Roboto à partir d'Android 4.0)
Nouveauté 19
Les polices suivantes peuvent être utilisées :
  • Droid Sans -> toutes versions d'Android
  • Droid Sans Mono-> toutes versions d'Android
  • Droid Serif -> toutes versions d'Android
  • Roboto -> à partir d'Android 4.0 (Ice Cream Sandwich, api level 14)
  • Roboto Condensed -> à partir d'Android 4.1 (Jelly Bean, api level 16)
  • Roboto Light -> à partir d'Android 4.1 (Jelly Bean, api level 16)
  • Roboto Thin -> à partir d'Android 4.2 (Jelly Bean MR1, api level 17)
Si la police spécifiée n'est pas supportée en exécution sur l'appareil, une police de substitution sera utilisée (Droid Sans ou Roboto à partir d'Android 4.0)
Les polices suivantes peuvent être utilisées :
  • Droid Sans -> toutes versions d'Android
  • Droid Sans Mono-> toutes versions d'Android
  • Droid Serif -> toutes versions d'Android
  • Roboto -> à partir d'Android 4.0 (Ice Cream Sandwich, api level 14)
  • Roboto Condensed -> à partir d'Android 4.1 (Jelly Bean, api level 16)
  • Roboto Light -> à partir d'Android 4.1 (Jelly Bean, api level 16)
  • Roboto Thin -> à partir d'Android 4.2 (Jelly Bean MR1, api level 17)
Si la police spécifiée n'est pas supportée en exécution sur l'appareil, une police de substitution sera utilisée (Droid Sans ou Roboto à partir d'Android 4.0)
Gestion des logs ADB

Débogage d'applications déployées via les logs ADB

Lorsqu’une application est déployée, les éventuelles erreurs de l’application qui se produisent chez les utilisateurs finaux sont mises à disposition du concepteur de l’application dans le "log ADB".
Il est ainsi possible de récupérer les erreurs, mais également les Asserts et les traces de tous les matériels qui exécutent l’application. Les messages suivants sont écrits dans le log ADB :
  • Messages de la fonction Trace(niveau "Info").
  • Messages de la fonction dbgSortieStandard (niveau "Debug").
  • Versions 22 et supérieures
    Messages des asserts (fonctions dbgAssertion, dbgVérifiexxx, dbgErreur(niveau "Assert").
    Nouveauté 22
    Messages des asserts (fonctions dbgAssertion, dbgVérifiexxx, dbgErreur(niveau "Assert").
    Messages des asserts (fonctions dbgAssertion, dbgVérifiexxx, dbgErreur(niveau "Assert").
  • Versions 22 et supérieures
    Messages des erreurs fatales et non fatales (niveau "Error").
    Nouveauté 22
    Messages des erreurs fatales et non fatales (niveau "Error").
    Messages des erreurs fatales et non fatales (niveau "Error").
Le "log ADB" est accessible :
  • sur chaque téléphone. Des logiciels spécifiques permettent de traiter et de visualiser le contenu de ce fichier.
  • via l'outil "Monitor" disponible dans le SDK Android. Dans ce cas, il est possible de visualiser dans l'onglet "Log cat" les logs ADB de toutes les applications situées sur le périphérique connecté au PC (le périphérique doit avoir le mode "Débuggage USB" activé. Pour plus de détails, consultez Préparation du téléphone pour tester une application Android).
Impression au format PDF
Sous Android, les impressions PDF supportent uniquement les polices standards Adobe (non Unicode) : Courrier, Helvetica, Times, Symbol et ZapFDingbats.
Version minimum requise
  • Version 15
Commentaires
Echange de données entre l'application WM et le code JAVA
Depuis la version 17, les procédures locales ou globales écrites en WL dans l'application peuvent être appelées à partir du code Java.

Cette fonctionnalité est décrite dans la page de doc :
http://doc.pcsoft.fr/fr-fr/?9000011&name=saisir-code-java

ATTENTION toutefois : dans la procédure appelée, si vous devez manipuler des éléments d'une fenêtre, vous risquez un plantage si l'appel dans java se fait dans un thread secondaire. Ceci peut être le cas lorsque vous avez crée un listener, une classe ou une interface, avec la commande "new".

Dans ce cas, il faut passer par un "proxy" :

====code java============
appelProcedureWL("ProcedureProxy",<param>)
======================

====code WL Procedure Proxy====
ExécuteThreadPrincipal(MaProcedure,<param>)
========================

====code WL MaProcedure======
<manipulation éléments fenêtre avec les params>
========================
jjmonot
03 juin 2013
Exemple d'utilisation de getView
Si dans votre fenêtre vous créez un champ libellé appelé "LIB_texte", alors vous pouvez écrire dedans avec un appel natif Java dans une procédure globale (appelée par un bouton par exemple) :

======
import android.content.Context;
import android.widget.TextView;

public static void afficheText()
{

// Variables
Context tmpContext = getContexteApplication();
TextView myTextView;

myTextView = (TextView) getView ("LIB_texte");
myTextView.setText("hello world");

}
=============

REMARQUE : le code NE FONCTIONNE PAS dans le SIMULATEUR WM !! Il faut utiliser un vrai téléphone ou tablette, ou utiliser un émulateur ANDROID.

========= COMPLEMENTS 3/6/2013 ===========
Cette manière d'accéder directement aux éléments de la fenêtre peut provoquer un plantage violent de l'application, quant cet appel est fait par exemple dans un listener (pour le GPS) créé dynamiquement. En effet, la fenêtre et ses éléments vont appartenir au thread principal alors que le listener est placé dans un thread secondaire. La manipulation des éléments du thread principal par le thread secondaire provoque l'arrêt de l'application.
jjmonot
03 juin 2013
déclaration de méthodes et de classes en code java natif
En Java sous Android, dans le code natif d'une procédure il est tout à fait possible de déclarer plusieurs méthodes (privées ou pas), des classes, etc.

Il y a cependant deux réserves :
- Seule la première méthode déclarée dans le traitement pourra être appelée directement depuis le WLangage. (Nouvelle_Procédure1 dans le cas de l'exemple)
- Il ne faut pas oublier les imports (Ils peuvent être insérés n'importe où dans le code)

========== exemple 1 ==================
public static void NouvelleProcedure1 ()
{
Nouvelle_procedure2 ();
Nouvelle_procedure3 ();
}

private static void Nouvelle_Procedure2 ()
{
}

private static void Nouvelle_Procedure3 ()
{
}

=========== exemple 2 ==============
public static void NouvelleProcedure ()
{

MaClasse m = new MaClasse ();
}

public static classe MaClasse ()
{
public MaClasse ()
{
}
}
jjmonot
18 jan. 2012