अपनी सामग्री के अनुसार डीबीजीड (या अन्य समान) कॉलम चौड़ाई को फिट/स्केल कैसे करें?

Question

मैं DBGrid के साथ एक फ्रेम बनाने की कोशिश कर रहा हूं जो 10 से अधिक टेबलों के लिए अपने आधे फ़ील्ड डिफ़ॉल्ट के रूप में और प्रत्येक तालिका के लिए विशेष रूप से अन्य फ़ील्ड के साथ काम करेगा।

कॉलम के लिए जगह सीमित है और मैं प्रत्येक तालिका के प्रत्येक कॉलम को मैन्युअल रूप से कॉन्फ़िगर नहीं करना चाहता क्योंकि यह बहुत खराब गुणवत्ता का काम है, मैं सबसे बड़ी सामग्री द्वारा प्रत्येक कॉलम की चौड़ाई की गणना करने का एक तरीका सोच रहा था उस कॉलम के अंदर एक पंक्ति, जो स्वयं के घटक या डेटा सेट द्वारा मापा जाता है।

क्या कोई रास्ता जानता है? क्या दुनिया में कुछ शक्ति उस शक्ति के साथ है? मुझे एक ऐसे समाधान की आवश्यकता है जो ग्रिड के सभी दृश्यमान कॉलम के दृश्यमान डेटा के अनुसार आकार में वृद्धि और कमी को लागू करे। मेरे समाधान को अब तक चयनित सेल की पेंटिंग में कोई समस्या है, चयनित डेटासेट पंक्ति से चुड़ैल कूदता है।

---

नोट: कृपया, मेरे सवाल बंद नहीं करते। यह ग्रिड की चौड़ाई या फॉर्म की चौड़ाई के साथ फिट के बारे में नहीं है। यह क्षैतिज स्क्रॉलबार को कम करने के लिए सभी कॉलम चौड़ाई के बारे में है, लेकिन जरूरी नहीं कि इसे छुपाएं।

Answer 1

आप क्या करना है मीटर ग्रिड के कैनवास का उपयोग करने के लिए है प्रत्येक कॉलम की सामग्री को आसान बनाएं और तदनुसार कॉलम की चौड़ाई निर्धारित करें। आप या तो डेटासेट के माध्यम से फिर से चल सकते हैं या फ्लाई पर चौड़ाई समायोजित करने के लिए OnColumnDraw-Event का उपयोग कर सकते हैं।

यहां एक नमूना है अगर वहाँ स्क्रॉल बार या नहीं हो गया है देखभाल के बिना

procedure TForm7.DBGridDrawColumnCell(Sender: TObject; const Rect: TRect; 
    DataCol: Integer; Column: TColumn; State: TGridDrawState); 
Var 
    w : Integer; 

begin 
    w := 5+DBGrid.Canvas.TextExtent(Column.Field.DisplayText).cx; 
    if w>column.Width then Column.Width := w; 
end; 

procedure TForm7.FormActivate(Sender: TObject); 
Var 
    i : Integer; 

begin 
    // Initialize width 
    for I := 0 to DBGrid.Columns.Count - 1 do 
    DBGrid.Columns[i].Width := 5 + DBGrid.Canvas.TextWidth(DBGrid.Columns[i].title.caption) 
end; 

Answer 2

संपादित:

मेरा पहला कोड के बारे में इस नए कोड के साथ, साथ ग्रिड के अंदर कॉलम फिट किया गया था, AutoSizeColumns रिकॉर्ड पढ़ता है जब तक MaxRows या Dataset.Eof प्रत्येक स्तंभ की चौड़ाई calc करने के लिए:

class function TDBGridHelper.AutoSizeColumns(DBGrid: TDBGrid; const MaxRows: Integer = 25): Integer; 

var 
    DataSet: TDataSet; 
    Bookmark: TBookmark; 
    Count, I: Integer; 
    ColumnsWidth: array of Integer; 
