Logo Search packages:      
Sourcecode: plplot version File versions  Download package

mac.c

/* $Id: mac.c,v 1.3 2000/12/18 21:01:50 airwin Exp $
   $Log: mac.c,v $
   Revision 1.3  2000/12/18 21:01:50  airwin
   Change to new style plplot/*.h header file locations.

   Revision 1.2  2000/05/12 18:05:32  furnish
   Imported latest Mac port work by Rob Managan.

 * Revision 1.1  1995/04/11  09:39:13  mjl
 * Mac port, contributed by Mark Franz.
 *
 *
*/

/*
      Rect  PlotRect = {40, 10, 540, 510};

      MaxApplZone();
      
      for (i = 0; i < 12; i++)
            MoreMasters();

      mac_plot_area(&PlotRect);

*/

/*    mac.c

      Adapted from bgivga.c
       MArk Franz
       24-Mar-95

  A driver for Macintosh
  Compile this with MetroWerks C/C++ 

*/
#include "plplot/plplotP.h"
#include <stdio.h>
#include <stdlib.h>
#include "plplot/drivers.h"
#include "plplot/mac.h"

#define MAC_XMAX 400
#define MAC_YMAX 400
#define MAC_XOFFSET 20
#define NIL       NULL
#define Max_Mac_Windows 8


// Plot menu 
#define plotM                 1000
#define PlotCopy        1
#define PlotSave        2
#define PlotContinue    4



Str255      MAC_WINDOW_TITLE = "\pPlot ";
Str255      tempWTitle;


RgnHandle   fillRegion;
static int              Max_Mac_Windows_Used;
static WindowPtr  plotWindow[Max_Mac_Windows];
static PicHandle  plotPicture[Max_Mac_Windows];
static Handle           saveMBar, myMBar;
static MenuHandle myMenu;
RGBColor                rgbColor;
long                    PICTCount;
short                         globalRef; 
short                   plotActive = 0;
PicHandle               newPICTHand;
short                   plotWidth = MAC_XMAX;
short                   plotHeight = MAC_YMAX;
static      GrafPtr     savedPort;


static Rect boundsRect = {40, 10, MAC_YMAX+40, MAC_XMAX+10};

/*----------------------------------------------------------------------*\
* mac_init()
*
* Initialize device.
\*----------------------------------------------------------------------*/
 
void
plD_init_mac1(PLStream *pls)
{     
      Max_Mac_Windows_Used = 1;
      init_mac(pls);
}
void
plD_init_mac8(PLStream *pls)
{     
      Max_Mac_Windows_Used = 8;
      init_mac(pls);
}
void
init_mac(PLStream *pls)
{     
      int         i;

      for(i = 0; i < Max_Mac_Windows_Used; i++)
      {
            plotWindow[i] = NULL;
            plotPicture[i] = NULL;
      }
      plotActive = -1;

      fprintf(stderr, "Macintosh Window\n");  // This is here just to
                                                                  // make sure Menus drawn
      
      SetUpMenu();

       pls->termin = 1;            /* is an interactive terminal */
       pls->icol0 = 1;
       pls->icol1 = 1;
       pls->width = 1;
       pls->bytecnt = 0;
       pls->page = 0;
       pls->dev_fill0 = 1;          /* supports hardware solid fills */
       pls->dev_fill1 = 0;
//    pls->plbuf_write = 1;   /* Activate plot buffer */
       
       pls->graphx = GRAPHICS_MODE;

       if (!pls->colorset)
            pls->color = 1;
            

/* Set up device parameters */

       plP_setpxl(2.83465, 2.83465);           /* Pixels/mm. */

       plP_setphy((PLINT) 0, (PLINT) (boundsRect.right-boundsRect.left), 
                        (PLINT) 0, (PLINT) (boundsRect.bottom-boundsRect.top));
       
       
}

/*----------------------------------------------------------------------*\
* mac_line()
*
* Draw a line in the current color from (x1,y1) to (x2,y2).
\*----------------------------------------------------------------------*/

void
plD_line_mac(PLStream *pls, short x1a, short y1a, short x2a, short y2a)
{
      int y1, y2 ;

      GetPort(&savedPort);
      SetPort(plotWindow[plotActive]);

      y1 = (boundsRect.bottom-boundsRect.top) - y1a;
      y2 = (boundsRect.bottom-boundsRect.top) - y2a;

       MoveTo(x1a, y1);
       LineTo(x2a, y2);

       SetPort(savedPort);
}

