Rende le finestre di dialogo compatibili con "caratteri grandi".

Question

Quali ritieni siano le migliori pratiche per rendere la finestra di dialogo di Windows compatibile sia con i caratteri standard (96 dpi) che con l'impostazione "caratteri grandi" (120 dpi) in modo che gli oggetti non si sovrappongano o si tagliano?

BTW: Nel caso sia pertinente, sono interessato a farlo per i dialoghi Delphi.

Grazie in anticipo!

Answer 1

C'è un articolo abbastanza buono nel file della guida di D2007, sotto "Considerations When Dynamically Resizing Forms and Controls" (si noti che l'URL si trova nel file della guida stesso e non in una pagina Web in quanto tale).

Lo stesso argomento, con lo stesso nome, può essere trovato nel D2010 help file (stessa avvertenza sull'URL come sopra) o sul docwiki.

Vale anche la pena (almeno un po ') di esaminare TForm.Scaled e TForm.ScaleBy.

Answer 2

In generale, è necessario utilizzare i gestori di layout per questo scopo. Quello per cui sono progettati.

Delphi (non ha funzionato per molto tempo) non dispone di tali gestori ma è in grado di gestire dpi diversi da allora. È necessario utilizzare l'autosize propery dei componenti per assicurarsi che abbiano le giuste dimensioni per il testo che visualizzano. Per evitare la sovrapposizione dei componenti, sistemali sul modulo utilizzando le proprietà di allineamento e ancoraggio. Alla fine devi raggruppare i componenti in contenitori per ottenere un layout corretto.

Answer 3

• Non mettere mai un controllo e la sua etichetta descrittiva fianco a fianco, posizionare sempre l'etichetta su di esso.

Ma a parte questo? Forse:

• Lascia uno spazio sufficiente a destra e in fondo alle etichette in modo che non si sovrappongano ad altri controlli quando si utilizzano caratteri grandi.

Non ho mai provato a utilizzare TLabeledEdit in quello scenario, forse lo fanno automaticamente?

Answer 4

Ci sono presunte soluzioni commerciali (Developer Express VCL Layout Manager). Ma non mi fido di nessuno di loro. Ho il sospetto che Embarcadero dovrebbe affrontare questo come una debolezza critica nel set di componenti dell'interfaccia utente corrente (VCL).

Penso che il set di componenti di terze parti potrebbe essere la soluzione più veloce in questo momento. È commerciale ma non eccessivamente costoso.

http://www.devexpress.com/products/VCL/ExLayoutControl/

Answer 5

Questo è come io cerco di fare con pixel di Delphi VCL indipendentemente dall'impostazione della dimensione del font di Windows.

unit App.Screen; 

interface 

uses Controls; 

type 
    TAppScreen = class(TObject) 
    private 
    FDefaultPixelsPerInch: integer; 
    FPixelsPerInch: integer; 
    function GetPixelsPerInch: integer; 
    procedure SetPixelsPerInch(const Value: integer); 
    public 
    procedure AfterConstruction; override; 
    function DefaultPixelsPerInch: integer; 
    function InAcceptableRange(const aPPI: integer): boolean; 
    procedure ScaleControl(const aControl: TWinControl); 
    property PixelsPerInch: integer read GetPixelsPerInch write SetPixelsPerInch; 
    end; 

    TAppScreenHelper = class helper for TAppScreen 
    private 
    class var FInstance: TAppScreen; 
    class function GetInstance: TAppScreen; static; 
    public 
    class procedure Setup; 
    class procedure TearDown; 
    class property Instance: TAppScreen read GetInstance; 
    end; 

implementation 

uses 
    TypInfo, Windows, SysUtils, Forms, Graphics; 

type 
    TScreenEx = class(TScreen) 
    published 
    property PixelsPerInch; 
    end; 

    TScreenHelper = class helper for TScreen 
    public 
    procedure SetPixelsPerInch(Value: integer); 
    end; 

procedure TScreenHelper.SetPixelsPerInch(Value: integer); 
begin 
    PInteger(Integer(Self) + (Integer(GetPropInfo(TScreenEx, 'PixelsPerInch').GetProc) and $00FFFFFF))^ := Value; 
end; 

procedure TAppScreen.AfterConstruction; 
begin 
    inherited; 
    FDefaultPixelsPerInch := Screen.PixelsPerInch; 
    FPixelsPerInch := FDefaultPixelsPerInch; 
end; 

function TAppScreen.DefaultPixelsPerInch: integer; 
begin 
    Result := FDefaultPixelsPerInch; 
end; 

function TAppScreen.GetPixelsPerInch: integer; 
begin 
    Result := FPixelsPerInch; 
end; 

function TAppScreen.InAcceptableRange(const aPPI: integer): boolean; 
begin 
    if DefaultPixelsPerInch > aPPI then 
    Result := DefaultPixelsPerInch * 0.55 < aPPI 
    else if DefaultPixelsPerInch < aPPI then 
    Result := DefaultPixelsPerInch * 1.55 > aPPI 
    else 
    Result := True; 
end; 

procedure TAppScreen.ScaleControl(const aControl: TWinControl); 
begin 
    aControl.ScaleBy(PixelsPerInch, DefaultPixelsPerInch); 
end; 

procedure TAppScreen.SetPixelsPerInch(const Value: integer); 
begin 
    FPixelsPerInch := Value; 
    Screen.SetPixelsPerInch(FPixelsPerInch); 
end; 

class function TAppScreenHelper.GetInstance: TAppScreen; 
begin 
    if FInstance = nil then 
    FInstance := TAppScreen.Create; 
    Result := FInstance; 
end; 

class procedure TAppScreenHelper.Setup; 
begin 
    TAppScreen.Instance; 
end; 

class procedure TAppScreenHelper.TearDown; 
begin 
    FInstance.Free; 
    FInstance := nil; 
end; 

initialization 
    TAppScreen.Setup; 
finalization 
    TAppScreen.TearDown; 
end. 

provare il seguente per testare gli effetti del diverso valore di pixel:

TAppScreen.Instance.PixelsPerInch := 120; 
TAppScreen.Instance.PixelsPerInch := 96; 
TAppScreen.Instance.PixelsPerInch := 150; 

è necessario modificare il PixelsPerInch prima di istanziare discendente di TForm tra cui i dialoghi VCL di Delphi.