Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

unit ormsearch; interface uses Winapi.Windows, Winapi.Messages, System.SysUtils,…

  1. User

    unit orm_search;

    interface

    uses Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, StrUtils, System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, System.Generics.Collections, Vcl.StdCtrls, Vcl.ExtCtrls, scGPExtControls, scControls, scGPFontControls, scGPControls, sPanel, AdvUtil, AdvGrid, AdvCGrid, Vcl.ComCtrls, Vcl.WinXPickers, orm_utils, ORM_CustomAttributes, System.Rtti, System.DateUtils, DM1, Data.DB, Uni, Vcl.Grids, AdvObj, BaseGrid, Vcl.Mask, pixel_utils, interposer_class, pixel_classes;

    const FILTER_PANEL_HEIGHT = 35; FILTER_PANEL_SPACING = 5; PANEL_MARGIN = 5; GRID_MIN_HEIGHT = 200;

    type TSearchColumn = class private FFieldName: string; FDisplayName: string; FWidth: Integer; FVisible: Boolean; FUsableAsFilter: Boolean; FDataType: TORMFormatType; public constructor Create(const AFieldName, ADisplayName: string; AWidth: Integer; AVisible: Boolean = True; AUsableAsFilter: Boolean = True); property FieldName: string read FFieldName; property DisplayName: string read FDisplayName; property Width: Integer read FWidth; property Visible: Boolean read FVisible; property UsableAsFilter: Boolean read FUsableAsFilter; property DataType: TORMFormatType read FDataType write FDataType; end;

    TSelectedSearch = class private FValues: TDictionary<string, TValue>; FDisplayValues: TDictionary<string, string>; public constructor Create; destructor Destroy; override; procedure SetValue(const AFieldName: string; const AValue: TValue; const ADisplayValue: string); function GetValue(const AFieldName: string): TValue; function GetDisplayValue(const AFieldName: string): string; property Values[const AFieldName: string]: TValue read GetValue; default; end;

    TActiveFilter = class private FFieldName: string; FDisplayName: string; FFilterOperator: TFilterOperator; FValue1: string; FValue2: string; FFilterPanel: TscGPPanel; FFilterLabel: TLabel; FDeleteButton: TscGPCharGlyphButton; FDataType: TORMFormatType; FIsOrCondition: Boolean; FGroupLevel: Integer; FGroupStarted: Boolean; FGroupEnded: Boolean; public constructor Create; destructor Destroy; override; property FieldName: string read FFieldName write FFieldName; property DisplayName: string read FDisplayName write FDisplayName; property FilterOperator: TFilterOperator read FFilterOperator write FFilterOperator; property Value1: string read FValue1 write FValue1; property Value2: string read FValue2 write FValue2; property FilterPanel: TscGPPanel read FFilterPanel write FFilterPanel; property FilterLabel: TLabel read FFilterLabel write FFilterLabel; property DeleteButton: TscGPCharGlyphButton read FDeleteButton write FDeleteButton; property DataType: TORMFormatType read FDataType write FDataType; property IsOrCondition: Boolean read FIsOrCondition write FIsOrCondition; property GroupStarted: Boolean read FGroupStarted write FGroupStarted; property GroupEnded: Boolean read FGroupEnded write FGroupEnded; function ToSQL: string; end;

    TORMSearchForm = class(TForm) pnlTop: TPanel; pnlFilters: TscGPPanel; pnlActiveFilters: TscGPPanel; pnlGrid: TsPanel; pnlBottom: TPanel;

    cboField: TscComboBox;
    cboOperator: TscComboBox;
    edtValue1: TscGPEdit;
    edtValue2: TscGPEdit;
    dateValue1: TscGPDateEdit;
    dateValue2: TscGPDateEdit;
    btnAddFilter: TscGPCharGlyphButton;
    
    SearchGrid: TAdvColumnGrid;
    
    btnSearch: TscGPCharGlyphButton;
    btnClose: TscGPCharGlyphButton;
    btnClearFilters: TscGPCharGlyphButton;
    
    procedure FormDestroy(Sender: TObject);
    procedure cboFieldChange(Sender: TObject);
    procedure cboOperatorChange(Sender: TObject);
    procedure btnAddFilterClick(Sender: TObject);
    procedure btnSearchClick(Sender: TObject);
    procedure btnCloseClick(Sender: TObject);
    procedure btnClearFiltersClick(Sender: TObject);
    procedure SearchGridDblClick(Sender: TObject);
    procedure FilterDeleteButtonClick(Sender: TObject);
    

    private FActiveFilters: TObjectList; FSearchColumns: TObjectList; FSelectedSearch: TSelectedSearch; FBaseQuery: string; FConnection: TUniConnection; FQuery: TUniQuery; FIsORMMode: Boolean; FORMFilter: TORMFilter; FFieldTypes: TDictionary<string, TORMFormatType>;

    procedure SetupGrid;
    procedure UpdateValueControls;
    procedure RemoveActiveFilter(Filter: TActiveFilter);
    procedure ArrangeFilterPanels;
    procedure ClearActiveFilters;
    procedure UpdatePanelLayouts;
    procedure CreateFilterPanel(Filter: TActiveFilter);
    procedure LoadData;
    procedure SetupFieldTypes;
    procedure PopulateOperators(ADataType: TORMFormatType);
    function BuildWhereClause: string;
    function GetFilteredSQL: string;
    procedure UpdateSelectedSearch;
    function GetSelectedRow: Integer;
    procedure SetupColumns;
    procedure UpdateGridData;
    function ValidateFilterValue(const Value: string; DataType: TORMFormatType): Boolean;
    procedure SetupORMFilter;
    
    procedure SetupVisualStyles;
    procedure ValidateInputs;
    procedure ShowValidationError(const Msg: string);
    procedure UpdateControlStates;
    function GetOperatorDisplayText(AOperator: TFilterOperator): string;
    

    public constructor Create(AOwner: TComponent); override; destructor Destroy; override;

    class function Execute(AConnection: TUniConnection; const ABaseQuery: string;
      const ASearchColumns: array of TSearchColumn; var ASelectedSearch: TSelectedSearch): Boolean;
    
    procedure InitializeSearch(AConnection: TUniConnection; const ABaseQuery: string;
      const ASearchColumns: array of TSearchColumn);
    

    end;

    implementation

    uses Math;

    {$R *.dfm}

    procedure LogToFile(const Msg: string); var LogFile: TextFile; LogFileName: string; begin LogFileName := ExtractFilePath(ParamStr(0)) + 'orm_search.log'; AssignFile(LogFile, LogFileName); try if FileExists(LogFileName) then Append(LogFile) else Rewrite(LogFile); WriteLn(LogFile, Format('[%s] %s', [FormatDateTime('yyyy-mm-dd hh:nn:ss.zzz', Now), Msg])); finally CloseFile(LogFile); end; end;

    { TSearchColumn }

    constructor TSearchColumn.Create(const AFieldName, ADisplayName: string; AWidth: Integer; AVisible: Boolean = True; AUsableAsFilter: Boolean = True); begin inherited Create; FFieldName := AFieldName; FDisplayName := ADisplayName; FWidth := AWidth; FVisible := AVisible; FUsableAsFilter := AUsableAsFilter; FDataType := tiString; // Default, will be updated when field types are loaded end;

    { TSelectedSearch }

    constructor TSelectedSearch.Create; begin inherited; FValues := TDictionary<string, TValue>.Create; FDisplayValues := TDictionary<string, string>.Create; end;

    destructor TSelectedSearch.Destroy; begin FValues.Free; FDisplayValues.Free; inherited; end;

    procedure TSelectedSearch.SetValue(const AFieldName: string; const AValue: TValue; const ADisplayValue: string); begin FValues.AddOrSetValue(AFieldName, AValue); FDisplayValues.AddOrSetValue(AFieldName, ADisplayValue); end;

    function TSelectedSearch.GetValue(const AFieldName: string): TValue; begin if not FValues.TryGetValue(AFieldName, Result) then Result := TValue.Empty; end;

    function TSelectedSearch.GetDisplayValue(const AFieldName: string): string; begin if not FDisplayValues.TryGetValue(AFieldName, Result) then Result := ''; end;

    constructor TORMSearchForm.Create(AOwner: TComponent); begin inherited Create(AOwner);

    // Initialize collections and dictionaries FActiveFilters := TObjectList.Create(True); FSearchColumns := TObjectList.Create(True); FFieldTypes := TDictionary<string, TORMFormatType>.Create; FIsORMMode := False;

    // Initialize panel properties pnlActiveFilters.Visible := False; pnlActiveFilters.Height := 0; pnlActiveFilters.Align := alTop;

    SetupGrid; end;

    procedure TORMSearchForm.SetupVisualStyles; begin // Panel styling pnlActiveFilters.Padding.Left := PANEL_MARGIN; pnlActiveFilters.Padding.Right := PANEL_MARGIN; pnlActiveFilters.Padding.Top := PANEL_MARGIN; pnlActiveFilters.Padding.Bottom := PANEL_MARGIN;

    // Grid styling SearchGrid.Constraints.MinHeight := GRID_MIN_HEIGHT;

    // Input controls edtValue1.Options.ShapeCornerRadius := 3; edtValue2.Options.ShapeCornerRadius := 3; dateValue1.Options.ShapeCornerRadius := 3; dateValue2.Options.ShapeCornerRadius := 3;

    // Buttons btnAddFilter.Options.ShapeCornerRadius := 3; btnSearch.Options.ShapeCornerRadius := 3; btnClearFilters.Options.ShapeCornerRadius := 3; btnClose.Options.ShapeCornerRadius := 3; end;

    procedure TORMSearchForm.ValidateInputs; var ErrorMsg: string; IsValid: Boolean; SelectedColumn: TSearchColumn; FieldType: TORMFormatType; begin IsValid := True; ErrorMsg := '';

    if cboField.ItemIndex < 0 then begin ErrorMsg := 'Please select a field'; IsValid := False; end else if cboOperator.ItemIndex < 0 then begin ErrorMsg := 'Please select an operator'; IsValid := False; end else begin // Find the selected column to get its field name SelectedColumn := nil; for var Column in FSearchColumns do begin if Column.DisplayName = cboField.Text then begin SelectedColumn := Column; Break; end; end;

    if Assigned(SelectedColumn) and FFieldTypes.TryGetValue(SelectedColumn.FieldName, FieldType) then
    begin
      case FieldType of
        tiInteger, tiFloat, tiMoney:
          begin
            if not ValidateFilterValue(edtValue1.Text, FieldType) then
            begin
              ErrorMsg := 'Please enter a valid number';
              IsValid := False;
            end
            else if (cboOperator.Text = 'Between') and
                    not ValidateFilterValue(edtValue2.Text, FieldType) then
            begin
              ErrorMsg := 'Please enter a valid number for the second value';
              IsValid := False;
            end;
          end;
    
        tiDate, tiDateTime:
          begin
            if dateValue1.Visible and (dateValue1.Date = 0) then
            begin
              ErrorMsg := 'Please enter a valid date';
              IsValid := False;
            end
            else if dateValue2.Visible and (dateValue2.Date = 0) then
            begin
              ErrorMsg := 'Please enter a valid date for the second value';
              IsValid := False;
            end;
          end;
      end;
    end
    else
    begin
      ErrorMsg := 'Invalid field type configuration';
      IsValid := False;
    end;
    

    end;

    if not IsValid then ShowValidationError(ErrorMsg);

    btnAddFilter.Enabled := IsValid; end;

    procedure TORMSearchForm.ShowValidationError(const Msg: string); begin // Implement visual feedback for validation errors // Could show error icon, highlight invalid fields, etc. MessageDlg(Msg, mtError, [mbOK], 0); end;

    procedure TORMSearchForm.UpdateControlStates; begin btnClearFilters.Enabled := FActiveFilters.Count > 0; btnSearch.Enabled := FActiveFilters.Count > 0;

    ValidateInputs; end;

    { TActiveFilter }

    constructor TActiveFilter.Create; begin inherited; FIsOrCondition := False; FGroupStarted := False; FGroupEnded := False; FGroupLevel := 0; FFilterOperator := foEqual; FDataType := tiString; end;

    destructor TActiveFilter.Destroy; begin try // Free the panel if it exists if Assigned(FFilterPanel) then begin LogToFile(Format('Destroying filter panel %s', [FFilterPanel.Name])); FFilterPanel.Free; FFilterPanel := nil; end; except on E: Exception do LogToFile(Format('Error in TActiveFilter.Destroy: %s', [E.Message])); end;

    inherited; end;

    function TActiveFilter.ToSQL: string; var FieldExpression: string; begin FieldExpression := FFieldName;

    case FilterOperator of foEqual: if Value1 = '' then Result := Format('%s IS NULL', [FieldExpression]) else case DataType of tiString: Result := Format('%s = %s', [FieldExpression, QuotedStr(Value1)]); tiInteger: Result := Format('%s = %s', [FieldExpression, Value1]); tiFloat, tiMoney: Result := Format('%s = %s', [FieldExpression, Value1]); tiDate: Result := Format('%s = %s', [FieldExpression, QuoteDate_SQL(Value1)]); tiDateTime: Result := Format('%s = %s', [FieldExpression, QuoteDateTime_SQL(Value1)]); else Result := Format('%s = %s', [FieldExpression, QuotedStr(Value1)]); end;

    foNotEqual:
      if Value1 = '' then
        Result := Format('%s IS NOT NULL', [FieldExpression])
      else case DataType of
        tiString: Result := Format('%s <> %s', [FieldExpression, QuotedStr(Value1)]);
        tiInteger: Result := Format('%s <> %s', [FieldExpression, Value1]);
        tiFloat, tiMoney: Result := Format('%s <> %s', [FieldExpression, Value1]);
        tiDate: Result := Format('%s <> %s', [FieldExpression, QuoteDate_SQL(Value1)]);
        tiDateTime: Result := Format('%s <> %s', [FieldExpression, QuoteDateTime_SQL(Value1)]);
        else Result := Format('%s <> %s', [FieldExpression, QuotedStr(Value1)]);
      end;
    
    foGreaterThan:
      case DataType of
        tiString: Result := Format('%s > %s', [FieldExpression, QuotedStr(Value1)]);
        tiInteger: Result := Format('%s > %s', [FieldExpression, Value1]);
        tiFloat, tiMoney: Result := Format('%s > %s', [FieldExpression, Value1]);
        tiDate: Result := Format('%s > %s', [FieldExpression, QuoteDate_SQL(Value1)]);
        tiDateTime: Result := Format('%s > %s', [FieldExpression, QuoteDateTime_SQL(Value1)]);
        else Result := Format('%s > %s', [FieldExpression, QuotedStr(Value1)]);
      end;
    
    foLessThan:
      case DataType of
        tiString: Result := Format('%s < %s', [FieldExpression, QuotedStr(Value1)]);
        tiInteger: Result := Format('%s < %s', [FieldExpression, Value1]);
        tiFloat, tiMoney: Result := Format('%s < %s', [FieldExpression, Value1]);
        tiDate: Result := Format('%s < %s', [FieldExpression, QuoteDate_SQL(Value1)]);
        tiDateTime: Result := Format('%s < %s', [FieldExpression, QuoteDateTime_SQL(Value1)]);
        else Result := Format('%s < %s', [FieldExpression, QuotedStr(Value1)]);
      end;
    
    foGreaterEqual:
      case DataType of
        tiString: Result := Format('%s >= %s', [FieldExpression, QuotedStr(Value1)]);
        tiInteger: Result := Format('%s >= %s', [FieldExpression, Value1]);
        tiFloat, tiMoney: Result := Format('%s >= %s', [FieldExpression, Value1]);
        tiDate: Result := Format('%s >= %s', [FieldExpression, QuoteDate_SQL(Value1)]);
        tiDateTime: Result := Format('%s >= %s', [FieldExpression, QuoteDateTime_SQL(Value1)]);
        else Result := Format('%s >= %s', [FieldExpression, QuotedStr(Value1)]);
      end;
    
    foLessEqual:
      case DataType of
        tiString: Result := Format('%s <= %s', [FieldExpression, QuotedStr(Value1)]);
        tiInteger: Result := Format('%s <= %s', [FieldExpression, Value1]);
        tiFloat, tiMoney: Result := Format('%s <= %s', [FieldExpression, Value1]);
        tiDate: Result := Format('%s <= %s', [FieldExpression, QuoteDate_SQL(Value1)]);
        tiDateTime: Result := Format('%s <= %s', [FieldExpression, QuoteDateTime_SQL(Value1)]);
        else Result := Format('%s <= %s', [FieldExpression, QuotedStr(Value1)]);
      end;
    
    foBetween:
      case DataType of
        tiString: Result := Format('%s BETWEEN %s AND %s', [FieldExpression, QuotedStr(Value1), QuotedStr(Value2)]);
        tiInteger: Result := Format('%s BETWEEN %s AND %s', [FieldExpression, Value1, Value2]);
        tiFloat, tiMoney: Result := Format('%s BETWEEN %s AND %s', [FieldExpression, Value1, Value2]);
        tiDate: Result := Format('%s BETWEEN %s AND %s', [FieldExpression, QuoteDate_SQL(Value1), QuoteDate_SQL(Value2)]);
        tiDateTime: Result := Format('%s BETWEEN %s AND %s', [FieldExpression, QuoteDateTime_SQL(Value1), QuoteDateTime_SQL(Value2)]);
        else Result := Format('%s BETWEEN %s AND %s', [FieldExpression, QuotedStr(Value1), QuotedStr(Value2)]);
      end;
    
    foContains:
      Result := Format('%s LIKE ''%%%s%%''', [FieldExpression, Value1]);
    
    foBeginsWith:
      Result := Format('%s LIKE ''%s%%''', [FieldExpression, Value1]);
    
    foEndsWith:
      Result := Format('%s LIKE ''%%%s''', [FieldExpression, Value1]);
    
    foIsNull:
      Result := Format('%s IS NULL', [FieldExpression]);
    
    foIsNotNull:
      Result := Format('%s IS NOT NULL', [FieldExpression]);
    

    end; end;

    { TORMSearchForm }

    destructor TORMSearchForm.Destroy; begin try // Free collections in reverse order of creation FFieldTypes.Free; FSearchColumns.Free; FActiveFilters.Free; FQuery.Free; finally inherited Destroy; end; end;

    class function TORMSearchForm.Execute(AConnection: TUniConnection; const ABaseQuery: string; const ASearchColumns: array of TSearchColumn; var ASelectedSearch: TSelectedSearch): Boolean; var SearchForm: TORMSearchForm; begin Result := False; SearchForm := TORMSearchForm.Create(nil); try SearchForm.InitializeSearch(AConnection, ABaseQuery, ASearchColumns); if SearchForm.ShowModal = mrOk then begin SearchForm.UpdateSelectedSearch; ASelectedSearch := SearchForm.FSelectedSearch; Result := True; end; finally SearchForm.Free; end; end;

    procedure TORMSearchForm.InitializeSearch(AConnection: TUniConnection; const ABaseQuery: string; const ASearchColumns: array of TSearchColumn); var i: Integer; begin FConnection := AConnection; FBaseQuery := ABaseQuery;

    // Clear existing columns FSearchColumns.Clear;

    // Copy search columns for i := 0 to High(ASearchColumns) do FSearchColumns.Add(TSearchColumn.Create( ASearchColumns[i].FieldName, ASearchColumns[i].DisplayName, ASearchColumns[i].Width, ASearchColumns[i].Visible, ASearchColumns[i].UsableAsFilter ));

    SetupColumns; SetupFieldTypes; LoadData; end;

    procedure TORMSearchForm.SetupFieldTypes; begin if not Assigned(FQuery) then FQuery := TUniQuery.Create(nil);

    try FQuery.Connection := FConnection; FQuery.SQL.Text := FBaseQuery + ' WHERE 1=0'; // Just get structure FQuery.Open;

    FFieldTypes.Clear;
    for var Column in FSearchColumns do
    begin
      var Field := FQuery.FindField(Column.FieldName);
      if Assigned(Field) then
      begin
        case Field.DataType of
          ftString, ftWideString, ftMemo, ftWideMemo:
            Column.DataType := tiString;
          ftSmallint, ftInteger, ftWord, ftLongWord, ftShortint:
            Column.DataType := tiInteger;
          ftFloat, ftCurrency, ftBCD:
            Column.DataType := tiFloat;
          ftDate:
            Column.DataType := tiDate;
          ftDateTime, ftTimeStamp:
            Column.DataType := tiDateTime;
          ftBoolean:
            Column.DataType := tiBoolean;
        else
          Column.DataType := tiString;
        end;
        FFieldTypes.Add(Column.FieldName, Column.DataType);
      end;
    end;
    

    finally FQuery.Close; end; end;

    procedure TORMSearchForm.SetupColumns; begin // Setup grid columns based on search columns SearchGrid.ColCount := FSearchColumns.Count; SearchGrid.FixedRows := 1;

    for var i := 0 to FSearchColumns.Count - 1 do begin SearchGrid.Cells[i, 0] := FSearchColumns[i].DisplayName; SearchGrid.ColWidths[i] := FSearchColumns[i].Width; if not FSearchColumns[i].Visible then SearchGrid.ColWidths[i] := 0; end;

    // Setup field combo cboField.Items.Clear; for var Column in FSearchColumns do if Column.UsableAsFilter then cboField.Items.Add(Column.DisplayName);

    if cboField.Items.Count > 0 then cboField.ItemIndex := 0; end;

    procedure TORMSearchForm.cboFieldChange(Sender: TObject); var SelectedColumn: TSearchColumn; begin if cboField.ItemIndex < 0 then Exit;

    // Find corresponding column SelectedColumn := nil; for var Column in FSearchColumns do begin if Column.DisplayName = cboField.Text then begin SelectedColumn := Column; Break; end; end;

    if Assigned(SelectedColumn) then begin PopulateOperators(SelectedColumn.DataType); UpdateValueControls; end; end;

    procedure TORMSearchForm.PopulateOperators(ADataType: TORMFormatType); begin cboOperator.Items.Clear;

    case ADataType of tiString: begin cboOperator.Items.AddStrings(['Equals', 'Contains', 'Starts with', 'Ends with', 'Is empty', 'Is not empty']); end;

    tiInteger, tiFloat, tiMoney:
      begin
        cboOperator.Items.AddStrings(['Equals', 'Not equals', 'Greater than', 'Less than', 
          'Greater or equal', 'Less or equal', 'Between', 'Is empty', 'Is not empty']);
      end;
      
    tiDate, tiDateTime:
      begin
        cboOperator.Items.AddStrings(['Equals', 'Not equals', 'Greater than', 'Less than',
          'Greater or equal', 'Less or equal', 'Between', 'Is empty', 'Is not empty']);
      end;
      
    tiBoolean:
      begin
        cboOperator.Items.AddStrings(['True', 'False', 'Is empty', 'Is not empty']);
      end;
    

    end;

    if cboOperator.Items.Count > 0 then cboOperator.ItemIndex := 0; end;

    function TORMSearchForm.ValidateFilterValue(const Value: string; DataType: TORMFormatType): Boolean; var DummyInt: Integer; DummyFloat: Extended; DummyDate: TDateTime; begin if Value.Trim = '' then begin Result := True; Exit; end;

    case DataType of tiInteger: Result := TryStrToInt(Value, DummyInt);

    tiFloat, tiMoney:
      Result := TryStrToFloat(Value, DummyFloat);
      
    tiDate, tiDateTime:
      Result := TryStrToDateTime(Value, DummyDate);
      
    tiBoolean:
      Result := SameText(Value, 'True') or SameText(Value, 'False');
      
    else
      Result := True;
    

    end; end;

    procedure TORMSearchForm.UpdateValueControls; var Column: TSearchColumn; IsBetween: Boolean; begin if cboField.ItemIndex < 0 then Exit;

    // Find corresponding column for Column in FSearchColumns do if Column.DisplayName = cboField.Text then begin IsBetween := cboOperator.Text = 'Between';

      case Column.DataType of
        tiDate, tiDateTime:
          begin
            dateValue1.Visible := True;
            dateValue2.Visible := IsBetween;
            edtValue1.Visible := False;
            edtValue2.Visible := False;
          end;
    
        else
          begin
            dateValue1.Visible := False;
            dateValue2.Visible := False;
            edtValue1.Visible := True;
            edtValue2.Visible := IsBetween;
          end;
      end;
      Break;
    end;
    

    end;

    procedure TORMSearchForm.CreateFilterPanel(Filter: TActiveFilter); begin Filter.FilterPanel := TscGPPanel.Create(pnlActiveFilters); with Filter.FilterPanel do begin Name := Format('FilterPanel_%d', [GetTickCount]); Parent := pnlActiveFilters; BevelOuter := bvNone;

    // Set initial size and position
    Height := FILTER_PANEL_HEIGHT;
    Align := alNone;
    Left := PANEL_MARGIN;
    Width := pnlActiveFilters.ClientWidth - (2 * PANEL_MARGIN);
    
    // Style settings
    FluentUIOpaque := False;
    BackgroundStyle := gppbsColor;
    FillColor := clWhite;
    FillColorAlpha := 230;
    FrameColor := clGray;
    FrameColorAlpha := 40;
    FrameRadius := 3;
    
    // Padding
    Padding.Left := 5;
    Padding.Right := 5;
    Padding.Top := 2;
    Padding.Bottom := 2;
    

    end;

    // Create label Filter.FilterLabel := TLabel.Create(Filter.FilterPanel); with Filter.FilterLabel do begin Parent := Filter.FilterPanel; Left := 10; Top := (Filter.FilterPanel.Height - Height) div 2; AutoSize := True; Caption := Format('%s %s %s', [ Filter.DisplayName, GetOperatorDisplayText(Filter.FilterOperator), Filter.Value1 + IfThen(Filter.FilterOperator = foBetween, ' AND ' + Filter.Value2, '') ]); end;

    // Create delete button Filter.DeleteButton := TscGPCharGlyphButton.Create(Filter.FilterPanel); with Filter.DeleteButton do begin Parent := Filter.FilterPanel; Width := 24; Height := 24; Top := (Filter.FilterPanel.Height - Height) div 2; Align := alRight; Margins.Right := 5; Caption := '';

    // Button style
    Options.NormalColor := clBtnFace;
    Options.HotColor := clBtnFace;
    Options.PressedColor := clBtnFace;
    Options.FocusedColor := clBtnFace;
    
    // Glyph settings
    GlyphOptions.NormalColor := clGray;
    GlyphOptions.HotColor := clRed;
    GlyphOptions.PressedColor := clMaroon;
    GlyphOptions.Size := 10;
    GlyphOptions.Index := 13; // 'X' glyph
    
    OnClick := FilterDeleteButtonClick;
    Tag := NativeInt(Filter);
    

    end;

    LogToFile(Format('Created new filter panel: %s', [Filter.FilterPanel.Name])); end;

    function TORMSearchForm.GetOperatorDisplayText(AOperator: TFilterOperator): string; begin case AOperator of foEqual: Result := '='; foNotEqual: Result := '<>'; foGreaterThan: Result := '>'; foLessThan: Result := '<'; foGreaterEqual: Result := '>='; foLessEqual: Result := '<='; foBetween: Result := 'between'; foContains: Result := 'contains'; foBeginsWith: Result := 'starts with'; foEndsWith: Result := 'ends with'; foIsNull: Result := 'is empty'; foIsNotNull: Result := 'is not empty'; else Result := '='; end; end;

    procedure TORMSearchForm.RemoveActiveFilter(Filter: TActiveFilter); var idx: Integer; PanelToRemove: TscGPPanel; begin LogToFile('Starting RemoveActiveFilter');

    if not Assigned(Filter) then Exit;

    try // Find filter index idx := FActiveFilters.IndexOf(Filter); if idx < 0 then Exit;

    // Save panel reference and clear it from filter
    PanelToRemove := Filter.FilterPanel;
    Filter.FilterPanel := nil;  // Prevent double-free
    
    // Remove filter from collection
    FActiveFilters.Delete(idx);
    LogToFile(Format('Removed filter. Remaining count: %d', [FActiveFilters.Count]));
    
    // Free the panel
    if Assigned(PanelToRemove) then
    begin
      PanelToRemove.Parent := nil;
      PanelToRemove.Free;
    end;
    
    // Update layout and data
    UpdatePanelLayouts;
    LoadData;
    
    LogToFile('Filter removal completed successfully');
    

    except on E: Exception do LogToFile(Format('Error removing filter: %s', [E.Message])); end; end;

    procedure TORMSearchForm.ArrangeFilterPanels; const PADDING_TOP = 5; PADDING_BOTTOM = 5; var RequiredHeight: Integer; i: Integer; FilterPanel: TscGPPanel; YPosition: Integer; begin LogToFile(Format('Starting ArrangeFilterPanels with %d filters', [FActiveFilters.Count]));

    // Hide panel if no filters if FActiveFilters.Count = 0 then begin pnlActiveFilters.Height := 0; pnlActiveFilters.Visible := False; pnlTop.Height := pnlFilters.Height; LogToFile('No filters - hiding panel'); Exit; end;

    // Calculate total height needed RequiredHeight := PADDING_TOP + PADDING_BOTTOM + (FActiveFilters.Count * FILTER_PANEL_HEIGHT) + (Max(0, FActiveFilters.Count - 1) * FILTER_PANEL_SPACING);

    LogToFile(Format('Required height calculated: %d for %d filters', [RequiredHeight, FActiveFilters.Count]));

    // Set panel heights - IMPORTANT: Set Constraints first pnlActiveFilters.Constraints.MinHeight := RequiredHeight; pnlActiveFilters.Constraints.MaxHeight := RequiredHeight;

    // Now set the actual heights pnlActiveFilters.DisableAlign; try pnlActiveFilters.Visible := True; pnlActiveFilters.Height := RequiredHeight; pnlTop.Height := pnlFilters.Height + RequiredHeight;

    // Position each filter panel
    YPosition := PADDING_TOP;
    for i := FActiveFilters.Count - 1 downto 0 do
    begin
      FilterPanel := FActiveFilters[i].FilterPanel;
      if Assigned(FilterPanel) then
      begin
        // Explicitly set panel properties
        FilterPanel.DisableAlign;
        try
          FilterPanel.Parent := pnlActiveFilters;
          FilterPanel.Align := alNone;
          FilterPanel.Anchors := [akLeft, akTop, akRight]; // Add anchors
          FilterPanel.Top := YPosition;
          FilterPanel.Left := PANEL_MARGIN;
          FilterPanel.Width := pnlActiveFilters.ClientWidth - (2 * PANEL_MARGIN);
          FilterPanel.Height := FILTER_PANEL_HEIGHT;
          FilterPanel.Visible := True;
          FilterPanel.BringToFront;
    
          LogToFile(Format('Positioned filter panel %d at Y=%d', [i, FilterPanel.Top]));
    
          Inc(YPosition, FILTER_PANEL_HEIGHT + FILTER_PANEL_SPACING);
        finally
          FilterPanel.EnableAlign;
        end;
      end;
    end;
    

    finally pnlActiveFilters.EnableAlign; end;

    // Force size pnlActiveFilters.Height := RequiredHeight; LogToFile(Format('Set final heights - Active Filters Panel: %d, Required: %d', [pnlActiveFilters.Height, RequiredHeight]));

    // Ensure visibility and update pnlActiveFilters.Invalidate; pnlTop.Invalidate; Application.ProcessMessages;

    // Double-check height after processing if pnlActiveFilters.Height <> RequiredHeight then begin LogToFile('Height mismatch detected - forcing correction'); pnlActiveFilters.Height := RequiredHeight; end;

    LogToFile(Format('Finished arranging. Final panel height: %d', [pnlActiveFilters.Height])); end;

    procedure TORMSearchForm.UpdatePanelLayouts; begin LogToFile('Starting UpdatePanelLayouts');

    pnlActiveFilters.DisableAlign; try // Rearrange all filter panels ArrangeFilterPanels;

    // Ensure parent panels are properly sized
    pnlActiveFilters.Realign;
    pnlTop.Realign;
    

    finally pnlActiveFilters.EnableAlign; end;

    // Force visual update pnlActiveFilters.Refresh; pnlTop.Refresh;

    LogToFile(Format('Panel layouts updated. Active filters: %d, Panel height: %d', [FActiveFilters.Count, pnlActiveFilters.Height])); end;

    procedure TORMSearchForm.FilterDeleteButtonClick(Sender: TObject); var Filter: TActiveFilter; begin if not (Sender is TscGPCharGlyphButton) then Exit;

    // Get filter from button's tag Filter := TActiveFilter(TscGPCharGlyphButton(Sender).Tag); if Assigned(Filter) then RemoveActiveFilter(Filter); end;

    function TORMSearchForm.BuildWhereClause: string; var SQLBuilder: TStringBuilder; i: Integer; Filter: TActiveFilter; NeedsAND: Boolean; begin SQLBuilder := TStringBuilder.Create; try NeedsAND := False;

    for i := 0 to FActiveFilters.Count - 1 do
    begin
      Filter := FActiveFilters[i];
    
      if NeedsAND then
        SQLBuilder.Append(' AND ');
    
      // Add current filter condition
      case Filter.DataType of
        tiString:
          case Filter.FilterOperator of
            foEqual: SQLBuilder.AppendFormat('%s = %s',
              [Filter.FieldName, QuotedStr(Filter.Value1)]);
            foContains: SQLBuilder.AppendFormat('%s LIKE %s',
              [Filter.FieldName, QuotedStr('%' + Filter.Value1 + '%')]);
            foBeginsWith: SQLBuilder.AppendFormat('%s LIKE %s',
              [Filter.FieldName, QuotedStr(Filter.Value1 + '%')]);
            foEndsWith: SQLBuilder.AppendFormat('%s LIKE %s',
              [Filter.FieldName, QuotedStr('%' + Filter.Value1)]);
            foIsNull: SQLBuilder.AppendFormat('%s IS NULL', [Filter.FieldName]);
            foIsNotNull: SQLBuilder.AppendFormat('%s IS NOT NULL', [Filter.FieldName]);
          end;
    
        tiInteger, tiFloat, tiMoney:
          case Filter.FilterOperator of
            foEqual: SQLBuilder.AppendFormat('%s = %s',
              [Filter.FieldName, Filter.Value1]);
            foGreaterThan: SQLBuilder.AppendFormat('%s > %s',
              [Filter.FieldName, Filter.Value1]);
            foLessThan: SQLBuilder.AppendFormat('%s < %s',
              [Filter.FieldName, Filter.Value1]);
            foBetween: SQLBuilder.AppendFormat('%s BETWEEN %s AND %s',
              [Filter.FieldName, Filter.Value1, Filter.Value2]);
            foIsNull: SQLBuilder.AppendFormat('%s IS NULL', [Filter.FieldName]);
            foIsNotNull: SQLBuilder.AppendFormat('%s IS NOT NULL', [Filter.FieldName]);
          end;
    
        tiDate, tiDateTime:
          case Filter.FilterOperator of
            foEqual: SQLBuilder.AppendFormat('%s = %s',
              [Filter.FieldName, QuotedStr(Filter.Value1)]);
            foGreaterThan: SQLBuilder.AppendFormat('%s > %s',
              [Filter.FieldName, QuotedStr(Filter.Value1)]);
            foLessThan: SQLBuilder.AppendFormat('%s < %s',
              [Filter.FieldName, QuotedStr(Filter.Value1)]);
            foBetween: SQLBuilder.AppendFormat('%s BETWEEN %s AND %s',
              [Filter.FieldName, QuotedStr(Filter.Value1), QuotedStr(Filter.Value2)]);
            foIsNull: SQLBuilder.AppendFormat('%s IS NULL', [Filter.FieldName]);
            foIsNotNull: SQLBuilder.AppendFormat('%s IS NOT NULL', [Filter.FieldName]);
          end;
      end;
    
      NeedsAND := True;
    end;
    
    if SQLBuilder.Length > 0 then
      Result := ' WHERE ' + SQLBuilder.ToString
    else
      Result := '';
    

    finally SQLBuilder.Free; end; end;

    procedure TORMSearchForm.btnSearchClick(Sender: TObject); begin LoadData; end;

    procedure TORMSearchForm.LoadData; var SQL: string; begin if not Assigned(FQuery) then FQuery := TUniQuery.Create(nil);

    try SQL := FBaseQuery;

    // Add WHERE clause if there are filters
    if FActiveFilters.Count > 0 then
      SQL := SQL + BuildWhereClause;
    
    FQuery.Close;
    FQuery.SQL.Text := SQL;
    FQuery.Open;
    
    UpdateGridData;
    

    except on E: Exception do begin ShowMessage('Error loading data: ' + E.Message); FQuery.Close; end; end; end;

    function TORMSearchForm.GetFilteredSQL: string; begin Result := FBaseQuery; if FActiveFilters.Count > 0 then Result := Result + BuildWhereClause; end;

    procedure TORMSearchForm.UpdateGridData; var Row: Integer; begin SearchGrid.RowCount := FQuery.RecordCount + 1;

    Row := 1; FQuery.First; while not FQuery.Eof do begin for var i := 0 to FSearchColumns.Count - 1 do begin var Field := FQuery.FieldByName(FSearchColumns[i].FieldName); if Assigned(Field) then begin if Field.IsNull then SearchGrid.Cells[i, Row] := '' else case FSearchColumns[i].DataType of tiDate: SearchGrid.Cells[i, Row] := DateToStr(Field.AsDateTime); tiDateTime: SearchGrid.Cells[i, Row] := DateTimeToStr(Field.AsDateTime); tiFloat, tiMoney: SearchGrid.Cells[i, Row] := FormatFloat('#,##0.00', Field.AsFloat); else SearchGrid.Cells[i, Row] := Field.AsString; end; end; end; Inc(Row); FQuery.Next; end; end;

    procedure TORMSearchForm.UpdateSelectedSearch; var Row: Integer; begin Row := GetSelectedRow; if Row < 1 then Exit;

    FSelectedSearch := TSelectedSearch.Create;

    for var i := 0 to FSearchColumns.Count - 1 do begin var Field := FQuery.FieldByName(FSearchColumns[i].FieldName); if Assigned(Field) then begin var Value: TValue; if Field.IsNull then Value := TValue.Empty else case Field.DataType of ftString, ftWideString: Value := TValue.From(Field.AsString); ftInteger, ftSmallint: Value := TValue.From(Field.AsInteger); ftFloat, ftCurrency: Value := TValue.From(Field.AsFloat); ftDateTime, ftDate: Value := TValue.From(Field.AsDateTime); ftBoolean: Value := TValue.From(Field.AsBoolean); else Value := TValue.From(Field.AsString); end;

      FSelectedSearch.SetValue(
        FSearchColumns[i].FieldName,
        Value,
        SearchGrid.Cells[i, Row]
      );
    end;
    

    end; end;

    function TORMSearchForm.GetSelectedRow: Integer; begin Result := SearchGrid.Row; if Result >= SearchGrid.RowCount then Result := -1; end;

    procedure TORMSearchForm.SearchGridDblClick(Sender: TObject); begin if GetSelectedRow > 0 then ModalResult := mrOk; end;

    procedure TORMSearchForm.btnCloseClick(Sender: TObject); begin ModalResult := mrCancel; end;

    procedure TORMSearchForm.btnClearFiltersClick(Sender: TObject); begin FActiveFilters.Clear; UpdatePanelLayouts; LoadData; end;

    procedure TORMSearchForm.FormDestroy(Sender: TObject); begin ClearActiveFilters; FActiveFilters.Free; FSearchColumns.Free; FFieldTypes.Free; FQuery.Free; end;

    procedure TORMSearchForm.cboOperatorChange(Sender: TObject); begin UpdateValueControls; end;

    procedure TORMSearchForm.btnAddFilterClick(Sender: TObject); var Filter: TActiveFilter; Column: TSearchColumn; CurrentValue1, CurrentValue2: string; begin if cboField.ItemIndex < 0 then Exit;

    // Get current values if dateValue1.Visible then CurrentValue1 := DateToStr(dateValue1.Date) else CurrentValue1 := edtValue1.Text;

    if dateValue2.Visible then CurrentValue2 := DateToStr(dateValue2.Date) else CurrentValue2 := edtValue2.Text;

    // Find corresponding column for Column in FSearchColumns do begin if Column.DisplayName = cboField.Text then begin // Validate values if not ValidateFilterValue(CurrentValue1, Column.DataType) or ((cboOperator.Text = 'Between') and not ValidateFilterValue(CurrentValue2, Column.DataType)) then begin ShowMessage('Please enter valid values for the selected data type'); Exit; end;

      Filter := TActiveFilter.Create;
      try
        // Set basic properties
        Filter.FieldName := Column.FieldName;
        Filter.DisplayName := Column.DisplayName;
        Filter.DataType := Column.DataType;
        Filter.Value1 := CurrentValue1;
        Filter.Value2 := CurrentValue2;
    
        // Map operator string to enum
        case cboOperator.ItemIndex of
          0: Filter.FilterOperator := foEqual;
          1: Filter.FilterOperator := foContains;
          2: Filter.FilterOperator := foBeginsWith;
          3: Filter.FilterOperator := foEndsWith;
          4: Filter.FilterOperator := foGreaterThan;
          5: Filter.FilterOperator := foLessThan;
          6: Filter.FilterOperator := foBetween;
          7: Filter.FilterOperator := foIsNull;
          8: Filter.FilterOperator := foIsNotNull;
        end;
    
        // Create visual components
        CreateFilterPanel(Filter);
        FActiveFilters.Add(Filter);
        UpdatePanelLayouts;
    
        // Clear inputs
        edtValue1.Clear;
        edtValue2.Clear;
        if dateValue1.Visible then dateValue1.Date := Date;
        if dateValue2.Visible then dateValue2.Date := Date;
    
      except
        Filter.Free;
        raise;
      end;
      Break;
    end;
    

    end;

    // Refresh data with new filter LoadData; end;

    procedure TORMSearchForm.SetupGrid; begin with SearchGrid do begin Options := [goFixedVertLine, goFixedHorzLine, goVertLine, goHorzLine, goRangeSelect, goRowSelect]; FixedRows := 1; RowCount := 2; ColCount := 2; // Will be updated when columns are added

    // Basic styling
    Font.Name := 'Segoe UI';
    Font.Size := 9;
    DefaultRowHeight := 25;
    FixedFont.Name := 'Segoe UI';
    FixedFont.Style := [fsBold];
    
    // Colors
    FixedColor := clBtnFace;
    Color := clWhite;
    

    end; end;

    procedure TORMSearchForm.ClearActiveFilters; begin for var Filter in FActiveFilters do begin if Assigned(Filter.FilterPanel) then Filter.FilterPanel.Free; end; FActiveFilters.Clear; UpdatePanelLayouts; end;

    procedure TORMSearchForm.SetupORMFilter; begin if FIsORMMode then begin if not Assigned(FORMFilter) then FORMFilter := TORMFilter.Create(nil);

    // Clear existing filters
    FORMFilter.Clear;
    
    // Add filters from active filters
    for var Filter in FActiveFilters do
    begin
      case Filter.FilterOperator of
        foEqual:
          FORMFilter.Where(Filter.FieldName).EqualTo(Filter.Value1);
        foNotEqual:
          FORMFilter.Where(Filter.FieldName).NotEqualTo(Filter.Value1);
        foGreaterThan:
          FORMFilter.Where(Filter.FieldName).GreaterThan(Filter.Value1);
        foLessThan:
          FORMFilter.Where(Filter.FieldName).LessThan(Filter.Value1);
        foGreaterEqual:
          FORMFilter.Where(Filter.FieldName).GreaterOrEqual(Filter.Value1);
        foLessEqual:
          FORMFilter.Where(Filter.FieldName).LessOrEqual(Filter.Value1);
        foBetween:
          FORMFilter.Where(Filter.FieldName).Between(Filter.Value1, Filter.Value2);
        foContains:
          FORMFilter.Where(Filter.FieldName).Contains(Filter.Value1);
        foBeginsWith:
          FORMFilter.Where(Filter.FieldName).BeginsWith(Filter.Value1);
        foEndsWith:
          FORMFilter.Where(Filter.FieldName).EndsWith(Filter.Value1);
        foIsNull:
          FORMFilter.Where(Filter.FieldName).IsNull;
        foIsNotNull:
          FORMFilter.Where(Filter.FieldName).IsNotNull;
      end;
    end;
    

    end; end;

    end.


    Check why this unit is giving me an access violation when I close the form

  2. Assistant

    The access violation you're experiencing when closing the form is likely due to double-freeing of objects within your TORMSearchForm class. Specifically, both the FormDestroy event and the class destructor are attempting to free the same objects, leading to an attempt to access memory that has already been freed.

    Detailed Analysis

    1. Destructor Implementation:

      destructor TORMSearchForm.Destroy;
      begin
        try
          // Free collections in reverse order of creation
          FFieldTypes.Free;
          FSearchColumns.Free;
          FActiveFilters.Free;
          FQuery.Free;
        finally
          inherited Destroy;
        end;
      end;
      

      The destructor correctly frees the following objects:

      • FFieldTypes
      • FSearchColumns
      • FActiveFilters
      • FQuery
    2. FormDestroy Event:

      procedure TORMSearchForm.FormDestroy(Sender: TObject);
      begin
        ClearActiveFilters;
        FActiveFilters.Free;
        FSearchColumns.Free;
        FFieldTypes.Free;
        FQuery.Free;
      end;
      

      The FormDestroy event is also attempting to free the same objects:

      • FActiveFilters
      • FSearchColumns
      • FFieldTypes
      • FQuery
    3. Double-Free Scenario:

      Since both the destructor and the FormDestroy event are freeing the same objects, the first free operation releases the memory, and the second attempt to free the already freed memory leads to an access violation.

    Recommended Solution

    To resolve the access violation, you should remove the freeing logic from the FormDestroy event. The destructor already handles the cleanup of these objects, and having the cleanup in both places is redundant and problematic.

    Here's how you can modify your code:

    1. Remove Free Calls from FormDestroy:

      procedure TORMSearchForm.FormDestroy(Sender: TObject);
      begin
        ClearActiveFilters;
        // Remove the following lines:
        // FActiveFilters.Free;
        // FSearchColumns.Free;
        // FFieldTypes.Free;
        // FQuery.Free;
      end;
      
    2. Optionally, Update ClearActiveFilters:

      Ensure that ClearActiveFilters does not attempt to free objects that are managed elsewhere. If ClearActiveFilters is only responsible for clearing the contents of FActiveFilters without freeing the list itself, it should look like this:

      procedure TORMSearchForm.ClearActiveFilters;
      begin
        for var Filter in FActiveFilters do
        begin
          if Assigned(Filter.FilterPanel) then
            Filter.FilterPanel.Free;
        end;
        FActiveFilters.Clear;
        UpdatePanelLayouts;
      end;
      
    3. Verify Ownership and Management:

      Ensure that all objects are owned and managed correctly. For instance, if any components or objects are created with an owner (like TComponent), Delphi will handle their destruction automatically. Verify that objects like FFilterPanel and others are not being freed multiple times.

    Additional Recommendations

    While the double-free issue is the most probable cause of the access violation, it's also good practice to review the following areas to prevent similar issues:

    • Object Ownership: Ensure that components created dynamically have their Owner property set appropriately. This allows Delphi to manage their lifetimes automatically.

    • Event Handlers: Verify that event handlers (like FilterDeleteButtonClick) are not causing unintended side effects or accessing freed objects.

    • Exception Safety: Ensure that all objects are properly freed even if exceptions occur. Using try...finally blocks is a good practice, which you already have in the destructor.

    • Logging and Debugging: Utilize the LogToFile procedure effectively to trace the flow of object creation and destruction. This can help identify where the double-free might be occurring.

    Summary

    By removing the redundant freeing of objects in the FormDestroy event and relying solely on the destructor for cleanup, you should eliminate the access violation when closing the form.


    Updated FormDestroy Procedure:

    procedure TORMSearchForm.FormDestroy(Sender: TObject);
    begin
      ClearActiveFilters;
      // Removed freeing of objects to prevent double-freeing
    end;
    

    Destructor Remains Unchanged:

    destructor TORMSearchForm.Destroy;
    begin
      try
        // Free collections in reverse order of creation
        FFieldTypes.Free;
        FSearchColumns.Free;
        FActiveFilters.Free;
        FQuery.Free;
      finally
        inherited Destroy;
      end;
    end;
    

    By making these adjustments, you ensure that each object is freed exactly once, preventing access violations related to memory corruption.


    If the Issue Persists:

    If after making the above changes the access violation still occurs, consider the following steps:

    1. Use Debugging Tools: Utilize Delphi’s debugging tools to determine the exact line where the access violation occurs.

    2. Check Event Handlers: Ensure that no event handlers are accessing objects after they've been freed.

    3. Review Additional Resources: Make sure that all dynamically created objects are being managed correctly and not causing memory leaks or corruption elsewhere in the code.

    Feel free to provide more details or error logs if further assistance is needed!