/*----------------------------------------------------------------------*\
* mac_polyline()
*
* Draw a polyline in the current color.
\*----------------------------------------------------------------------*/

void
plD_polyline_mac(PLStream *pls, short *xa, short *ya, PLINT npts)
{
       PLINT i;

      GetPort(&savedPort);
      SetPort(plotWindow[plotActive]);

       for (i = 0; i < npts - 1; i++)
      plD_line_mac(pls, xa[i], ya[i], xa[i + 1], ya[i + 1]);

       SetPort(savedPort);
}

/*----------------------------------------------------------------------*\
* mac_eop()
*
* End of page.
\*----------------------------------------------------------------------*/

void
plD_eop_mac(PLStream *pls)
{
Rect  myRect;
      
      GetPort(&savedPort);
      SetPort(plotWindow[plotActive]);

      ClosePicture();
      DrawPicture(plotPicture[plotActive],&plotWindow[plotActive]->portRect);

      if(pls->termin == 1)
      {
            if(plotWindow[plotActive] !=NULL)  // added subscript for current window RAM 10/14/96
            {
                  GetWTitle(plotWindow[plotActive], tempWTitle);
                  SetWTitle(plotWindow[plotActive], "\pHit any key to continue.");
                  InvalRect(&plotWindow[plotActive]->portRect);
                  AdjustMenu();
                  if (Max_Mac_Windows_Used != 1)
                  {
                        while(!MAC_event(pls));
                        SetWTitle(plotWindow[plotActive], tempWTitle);
                  }
//                RestoreMenu();
            }
      }
      else
      {
            if(plotPicture[plotActive] != NULL)
            {     
                  AdjustMenu();
                  myRect=plotWindow[plotActive]->portRect;
                  DrawPicture(plotPicture[plotActive],&myRect);
//                RestoreMenu();
            }
      }

       SetPort(savedPort);
}

/*----------------------------------------------------------------------*\
* mac_bop()
*
* Set up for the next page.
\*----------------------------------------------------------------------*/

void
plD_bop_mac(PLStream *pls)
{
RGBColor    backGround;
Str255            numberAsString;
Str255            currentTitle;

      pls->page++;

      plotActive++;
      
      if(plotActive == Max_Mac_Windows_Used) 
            plotActive =0;
            
      if (plotWindow[plotActive] == NULL)                         //  Get a window handle
      {
            boundsRect.top    = 40+plotActive*20;                       //  Set the inital window location
            boundsRect.left = (plotActive+1)*10;
            boundsRect.right = plotWidth+(plotActive+1)*10;
            boundsRect.bottom = plotHeight+40+plotActive*20;
            
            plotWindow[plotActive] = NewCWindow(NULL, &boundsRect,"\p ", FALSE, 
                                                                  documentProc, (void *)-1L, FALSE, 0L);                                                          
      }
      currentTitle[0]=0;
      NumToString(pls->page, numberAsString);
      CopyPStrings(currentTitle, MAC_WINDOW_TITLE);
      CatenatePStrings(currentTitle, numberAsString);
      SetWTitle(plotWindow[plotActive], currentTitle);
      
      boundsRect = plotWindow[plotActive]->portRect;        //  Get current window location

      GetPort(&savedPort);
      SetPort(plotWindow[plotActive]);
      SetWRefCon(plotWindow[plotActive], (long)( plotActive ) );  //  Save the window number
      EraseRect(&plotWindow[plotActive]->portRect);
    ShowWindow(plotWindow[plotActive]);
      SelectWindow(plotWindow[plotActive]);     // RAM 10/9/96
      if(plotPicture[plotActive] != NULL)             //  Make sure the associated Picture is free
      {
            SetWindowPic(plotWindow[plotActive], NULL);
            KillPicture(plotPicture[plotActive]);
            plotPicture[plotActive]=NULL;
      }
      plotPicture[plotActive]=OpenPicture(&(((GrafPtr) plotWindow[plotActive])->portRect));
      TextFont(kFontIDMonaco);
      TextSize(9);
      TextFace(normal);
      PenNormal();

//  Paint the Background  - use plscolbg(r,g,b) function 

      backGround.red = 257*plsc->cmap0[0].r;
      backGround.green = 257*plsc->cmap0[0].g;
      backGround.blue = 257*plsc->cmap0[0].b;
      RGBForeColor( &backGround );
      PaintRect(&plotWindow[plotActive]->portRect);
      
//  Make sure the colors are set correctly for the beginning of the plot 

      rgbColor.red = 257*plsc->curcolor.r;
      rgbColor.green = 257*plsc->curcolor.g;
      rgbColor.blue = 257*plsc->curcolor.b;
      RGBForeColor( &rgbColor );
      

       SetPort(savedPort);
}

