ftbitmap.c File Reference

#include <ft2build.h>

Include dependency graph for ftbitmap.c:

Go to the source code of this file.

Functions
	FT_Bitmap_Init (FT_Bitmap *abitmap)
	FT_Bitmap_New (FT_Bitmap *abitmap)
	FT_Bitmap_Copy (FT_Library library, const FT_Bitmap *source, FT_Bitmap *target)
static FT_Error	ft_bitmap_assure_buffer (FT_Memory memory, FT_Bitmap *bitmap, FT_UInt xpixels, FT_UInt ypixels)
	FT_Bitmap_Embolden (FT_Library library, FT_Bitmap *bitmap, FT_Pos xStrength, FT_Pos yStrength)
static FT_Byte	ft_gray_for_premultiplied_srgb_bgra (const FT_Byte *bgra)
	FT_Bitmap_Convert (FT_Library library, const FT_Bitmap *source, FT_Bitmap *target, FT_Int alignment)
	FT_GlyphSlot_Own_Bitmap (FT_GlyphSlot slot)
	FT_Bitmap_Done (FT_Library library, FT_Bitmap *bitmap)

Variables
static const FT_Bitmap	null_bitmap = { 0, 0, 0, 0, 0, 0, 0, 0 }

Function Documentation

ft_bitmap_assure_buffer()

static FT_Error ft_bitmap_assure_buffer ( FT_Memory  memory, FT_Bitmap *  bitmap, FT_UInt  xpixels, FT_UInt  ypixels  )

static

Definition at line 150 of file ftbitmap.c.

  {
    FT_Error        error;
    unsigned int    pitch;
    unsigned int    new_pitch;
    FT_UInt         bpp;
    FT_UInt         width, height;
    unsigned char*  buffer = NULL;
 
 
    width  = bitmap->width;
    height = bitmap->rows;
    pitch  = (unsigned int)FT_ABS( bitmap->pitch );
 
    switch ( bitmap->pixel_mode )
    {
    case FT_PIXEL_MODE_MONO:
      bpp       = 1;
      new_pitch = ( width + xpixels + 7 ) >> 3;
      break;
    case FT_PIXEL_MODE_GRAY2:
      bpp       = 2;
      new_pitch = ( width + xpixels + 3 ) >> 2;
      break;
    case FT_PIXEL_MODE_GRAY4:
      bpp       = 4;
      new_pitch = ( width + xpixels + 1 ) >> 1;
      break;
    case FT_PIXEL_MODE_GRAY:
    case FT_PIXEL_MODE_LCD:
    case FT_PIXEL_MODE_LCD_V:
      bpp       = 8;
      new_pitch = width + xpixels;
      break;
    default:
      return FT_THROW( Invalid_Glyph_Format );
    }
 
    /* if no need to allocate memory */
    if ( ypixels == 0 && new_pitch <= pitch )
    {
      /* zero the padding */
      FT_UInt  bit_width = pitch * 8;
      FT_UInt  bit_last  = ( width + xpixels ) * bpp;
 
 
      if ( bit_last < bit_width )
      {
        FT_Byte*  line  = bitmap->buffer + ( bit_last >> 3 );
        FT_Byte*  end   = bitmap->buffer + pitch;
        FT_UInt   shift = bit_last & 7;
        FT_UInt   mask  = 0xFF00U >> shift;
        FT_UInt   count = height;
 
 
        for ( ; count > 0; count--, line += pitch, end += pitch )
        {
          FT_Byte*  write = line;
 
 
          if ( shift > 0 )
          {
            write[0] = (FT_Byte)( write[0] & mask );
            write++;
          }
          if ( write < end )
            FT_MEM_ZERO( write, end - write );
        }
      }
 
      return FT_Err_Ok;
    }
 
    /* otherwise allocate new buffer */
    if ( FT_QALLOC_MULT( buffer, bitmap->rows + ypixels, new_pitch ) )
      return error;
 
    /* new rows get added at the top of the bitmap, */
    /* thus take care of the flow direction         */
    if ( bitmap->pitch > 0 )
    {
      FT_UInt  len = ( width * bpp + 7 ) >> 3;
 
      unsigned char*  in  = bitmap->buffer;
      unsigned char*  out = buffer;
 
      unsigned char*  limit = bitmap->buffer + pitch * bitmap->rows;
      unsigned int    delta = new_pitch - pitch;
 
 
      FT_MEM_ZERO( out, new_pitch * ypixels );
      out += new_pitch * ypixels;
 
      while ( in < limit )
      {
        FT_MEM_COPY( out, in, len );
        in  += pitch;
        out += pitch;
 
        FT_MEM_ZERO( out, delta );
        out += delta;
      }
    }
    else
    {
      FT_UInt  len = ( width * bpp + 7 ) >> 3;
 
      unsigned char*  in  = bitmap->buffer;
      unsigned char*  out = buffer;
 
      unsigned char*  limit = bitmap->buffer + pitch * bitmap->rows;
      unsigned int    delta = new_pitch - pitch;
 
 
      while ( in < limit )
      {
        FT_MEM_COPY( out, in, len );
        in  += pitch;
        out += pitch;
 
        FT_MEM_ZERO( out, delta );
        out += delta;
      }
 
      FT_MEM_ZERO( out, new_pitch * ypixels );
    }
 
    FT_FREE( bitmap->buffer );
    bitmap->buffer = buffer;
 
    /* set pitch only, width and height are left untouched */
    if ( bitmap->pitch < 0 )
      bitmap->pitch = -(int)new_pitch;
    else
      bitmap->pitch = (int)new_pitch;
 
    return FT_Err_Ok;
  }

