Discussion :

[J0r_x]

Bonjour,

Dans une fenêtre d'une largeur de base de 1024 pixels, j'ai un champ table qui contient une dizaine de colonnes.
Seul 6 de ces colonnes sont apparentes, pour les autres il faut utiliser l’ascenseur horizontal.
Mon champ table a comme ancrage un agrandissement en hauteur et en largeur.

Exemple 1 (aucun ancrage sur les colonnes) :
Si j’agrandis ma fenêtre, le champ table va s'agrandir, toutes les colonnes vont apparaître, l'ascenseur horizontal disparait puis un vide apparait entre la dernière colonne et l'ascenseur horizontal.

Exemple 2 (définition d'un ancrage sur une colonne) :
Si j’agrandis ma fenêtre, le champ table va s'agrandir, la colonne ayant l'ancrage va s'agrandir et les colonnes qui ne sont pas apparentes, reste non apparentes, il faut utiliser l'ascenseur horizontal.

Ce que je voudrais, c'est un mix de ces deux exemples, c'est-à-dire que l'ancrage sur la ou les colonnes ne se fassent que lorsque toutes les colonnes sont apparentes, est-ce possible ?

[frenchsting]

C'est assez technique à mon avis : il faut de redimensionner les colonnes suivant le redimensionnement de la table, avec un calcul. Inconvénient, il faut se taper la détection du changement de taille de la fenêtre (si c'est avec la poignée de redimensionnement).

Je bloquerais la poignée et je mettre uniquement plein écran (et mode fenêtre) disponible. Là, c'est plus simple, tu peux savoir si tu es en mode fenêtre et donc forcer la taille de tes colonnes.

[djejackk]

Bonjour,

Je verrai ça comme ça de tête, sans avoir testé :
1. On définit la table avec largeur de colonne et ancrage souhaitée sur chaque colonne

2. En initialisation de table (ou de fenêtre),
- on mémorise pour chaque colonne le taux d'ancrage en largeur (dans un tableau associatif), en utilisant la propriété TauxAncrageLargeur.
- on mémorise la largeur cumulée de toutes les colonnes (pour voir à partir de quel largeur la table pourra tout afficher)
- on supprime tous les taux d'ancrages de chaque colonne

3. En redimensionnement du champ table, on compare la largeur de la table à la largeur de toute les colonnes calculées précédemment
- si le champ table est égale ou plus large, ça veut dire que toutes les colonnes peuvent être affichées dans le champ; on réaffecte à chaque colonne son taux d'ancrage pour que les ancrages soient pris en compte.
- si le champ table est moins large, ca veut dire que des colonnes sont cachées; on supprime tous les taux d'ancrage.

C'est une théorie à tester : essayez de votre côté, je regarde quand j'aurai 5 minutes de mon côté.

Cordialement

[Hibernatus34]

Il suffirait que PC Soft ajoute 2 coches :
- Adapter automatiquement la largeur des colonnes (comme ça se passe quand on a 1 seule colonne ancrée, mais là il y aurait une répartition d'après le taux d'ancrage)
- Ne pas réduire la largeur d'une colonne en-dessous de la largeur initiale.

Et je pense que les ancrages de colonnes seraient enfin utilisables sur de grosses tables.

[J0r_x]

C'est bien ce que je pensais, je trouve ça un peu lourd juste pour avoir un rendu correct d'un champ table, dommage que dans leur 1000 nouveautés à chaque version PCSoft ne pense au chose vraiment utile

[J0r_x]

Je met la solution qui fonctionne dans le cadre de mes applications :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
w_indice est un entier
w_largeur_table,w_largeur_colonnes,w_largeur_ancrage sont des entiers
w_colonne est une chaîne
w_tab_ancrage est un tableau de 0 par 2 chaîne
 
//On récupère la largeur du champ table - 15 pixels (largeur de l'ascenseur vertical)
w_largeur_table = {P_table,indChamp}..Largeur - 15
 
//Pour toutes les colonnes du champ table
POUR w_indice = 1 _A_ TableOccurrence({P_table,indChamp},toColonne)
	//Récupération du nom de la colonne
	w_colonne = TableEnumèreColonne({P_table,indChamp},w_indice)
 
	//Si la colonne est invisible on ne la traite pas
	SI {w_colonne,indChamp}..Visible = Faux ALORS CONTINUER
 
	//Si un ancrage est définit il faut le sauvegarder pour le remettre après
	SI {w_colonne,indChamp}..TauxAncrageLargeur > 0 ALORS
		//On remet la largeur initiale à la colonne, l'ancrage a déjà été effectué, la colonne a déjà été agrandie
		{w_colonne,indChamp}..Largeur = {w_colonne,indChamp}..LargeurInitiale
 
		TableauAjouteLigne(w_tab_ancrage,w_colonne,{w_colonne,indChamp}..TauxAncrageLargeur)
	FIN
 
	//On cumul la largeur des colonnes
	w_largeur_colonnes += {w_colonne,indChamp}..Largeur
FIN
 
//On définit la largeur de l'ancrage
w_largeur_ancrage = w_largeur_table - w_largeur_colonnes
 
//Si cette largeur est positive
SI w_largeur_ancrage > 0 ALORS
	//On agrandie toutes les colonnes disposant d'un ancrage
	POUR w_indice = 1 _A_ TableauOccurrence(w_tab_ancrage)
		//Le taux d'ancrage est sauvegardé en base 1000, 100% = 1000
		{w_tab_ancrage[w_indice,1],indChamp}..Largeur += Val(w_tab_ancrage[w_indice,2]) / 1000 * w_largeur_ancrage
	FIN	
FIN

Merci pour vos idées

[Techys]

Pour faire plus simple, regarde dans IHM de chaque colonne en bas tu a le taux d'ancrage met la valeur a 100 dans toutes les colonnes.

Ca marche pour moi