/*----------------------------------------------------------------------*\
* mac_tidy()
*
* Close graphics file or otherwise clean up.
\*----------------------------------------------------------------------*/

void
plD_tidy_mac(PLStream *pls)
{
short i;

      GetPort(&savedPort);
      SetPort(plotWindow[plotActive]);

//    AdjustMenu();
//    while(!MAC_event(pls));             //  Wait for one last time
//    RestoreMenu();

      for(i = 0; i < Max_Mac_Windows_Used; i++)
      {
            if(plotWindow[i] != NULL )
                  DisposeWindow(plotWindow[i]);
      }

       SetPort(savedPort);
}
/*----------------------------------------------------------------------*\
* plD_state_mac()
*
* Handle change in PLStream state (color, pen width, fill attribute, etc).
\*----------------------------------------------------------------------*/

void 
plD_state_mac(PLStream *pls, PLINT op)
{

      GetPort(&savedPort);
      SetPort(plotWindow[plotActive]);

    switch (op) {

            case PLSTATE_WIDTH:
                  if (pls->width < 1 || pls->width > 10)
                  pls->width=9;
          
                  PenSize((short) pls->width, (short) pls->width);

            break;
            
      case PLSTATE_CMAP0:
      case PLSTATE_CMAP1:
                        ;                 //  Not sure what to do here since colors are used differently
            break;

      case PLSTATE_COLOR1:
      case PLSTATE_COLOR0:
                  rgbColor.red = 257*plsc->curcolor.r;
                  rgbColor.green = 257*plsc->curcolor.g;
                  rgbColor.blue = 257*plsc->curcolor.b;
                  RGBForeColor( &rgbColor );
            break;
            
      case PLSTATE_FILL:
                        ;                 //  TBD:  Need to set fill at some point in future
            break;


    }

       SetPort(savedPort);
}

/*----------------------------------------------------------------------*\
* mac_text()
*
* Switch to text mode.
\*----------------------------------------------------------------------*/

void
mac_text(PLStream *pls)
{
}

/*----------------------------------------------------------------------*\
 * mac_esc()
 *
 * Escape function.
 *
 * Functions:
 *
 *    PLESC_EH    Handle pending events
 *    PLESC_EXPOSE      Force an expose
 *    PLESC_FILL  Fill polygon
 *    PLESC_FLUSH Flush X event buffer
 *    PLESC_GETC  Get coordinates upon mouse click
 *    PLESC_REDRAW      Force a redraw
 *    PLESC_RESIZE      Force a resize
\*----------------------------------------------------------------------*/

void
plD_esc_mac(PLStream *pls, PLINT op, void *ptr)
{
int         i;

      GetPort(&savedPort);
      SetPort(plotWindow[plotActive]);

      switch (op) 
      {
        case PLESC_EXPOSE:    /* handle window expose */
          break;
        case PLESC_RESIZE:    /* handle window resize */
          break;
        case PLESC_REDRAW:    /* handle window redraw */
          break;
        case PLESC_TEXT:            /* switch to text screen */
          break;
        case PLESC_GRAPH:           /* switch to graphics screen */
          break;
        case PLESC_FILL:            /* fill polygon */
                  OpenRgn();                                            //  Start a Region for a fill
                  for (i = 0; i < pls->dev_npts - 1; i++)
                  {
                        plD_line_mac(pls, pls->dev_x[i], pls->dev_y[i], 
                                           pls->dev_x[i + 1], pls->dev_y[i + 1]);
                  }
                                     
                  CloseRgn(fillRegion);   //  Close the region
                  
                  PaintRgn(fillRegion);   // Now Paint it
            break;
        case PLESC_DI:        /* handle DI command */
          break;
        case PLESC_FLUSH:           /* flush output */
          break;
        case PLESC_EH:        /* handle Window events */
          break;
        case PLESC_GETC:            /* get cursor position */
          break;
        case PLESC_SWIN:            /* set window parameters */
          break;
      }

       SetPort(savedPort);
}
/*----------------------------------------------------------------------*\
* mac_esc()
*
* Escape function.
\*----------------------------------------------------------------------*/