Referenced by FT_Bitmap_Embolden().

FT_Bitmap_Convert()

FT_Bitmap_Convert	(	FT_Library	library,
		const FT_Bitmap *	source,
		FT_Bitmap *	target,
		FT_Int	alignment
	)

Definition at line 504 of file ftbitmap.c.

  {
    FT_Error   error = FT_Err_Ok;
    FT_Memory  memory;
 
    FT_Byte*  s;
    FT_Byte*  t;
 
 
    if ( !library )
      return FT_THROW( Invalid_Library_Handle );
 
    if ( !source || !target )
      return FT_THROW( Invalid_Argument );
 
    memory = library->memory;
 
    switch ( source->pixel_mode )
    {
    case FT_PIXEL_MODE_MONO:
    case FT_PIXEL_MODE_GRAY:
    case FT_PIXEL_MODE_GRAY2:
    case FT_PIXEL_MODE_GRAY4:
    case FT_PIXEL_MODE_LCD:
    case FT_PIXEL_MODE_LCD_V:
    case FT_PIXEL_MODE_BGRA:
      {
        FT_Int    pad, old_target_pitch, target_pitch;
        FT_ULong  old_size;
 
 
        old_target_pitch = target->pitch;
        if ( old_target_pitch < 0 )
          old_target_pitch = -old_target_pitch;
 
        old_size = target->rows * (FT_UInt)old_target_pitch;
 
        target->pixel_mode = FT_PIXEL_MODE_GRAY;
        target->rows       = source->rows;
        target->width      = source->width;
 
        pad = 0;
        if ( alignment > 0 )
        {
          pad = (FT_Int)source->width % alignment;
          if ( pad != 0 )
            pad = alignment - pad;
        }
 
        target_pitch = (FT_Int)source->width + pad;
 
        if ( target_pitch > 0                                               &&
             (FT_ULong)target->rows > FT_ULONG_MAX / (FT_ULong)target_pitch )
          return FT_THROW( Invalid_Argument );
 
        if ( FT_QREALLOC( target->buffer,
                          old_size, target->rows * (FT_UInt)target_pitch ) )
          return error;
 
        target->pitch = target->pitch < 0 ? -target_pitch : target_pitch;
      }
      break;
 
    default:
      error = FT_THROW( Invalid_Argument );
    }
 
    s = source->buffer;
    t = target->buffer;
 
    /* take care of bitmap flow */
    if ( source->pitch < 0 )
      s -= source->pitch * (FT_Int)( source->rows - 1 );
    if ( target->pitch < 0 )
      t -= target->pitch * (FT_Int)( target->rows - 1 );
 
    switch ( source->pixel_mode )
    {
    case FT_PIXEL_MODE_MONO:
      {
        FT_UInt  i;
 
 
        target->num_grays = 2;
 
        for ( i = source->rows; i > 0; i-- )
        {
          FT_Byte*  ss = s;
          FT_Byte*  tt = t;
          FT_UInt   j;
 
 
          /* get the full bytes */
          for ( j = source->width >> 3; j > 0; j-- )
          {
            FT_Int  val = ss[0]; /* avoid a byte->int cast on each line */
 
#ifdef __REACTOS__
            tt[0] = (FT_Byte)( ( val & 0x80 ) ? 0xff : 0);
            tt[1] = (FT_Byte)( ( val & 0x40 ) ? 0xff : 0);
            tt[2] = (FT_Byte)( ( val & 0x20 ) ? 0xff : 0);
            tt[3] = (FT_Byte)( ( val & 0x10 ) ? 0xff : 0);
            tt[4] = (FT_Byte)( ( val & 0x08 ) ? 0xff : 0);
            tt[5] = (FT_Byte)( ( val & 0x04 ) ? 0xff : 0);
            tt[6] = (FT_Byte)( ( val & 0x02 ) ? 0xff : 0);
            tt[7] = (FT_Byte)( ( val & 0x01 ) ? 0xff : 0);
#else
            tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7 );
            tt[1] = (FT_Byte)( ( val & 0x40 ) >> 6 );
            tt[2] = (FT_Byte)( ( val & 0x20 ) >> 5 );
            tt[3] = (FT_Byte)( ( val & 0x10 ) >> 4 );
            tt[4] = (FT_Byte)( ( val & 0x08 ) >> 3 );
            tt[5] = (FT_Byte)( ( val & 0x04 ) >> 2 );
            tt[6] = (FT_Byte)( ( val & 0x02 ) >> 1 );
            tt[7] = (FT_Byte)(   val & 0x01 );
#endif
 
            tt += 8;
            ss += 1;
          }
 
          /* get remaining pixels (if any) */
          j = source->width & 7;
          if ( j > 0 )
          {
            FT_Int  val = *ss;
 
 
            for ( ; j > 0; j-- )
            {
#ifdef __REACTOS__
              tt[0] = (FT_Byte)( ( val & 0x80 ) ? 0xff : 0);
#else
              tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7);
#endif
              val <<= 1;
              tt   += 1;
            }
          }
 
          s += source->pitch;
          t += target->pitch;
        }
      }
      break;
 
 
    case FT_PIXEL_MODE_GRAY:
    case FT_PIXEL_MODE_LCD:
    case FT_PIXEL_MODE_LCD_V:
      {
        FT_UInt  width = source->width;
        FT_UInt  i;
 
 
        target->num_grays = 256;
 
        for ( i = source->rows; i > 0; i-- )
        {
          FT_ARRAY_COPY( t, s, width );
 
          s += source->pitch;
          t += target->pitch;
        }
      }
      break;
 
 
    case FT_PIXEL_MODE_GRAY2:
      {
        FT_UInt  i;
 
 
        target->num_grays = 4;
 
        for ( i = source->rows; i > 0; i-- )
        {
          FT_Byte*  ss = s;
          FT_Byte*  tt = t;
          FT_UInt   j;
 
 
          /* get the full bytes */
          for ( j = source->width >> 2; j > 0; j-- )
          {
            FT_Int  val = ss[0];
 
 
            tt[0] = (FT_Byte)( ( val & 0xC0 ) >> 6 );
            tt[1] = (FT_Byte)( ( val & 0x30 ) >> 4 );
            tt[2] = (FT_Byte)( ( val & 0x0C ) >> 2 );
            tt[3] = (FT_Byte)( ( val & 0x03 ) );
 
            ss += 1;
            tt += 4;
          }
 
          j = source->width & 3;
          if ( j > 0 )
          {
            FT_Int  val = ss[0];
 
 
            for ( ; j > 0; j-- )
            {
              tt[0]  = (FT_Byte)( ( val & 0xC0 ) >> 6 );
              val  <<= 2;
              tt    += 1;
            }
          }
 
          s += source->pitch;
          t += target->pitch;
        }
      }
      break;
 
 
    case FT_PIXEL_MODE_GRAY4:
      {
        FT_UInt  i;
 
 
        target->num_grays = 16;
 
        for ( i = source->rows; i > 0; i-- )
        {
          FT_Byte*  ss = s;
          FT_Byte*  tt = t;
          FT_UInt   j;
 
 
          /* get the full bytes */
          for ( j = source->width >> 1; j > 0; j-- )
          {
            FT_Int  val = ss[0];
 
 
            tt[0] = (FT_Byte)( ( val & 0xF0 ) >> 4 );
            tt[1] = (FT_Byte)( ( val & 0x0F ) );
 
            ss += 1;
            tt += 2;
          }
 
          if ( source->width & 1 )
            tt[0] = (FT_Byte)( ( ss[0] & 0xF0 ) >> 4 );
 
          s += source->pitch;
          t += target->pitch;
        }
      }
      break;
 
 
    case FT_PIXEL_MODE_BGRA:
      {
        FT_UInt  i;
 
 
        target->num_grays = 256;
 
        for ( i = source->rows; i > 0; i-- )
        {
          FT_Byte*  ss = s;
          FT_Byte*  tt = t;
          FT_UInt   j;
 
 
          for ( j = source->width; j > 0; j-- )
          {
            tt[0] = ft_gray_for_premultiplied_srgb_bgra( ss );
 
            ss += 4;
            tt += 1;
          }
 
          s += source->pitch;
          t += target->pitch;
        }
      }
      break;
 
    default:
      ;
    }
 
    return error;
  }

