# 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