//private functions

static unsigned char MAC_event(PLStream *pls)
{
      EventRecord theEvent;
      WindowPtr   whichWindow;
      Rect        dragRect, growRect;
      int         i, growResult;
      short       newWidth, newHeight;

      SystemTask();

      if (GetNextEvent(everyEvent, &theEvent))
            switch (theEvent.what)
            {
            case mouseDown:
                  switch(FindWindow(theEvent.where,&whichWindow))
                  {
                        case inSysWindow:
                              SystemClick(&theEvent,whichWindow);
                        break;
                        
                        case inContent:
                              return TRUE;
                        break;

                        case inDrag:
                              SetRect(&dragRect,4,24,qd.screenBits.bounds.right-4,qd.screenBits.bounds.bottom-4);
                              DragWindow(whichWindow,theEvent.where, &dragRect);
                              break;
                        case inGrow:
                              SetRect(&growRect,128,128,32767,32767);
                              growResult = GrowWindow(whichWindow,theEvent.where, &growRect);
                              if (growResult != 0)
                              {
                                    newWidth  = LoWord(growResult);
                                    newHeight = HiWord(growResult);
                                    ResizeWin(pls, whichWindow,newWidth,newHeight);
                              }
                        break;

                        case inMenuBar:
                              AdjustMenu();
                              HiliteMenu(0);
                              return doMenuCommand(MenuSelect(theEvent.where));
                        break;
                  };
                  break;
                  
            case keyDown:
            case autoKey:
                if ((theEvent.modifiers & cmdKey) != 0)
                {
                        AdjustMenu();
                        HiliteMenu(0);
                        return doMenuCommand(MenuKey(theEvent.message & charCodeMask));
                  }
                  else
                        HiliteMenu(0);
                        return TRUE;
                  break;
                  
            case updateEvt:   //  Update a window
                  whichWindow = (WindowPtr)theEvent.message;

                  i = GetWRefCon(whichWindow);
                  if (i >= 0 && i < Max_Mac_Windows_Used)
                  {
                        BeginUpdate(plotWindow[i]);
                        GetPort(&savedPort);
                        SetPort(plotWindow[i]);
                        DrawPicture(plotPicture[i],&plotWindow[i]->portRect);
                        SetPort(savedPort);
                        EndUpdate(plotWindow[i]);
                  }
            break;
                
            case activateEvt:
//                InvalRect(&plotWindow[plotActive]->portRect);
                  break;
          }
          return FALSE;
}

void  ResizeWin(  PLStream *pls,
                              WindowPtr whichWindow,
                              short newWidth,
                              short newHeight)
{
      int               i, myWindow = Max_Mac_Windows_Used;

      i = GetWRefCon(whichWindow);
      if (i >= 0 && i < Max_Mac_Windows_Used)
      {
            myWindow = i;
      }
      if (Max_Mac_Windows_Used == myWindow)
            return;
      SizeWindow(whichWindow, newWidth, newHeight, true);
      InvalRect(&whichWindow->portRect); // make sure whole window is redrawn in the update

      if (myWindow == plotActive)
      {
            plotWidth = newWidth;
            plotHeight = newHeight;
            plP_setphy((PLINT) 0, (PLINT) (newWidth), (PLINT) 0, (PLINT) (newHeight));
      }
}

unsigned char  doMenuCommand(long mCmd)
{
      unsigned char     result=FALSE;
      int         item,menu;
//    Str255            daName;
//    short       daRefNum;

      item=LoWord(mCmd);
      menu=HiWord(mCmd);
      switch(menu)
      {
            case plotM:
                  switch(item)
                  {
                        case PlotCopy:
                              doCopy();
                              result = FALSE;
                        break;
                        case PlotSave:
                              PutPictToFile();
                              result = FALSE;
                        break;
                        case PlotContinue:
                              result = TRUE;
                        break;
                  }
                  break;
      }
      HiliteMenu(0);
      AdjustMenu();
      return result;
}
/**************************** doCopy *************************/

void doCopy()
{
short       frontWindow;
WindowPtr   tempWindow;

      tempWindow = FrontWindow();
      frontWindow = (short) GetWRefCon(tempWindow);  //  Get the window number

      ZeroScrap();
      HLock((Handle) plotPicture[frontWindow]);
      PutScrap(GetHandleSize((Handle)plotPicture[frontWindow]) ,'PICT', *plotPicture[frontWindow]);
      HUnlock((Handle) plotPicture[frontWindow]);
}
/**************************** SetUpMenu *************************/