begin 
    SetLength(ColumnsWidth, DBGrid.Columns.Count); 
    for I := 0 to DBGrid.Columns.Count - 1 do 
    if DBGrid.Columns[I].Visible then 
     ColumnsWidth[I] := DBGrid.Canvas.TextWidth(DBGrid.Columns[I].Title.Caption + ' ') 
    else 
     ColumnsWidth[I] := 0; 
    if DBGrid.DataSource <> nil then 
    DataSet := DBGrid.DataSource.DataSet 
    else 
    DataSet := nil; 
    if (DataSet <> nil) and DataSet.Active then 
    begin 
    Bookmark := DataSet.GetBookmark; 
    DataSet.DisableControls; 
    try 
     Count := 0; 
     DataSet.First; 
     while not DataSet.Eof and (Count < MaxRows) do 
     begin 
     for I := 0 to DBGrid.Columns.Count - 1 do 
      if DBGrid.Columns[I].Visible then 
      ColumnsWidth[I] := Max(ColumnsWidth[I], DBGrid.Canvas.TextWidth(
       DBGrid.Columns[I].Field.Text)); 
     Inc(Count); 
     DataSet.Next; 
     end; 
    finally 
     DataSet.GotoBookmark(Bookmark); 
     DataSet.FreeBookmark(Bookmark); 
     DataSet.EnableControls; 
    end; 
    end; 
    Count := 0; 
    for I := 0 to DBGrid.Columns.Count - 1 do 
    if DBGrid.Columns[I].Visible then 
    begin 
     DBGrid.Columns[I].Width := ColumnsWidth[I]; 
     Inc(Count, ColumnsWidth[I]); 
    end; 
    Result := Count - DBGrid.ClientWidth; 
end; 

मैं DataSet.AfterOpen स्थिति में यह कहते हैं:

TGridHelper.AutoSizeColumns(MyDBGrid); 

Answer 3

यह समाधान बनाता है सभी स्तंभों उसे विस्तृत या के अनुसार हटना, सामग्री है (मैं उपयोग करने के लिए एक 5 पिक्सल के ऑफसेट था), और चयनित सेल ड्राइंग malfunction और रिकॉर्ड सूचक खराब होने को ठीक करें।

type 
    TColumnAutoAdjust = record {Save the information responsible for setting column widths in the grid} 
    Field: String;   {Field name whose information is being stored} 
    Registered: Boolean;  {Indicates whether the size of this column already registered} 
    Updated: Boolean;  {Indicates the actual size of the column was updated} 
    LastWidth: Integer;  {Width indicates the final text of a record of a row column} 
    CurrWidth: Integer;  {Indicates the current size and column width} 
    Reverter: Integer;  {Indicates the greatest width recorded but that is less than the current} 
    Scrolls: Integer;  {Indicates the amount of scrolls present after one width adjustment} 
    RecNo: Integer;   {Indicates which was the record in the table which increased the width of colune} 
    end; 

var { inside the forms private } 
    gdCols: array of TColumnAutoAdjust; { vetor de ajuste de largura de cada coluna na grade de resultado } 
    RegisteredCols: Integer; { quantas colunas já foram registradas no controle de ajuste } 
    gdVisibleRows: Integer; { quantas linhas de cadastros estão visíveis da grade de resultado } 
    gdVisibleCols: Integer; { quantas colunas de cadastros estão visíveis da grade de resultado } 

{ before showing the grid } 
    RegisteredCols := ResultGrid.Columns.Count; 
    SetLength(gdCols, RegisteredCols); { determina o tamanho da vetor de controle de colunas } 
    { libera a lista } 
    ResultGrid.Align := alClient; 
    for i := 0 to RegisteredCols -1 do { inicializando a largura das colunas no tamanho do título de cada } 
    begin 
     gdCols[i].Field := ResultGrid.Columns[i].FieldName; 
     ResultGrid.Columns[i].Width := ResultGrid.Canvas.TextExtent(ResultGrid.Columns[i].Title.Caption).cx; 
     ResultGrid.Columns[i].Alignment := taLeftJustify; 
     ResultGrid.Columns[i].Title.Alignment := taLeftJustify; 
    end; 
    BrowserQuery.Open; 
    ResultGrid.Show; 
    for i := 0 to gdVisibleRows do 
    begin 
     BrowserQuery.Next; 
     ResultGrid.Refresh; 
    end; 
    for i := 0 to gdVisibleRows do 
    begin 
     BrowserQuery.Prior; 
     ResultGrid.Refresh; 
    end; 
    BrowserQuery.First; 
    ResultGrid.SetFocus; 
    end 

{ after dataset scroll}  
procedure TRecordsBrowserFrameBase.BrowserQueryAfterScroll(DataSet: TDataSet); 
var 
    i, TitleWidth: Integer; 
    mayAdjustAgain: Boolean; { } 