Referenced by FT_Bitmap_Embolden(), FT_Render_Glyph_Internal(), and IntGetBitmapGlyphWithCache().

FT_Bitmap_Copy()

FT_Bitmap_Copy	(	FT_Library	library,
		const FT_Bitmap *	source,
		FT_Bitmap *	target
	)

Definition at line 54 of file ftbitmap.c.

  {
    FT_Memory  memory;
    FT_Error   error  = FT_Err_Ok;
 
    FT_Int    pitch;
    FT_ULong  size;
 
    FT_Int  source_pitch_sign, target_pitch_sign;
 
 
    if ( !library )
      return FT_THROW( Invalid_Library_Handle );
 
    if ( !source || !target )
      return FT_THROW( Invalid_Argument );
 
    if ( source == target )
      return FT_Err_Ok;
 
    source_pitch_sign = source->pitch < 0 ? -1 : 1;
    target_pitch_sign = target->pitch < 0 ? -1 : 1;
 
    if ( !source->buffer )
    {
      *target = *source;
      if ( source_pitch_sign != target_pitch_sign )
        target->pitch = -target->pitch;
 
      return FT_Err_Ok;
    }
 
    memory = library->memory;
    pitch  = source->pitch;
 
    if ( pitch < 0 )
      pitch = -pitch;
    size = (FT_ULong)pitch * source->rows;
 
    if ( target->buffer )
    {
      FT_Int    target_pitch = target->pitch;
      FT_ULong  target_size;
 
 
      if ( target_pitch < 0 )
        target_pitch = -target_pitch;
      target_size = (FT_ULong)target_pitch * target->rows;
 
      if ( target_size != size )
        (void)FT_QREALLOC( target->buffer, target_size, size );
    }
    else
      (void)FT_QALLOC( target->buffer, size );
 
    if ( !error )
    {
      unsigned char *p;
 
 
      p = target->buffer;
      *target = *source;
      target->buffer = p;
 
      if ( source_pitch_sign == target_pitch_sign )
        FT_MEM_COPY( target->buffer, source->buffer, size );
      else
      {
        /* take care of bitmap flow */
        FT_UInt   i;
        FT_Byte*  s = source->buffer;
        FT_Byte*  t = target->buffer;
 
 
        t += (FT_ULong)pitch * ( target->rows - 1 );
 
        for ( i = target->rows; i > 0; i-- )
        {
          FT_ARRAY_COPY( t, s, pitch );
 
          s += pitch;
          t -= pitch;
        }
      }
    }
 
    return error;
  }

