Logo Search packages:      
Sourcecode: ted version File versions

appMacPict.c

#   include "appFrameConfig.h"

#   include <stddef.h>
#   include <stdlib.h>

#   include <appMacPict.h>
#   include <utilPs.h>
#   include <sioEndian.h>

#   define  y0    math_y0
#   define  y1    math_y1
#   include <math.h>
#   undef   y0
#   undef   y1

#   include <appDebugon.h>

#   ifndef  M_PI
#     define      M_PI  3.14159265358979323846
#   endif

# if 0
#    define PICTDEB(x)  (x)
# else
#    define PICTDEB(x)  /*nothing*/
# endif

/************************************************************************/
/*                                                    */
/*  Initialize/Clean a mac pict device.                           */
/*                                                    */
/*  1)  1=BLACK= (foreground), 0=WHITE= (background)              */
/*                                                    */
/************************************************************************/

void appMacPictInitDeviceHeader(    MacpictDevice *         md,
                              int               outWide,
                              int               outHigh,
                              int               outTwipsWide,
                              int               outTwipsHigh )
    {
    md->mdVersion= 0;

    md->mdInX0= 0;
    md->mdInY0= 0;
    md->mdInX1= 0;
    md->mdInY1= 0;

    md->mdRectX0= 0;
    md->mdRectY0= 0;
    md->mdRectX1= 0;
    md->mdRectY1= 0;

    md->mdOvalX0= 0;
    md->mdOvalY0= 0;
    md->mdOvalX1= 0;
    md->mdOvalY1= 0;

    md->mdPolyX0= 0;
    md->mdPolyY0= 0;
    md->mdPolyX1= 0;
    md->mdPolyY1= 0;

    md->mdRRectX0= 0;
    md->mdRRectY0= 0;
    md->mdRRectX1= 0;
    md->mdRRectY1= 0;
    md->mdRRectOvalWide= 12;
    md->mdRRectOvalHigh= 12;

    md->mdOutWide= outWide;
    md->mdOutHigh= outHigh;
    md->mdOutTwipsWide= outTwipsWide;
    md->mdOutTwipsHigh= outTwipsHigh;

    md->mdPenMode= PENMODE_patOr;
    md->mdPenX= 0;
    md->mdPenY= 0;

    /*  1  */
    memset( md->mdPenPattern, 1, 8 );
    md->mdPenIsSolid= 1;

    /*  1  */
    memset( md->mdFillPattern, 0, 8 );
    md->mdFillIsSolid= 1;

    /*  1  */
    memset( md->mdBackPattern, 0, 8 );
    md->mdBackIsSolid= 1;

    md->mdRedMax= 65536;
    md->mdGreenMax= 65536;
    md->mdBlueMax= 65536;

    bmInitRGB8Color( &(md->mdForeColor) );
    bmInitRGB8Color( &(md->mdBackColor) );
    bmInitRGB8Color( &(md->mdColorSet) );

    md->mdBackColor.rgb8Red= 255;
    md->mdBackColor.rgb8Green= 255;
    md->mdBackColor.rgb8Blue= 255;

    md->mdForeColor.rgb8Red= 0;
    md->mdForeColor.rgb8Green= 0;
    md->mdForeColor.rgb8Blue= 0;

    md->mdFontName= (char *)0;
    utilInitTextAttribute( &(md->mdTextAttribute) );
    md->mdPrivateFont= -1;
    md->mdAfi= (AfmFontInfo *)0;
    md->mdFontEncoding= -1;

    md->mdStippleSet= STIPPLE_UNDEF;
    md->mdFillStippled= 0;
    md->mdTilePixmap= (APP_BITMAP_IMAGE)0;

    md->mdTextString= (unsigned char *)0;
    md->mdTextStringLength= 0;
    md->mdPolyPoints= (APP_POINT *)0;
    md->mdPolyPointCount= 0;

    docInitFontList( &(md->mdFontList) );
    appInitDrawingData( &(md->mdDrawingData) );

    return;
    }

void appMacPictCleanDeviceHeader(   MacpictDevice *         md )
    {
    if  ( md->mdFontName )
      { free( md->mdFontName ); }
    if  ( md->mdTextString )
      { free( md->mdTextString ); }
    if  ( md->mdPolyPoints )
      { free( md->mdPolyPoints ); }

    if  ( md->mdTilePixmap )
      { appDrawFreePixmap( &(md->mdDrawingData), md->mdTilePixmap );    }

    docCleanFontList( &(md->mdFontList) );
    appCleanDrawingData( &(md->mdDrawingData) );

    return;
    }

/************************************************************************/
/*                                                    */
/*  Read the header of a macpict metafile.                        */
/*                                                    */
/*  2)  Read picture size.                                  */
/*  3)  Read picture frame.                                 */
/*  4)  Read version.                                       */
/*                                                    */
/************************************************************************/

