Comment convertir des Twips en Pixels in.NET?
Je travaille sur un projet de migration dans lequel une base de données stocke réellement les tailles d'affichage dans twips. Comme je ne peux pas utiliser twips pour attribuer des tailles aux contrôles WPF ou Winforms, je me demandais si. net avait une méthode de conversion Utilisable à l'exécution?
4 réponses
Il s'avère que l'outil de migration a quelque chose, mais cela ne servirait à rien à l'exécution. Voici ce que j'ai fait (si la valeur codée en dur dans la méthode d'extension était changée en valeur pour les points par pouce, cela fonctionnerait aussi comme un convertisseur de points):
1 Twip = 1 / 1440ème de pouce.
L'objet. Net Graphics
a une méthode DpiX
et DpiY
qui peut être utilisée pour déterminer le nombre de pixels par pouce.
En utilisant ces mesures j'ai créé 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 suffit de faire ce qui suit (en supposant que vous êtes dans un contexte où CreateGraphics
renvoie un objet Drawing.Graphics
(ici this
est un formulaire, donc {[6] } est hérité de la super-classe de Form
Control
):
using( Graphics g = CreateGraphics() )
{
Width = g.ConvertTwipsToXPixels(sizeInTwips);
Height = g.ConvertTwipsToYPixels(sizeInTwips);
}
Voir la section "Remarques" dans le Graphics
Class documentation pour une liste des moyens d'obtenir un objet graphique. Une documentation plus complète est disponible dans le tutoriel Comment créer des objets graphiques .
Bref résumé des moyens les plus faciles:
Control.CreateGraphics
- une Peinture de l'événement
PaintEventArgs
est unGraphics
disponible dans sonGraphics
la propriété. - Hand {[17] } une image et il retournera un objet
Graphics
qui peut dessiner sur cette image. (Remarque: Il est peu probable que vous souhaitiez utiliser twips pour une image réelle)
Pour référence, une autre version C#, utilisant L'API Win32 au lieu de nécessiter 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: comment convertir des Twips en Pixels
Pour les projets de migration, nous pouvons utiliser des fonctions de support converstion intégrées
microsoft.visualbasic.compatibility.vb6.twipsperpixelx
microsoft.visualbasic.compatibility.vb6.twipsperpixely
Ancien post je sais Mais voici un FYI et quelques mathématiques pour les 1440 Réponses ci-dessus...
Un twip est pas simplement 1/1440
ème de pouce. Un twip est 1/20
de point.
Le point avec lequel vous travaillez dans un document imprimable est généralement un 72dpi postscript:
72dpi * 20Twips/Point = 1440twips
.
Donc, en traitant par exemple un rapport de cristal, avec une largeur de twips de 15840
(et des marges de 0 twips),
la largeur serait 11 inches (15840 / (72 * 20))
.
Basé sur une densité d'écran de 96 dpi, le rapport publier à l'écran à:
1056px wide (96dpi * 11in = 1056px)
.