Comment convertir des twips en pixels dans .NET?

Question

Je travaille sur un projet de migration dans lequel une base de données stocke réellement des tailles d'affichage en twips. Comme je ne peux pas utiliser twips pour assigner des tailles aux contrôles WPF ou Winforms, je me demandais si .NET avait une méthode de conversion utilisable à l'exécution?

Answer 1

Il s'avère que l'outil de migration a quelque chose, mais il ne ferait rien de bon à l'exécution. Voici ce que j'ai fait (si la valeur codée en dur dans la méthode d'extension a été changée en valeur pour les points par pouce, cela fonctionnerait aussi comme un convertisseur de point):

1 Twip = 1/1440th of inch. L'objet .NET Graphics a une méthode DpiX et DpiY qui peut être utilisée pour déterminer combien de pixels sont dans un pouce. En utilisant ces mesures que je crée les méthodes d'extension suivantes pour Graphics:

using System.Drawing; 

static class Extensions 
{ 
    /// <summary> 
    /// Converts an integer value in twips to the corresponding integer value 
    /// in pixels on the x-axis. 
    /// </summary> 
    /// <param name="source">The Graphics context to use</param> 
    /// <param name="inTwips">The number of twips to be converted</param> 
    /// <returns>The number of pixels in that many twips</returns> 
    public static int ConvertTwipsToXPixels(this Graphics source, int twips) 
    { 
     return (int)(((double)twips) * (1.0/1440.0) * source.DpiX); 
    } 

    /// <summary> 
    /// Converts an integer value in twips to the corresponding integer value 
    /// in pixels on the y-axis. 
    /// </summary> 
    /// <param name="source">The Graphics context to use</param> 
    /// <param name="inTwips">The number of twips to be converted</param> 
    /// <returns>The number of pixels in that many twips</returns> 
    public static int ConvertTwipsToYPixels(this Graphics source, int twips) 
    { 
     return (int)(((double)twips) * (1.0/1440.0) * source.DpiY); 
    } 
} 

Pour utiliser ces méthodes, il faut simplement faire ce qui suit (en supposant que vous êtes dans un contexte où CreateGraphics retourne un objet Drawing.Graphics (ici this est un forme, donc CreateGraphics est héritée de super-classe de FormControl):

using(Graphics g = CreateGraphics()) 
{ 
    Width = g.ConvertTwipsToXPixels(sizeInTwips); 
    Height = g.ConvertTwipsToYPixels(sizeInTwips); 
} 

Voir la section « Remarques » dans la Graphics Class documentation une liste des façons d'obtenir un graphique objet ics. Une documentation plus complète est disponible dans le tutoriel How to: Create Graphics Objects.

Bref résumé des façons les plus simples:

• Control.CreateGraphics
• un événement de peinture PaintEventArgs a un Graphics disponible dans sa propriété Graphics.
• Main Graphics.FromImage une image et il renverra un objet Graphics qui peut dessiner sur cette image. (NOTE: Il est peu probable que vous aurez envie d'utiliser twips pour une image réelle)

Answer 2

Pour référence, une autre version C#, en utilisant l'API Win32 au lieu d'exiger un Graphics objets:

using System.Runtime.InteropServices; 

static class SomeUtils { 

    public static int ConvertTwipsToPixels(int twips, MeasureDirection direction) { 
    return (int)(((double)twips)*((double)GetPixperinch(direction))/1440.0); 
    } 

    public static int ConvertPixelsToTwips(int pixels, MeasureDirection direction) { 
    return (int)((((double)pixels)*1440.0)/((double)GetPixperinch(direction))); 
    } 

    public static int GetPPI(MeasureDirection direction) { 
    int ppi; 
    IntPtr dc = GetDC(IntPtr.Zero); 

    if (direction == MeasureDirection.Horizontal) 
     ppi = GetDeviceCaps(dc, 88); //DEVICECAP LOGPIXELSX 
    else 
     ppi = GetDeviceCaps(dc, 90); //DEVICECAP LOGPIXELSY 

    ReleaseDC(IntPtr.Zero, dc); 
    return ppi; 
    } 

    [DllImport("user32.dll")] 
    static extern IntPtr GetDC(IntPtr hWnd); 

    [DllImport("user32.dll")] 
    static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDC); 

    [DllImport("gdi32.dll")] 
    static extern int GetDeviceCaps(IntPtr hdc, int devCap); 
} 

public enum MeasureDirection { 
    Horizontal, 
    Vertical 
} 

Le MeasureDirection est censé être spécifié car il n'y a aucune garantie que les pixels sont toujours carrés (selon le kb).

Référence: kb210590: ACC2000: How to Convert Twips to Pixels

Answer 3

Pour les projets de migration, nous pouvons utiliser les fonctions intégrées de soutien de converstion

microsoft.visualbasic.compatibility.vb6.twipsperpixelx 
microsoft.visualbasic.compatibility.vb6.twipsperpixely 

Answer 4

poste Je sais, mais voici un FYI et un peu de mathématiques pour les 1440 réponses ci-dessus ...

Un twip n'est pas simplement 1/1440 d'un pouce. Un twip est 1/20 d'un point.

Le point que vous travaillez dans un document imprimable, en général, est un post-scriptum:

72dpi. 72dpi * 20Twips/Point = 1440twips. Donc, en traitant par exemple un rapport Crystal, avec une largeur de twips de 15840 (et des marges de 0 twips), la largeur serait 11 inches (15840/(72 * 20)).

Sur la base d'une densité d'écran de 96 dpi, le rapport à l'écran poster à:

1056px wide (96dpi * 11in = 1056px).