int appMacPictGetDeviceHeader(      MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int                 pictureSize;
    int                 version;

    int                 x0;
    int                 y0;
    int                 x1;
    int                 y1;

    int                 c;
    int                 i;
    long          l;

    /*  2  */
    pictureSize= sioEndianGetBeInt16( sis );

    /*  3  */
    y0= sioEndianGetBeInt16( sis );
    x0= sioEndianGetBeInt16( sis );
    y1= sioEndianGetBeInt16( sis );
    x1= sioEndianGetBeInt16( sis );

    /*  4  */
    c= sioInGetCharacter( sis );
    switch( c )
      {
      case 0:
          c= sioInGetCharacter( sis );
          if  ( c != 0x11 )
            { XDEB(c); return -1;   }

          version= sioInGetCharacter( sis );
          if  ( version != 2 )
            { LDEB(version); return -1;   }

          c= sioInGetCharacter( sis );
          if  ( c != 0xff )
            { XDEB(c); return -1;   }

          c= sioEndianGetBeInt16( sis );
          if  ( c != 0xc00 )
            { XDEB(c); return -1;   }

          l= sioEndianGetBeInt32( sis );
          /*
          if  ( l != -1 )
            { LDEB(l); return -1;   }
          */

          for ( i= 0; i < 8; i++ )
            { c= sioEndianGetBeInt16( sis ); }

          c= sioEndianGetBeInt16( sis );
          if  ( c != 0x00 )
            { XDEB(c); /*return -1;*/     }
          c= sioEndianGetBeInt16( sis );
          if  ( c != 0x00 )
            { XDEB(c); /*return -1;*/     }
          break;

      case 0x11:
          version= sioInGetCharacter( sis );
          if  ( version != 1 )
            { LDEB(version); return -1;   }
          break;

      default:
          XDEB(c); return -1;
      }


    md->mdVersion= version;

    md->mdInX0= x0;
    md->mdInY0= y0;
    md->mdInX1= x1;
    md->mdInY1= y1;

    return 0;
    }

/************************************************************************/
/*                                                    */
/*  Retrieve the next opcode from a macpict metafile.             */
/*                                                    */
/************************************************************************/

int appMacPictGetOpcode(      unsigned int *          pOpcode,
                        int *             pBytes,
                        const MacpictDevice *   md,
                        SimpleInputStream *     sis )
    {
    int                 bytes= -1;
    unsigned int  opcode;

    switch( md->mdVersion )
      {
      case 1:
          opcode= sioInGetCharacter( sis );
          break;
      case 2:
          opcode= sioEndianGetBeUint16( sis );
          break;
      default:
          LDEB(md->mdVersion); return -1;
      }

    if  ( opcode == EOF )
      { LDEB(opcode); return -1;    }

    bytes= -1;
    if  ( opcode >= 0x100 && opcode <= 0x7fff )
      {
      bytes= 2* ( ( opcode >> 8 ) & 0xff );
      opcode= opcode & 0xff;
      }


    *pBytes= bytes;
    *pOpcode= opcode;
    return 0;
    }

/************************************************************************/
/*                                                    */
/*  Retrieve a color.                                       */
/*                                                    */
/************************************************************************/

int appMacPictGetColor( RGB8Color *       rgb8,
                  const MacpictDevice *   md,
                  SimpleInputStream *     sis )
    {
    unsigned int  r= sioEndianGetBeUint16( sis );
    unsigned int  g= sioEndianGetBeUint16( sis );
    unsigned int  b= sioEndianGetBeUint16( sis );

    rgb8->rgb8Red= r/ 256;
    rgb8->rgb8Green= g/ 256;
    rgb8->rgb8Blue= b/ 256;

    return 0;
    }

/************************************************************************/
/*                                                    */
/*  Retrieve a text string.                                 */
/*                                                    */
/************************************************************************/

int appMacPictGetCountAndString(    MacpictDevice *         md,
                              int *             pCount,
                              SimpleInputStream *     sis )
    {
    int                 count= sioInGetCharacter( sis );

    int                 i;
    unsigned char *     fresh;

    fresh= realloc( md->mdTextString, count+ 1 );
    if  ( ! fresh )
      { LXDEB(count,fresh); return -1;    }
    md->mdTextString= (unsigned char *)fresh;
    md->mdTextStringLength= count;

    for ( i= 0; i < count; fresh++, i++ )
      {
      *fresh= sioInGetCharacter( sis );

      if  ( *fresh == '\r' )
          { *fresh= '\n';     }
      else{ *fresh= docMAC_to_ISO1[*fresh];     }
      }
    *fresh= '\0';

    *pCount= count;
    return 0;
    }

/************************************************************************/
/*                                                    */
/*  Retrieve the points of a polyline/polygon.                    */
/*                                                    */
/************************************************************************/

int appMacPictGetPoly(        MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int                 bytes;
    int                 count;

    APP_POINT *         xp;
    int                 done;

    bytes= sioEndianGetBeInt16( sis );
    bytes -= 2;
    bytes -= 8;

    if  ( bytes % 4 || bytes <= 4 )
      { LDEB(bytes); return -1;     }

    count= bytes/ 4;

    xp= (APP_POINT *)realloc( md->mdPolyPoints, (count+ 1)* sizeof(APP_POINT) );
    if  ( ! xp )
      { LXDEB(count,xp); return -1; }

    md->mdPolyPoints= xp;
    md->mdPolyPointCount= count;

    md->mdPolyY0= sioEndianGetBeInt16( sis );
    md->mdPolyX0= sioEndianGetBeInt16( sis );
    md->mdPolyY1= sioEndianGetBeInt16( sis );
    md->mdPolyX1= sioEndianGetBeInt16( sis );

    for ( done= 0; done < count; xp++, done++ )
      {
      int   y= sioEndianGetBeInt16( sis );
      int   x= sioEndianGetBeInt16( sis );

      xp->x= MD_X( x, md );
      xp->y= MD_Y( y, md );
      }

    *xp= md->mdPolyPoints[0];

    return 0;
    }