Referenced by ft_bitmap_glyph_copy(), ft_bitmap_glyph_init(), and FT_GlyphSlot_Own_Bitmap().

FT_Bitmap_Done()

FT_Bitmap_Done	(	FT_Library	library,
		FT_Bitmap *	bitmap
	)

Definition at line 826 of file ftbitmap.c.

  {
    FT_Memory  memory;
 
 
    if ( !library )
      return FT_THROW( Invalid_Library_Handle );
 
    if ( !bitmap )
      return FT_THROW( Invalid_Argument );
 
    memory = library->memory;
 
    FT_FREE( bitmap->buffer );
    *bitmap = null_bitmap;
 
    return FT_Err_Ok;
  }

Referenced by FT_Bitmap_Embolden(), ft_bitmap_glyph_done(), FT_Render_Glyph_Internal(), and IntGetBitmapGlyphWithCache().

FT_Bitmap_Embolden()

FT_Bitmap_Embolden	(	FT_Library	library,
		FT_Bitmap *	bitmap,
		FT_Pos	xStrength,
		FT_Pos	yStrength
	)

Definition at line 296 of file ftbitmap.c.

  {
    FT_Error        error;
    unsigned char*  p;
    FT_Int          i, x, pitch;
    FT_UInt         y;
    FT_Int          xstr, ystr;
 
 
    if ( !library )
      return FT_THROW( Invalid_Library_Handle );
 
    if ( !bitmap || !bitmap->buffer )
      return FT_THROW( Invalid_Argument );
 
    if ( ( ( FT_PIX_ROUND( xStrength ) >> 6 ) > FT_INT_MAX ) ||
         ( ( FT_PIX_ROUND( yStrength ) >> 6 ) > FT_INT_MAX ) )
      return FT_THROW( Invalid_Argument );
 
    xstr = (FT_Int)FT_PIX_ROUND( xStrength ) >> 6;
    ystr = (FT_Int)FT_PIX_ROUND( yStrength ) >> 6;
 
    if ( xstr == 0 && ystr == 0 )
      return FT_Err_Ok;
    else if ( xstr < 0 || ystr < 0 )
      return FT_THROW( Invalid_Argument );
 
    switch ( bitmap->pixel_mode )
    {
    case FT_PIXEL_MODE_GRAY2:
    case FT_PIXEL_MODE_GRAY4:
      {
        FT_Bitmap  tmp;
 
 
        /* convert to 8bpp */
        FT_Bitmap_Init( &tmp );
        error = FT_Bitmap_Convert( library, bitmap, &tmp, 1 );
        if ( error )
          return error;
 
        FT_Bitmap_Done( library, bitmap );
        *bitmap = tmp;
      }
      break;
 
    case FT_PIXEL_MODE_MONO:
      if ( xstr > 8 )
        xstr = 8;
      break;
 
    case FT_PIXEL_MODE_LCD:
      xstr *= 3;
      break;
 
    case FT_PIXEL_MODE_LCD_V:
      ystr *= 3;
      break;
 
    case FT_PIXEL_MODE_BGRA:
      /* We don't embolden color glyphs. */
      return FT_Err_Ok;
    }
 
    error = ft_bitmap_assure_buffer( library->memory, bitmap,
                                     (FT_UInt)xstr, (FT_UInt)ystr );
    if ( error )
      return error;
 
    /* take care of bitmap flow */
    pitch = bitmap->pitch;
    if ( pitch > 0 )
      p = bitmap->buffer + pitch * ystr;
    else
    {
      pitch = -pitch;
      p = bitmap->buffer + (FT_UInt)pitch * ( bitmap->rows - 1 );
    }
 
    /* for each row */
    for ( y = 0; y < bitmap->rows; y++ )
    {
      /*
       * Horizontally:
       *
       * From the last pixel on, make each pixel or'ed with the
       * `xstr' pixels before it.
       */
      for ( x = pitch - 1; x >= 0; x-- )
      {
        unsigned char  tmp;
 
 
        tmp = p[x];
        for ( i = 1; i <= xstr; i++ )
        {
          if ( bitmap->pixel_mode == FT_PIXEL_MODE_MONO )
          {
            p[x] |= tmp >> i;
 
            /* the maximum value of 8 for `xstr' comes from here */
            if ( x > 0 )
              p[x] |= p[x - 1] << ( 8 - i );
 
#if 0
            if ( p[x] == 0xFF )
              break;
#endif
          }
          else
          {
            if ( x - i >= 0 )
            {
              if ( p[x] + p[x - i] > bitmap->num_grays - 1 )
              {
                p[x] = (unsigned char)( bitmap->num_grays - 1 );
                break;
              }
              else
              {
                p[x] = (unsigned char)( p[x] + p[x - i] );
                if ( p[x] == bitmap->num_grays - 1 )
                  break;
              }
            }
            else
              break;
          }
        }
      }
 
      /*
       * Vertically:
       *
       * Make the above `ystr' rows or'ed with it.
       */
      for ( x = 1; x <= ystr; x++ )
      {
        unsigned char*  q;
 
 
        q = p - bitmap->pitch * x;
        for ( i = 0; i < pitch; i++ )
          q[i] |= p[i];
      }
 
      p += bitmap->pitch;
    }
 
    bitmap->width += (FT_UInt)xstr;
    bitmap->rows += (FT_UInt)ystr;
 
    return FT_Err_Ok;
  }

