Discussion :

[ddubois]

Pour trier mon TStringGrid, j'utilise cette routine de tri :
http://castelain.developpez.com/sources/TriStringGrid/

Cependant du fait que ma grille ne contient que des chiffres (de 0 à 20), les notes inférieures à 10 (à un chiffre) sont mal triés par contre le colonnes qui n'ont que des chiffres a 2 "digits" de 10 à 20, sont bien triés.

Pour lui 8 estsupérieur à 20 ou à 10 (puisque 8 > 2 et 1) !

Comment modifier le code pour arriver à trier correctement les chiffres à une unité ou sinon obtenir un autre routine de trie de mes colonnes de chiffres.

Merci,

M. DUBOIS

[ShaiLeTroll]

C'est si simple, il suffit de comparer des entiers, ... à toi de gérer les erreurs de conversion, en jouant sur MaxInt ou -MaxInt, cela peut suffir ...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
function CellCompare(const AStringGrid: TStringGrid;
  const SortOrder: TSortOrder;
  const Column, Index1, Index2: Integer): Integer;
begin
  with AStringGrid do
    case SortOrder of
      soUp: result:= StrToIntDef(Cells[Column, Index1], -MaxInt) - StrToIntDef(Cells[Column, Index2], -MaxInt);
      soDown: result:= StrToIntDef(Cells[Column, Index2]], MaxInt) - StrToIntDef(Cells[Column, Index1]], MaxInt);
      else
       result:= 0;
    end;
end;

As-tu cherché à comprendre le code copier depuis le site ? si oui, tu n'as pas chercher longtemps, car sinon tu aurais compris comme cela fonctionnait, et tu aurais trouver la solution ...

[Jipété]

Salut

Comment modifier le code pour arriver à trier correctement les chiffres à une unité ou sinon obtenir un autre routine de trie de mes colonnes de chiffres.

Mets des nombres à 2 chiffres, ie, 8 --> 08.

Mes 2 cts,
--
jp

[edit]et bon, grillé par Shai, [/edit]

[ddubois]

Grand merci je vais tester demain

la soluce de mettre 2 chiffres : je confirme : c'est vraiment nul !!

[ddubois]

Genial ca marche ! merci

Pendant que je te tiens et que tu ma l'air compétent la dessus : comme j'ai 12 lignes fixes dans mon TStringGrid et certaines sont parfois vides, je souhaite les ignorer lors des tries sinon je me retrouve avec des lignes vides en haut puis le contenu trié en dessous !
J'avais testé une routine sans succès (code entre accolades) :
(toujours avec le code de Pierre castalain)

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
 
function CellCompare(const AStringGrid: TStringGrid;
  const SortOrder: TSortOrder;
  const Column, Index1, Index2: Integer): Integer;
begin
  // Si vous voulez ne pas tenir compte de la casse, utilisez AnsiCompareText
  // au lieu de AnsiCompareStr
  with AStringGrid do
  {Si cellule vide (Test non concluant !) :
   if Trim(Cells[Column, Index1]) = '' then
    Result := -1;
  if Trim(Cells[Column, Index2]) = '' then
    Result := -1;
  }
    case SortOrder of
      //Modifier pour comparer des chiffres :
      soUp: result:= StrToIntDef(Cells[Column, Index1], -MaxInt) - StrToIntDef(Cells[Column, Index2], -MaxInt);
      soDown: result:= StrToIntDef(Cells[Column, Index2], MaxInt) - StrToIntDef(Cells[Column, Index1], MaxInt);
      else
       result:= 0;
    end;
end;

Merci

Denis

[Aka Guymelef]

Bonjour,

tu ne peux pas juste ignorer les lignes vides, tu dois décider si elles doivent toutes se trouver en haut ou en bas et donc adapter le retour de la fonction de comparaison en conséquence.

[ShaiLeTroll]

Grand merci je vais tester demain

la soluce de mettre 2 chiffres : je confirme : c'est vraiment nul !!