/************************************************************************/
/*                                                    */
/*  Read the colors in a mac pict palette.                        */
/*                                                    */
/************************************************************************/

int appMacPictReadPaletteColors(    BitmapDescription *     bd,
                              int *             pBytesRead,
                              const MacpictDevice *   md,
                              int               colorCount,
                              int               flags,
                              SimpleInputStream *     sis )
    {
    int           col;

    RGB8Color *   rgb8;

    int           bytesRead= 0;

    rgb8= realloc( bd->bdRGB8Palette, colorCount* sizeof( RGB8Color ) );
    if  ( ! rgb8 )
      { LXDEB(colorCount,bd->bdRGB8Palette); return -1;     }
    bd->bdRGB8Palette= rgb8;

    for ( col= 0; col < colorCount; rgb8++, col++ )
      {
      int   idx;

      idx= sioEndianGetBeInt16( sis ); bytesRead += 2;
      if  ( idx < 0 )
          { LDEB(idx); idx= 0;                  }
      if  ( idx >= colorCount )
          { LLDEB(idx,colorCount); idx= colorCount- 1; }

      if  ( flags & 0x8000 )
          { idx= col;   }

      rgb8->rgb8Red= sioEndianGetBeUint16( sis )/ 256; bytesRead += 2;
      rgb8->rgb8Green= sioEndianGetBeUint16( sis )/ 256; bytesRead += 2;
      rgb8->rgb8Blue= sioEndianGetBeUint16( sis )/ 256; bytesRead += 2;
      }

    *pBytesRead= bytesRead;
    return 0;
    }

/************************************************************************/
/*                                                    */
/*  Read one row of PackBits data.                          */
/*                                                    */
/************************************************************************/

int appMacPictReadPacBitsRow( unsigned char *               to,
                        int *                   pBytesRead,
                        int                     bytesPerRow,
                        const MacpictDevice *         md,
                        const BitmapDescription *     bd,
                        SimpleInputStream *           sis )
    {
    int                 byteCount;
    int                 done= 0;
    int                 bytesRead= 0;

    if  ( bytesPerRow > 250 )
      { byteCount= sioEndianGetBeInt16( sis ); bytesRead += 2;    }
    else{ byteCount= sioInGetCharacter( sis ); bytesRead++;       }

    /*
    if  ( byteCount > bd->bdBytesPerRow )
      { LLDEB(byteCount,bd->bdBytesPerRow); return -1;      }
    */

    bytesRead += byteCount;

    while( byteCount > 0 )
      {
      int   c0= sioInGetCharacter( sis );
      int   len;
      int   use;

      if  ( c0 == EOF )
          { LDEB(c0); return -1;    }

      if  ( c0 == 0x80 )
          { XDEB(c0); byteCount--; continue;    }

      if  ( c0 & 0x80 )
          {
          int           c1= sioInGetCharacter( sis );

          len= 257- c0; use= len;

          if  ( done+ len > bd->bdBytesPerRow )
            {
            if  ( ! ( bd->bdBytesPerRow % 2 )   ||
                  done+ len > bd->bdBytesPerRow+ 1    )
                { LLLDEB(done,len,bd->bdBytesPerRow); }

            use= bd->bdBytesPerRow- done;
            }

          byteCount -= 2; done += use;

          while( use > 0 )
            { *(to++)= c1; use--; }
          }
      else{
          len= c0+ 1; use= len;

          if  ( done+ len > bd->bdBytesPerRow )
            {
            if  ( ! ( bd->bdBytesPerRow % 2 )   ||
                  done+ len > bd->bdBytesPerRow+ 1    )
                { LLLDEB(done,len,bd->bdBytesPerRow); }

            use= bd->bdBytesPerRow- done;
            }

          byteCount -= 1+ len; done += use;

          while( use > 0 )
            { *(to++)= sioInGetCharacter( sis ); use--; len--; }
          while( len > 0 )
            { (void) sioInGetCharacter( sis ); len--; }
          }
      }

    *pBytesRead= bytesRead;
    return 0;
    }

static int appMacPictAddFont(       MacpictDevice *         md,
                              const char *            name )
    {
    int                 rval= 0;

    int                 fontNum;
    int                 fontStyle;

    DocumentFont  dfNew;

    docInitDocumentFont( &dfNew );

    if  ( docFontSetFamilyName( &dfNew, name ) )
      { LDEB(1); rval= -1; goto ready;    }

    fontStyle= utilFontFamilyStyle( name );
    if  ( docFontSetFamilyStyle( &dfNew, fontStyle ) )
      { SLDEB(name,fontStyle); rval= -1; goto ready; }

    fontNum= docMergeFontIntoFontlist( &(md->mdFontList), &dfNew );
    if  ( fontNum < 0 )
      { SLDEB(name,fontNum); rval= -1; goto ready; }

    if  ( md->mdTextAttribute.taFontNumber != fontNum )
      {
      md->mdTextAttribute.taFontNumber= fontNum;
      md->mdPrivateFont= -1;
      md->mdAfi= (AfmFontInfo *)0;
      md->mdFontEncoding= -1;
      }

  ready:
    docCleanDocumentFont( &dfNew );

    return rval;
    }

