14 respuestas en este tema

[enecumene]

Pues eso, vamos a ordenar un ListView de forma Ascendente/Descendente de acuerdo al contenido de una columna, igual como hacemos con el explorador de windows en su vista details.

Lo primero que haremos es declarar dos variables globales:

delphi

var
  Form1: TForm1;
  UltimoSorteo: Integer; //guardará el dato de la última ordenación;
  Ascendente: Boolean; //verificaremos si la ordenación es Ascendente o no;

Luego debemos inicializar las variables que hemos creado:

delphi

procedure TForm1.FormCreate(Sender: TObject);
begin
  UltimoSorteo := -1; //no hay ninguno (también devuelve 1 y 0);
  Ascendente := True; //lo iniciamos de manera ascendente;
end;

Ahora, en el evento OnColumnClick del ListView colocaremos el siguiente code:

delphi

procedure TForm1.ListView1ColumnClick(Sender: TObject;
  Column: TListColumn);
begin
  if Column.Index = UltimoSorteo then
    Ascendente := Not Ascendente
  else
    UltimoSorteo := Column.Index;
 
TListView(Sender).CustomSort(@SortByColumn, Column.Index);
end;

Por último debemos crear una función que hará la ordenación de los datos de acuerdo a la columna:

delphi

function SortByColumn(Item1, Item2: TListItem; Data: integer):
    integer; stdcall;
  begin
    if Data = 0 then
      Result := AnsiCompareText(Item1.Caption, Item2.Caption)
    else
      Result := AnsiCompareText(Item1.SubItems[Data-1],
                                Item2.SubItems[Data-1]);
    if not Ascendente then Result := -Result;
end;

Pues ya con eso pueden ordenar los datos de una columna de un listview sin importar el tipo de contenido que tenga, Nota: Probado con Delphi 7.

Que lo disfruten, Saludos.

[escafandra]

Interesante y educativo este ejemplo enecumene

Saludos.

[Caral]

Hola
Siempre con codigo interesante y practico, gracias amigo.
Saludos

[egostar]

Que bien amigo, parece que lo voy a usar muy pronto.

Salud OS

[enecumene]

Vale qué bueno les haya gustado

Saludos.

[egostar]

Que bien amigo, parece que lo voy a usar muy pronto.

Salud OS

4 meses después ......

Funciona muy bien amigo Probado con Turbo Delphi

Salud OS

[monchito_elroro]

Muchas gracias amigo Enecumene, mas quisiera hacerle una consulta, cuando lo pruebo en lazarus me sale el siguiente mensaje:

php

unit1.pas(72,19) Error: identifier idents no member "CustomSort"

y se detiene aquí:

php

TListView(Sender).CustomSort(@SortByColumn, Column.Index);

Estoy usando Lazarus en windows 10, me podrían dar una manito.

[Delphius]

Muchas gracias amigo Enecumene, mas quisiera hacerle una consulta, cuando lo pruebo en lazarus me sale el siguiente mensaje:

php

unit1.pas(72,19) Error: identifier idents no member "CustomSort"

y se detiene aquí:

php

TListView(Sender).CustomSort(@SortByColumn, Column.Index);

Estoy usando Lazarus en windows 10, me podrían dar una manito.

 

Lamentablemente Lazarus no cuenta con este método aún. La idea está, pero parece que tienen unas dificultades en su implementación por lo que está en "stand by".

 

De lo que estoy viendo si existen propiedades relacionadas con el ordenamiento: SortColumn que recibe el nro de columna por la cual ordenar, SortDirection que indica si es ascendente o descendente, y SortType que establece el tipo de dato por el cual ordenar.

Pero no le veo un método Sort o algo parecido en forma pública. Explorando el código resulta ser que se realiza el ordenamiento de forma automática cuando establece el valor de SortDirection o de cualquiera de las otras.

En su código aprecio que invoca al método @CompareItems que en su interior invoca al método para el evento OnCompare (si hay uno asignado) o a uno por defecto (que compara la data de item1 e item2). El método de respuesta a OnCompare vendría a ser el análogo del método SortByColumn que ha puesto el compañero enecumene en su ejemplo.

 

Ahora bien, la documentación oficial (la disponible al menos desde el ide con F1) sobre OnCompare no aclara mucho sobre su diseño. El tipo de puntero a método de OnCompare está declarado así:

delphi

TLVCompareEvent = procedure(Sender: TObject; Item1, Item2: TListItem;
                               Data: Integer; var Compare: Integer) of object;