Moi, je ne faisais une remarque que sur l'orthographe de "mes\mais", dans certains cas, par exemple, la numérotation de version, mettre de zéros en plus permet dans l'explorateur windows de trier dans l'ordre des versions malgré le tri alphabétique ...

Sinon, tu dis cela mais tu n'as pas non plus apporter de solution ... ce qui est marrant, c'est que tu n'as pas non plus lu mes réponses dans le précédent sujet, la critique est aisée, l'art l'est moins ...

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
function CellCompare(const AStringGrid: TStringGrid;
  const SortOrder: TSortOrder;
  const Column, Index1, Index2: Integer): Integer;
begin
  // Si vous voulez ne pas tenir compte de la casse, utilisez AnsiCompareText
  // au lieu de AnsiCompareStr
  with AStringGrid do
   Si cellule vide // Un peu d'effort pour corriger :
   if Trim(Cells[Column, Index1]) = '' then
   begin
     Result := -1;
     Exit; 
   end;
  if Trim(Cells[Column, Index2]) = '' then
  begin
    Result := 1;
    Exit;
  end;
 
    case SortOrder of
      //Modifier pour comparer des chiffres :
      soUp: result:= StrToIntDef(Cells[Column, Index1], -MaxInt) - StrToIntDef(Cells[Column, Index2], -MaxInt);
      soDown: result:= StrToIntDef(Cells[Column, Index2], MaxInt) - StrToIntDef(Cells[Column, Index1], MaxInt);
      else
       result:= 0;
    end;
end;

[ddubois]

J'ai une erreur de débordement de pile, après modification de :

case SortOrder of
soUp:
soDonw:

pour prendre en compte des valeurs entières (0 à 20)

Help me pls

Denis

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
 
function CellCompare(const AStringGrid: TStringGrid;
  const SortOrder: TSortOrder;
  const Column, Index1, Index2: Integer): Integer;
begin
  // Si vous voulez ne pas tenir compte de la casse, utilisez AnsiCompareText
  // au lieu de AnsiCompareStr
  with AStringGrid do
  //Si cellule vide (Test non concluant !) :
   if Trim(AStringGrid.Cells[Column, Index1]) = '' then
   begin
    Result := -1;
    exit;
   end;
  if Trim(AStringGrid.Cells[Column, Index2]) = '' then
  begin
    Result := 1;
    exit;
  end;
 
    case SortOrder of
      //Modifier pour comparer des chiffres :
      soUp: result:= StrToIntDef(AStringGrid.Cells[Column, Index1], -MaxInt) - StrToIntDef(AStringGrid.Cells[Column, Index2], -MaxInt);
      soDown: result:= StrToIntDef(AStringGrid.Cells[Column, Index2], MaxInt) - StrToIntDef(AStringGrid.Cells[Column, Index1], MaxInt);
      else
       result:= 0;
    end;
end;

[ShaiLeTroll]

bon, je suppose que tu as corrigé le begin manquant de le with, ... après, cela peut venir du quick sort qui est récursif, il me semble, ... donc comme à un moment donné, il n'a plus que des '' à comparer à des '', et que l'on a oublié l'égalité, automatiquement cela boucle infinimenent où jusqu'à la saturation de la pile à cause de la succession de push lié à l'appel d'une fonction ... bon, j'ai fait la même chose à mes débuts, c'est vrai que j'avais pas mal chercher, j'ai passé du temps à débugger la lib delphi (options de compilation très utile), pour comprendre, depuis ça me semble tellement logique, ...

Ajoute cela juste après le with ...

Code :

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

1
2
3
4
5
if AStringGrid.Cells[Column, Index1] = AStringGrid.Cells[Column, Index1]  then
begin
    Result := 0;
    exit;
end;

[ddubois]

Je voudrais pas te contredire mais si tu met cela :

Code :

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

1
2
 
if Cells[Column, Index1] = Cells[Column, Index1]  then...

cela se verifiera toujours ! Je pense que tu as voulu mettre Index1 et Index2 (?)