int appMacPictGetFontName(          MacpictDevice *         md,
                              SimpleInputStream *     sis )
    {
    int                 rval= 0;

    int                 dataLength= sioEndianGetBeInt16( sis );
    int                 oldFontId= sioEndianGetBeInt16( sis );
    int                 nameLength= sioInGetCharacter( sis );

    int                 i;
    char *        fresh;

    oldFontId= oldFontId;

    fresh= realloc( md->mdFontName, nameLength+ 1 );
    if  ( ! fresh )
      { LXDEB(nameLength,fresh); rval= -1; goto ready;      }
    md->mdFontName= fresh;

    for ( i= 0; i < nameLength; fresh++, i++ )
      { *fresh= sioInGetCharacter( sis ); }
    *fresh= '\0';

    PICTDEB(appDebug( "FontName( %d, %d, %d, \"%s\" )\n",
          dataLength, oldFontId, nameLength, md->mdFontName ));

    if  ( dataLength > 3+ nameLength )
      { LLDEB(dataLength,3+nameLength); }

    for ( i= 3+ nameLength; i < dataLength; i++ )
      { (void) sioInGetCharacter( sis );  }

    if  ( appMacPictAddFont( md, md->mdFontName ) )
      { LDEB(1); rval= -1; goto ready;    }

  ready:

    return rval;
    }

int appMacPictGetTxFont(            MacpictDevice *         md,
                              SimpleInputStream *     sis )
    {
    int                 rval= 0;

    int                 val= sioEndianGetBeInt16( sis );
    char *        name= "?";

    PICTDEB(appDebug( "TxFont( %d )\n", val ));

    switch( val )
      {
      case 0:           name= "Chicago";  break;
      case 1:           name= "Helvetica";      break;
      case 2:           name= "Times";          break;
      case 3:           name= "Helvetica";      break;
      case 4:           name= "Courier";  break;
      case 20:    name= "Times";          break;
      case 21:    name= "Helvetica";      break;
      case 22:    name= "Courier";  break;
      case 23:    name= "Symbol";         break;
      case 15011: name= "Avantgarde";     break;

      default:    goto ready;
      }

    if  ( appMacPictAddFont( md, name ) )
      { LDEB(1); rval= -1; goto ready;    }

  ready:

    return rval;
    }

int appMacPictGetOvSize(            MacpictDevice *         md,
                              SimpleInputStream *     sis )
    {
    md->mdRRectOvalHigh= sioEndianGetBeInt16( sis );
    md->mdRRectOvalWide= sioEndianGetBeInt16( sis );

    PICTDEB(appDebug( "OvSize( %d, %d )\n",
                      md->mdRRectOvalWide, md->mdRRectOvalHigh ));

    return 0;
    }

int appMacPictGetTxFace(            MacpictDevice *         md,
                              SimpleInputStream *     sis )
    {
    unsigned int  val= sioInGetCharacter( sis );

    int                 isBold= 0;
    int                 isSlanted= 0;

    PICTDEB(appDebug( "TxFace( 0x%02x )\n", val ));

    if  ( val & 1 )
      { isBold= 1; val &= ~1; }
    if  ( val & 2 )
      { isSlanted= 1; val &= ~2;    }

    if(val)LDEB(val);

    if  ( md->mdVersion > 1 )
      { (void)sioInGetCharacter( sis );   }

    if  ( md->mdTextAttribute.taFontIsBold != isBold )
      {
      md->mdTextAttribute.taFontIsBold= isBold;
      md->mdPrivateFont= -1;
      md->mdAfi= (AfmFontInfo *)0;
      md->mdFontEncoding= -1;
      }

    if  ( md->mdTextAttribute.taFontIsSlanted != isSlanted )
      {
      md->mdTextAttribute.taFontIsSlanted= isSlanted;
      md->mdPrivateFont= -1;
      md->mdAfi= (AfmFontInfo *)0;
      md->mdFontEncoding= -1;
      }

    return 0;
    }

int appMacPictGetTxSize(            MacpictDevice *         md,
                              SimpleInputStream *     sis )
    {
    int           size= sioEndianGetBeInt16( sis );
    double  scale;

    int           inWide;
    int           inHigh;

    PICTDEB(appDebug( "TxSize( %d )\n", size ));

    inWide= md->mdInX1- md->mdInX0;
    inHigh= md->mdInY1- md->mdInY0;

    scale= sqrt( ( (double)md->mdOutTwipsWide* md->mdOutTwipsHigh )/
                                    ( (double)inWide* inHigh ) );

    size= ( scale* size/ 10 );

    if  ( md->mdTextAttribute.taFontSizeHalfPoints != size )
      {
      md->mdTextAttribute.taFontSizeHalfPoints= size;
      md->mdPrivateFont= -1;
      }

    return 0;
    }

/************************************************************************/
/*                                                    */
/*  Arcs:                                             */
/*                                                    */
/*  The origin of arcs is at the top of the circle. The orientation is  */
/*  clockwise.                                              */
/*                                                    */
/************************************************************************/