Como he dicho, el método Sort interno recibe como parámetro @CompareItems. Cuya implementación es:

delphi

function CompareItems(Item1, Item2: Pointer): Integer;
var
  Str1: String;
  Str2: String;
  ListView: TCustomListView;
begin
  Result := 0;
  ListView := TListItem(Item1).Owner.Owner;
  if Assigned(ListView.FOnCompare) then
    ListView.FOnCompare(ListView, TListItem(Item1), TListItem(Item2),0 ,Result)
  else
  begin
    if ListView.SortType in [stData] then
      Result := CompareValue(PtrUInt(TListItem(Item1).Data), PtrUInt(TListItem(Item2).Data))
    else
    begin
      if ListView.FSortColumn = 0 then
      begin
        Str1 := TListItem(Item1).Caption;
        Str2 := TListItem(Item2).Caption;
      end else
      begin
        if ListView.FSortColumn <= TListItem(Item1).SubItems.Count then
          Str1 := TListItem(Item1).SubItems.Strings[ListView.FSortColumn-1]
        else
          Str1 := '';
        if ListView.FSortColumn <= TListItem(Item2).SubItems.Count then
          Str2 := TListItem(Item2).SubItems.Strings[ListView.FSortColumn-1]
        else
          Str2 := '';
      end;
      Result := AnsiCompareText(Str1, Str2);
    end;
    if ListView.SortDirection = sdDescending then
      Result := -Result;
  end;
end;

Creí que al ver en como invoca a OnCompare() podría aclararme mejor el punto pero no es el caso. No se a que se refiere o que se supone que debe significar o que uso darle a los parámetros Data y Compare. También no me queda claro que valor debe regresar este método (nota que Compare es una variable por valor).

 

Quizá si le dedicas más tiempo en la investigación que yo puedas encontrar estas respuestas. Por lo pronto yo no encuentro alguna.

 

Saludos,

[Delphius]

Incluyo la implementación de Sort por si les aclara mejor el panorama:

delphi

procedure TCustomListView.Sort;
var
  FSavedSelection: TFPList;
  FSavedFocused: TListItem;
  i: Integer;
  AItemIndex: Integer;
begin
  if FSortType = stNone then exit;
  if (FSortColumn < 0) or (FSortColumn >= ColumnCount) then exit;
  if FListItems.Count < 2 then exit;
  if lffPreparingSorting in FFlags then exit;
 
  if HandleAllocated then
  begin
    Include(FFlags, lffItemsSorting);
    FSavedSelection := TFPList.Create;
    try
      if (ItemIndex >= 0) then
        FSavedFocused := Items[ItemIndex]
      else
        FSavedFocused := nil;
      if Assigned(Selected) then
      begin
        FSavedSelection.Add(Selected);
        if MultiSelect then
          for i := 0 to Items.Count-1 do
            if Items[i].Selected and (Items[i] <> Selected) then
              FSavedSelection.Add(Items[i]);
      end;
 
      Items.FCacheIndex := -1;
      Items.FCacheItem := nil;
 
      FListItems.FItems.Sort(@CompareItems);
      TWSCustomListViewClass(WidgetSetClass).SetSort(Self, FSortType,
        FSortColumn, FSortDirection);
 
      if (FSavedSelection.Count > 0) or Assigned(FSavedFocused) then
      begin
        Selected := nil; // unselect all
 
        if FSavedFocused <> nil then
          TWSCustomListViewClass(WidgetSetClass).ItemSetState(Self,
            FSavedFocused.Index, FSavedFocused, lisFocused, True);
 
        for i := FSavedSelection.Count - 1 downto 0 do
        begin
          AItemIndex := Items.IndexOf(TListItem(FSavedSelection.Items[i]));
          if AItemIndex <> -1 then
            TWSCustomListViewClass(WidgetSetClass).ItemSetState(Self,
              AItemIndex, Items[AItemIndex], lisSelected, True);
        end;
      end;
    finally
      FreeThenNil(FSavedSelection);
      Exclude(FFlags, lffItemsSorting);
    end;
  end else
    FListItems.FItems.Sort(@CompareItems);
end;

Puede verse allí el Sort interno asociado a FItems, y que se pasa el @CompareItems.

 

El método Sort, que se invoca ante cualquier cambio de las propiedades "Sort" está definido como protegido. Por lo que de última puede heredarse de TListView y ponerlo como público.

 