Referenced by FT_GlyphSlot_Embolden().

FT_Bitmap_Init()

FT_Bitmap_Init

(

FT_Bitmap *

abitmap

)

Definition at line 34 of file ftbitmap.c.

  {
    if ( abitmap )
      *abitmap = null_bitmap;
  }

Referenced by FT_Bitmap_Embolden(), ft_bitmap_glyph_init(), FT_GlyphSlot_Own_Bitmap(), and FT_Render_Glyph_Internal().

FT_Bitmap_New()

FT_Bitmap_New

(

FT_Bitmap *

abitmap

)

Definition at line 44 of file ftbitmap.c.

  {
    if ( abitmap )
      *abitmap = null_bitmap;
  }

Referenced by IntGetBitmapGlyphWithCache().

FT_GlyphSlot_Own_Bitmap()

FT_GlyphSlot_Own_Bitmap

(

FT_GlyphSlot

slot

)

Definition at line 801 of file ftbitmap.c.

  {
    if ( slot && slot->format == FT_GLYPH_FORMAT_BITMAP   &&
         !( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )
    {
      FT_Bitmap  bitmap;
      FT_Error   error;
 
 
      FT_Bitmap_Init( &bitmap );
      error = FT_Bitmap_Copy( slot->library, &slot->bitmap, &bitmap );
      if ( error )
        return error;
 
      slot->bitmap = bitmap;
      slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
    }
 
    return FT_Err_Ok;
  }

Referenced by FT_GlyphSlot_Embolden().

ft_gray_for_premultiplied_srgb_bgra()

static FT_Byte ft_gray_for_premultiplied_srgb_bgra ( const FT_Byte *  bgra )

static

Definition at line 456 of file ftbitmap.c.

  {
    FT_UInt  a = bgra[3];
    FT_UInt  l;
 
 
    /* Short-circuit transparent color to avoid division by zero. */
    if ( !a )
      return 0;
 
    /*
     * Luminosity for sRGB is defined using ~0.2126,0.7152,0.0722
     * coefficients for RGB channels *on the linear colors*.
     * A gamma of 2.2 is fair to assume.  And then, we need to
     * undo the premultiplication too.
     *
     *   https://accessibility.kde.org/hsl-adjusted.php
     *
     * We do the computation with integers only, applying a gamma of 2.0.
     * We guarantee 32-bit arithmetic to avoid overflow but the resulting
     * luminosity fits into 16 bits.
     *
     */
 
    l = (  4732UL /* 0.0722 * 65536 */ * bgra[0] * bgra[0] +
          46871UL /* 0.7152 * 65536 */ * bgra[1] * bgra[1] +
          13933UL /* 0.2126 * 65536 */ * bgra[2] * bgra[2] ) >> 16;
 
    /*
     * Final transparency can be determined as follows.
     *
     * - If alpha is zero, we want 0.
     * - If alpha is zero and luminosity is zero, we want 255.
     * - If alpha is zero and luminosity is one, we want 0.
     *
     * So the formula is a * (1 - l) = a - l * a.
     *
     * We still need to undo premultiplication by dividing l by a*a.
     *
     */
 
    return (FT_Byte)( a - l / a );
  }

Referenced by FT_Bitmap_Convert().

Variable Documentation

null_bitmap

const FT_Bitmap null_bitmap = { 0, 0, 0, 0, 0, 0, 0, 0 }

static

Definition at line 28 of file ftbitmap.c.

Referenced by FT_Bitmap_Done(), FT_Bitmap_Init(), and FT_Bitmap_New().