int appMacPictGetArc(         MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    md->mdArcY0= sioEndianGetBeInt16( sis );
    md->mdArcX0= sioEndianGetBeInt16( sis );
    md->mdArcY1= sioEndianGetBeInt16( sis );
    md->mdArcX1= sioEndianGetBeInt16( sis );

    md->mdArcA0= sioEndianGetBeInt16( sis );
    md->mdArcA1= sioEndianGetBeInt16( sis );

    return 0;
    }

int appMacPictGetOval(        MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    md->mdOvalY0= sioEndianGetBeInt16( sis );
    md->mdOvalX0= sioEndianGetBeInt16( sis );
    md->mdOvalY1= sioEndianGetBeInt16( sis );
    md->mdOvalX1= sioEndianGetBeInt16( sis );

    return 0;
    }

int appMacPictGetShortLine(   int *             pX0,
                        int *             pY0,
                        int *             pX1,
                        int *             pY1,
                        MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int                 y0= sioEndianGetBeInt16( sis );
    int                 x0= sioEndianGetBeInt16( sis );
    int                 y1;
    int                 x1;
    int                 c;

    c= sioInGetCharacter( sis );
    if  ( c & 0x80 )
      { x1= x0+ c- 256; }
    else{ x1= x0+ c;    }

    c= sioInGetCharacter( sis );
    if  ( c & 0x80 )
      { y1= y0+ c- 256; }
    else{ y1= y0+ c;    }


    PICTDEB(appDebug( "ShortLine( %d+ %d, %d+ %d )\n",
                            x0, x1- x0, y0, y1- y0 ));

    md->mdPenX= x1;
    md->mdPenY= y1;

    *pX0= x0;
    *pY0= y0;
    *pX1= x1;
    *pY1= y1;

    return 0;
    }

int appMacPictGetShortLineFrom(     int *             pX0,
                        int *             pY0,
                        int *             pX1,
                        int *             pY1,
                        MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int                 y0= md->mdPenY;
    int                 x0= md->mdPenX;
    int                 y1;
    int                 x1;
    int                 c;

    c= sioInGetCharacter( sis );
    if  ( c & 0x80 )
      { x1= x0+ c- 256; }
    else{ x1= x0+ c;    }

    c= sioInGetCharacter( sis );
    if  ( c & 0x80 )
      { y1= y0+ c- 256; }
    else{ y1= y0+ c;    }

    PICTDEB(appDebug( "ShortLineFrom( %d+ %d, %d+ %d )\n",
                            x0, x1- x0, y0, y1- y0 ));


    *pX0= x0;
    *pY0= y0;
    *pX1= x1;
    *pY1= y1;

    return 0;
    }

int appMacPictGetLineFrom(    int *             pX0,
                        int *             pY0,
                        int *             pX1,
                        int *             pY1,
                        MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int           y0= sioEndianGetBeInt16( sis );
    int           x0= sioEndianGetBeInt16( sis );
    int           y1= md->mdPenY;
    int           x1= md->mdPenX;

    PICTDEB(appDebug( "LineFrom( %d, %d )\n", x0, y0 ));

    *pX0= x0;
    *pY0= y0;
    *pX1= x1;
    *pY1= y1;

    return 0;
    }

int appMacPictGetLine(        int *             pX0,
                        int *             pY0,
                        int *             pX1,
                        int *             pY1,
                        MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int                 y0= sioEndianGetBeInt16( sis );
    int                 x0= sioEndianGetBeInt16( sis );
    int                 y1= sioEndianGetBeInt16( sis );
    int                 x1= sioEndianGetBeInt16( sis );

    PICTDEB(appDebug( "Line( %d, %d, %d, %d )\n", x0, y0, x1, y1 ));

    md->mdPenX= x1;
    md->mdPenY= y1;

    *pX0= x0;
    *pY0= y0;
    *pX1= x1;
    *pY1= y1;

    return 0;
    }

/************************************************************************/
/*                                                    */
/*  Read a pattern.                                         */
/*                                                    */
/************************************************************************/

int appMacPictGetPattern(           MacpictDevice *         md,
                              SimpleInputStream *     sis,
                              int               unsetStipple,
                              int *             pIsSolid,
                              unsigned char           pattern[8] )
    {
    int           i;
    int           isSolid;

    pattern[0]= sioInGetCharacter( sis );
    isSolid= ( pattern[0] == 0x00 || pattern[0] == 0xff );

    for ( i= 1; i < 8; i++ )
      {
      pattern[i]= sioInGetCharacter( sis );

      if  ( pattern[i] != pattern[0] )
          { isSolid= 0; }
      }

    if  ( md->mdStippleSet == unsetStipple )
      { md->mdStippleSet=   STIPPLE_UNDEF;      }

    *pIsSolid= isSolid;
    return 0;
    }

/************************************************************************/
/*                                                    */
/*  MACPICT_PackBitsRect                                    */
/*                                                    */
/*  2)  Get bytes per row and palette flag.                       */
/*  3)  Get image frame.                                    */
/*  4)  Default is a black and white image.                       */
/*  5)  For color images, get additional information.             */
/*  6)  Retrieve palette.                                   */
/*  7)  Finish bitmap administration and allocate buffer.         */
/*  8)  Read source and destination rectangle.                    */
/*  9)  Read raster operation. (Assume copy anyway)               */
/*  10) Read bitmap data.                                   */
/*  11) Later versions of mac pict have an even number of bytes per     */
/*    operation.                                      */
/*                                                    */
/************************************************************************/