void SetUpMenu(void)
{
      
      saveMBar=GetMenuBar();
//    ClearMenuBar();
//    myMenu=NewMenu(appleM,"\p\024");
//    AppendMenu(myMenu, "\pAbout\311");
//    InsertMenu(myMenu,0);
//    AddResMenu(GetMHandle(appleM), 'DRVR');   /* add DA names to Apple menu */
      myMenu=NewMenu(plotM,"\pPLplot");
      AppendMenu(myMenu, "\pCopy To Clipboard/C;Save To File/S;(-;Continue/G");
      InsertMenu(myMenu,0);
      DrawMenuBar();
      myMBar=GetMenuBar();
}

void AdjustMenu(void)
{
      SetMenuBar(myMBar);
      DrawMenuBar();
}

void RestoreMenu(void)
{
      SetMenuBar(saveMBar);
      DrawMenuBar();
      DisposeMenu(myMenu);
      DisposeHandle(myMBar);
      DisposeHandle(saveMBar);
}

// routines to create PICT file.

/*------ PutPictToFile ----------------------------------------------------------------------------*/


//void PutPictToFile(PicHandle thePicture)
void PutPictToFile(void)
{
      SFReply           tr;
      short       fRefNum, count;
      long        inOutCount;
      Point       where;
      unsigned char header[512];
      OSErr             myError;
      short       frontWindow;
      Str255            tempTitle;

      frontWindow = (short) GetWRefCon(FrontWindow());  //  Get the window number
      if(frontWindow != plotActive)
            GetWTitle(plotWindow[frontWindow], tempTitle);
      else
            BlockMove(tempWTitle, tempTitle, (long) tempWTitle[0]+1);

      
      for (count = 0; count < 512; count++)
            header[count] = 0x00;
      
      where.h=100; where.v=50;                        /* where the  Standard File dialog window goes */
      
      SFPutFile( where, "\pSave PICT as:", tempTitle, NULL, &tr );
      
      if ( tr.good ) {
            myError = Create(tr.fName, tr.vRefNum, 'CDrw', 'PICT');
            if (myError == dupFNErr) 
            {
                  myError = FSDelete(tr.fName,tr.vRefNum);
                  myError = Create(tr.fName, tr.vRefNum, 'CDrw', 'PICT');
            }                                         /* this is quick 'n' dirty or there'd 
                                                            be more robust handling here */
            
            myError = FSOpen( tr.fName, tr.vRefNum, &fRefNum );
            if ( myError == noErr ) 
            { 
                  inOutCount = 512;
                  myError = FSWrite(fRefNum, &inOutCount, header);            /* write the header */
                  HLock((Handle)plotPicture[frontWindow]);
                  if (myError == noErr) 
                  {                                   /* don't write if error the first time */
                        inOutCount = GetHandleSize((Handle)plotPicture[frontWindow]);
                        myError = FSWrite(fRefNum,&inOutCount,*plotPicture[frontWindow]);
                  }
                  FSClose( fRefNum );           /* close it */
                  HUnlock((Handle)plotPicture[frontWindow]);
            }
      }
}
/**************************** DoAbout *************************/
void
DoAbout( Str255 s )
{
#define BASE_RES_ID                 400
#define     NIL_POINTER             0L

      ParamText( s, "\p", "\p", "\p" );
      NoteAlert( BASE_RES_ID, NIL_POINTER );
}
/**************************** DoAbout *************************/
//  Routine to place the plot area on the screen --- 
//  Defualt: boundsRect = {50, 10, 650, 610}
//
//  This utility will not allow plot to be smaller than 200 x 200
//  or larger than 600 x 600