De toute façon ca ne marche toujours pas, enfin, voici le code complet, dis moi ce qu'il faut modifier stp :

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
 
function CellCompare(const AStringGrid: TStringGrid;
  const SortOrder: TSortOrder;
  const Column, Index1, Index2: Integer): Integer;
begin
  // Si vous voulez ne pas tenir compte de la casse, utilisez AnsiCompareText
  // au lieu de AnsiCompareStr
  with AStringGrid do
  begin
  if Cells[Column, Index1] = Cells[Column, Index1]  then
  begin
    Result := 0;
    exit;
  end; 
 
  {
   if Trim(Cells[Column, Index1]) = '' then
   begin
     Result := -1;
     Exit;
   end;
  if Trim(Cells[Column, Index2]) = '' then
  begin
    Result := 1;
    Exit;
  end;
  }
    case SortOrder of
      //Modifier pour comparer des chiffres :
      soUp: result:= StrToIntDef(Cells[Column, Index1], -MaxInt) - StrToIntDef(Cells[Column, Index2], -MaxInt);
      soDown: result:= StrToIntDef(Cells[Column, Index2], MaxInt) - StrToIntDef(Cells[Column, Index1], MaxInt);
      else
       result:= 0;
    end;
  end;
end;

Merci,

Denis

[ShaiLeTroll]

Ben c'était un piège ... j'ai juste copier-coller sans changer le 1 en 2

Pourquoi les Trim(= '') sont en commentaires ?

[ddubois]

désolé d'insister mais cela ne donne rien :

Je résume tout depuis le début :

Pour trier mon TStringGrid, j'utilise cette routine de tri :
http://castelain.developpez.com/sources/TriStringGrid/

Auquel j'ai modifié ces 2 lignes pour ne prendre en compte que des valeurs numériques qui sont des notes (parfois avec virgules) de 0 à 20 :

Code :

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

1
2
3
 
      soUp: result:= StrToIntDef(Cells[Column, Index1], -MaxInt) - StrToIntDef(Cells[Column, Index2], -MaxInt);
      soDown: result:= StrToIntDef(Cells[Column, Index2], MaxInt) - StrToIntDef(Cells[Column, Index1], MaxInt);

Je souhaite ignorer (ou supprimer) les lignes vides qui s'affichent en tête de trie (c'est à dire en haut de ma grille) lors d'un trie décroissant (uniquement) lorsque les 12 lignes de mon TStringGrid ne sont pas remplies.
nota : Lors d'un tri croissant les lignes vides s'affichant en bas de grille, cela ne gène absolument pas.

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
 
function CellCompare(const AStringGrid: TStringGrid;
  const SortOrder: TSortOrder;
  const Column, Index1, Index2: Integer): Integer;
begin
  // Si vous voulez ne pas tenir compte de la casse, utilisez AnsiCompareText
  // au lieu de AnsiCompareStr
  with AStringGrid do
  begin
 { test non concluant :
  if Cells[Column, Index1] = Cells[Column, Index2]  then
  begin
    Result := 0;
    exit;
  end;   }
 
  {Si cellule vide (Test non concluant !) :
   if Trim(Cells[Column, Index1]) = '' then
   begin
     Result := -1;
     Exit;
   end;
  if Trim(Cells[Column, Index2]) = '' then
  begin
    Result := 1;
    Exit;
  end;
  }
    case SortOrder of
      //Modifier pour comparer des chiffres :
      soUp: result:= StrToIntDef(Cells[Column, Index1], -MaxInt) - StrToIntDef(Cells[Column, Index2], -MaxInt);
      soDown: result:= StrToIntDef(Cells[Column, Index2], MaxInt) - StrToIntDef(Cells[Column, Index1], MaxInt);
      else
       result:= 0;
    end;
  end;
end;

Merci de votre aide,

Denis

[Rayek]

Auquel j'ai modifié ces 2 lignes pour ne prendre en compte que des valeurs numériques qui sont des notes (parfois avec virgules) de 0 à 20 :