int appMacPictGetImage(             AppBitmapImage *  abi,
                              int *             pY0Source,
                              int *             pX0Source,
                              int *             pY1Source,
                              int *             pX1Source,
                              int *             pY0Dest,
                              int *             pX0Dest,
                              int *             pY1Dest,
                              int *             pX1Dest,
                              MacpictDevice *         md,
                              SimpleInputStream *     sis,
                              int               packed,
                              int               direct,
                              int               clipRegion )
    {
    unsigned int  bytesPerRow;
    int                 hasPalette= 0;

    int                 y0Frame;
    int                 x0Frame;
    int                 y1Frame;
    int                 x1Frame;

    int                 y0Source;
    int                 x0Source;
    int                 y1Source;
    int                 x1Source;

    int                 y0Dest;
    int                 x0Dest;
    int                 y1Dest;
    int                 x1Dest;

    int                 rop;

    BitmapDescription * bd= &(abi->abiBitmap);

    int                 bytesRead= 0;
    int                 rowsArePlanar= 0;

    /*  2  */
    if  ( direct )
      {
      int n;
      bytesPerRow= 0;

      n= sioEndianGetBeUint16( sis ); bytesRead += 2;
      n= sioEndianGetBeUint16( sis ); bytesRead += 2;
      n= sioEndianGetBeUint16( sis ); bytesRead += 2;
      }
    else{
      bytesPerRow= sioEndianGetBeUint16( sis ); bytesRead += 2;
      if  ( bytesPerRow & 0x8000 )
          {
          hasPalette= 1;
          bytesPerRow &= ~0x8000;
          }
      }

    /*  3  */
    y0Frame= sioEndianGetBeInt16( sis ); bytesRead += 2;
    x0Frame= sioEndianGetBeInt16( sis ); bytesRead += 2;
    y1Frame= sioEndianGetBeInt16( sis ); bytesRead += 2;
    x1Frame= sioEndianGetBeInt16( sis ); bytesRead += 2;

    bd->bdPixelsWide= x1Frame- x0Frame;
    bd->bdPixelsHigh= y1Frame- y0Frame;

    bd->bdBytesPerRow= bytesPerRow;

    /*  4  */
    bd->bdBitsPerPixel= 1;
    bd->bdSamplesPerPixel= 1;
    bd->bdBitsPerSample= 1;
    bd->bdColorEncoding= BMcoBLACKWHITE;

    /*  5  */
    if  ( direct || hasPalette )
      {
      int         version;
      int         packType;
      long        packSize;
      int         xRes;
      int         yRes;
      int         pixelType;
      int         planeBytes;
      int         table;
      int         reserved;

      version= sioEndianGetBeInt16( sis ); bytesRead += 2;
      packType= sioEndianGetBeInt16( sis ); bytesRead += 2;
      if  ( packType == 4 )
          { packed= 1;  }
      packSize= sioEndianGetBeInt32( sis ); bytesRead += 4;
      xRes= sioEndianGetBeInt32( sis ); bytesRead += 4;
      yRes= sioEndianGetBeInt32( sis ); bytesRead += 4;
      pixelType= sioEndianGetBeInt16( sis ); bytesRead += 2;
      bd->bdBitsPerPixel= sioEndianGetBeInt16( sis ); bytesRead += 2;
      bd->bdSamplesPerPixel= sioEndianGetBeInt16( sis ); bytesRead += 2;
      bd->bdBitsPerSample= sioEndianGetBeInt16( sis ); bytesRead += 2;
      planeBytes= sioEndianGetBeInt32( sis ); bytesRead += 4;
      table= sioEndianGetBeInt32( sis ); bytesRead += 4;
      reserved= sioEndianGetBeInt32( sis ); bytesRead += 4;

      if  ( bd->bdSamplesPerPixel == 4 )
          { bd->bdHasAlpha= 1;      }

      if  ( direct && bd->bdSamplesPerPixel > 1 )
          {
bd->bdColorEncoding= BMcoRGB;
LDEB(bd->bdColorEncoding);
          if  ( bd->bdSamplesPerPixel == 3 && bd->bdBitsPerSample == 8 )
            { rowsArePlanar= 1;     }
          }

      if  ( direct )
          {
          bytesPerRow=
            ( bd->bdBitsPerPixel* bd->bdPixelsWide+ 7 )/ 8;
          }

      version= version;
      packType= packType;
      packSize= packSize;
      xRes= xRes;
      yRes= yRes;
      pixelType= pixelType;
      planeBytes= planeBytes;
      table= table;
      reserved= reserved;
      }

    /*  6  */
    if  ( hasPalette )
      {
      long        seed;
      int         flags;
      int         colorCount;

      int         done;

      seed= sioEndianGetBeInt32( sis ); bytesRead += 4;
      flags= sioEndianGetBeUint16( sis ); bytesRead += 2;
      colorCount= sioEndianGetBeInt16( sis )+ 1; bytesRead += 2;

      bd->bdColorEncoding= BMcoRGB8PALETTE;

      if  ( appMacPictReadPaletteColors( bd, &done, md,
                                        colorCount, flags, sis ) )
          { LDEB(hasPalette); return -1;  }

      bytesRead += done;
      }

    /*  7  */
    bmCalculateSizes( bd );

    abi->abiBuffer= malloc( bd->bdBufferLength+
                              rowsArePlanar* bd->bdBytesPerRow );
    if  ( ! abi->abiBuffer )
      {
      LXDEB(bd->bdBufferLength,abi->abiBuffer);
      return -1;
      }

    /*  8  */
    y0Source= sioEndianGetBeInt16( sis ); bytesRead += 2;
    x0Source= sioEndianGetBeInt16( sis ); bytesRead += 2;
    y1Source= sioEndianGetBeInt16( sis ); bytesRead += 2;
    x1Source= sioEndianGetBeInt16( sis ); bytesRead += 2;

    y0Dest= sioEndianGetBeInt16( sis ); bytesRead += 2;
    x0Dest= sioEndianGetBeInt16( sis ); bytesRead += 2;
    y1Dest= sioEndianGetBeInt16( sis ); bytesRead += 2;
    x1Dest= sioEndianGetBeInt16( sis ); bytesRead += 2;

    /*  9  */
    rop= sioEndianGetBeInt16( sis ); bytesRead += 2;
    if  ( rop != 0 )
      { LDEB(rop);      }

    if  ( clipRegion )
      {
      int   i;
      int   count= sioEndianGetBeInt16( sis ); bytesRead += 2;

      for ( i= 2; i < count; i++ )
          { (void) sioInGetCharacter( sis ); bytesRead++; }
      }

    /*  10  */
    if  ( ! packed || bytesPerRow < 8 )
      {
      int         row;

      for ( row= 0; row < bd->bdPixelsHigh; row++ )
          {
          unsigned char *     to;
          int                 i;

          to= abi->abiBuffer+ row* bd->bdBytesPerRow;

          for ( i= 0; i < bytesPerRow; i++ )
            { *(to++)= sioInGetCharacter( sis ); bytesRead++;     }
          }
      }
    else{
      int   row;

      for ( row= 0; row < bd->bdPixelsHigh; row++ )
          {
          int                 done;
          unsigned char *     to;

          if  ( rowsArePlanar )
            { to= abi->abiBuffer+ bd->bdBufferLength; }
          else{ to= abi->abiBuffer+ row* bd->bdBytesPerRow; }

          if  ( appMacPictReadPacBitsRow(
                            to, &done, bytesPerRow, md, bd, sis ) )
            { LDEB(row); return -1; }

          if  ( rowsArePlanar )
            {
            const unsigned char *   r;
            const unsigned char *   g;
            const unsigned char *   b;
            int               i;

            r= abi->abiBuffer+ bd->bdBufferLength;
            g= r+ bd->bdPixelsWide;
            b= g+ bd->bdPixelsWide;

            to= abi->abiBuffer+ row* bd->bdBytesPerRow;

            for ( i= 0; i < bd->bdPixelsWide; i++ )
                {
                *(to++)= *(r++);
                *(to++)= *(g++);
                *(to++)= *(b++);
                }
            }

          bytesRead += done;
          }
      }

    /*  11  */
    if  ( md->mdVersion > 1 && bytesRead % 2 )
      { (void)sioInGetCharacter( sis );   }

    *pY0Source= y0Source;
    *pX0Source= x0Source;
    *pY1Source= y1Source;
    *pX1Source= x1Source;
    *pY0Dest= y0Dest;
    *pX0Dest= x0Dest;
    *pY1Dest= y1Dest;
    *pX1Dest= x1Dest;

    return 0;
    }

