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?

23
demandé sur Crisfole 2010-10-28 19:27:06

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 FormControl):

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 un Graphics disponible dans son Graphics 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)
27
répondu Crisfole 2013-07-02 17:40:20

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

4
répondu Renaud Bompuis 2010-12-16 07:21:04

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
4
répondu Jayesh 2012-07-15 13:28:09

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).

2
répondu ShaneLS 2018-03-14 20:16:47