Le forum (ô combien francophone) des utilisateurs de Powerbuilder.
Bonjour,
J'ai un projet sous PowerBluider 11.1 Bluid 8123. Lorsque j’exécute ce projet j'ai un souci car les fenêtres ne sont pas automatiquement adaptées à la résolution de mon écran.
Pour plus de précision, les programmes s'affichent normalement sur un écran 1284*1024, par contre mon écran a une résolution de 1152*864.
J'aimerai si possible que vous puissiez m'indiquer comment faire pour que mes windows et mes frames se dimensionnent automatiquement en fonction de l'écran qui se chargeront de les afficher.
Ce projet est un projet Client-Serveur
Merci et Bonne journée.
Hors ligne
environment myEnv GetEnvironment(myEnv) messagebox("Screen Resolution",String(myEnv.ScreenWidth) + "x" + String(myEnv.ScreenHeight))
Hors ligne
Bonjour,
Comment est ce que j'adapte cela à mes Windows ou mes frames?
Merci pour ta promptitude.
Hors ligne
Bonjour,
Pour que la fenêtre prenne tout l'écran (à son ouverture) c'est la propriété de la fenêtre : windowstate = maximized!
Hors ligne
Mon problème c'est que je voudrai qu'à l'ouverture de mon logiciel, que ce soit sur un écran 14", 15", 17" ou 19", que les différentes fenêtres de mon application puisse s'adapter automatiquement à l'écran.
Merci
Hors ligne
Tu veux parler de la taille de la fenêtre ?
Si c'est le contenu, il n'y a rien de natif.
Hors ligne
Bonjour,
On a développer une application et les différentes fenêtres de notre application s'affiche bien lorsqu'il s'agit d'un écran 17". Par contre, si l'écran sur le quel est déployer l'application finale à une résolution inférieure à 1284*1024 alors les fenêtres de notre application ne sont plus bien affichés. Elles s'affichent avec des tailles énormes qui font que l'application devient bizarre. En fait ce que je demande c'est compte tenu de cette situation, Y'a t'il un moyen pour nous même de rendre l'affichage des fenêtres de notre application en fonction de l'écran sur lequel il sera déployé? De telle en sorte qu'à l'ouverture, le programme calcule automatiquement la résolution de l'écran et adapte les différentes fenêtres de l'application en fonction de celle- ci.
Meri
Hors ligne
Depuis les moniteurs de type dalle les résolutions d'écran sont natives on peut être en dessous (par extrapolation) mais pas au dessus.
Il n'y a donc pas de solution dans votre cas (sauf à refaire tous les écrans avec une autre cible de résolution)...donc pas de problème.
Dernière modification par Dadone (03-10-2013 14:56:21)
Hors ligne
Bonsoir,
Il n'existe rien de natif, mais il est tout a fait envisageable d'ouvrir vos fenêtre en fonction de la résolution d'écran.
Il faut surtout savoir ce que vous attendez lorsqu'une fenêtre s'affiche dans une résolution supérieure ou inférieure.
question : Les contrôles doivent t'il s'aggrandir (hauteur et largeur ) en conservant la taille des fontes ou faut t'il un effet de zoom sur le fenêtre powerbuilder.
Les boutons doivent t'il conserver leur espacement avec le bord de la fenêtre ou doivent t'il également être aggrandi ( cas du zoom)
etc...
L'important étant de designer vos écran dans la plus petite des résolutions envisagés car si tel n'est pas le cas on peut imaginer une fenêtre designer en 1284*1024 et quelle soit affichée sur un écran 800*600 alors la réduction aura pour effet de rendre quasiment illisible les caractères.
Certains framework proposent des solutions pour effectuer celà. C'est le cas par exemple des PFC de SYBASE que j'ai utilisé dans un projet il y a 1 an ou justement on m'a demandé d'affiché les fenêtres en fonction de la résolution. ( écran 17 , 19 et 21 pouces). j'y ai même intérgré une règle supplémentaire lorsque l'utilisateur a 2 écrans et qu'il bascule son appli Pb sur le deuxième écran.
cdt
Yanis
Hors ligne
Merci Yanis pour tes remarques,
Peux-tu m'aider dans cette tâche?
Merci
Hors ligne
un truc qui pourrait être utile, c'est les nv_auto_resizer, u_splitbar_horizontal et u_splitbar_vertical d'xlat qui permettent d'ancrer des contrôles sur l'un ou plusieurs bords de l'écran et de faire facilement des split bars.
Si on ancre un objet (liste, datawindow, ...) en même temps à gauche et à droite, quand la fenêtre s'agrandit l'objet est étiré horizontalement, de même si on l'ancre en haut et en bas (si on ne l'ancre qu'à droite ou qu'en bas, il se déplacera en même temps que la bordure).
Pour récupérer ces composants et voir un exemple d'utilisation, regarde PBRegexCoach, l'outil de test de mon extension pbniregex.
Hors ligne
Salut,
Tout dépend du niveau d'aide que tu attends. Tout d'abord exprime moi ton besoin réel et décrit comment doit se comporter ta fenêtre à l'ouveture lorsque la résolution de l'écran ne correspond pas à celle du devt. ( ex : tu as une fenetre avec des controles datawindow , des boutons , des onglets avec à l'intérieur des controles datawindow etc....).
Pas de problème pour t'aider , t'orienter , te fournir des petits bouts de code etc.. mais je ne pourrais pas refaire à ta place ce service de manière complète ( tu comprendras que j'ai également une activité de mon coté )
Cdt
Yanis
Hors ligne
Bonsoir à vous,
Il y'a en place un projet PowerBluider où il existe une fenêtre d’authentification, un fenêtres d’accueil et les différents menus qui y sont joints avec des fenêtres Windows correspondant à ces menus. Ce que je voudrai, c'est qu'une fois un utilisateur authentifié, avant que la frame princiaple ne se présente à lui, le programme prend en compte de façon automatique la résolution de l'écran et ajuste l'affichage de la frame principale en fonction de cette résolution. De même, une fois la frame principale affiché en fonction de la résolution de l'écran, les autres fenêtres qui devront être appelées devraient suivre le même principe et ce maintenant en fonction de l'affichage de la frame princiaple, car je pense que si on s'en tient à celle de l'écran, on risquerait de ne pas avoir de bonne affichage. Par la suite, si sur un Pbobject de type Window, il des boutons, des onglets, et..., ceux ci devront être gérer de façon similaire pour qu'il puisse avoir une uniformité.
Je pense avoir été claire, et concernant le niveau d'aide, un procédé qui décrirait pas à pas comment y arrivé sera la bienvenu
Merci et bonne soirée à vous.
Hors ligne
Yanis a écrit:
Tout d'abord exprime moi ton besoin réel et décrit comment doit se comporter ta fenêtre à l'ouveture lorsque la résolution de l'écran ne correspond pas à celle du devt. ( ex : tu as une fenetre avec des controles datawindow , des boutons , des onglets avec à l'intérieur des controles datawindow etc....).
Yanis
Décris précisément le comportement que tu attends de tes fenêtres et de leurs contenu... j'ai l'impression de lire un "cahier décharges" de ce qu'il y a de plus flou et ca me rappelle trop le boulot là
Hors ligne
Bonsoir,
Ce que je dis simplement c'est que, lorsque à l'ouverture, la résolution d'écran ne correspond pas à celle du développement, que le programme se charge de redimensionner toutes les fenêtres ainsi que les composants qui y sont en fonction de la nouvelle résolution pour permettre ainsi de garder la beauté du design que l'on s'est donné pendant la phase de développement.
Merci et en espérant avoir assez été claire.
Hors ligne
Il n'y a pas de formule magique miracle qui va tout faire tout seul
Il va te falloir un objet/fonction (par exemple le nv_auto_resizer de xlat pointé par seki) pour positionner/redimensionner tes contrôles dans les fenêtres
Il va falloir tes fenêtres soient héritées d'une fenêtre ancêtre qui appelle le resizer dans l'event resize _OU_ il faut que tu modifies toutes tes fenêtres pour faire la même chose
Les resizer ne fonctionnent pas tout seul, il faut leur dire pour chaque objet comment tu veux les ancrer à la fenêtre (cela va déterminer pour chaque contrôle si ils doivent être repositionnés et/ou redimensionnés)
Ca c'est juste la partie qui gère la position des contrôles
Après pour la seconde partie: Le redimensionnement automatique des frames
Comme Yanis l'a déjà souligné il faut designer les fenêtres sur la résolution minimale car au moins on est sûrs que tout rentre. Si tu as une fenêtre de 1000*1000 bien remplie si tu la redimensionnes en 500*500 il va y avoir des disparitions...
Il t'a été indiqué plus haut comment récupérer la résolution d'écran
A partir de là dans le open des fenêtres tu peux comparer la résolution actuelle à la résolution de dev et poster un resize qui va lui appeler le resizer etc...
J'espère pour toi que tu n'as pas trop de fenêtres dans ton application et que tout est hérité sinon ça va être une bataille de tranchées.
En tout cas bon courage
Hors ligne
Bonjour,
Les étapes doivent être les suivantes.
- A l'ouverture de chaque fenêtre enregistrer la taille initiale ( Hauteur/Largeur : tu doit obtenir les valeurs de développement de ta fenêtre ) de la fenêtre ainsi que la taille et la position de chaque contrôle graphique.
- Ensuite dans l'evt resize de la fenêtre calculer le ratio(%) en X et en Y d'augmentation ou de baisse de la taille de la fenêtre ( l'evt resize contient en argument la nouvelle taille )
- Appliquer ce ratio à chaque contrôle graphique de la fenêtre
- Si tu fonctionnes avec une application ayant un cadre MDI, ouvre le cadre MDI avec la propriété Windowstate à maximized!. Celà aura pour effet de mettre ta frame à la taille maximale de ton écran quelque soit sa résoluton.
- Puis ensuite pour les fenêtres sheet met leurs la propriété WindowState à normal! et quand tu les ouvres avec la fonction openSheet, ouvrent les en Layered! ( paramètre de la fonction opensheet )
Cdt
Yanis
Hors ligne
Pour obtenir la taille initiale de chaque fenêtre tu peux
Soit la stocker dans des variables d'instance (mais il faut penser à les changer si tu redimensionne la fenêtre dans ton atelier)
Soit utiliser un truc dans le genre, j'ai utilisé ça pour le resizer que j'ai utilisé dans mon mini-framework pour que les objets dans un visual object soient redimensionné automatiquement si le user object dans la fenêtre n'a pas la même taille que la version originale. Il faut le réadapter à tes besoins.
graphicobject lgo_objet_conteneur classDefinition lcd_obj, lcd_ancestor int li_cpt, li_count boolean lb_trouve_hauteur, lb_trouve_largeur variableDefinition lvd_var lgo_objet_conteneur = adrg_objet_contenu.getParent() if ab_constructor then lcd_obj = lgo_objet_conteneur.classDefinition lcd_ancestor = lcd_obj.ancestor if lcd_ancestor.datatypeof = "userobject" and lcd_ancestor.name <> "u_customvisual" then li_count = upperBound(lcd_ancestor.variablelist) lb_trouve_hauteur = false lb_trouve_largeur = false li_cpt = 0 do while li_cpt < li_count and not (lb_trouve_hauteur and lb_trouve_largeur) li_cpt++ lvd_var = lcd_ancestor.variablelist[li_cpt] if lvd_var.name = "width" then ll_largeur = long(lvd_var.initialValue) lb_trouve_largeur = true end if if lvd_var.name = "height" then ll_hauteur = long(lvd_var.initialValue) lb_trouve_hauteur = true end if loop end if end if
Il faut aussi penser aux bordures de tes fenêtres qui vont changer selon le thème de Windows (je peux donner un peu de code aussi mais ça se trouve facilement)
Dernière modification par _francois_ (07-10-2013 08:32:34)
Hors ligne
Bonjour cher tous,
Je suis de retour malgré quelques soucis, mais bon, que pensez vous du fait que:
1- On a la possibilité de récupérer l résolution de l'écran comme indiqué ci-haut
2- Chaque composant(Bouton, ListBox, Picture, et...) ont chacun un width et un height
3- Je voudrai écrire une fonction qui permettra d'affecter un nouveau width et un nouveau height à chaque composant de ma fénêtre pour forcer le redimensionnement de ceux-ci, si au préalable ma fenêtre ne s'affiche pas correctement.
Questions: Quelle est la relation qui lie un witdh et un heigth aux dimensions d'un écran? par exemple si j'ai une fenêtre qui s'affiche normalement sur un écran de 1284*1024 et qui a un width=5714 et height=3624, quelle serai le width et le height de cette fenêtre si on était à 800*600 comme résolution d'écran.
D'un autre côté, pouvez vous monsieur @_francois_ expliquer ce code car je ne comprends pas
Dans l'espoir que je me suis fait comprendre
Bonne journéé à tous.
Hors ligne
Bonjour, il y a PixelsToUnits et UnitsToPixels pour faire les conversions.
Hors ligne
Mon code ne peut être repris tel quel c'était un exemple d'utilisation des classdefinition
Dans mon cas c'était pour des userobject dans ton cas ce sera plutôt pour des Window
Il ne te sera utile que si tu veux connaitre la taille "Atelier" de ta fenêtre
J'ai utilisé dans mon code des GraphicObject et DragObject pour être générique car j'appelle la fonction pour tous les objets de mon application.
En gros (je vais partir du principe que c'est pareil pour les window):
Dans mon atelier j'ai une classe objet visuelle u_toto qui a comme dimension 500*500
Dans une fenêtre j'instancie un objet uo_mon_toto de type u_toto et je lui donne comme dimension 700*800
Au moment de la construction de uo_mon_toto si je demande sa taille PB va me répondre 700*800
Mais moi je veux connaitre sa taille atelier c'est à dire 500*500
Le code sert à ça
Tu demandes la classdefinition de ta fenêtre
lcd_fen = lw_fen.classDefinition
Je suppose que si tu as spécifié le windowtype dans ton open il faut travailler sur le .ancestor et sinon non (je dis peut-être une grosse connerie là)
lcd_ancetre = lcd_fen.ancestor
Les classDefinition ont une propriété "variableList"
"variableList" est en fait un tableau de "variableDefinition"
Une variableDefinition a un nom "name" qui te permet de savoir quelle est la variable en question (dans notre cas nous recherchons width et height)
Une fois trouvé les bonnes variableDefinition on peut récupérer le "initialValue"
C'est à dire les valeurs de width et height dans l'atelier et non dans la version instanciée dans l'application client.
J'espère avoir été un poil plus clair
après si tu ne veux pas t'embêter tu stockes la taille manuellement dans des variable au niveau de ton atelier.
Hors ligne
Hi all,
Pour ma part, je mets un peu de code dans l'évènement resize() de la fenêtre et je m'appuie sur la taille de la fenêtre
Exemple pour une fenêtre contenant de haut en bas :
gb_critères / dw_liste / tab_detail
if (this.height - this.tab_detail.height - 160) > this.dw_liste.y then // Taille Minimum pour le redimensionnement this.setredraw(false) // Eviter les scintillements // gb_critère de la taille de la fenêtre moins une bordure à appliquer à droite d'un objet this.gb_criteres.width = this.width - 180 // y de tab_detail de sorte que tab_detail soit toujours visible this.tab_detail.y = this.height - this.tab_detail.height - 160 // tab_detail prend toute la largeur comme gb_critère this.tab_detail.width = this.width - 180 // On redimensionne la dw_liste entre les 2 autres objets this.dw_liste.resize(this.width - 170 , this.tab_detail.y - this.dw_liste.y - 20) this.setredraw(true) end if
Après, si c'est par exemple on veut 3 datawindows redimensionnées côte à côte, il suffit de prendre quelque chose comme :
ll_dwWidth = this.width / 4 - ll_sommeDesBordures // Définir la largeur des dw dw_1.width = ll_dwWidth dw_2.width = ll_dwWidth dw_3.width = ll_dwWidth dw_4.width = ll_dwWidth dw_2.x = dw_1.x + ll_espacement // Définir la position des dw en x dw_3.x = dw_2.x + ll_espacement dw_4.x = dw_3.x + ll_espacement ...
Dernière modification par Gilles (13-11-2013 15:49:02)
Hors ligne