Aquí pongo de ejemplo de como se lo invoca cuando se cambia la dirección de ordenamiento:

delphi

procedure TCustomListView.SetSortDirection(const AValue: TSortDirection);
begin
  if FSortDirection=AValue then exit;
  FSortDirection:=AValue;
  Sort;
end;

Notará que no es un TListView sino un TCustomView. TListView no es más que una versión "pública" de TCustomView, es decir que cambia la visibilidad de algunas propiedades y métodos.

 

Creo que con todo esto ya se puede hechar un poco más de luz al tema. Mi búsqueda me ha llevado por algunos hilos en los foros de Lazarus, y en ellos no hay respuesta definitiva. Como he dicho antes: esto está en "veremos".

 

Saludos,

[escafandra]

Pongo un fragmento de código de un programa, que inicialmente escribí en C++Builder y mas tarde migré a delphi y Lazarus. Una AlphaSort sin problemas y trabaja como espero que lo haga:
 
 

delphi

procedure TForm1.ListView1ColumnClick(Sender: TObject; Column: TListColumn);
begin
  Pulse:= Pulse xor true;
  ColumnToSort:= Column.Index;
  (Sender as TCustomListView).AlphaSort;
  if ListView1.Selected <> nil then
     ListView_EnsureVisible(ListView1.Handle, ListView1.Selected.Index, 1);
end;
 
procedure TForm1.ListView1Compare(Sender: TObject; Item1, Item2: TListItem;
  Data: Integer; var Compare: Integer);
var ix: integer;
begin
  if (ColumnToSort = 0) then
    Compare:= StrToInt(Item2.Caption) - StrToInt(Item1.Caption)
  else if(ColumnToSort<4) then
  begin
    ix:= ColumnToSort - 1;
    Compare:= CompareText(Item1.SubItems.Strings[ix], Item2.SubItems.Strings[ix]);
  end;
  if Pulse then Compare:= -Compare;
end;

Saludos.

[Delphius]

Pongo un fragmento de código de un programa, que inicialmente escribí en C++Builder y mas tarde migré a delphi y Lazarus. Una AlphaSort sin problemas y trabaja como espero que lo haga:
 
 

delphi

procedure TForm1.ListView1ColumnClick(Sender: TObject; Column: TListColumn);
begin
  Pulse:= Pulse xor true;
  ColumnToSort:= Column.Index;
  (Sender as TCustomListView).AlphaSort;
  if ListView1.Selected <> nil then
     ListView_EnsureVisible(ListView1.Handle, ListView1.Selected.Index, 1);
end;
 
procedure TForm1.ListView1Compare(Sender: TObject; Item1, Item2: TListItem;
  Data: Integer; var Compare: Integer);
var ix: integer;
begin
  if (ColumnToSort = 0) then
    Compare:= StrToInt(Item2.Caption) - StrToInt(Item1.Caption)
  else if(ColumnToSort<4) then
  begin
    ix:= ColumnToSort - 1;
    Compare:= CompareText(Item1.SubItems.Strings[ix], Item2.SubItems.Strings[ix]);
  end;
  if Pulse then Compare:= -Compare;
end;

Saludos.

 

 

Vaya, desconocía AlphaSort. Por lo que estuve viendo, Con AlphaSort se ordena por la columna 0 y en forma ascendente siempre en Lazarus.

 

A lo que todavía no le encuentro sentido es que propósito tiene el parámetro Data del OnCompare. Hasta donde entiendo en Compare debe regresarse -1, 1, o 0 según el criterio a ordenar y la forma que tengamos pensado aplicar la comparación.

 

Saludos,

[Delphius]

He encontrado un hilo en StackOverflow que da una propuesta interesante para aplicar ordenamiento ascendente y descendente. Quizá pueda ser portado a Lazarus sin demasiadas complicaciones.

 

Saludos,

[Delphius]

¿Saben de que me he dado cuenta ahora? Es bien sabido que el algoritmo interno de ordenamiento por defecto es QuickSort... pero QuickSort no es bueno cuando se trata de items organizados matricialmente.... como por ejemplo en un TListView configurado de esa forma, una Grid, etc.

En especial cuando la cantidad de sub-items (columnas) se acerque a la cantidad de items, no es bueno que aplique el algoritmo QuickSort (aún cuando fuese su versión in-place).

