8. Licence et mode démo #

← FAQ et dépannage · Sommaire

PBToolboxAI est une bibliothèque commerciale. Le contrôle de licence est entièrement hors ligne : aucune connexion, aucune activation, aucun appel serveur. Une clé signée est posée au démarrage, la DLL la vérifie localement.

8.1 Les trois types de clés #

Les clés sont cumulables : appelez PBT_SetLicense autant de fois que nécessaire, la bibliothèque retient une clé par type.

Type	Porteur	Débride
`dev`	Nominative, un développeur	Uniquement dans l'IDE PowerBuilder
`runtime`	Votre société, embarquée dans l'application livrée	Uniquement dans un exécutable compilé
`demo`	Fournie avec l'application de démonstration	L'application de démonstration, dans l'IDE, jusqu'à expiration

Un projet a donc besoin des deux : un siège dev par développeur, et une clé runtime pour l'application livrée à vos clients.

Une clé dev qui se retrouverait dans un exécutable ne débride rien.
Une clé runtime ne donne aucun poste de développement.
Vos clients finaux n'ont rien à saisir, rien à activer : la clé runtime est dans votre code.

La détection « IDE ou exécutable » est faite par la DLL elle-même (nom du process, modules design-time chargés), pas par du code PowerBuilder — elle ne peut pas être contournée depuis vos sources.

8.2 Poser la clé #

Une seule chose à faire, avant l'ouverture de la première fenêtre :

// Declaration - objet application, "Local External Functions"
Function long PBT_SetLicense (string as_client, string as_key) Library "pbtoolboxai.dll"

// Event open de l'objet application
long ll_rc
string ls_cle_dev

// La cle RUNTIME va dans le code : elle DOIT partir dans l'exe livre.
ll_rc = PBT_SetLicense(gs_titulaire, gs_cle_runtime)

// La cle DEV se lit sur le poste : elle ne debride que l'IDE, et embarquee
// dans le code elle partirait dans chaque copie livree sans y servir a rien.
ls_cle_dev = ProfileString("pbtoolboxai.ini", "license", "dev", "")
if ls_cle_dev <> "" then ll_rc = PBT_SetLicense(gs_titulaire, ls_cle_dev)

Open(w_principale)

La clé se pose par la fonction de la DLL, jamais par une méthode de composant : elle vaut pour tout le processus et doit être posée avant qu'aucun composant n'existe. C'est pour cette même raison que PBT_LicenseStatus ne demande aucun handle.

Le titulaire est passé en clair, en premier argument : c'est le nom (ou l'adresse e-mail) sous lequel la licence a été émise, et il doit correspondre à celui que porte la clé signée. Une clé ne peut donc pas circuler sans le nom de qui l'a achetée.

Retour	Signification
`0`	Clé valide et retenue
`-1`	Format de clé invalide
`-2`	Signature invalide (clé altérée ou étrangère)
`-3`	Maintenance expirée pour cette version de la bibliothèque (voir 8.5)
`-4`	Clé `demo` expirée
`-5`	Le titulaire passé ne correspond pas à celui de la clé

💡 Où mettre quelle clé. La clé runtime appartient au code : elle doit se retrouver dans l'exécutable que vous livrez. La clé dev, elle, n'a rien à y faire — elle ne débride que l'IDE, donc dans un exe elle ne sert à rien tout en s'y promenant, avec le nom de votre société. Sa place est un fichier pbtoolboxai.ini à côté de l'IDE, ou une valeur dans la base de registre.

Poser la clé après la création d'un composant fonctionne aussi : les composants déjà ouverts se débrident immédiatement. Mais le plus simple reste l'event open de l'application.

💡 Conservez la clé dans une constante ou une ressource de votre application. Elle est signée : elle ne contient aucun secret exploitable et ne peut pas être modifiée sans invalider sa signature.

8.3 Vérifier l'état de la licence #

// Declaration
Function long PBT_LicenseStatus (ref string as_json, long al_len) Library "pbtoolboxai.dll"

string ls_statut

ls_statut = Space(1024)
PBT_LicenseStatus(ls_statut, 1024)
// -> {"licensed":true,"ide":false,"keys":{...},"reason":""}

