home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1993 #2 / Image.iso / database / cdmusic.zip / CDASCII.CPP next >
Encoding:
C/C++ Source or Header  |  1993-06-09  |  29.4 KB  |  846 lines
  1. #include "cdascii.h"
  2. #include "cdmcrt.h"
  3.  
  4. #define OKAY 0
  5. #define FAIL 1
  6.  
  7. char far*fldNames[ MAXFIELDS ];
  8. char far*fldTypes[ MAXFIELDS ];
  9.  
  10. REQUIREDFIELDARRAY TR_TrackRecord[] =
  11.   {
  12.     { 3, "Disc ID",          "N",    1 },
  13.     { 3, "Track ID",         "N",    2 },
  14.     { 1, "Title",            "A80",  3 },
  15.     { 1, "Min",              "S",    4 },
  16.     { 1, "Sec",              "S",    5 },
  17.     { 1, "Sec100",           "S",    6 }
  18.   };
  19.  
  20. REQUIREDFIELDARRAY DR_DiscRecord[] =
  21.   {
  22.     { 3, "Disc ID",          "N",    1 },
  23.     { 1, "Artist",           "A80",  2 },
  24.     { 1, "Title",            "A80",  3 },
  25.     { 1, "Tracks",           "S",    4 },
  26.     { 1, "Min",              "S",    5 },
  27.     { 1, "Sec",              "S",    6 },
  28.     { 1, "Entry Date",         "D",    7 }
  29.   };
  30.  
  31. REQUIREDFIELDARRAY *TR_TrackArray[ 24 ];
  32. extern char MouseChar;
  33. extern ColorSet EsColors,
  34.         cdColors;
  35. RawWindow lcWindow;
  36. char lcString[ 80 ];
  37.  
  38. /*--------------------------------------------------------------------------*/
  39. int Error( int lcRC )
  40.   {
  41.     if ( lcRC != PXSUCCESS )
  42.       {
  43.     CharStr( ' ', 78, lcString );
  44.         lcWindow.wFastText( lcString, 20, 2 );
  45.     sprintf( lcString, "CDASCII: %s", PXErrMsg( lcRC ) );
  46.     lcWindow.wFastText( lcString, 20, 2 );
  47.       }
  48.  
  49.     return lcRC;
  50.   }
  51.  
  52. /*--------------------------------------------------------------------------*/
  53. word track_scrn( int lctracks )
  54. {
  55.   word Status;
  56.   ScrollingEntryScreen ES;
  57.  
  58.   OPEntryInit();
  59.  
  60.   #if defined(UseMouse)
  61.   if (MouseInstalled) {
  62.       //activate mouse cursor
  63.       SoftMouseCursor(0x0000, (ColorMono(EsColors.MouseColor, EsColors.MouseMono) << 8)+
  64.                  MouseChar);
  65.       ShowMouse();
  66.       //enable mouse support
  67.       EntryCommands.cpOptionsOn(cpEnableMouse);
  68.     };
  69.   #endif
  70.  
  71.   //initialize entry screen
  72.   Status = cd_trackscrn( ES, EsColors, lctracks );
  73.   if (Status != 0) {
  74.     printf("Error initializing entry screen: %u\r\n", Status);
  75.     exit( 0 );
  76.     return Status;
  77.   };
  78.  
  79.   ES.Process();
  80.   ES.Erase();
  81.   #if defined(UseMouse)
  82.   HideMouse();
  83.   #endif
  84.   Status = ES.GetLastCommand();
  85.   ES.Done();
  86.   return Status;
  87. };
  88.  
  89. TABLEHANDLE glDiscTable;
  90. RECORDHANDLE glDiscRecord;
  91.  
  92. /*--------------------------------------------------------------------------*/
  93. void PickTitle( word lcItem, pkMode lcMode,
  94.                 pkItemType &lcType, char *lcIString,
  95.                 PickListPtr PickPtr )
  96.   {
  97.     int lcRC,
  98.         lcDone = 0,
  99.         lcCount = 0;
  100.  
  101.     lcRC = Error( PXSrchFld( glDiscTable, glDiscRecord, DR_DiscRecord[ DR_Artist ].fldHandle, SEARCHFIRST ) );
  102.     do
  103.       {      
  104.         lcCount++;
  105.         if ( ( lcItem == lcCount ) &&
  106.              ( lcRC == PXSUCCESS ) )
  107.           {
  108.             if ( lcRC == PXSUCCESS )
  109.               lcRC = Error( PXRecGet( glDiscTable, glDiscRecord ) );
  110.             if ( lcRC == PXSUCCESS )
  111.               lcRC = Error( PXGetAlpha( glDiscRecord, DR_DiscRecord[ DR_Title ].fldHandle, BUFSIZ, DR_DiscRecord[ DR_Title ].fldBuffer ) );
  112.             strcpy( lcIString, DR_DiscRecord[ DR_Title ].fldBuffer );
  113.             lcDone = 1;
  114.           }
  115.          if ( ( lcRC == PXSUCCESS ) &&
  116.               ( !lcDone ) )
  117.            lcRC = PXSrchFld( glDiscTable, glDiscRecord, DR_DiscRecord[ DR_Artist ].fldHandle, SEARCHNEXT );
  118.       }
  119.     while ( ( lcRC == PXSUCCESS ) &&
  120.             ( !lcDone ) );
  121.   }
  122.  
  123. /*--------------------------------------------------------------------------*/
  124. word disc_search( TABLEHANDLE lcDiscTable, RECORDHANDLE lcDiscRecord )
  125.   {
  126.     PickList lcPick;
  127.     int lcRC,
  128.         lcCount;
  129.     long lcLong;
  130.     word lcCmd = ccUser2;
  131.  
  132.     lcRC = Error( PXPutAlpha( lcDiscRecord, DR_DiscRecord[ DR_Artist ].fldHandle, DR_DiscRecord[ DR_Artist].fldBuffer ) );
  133.     if ( lcRC == PXSUCCESS )
  134.       lcRC = PXSrchFld( lcDiscTable, lcDiscRecord, DR_DiscRecord[ DR_Artist ].fldHandle, SEARCHFIRST );
  135.     if ( lcRC == PXSUCCESS )
  136.       {
  137.         lcCount = 0;
  138.         do
  139.           {
  140.             lcRC = PXSrchFld( lcDiscTable, lcDiscRecord, DR_DiscRecord[ DR_Artist ].fldHandle, SEARCHNEXT );
  141.             lcCount++;
  142.           }
  143.         while ( lcRC == PXSUCCESS );
  144.         glDiscTable = lcDiscTable;
  145.         glDiscRecord = lcDiscRecord;
  146.  
  147.         OPPickInit();
  148.         lcRC = lcPick.InitCustom ( 35, 10, 70, 20,
  149.                             EsColors,
  150.                             DefWindowOptions | wBordered,
  151.                             35,
  152.                             lcCount,
  153.                             PickTitle,
  154.                             PickVertical,
  155.                             SingleChoice );
  156.         lcPick.SetSearchMode(PickCharSearch);
  157.         lcPick.wFrame.AddShadow( shBR, shOverWrite);
  158.         lcPick.wFrame.AddHeader( DR_DiscRecord[ DR_Artist ].fldBuffer, heTL );
  159.         lcPick.Process();
  160.         lcPick.Erase();
  161.         //get selection
  162.         if ( lcPick.GetLastCommand() == ccSelect )
  163.           {
  164.             lcCmd = ccUser4;
  165.             lcRC = Error( PXGetLong( glDiscRecord, DR_DiscRecord[ DR_DiscID ].fldHandle, &lcLong ) );
  166.             sprintf( DR_DiscRecord[ DR_DiscID ].fldBuffer, "%ld", lcLong );
  167.           }
  168.         lcPick.Done();
  169.       }
  170.     else
  171.       {
  172.         lcWindow.wFastText( "CDMUSIC: Artist Search Failed", 20, 2 );
  173.       }
  174.     return lcCmd;
  175.   }
  176.  
  177. /*--------------------------------------------------------------------------*/
  178. word cd_scrn( TABLEHANDLE lcDiscTable, RECORDHANDLE lcDiscRecord )
  179. {
  180.   word Status;
  181.   EntryScreen ES;
  182.  
  183.   OPEntryInit();
  184.  
  185.   #if defined(UseMouse)
  186.   if (MouseInstalled) {
  187.       //activate mouse cursor
  188.       SoftMouseCursor(0x0000, (ColorMono(EsColors.MouseColor, EsColors.MouseMono) << 8)+
  189.                  MouseChar);
  190.       ShowMouse();
  191.       //enable mouse support
  192.       EntryCommands.cpOptionsOn(cpEnableMouse);
  193.     };
  194.   #endif
  195.  
  196.   //initialize entry screen
  197.   Status = cd_discscrn(ES, EsColors );
  198.   if (Status != 0) {
  199.     printf("Error initializing entry screen: %u\r\n", Status);
  200.     exit( 0 );
  201.     return Status;
  202.   };
  203.  
  204.   EntryCommands.AddCommand( ccUser0, 1, 0x3B00, 0 );
  205.   EntryCommands.AddCommand( ccUser1, 1, 0x3C00, 0 );
  206.   EntryCommands.AddCommand( ccUser2, 1, 0x3D00, 0 );
  207.  
  208.   do
  209.     {
  210.       ES.Process();
  211.       Status = ES.GetLastCommand();
  212.       if ( Status == ccUser2 )
  213.         {
  214.           Status = disc_search( lcDiscTable, lcDiscRecord );
  215.         }
  216.     }
  217.   while ( Status == ccUser2 );
  218.   ES.Erase();
  219.   #if defined(UseMouse)
  220.   HideMouse();
  221.   #endif
  222.   ES.Done();
  223.   return Status;
  224. };
  225.  
  226. //--------------------------------------------------------------------------
  227. int GetData( REQUIREDFIELDARRAY *lcFieldArray, RECORDHANDLE lcRecordHandle, int lcField )
  228.   {
  229.     long theDate;
  230.     int month, day, year;
  231.     double theValue;
  232.     short theShort;
  233.     int isBlank;
  234.     FIELDHANDLE lcFieldHandle;
  235.  
  236.     lcFieldHandle = lcFieldArray[ lcField ].fldHandle;
  237.  
  238.     /* if this field is blank, we want to return a blank string */
  239.     if ( !Error( PXFldBlank( lcRecordHandle, lcFieldHandle, &isBlank ) ) )
  240.       {
  241.         if ( isBlank )
  242.         {
  243.             lcFieldArray[ lcField ].fldBuffer[0] = '\0';
  244.             return PXSUCCESS;
  245.         }
  246.       }
  247.     else
  248.         return FAIL;
  249.  
  250.     //printf( " Get %d", lcFieldArray[ lcField ].fldHandle );
  251.     switch( lcFieldArray[ lcField ].fldType[0] )
  252.       {
  253.         case 'a':
  254.         case 'A':
  255.             if ( Error( PXGetAlpha( lcRecordHandle, lcFieldHandle, BUFSIZ, lcFieldArray[ lcField ].fldBuffer ) ) )
  256.         return FAIL;
  257.             break;
  258.         case 'd':
  259.         case 'D':
  260.         if ( !Error( PXGetDate( lcRecordHandle, lcFieldHandle, &theDate ) ) )
  261.             {
  262.                 PXDateDecode( theDate, &month, &day, &year );
  263.                 sprintf( lcFieldArray[ lcField ].fldBuffer, "%d/%d/%d", month, day, year );
  264.             }
  265.             else
  266.                 return FAIL;
  267.         break;
  268.         case 'n':
  269.         case 'N':
  270.             if ( !Error( PXGetDoub( lcRecordHandle, lcFieldHandle, &theValue ) ) )
  271.                 sprintf( lcFieldArray[ lcField ].fldBuffer, "%5.0lf", theValue );
  272.             else
  273.                 return FAIL;
  274.             break;
  275.         case '$':
  276.             if ( !Error( PXGetDoub( lcRecordHandle, lcFieldHandle, &theValue ) ) )
  277.                 sprintf( lcFieldArray[ lcField ].fldBuffer, "%4.2lf", theValue );
  278.             else
  279.                 return FAIL;
  280.             break;
  281.         case 's':
  282.         case 'S':
  283.             if ( !Error( PXGetShort( lcRecordHandle, lcFieldHandle, &theShort ) ) )
  284.                 sprintf( lcFieldArray[ lcField ].fldBuffer, "%d", theShort );
  285.             else
  286.                 return FAIL;
  287.             break;
  288.       }
  289.     return( PXSUCCESS );
  290.   }
  291.  
  292. /*--------------------------------------------------------------------------*/
  293. int PutData( REQUIREDFIELDARRAY *lcFieldArray,
  294.              RECORDHANDLE lcRecordHandle,
  295.          int lcField )
  296. {
  297.     long theDate;
  298.     int month, day, year;
  299.     double theValue;
  300.     short theShort;
  301.  
  302.     /* If the field is blank, put a blank into the record buffer. */
  303.     if ( strlen( lcFieldArray[ lcField ].fldBuffer ) == 0 )
  304.       {
  305.     if ( Error( PXPutBlank( lcRecordHandle, lcFieldArray[ lcField ].fldHandle ) ) != PXSUCCESS )
  306.           {
  307.         return FAIL;
  308.           }
  309.     else
  310.       {
  311.         return PXSUCCESS;
  312.           }
  313.       }
  314.  
  315.     //printf( " Put %d", lcFieldArray[ lcField ].fldHandle );
  316.     switch( lcFieldArray[ lcField ].fldType[0] )
  317.     {
  318.         case 'a':
  319.         case 'A':
  320.         if ( Error( PXPutAlpha( lcRecordHandle, lcFieldArray[ lcField ].fldHandle, lcFieldArray[ lcField ].fldBuffer ) ) )
  321.                 return FAIL;
  322.             break;
  323.  
  324.         case 'D':
  325.         case 'd':
  326.             sscanf( lcFieldArray[ lcField ].fldBuffer, "%d/%d/%d", &month, &day, &year );
  327.             if ( ( Error( PXDateEncode( month, day, year, &theDate ) ) ) ||
  328.                  ( Error( PXPutDate( lcRecordHandle, lcFieldArray[ lcField ].fldHandle, theDate ) ) ) )
  329.                 return FAIL;
  330.         break;
  331.  
  332.         case '$':
  333.         case 'N':
  334.         case 'n':
  335.             sscanf( lcFieldArray[ lcField ].fldBuffer, "%lf", &theValue );
  336.             if ( Error( PXPutDoub( lcRecordHandle, lcFieldArray[ lcField ].fldHandle, theValue ) ) )
  337.         return FAIL;
  338.             break;
  339.         case 'S':
  340.         case 's':
  341.             sscanf( lcFieldArray[ lcField ].fldBuffer, "%d", &theShort );
  342.             if ( Error( PXPutShort( lcRecordHandle, lcFieldArray[ lcField ].fldHandle, theShort ) ) )
  343.                 return FAIL;
  344.             break;
  345.     }
  346.  
  347.     return( PXSUCCESS );
  348. }
  349.  
  350. /*--------------------------------------------------------------------------*/
  351. int cdfilename( char *lcName )
  352.   {
  353.     DirList lcDir;
  354.     boolean lcDone;
  355.  
  356.     OPDirInit();
  357.  
  358.     if ( !lcDir.InitCustom( 25, 5, 55, 18,
  359.                             cdColors, DefWindowOptions | wBordered,
  360.                             ( long )coreleft, PickVertical, SingleFile ) )
  361.       {
  362.         return( 1 );
  363.       }
  364.  
  365.     lcDir.SetPadSize( 1, 1 );
  366.     lcDir.diOptionsOn( diOptimizeSize + diShowDrives );
  367.     lcDir.AddMaskHeader( TRUE, 1, 30, heTC );
  368.     lcDir.SetSortOrder( SortDirName );
  369.     lcDir.SetNameSizeTimeFormat( "<dir>", "Mm/dd/yy", "Hh:mmt" );
  370.     lcDir.SetMask( "*.*", dAnyFile );
  371.  
  372.     lcDone = FALSE;
  373.  
  374.     do
  375.       {
  376.         lcDir.Process();
  377.         switch( lcDir.GetLastCommand( ) )
  378.           {
  379.             case ccSelect :  {
  380.                                 lcDir.GetSelectedPath( *( PathStr* ) lcName );
  381.                                 lcDone = TRUE;
  382.                                 break;
  383.                              }
  384.             case ccError  :  {
  385.                                 Long2Str( lcDir.RawError( ), lcName );
  386.                                 break;
  387.                              }
  388.             case ccQuit   :  {
  389.                                 lcDone = TRUE;
  390.                              }
  391.           }
  392.       }
  393.     while( !lcDone );
  394.  
  395.     lcDir.Done();
  396.   }
  397.  
  398. /*--------------------------------------------------------------------------*/
  399. int process_loop( TABLEHANDLE lcDiscTable, TABLEHANDLE lcTrackTable,
  400.           RECORDHANDLE lcDiscRecord, RECORDHANDLE lcTrackRecord )
  401.   {
  402.     int lcRC,
  403.         lcMode = 0,
  404.         lcCount = 0,
  405.         lcRow = 1,
  406.         lcPos1,
  407.         lcPos2,
  408.         lcTrack,
  409.         lcField,
  410.         quitcd = 0;
  411.     char lcCat[80],
  412.     lcReturn[80],
  413.          lcStringIn[255];
  414.     FILE *AsciiIn;
  415.     struct date lcDate;
  416.  
  417.     getdate( &lcDate );
  418.     cdfilename( lcStringIn );
  419.     if ( ( AsciiIn = fopen( lcStringIn, "rt" ) ) == NULL )
  420.       {
  421.         return( 1 );
  422.       }
  423.  
  424.     while ( ( fscanf( AsciiIn, "%s", lcStringIn ) ) &&
  425.             ( !feof( AsciiIn ) ) &&
  426.             ( Pos( '[', lcStringIn ) == StBadPos ) );
  427.     if ( !feof( AsciiIn ) )
  428.       do
  429.         {
  430.           lcPos1 = Pos( '[', lcStringIn );
  431.           lcPos2 = Pos( ']', lcStringIn );
  432.           if ( ( lcPos1 != StBadPos ) &&
  433.                ( lcPos2 != StBadPos ) )
  434.             {
  435.               Copy( lcStringIn, ( lcPos1 + 1 ), ( lcPos2 - ( lcPos1 + 1 ) ), DR_DiscRecord[ DR_DiscID ].fldBuffer );
  436.               lcRC = PutData( DR_DiscRecord, lcDiscRecord, DR_DiscID );
  437.               if ( ( !fscanf( AsciiIn, "%s", lcStringIn ) ) ||
  438.                    ( feof( AsciiIn ) ) )
  439.                 {
  440.                   quitcd = 1;
  441.                 }
  442.               else
  443.                 {
  444.                   lcPos1 = PosStr( lcStringIn, "DiscTitle" );
  445.                   if ( lcPos1 == StBadPos )
  446.                     {
  447.                       quitcd = 1;
  448.                     }
  449.                   else
  450.                     {
  451.                       strcpy( lcReturn, "" );
  452.                       lcPos1 = Pos( '=', lcStringIn );
  453.                       lcPos2 = Pos( ':', lcStringIn );
  454.                       if ( lcPos2 == StBadPos )
  455.                         while ( lcPos2 == StBadPos )
  456.                           {
  457.                             Copy( lcStringIn, ( lcPos1 + 1 ), ( strlen( lcStringIn ) - ( lcPos1 + 1 ) ), lcCat );
  458.                             strcat( lcReturn, lcCat );
  459.                             strcat( lcReturn, " " );
  460.                             fscanf( AsciiIn, "%s", lcStringIn );
  461.                             lcPos2 = Pos( ':', lcStringIn );
  462.                             lcPos1 = -1;
  463.                           }
  464.                       Copy( lcStringIn, ( lcPos1 + 1 ), ( lcPos2 - ( lcPos1 + 1 ) ), lcCat );
  465.                       strcat( lcReturn, lcCat );
  466.                       strcpy( DR_DiscRecord[ DR_Artist ].fldBuffer, lcReturn );
  467.                       lcRC = PutData( DR_DiscRecord, lcDiscRecord, DR_Artist );
  468.                       strcpy( lcReturn, "" );
  469.                       while ( ( fscanf( AsciiIn, "%s", lcStringIn ) ) &&
  470.                               ( !feof( AsciiIn ) ) &&
  471.                               ( PosStr( "Track", lcStringIn ) == StBadPos ) )
  472.                         {
  473.                           strcat( lcReturn, lcStringIn );
  474.                           strcat( lcReturn, " " );
  475.                         }
  476.  
  477.                       lcTrack = 0;
  478.                       strcpy( DR_DiscRecord[ DR_Title ].fldBuffer, lcReturn );
  479.                       lcRC = PutData( DR_DiscRecord, lcDiscRecord, DR_Title );
  480.                       strcpy( lcReturn, "" );
  481.                       do
  482.                         {
  483.                           lcPos1 = Pos( '=', lcStringIn );
  484.                           if ( lcPos1 == StBadPos )
  485.                             {
  486.                               strcat( lcReturn, lcStringIn );
  487.                               strcat( lcReturn, " " );
  488.                             }
  489.                           else
  490.                             {
  491.                               if ( strlen( lcReturn ) > 0 )
  492.                                 {
  493.                                   strcpy( TR_TrackRecord[ TR_Title ].fldBuffer, lcReturn );
  494.                                   lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_Title );
  495.                                   strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, DR_DiscRecord[ DR_DiscID ].fldBuffer );
  496.                                   lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_DiscID );
  497.                                   lcTrack++;
  498.                                   sprintf( lcReturn, "%d", lcTrack );
  499.                                   strcpy( TR_TrackRecord[ TR_TrackID ].fldBuffer, lcReturn );
  500.                                   lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_TrackID );
  501.                                   lcRC = Error( PXRecAppend( lcTrackTable, lcTrackRecord ) );
  502.                                   lcRC = Error( PXSave( ) );
  503.                                 }
  504.                               Copy( lcStringIn, ( lcPos1 + 1 ), ( strlen( lcStringIn ) - ( lcPos1 + 1 ) ), lcReturn );
  505.                               strcat( lcReturn, " " );
  506.                             }
  507.                         }
  508.                       while ( ( fscanf( AsciiIn, "%s", lcStringIn ) ) &&
  509.                               ( !feof( AsciiIn ) ) &&
  510.                               ( PosStr( "DiscLength", lcStringIn ) == StBadPos ) );
  511.                       if ( strlen( lcReturn ) > 0 )
  512.                         {
  513.                           strcpy( TR_TrackRecord[ TR_Title ].fldBuffer, lcReturn );
  514.                           lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_Title );
  515.                           strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, DR_DiscRecord[ DR_DiscID ].fldBuffer );
  516.                           lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_DiscID );
  517.                           lcTrack++;
  518.                           sprintf( lcReturn, "%d", lcTrack );
  519.                           strcpy( TR_TrackRecord[ TR_TrackID ].fldBuffer, lcReturn );
  520.                           lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_TrackID );
  521.                           lcRC = Error( PXRecAppend( lcTrackTable, lcTrackRecord ) );
  522.                           lcRC = Error( PXSave( ) );
  523.                         }
  524.                       sprintf( lcReturn, "%d", lcTrack );
  525.                       strcpy( DR_DiscRecord[ DR_Tracks ].fldBuffer, lcReturn );
  526.                       lcRC = PutData( DR_DiscRecord, lcDiscRecord, DR_Tracks );
  527.  
  528.  
  529.                       lcPos1 = Pos( '=', lcStringIn );
  530.                       lcField = DR_Min;
  531.                       while ( Pos( ':', lcStringIn ) != StBadPos )
  532.                         {
  533.                           lcPos2 = Pos( ':', lcStringIn );
  534.                           Copy( lcStringIn, ( lcPos1 + 1 ), ( lcPos2 - ( lcPos1 + 1 ) ), lcReturn );
  535.                           strcpy( DR_DiscRecord[ lcField ].fldBuffer, lcReturn );
  536.                           lcRC = PutData( DR_DiscRecord, lcDiscRecord, lcField );
  537.                           Copy( lcStringIn, ( lcPos2 + 1 ), ( strlen( lcStringIn ) - ( lcPos2 + 1 ) ), lcStringIn );
  538.                           lcPos1 = -1;
  539.                           lcField++;
  540.                         }
  541.                       sprintf( DR_DiscRecord[ DR_Entry ].fldBuffer, "%d/%d/%d", lcDate.da_mon, lcDate.da_day, lcDate.da_year );
  542.                       lcRC = PutData( DR_DiscRecord, lcDiscRecord, DR_Entry );
  543.                       lcRC = Error( PXRecAppend( lcDiscTable, lcDiscRecord ) );
  544.                       lcRC = Error( PXSave( ) );
  545.                       //forget writing disc 100ths sec
  546.                       //strcpy( DR_DiscRecord[ lcField ].fldBuffer, lcStringIn );
  547.                       //lcRC = PutData( DR_DiscRecord, lcDiscRecord, lcField );
  548.  
  549.                       lcTrack = 1;
  550.                       sprintf( TR_TrackRecord[ TR_TrackID ].fldBuffer, "%d", lcTrack );
  551.                       lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_TrackID );
  552.                       lcRC = Error( PXSrchKey( lcTrackTable, lcTrackRecord, 2, SEARCHFIRST ) );
  553.                       lcRC = Error( PXRecGet( lcTrackTable, lcTrackRecord ) );
  554.                       while ( ( fscanf( AsciiIn, "%s", lcStringIn ) ) &&
  555.                               ( !feof( AsciiIn ) ) &&
  556.                               ( Pos( '[', lcStringIn ) == StBadPos ) )
  557.                         {
  558.                           lcField = TR_Min;
  559.                           lcPos1 = Pos( '=', lcStringIn );
  560.                           while ( Pos( ':', lcStringIn ) != StBadPos )
  561.                             {
  562.                               lcPos2 = Pos( ':', lcStringIn );
  563.                               Copy( lcStringIn, ( lcPos1 + 1 ), ( lcPos2 - ( lcPos1 + 1 ) ), lcReturn );
  564.                               strcpy( TR_TrackRecord[ lcField ].fldBuffer, lcReturn );
  565.                               lcRC = PutData( TR_TrackRecord, lcTrackRecord, lcField );
  566.                               lcField++;
  567.                               Copy( lcStringIn, ( lcPos2 + 1 ), ( strlen( lcStringIn ) - ( lcPos2 + 1 ) ), lcStringIn );
  568.                               lcPos1 = -1;
  569.                             }
  570.                           strcpy( TR_TrackRecord[ lcField ].fldBuffer, lcStringIn );
  571.                           lcRC = PutData( TR_TrackRecord, lcTrackRecord, lcField );
  572.                           lcRC = Error( PXRecUpdate( lcTrackTable, lcTrackRecord ) );
  573.                           lcRC = Error( PXSave( ) );
  574.                           lcTrack++;
  575.                           sprintf( TR_TrackRecord[ TR_TrackID ].fldBuffer, "%d", lcTrack );
  576.                           lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_TrackID );
  577.                           lcRC = Error( PXSrchKey( lcTrackTable, lcTrackRecord, 2, SEARCHFIRST ) );
  578.                           lcRC = Error( PXRecGet( lcTrackTable, lcTrackRecord ) );
  579.                         }
  580.                     }
  581.  
  582.                 }
  583.             }
  584.           else
  585.             {
  586.               quitcd = 1;
  587.             }
  588.         }
  589.       while ( !quitcd );
  590.  
  591.     fclose( AsciiIn );
  592.  
  593.     return(OKAY);
  594.   }
  595.  
  596. /*--------------------------------------------------------------------------*/
  597. int CheckTableStructure( TABLEHANDLE lcTableHandle, REQUIREDFIELDARRAY *lcFieldArray, int lcFields )
  598.   {
  599.     int rc,
  600.         iteration,
  601.     lcFieldCount,
  602.         iteration2;
  603.  
  604.     rc = PXSUCCESS;
  605.     lcFieldCount = 0;
  606.     rc = Error( PXRecNFlds( lcTableHandle, &lcFieldCount ) );
  607.     for ( iteration = 1; iteration <= lcFields; ++iteration )
  608.       {
  609.     iteration2 = 0;
  610.     while ( stricmp( lcFieldArray[iteration-1].fldName, fldNames[iteration2] ) != 0 &&
  611.         iteration2 <= lcFieldCount-1 )
  612.       iteration2++;
  613.     if ( stricmp( lcFieldArray[iteration-1].fldName, fldNames[iteration2]) == 0 )
  614.       {
  615.         if ( strncmp( lcFieldArray[iteration-1].fldType, fldTypes[iteration2], strlen( lcFieldArray[iteration-1].fldType ) ) == 0 )
  616.           {
  617.         lcFieldArray[iteration-1].fldHandle = iteration2 + 1;
  618.         lcFieldArray[iteration-1].fldBuffer = (char *) malloc( BUFSIZ );
  619.         rc = PXSUCCESS;
  620.           }
  621.         else
  622.           {
  623.         sprintf( lcString, "ERROR: Type mismatch (%s vs. %s) for Field #%d (%s)\n", fldTypes[iteration2],
  624.                                         lcFieldArray[iteration - 1].fldType,
  625.                                         iteration,
  626.                                         lcFieldArray[iteration-1].fldName);
  627.         lcWindow.wFastText( lcString, 24, 2 );
  628.         iteration = lcFields;
  629.         rc = PXERR_OUTOFRANGE;
  630.           }
  631.       }
  632.     else
  633.       {
  634.         sprintf( lcString, "ERROR: %d %s MISSING\n", iteration, lcFieldArray[iteration-1].fldName);
  635.         lcWindow.wFastText( lcString, 24, 2 );
  636.         iteration = lcFields;
  637.         rc = PXERR_OUTOFRANGE;
  638.       }
  639.       }
  640.  
  641.     return rc;
  642.   }
  643.  
  644. /*--------------------------------------------------------------------------*/
  645. int GetTableStructure( TABLEHANDLE lcTableHandle )
  646.   {
  647.     int rc;
  648.     FIELDHANDLE lcFieldHandle;
  649.     char fldName[ BUFSIZ ];
  650.     char fldType[ BUFSIZ ];
  651.     int lcFieldCount;
  652.  
  653.     lcFieldCount = 0;
  654.     rc = Error( PXRecNFlds(lcTableHandle, &lcFieldCount ) );
  655.     if ( rc == PXSUCCESS )
  656.       for ( lcFieldHandle = 1; lcFieldHandle <= lcFieldCount; ++lcFieldHandle )
  657.         {
  658.           rc = Error( PXFldName( lcTableHandle, lcFieldHandle, BUFSIZ, fldName ) );
  659.           if ( rc == PXSUCCESS )
  660.             rc = Error( PXFldType( lcTableHandle, lcFieldHandle, BUFSIZ, fldType ) );
  661.           if ( rc == PXSUCCESS )
  662.             {
  663.               /* printf( "%d\t", fldHandle ); */
  664.               fldNames[ lcFieldHandle-1 ] = strdup( fldName );
  665.               /* printf( "%s\t", fldNames[ fldHandle-1 ] ); */
  666.               fldTypes[ lcFieldHandle-1 ] = strdup( fldType );
  667.               /* printf( "%s\n", fldTypes[ fldHandle-1 ] ); */
  668.             }
  669.           else
  670.             lcFieldHandle = lcFieldCount + 1;
  671.     }
  672.  
  673.     return rc;
  674.   }
  675.  
  676. /*--------------------------------------------------------------------------*/
  677. int DeleteTableStructure( TABLEHANDLE lcTableHandle )
  678.   {
  679.     int rc;
  680.     FIELDHANDLE lcFieldHandle;
  681.     char fldName[ BUFSIZ ];
  682.     char fldType[ BUFSIZ ];
  683.     int lcFieldCount;
  684.  
  685.     lcFieldCount = 0;
  686.     rc = Error( PXRecNFlds(lcTableHandle, &lcFieldCount ) );
  687.     if ( rc == PXSUCCESS )
  688.       for ( lcFieldHandle = lcFieldCount; lcFieldHandle >= 1; --lcFieldHandle )
  689.         {
  690.       free( (void *)fldTypes[ lcFieldHandle - 1 ] );
  691.       free( (void *)fldNames[ lcFieldHandle - 1 ] );
  692.         }
  693.  
  694.     return rc;
  695.   }
  696.  
  697. /*--------------------------------------------------------------------------*/
  698. int MakeTable( TABLEHANDLE *lcTableHandle, REQUIREDFIELDARRAY *lcFieldArray,
  699.            char *lcTableName, RECORDHANDLE *lcRecordHandle, int lcFields )
  700.   {
  701.     FIELDHANDLE lcKeyHandles[ ] = { 1, 2, 3 };
  702.     int  iteration,
  703.      lcKeyFields,
  704.          lcRC;
  705.     char far*lcfldNames[ MAXFIELDS ];
  706.     char far*lcfldTypes[ MAXFIELDS ];
  707.  
  708.     CharStr( ' ', 40, lcString);
  709.     lcWindow.wFastText( lcString, 5, 20 );
  710.     sprintf( lcString, "Making %s", lcTableName );
  711.     lcWindow.wFastText( lcString, 5, 20 );
  712.     lcKeyFields = 0;
  713.     for ( iteration = 1; iteration <= lcFields; ++iteration )
  714.       {
  715.     if ( lcFieldArray[ iteration - 1 ].required == 3 )
  716.       {
  717.         lcKeyFields++;
  718.       }
  719.     lcfldNames[ iteration - 1 ] = strdup( lcFieldArray[ iteration - 1 ].fldName );
  720.     lcfldTypes[ iteration - 1 ] = strdup( lcFieldArray[ iteration - 1 ].fldType );
  721.       }
  722.  
  723.     lcRC = Error( PXTblCreate( lcTableName, lcFields, lcfldNames, lcfldTypes ) );
  724.     if ( lcRC == PXSUCCESS )
  725.       lcRC = Error( PXKeyAdd( lcTableName, lcKeyFields, lcKeyHandles, PRIMARY ) );
  726.     if ( lcRC == PXSUCCESS )
  727.       lcRC = Error( PXTblOpen( lcTableName, lcTableHandle, 0, 0 ) );
  728.     if ( lcRC == PXSUCCESS )
  729.       lcRC = Error( PXRecBufOpen( *lcTableHandle, lcRecordHandle ) );
  730.  
  731.     for ( iteration = 1; iteration <= lcFields; ++iteration )
  732.       {
  733.     free( (void *)lcfldNames[ iteration - 1 ] );
  734.     free( (void *)lcfldTypes[ iteration - 1 ] );
  735.     lcFieldArray[ iteration - 1 ].fldBuffer = (char *) malloc( BUFSIZ );
  736.       }
  737.  
  738.     return lcRC;
  739.   }
  740.  
  741. /*--------------------------------------------------------------------------*/
  742.   int process_main( void )
  743.     {
  744.       int exist,
  745.           lcrc;
  746.       RECORDHANDLE lcDiscRecord,
  747.                    lcTrackRecord;
  748.       TABLEHANDLE  lcDiscTable,
  749.            lcTrackTable;
  750.  
  751.       OPRawWindowInit();
  752.  
  753.       lcWindow.InitCustom( 2, 2, 79, 23, cdColors, wBordered + wClear );
  754.       lcWindow.wFrame.AddHeader( "CDMUSIC Status Window", heTC );
  755.       lcWindow.Draw();
  756.  
  757.       lcrc = Error( PXTblExist( "DISC", &exist ) );
  758.       if ( lcrc == PXSUCCESS )
  759.     {
  760.       if ( exist )
  761.         {
  762.           lcrc = Error( PXTblOpen( "DISC", &lcDiscTable, 0, 0 ) );
  763.           if ( lcrc == PXSUCCESS )
  764.         lcrc = Error( PXRecBufOpen( lcDiscTable, &lcDiscRecord ) );
  765.         }
  766.       else
  767.         {
  768.           lcrc = MakeTable( &lcDiscTable, DR_DiscRecord, "DISC", &lcDiscRecord, DR_LASTFIELD + 1 );
  769.         }
  770.     }
  771.       if ( lcrc == PXSUCCESS )
  772.     {
  773.       if ( lcrc == PXSUCCESS )
  774.         lcrc = GetTableStructure( lcDiscTable );
  775.       if ( lcrc == PXSUCCESS )
  776.         lcrc = CheckTableStructure( lcDiscTable, DR_DiscRecord, DR_LASTFIELD + 1 );
  777.       if ( lcrc == PXSUCCESS )
  778.         lcrc = DeleteTableStructure( lcDiscTable );
  779.     }
  780.  
  781.       if ( lcrc == PXSUCCESS )
  782.     lcrc = Error( PXTblExist( "TRACK", &exist ) );
  783.       if ( lcrc == PXSUCCESS )
  784.     {
  785.       if ( exist )
  786.         {
  787.           lcrc = Error( PXTblOpen( "TRACK", &lcTrackTable, 0, 0 ) );
  788.           if ( lcrc == PXSUCCESS )
  789.         lcrc = Error( PXRecBufOpen( lcTrackTable, &lcTrackRecord ) );
  790.         }
  791.       else
  792.         {
  793.           lcrc = MakeTable( &lcTrackTable, TR_TrackRecord, "TRACK", &lcTrackRecord, TR_LASTFIELD + 1 );
  794.         }
  795.     }
  796.       if ( lcrc == PXSUCCESS )
  797.     {
  798.       if ( lcrc == PXSUCCESS )
  799.         lcrc = GetTableStructure( lcTrackTable );
  800.       if ( lcrc == PXSUCCESS )
  801.         lcrc = CheckTableStructure( lcTrackTable, TR_TrackRecord, TR_LASTFIELD + 1 );
  802.       if ( lcrc == PXSUCCESS )
  803.         lcrc = DeleteTableStructure( lcTrackTable );
  804.     }
  805.  
  806.  
  807.       if ( lcrc == PXSUCCESS )
  808.     lcrc = process_loop( lcDiscTable, lcTrackTable, lcDiscRecord, lcTrackRecord );
  809.  
  810.       if ( lcrc == PXSUCCESS )
  811.     lcrc = Error( PXRecBufClose( lcTrackRecord ) );
  812.       if ( lcrc == PXSUCCESS )
  813.     lcrc = Error( PXRecBufClose( lcDiscRecord ) );
  814.       if ( lcrc == PXSUCCESS )
  815.     lcrc = Error( PXTblClose( lcTrackTable ) );
  816.       if ( lcrc == PXSUCCESS )
  817.     lcrc = Error( PXTblClose( lcDiscTable ) );
  818.  
  819.       lcWindow.wFrame.AddHeader( "Finished - Press any key", heBC );
  820.       lcWindow.wFrame.UpdateFrame();
  821.       ReadKeyWord();
  822.       lcWindow.Erase();
  823.       lcWindow.Done();
  824.  
  825.       return lcrc;
  826.     }
  827.  
  828. /*--------------------------------------------------------------------------*/
  829. main( void )
  830.   {
  831.     int rc;
  832.  
  833.     printf( "CDASCII.EXE: Imports CD music library database records from ASCII file v1.0\n" );
  834.     printf( "Uses Paradox v4.0 database format\n" );
  835.  
  836.     rc = ( Error ( PXInit( ) ) );
  837.     if (rc == PXSUCCESS)
  838.       {
  839.     return( process_main() );
  840.       }
  841.     else
  842.       {
  843.     printf( "CDASCII: %s\n", PXErrMsg( rc ) );
  844.       }
  845.   }
  846.