¿Porqué? Porque al ordenar por una columna debe iterar a su vez por el resto de los subitems para ubicarlos en la misma posición. QuickSort se degrada cuando se debe aumentar la cantidad de elementos a desplazar. Es el mismo caso que se me ha presentado en un ocasión.

 

Lo explico: QuickSort tiene una complejidad media de O(n * log(n)) cuando una lista está formada por n elementos. Ahora la lista en realidad es una matriz (n, m) y no (n, 1). Es decir, cada siendo n la cantidad de items, y m la de subitems. Cada vez que hay un intercambio (swapping en la jerga de los algoritmos de ordenamiento) del item/subitem por el cual se debe realizar el ordenamiento se debe iterar sobre los m subitems restantes a su nuevo lugar. Este "barrido horizontal" completo requiere de O(n*m) operaciones.

Tenemos por tanto que la complejidad es Max( O(n * log(n)), O(n*m)) La máxima complejidad es O(n*m). Para cuando m se aproxima a n, todo se resume a O(n²).

 

Para estos casos es preferible directamente SelectionSort, que reduce ya de por si los intercambios y conserva su complejidad O(n²) al agregarse esta nueva dimensión.

 

Creo que ya el equipo de Lazarus ya está estudiando migrar el algoritmo de ordenamiento por defecto a TimSort, como ya lo han hecho (hace un buen tiempo) otros lenguajes. TimSort puede tener unas ventajas por sobre QuickSort y se me hace ante un esquema multidimensional es absorvente.

 

Saludos,

[escafandra]

Vaya, desconocía AlphaSort. Por lo que estuve viendo, Con AlphaSort se ordena por la columna 0 y en forma ascendente siempre en Lazarus.

Pues ya ves que el código que expongo es capaz de ordenar por la columna escogida y no solo por la cero.
 

A lo que todavía no le encuentro sentido es que propósito tiene el parámetro Data del OnCompare. Hasta donde entiendo en Compare debe regresarse -1, 1, o 0 según el criterio a ordenar y la forma que tengamos pensado aplicar la comparación.

Data está ligado a CustomSort. En realidad no le encuentro utilidad.

 

Compare está pasado por referencia y sirve para que la rutina de ordenación sepa si los elementos son iguales o uno es mayor, en cuyo caso deberá proceder a su ordenación. Cambiando de signo de Compare, cambiamos el sentido del orden ascendente o descendente, de ahí la utilidad de las flechitas del truco que publiqué no hace mucho: Como colocar las flechitas que indican el orden de columnas de un ListView. Aunque en Lazarus sólo tiene sentido en entorno Windows. Fuera de él habría que pintarlas a pelo, como imágenes en las cabeceras de columna.

 

 

Saludos.

[escafandra]

Al releer este tema me doy cuenta de que Delphius había puesto dos entradas más antes de escribir mi mensaje anterior. Leo la consideración sobre QuickSort en un ListView. No estoy tan seguro de que cambiar un Item de lugar implique recorrer todos los sumitem, al menos en Windows y supongo que en Lazarus. Un Item engloba sus subitem y posicionarlo requiere de un simple mensaje sin recorrer más. En realidad depende del trabajo interno de las API.
 
Yo suelo abusar de punteros, y una de as ventajas que tiene trabajar con ellos, es precisamente la ordenación de los elementos apuntados, no tengo que cambiar los elementos complejos, sólo su puntero. Me explico, si tengo elementos en una matriz de una estructura compleja, lo que tengo en realidad es una matriz de punteros que apuntan a cada estructura compleja, me basta con cambiar el orden de los punteros para reordenar todo el tema, solo cambio un número (el puntero) en su matriz, y con esto he ordenado todo a toda velocidad. Bien es cierto que su representación visual va a tardar, pero, basta con anular el repintado de cada cambio para hacer solo uno al final de la ordenación. Windows tiene previsto la inhabilitación del WS_PAINT para usar en este tipo de casos, de esta forma no apreciamos los cambios parciales y el proceso es muy veloz.

Y ahora que recuerdo, ya expuse esto en este truco: Trucos para TListView con la API de Windows.
 
 

cpp

// Evito que se repinte a cada actualización de Item...
SendMessage(ListView->Handle, WM_SETREDRAW, FALSE, 0L);
 
ListView->Items->Clear();  // proceso lento si se permite el repintado
 
// Permito que se repinte y obligo a que se actualize
SendMessage(ListView->Handle, WM_SETREDRAW, TRUE, 0L);
InvalidateRect(ListView->Handle, NULL, TRUE);

Saludos.