int appMacPictGetGlyphState(  MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int     dataLength= sioEndianGetBeInt16( sis );
    int     i;
    int     c;

    int     outlinePreferred= 0;
    int     preserveGlyph= 0;
    int     fractionalWidth= 0;
    int     scalingDisabled= 0;

    for ( i= 0; i < dataLength; i++ )
      {
      c= sioInGetCharacter( sis );

      if  ( i == 0 )
          { outlinePreferred= c;    }
      if  ( i == 1 )
          { preserveGlyph= c; }
      if  ( i == 2 )
          { fractionalWidth= c;     }
      if  ( i == 3 )
          { scalingDisabled= c;     }
      }

    PICTDEB(appDebug( "GlyphState( %d:%x,%x,%x,%x )\n",
                        dataLength,
                        outlinePreferred,
                        preserveGlyph,
                        fractionalWidth,
                        scalingDisabled ));

    md->mdPenX= 0;
    md->mdPenY= 0;

    return 0;
    }

int appMacPictGetDHText(      int *             pCount,
                        MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int     dh= sioInGetCharacter( sis );
    int     count;

    if  ( appMacPictGetCountAndString( md, &count, sis ) )
      { LDEB(1); return -1;   }

    PICTDEB(appDebug( "DHText( %d, %d: \"%s\" )\n",
                        dh, count, md->mdTextString ));

    md->mdPenX += dh;

    if  ( md->mdVersion > 1 && count % 2 )
      { (void)sioInGetCharacter( sis );   }

    *pCount= count;
    return 0;
    }