Il serait bien, de fournir la prochaine fois un énoncé complet avec tous les cas.
Donc en clair il ne faut pas travailler avec des int mais des float donc au lieu d'utiliser StrToIntDef il faut utiliser StrToFloatDef

[ddubois]

oui excuse mais le tri s'effectuait correctement quand même !
J'ai modifié le code mais j'ai une erreur :

>>[Erreur] Types incompatibles : 'Integer' et 'Extended'

En effet, par quoi remplacer les MaxInt ? MaxFloat ne semble pas exister...

De toute facon ca ne résoud pas mon problème des lignes vides qui s'affichent en premier.

Code :

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

1
2
3
4
5
6
7
8
 
    case SortOrder of
      soUp: result:= StrToFloatDef(Cells[Column, Index1], -MaxInt) - StrToFloatDef(Cells[Column, Index2], -MaxInt);
      soDown: result:= StrToFloatDef(Cells[Column, Index2], MaxInt) - StrToFloatDef(Cells[Column, Index1], MaxInt);
      else
       result:= 0;
    end;
  end;

Merci,

[Rayek]

oui excuse mais le tri s'effectuait correctement quand même !
J'ai modifié le code mais j'ai une erreur :

>>[Erreur] Types incompatibles : 'Integer' et 'Extended'

En effet, par quoi remplacer les MaxInt ? MaxFloat ne semble pas exister...

De toute facon ca ne résoud pas mon problème des lignes vides qui s'affichent en premier.

Code :

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

1
2
3
4
5
6
7
8
 
    case SortOrder of
      soUp: result:= StrToFloatDef(Cells[Column, Index1], -MaxInt) - StrToFloatDef(Cells[Column, Index2], -MaxInt);
      soDown: result:= StrToFloatDef(Cells[Column, Index2], MaxInt) - StrToFloatDef(Cells[Column, Index1], MaxInt);
      else
       result:= 0;
    end;
  end;

Merci,

Il faudrait peut être essayer de comprendre le code que tu utilises, ça serait le mieux.
Vu que c'est pour faire un tri sur des notes (donc de 0 à 20) je pense que tu peux remplacer le MaxInt par une valeur juste en dessous (genre -1.00) ou au dessus (selon le type de tri)
Ou alors directement dans le code tu peux mettre les valeurs limites

Code :

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

1
2
3
4
5
6
7
8
 
    case SortOrder of
      soUp: result:= StrToFloatDef(Cells[Column, Index1], -1.0) - StrToFloatDef(Cells[Column, Index2], -1.0);
      soDown: result:= StrToFloatDef(Cells[Column, Index2], 21.0) - StrToFloatDef(Cells[Column, Index1], 21.0);
      else
       result:= 0;
    end;
  end;

Pour les lignes vides, il serait peut être mieux de les supprimer avant de les mettre dans la StringGrid, cela résoudrait le problème (ou de les supprimer avant le traitement)

[ddubois]

Quand je fais cela j'ai le message

[Erreur] Unit6.pas(164): Types incompatibles : 'Integer' et 'Extended'

peut-être dus aux déclarations ?

function CellCompare(const AStringGrid: TStringGrid;
const SortOrder: TSortOrder;
const Column, Index1, Index2: Integer): Integer;

begin

Merci,

Denis

[ShaiLeTroll]

, tu devrais commencer par quelque chose de plus simple, non ? tu galères pour rien, apprend déjà à manipuler les entiers, les réels, les chaines, et tu reviens plus tard pour ce qui est des tris sur une grille lorsque tu auras assimilés, les notions de bases ...

Code :

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

1
2
3
4
5
6
case SortOrder of
      soUp: result:= Trunc(StrToFloatDef(Cells[Column, Index1], -1.0) - StrToFloatDef(Cells[Column, Index2], -1.0));
      soDown: result:= Trunc(StrToFloatDef(Cells[Column, Index2], 21.0) - StrToFloatDef(Cells[Column, Index1], 21.0));
      else
       result:= 0;
    end;