void
mac_plot_area(Rect *plotArea)
{
//   Limits set by Screenbits --  Comemnted out

//    plotArea->left = (plotArea->left > 10) ? plotArea->left : 10;
//    plotArea->top = (plotArea->top > 40) ? plotArea->top : 40;
//    plotArea->right= (plotArea->right > qd.screenBits.bounds.right) ? 
//                            qd.screenBits.bounds.right-10 : plotArea->right;
//    plotArea->bottom= (plotArea->bottom > qd.screenBits.bounds.bottom) ? 
//                            qd.screenBits.bounds.bottom-10 : plotArea->bottom;                            

//  XMAX and YMAX limits
//
      plotArea->left = (plotArea->left > 10) ? plotArea->left : 10;
      plotArea->top = (plotArea->top > 40) ? plotArea->top : 40;
      plotArea->right= (plotArea->right > plotArea->left+MAC_XMAX) ? 
                              plotArea->left+MAC_XMAX : plotArea->right;
      plotArea->bottom= (plotArea->bottom > plotArea->top+MAC_YMAX) ? 
                              plotArea->top+MAC_YMAX : plotArea->bottom;
                              
//  Make sure it's at least 200 x 200 as minimum

      if(plotArea->right-plotArea->left < 200) 
            plotArea->right = plotArea->left+200;
      
      if(plotArea->bottom-plotArea->top < 200) 
            plotArea->bottom = plotArea->top+200;
            
      SetRect(&boundsRect, plotArea->left, plotArea->top, plotArea->right, plotArea->bottom);
      plotWidth = plotArea->right - plotArea->left;
      plotHeight = plotArea->bottom - plotArea->top;
}

/*******************************************************************************

      CatenatePStrings

      Catenate two Pascal strings by attaching the second string on the end of
      the first string. If you are running under MPW 3.2 or later, you can
      simply use the PLCatenate library routine instead.

*******************************************************************************/
void  
CatenatePStrings(Str255 targetStr, Str255 appendStr)
{
      short appendLen;

      /* Figure out number of bytes to copy, up to 255 */

      appendLen = MIN(appendStr[0], 255 - targetStr[0]);
      if (appendLen > 0) {
            BlockMove(appendStr+1, targetStr+targetStr[0]+1, (long) appendLen);
            targetStr[0] += appendLen;
      }
}
/*******************************************************************************

      CopyPStrings

      Copies two Pascal strings by attaching the second string on the end of
      the first string. If you are running under MPW 3.2 or later, you can
      simply use the PLCatenate library routine instead.

*******************************************************************************/
void  
CopyPStrings(Str255 targetStr, Str255 appendStr)
{
//    short appendLen;

      /* Figure out number of bytes to copy, up to 255 */

            BlockMove(appendStr, targetStr, (long) appendStr[0]+1);
//          targetStr[0];
}


/*--------------------------------------------------------------------------*\
 * FILE *plMacLibOpen(fn)
 *
 * Return file pointer to lib file.
 * Locations checked:
 *    In the system Preferences folder we check for
 *  the lib folder or a plplot_lib folder. The latter may be an alias
\*--------------------------------------------------------------------------*/
#include <Folders.h>
#include <Files.h>
//#include <MoreFilesExtras.h>
//#include <FSpCompat.h>
#include <FSp_fopen.h>

FILE *plMacLibOpen(char *fn)
{
      FILE  *file;
      char  *fs = NULL;
      OSErr anErr;
      short prefVRefNum;
      long  prefDirID;
      FSSpec      FSlibFileDir, FSlibFile;
      Boolean     resolveAliasChains=TRUE, targetIsFolder, wasAliased;
      
      /* find the preferences folder */
      anErr = FindFolder( kOnSystemDisk, 'pref', kDontCreateFolder , &prefVRefNum, &prefDirID);
      // first see if the plplot_lib folder is here; alias or not
      anErr = FSMakeFSSpec(prefVRefNum, prefDirID, "\pplplot_lib", &FSlibFileDir);
      if ( (anErr == noErr) && (FSlibFileDir.parID == 0) )
            FSlibFileDir.parID = fsRtParID;
      // if it is an alias get what it points to!
      anErr = ResolveAliasFile(&FSlibFileDir, resolveAliasChains, &targetIsFolder, &wasAliased);
      // make FSSpec for file within the directory ; 1st construct the relative filename
      // then make the FSSpec; then open it!
      plGetName("", p2cstr(FSlibFileDir.name), fn, &fs);
      anErr = FSMakeFSSpec(FSlibFileDir.vRefNum, FSlibFileDir.parID, c2pstr(fs), &FSlibFile);
      if ( (anErr == noErr) && (FSlibFile.parID == 0) )
            FSlibFile.parID = fsRtParID;
      file = FSp_fopen(&FSlibFile, "rb");
/*    if (file != NULL)
    {
          free_mem(fs);
            return (file);
      }
*/    
    free_mem(fs);
    return (file);
}


Generated by  Doxygen 1.6.0   Back to index