begin 
{ ajusta as colunas da grade de resultado a cada movimento da tabela de resultado } 
    mayAdjustAgain := False; 
    for i := 0 to RegisteredCols -1 do 
    begin 
    if not gdCols[i].Updated then 
    begin 
     ResultGrid.Columns[i].Width := gdCols[i].CurrWidth; 
     gdCols[i].Scrolls := 0; 
     gdCols[i].Updated := True; 
    end 
    else 
    begin 
     Inc(gdCols[i].Scrolls); 
     if (DataSet.RecNo > gdCols[i].RecNo + gdVisibleRows) or (DataSet.RecNo < gdCols[i].RecNo - gdVisibleRows) then 
     begin 
     TitleWidth := MaxColSpacing + ResultGrid.Canvas.TextExtent(ResultGrid.Columns[i].Title.Caption).cx; 
     gdCols[i].LastWidth := gdCols[i].CurrWidth; 
     gdCols[i].CurrWidth := IFX(gdCols[i].Reverter > TitleWidth, gdCols[i].Reverter, TitleWidth); 
     gdCols[i].Reverter := IFX(gdCols[i].Reverter > TitleWidth, TitleWidth, 0); 
     gdCols[i].Updated := False; 
     mayAdjustAgain := True; 
     end; 
    end; 
    end; 
    if mayAdjustAgain then 
    begin 
    ResultGrid.Refresh; 
    BrowserQueryAfterScroll(DataSet); 
    end; 
end; 

{ on draw column cell } 

procedure TRecordsBrowserFrameBase.GridColumnWidthAdjust(Sender: TObject; const Rect: TRect; DataCol: Integer; Column: TColumn; State: TGridDrawState); 
var 
    ColWidth, TextWidth, TitleWidth: Integer; 
begin 
{ ajusta a capitalização do texto das células } 
    (Sender as TJvDBGrid).Canvas.Pen.Color := clWhite; 
    (Sender as TJvDBGrid).Canvas.Rectangle(Rect); 
    (Sender as TJvDBGrid).Canvas.TextOut(Rect.Left+2, Rect.Top+2, NameCase(Column.Field.DisplayText)); 
{ ajusta as colunas de uma grade de acordo com o conteúdo das células } 
    gdVisibleRows := (Sender as TJvDBGrid).VisibleRowCount; 
    gdVisibleCols := (Sender as TJvDBGrid).VisibleColCount; 
    TitleWidth := MaxColSpacing + (Sender as TJvDBGrid).Canvas.TextExtent(Column.Title.Caption).cx; 
    TextWidth := MaxColSpacing + (Sender as TJvDBGrid).Canvas.TextExtent(NameCase(Column.Field.DisplayText)).cx; 
    ColWidth := Column.Width; 
    {$WARNINGS OFF} 
    if (TextWidth > gdCols[DataCol].Reverter) and (TextWidth < ColWidth) then gdCols[DataCol].Reverter := TextWidth; 
    if (TextWidth > ColWidth) then { texto da célula é mais largo que a coluna } 
    begin 
    gdCols[DataCol].Registered := True; 
    gdCols[DataCol].LastWidth := ColWidth; 
    gdCols[DataCol].CurrWidth := TextWidth; 
    gdCols[DataCol].Updated := False; 
    gdCols[DataCol].RecNo := BrowserQuery.RecNo; 
    gdCols[DataCol].Reverter := TitleWidth; 
    Exit; 
    end; 
    if (ColWidth < TitleWidth) then { texto da célula é menor que o título da coluna } 
    begin 
    gdCols[DataCol].Registered := True; 
    gdCols[DataCol].LastWidth := ColWidth; 
    gdCols[DataCol].CurrWidth := TitleWidth; 
    gdCols[DataCol].Updated := False; 
    gdCols[DataCol].Reverter := TitleWidth; 
    Exit; 
    end; 
{$WARNINGS ON} 
end; 

Answer 4

इतना जटिल कोड का उपयोग क्यों करें? : डी बस इसका इस्तेमाल करें। इसके पास 5 पीएक्स ऑफ़सेट भी है।

procedure TForm1.FormActivate(Sender: TObject); 

var 

    i:integer; 

begin 

    for i :=0 to DbGrid1.Columns.Count - 1 do 
    DbGrid1.Columns[i].width :=5+dbgrid1.Canvas.TextWidth(DbGrid1.Columns[i].Title.Caption); 

end; 

Answer 5

प्रत्येक स्तंभ आप स्वत: होना चाहता हूँ के लिए संपत्ति SizePriority=1 सेट आकार और फिक्स्ड स्तंभों के लिए SizePriority=0 निर्धारित करते हैं, आपके मामले में केवल अंतिम स्तंभ ऑटो आकार होगा।

फिर संपत्ति grid.AutoFillColumns=true सेट करें और इसे करना चाहिए।