int appMacPictGetDVText(      int *             pCount,
                        MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int                 dv= sioInGetCharacter( sis );
    int                 count;

    if  ( appMacPictGetCountAndString( md, &count, sis ) )
      { LDEB(1); return -1;   }

    PICTDEB(appDebug( "DVText( %d, %d: \"%s\" )\n",
                        dv, count, md->mdTextString ));

    md->mdPenY += dv;

    if  ( md->mdVersion > 1 && count % 2 )
      { (void)sioInGetCharacter( sis );   }

    *pCount= count;
    return 0;
    }

int appMacPictGetDHDVText(    int *             pCount,
                        MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int     dh= sioInGetCharacter( sis );
    int     dv= sioInGetCharacter( sis );
    int     count;

    if  ( appMacPictGetCountAndString( md, &count, sis ) )
      { LDEB(1); return -1;   }

    PICTDEB(appDebug( "DHDVText( %d, %d, %d: \"%s\" )\n",
                        dh, dv, count, md->mdTextString ));

    md->mdPenX += dh;
    md->mdPenY += dv;

    if  ( md->mdVersion > 1 && count % 2 == 0 )
      { (void)sioInGetCharacter( sis );   }

    *pCount= count;
    return 0;
    }

int appMacPictGetLongText(    int *             pCount,
                        MacpictDevice *         md,
                        SimpleInputStream *     sis )
    {
    int     y= sioEndianGetBeInt16( sis );
    int     x= sioEndianGetBeInt16( sis );
    int     count;

    if  ( appMacPictGetCountAndString( md, &count, sis ) )
      { LDEB(1); return -1;   }

    PICTDEB(appDebug( "LongText( %d, %d, %d: \"%s\" )\n",
                        x, y, count, md->mdTextString ));

    md->mdPenX= x;
    md->mdPenY= y;

    if  ( md->mdVersion > 1 && count % 2 == 0 )
      { (void)sioInGetCharacter( sis );   }

    *pCount= count;
    return 0;
    }

const char * appMacPictCommentName( int               n )
    {
    static char   scratch[22];

    switch( n )
      {
      case PICTCMT_Proprietary:     return "Proprietary";
      case PICTCMT_MacDrawBegin:    return "MacDrawBegin";
      case PICTCMT_MacDrawEnd:      return "MacDrawEnd";
      case PICTCMT_GroupedBegin:    return "GroupedBegin";
      case PICTCMT_GroupedEnd:      return "GroupedEnd";
      case PICTCMT_BitmapBegin:     return "BitmapBegin";
      case PICTCMT_BitmapEnd:       return "BitmapEnd";
      case PICTCMT_ArrowAtEnd:      return "ArrowAtEnd";
      case PICTCMT_ArrowAtStart:    return "ArrowAtStart";
      case PICTCMT_ArrowBothEnds:   return "ArrowBothEnds";
      case PICTCMT_ArrowEnd:        return "ArrowEnd";
      case PICTCMT_SetGray:         return "SetGray";
      case PICTCMT_TextBegin:       return "TextBegin";
      case PICTCMT_TextEnd:         return "TextEnd";
      case PICTCMT_StringBegin:     return "StringBegin";
      case PICTCMT_StringEnd:       return "StringEnd";
      case PICTCMT_TextCenter:      return "TextCenter";
      case PICTCMT_LineLayoutOff:   return "LineLayoutOff";
      case PICTCMT_LineLayoutOn:    return "LineLayoutOn";
      case PICTCMT_ClientLineLayout:      return "ClientLineLayout";
      case PICTCMT_PolyBegin:       return "PolyBegin";
      case PICTCMT_PolyEnd:         return "PolyEnd";
      case PICTCMT_PolyIgnore:      return "PolyIgnore";
      case PICTCMT_PolySmooth:      return "PolySmooth";
      case PICTCMT_PolyClose:       return "PolyClose";
      case PICTCMT_RotateBegin:     return "RotateBegin";
      case PICTCMT_RotateEnd:       return "RotateEnd";
      case PICTCMT_RotateCenter:    return "RotateCenter";
      case PICTCMT_DashedLine:      return "DashedLine";
      case PICTCMT_DashedStop:      return "DashedStop";
      case PICTCMT_SetLineWidth:    return "SetLineWidth";
      case PICTCMT_PostScriptBegin: return "PostScriptBegin";
      case PICTCMT_PostScriptEnd:   return "PostScriptEnd";
      case PICTCMT_PostScriptHandle:      return "PostScriptHandle";
      case PICTCMT_PostScriptFile:  return "PostScriptFile";
      case PICTCMT_TextIsPostScript:      return "TextIsPostScript";
      case PICTCMT_ResourcePS:      return "ResourcePS";
      case PICTCMT_PSBeginNoSave:   return "PSBeginNoSave";
      case PICTCMT_FormsPrinting:   return "FormsPrinting";
      case PICTCMT_EndFormsPrinting:      return "EndFormsPrinting";
      case PICTCMT_CMBeginProfile:  return "CMBeginProfile";
      case PICTCMT_CMEndProfile:    return "CMEndProfile";
      case PICTCMT_CMEnableMatching:      return "CMEnableMatching";
      case PICTCMT_CMDisableMatching:     return "CMDisableMatching";
      }

    sprintf( scratch, "%d", n );
    return scratch;
    }

Generated by  Doxygen 1.6.0   Back to index