c# - modify - ¿Cómo convierto Twips a píxeles en.NET?

modify size form c#

Question

Estoy trabajando en un proyecto de migración en el que una base de datos realmente almacena los tamaños de visualización en twips. Dado que no puedo usar twips para asignar tamaños a los controles de WPF o Winforms, me preguntaba si .NET tiene un método de conversión que se pueda usar en el tiempo de ejecución.

Answer 1

Antiguo mensaje que conozco, pero aquí hay un FYI y algunas matemáticas para las 1440 respuestas anteriores ...

Un twip no es simplemente 1/1440 de una pulgada. Un twip es 1/20 de un punto .

El punto con el que está trabajando en un documento imprimible, normalmente, es un PostScript 72 ppp:

72dpi * 20Twips/Point = 1440twips .

Entonces, al tratar con un informe de Crystal, con un ancho de twips de 15840 (y márgenes de 0 twips), el ancho sería de 11 inches (15840 / (72 * 20)) .

Basado en una densidad de pantalla de 96 ppp, el informe se publicará en la pantalla en:

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

Answer 2

Para proyectos de migración podemos usar funciones de soporte de conversión integradas.

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

Answer 3

Para referencia, otra versión de C #, que usa la API de Win32 en lugar de requerir un objeto de Graphics :

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
}

Se supone que se especifica MeasureDirection ya que no hay garantía de que los píxeles sean siempre cuadrados (según la kb).

Referencia: kb210590: ACC2000: Cómo convertir twips a píxeles

Answer 4

Resulta que la herramienta de migración tiene algo, pero no funcionaría en tiempo de ejecución. Esto es lo que hice (si el valor codificado en el método de extensión se cambiara al valor de puntos por pulgada, también funcionaría como un convertidor de puntos):

1 Twip = 1 / 1440th de una pulgada. El objeto .NET Graphics tiene un método DpiX y DpiY que se puede usar para determinar cuántos píxeles hay en una pulgada. Usando esas medidas, creé los siguientes métodos de extensión para 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);
    }
}

Para usar estos métodos, simplemente tiene que hacer lo siguiente (asumiendo que está en un contexto donde CreateGraphics devuelve un objeto Drawing.Graphics (aquí, this es un formulario, por lo que CreateGraphics se hereda del Control clase CreateGraphics de Form )

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

Consulte la sección "Comentarios" en la documentación de Graphics Class para obtener una lista de formas de obtener un objeto de gráficos. Más documentación completa está disponible en el tutorial Cómo crear objetos gráficos .

Breve resumen de las maneras más fáciles:

• Control.CreateGraphics
• PaintEventArgs un evento Paint tiene Graphics disponibles en su propiedad Graphics .
• Hand Graphics.FromImage una imagen y devolverá un objeto Graphics que puede dibujar en esa imagen. (NOTA: es poco probable que desee utilizar twips para una imagen real)