Utile en phase d'intégration pour vérifier qu'une clé est bien prise en compte, ou pour tracer un démarrage dans votre journal applicatif.

8.4 Le mode démo #

Sans clé valide — ou avec une clé qui ne s'applique pas au contexte (une clé dev dans un exe, par exemple) — la bibliothèque fonctionne en mode démo : tout est utilisable, tout est visible, mais avec des limites — sauf les quatre composants de l'édition communauté, décrits juste en dessous, qui ne sont jamais bridés.

Quatre composants restent gratuits #

L'édition communauté n'a rien à poser : sans aucune clé, quatre composants fonctionnent sans badge et sans limite, indéfiniment.

Composant	Ce qu'il apporte
statictext	Libellé à balises : gras, couleurs, liens, puces, blocs repliables
messagebox	Boîte de dialogue thémée, modale, à boutons libres
toaster	Notifications en coin d'écran, avec titre, image et actions
webbrowser	Navigateur WebView2 hébergé dans une fenêtre PowerBuilder

Ce choix est délibéré : ce sont les quatre que l'on rencontre en premier, ils ne portent aucun modèle de données, et ils suffisent à prouver sur un poste verrouillé que le runtime se déploie — l'obstacle réel avant tout achat.

La liste vit dans la DLL. PBT_LicenseStatus la renvoie telle quelle, dans "free" : votre application peut donc annoncer ce à quoi elle a droit sans clé, plutôt que de le découvrir composant par composant.

Une clé valide prime toujours : sur ces quatre composants comme sur les autres, elle rétablit votre nom et votre édition.

Le badge #

Chaque composant affiche un badge « PBToolboxAI — DEMO », non masquable.

Les limites fonctionnelles #

Composant	Limite en mode démo
tab	3 pages maximum
ribbon	2 onglets maximum
toolbar	6 items affichés, toutes barres confondues
tilesbox	8 tuiles affichées
Tous les autres	Badge uniquement — aucune limite fonctionnelle

Ces limites s'appliquent au rendu : rien n'échoue, l'affichage est tronqué. Vous pouvez donc évaluer chaque composant réellement, sur vos données, avant d'acheter.

Poser une clé valide lève instantanément toutes ces limites et retire le badge, sans redémarrer l'application.

8.5 Perpétuel + maintenance #

La licence est perpétuelle : les versions couvertes par votre période de maintenance fonctionnent pour toujours, y compris après l'expiration de celle-ci.

Concrètement, la clé porte une date de fin de maintenance, comparée à la date de compilation de la DLL :

une version de la bibliothèque publiée pendant votre maintenance est débridée définitivement ;
une version publiée après l'expiration renvoie -3 : renouvelez la maintenance pour y accéder ;
vos applications déjà livrées ne sont jamais affectées : elles embarquent la version qu'elles ont toujours utilisée.

8.6 Questions fréquentes #

Ma clé est-elle vérifiée en ligne ? Non. Aucun réseau, jamais. La vérification est une signature RSA validée localement par Windows.

Mes clients ont-ils besoin d'une clé ? Non. Votre clé runtime est dans votre application ; ils ne voient jamais rien de la licence.

Que se passe-t-il si j'oublie PBT_SetLicense en production ? L'application fonctionne, mais chaque composant affiche le badge démo et les limites du tableau ci-dessus s'appliquent. C'est le premier point à vérifier si un badge apparaît chez un client.

Puis-je poser une clé dev et une clé runtime dans le même code ? Oui — c'est même le cas courant : la dev sert quand vous exécutez depuis l'IDE, la runtime quand vous exécutez l'exe. Chacune est ignorée dans l'autre contexte.

Le badge apparaît alors que la clé est posée. Trois causes, par ordre de fréquence : (1) clé dev alors que vous exécutez un exe compilé, ou l'inverse ; (2) retour de PBT_SetLicense non testé — vérifiez qu'il vaut 0 ; (3) maintenance expirée pour la version de DLL installée (retour -3). PBT_LicenseStatus tranche en une ligne.

Une clé est nominative. Une clé dev est liée à un développeur, une clé runtime à votre société. Ne les partagez pas hors de votre équipe.

← FAQ et dépannage · Sommaire